@nasti-toolchain/nasti 1.7.1 → 2.0.1

package/dist/cli.js

@@ -1,15 +1,168 @@
+var __create = Object.create;
 var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __glob = (map) => (path17) => {
+  var fn = map[path17];
+  if (fn) return fn();
+  throw new Error("Module not found in bundle: " + path17);
+};
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
+var __commonJS = (cb, mod) => function __require3() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/core/logger.ts
+var logger_exports = {};
+__export(logger_exports, {
+  LogLevels: () => LogLevels,
+  createLogger: () => createLogger,
+  printServerUrls: () => printServerUrls
+});
+import readline from "readline";
+import pc from "picocolors";
+function getTimeFormatter() {
+  return new Intl.DateTimeFormat(void 0, {
+    hour: "numeric",
+    minute: "numeric",
+    second: "numeric"
+  });
+}
+function createLogger(level = "info", options = {}) {
+  if (options.customLogger) {
+    return options.customLogger;
+  }
+  const timeFormatter = getTimeFormatter();
+  const loggedErrors = /* @__PURE__ */ new WeakSet();
+  const { prefix = "[nasti]", allowClearScreen = true, console: console_ = console } = options;
+  const thresh = LogLevels[level];
+  const canClearScreen = allowClearScreen && process.stdout.isTTY && !process.env.CI;
+  const clear = canClearScreen ? clearScreen : () => {
+  };
+  function format(type, msg, options2 = {}) {
+    if (options2.timestamp) {
+      const tag = type === "info" ? pc.cyan(pc.bold(prefix)) : type === "warn" ? pc.yellow(pc.bold(prefix)) : pc.red(pc.bold(prefix));
+      return `${pc.dim(timeFormatter.format(/* @__PURE__ */ new Date()))} ${tag} ${msg}`;
+    }
+    return msg;
+  }
+  function output(type, msg, options2 = {}) {
+    if (thresh < LogLevels[type]) return;
+    const method = type === "info" ? "log" : type;
+    if (options2.error) {
+      loggedErrors.add(options2.error);
+    }
+    if (canClearScreen) {
+      if (type === lastType && msg === lastMsg) {
+        sameCount++;
+        clear();
+        console_[method](format(type, msg, options2), pc.yellow(`(x${sameCount + 1})`));
+      } else {
+        sameCount = 0;
+        lastMsg = msg;
+        lastType = type;
+        if (options2.clear) clear();
+        console_[method](format(type, msg, options2));
+      }
+    } else {
+      console_[method](format(type, msg, options2));
+    }
+  }
+  const warnedMessages = /* @__PURE__ */ new Set();
+  const logger = {
+    hasWarned: false,
+    info(msg, opts) {
+      output("info", msg, opts);
+    },
+    warn(msg, opts) {
+      logger.hasWarned = true;
+      output("warn", msg, opts);
+    },
+    warnOnce(msg, opts) {
+      if (warnedMessages.has(msg)) return;
+      logger.hasWarned = true;
+      output("warn", msg, opts);
+      warnedMessages.add(msg);
+    },
+    error(msg, opts) {
+      output("error", msg, opts);
+    },
+    clearScreen(type) {
+      if (thresh >= LogLevels[type]) clear();
+    },
+    hasErrorLogged(error) {
+      return loggedErrors.has(error);
+    }
+  };
+  return logger;
+}
+function clearScreen() {
+  const repeatCount = process.stdout.rows - 2;
+  const blank = repeatCount > 0 ? "\n".repeat(repeatCount) : "";
+  console.log(blank);
+  readline.cursorTo(process.stdout, 0, 0);
+  readline.clearScreenDown(process.stdout);
+}
+function printServerUrls(urls, info) {
+  const colorUrl = (url) => pc.cyan(url.replace(/:(\d+)\//, (_, port) => `:${pc.bold(port)}/`));
+  for (const url of urls.local) {
+    info(`  ${pc.green("\u279C")}  ${pc.bold("Local")}:   ${colorUrl(url)}`);
+  }
+  for (const url of urls.network) {
+    info(`  ${pc.green("\u279C")}  ${pc.bold("Network")}: ${colorUrl(url)}`);
+  }
+  if (urls.network.length === 0) {
+    info(
+      pc.dim(`  ${pc.green("\u279C")}  ${pc.bold("Network")}: use `) + pc.bold("--host") + pc.dim(" to expose")
+    );
+  }
+}
+var LogLevels, lastType, lastMsg, sameCount;
+var init_logger = __esm({
+  "src/core/logger.ts"() {
+    "use strict";
+    LogLevels = {
+      silent: 0,
+      error: 1,
+      warn: 2,
+      info: 3
+    };
+    sameCount = 0;
+  }
+});
 
 // src/config/defaults.ts
-var defaultResolve, defaultServer, defaultBuild, defaultElectron, defaults;
+var defaultResolve, defaultServer, defaultBuild, defaultElectron, defaultExperimental, defaults;
 var init_defaults = __esm({
   "src/config/defaults.ts"() {
     "use strict";
@@ -36,7 +189,12 @@ var init_defaults = __esm({
       target: "es2022",
       rolldownOptions: {},
       emptyOutDir: true,
-      css: {}
+      css: {},
+      reportCompressedSize: true,
+      chunkSizeWarningLimit: 500,
+      cssCodeSplit: true,
+      // 默认跟随 build.minify（resolveConfig 中按 minify 取值填充）
+      cssMinify: true
     };
     defaultElectron = {
       main: "src/electron/main.ts",
@@ -51,6 +209,9 @@ var init_defaults = __esm({
       minVersion: 41,
       external: ["electron"]
     };
+    defaultExperimental = {
+      bundledDev: false
+    };
     defaults = {
       root: ".",
       base: "/",
@@ -63,7 +224,9 @@ var init_defaults = __esm({
       electron: defaultElectron,
       plugins: [],
       envPrefix: ["NASTI_", "VITE_"],
-      logLevel: "info"
+      logLevel: "info",
+      clearScreen: true,
+      experimental: defaultExperimental
     };
   }
 });
@@ -128,17 +291,28 @@ async function resolveConfig(inlineConfig = {}, command) {
     ...fileConfig.plugins ?? [],
     ...inlineConfig.plugins ?? []
   ];
-  const env = { mode: merged.mode ?? defaults.mode, command };
+  const mode = merged.mode ?? (command === "build" ? "production" : "development");
+  const env = { mode, command };
   for (const plugin of rawPlugins) {
     if (plugin.config) {
       const result = await plugin.config(merged, env);
       if (result) Object.assign(merged, result);
     }
   }
+  const logLevel = merged.logLevel ?? defaults.logLevel;
+  const clearScreen2 = merged.clearScreen ?? defaults.clearScreen;
+  const logger = createLogger(logLevel, {
+    allowClearScreen: clearScreen2,
+    customLogger: merged.customLogger
+  });
+  const mergedBuild = { ...defaults.build, ...merged.build };
+  if (merged.build?.cssMinify === void 0) {
+    mergedBuild.cssMinify = !!mergedBuild.minify;
+  }
   const resolved = {
     root,
     base: merged.base ?? defaults.base,
-    mode: command === "build" ? "production" : "development",
+    mode,
     target: merged.target ?? defaults.target,
     framework: merged.framework ?? defaults.framework,
     command,
@@ -151,11 +325,70 @@ async function resolveConfig(inlineConfig = {}, command) {
     },
     plugins: [],
     server: { ...defaults.server, ...merged.server },
-    build: { ...defaults.build, ...merged.build },
+    build: mergedBuild,
     electron: { ...defaults.electron, ...merged.electron },
     envPrefix: Array.isArray(merged.envPrefix) ? merged.envPrefix : merged.envPrefix ? [merged.envPrefix] : [...defaults.envPrefix],
-    logLevel: merged.logLevel ?? defaults.logLevel
+    logLevel,
+    clearScreen: clearScreen2,
+    logger,
+    environments: {},
+    experimental: {
+      bundledDev: merged.experimental?.bundledDev ?? defaults.experimental.bundledDev
+    }
+  };
+  const userEnvironments = {
+    client: {},
+    ssr: {},
+    ...merged.environments ?? {}
   };
+  for (const [name, envOptions] of Object.entries(userEnvironments)) {
+    for (const plugin of rawPlugins) {
+      if (plugin.configEnvironment) {
+        const result = await plugin.configEnvironment(name, envOptions, env);
+        if (result) Object.assign(envOptions, deepMerge(envOptions, result));
+      }
+    }
+  }
+  for (const [name, envOptions] of Object.entries(userEnvironments)) {
+    const consumer = envOptions.consumer ?? (name === "client" ? "client" : "server");
+    if (name === "client") {
+      if (envOptions.resolve) {
+        Object.assign(resolved.resolve, {
+          ...envOptions.resolve,
+          alias: { ...resolved.resolve.alias, ...envOptions.resolve.alias }
+        });
+      }
+      if (envOptions.build) Object.assign(resolved.build, envOptions.build);
+      resolved.environments.client = {
+        consumer,
+        entry: [],
+        // 同引用 —— 精确镜像（assertClientEnvironmentMirror 校验）
+        resolve: resolved.resolve,
+        build: resolved.build
+      };
+      continue;
+    }
+    resolved.environments[name] = {
+      consumer,
+      entry: (Array.isArray(envOptions.entry) ? envOptions.entry : envOptions.entry ? [envOptions.entry] : []).map((e) => path.resolve(root, e)),
+      resolve: {
+        alias: { ...resolved.resolve.alias, ...envOptions.resolve?.alias },
+        extensions: envOptions.resolve?.extensions ?? [...resolved.resolve.extensions],
+        // server consumer：node conditions（去 'browser'）；client 非默认环境沿用 top-level
+        conditions: envOptions.resolve?.conditions ?? (consumer === "server" ? ["node", ...resolved.resolve.conditions.filter((c) => c !== "browser")] : [...resolved.resolve.conditions]),
+        mainFields: envOptions.resolve?.mainFields ?? (consumer === "server" ? ["module", "main"] : [...resolved.resolve.mainFields])
+      },
+      build: {
+        ...resolved.build,
+        ...envOptions.build,
+        // 非 client 环境默认产出到 <outDir>/<envName>（如 dist/ssr），可显式覆盖
+        outDir: envOptions.build?.outDir ?? path.join(resolved.build.outDir, name),
+        // server 产物默认不压缩（可调试性优先，与 Vite SSR 默认一致），可显式覆盖
+        minify: envOptions.build?.minify ?? (consumer === "server" ? false : resolved.build.minify)
+      }
+    };
+  }
+  assertClientEnvironmentMirror(resolved);
   const filteredPlugins = rawPlugins.filter((p) => {
     if (!p.apply) return true;
     if (typeof p.apply === "function") return p.apply(resolved, env);
@@ -244,11 +477,40 @@ function hasDotNodeFile(dir, depth = 0) {
   }
   return false;
 }
+function assertClientEnvironmentMirror(config) {
+  if (process.env.NASTI_DISABLE_MIRROR_ASSERT) return;
+  const client = config.environments.client;
+  if (!client) {
+    throw new Error("[nasti] internal: environments.client missing after resolveConfig");
+  }
+  if (client.resolve === config.resolve && client.build === config.build) return;
+  const pairs = [
+    ["resolve", config.resolve, client.resolve],
+    ["build", config.build, client.build]
+  ];
+  for (const [field, top, env] of pairs) {
+    const a = JSON.stringify(top);
+    const b = JSON.stringify(env);
+    if (a !== b) {
+      throw new Error(
+        `[nasti] config mirror violation: top-level \`${field}\` and \`environments.client.${field}\` diverged.
+  top-level: ${a}
+  client:    ${b}
+top-level \u4E0E client \u73AF\u5883\u5FC5\u987B\u7CBE\u786E\u955C\u50CF \u2014\u2014 \u8BF7\u901A\u8FC7 top-level \u6216 environments.client \u4E4B\u4E00\u914D\u7F6E\uFF0C\u4E0D\u8981\u5728\u89E3\u6790\u540E\u5206\u522B\u4FEE\u6539\u4E24\u8005\u3002`
+      );
+    }
+  }
+}
+function isPlainObject(val) {
+  if (val === null || typeof val !== "object") return false;
+  const proto = Object.getPrototypeOf(val);
+  return proto === Object.prototype || proto === null;
+}
 function deepMerge(target, source) {
   const result = { ...target };
   for (const key of Object.keys(source)) {
     const val = source[key];
-    if (val && typeof val === "object" && !Array.isArray(val)) {
+    if (isPlainObject(val)) {
       result[key] = deepMerge(
         result[key] ?? {},
         val
@@ -264,6 +526,7 @@ var init_config = __esm({
   "src/config/index.ts"() {
     "use strict";
     init_defaults();
+    init_logger();
     CONFIG_FILES = [
       "nasti.config.ts",
       "nasti.config.js",
@@ -294,8 +557,11 @@ var init_plugin_container = __esm({
       config;
       ctx;
       emittedFiles = /* @__PURE__ */ new Map();
-      constructor(config) {
+      /** Environment API：容器所属环境（未传时为 undefined，行为同 1.x client） */
+      environment;
+      constructor(config, environment) {
         this.config = config;
+        this.environment = environment;
         this.plugins = sortPlugins(config.plugins);
         this.ctx = this.createContext();
       }
@@ -316,7 +582,8 @@ var init_plugin_container = __esm({
           },
           getModuleInfo(_id) {
             return null;
-          }
+          },
+          environment: container.environment
         };
       }
       /** 返回所有通过 emitFile() 输出的文件 */
@@ -338,13 +605,14 @@ var init_plugin_container = __esm({
         }
       }
       async resolveId(source, importer, options = {}) {
+        const ssr = this.environment?.consumer === "server";
         for (const plugin of this.plugins) {
           if (!plugin.resolveId) continue;
           const result = await plugin.resolveId.call(
             this.ctx,
             source,
             importer ?? void 0,
-            { isEntry: options.isEntry ?? false, ssr: false }
+            { isEntry: options.isEntry ?? false, ssr }
           );
           if (result != null) return result;
         }
@@ -518,6 +786,171 @@ var init_module_graph = __esm({
   }
 });
 
+// src/core/hot-channel.ts
+function createNoopHotChannel() {
+  return {
+    send() {
+    },
+    on() {
+    },
+    off() {
+    },
+    listen() {
+    },
+    close() {
+    },
+    setInvokeHandler() {
+    }
+  };
+}
+function createWsHotChannel(ws) {
+  const listeners = /* @__PURE__ */ new Map();
+  let invokeHandlers;
+  return {
+    send(payload) {
+      ws.send(payload);
+    },
+    on(event, listener) {
+      let set = listeners.get(event);
+      if (!set) listeners.set(event, set = /* @__PURE__ */ new Set());
+      set.add(listener);
+    },
+    off(event, listener) {
+      listeners.get(event)?.delete(listener);
+    },
+    listen() {
+    },
+    close() {
+      ws.close();
+    },
+    setInvokeHandler(handlers) {
+      invokeHandlers = handlers;
+      void invokeHandlers;
+    }
+  };
+}
+var init_hot_channel = __esm({
+  "src/core/hot-channel.ts"() {
+    "use strict";
+  }
+});
+
+// src/core/debug.ts
+import pc2 from "picocolors";
+function createDebugger(namespace, options = {}) {
+  if (!DEBUG) return void 0;
+  const patterns = DEBUG.split(",").map((p) => p.trim());
+  const enabled = patterns.some((p) => {
+    if (p === "*" || p === "nasti:*" || p === "vite:*") return true;
+    const normalized = p.startsWith("vite:") ? `nasti:${p.slice(5)}` : p;
+    return normalized === namespace;
+  });
+  if (!enabled) return void 0;
+  if (options.onlyWhenFocused) {
+    const focus = typeof options.onlyWhenFocused === "string" ? options.onlyWhenFocused : namespace;
+    if (!patterns.includes(focus)) return void 0;
+  }
+  let lastTime = performance.now();
+  return (...args) => {
+    const now = performance.now();
+    const elapsed = now - lastTime;
+    lastTime = now;
+    const msg = args.map((a) => {
+      if (typeof a === "string") return a;
+      try {
+        return JSON.stringify(a);
+      } catch {
+        return String(a);
+      }
+    }).join(" ");
+    if (filter && !msg.includes(filter)) return;
+    console.debug(
+      `${pc2.magenta(namespace)} ${msg} ${pc2.dim(`+${Math.round(elapsed)}ms`)}`
+    );
+  };
+}
+var DEBUG, filter;
+var init_debug = __esm({
+  "src/core/debug.ts"() {
+    "use strict";
+    DEBUG = process.env.DEBUG;
+    filter = process.env.NASTI_DEBUG_FILTER || process.env.VITE_DEBUG_FILTER;
+  }
+});
+
+// src/core/environment.ts
+function resolveEnvironmentPlugins(environment, plugins) {
+  return plugins.filter((p) => {
+    if (!p.applyToEnvironment) return true;
+    try {
+      return p.applyToEnvironment(environment);
+    } catch (err) {
+      environment.config.logger.error(
+        `[nasti] plugin "${p.name}" applyToEnvironment threw: ${err.message}`,
+        { error: err }
+      );
+      return false;
+    }
+  });
+}
+var debug, NastiEnvironment;
+var init_environment = __esm({
+  "src/core/environment.ts"() {
+    "use strict";
+    init_plugin_container();
+    init_module_graph();
+    init_hot_channel();
+    init_debug();
+    debug = createDebugger("nasti:environment");
+    NastiEnvironment = class {
+      name;
+      consumer;
+      mode;
+      config;
+      options;
+      hot;
+      /** applyToEnvironment 过滤后的插件（init() 后可用） */
+      plugins = [];
+      /** per-env 插件容器（init() 后可用；dev 管线使用） */
+      pluginContainer = null;
+      /** per-env 模块图（dev 管线使用） */
+      moduleGraph;
+      candidatePlugins;
+      initialized = false;
+      constructor(name, config, init = {}) {
+        const options = config.environments[name];
+        if (!options) {
+          throw new Error(
+            `[nasti] unknown environment "${name}" \u2014 declare it in config.environments`
+          );
+        }
+        this.name = name;
+        this.consumer = options.consumer;
+        this.mode = init.mode ?? (config.command === "build" ? "build" : "dev");
+        this.config = config;
+        this.options = options;
+        this.hot = init.hot ?? createNoopHotChannel();
+        this.moduleGraph = new ModuleGraph();
+        this.candidatePlugins = init.plugins ?? config.plugins;
+      }
+      /** 过滤插件并建 per-env PluginContainer */
+      async init() {
+        if (this.initialized) return;
+        this.initialized = true;
+        this.plugins = resolveEnvironmentPlugins(this, this.candidatePlugins);
+        this.pluginContainer = new PluginContainer(
+          { ...this.config, plugins: this.plugins },
+          this
+        );
+        debug?.(`env "${this.name}" initialized (${this.plugins.length} plugins)`);
+      }
+      async close() {
+        await this.hot.close?.();
+      }
+    };
+  }
+});
+
 // src/server/ws.ts
 import { WebSocketServer as WsServer } from "ws";
 function createWebSocketServer(server) {
@@ -718,7 +1151,7 @@ function loadEnv(mode, root, prefixes) {
   }
   return filtered;
 }
-function buildEnvDefine(env, mode) {
+function buildEnvDefine(env, mode, overrides = {}) {
   const define = {};
   for (const [key, value] of Object.entries(env)) {
     define[`import.meta.env.${key}`] = JSON.stringify(value);
@@ -727,7 +1160,10 @@ function buildEnvDefine(env, 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;
+  return { ...define, ...overrides };
+}
+function ssrDefineOverrides(consumer) {
+  return { "import.meta.env.SSR": consumer === "server" ? "true" : "false" };
 }
 function replaceEnvInCode(code, define) {
   let result = code;
@@ -747,6 +1183,7 @@ var init_env = __esm({
 var middleware_exports = {};
 __export(middleware_exports, {
   REACT_REFRESH_GLOBAL_PREAMBLE: () => REACT_REFRESH_GLOBAL_PREAMBLE,
+  getReactRefreshRuntimeEsm: () => getReactRefreshRuntimeEsm,
   transformMiddleware: () => transformMiddleware,
   transformRequest: () => transformRequest
 });
@@ -754,11 +1191,12 @@ import path4 from "path";
 import fs4 from "fs";
 import { createRequire } from "module";
 import { fileURLToPath, pathToFileURL as pathToFileURL2 } from "url";
+import pc3 from "picocolors";
 function getReactRefreshRuntimeEsm() {
   if (__refreshRuntimeCache) return __refreshRuntimeCache;
   let cjsPath;
   try {
-    const pkgPath = __require.resolve("react-refresh/package.json");
+    const pkgPath = __require2.resolve("react-refresh/package.json");
     cjsPath = path4.join(path4.dirname(pkgPath), "cjs", "react-refresh-runtime.development.js");
   } catch (err) {
     cjsPath = path4.resolve(__dirname_esm, "../../node_modules/react-refresh/cjs/react-refresh-runtime.development.js");
@@ -889,7 +1327,11 @@ function transformMiddleware(ctx) {
           return;
         }
       } catch (err) {
-        console.error(`[nasti] Transform error: ${url}`, err.message);
+        ctx.config.logger.error(
+          pc3.red(`Transform error: ${url}
+`) + (err.stack ?? err.message),
+          { timestamp: true, error: err }
+        );
         res.statusCode = 500;
         res.end(`Transform error: ${err.message}`);
         return;
@@ -908,6 +1350,28 @@ async function transformRequest(url, ctx) {
   if (cleanReqUrl === "/@react-refresh") {
     return { code: getReactRefreshRuntimeEsm() };
   }
+  if (cleanReqUrl.startsWith("/@modules/") && url.includes("?")) {
+    const idParam = new URLSearchParams(url.slice(url.indexOf("?") + 1)).get("id");
+    let realId = null;
+    let realIdValid = false;
+    try {
+      if (idParam) {
+        realId = fs4.realpathSync(idParam);
+        realIdValid = fs4.statSync(realId).isFile() && (realId.includes(`${path4.sep}node_modules${path4.sep}`) || isUnderRoot(realId, config.root));
+      }
+    } catch {
+      realId = null;
+      realIdValid = false;
+    }
+    if (realId && realIdValid) {
+      const mod2 = await moduleGraph.ensureEntryFromUrl(url);
+      moduleGraph.registerModule(mod2, realId);
+      const code2 = await bundlePackageAsEsm(realId, config.root);
+      const transformResult2 = { code: code2 };
+      mod2.transformResult = transformResult2;
+      return transformResult2;
+    }
+  }
   if (cleanReqUrl.startsWith("/@modules/")) {
     const spec = cleanReqUrl.slice("/@modules/".length);
     const virtual = await loadVirtualModule(spec, ctx);
@@ -918,12 +1382,34 @@ async function transformRequest(url, ctx) {
       return virtual.result;
     }
   }
+  const rawQuery = url.includes("?") ? url.slice(url.indexOf("?") + 1) : "";
+  if (rawQuery && !/^t=\d+$/.test(rawQuery)) {
+    const loaded = await pluginContainer.load(url);
+    if (loaded != null) {
+      let code2 = typeof loaded === "string" ? loaded : loaded.code;
+      const transformed = await pluginContainer.transform(code2, url);
+      if (transformed != null) {
+        code2 = typeof transformed === "string" ? transformed : transformed.code;
+      }
+      const mod2 = await moduleGraph.ensureEntryFromUrl(url);
+      moduleGraph.registerModule(mod2, cleanReqUrl);
+      code2 = injectImportMetaHot(code2, url);
+      code2 = replaceEnvInCode(code2, ctx.envDefine ?? buildEnvDefine(
+        loadEnv(config.mode, config.root, config.envPrefix),
+        config.mode
+      ));
+      code2 = rewriteImports(code2, config, cleanReqUrl);
+      const transformResult2 = { code: code2 };
+      mod2.transformResult = transformResult2;
+      return transformResult2;
+    }
+  }
   const filePath = resolveUrlToFile(url, config.root);
   if (!filePath || !fs4.existsSync(filePath)) return null;
   const mod = await moduleGraph.ensureEntryFromUrl(url);
   moduleGraph.registerModule(mod, filePath);
   if (cleanReqUrl.startsWith("/@modules/")) {
-    const code2 = await bundlePackageAsEsm(filePath);
+    const code2 = await bundlePackageAsEsm(filePath, config.root);
     const transformResult2 = { code: code2 };
     mod.transformResult = transformResult2;
     return transformResult2;
@@ -986,17 +1472,17 @@ async function loadVirtualModule(spec, ctx) {
   code = rewriteImports(code, config, anchor);
   return { id: resolvedId, result: { code } };
 }
-async function bundlePackageAsEsm(entryFile) {
+async function bundlePackageAsEsm(entryFile, root) {
   if (!esmBundleCache.has(entryFile)) {
-    esmBundleCache.set(entryFile, doBundlePackage(entryFile));
+    esmBundleCache.set(entryFile, doBundlePackage(entryFile, root));
   }
   return esmBundleCache.get(entryFile);
 }
-async function doBundlePackage(entryFile) {
-  const shim = await tryGenerateSubpathShim(entryFile);
+async function doBundlePackage(entryFile, root) {
+  const shim = await tryGenerateSubpathShim(entryFile, root);
   if (shim != null) return shim;
   const { rolldown: rolldown4 } = await import("rolldown");
-  const bundle = await rolldown4({
+  const bundle2 = await rolldown4({
     input: entryFile,
     // 仅将其他 npm 包外部化；相对路径（包内部文件）全部内联打包
     external: (id) => {
@@ -1004,27 +1490,28 @@ async function doBundlePackage(entryFile) {
       return true;
     }
   });
-  const result = await bundle.generate({ format: "esm", exports: "named" });
-  await bundle.close();
+  const result = await bundle2.generate({ format: "esm", exports: "named" });
+  await bundle2.close();
   let code = result.output[0].code;
   code = code.replace(/process\.env\.NODE_ENV/g, '"development"');
+  const externalBaseDir = path4.dirname(entryFile);
   code = code.replace(
     /^(import\b[^;'"]*?\bfrom\s+)(['"])([^'"./][^'"]*)(\2)/gm,
-    (_, prefix, q, spec) => `${prefix}${q}/@modules/${spec}${q}`
+    (_, prefix, q, spec) => `${prefix}${q}${externalSpecToModuleUrl(spec, externalBaseDir)}${q}`
   ).replace(
     /^(export\b[^;'"]*?\bfrom\s+)(['"])([^'"./][^'"]*)(\2)/gm,
-    (_, prefix, q, spec) => `${prefix}${q}/@modules/${spec}${q}`
+    (_, prefix, q, spec) => `${prefix}${q}${externalSpecToModuleUrl(spec, externalBaseDir)}${q}`
   ).replace(
     /^(import\s+)(['"])([^'"./][^'"]*)(\2)/gm,
-    (_, prefix, q, spec) => `${prefix}${q}/@modules/${spec}${q}`
+    (_, prefix, q, spec) => `${prefix}${q}${externalSpecToModuleUrl(spec, externalBaseDir)}${q}`
   );
-  code = rewriteExternalRequires(code);
+  code = rewriteExternalRequires(code, externalBaseDir);
   if (code.includes("__commonJSMin")) {
     code = await injectCjsNamedExports(code, entryFile);
   }
   return code;
 }
-async function tryGenerateSubpathShim(entryFile) {
+async function tryGenerateSubpathShim(entryFile, root) {
   const NM = `${path4.sep}node_modules${path4.sep}`;
   if (!entryFile.includes(NM)) return null;
   let pkgDir = null;
@@ -1075,9 +1562,11 @@ async function tryGenerateSubpathShim(entryFile) {
     if (!("default" in mainNs)) return null;
     if (mainNs["default"] !== subNs["default"]) return null;
   }
+  const rootMain = resolveNodeModule(root, pkgName);
+  const mainEntryUrl = rootMain && rootMain.startsWith(pkgDir + path4.sep) ? `/@modules/${pkgName}` : `/@modules/${pkgName}?id=${encodeURIComponent(mainEntry)}`;
   const lines = [
     `// Nasti subpath shim \u2192 ${pkgName} (avoid duplicate bundling)`,
-    `import * as __pkg from "/@modules/${pkgName}";`
+    `import * as __pkg from "${mainEntryUrl}";`
   ];
   for (const k of subKeys) {
     lines.push(`export const ${k} = __pkg[${JSON.stringify(k)}];`);
@@ -1121,7 +1610,7 @@ function pickMainEntryByExtension(pkgDir, preferredExt) {
   }
   return null;
 }
-function rewriteExternalRequires(code) {
+function rewriteExternalRequires(code, baseDir) {
   const pkgs = /* @__PURE__ */ new Set();
   const re = /__require\(["']([^"']+)["']\)/g;
   let m;
@@ -1133,7 +1622,7 @@ function rewriteExternalRequires(code) {
   const imports = [];
   for (const pkg of pkgs) {
     const safe = pkg.replace(/[^a-zA-Z0-9_$]/g, "_");
-    imports.push(`import * as __ns_${safe} from "/@modules/${pkg}";`);
+    imports.push(`import * as __ns_${safe} from "${externalSpecToModuleUrl(pkg, baseDir)}";`);
     imports.push(`var __req_${safe} = "default" in __ns_${safe} ? __ns_${safe}["default"] : __ns_${safe};`);
     result = result.replaceAll(`__require("${pkg}")`, `__req_${safe}`);
     result = result.replaceAll(`__require('${pkg}')`, `__req_${safe}`);
@@ -1142,8 +1631,8 @@ function rewriteExternalRequires(code) {
 }
 async function injectCjsNamedExports(code, entryFile) {
   try {
-    const { createRequire: createRequire5 } = await import("module");
-    const req = createRequire5(entryFile);
+    const { createRequire: createRequire6 } = await import("module");
+    const req = createRequire6(entryFile);
     const cjsExports = req(entryFile);
     if (!cjsExports || typeof cjsExports !== "object" && typeof cjsExports !== "function" || Array.isArray(cjsExports)) return code;
     const namedKeys = Object.keys(cjsExports).filter(
@@ -1230,7 +1719,20 @@ function isUnderRoot(abs, root) {
   const rel = path4.relative(root, abs);
   return !!rel && !rel.startsWith("..") && !path4.isAbsolute(rel);
 }
-function resolveNodeModule(root, moduleName) {
+function externalSpecToModuleUrl(spec, baseDir) {
+  const resolved = resolveNodeModule(baseDir, spec);
+  return resolved ? `/@modules/${spec}?id=${encodeURIComponent(resolved)}` : `/@modules/${spec}`;
+}
+function resolveNodeModule(baseDir, moduleName) {
+  const resolved = resolveNodeModuleEntry(baseDir, moduleName);
+  if (!resolved) return null;
+  try {
+    return fs4.realpathSync(resolved);
+  } catch {
+    return resolved;
+  }
+}
+function resolveNodeModuleEntry(root, moduleName) {
   let pkgName;
   let subpath;
   if (moduleName.startsWith("@")) {
@@ -1300,7 +1802,12 @@ function resolvePackageExports(exports, key, pkgDir) {
     return key === "." ? path4.join(pkgDir, exports) : null;
   }
   const entry = exports[key];
-  if (entry === void 0) return null;
+  if (entry === void 0) {
+    if (key === "." && typeof exports === "object" && !Object.keys(exports).some((k) => k.startsWith("."))) {
+      return resolveExportValue(exports, pkgDir);
+    }
+    return null;
+  }
   return resolveExportValue(entry, pkgDir);
 }
 function resolveExportValue(value, pkgDir) {
@@ -1477,7 +1984,7 @@ export function createHotContext(ownerPath) {
 }
 `;
 }
-var __dirname_esm, __require, __refreshRuntimeCache, REACT_REFRESH_GLOBAL_PREAMBLE, esmBundleCache, VALID_IDENT, RESOLVE_EXTENSIONS, ESM_CONDITIONS;
+var __dirname_esm, __require2, __refreshRuntimeCache, REACT_REFRESH_GLOBAL_PREAMBLE, esmBundleCache, VALID_IDENT, RESOLVE_EXTENSIONS, ESM_CONDITIONS;
 var init_middleware = __esm({
   "src/server/middleware.ts"() {
     "use strict";
@@ -1485,7 +1992,7 @@ var init_middleware = __esm({
     init_html();
     init_env();
     __dirname_esm = path4.dirname(fileURLToPath(import.meta.url));
-    __require = createRequire(import.meta.url);
+    __require2 = createRequire(import.meta.url);
     __refreshRuntimeCache = null;
     REACT_REFRESH_GLOBAL_PREAMBLE = `
 import RefreshRuntime from "/@react-refresh";
@@ -1504,9 +2011,12 @@ window.__vite_plugin_react_preamble_installed__ = true;
 // src/server/hmr.ts
 import path5 from "path";
 import fs5 from "fs";
+import pc4 from "picocolors";
 async function handleFileChange(file, server) {
   const { moduleGraph, ws, config } = server;
+  const logger = config.logger;
   const relativePath = "/" + path5.relative(config.root, file);
+  const shortFile = path5.relative(config.root, file);
   const mods = moduleGraph.getModulesByFile(file);
   if (!mods || mods.size === 0) {
     return;
@@ -1534,6 +2044,7 @@ async function handleFileChange(file, server) {
     for (const affected of affectedModules) {
       const boundaries = moduleGraph.getHmrBoundaries(affected);
       if (boundaries.length === 0) {
+        logger.info(pc4.green("page reload ") + pc4.dim(shortFile), { timestamp: true });
         ws.send({ type: "full-reload", path: relativePath });
         return;
       }
@@ -1548,6 +2059,10 @@ async function handleFileChange(file, server) {
     }
   }
   if (updates.length > 0) {
+    logger.info(
+      updates.map((u) => pc4.green("hmr update ") + pc4.dim(u.path)).join("\n"),
+      { timestamp: true }
+    );
     ws.send({ type: "update", updates });
   }
 }
@@ -1662,396 +2177,2469 @@ var init_resolve = __esm({
   }
 });
 
-// src/plugins/tailwind.ts
-import path7 from "path";
-import { createRequire as createRequire3 } from "module";
-import { pathToFileURL as pathToFileURL3 } from "url";
-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 = createRequire3(path7.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(pathToFileURL3(nodePath).href);
-  const oxide = await import(pathToFileURL3(oxidePath).href);
-  cached = { node, oxide };
-  cachedRoot = projectRoot;
-  return cached;
-}
-async function compileTailwind(css, fromFile, projectRoot) {
-  const { node, oxide } = await loadTailwind(projectRoot);
-  const dependencies = [];
-  const compiler2 = await node.compile(css, {
-    base: path7.dirname(fromFile),
-    from: fromFile,
-    onDependency: (p) => dependencies.push(p)
-  });
-  const scanner = new oxide.Scanner({ sources: compiler2.sources });
-  const candidates = scanner.scan();
-  return {
-    css: compiler2.build(candidates),
-    dependencies: [...dependencies, ...scanner.files]
-  };
-}
-var TAILWIND_DIRECTIVE_RE, cached, cachedRoot;
-var init_tailwind = __esm({
-  "src/plugins/tailwind.ts"() {
-    "use strict";
-    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;
+// require("../lightningcss.*.node") in node_modules/lightningcss/node/index.js
+var globRequire_lightningcss_node;
+var init_ = __esm({
+  'require("../lightningcss.*.node") in node_modules/lightningcss/node/index.js'() {
+    globRequire_lightningcss_node = __glob({});
   }
 });
 
-// src/plugins/css.ts
-import path8 from "path";
-function cssPlugin(config) {
-  return {
-    name: "nasti:css",
-    resolveId(source) {
-      if (source.endsWith(".css")) return null;
-      return null;
-    },
-    async transform(code, id) {
-      if (!id.endsWith(".css")) return null;
-      let cssSource = code;
-      if (hasTailwindDirectives(code)) {
-        const compiled = await compileTailwind(code, id, config.root);
-        cssSource = compiled.css;
+// node_modules/detect-libc/lib/process.js
+var require_process = __commonJS({
+  "node_modules/detect-libc/lib/process.js"(exports, module) {
+    "use strict";
+    var isLinux = () => process.platform === "linux";
+    var report = null;
+    var getReport = () => {
+      if (!report) {
+        if (isLinux() && process.report) {
+          const orig = process.report.excludeNetwork;
+          process.report.excludeNetwork = true;
+          report = process.report.getReport();
+          process.report.excludeNetwork = orig;
+        } else {
+          report = {};
+        }
       }
-      const rewritten = rewriteCssUrls(cssSource, id, config.root);
-      const escaped = JSON.stringify(rewritten);
-      if (config.command === "serve") {
-        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', __nasti_css_id__);
-style.textContent = css;
-document.head.appendChild(style);
+      return report;
+    };
+    module.exports = { isLinux, getReport };
+  }
+});
 
-// HMR
-if (import.meta.hot) {
-  import.meta.hot.accept();
-  import.meta.hot.prune(() => {
-    style.remove();
-  });
-}
+// node_modules/detect-libc/lib/filesystem.js
+var require_filesystem = __commonJS({
+  "node_modules/detect-libc/lib/filesystem.js"(exports, module) {
+    "use strict";
+    var fs12 = __require("fs");
+    var LDD_PATH = "/usr/bin/ldd";
+    var SELF_PATH = "/proc/self/exe";
+    var MAX_LENGTH = 2048;
+    var readFileSync = (path17) => {
+      const fd = fs12.openSync(path17, "r");
+      const buffer = Buffer.alloc(MAX_LENGTH);
+      const bytesRead = fs12.readSync(fd, buffer, 0, MAX_LENGTH, 0);
+      fs12.close(fd, () => {
+      });
+      return buffer.subarray(0, bytesRead);
+    };
+    var readFile = (path17) => new Promise((resolve, reject) => {
+      fs12.open(path17, "r", (err, fd) => {
+        if (err) {
+          reject(err);
+        } else {
+          const buffer = Buffer.alloc(MAX_LENGTH);
+          fs12.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
+            resolve(buffer.subarray(0, bytesRead));
+            fs12.close(fd, () => {
+            });
+          });
+        }
+      });
+    });
+    module.exports = {
+      LDD_PATH,
+      SELF_PATH,
+      readFileSync,
+      readFile
+    };
+  }
+});
 
-export default css;
-`
-        };
+// node_modules/detect-libc/lib/elf.js
+var require_elf = __commonJS({
+  "node_modules/detect-libc/lib/elf.js"(exports, module) {
+    "use strict";
+    var interpreterPath = (elf) => {
+      if (elf.length < 64) {
+        return null;
       }
-      const cssConfig = config.build.css || {};
-      const nonce = cssConfig.nonce;
-      const emitCssFile = cssConfig.emitCssFile;
-      if (emitCssFile) {
-        const fileName = `assets/${path8.basename(id, ".css")}.css`;
-        this.emitFile({
-          type: "asset",
-          fileName,
-          source: rewritten
-        });
-        return {
-          code: `
-const link = document.createElement('link');
-link.rel = 'stylesheet';
-link.href = ${JSON.stringify("/" + fileName)};
-document.head.appendChild(link);
-
-export default ${escaped};
-`,
+      if (elf.readUInt32BE(0) !== 2135247942) {
+        return null;
+      }
+      if (elf.readUInt8(4) !== 2) {
+        return null;
+      }
+      if (elf.readUInt8(5) !== 1) {
+        return null;
+      }
+      const offset = elf.readUInt32LE(32);
+      const size = elf.readUInt16LE(54);
+      const count = elf.readUInt16LE(56);
+      for (let i = 0; i < count; i++) {
+        const headerOffset = offset + i * size;
+        const type = elf.readUInt32LE(headerOffset);
+        if (type === 3) {
+          const fileOffset = elf.readUInt32LE(headerOffset + 8);
+          const fileSize = elf.readUInt32LE(headerOffset + 32);
+          return elf.subarray(fileOffset, fileOffset + fileSize).toString().replace(/\0.*$/g, "");
+        }
+      }
+      return null;
+    };
+    module.exports = {
+      interpreterPath
+    };
+  }
+});
+
+// node_modules/detect-libc/lib/detect-libc.js
+var require_detect_libc = __commonJS({
+  "node_modules/detect-libc/lib/detect-libc.js"(exports, module) {
+    "use strict";
+    var childProcess = __require("child_process");
+    var { isLinux, getReport } = require_process();
+    var { LDD_PATH, SELF_PATH, readFile, readFileSync } = require_filesystem();
+    var { interpreterPath } = require_elf();
+    var cachedFamilyInterpreter;
+    var cachedFamilyFilesystem;
+    var cachedVersionFilesystem;
+    var command = "getconf GNU_LIBC_VERSION 2>&1 || true; ldd --version 2>&1 || true";
+    var commandOut = "";
+    var safeCommand = () => {
+      if (!commandOut) {
+        return new Promise((resolve) => {
+          childProcess.exec(command, (err, out) => {
+            commandOut = err ? " " : out;
+            resolve(commandOut);
+          });
+        });
+      }
+      return commandOut;
+    };
+    var safeCommandSync = () => {
+      if (!commandOut) {
+        try {
+          commandOut = childProcess.execSync(command, { encoding: "utf8" });
+        } catch (_err) {
+          commandOut = " ";
+        }
+      }
+      return commandOut;
+    };
+    var GLIBC = "glibc";
+    var RE_GLIBC_VERSION = /LIBC[a-z0-9 \-).]*?(\d+\.\d+)/i;
+    var MUSL = "musl";
+    var isFileMusl = (f) => f.includes("libc.musl-") || f.includes("ld-musl-");
+    var familyFromReport = () => {
+      const report = getReport();
+      if (report.header && report.header.glibcVersionRuntime) {
+        return GLIBC;
+      }
+      if (Array.isArray(report.sharedObjects)) {
+        if (report.sharedObjects.some(isFileMusl)) {
+          return MUSL;
+        }
+      }
+      return null;
+    };
+    var familyFromCommand = (out) => {
+      const [getconf, ldd1] = out.split(/[\r\n]+/);
+      if (getconf && getconf.includes(GLIBC)) {
+        return GLIBC;
+      }
+      if (ldd1 && ldd1.includes(MUSL)) {
+        return MUSL;
+      }
+      return null;
+    };
+    var familyFromInterpreterPath = (path17) => {
+      if (path17) {
+        if (path17.includes("/ld-musl-")) {
+          return MUSL;
+        } else if (path17.includes("/ld-linux-")) {
+          return GLIBC;
+        }
+      }
+      return null;
+    };
+    var getFamilyFromLddContent = (content) => {
+      content = content.toString();
+      if (content.includes("musl")) {
+        return MUSL;
+      }
+      if (content.includes("GNU C Library")) {
+        return GLIBC;
+      }
+      return null;
+    };
+    var familyFromFilesystem = async () => {
+      if (cachedFamilyFilesystem !== void 0) {
+        return cachedFamilyFilesystem;
+      }
+      cachedFamilyFilesystem = null;
+      try {
+        const lddContent = await readFile(LDD_PATH);
+        cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
+      } catch (e) {
+      }
+      return cachedFamilyFilesystem;
+    };
+    var familyFromFilesystemSync = () => {
+      if (cachedFamilyFilesystem !== void 0) {
+        return cachedFamilyFilesystem;
+      }
+      cachedFamilyFilesystem = null;
+      try {
+        const lddContent = readFileSync(LDD_PATH);
+        cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
+      } catch (e) {
+      }
+      return cachedFamilyFilesystem;
+    };
+    var familyFromInterpreter = async () => {
+      if (cachedFamilyInterpreter !== void 0) {
+        return cachedFamilyInterpreter;
+      }
+      cachedFamilyInterpreter = null;
+      try {
+        const selfContent = await readFile(SELF_PATH);
+        const path17 = interpreterPath(selfContent);
+        cachedFamilyInterpreter = familyFromInterpreterPath(path17);
+      } catch (e) {
+      }
+      return cachedFamilyInterpreter;
+    };
+    var familyFromInterpreterSync = () => {
+      if (cachedFamilyInterpreter !== void 0) {
+        return cachedFamilyInterpreter;
+      }
+      cachedFamilyInterpreter = null;
+      try {
+        const selfContent = readFileSync(SELF_PATH);
+        const path17 = interpreterPath(selfContent);
+        cachedFamilyInterpreter = familyFromInterpreterPath(path17);
+      } catch (e) {
+      }
+      return cachedFamilyInterpreter;
+    };
+    var family = async () => {
+      let family2 = null;
+      if (isLinux()) {
+        family2 = await familyFromInterpreter();
+        if (!family2) {
+          family2 = await familyFromFilesystem();
+          if (!family2) {
+            family2 = familyFromReport();
+          }
+          if (!family2) {
+            const out = await safeCommand();
+            family2 = familyFromCommand(out);
+          }
+        }
+      }
+      return family2;
+    };
+    var familySync = () => {
+      let family2 = null;
+      if (isLinux()) {
+        family2 = familyFromInterpreterSync();
+        if (!family2) {
+          family2 = familyFromFilesystemSync();
+          if (!family2) {
+            family2 = familyFromReport();
+          }
+          if (!family2) {
+            const out = safeCommandSync();
+            family2 = familyFromCommand(out);
+          }
+        }
+      }
+      return family2;
+    };
+    var isNonGlibcLinux = async () => isLinux() && await family() !== GLIBC;
+    var isNonGlibcLinuxSync = () => isLinux() && familySync() !== GLIBC;
+    var versionFromFilesystem = async () => {
+      if (cachedVersionFilesystem !== void 0) {
+        return cachedVersionFilesystem;
+      }
+      cachedVersionFilesystem = null;
+      try {
+        const lddContent = await readFile(LDD_PATH);
+        const versionMatch = lddContent.match(RE_GLIBC_VERSION);
+        if (versionMatch) {
+          cachedVersionFilesystem = versionMatch[1];
+        }
+      } catch (e) {
+      }
+      return cachedVersionFilesystem;
+    };
+    var versionFromFilesystemSync = () => {
+      if (cachedVersionFilesystem !== void 0) {
+        return cachedVersionFilesystem;
+      }
+      cachedVersionFilesystem = null;
+      try {
+        const lddContent = readFileSync(LDD_PATH);
+        const versionMatch = lddContent.match(RE_GLIBC_VERSION);
+        if (versionMatch) {
+          cachedVersionFilesystem = versionMatch[1];
+        }
+      } catch (e) {
+      }
+      return cachedVersionFilesystem;
+    };
+    var versionFromReport = () => {
+      const report = getReport();
+      if (report.header && report.header.glibcVersionRuntime) {
+        return report.header.glibcVersionRuntime;
+      }
+      return null;
+    };
+    var versionSuffix = (s) => s.trim().split(/\s+/)[1];
+    var versionFromCommand = (out) => {
+      const [getconf, ldd1, ldd2] = out.split(/[\r\n]+/);
+      if (getconf && getconf.includes(GLIBC)) {
+        return versionSuffix(getconf);
+      }
+      if (ldd1 && ldd2 && ldd1.includes(MUSL)) {
+        return versionSuffix(ldd2);
+      }
+      return null;
+    };
+    var version = async () => {
+      let version2 = null;
+      if (isLinux()) {
+        version2 = await versionFromFilesystem();
+        if (!version2) {
+          version2 = versionFromReport();
+        }
+        if (!version2) {
+          const out = await safeCommand();
+          version2 = versionFromCommand(out);
+        }
+      }
+      return version2;
+    };
+    var versionSync = () => {
+      let version2 = null;
+      if (isLinux()) {
+        version2 = versionFromFilesystemSync();
+        if (!version2) {
+          version2 = versionFromReport();
+        }
+        if (!version2) {
+          const out = safeCommandSync();
+          version2 = versionFromCommand(out);
+        }
+      }
+      return version2;
+    };
+    module.exports = {
+      GLIBC,
+      MUSL,
+      family,
+      familySync,
+      isNonGlibcLinux,
+      isNonGlibcLinuxSync,
+      version,
+      versionSync
+    };
+  }
+});
+
+// node_modules/lightningcss/node/browserslistToTargets.js
+var require_browserslistToTargets = __commonJS({
+  "node_modules/lightningcss/node/browserslistToTargets.js"(exports, module) {
+    "use strict";
+    var BROWSER_MAPPING = {
+      and_chr: "chrome",
+      and_ff: "firefox",
+      ie_mob: "ie",
+      op_mob: "opera",
+      and_qq: null,
+      and_uc: null,
+      baidu: null,
+      bb: null,
+      kaios: null,
+      op_mini: null
+    };
+    function browserslistToTargets2(browserslist) {
+      let targets = {};
+      for (let browser of browserslist) {
+        let [name, v] = browser.split(" ");
+        if (BROWSER_MAPPING[name] === null) {
+          continue;
+        }
+        let version = parseVersion(v);
+        if (version == null) {
+          continue;
+        }
+        if (targets[name] == null || version < targets[name]) {
+          targets[name] = version;
+        }
+      }
+      return targets;
+    }
+    function parseVersion(version) {
+      let [major, minor = 0, patch = 0] = version.split("-")[0].split(".").map((v) => parseInt(v, 10));
+      if (isNaN(major) || isNaN(minor) || isNaN(patch)) {
+        return null;
+      }
+      return major << 16 | minor << 8 | patch;
+    }
+    module.exports = browserslistToTargets2;
+  }
+});
+
+// node_modules/lightningcss/node/composeVisitors.js
+var require_composeVisitors = __commonJS({
+  "node_modules/lightningcss/node/composeVisitors.js"(exports, module) {
+    "use strict";
+    function composeVisitors2(visitors) {
+      if (visitors.length === 1) {
+        return visitors[0];
+      }
+      if (visitors.some((v) => typeof v === "function")) {
+        return (opts) => {
+          let v = visitors.map((v2) => typeof v2 === "function" ? v2(opts) : v2);
+          return composeVisitors2(v);
+        };
+      }
+      let res = {};
+      composeSimpleVisitors(res, visitors, "StyleSheet");
+      composeSimpleVisitors(res, visitors, "StyleSheetExit");
+      composeObjectVisitors(res, visitors, "Rule", ruleVisitor, wrapCustomAndUnknownAtRule);
+      composeObjectVisitors(res, visitors, "RuleExit", ruleVisitor, wrapCustomAndUnknownAtRule);
+      composeObjectVisitors(res, visitors, "Declaration", declarationVisitor, wrapCustomProperty);
+      composeObjectVisitors(res, visitors, "DeclarationExit", declarationVisitor, wrapCustomProperty);
+      composeSimpleVisitors(res, visitors, "Url");
+      composeSimpleVisitors(res, visitors, "Color");
+      composeSimpleVisitors(res, visitors, "Image");
+      composeSimpleVisitors(res, visitors, "ImageExit");
+      composeSimpleVisitors(res, visitors, "Length");
+      composeSimpleVisitors(res, visitors, "Angle");
+      composeSimpleVisitors(res, visitors, "Ratio");
+      composeSimpleVisitors(res, visitors, "Resolution");
+      composeSimpleVisitors(res, visitors, "Time");
+      composeSimpleVisitors(res, visitors, "CustomIdent");
+      composeSimpleVisitors(res, visitors, "DashedIdent");
+      composeArrayFunctions(res, visitors, "MediaQuery");
+      composeArrayFunctions(res, visitors, "MediaQueryExit");
+      composeSimpleVisitors(res, visitors, "SupportsCondition");
+      composeSimpleVisitors(res, visitors, "SupportsConditionExit");
+      composeArrayFunctions(res, visitors, "Selector");
+      composeTokenVisitors(res, visitors, "Token", "token", false);
+      composeTokenVisitors(res, visitors, "Function", "function", false);
+      composeTokenVisitors(res, visitors, "FunctionExit", "function", true);
+      composeTokenVisitors(res, visitors, "Variable", "var", false);
+      composeTokenVisitors(res, visitors, "VariableExit", "var", true);
+      composeTokenVisitors(res, visitors, "EnvironmentVariable", "env", false);
+      composeTokenVisitors(res, visitors, "EnvironmentVariableExit", "env", true);
+      return res;
+    }
+    module.exports = composeVisitors2;
+    function wrapCustomAndUnknownAtRule(k, f) {
+      if (k === "unknown") {
+        return ((value) => f({ type: "unknown", value }));
+      }
+      if (k === "custom") {
+        return ((value) => f({ type: "custom", value }));
+      }
+      return f;
+    }
+    function wrapCustomProperty(k, f) {
+      return k === "custom" ? ((value) => f({ property: "custom", value })) : f;
+    }
+    function ruleVisitor(f, item) {
+      if (typeof f === "object") {
+        if (item.type === "unknown") {
+          let v = f.unknown;
+          if (typeof v === "object") {
+            v = v[item.value.name];
+          }
+          return v?.(item.value);
+        }
+        if (item.type === "custom") {
+          let v = f.custom;
+          if (typeof v === "object") {
+            v = v[item.value.name];
+          }
+          return v?.(item.value);
+        }
+        return f[item.type]?.(item);
+      }
+      return f?.(item);
+    }
+    function declarationVisitor(f, item) {
+      if (typeof f === "object") {
+        let name = item.property;
+        if (item.property === "unparsed") {
+          name = item.value.propertyId.property;
+        } else if (item.property === "custom") {
+          let v = f.custom;
+          if (typeof v === "object") {
+            v = v[item.value.name];
+          }
+          return v?.(item.value);
+        }
+        return f[name]?.(item);
+      }
+      return f?.(item);
+    }
+    function extractObjectsOrFunctions(visitors, key) {
+      let values = [];
+      let hasFunction = false;
+      let allKeys = /* @__PURE__ */ new Set();
+      for (let visitor of visitors) {
+        let v = visitor[key];
+        if (v) {
+          if (typeof v === "function") {
+            hasFunction = true;
+          } else {
+            for (let key2 in v) {
+              allKeys.add(key2);
+            }
+          }
+          values.push(v);
+        }
+      }
+      return [values, hasFunction, allKeys];
+    }
+    function composeObjectVisitors(res, visitors, key, apply, wrapKey) {
+      let [values, hasFunction, allKeys] = extractObjectsOrFunctions(visitors, key);
+      if (values.length === 0) {
+        return;
+      }
+      if (values.length === 1) {
+        res[key] = values[0];
+        return;
+      }
+      let f = createArrayVisitor(visitors, (visitor, item) => apply(visitor[key], item));
+      if (hasFunction) {
+        res[key] = f;
+      } else {
+        let v = {};
+        for (let k of allKeys) {
+          v[k] = wrapKey(k, f);
+        }
+        res[key] = v;
+      }
+    }
+    function composeTokenVisitors(res, visitors, key, type, isExit) {
+      let [values, hasFunction, allKeys] = extractObjectsOrFunctions(visitors, key);
+      if (values.length === 0) {
+        return;
+      }
+      if (values.length === 1) {
+        res[key] = values[0];
+        return;
+      }
+      let f = createTokenVisitor(visitors, type, isExit);
+      if (hasFunction) {
+        res[key] = f;
+      } else {
+        let v = {};
+        for (let key2 of allKeys) {
+          v[key2] = f;
+        }
+        res[key] = v;
+      }
+    }
+    function createTokenVisitor(visitors, type, isExit) {
+      let v = createArrayVisitor(visitors, (visitor, item) => {
+        let f;
+        switch (item.type) {
+          case "token":
+            f = visitor.Token;
+            if (typeof f === "object") {
+              f = f[item.value.type];
+            }
+            break;
+          case "function":
+            f = isExit ? visitor.FunctionExit : visitor.Function;
+            if (typeof f === "object") {
+              f = f[item.value.name];
+            }
+            break;
+          case "var":
+            f = isExit ? visitor.VariableExit : visitor.Variable;
+            break;
+          case "env":
+            f = isExit ? visitor.EnvironmentVariableExit : visitor.EnvironmentVariable;
+            if (typeof f === "object") {
+              let name;
+              switch (item.value.name.type) {
+                case "ua":
+                case "unknown":
+                  name = item.value.name.value;
+                  break;
+                case "custom":
+                  name = item.value.name.ident;
+                  break;
+              }
+              f = f[name];
+            }
+            break;
+          case "color":
+            f = visitor.Color;
+            break;
+          case "url":
+            f = visitor.Url;
+            break;
+          case "length":
+            f = visitor.Length;
+            break;
+          case "angle":
+            f = visitor.Angle;
+            break;
+          case "time":
+            f = visitor.Time;
+            break;
+          case "resolution":
+            f = visitor.Resolution;
+            break;
+          case "dashed-ident":
+            f = visitor.DashedIdent;
+            break;
+        }
+        if (!f) {
+          return;
+        }
+        let res = f(item.value);
+        switch (item.type) {
+          case "color":
+          case "url":
+          case "length":
+          case "angle":
+          case "time":
+          case "resolution":
+          case "dashed-ident":
+            if (Array.isArray(res)) {
+              res = res.map((value) => ({ type: item.type, value }));
+            } else if (res) {
+              res = { type: item.type, value: res };
+            }
+            break;
+        }
+        return res;
+      });
+      return (value) => v({ type, value });
+    }
+    function extractFunctions(visitors, key) {
+      let functions = [];
+      for (let visitor of visitors) {
+        let f = visitor[key];
+        if (f) {
+          functions.push(f);
+        }
+      }
+      return functions;
+    }
+    function composeSimpleVisitors(res, visitors, key) {
+      let functions = extractFunctions(visitors, key);
+      if (functions.length === 0) {
+        return;
+      }
+      if (functions.length === 1) {
+        res[key] = functions[0];
+        return;
+      }
+      res[key] = (arg) => {
+        let mutated = false;
+        for (let f of functions) {
+          let res2 = f(arg);
+          if (res2) {
+            arg = res2;
+            mutated = true;
+          }
+        }
+        return mutated ? arg : void 0;
+      };
+    }
+    function composeArrayFunctions(res, visitors, key) {
+      let functions = extractFunctions(visitors, key);
+      if (functions.length === 0) {
+        return;
+      }
+      if (functions.length === 1) {
+        res[key] = functions[0];
+        return;
+      }
+      res[key] = createArrayVisitor(functions, (f, item) => f(item));
+    }
+    function createArrayVisitor(visitors, apply) {
+      let seen = new Bitset(visitors.length);
+      return (arg) => {
+        let arr = [arg];
+        let mutated = false;
+        seen.clear();
+        for (let i = 0; i < arr.length; i++) {
+          for (let v = 0; v < visitors.length && i < arr.length; ) {
+            if (seen.get(v)) {
+              v++;
+              continue;
+            }
+            let item = arr[i];
+            let visitor = visitors[v];
+            let res = apply(visitor, item);
+            if (Array.isArray(res)) {
+              if (res.length === 0) {
+                arr.splice(i, 1);
+              } else if (res.length === 1) {
+                arr[i] = res[0];
+              } else {
+                arr.splice(i, 1, ...res);
+              }
+              mutated = true;
+              seen.set(v);
+              v = 0;
+            } else if (res) {
+              arr[i] = res;
+              mutated = true;
+              seen.set(v);
+              v = 0;
+            } else {
+              v++;
+            }
+          }
+        }
+        if (!mutated) {
+          return;
+        }
+        return arr.length === 1 ? arr[0] : arr;
+      };
+    }
+    var Bitset = class {
+      constructor(maxBits = 32) {
+        this.bits = 0;
+        this.more = maxBits > 32 ? new Uint32Array(Math.ceil((maxBits - 32) / 32)) : null;
+      }
+      /** @param {number} bit */
+      get(bit) {
+        if (bit >= 32 && this.more) {
+          let i = Math.floor((bit - 32) / 32);
+          let b = bit % 32;
+          return Boolean(this.more[i] & 1 << b);
+        } else {
+          return Boolean(this.bits & 1 << bit);
+        }
+      }
+      /** @param {number} bit */
+      set(bit) {
+        if (bit >= 32 && this.more) {
+          let i = Math.floor((bit - 32) / 32);
+          let b = bit % 32;
+          this.more[i] |= 1 << b;
+        } else {
+          this.bits |= 1 << bit;
+        }
+      }
+      clear() {
+        this.bits = 0;
+        if (this.more) {
+          this.more.fill(0);
+        }
+      }
+    };
+  }
+});
+
+// node_modules/lightningcss/node/flags.js
+var require_flags = __commonJS({
+  "node_modules/lightningcss/node/flags.js"(exports) {
+    "use strict";
+    exports.Features = {
+      Nesting: 1,
+      NotSelectorList: 2,
+      DirSelector: 4,
+      LangSelectorList: 8,
+      IsSelector: 16,
+      TextDecorationThicknessPercent: 32,
+      MediaIntervalSyntax: 64,
+      MediaRangeSyntax: 128,
+      CustomMediaQueries: 256,
+      ClampFunction: 512,
+      ColorFunction: 1024,
+      OklabColors: 2048,
+      LabColors: 4096,
+      P3Colors: 8192,
+      HexAlphaColors: 16384,
+      SpaceSeparatedColorNotation: 32768,
+      FontFamilySystemUi: 65536,
+      DoublePositionGradients: 131072,
+      VendorPrefixes: 262144,
+      LogicalProperties: 524288,
+      LightDark: 1048576,
+      Selectors: 31,
+      MediaQueries: 448,
+      Colors: 1113088
+    };
+  }
+});
+
+// node_modules/lightningcss/node/index.js
+var require_node = __commonJS({
+  "node_modules/lightningcss/node/index.js"(exports, module) {
+    "use strict";
+    init_();
+    var parts = [process.platform, process.arch];
+    if (process.platform === "linux") {
+      const { MUSL, familySync } = require_detect_libc();
+      const family = familySync();
+      if (family === MUSL) {
+        parts.push("musl");
+      } else if (process.arch === "arm") {
+        parts.push("gnueabihf");
+      } else {
+        parts.push("gnu");
+      }
+    } else if (process.platform === "win32") {
+      parts.push("msvc");
+    }
+    var native;
+    try {
+      native = __require(`lightningcss-${parts.join("-")}`);
+    } catch (err) {
+      native = globRequire_lightningcss_node(`../lightningcss.${parts.join("-")}.node`);
+    }
+    module.exports.transform = wrap(native.transform);
+    module.exports.transformStyleAttribute = wrap(native.transformStyleAttribute);
+    module.exports.bundle = wrap(native.bundle);
+    module.exports.bundleAsync = wrap(native.bundleAsync);
+    module.exports.browserslistToTargets = require_browserslistToTargets();
+    module.exports.composeVisitors = require_composeVisitors();
+    module.exports.Features = require_flags().Features;
+    function wrap(call) {
+      return (options) => {
+        if (typeof options.visitor === "function") {
+          let deps = [];
+          options.visitor = options.visitor({
+            addDependency(dep) {
+              deps.push(dep);
+            }
+          });
+          let result = call(options);
+          if (result instanceof Promise) {
+            result = result.then((res) => {
+              if (deps.length) {
+                res.dependencies ??= [];
+                res.dependencies.push(...deps);
+              }
+              return res;
+            });
+          } else if (deps.length) {
+            result.dependencies ??= [];
+            result.dependencies.push(...deps);
+          }
+          return result;
+        } else {
+          return call(options);
+        }
+      };
+    }
+  }
+});
+
+// node_modules/lightningcss/node/index.mjs
+var node_exports = {};
+__export(node_exports, {
+  Features: () => Features,
+  browserslistToTargets: () => browserslistToTargets,
+  bundle: () => bundle,
+  bundleAsync: () => bundleAsync,
+  composeVisitors: () => composeVisitors,
+  transform: () => transform,
+  transformStyleAttribute: () => transformStyleAttribute
+});
+var import_index, transform, transformStyleAttribute, bundle, bundleAsync, browserslistToTargets, composeVisitors, Features;
+var init_node = __esm({
+  "node_modules/lightningcss/node/index.mjs"() {
+    "use strict";
+    import_index = __toESM(require_node(), 1);
+    ({ transform, transformStyleAttribute, bundle, bundleAsync, browserslistToTargets, composeVisitors, Features } = import_index.default);
+  }
+});
+
+// src/core/css-engine.ts
+function createCssEngine() {
+  return {
+    styles: /* @__PURE__ */ new Map(),
+    entryCss: /* @__PURE__ */ new Map(),
+    allCss: [],
+    pendingSingle: [],
+    singleFileName: null
+  };
+}
+function normalizeCssModuleId(id) {
+  return id.startsWith("\0") ? id.slice(1) : id;
+}
+async function minifyCss(css, config) {
+  if (lightningCss === void 0) {
+    try {
+      lightningCss = await Promise.resolve().then(() => (init_node(), node_exports));
+    } catch {
+      lightningCss = null;
+      debug2?.("lightningcss unavailable, falling back to regex minifier");
+    }
+  }
+  if (lightningCss) {
+    try {
+      const result = lightningCss.transform({
+        filename: "bundle.css",
+        code: Buffer.from(css),
+        minify: true,
+        // 不展开 @import（Tailwind 已 flatten；裸 @import 保留原样交给浏览器）
+        errorRecovery: true
+      });
+      for (const w of result.warnings ?? []) {
+        config.logger.warnOnce(`[nasti:css] ${w.message}`);
+      }
+      return result.code.toString();
+    } catch (err) {
+      config.logger.warnOnce(
+        `[nasti:css] Lightning CSS minify failed (${err.message}), emitting unminified CSS`
+      );
+      return css;
+    }
+  }
+  return fallbackMinify(css);
+}
+function fallbackMinify(css) {
+  return css.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\s*([{}:;,])\s*/g, "$1").replace(/;}/g, "}").replace(/\s+/g, " ").trim();
+}
+var debug2, lightningCss;
+var init_css_engine = __esm({
+  "src/core/css-engine.ts"() {
+    "use strict";
+    init_debug();
+    debug2 = createDebugger("nasti:css");
+  }
+});
+
+// src/plugins/tailwind.ts
+import path7 from "path";
+import { createRequire as createRequire3 } from "module";
+import { pathToFileURL as pathToFileURL3 } from "url";
+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 = createRequire3(path7.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(pathToFileURL3(nodePath).href);
+  const oxide = await import(pathToFileURL3(oxidePath).href);
+  cached = { node, oxide };
+  cachedRoot = projectRoot;
+  return cached;
+}
+async function compileTailwind(css, fromFile, projectRoot) {
+  const { node, oxide } = await loadTailwind(projectRoot);
+  const dependencies = [];
+  const compiler2 = await node.compile(css, {
+    base: path7.dirname(fromFile),
+    from: fromFile,
+    onDependency: (p) => dependencies.push(p)
+  });
+  const scanner = new oxide.Scanner({ sources: compiler2.sources });
+  const candidates = scanner.scan();
+  return {
+    css: compiler2.build(candidates),
+    dependencies: [...dependencies, ...scanner.files]
+  };
+}
+var TAILWIND_DIRECTIVE_RE, cached, cachedRoot;
+var init_tailwind = __esm({
+  "src/plugins/tailwind.ts"() {
+    "use strict";
+    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
+import path8 from "path";
+function cssPlugin(config, engine, consumer = "client") {
+  return {
+    name: "nasti:css",
+    resolveId(source) {
+      if (source.endsWith(".css")) return null;
+      return null;
+    },
+    async transform(code, id) {
+      const [file, query = ""] = id.split("?", 2);
+      const isCssRequest = file.endsWith(".css") || /\.css$/.test(id);
+      if (!isCssRequest) return null;
+      if (query === "raw" || query === "url") return null;
+      let cssSource = code;
+      if (hasTailwindDirectives(code)) {
+        const compiled = await compileTailwind(code, id, config.root);
+        cssSource = compiled.css;
+      }
+      const rewritten = rewriteCssUrls(cssSource, file, config.root);
+      const escaped = JSON.stringify(rewritten);
+      if (query === "inline") {
+        return { code: `export default ${escaped};
+`, moduleType: "js" };
+      }
+      if (consumer === "server") {
+        return { code: `export default ${escaped};
+`, moduleType: "js" };
+      }
+      if (config.command === "serve") {
+        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', __nasti_css_id__);
+style.textContent = css;
+document.head.appendChild(style);
+
+// HMR\uFF08prune \u5728 bundled \u6A21\u5F0F\u7684 rolldown hot context \u4E0A\u4E0D\u5B58\u5728\uFF0C\u987B\u5B88\u536B\uFF09
+if (import.meta.hot) {
+  import.meta.hot.accept();
+  if (import.meta.hot.prune) {
+    import.meta.hot.prune(() => {
+      style.remove();
+    });
+  }
+}
+
+export default css;
+`,
+          // bundled dev（DevEngine）下该模块会进 Rolldown：不标 js 会按 .css
+          // 扩展名走 CSS 管线触发 #4271 报错；unbundled 中间件忽略此字段
           moduleType: "js"
         };
       }
-      const nonceAttr = nonce ? `style.setAttribute('nonce', ${JSON.stringify(nonce)});` : "";
-      return {
-        code: `
-const css = ${escaped};
-const style = document.createElement('style');
-style.setAttribute('data-nasti-css', ${JSON.stringify(id)});
-${nonceAttr}
-style.textContent = css;
-document.head.appendChild(style);
-
-export default css;
-`,
-        moduleType: "js"
-      };
+      if (engine) {
+        engine.styles.set(normalizeCssModuleId(id), rewritten);
+        return {
+          code: `export default '';
+`,
+          moduleType: "js",
+          // 防止空 stub 被 tree-shake 出 chunk.moduleIds（css-post 靠它定位）
+          moduleSideEffects: "no-treeshake"
+        };
+      }
+      const cssConfig = config.build.css || {};
+      const nonce = cssConfig.nonce;
+      const nonceAttr = nonce ? `style.setAttribute('nonce', ${JSON.stringify(nonce)});` : "";
+      return {
+        code: `
+const css = ${escaped};
+const style = document.createElement('style');
+style.setAttribute('data-nasti-css', ${JSON.stringify(id)});
+${nonceAttr}
+style.textContent = css;
+document.head.appendChild(style);
+
+export default css;
+`,
+        moduleType: "js"
+      };
+    }
+  };
+}
+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 = path8.resolve(path8.dirname(from), url);
+    const relative = "/" + path8.relative(root, resolved).replace(/\\/g, "/");
+    return `url(${relative})`;
+  });
+}
+var init_css = __esm({
+  "src/plugins/css.ts"() {
+    "use strict";
+    init_css_engine();
+    init_tailwind();
+  }
+});
+
+// src/plugins/css-post.ts
+function collectChunkCss(chunk, engine) {
+  const ids = chunk.moduleIds ?? Object.keys(chunk.modules);
+  let css = "";
+  for (const id of ids) {
+    const styles = engine.styles.get(normalizeCssModuleId(id));
+    if (styles) css += styles + "\n";
+  }
+  return css;
+}
+function cssPostPlugin(config, engine) {
+  return {
+    name: "nasti:css-post",
+    enforce: "post",
+    async renderChunk(code, chunk) {
+      const css = collectChunkCss(chunk, engine);
+      if (!css) return null;
+      if (!config.build.cssCodeSplit) {
+        engine.pendingSingle.push(css);
+        return null;
+      }
+      const finalCss = config.build.cssMinify ? await minifyCss(css, config) : css;
+      const ref = this.emitFile({
+        type: "asset",
+        name: `${chunk.name}.css`,
+        source: finalCss
+      });
+      const fileName = this.getFileName(ref);
+      engine.allCss.push(fileName);
+      if (chunk.isEntry) {
+        const key = chunk.facadeModuleId ?? chunk.name;
+        const existing = engine.entryCss.get(key) ?? [];
+        existing.push(fileName);
+        engine.entryCss.set(key, existing);
+        return null;
+      }
+      const href = JSON.stringify(config.base + fileName);
+      const snippet = `
+;(function(){try{var d=document,h=${href};if(!d.querySelector('link[data-nasti-css="'+h+'"]')){var l=d.createElement('link');l.rel='stylesheet';l.href=h;l.setAttribute('data-nasti-css',h);d.head.appendChild(l);}}catch(e){}})();`;
+      return { code: code + snippet, map: null };
+    },
+    augmentChunkHash(chunk) {
+      const css = collectChunkCss(chunk, engine);
+      return css || void 0;
+    },
+    async generateBundle() {
+      if (config.build.cssCodeSplit || engine.pendingSingle.length === 0) return;
+      const merged = engine.pendingSingle.join("\n");
+      const finalCss = config.build.cssMinify ? await minifyCss(merged, config) : merged;
+      const ref = this.emitFile({ type: "asset", name: "style.css", source: finalCss });
+      const fileName = this.getFileName(ref);
+      engine.singleFileName = fileName;
+      engine.allCss.push(fileName);
+    }
+  };
+}
+var init_css_post = __esm({
+  "src/plugins/css-post.ts"() {
+    "use strict";
+    init_css_engine();
+  }
+});
+
+// src/plugins/assets.ts
+import path9 from "path";
+import fs7 from "fs";
+import crypto from "crypto";
+function assetsPlugin(config) {
+  return {
+    name: "nasti:assets",
+    resolveId(source) {
+      if (source.endsWith("?url") || source.endsWith("?raw")) {
+        return source;
+      }
+      return null;
+    },
+    load(id) {
+      const ext = path9.extname(id.replace(/\?.*$/, ""));
+      if (id.endsWith("?raw")) {
+        const file = id.slice(0, -4);
+        if (fs7.existsSync(file)) {
+          const content = fs7.readFileSync(file, "utf-8");
+          return `export default ${JSON.stringify(content)}`;
+        }
+      }
+      if (id.endsWith("?url") || ASSET_EXTENSIONS.has(ext)) {
+        const file = id.replace(/\?.*$/, "");
+        if (!fs7.existsSync(file)) return null;
+        if (config.command === "serve") {
+          const url = "/" + path9.relative(config.root, file);
+          return `export default ${JSON.stringify(url)}`;
+        }
+        const content = fs7.readFileSync(file);
+        const hash = crypto.createHash("sha256").update(content).digest("hex").slice(0, 8);
+        const basename = path9.basename(file, ext);
+        const hashedName = `${config.build.assetsDir}/${basename}.${hash}${ext}`;
+        return `export default ${JSON.stringify(config.base + hashedName)}`;
+      }
+      return null;
+    }
+  };
+}
+var ASSET_EXTENSIONS;
+var init_assets = __esm({
+  "src/plugins/assets.ts"() {
+    "use strict";
+    ASSET_EXTENSIONS = /* @__PURE__ */ new Set([
+      ".png",
+      ".jpg",
+      ".jpeg",
+      ".gif",
+      ".svg",
+      ".ico",
+      ".webp",
+      ".avif",
+      ".mp4",
+      ".webm",
+      ".ogg",
+      ".mp3",
+      ".wav",
+      ".flac",
+      ".aac",
+      ".woff",
+      ".woff2",
+      ".eot",
+      ".ttf",
+      ".otf",
+      ".pdf",
+      ".txt"
+    ]);
+  }
+});
+
+// src/plugins/vue.ts
+import crypto2 from "crypto";
+async function loadVueCompiler() {
+  if (compiler) return compiler;
+  try {
+    compiler = await import("@vue/compiler-sfc");
+    return compiler;
+  } catch {
+    return null;
+  }
+}
+function vuePlugin(config) {
+  const isDev = config.command === "serve";
+  const descriptorCache = /* @__PURE__ */ new Map();
+  return {
+    name: "nasti:vue",
+    enforce: "pre",
+    async resolveId(source) {
+      if (VUE_QUERY_RE.test(source)) {
+        return source;
+      }
+      return null;
+    },
+    // 虚拟子模块必须有 load 钩子：build 下 Rolldown 否则会按字面路径读盘，
+    // 抛 UNLOADABLE_DEPENDENCY（1.x Vue 生产构建因此直接失败）。
+    // style 子块在这里编译成 CSS 字符串，交给 css 插件统一处理
+    // （dev = <style> 注入 + HMR；build = CssEngine 抽取成 hashed .css）。
+    async load(id) {
+      const match = id.match(/(.+\.vue)\?vue&type=style(?:&index=(\d+))?/);
+      if (!match) return null;
+      const sfc = await loadVueCompiler();
+      if (!sfc) return null;
+      const [, filePath, indexStr] = match;
+      let descriptor = descriptorCache.get(filePath);
+      if (!descriptor) {
+        try {
+          const fs12 = await import("fs");
+          const source = fs12.readFileSync(filePath, "utf-8");
+          const parsed = sfc.parse(source, { filename: filePath });
+          if (parsed.errors.length) return null;
+          descriptor = parsed.descriptor;
+          descriptorCache.set(filePath, descriptor);
+        } catch {
+          return null;
+        }
+      }
+      const index2 = parseInt(indexStr ?? "0", 10);
+      const style = descriptor.styles[index2];
+      if (!style) return null;
+      const scopeId = hashId(filePath);
+      const result = await sfc.compileStyleAsync({
+        source: style.content,
+        filename: filePath,
+        id: `data-v-${scopeId}`,
+        scoped: style.scoped ?? false,
+        // <style lang="scss|less|stylus"> 需经对应预处理器（缺省 undefined = 纯 CSS）
+        preprocessLang: style.lang
+      });
+      return result.code;
+    },
+    async transform(code, id) {
+      if (!VUE_FILE_RE.test(id) && !VUE_QUERY_RE.test(id)) return null;
+      const sfc = await loadVueCompiler();
+      if (!sfc) {
+        console.warn("[nasti:vue] @vue/compiler-sfc not found. Install it: npm install @vue/compiler-sfc");
+        return null;
+      }
+      if (VUE_QUERY_RE.test(id)) {
+        return null;
+      }
+      const { descriptor, errors } = sfc.parse(code, { filename: id });
+      if (errors.length) {
+        console.error(`[nasti:vue] Parse error in ${id}:`, errors[0].message);
+        return null;
+      }
+      descriptorCache.set(id, descriptor);
+      const scopeId = hashId(id);
+      let scriptCode = "";
+      if (descriptor.script || descriptor.scriptSetup) {
+        const compiled = sfc.compileScript(descriptor, {
+          id: scopeId,
+          isProd: !isDev,
+          inlineTemplate: true,
+          // 让 compileScript 产出 `const __sfc__ = ...`（而非默认的 `export default {...}`）。
+          // 否则下方追加的 `__sfc__.render` / `__sfc__.__scopeId` / HMR 记录会引用一个
+          // 不存在的 `__sfc__`，并与 compileScript 自带的 `export default` 形成双重默认导出。
+          genDefaultAs: "__sfc__"
+        });
+        scriptCode = compiled.content;
+      }
+      let templateCode = "";
+      if (descriptor.template && !descriptor.scriptSetup) {
+        const compiled = sfc.compileTemplate({
+          source: descriptor.template.content,
+          filename: id,
+          id: scopeId,
+          compilerOptions: { scopeId: `data-v-${scopeId}` }
+        });
+        templateCode = compiled.code;
+      }
+      let output = scriptCode || "const __sfc__ = {}";
+      if (templateCode) {
+        output += `
+${templateCode}
+`;
+        output += `
+__sfc__.render = render
+`;
+      }
+      if (descriptor.styles.length > 0) {
+        for (let i = 0; i < descriptor.styles.length; i++) {
+          output += `
+import "${id}?vue&type=style&index=${i}&lang.css"
+`;
+        }
+      }
+      output += `
+__sfc__.__scopeId = "data-v-${scopeId}"
+`;
+      if (isDev) {
+        output += `
+__sfc__.__hmrId = ${JSON.stringify(scopeId)}
+if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
+  __VUE_HMR_RUNTIME__.createRecord(__sfc__.__hmrId, __sfc__)
+}
+if (import.meta.hot) {
+  import.meta.hot.accept((mod) => {
+    if (!mod) return
+    const { default: updated } = mod
+    if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
+      __VUE_HMR_RUNTIME__.rerender(updated.__hmrId, updated.render)
+    }
+  })
+}
+`;
+      }
+      output += `
+export default __sfc__
+`;
+      const lang = descriptor.scriptSetup?.lang ?? descriptor.script?.lang;
+      if (lang === "ts") {
+        const transpiled = transformCode(`${id}.ts`, output, { sourcemap: false });
+        return { code: transpiled.code };
+      }
+      return { code: output };
+    },
+    handleHotUpdate(ctx) {
+      const { file, modules } = ctx;
+      if (VUE_FILE_RE.test(file)) {
+        for (const mod of modules) {
+          mod.isSelfAccepting = true;
+        }
+        descriptorCache.delete(file);
+      }
+      return modules;
+    }
+  };
+}
+function hashId(filename) {
+  return crypto2.createHash("sha256").update(filename).digest("hex").slice(0, 8);
+}
+var VUE_FILE_RE, VUE_QUERY_RE, compiler;
+var init_vue = __esm({
+  "src/plugins/vue.ts"() {
+    "use strict";
+    init_transformer();
+    VUE_FILE_RE = /\.vue$/;
+    VUE_QUERY_RE = /\.vue\?vue&type=(script|template|style)(&index=\d+)?(&lang[.=]\w+)?/;
+    compiler = null;
+  }
+});
+
+// src/plugins/builtins.ts
+function resolvePluginList(config, userPlugins, opts = {}) {
+  const isServe = config.command === "serve";
+  return [
+    // vuePlugin 排最前（enforce: 'pre' 语义）：.vue 先编译成 JS 再走后续管道
+    ...config.framework === "vue" ? [vuePlugin(config)] : [],
+    resolvePlugin(config),
+    cssPlugin(config, opts.cssEngine, opts.consumer),
+    assetsPlugin(config),
+    ...isServe ? [htmlPlugin(config)] : [],
+    ...userPlugins,
+    // cssPostPlugin 最后（enforce: 'post' 语义）：renderChunk 聚合抽取
+    ...!isServe && opts.cssEngine ? [cssPostPlugin(config, opts.cssEngine)] : []
+  ];
+}
+var init_builtins = __esm({
+  "src/plugins/builtins.ts"() {
+    "use strict";
+    init_resolve();
+    init_css();
+    init_css_post();
+    init_assets();
+    init_vue();
+    init_html();
+  }
+});
+
+// src/server/runnable-environment.ts
+var runnable_environment_exports = {};
+__export(runnable_environment_exports, {
+  NastiModuleRunner: () => NastiModuleRunner,
+  createModuleRunner: () => createModuleRunner
+});
+import path10 from "path";
+import fs8 from "fs";
+import { builtinModules, createRequire as createRequire4 } from "module";
+import { pathToFileURL as pathToFileURL4 } from "url";
+function createModuleRunner(environment) {
+  if (environment.consumer !== "server") {
+    throw new Error(
+      `[nasti] module runner requires a server-consumer environment (got "${environment.name}" / ${environment.consumer})`
+    );
+  }
+  return new NastiModuleRunner(environment);
+}
+var debug3, NODE_BUILTINS, NastiModuleRunner, AsyncFunction;
+var init_runnable_environment = __esm({
+  "src/server/runnable-environment.ts"() {
+    "use strict";
+    init_transformer();
+    init_env();
+    init_debug();
+    debug3 = createDebugger("nasti:ssr");
+    NODE_BUILTINS = /* @__PURE__ */ new Set([...builtinModules, ...builtinModules.map((m) => `node:${m}`)]);
+    NastiModuleRunner = class {
+      environment;
+      config;
+      cache = /* @__PURE__ */ new Map();
+      envDefine;
+      require;
+      constructor(environment) {
+        this.environment = environment;
+        this.config = environment.config;
+        this.envDefine = buildEnvDefine(
+          loadEnv(this.config.mode, this.config.root, this.config.envPrefix),
+          this.config.mode,
+          ssrDefineOverrides(environment.consumer)
+        );
+        this.require = createRequire4(path10.join(this.config.root, "package.json"));
+        const handlers = {
+          fetchModule: async (id, importer) => this.fetchModule(id, importer),
+          getBuiltins: () => [/^node:/, ...builtinModules]
+        };
+        environment.hot.setInvokeHandler?.(handlers);
+      }
+      /** 入口：加载并执行一个模块（url 为根相对或绝对路径） */
+      async import(rawUrl) {
+        const id = this.resolveToId(rawUrl);
+        return this.instantiate(id);
+      }
+      /** 文件变更时按文件失效（含其所属的虚拟子模块） */
+      invalidateFile(file) {
+        for (const key of [...this.cache.keys()]) {
+          if (key === file || key.startsWith(file + "?")) {
+            this.cache.delete(key);
+          }
+        }
+      }
+      invalidateAll() {
+        this.cache.clear();
+      }
+      resolveToId(rawUrl) {
+        if (path10.isAbsolute(rawUrl) && fs8.existsSync(rawUrl.split("?")[0])) return rawUrl;
+        const clean = rawUrl.replace(/^\//, "");
+        return path10.resolve(this.config.root, clean);
+      }
+      /**
+       * fetchModule（invoke 契约方法）：环境管线产出 runner 可执行代码。
+       * resolve（插件 resolveId → 文件系统）→ load/读盘 → 插件 transform →
+       * oxc（TS/JSX）→ moduleRunnerTransform。
+       */
+      async fetchModule(id, importer) {
+        if (NODE_BUILTINS.has(id)) return { externalize: id };
+        if (!id.startsWith(".") && !path10.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 : path10.resolve(path10.dirname(importer.split("?")[0]), id);
+        }
+        resolvedId = this.completeExtension(resolvedId);
+        const cleanId = resolvedId.split("?")[0];
+        let code;
+        const loaded = await container.load(resolvedId);
+        if (loaded != null) {
+          code = typeof loaded === "string" ? loaded : loaded.code;
+        } else if (fs8.existsSync(cleanId)) {
+          code = fs8.readFileSync(cleanId, "utf-8");
+        } else {
+          throw new Error(`[nasti:ssr] cannot load module: ${resolvedId}`);
+        }
+        const transformed = await container.transform(code, resolvedId);
+        if (transformed != null) {
+          code = typeof transformed === "string" ? transformed : transformed.code;
+        }
+        if (shouldTransform(cleanId)) {
+          const result = transformCode(cleanId, code, {
+            sourcemap: false,
+            jsxRuntime: "automatic",
+            jsxImportSource: this.config.framework === "vue" ? "vue" : "react"
+          });
+          code = result.code;
+        }
+        code = replaceEnvInCode(code, this.envDefine);
+        let moduleRunnerTransform;
+        try {
+          ;
+          ({ moduleRunnerTransform } = await import("rolldown/experimental"));
+        } catch (err) {
+          throw new Error(
+            `[nasti:ssr] rolldown/experimental moduleRunnerTransform unavailable (installed rolldown incompatible?): ${err.message}`
+          );
+        }
+        const runnerResult = await moduleRunnerTransform(resolvedId, code);
+        debug3?.(`fetchModule ${resolvedId} (${runnerResult.deps?.length ?? 0} deps)`);
+        return { id: resolvedId, code: runnerResult.code };
+      }
+      completeExtension(id) {
+        const clean = id.split("?")[0];
+        const query = id.includes("?") ? id.slice(id.indexOf("?")) : "";
+        if (fs8.existsSync(clean) && fs8.statSync(clean).isFile()) return id;
+        const jsMatch = clean.match(/^(.*)\.([mc]?)jsx?$/);
+        if (jsMatch) {
+          for (const tsExt of [`.${jsMatch[2]}ts`, `.${jsMatch[2]}tsx`]) {
+            if (fs8.existsSync(jsMatch[1] + tsExt)) return jsMatch[1] + tsExt + query;
+          }
+        }
+        for (const ext of this.config.resolve.extensions) {
+          if (fs8.existsSync(clean + ext)) return clean + ext + query;
+        }
+        for (const ext of this.config.resolve.extensions) {
+          const indexPath = path10.join(clean, `index${ext}`);
+          if (fs8.existsSync(indexPath)) return indexPath;
+        }
+        return id;
+      }
+      async instantiate(id) {
+        const cached2 = this.cache.get(id);
+        if (cached2) return cached2.promise ?? Promise.resolve(cached2.exports);
+        const entry = { exports: {}, promise: null };
+        this.cache.set(id, entry);
+        entry.promise = this.evaluate(id, entry).then(() => {
+          entry.promise = null;
+          return entry.exports;
+        }).catch((err) => {
+          this.cache.delete(id);
+          throw err;
+        });
+        return entry.promise;
+      }
+      async evaluate(id, entry) {
+        const fetched = await this.fetchModule(id);
+        if ("externalize" in fetched) {
+          const spec = fetched.externalize;
+          const mod = await this.importExternal(spec);
+          entry.exports = mod;
+          return;
+        }
+        const ssrImport = async (dep) => {
+          if (NODE_BUILTINS.has(dep) || !dep.startsWith(".") && !path10.isAbsolute(dep) && !dep.startsWith("\0")) {
+            return this.importExternal(dep);
+          }
+          const depId = dep.startsWith(".") ? this.completeExtension(path10.resolve(path10.dirname(fetched.id.split("?")[0]), dep)) : this.completeExtension(dep);
+          return this.instantiate(depId);
+        };
+        const ssrExportAll = (sourceModule) => {
+          for (const key of Object.keys(sourceModule)) {
+            if (key !== "default" && !(key in entry.exports)) {
+              Object.defineProperty(entry.exports, key, {
+                enumerable: true,
+                configurable: true,
+                get: () => sourceModule[key]
+              });
+            }
+          }
+        };
+        const importMeta = {
+          url: pathToFileURL4(fetched.id.split("?")[0]).href,
+          env: { SSR: true, MODE: this.config.mode, DEV: this.config.mode !== "production", PROD: this.config.mode === "production" },
+          hot: void 0
+        };
+        const fn = new AsyncFunction(
+          "__vite_ssr_exports__",
+          "__vite_ssr_import__",
+          "__vite_ssr_dynamic_import__",
+          "__vite_ssr_exportAll__",
+          "__vite_ssr_import_meta__",
+          `"use strict";${fetched.code}
+//# sourceURL=${fetched.id}`
+        );
+        await fn(entry.exports, ssrImport, ssrImport, ssrExportAll, importMeta);
+      }
+      async importExternal(spec) {
+        try {
+          return await (spec.startsWith("node:") || !path10.isAbsolute(spec) ? import(this.resolveExternalSpecifier(spec)) : import(pathToFileURL4(spec).href));
+        } catch (err) {
+          throw new Error(`[nasti:ssr] failed to import external "${spec}": ${err.message}`);
+        }
+      }
+      /** bare specifier → 项目 node_modules 的绝对 URL（避免相对 Nasti 自身解析） */
+      resolveExternalSpecifier(spec) {
+        if (spec.startsWith("node:")) return spec;
+        if (NODE_BUILTINS.has(spec)) return `node:${spec}`;
+        try {
+          return pathToFileURL4(this.require.resolve(spec)).href;
+        } catch {
+          return spec;
+        }
+      }
+    };
+    AsyncFunction = Object.getPrototypeOf(async function() {
+    }).constructor;
+  }
+});
+
+// src/build/reporter.ts
+import path11 from "path";
+import { gzipSync } from "zlib";
+import pc5 from "picocolors";
+async function tryNativeReporterPlugin(config, logger) {
+  try {
+    const { viteReporterPlugin } = await import("rolldown/experimental");
+    if (typeof viteReporterPlugin !== "function") return null;
+    return viteReporterPlugin({
+      root: config.root,
+      isTty: process.stdout.isTTY ?? false,
+      isLib: false,
+      assetsDir: config.build.assetsDir,
+      chunkLimit: config.build.chunkSizeWarningLimit,
+      // 大 chunk 警告由 JS 侧 warnLargeChunks() 经 logger.warn 输出，
+      // 原生侧只产 info 级表格，避免警告被 logLevel 过滤吞掉
+      warnLargeChunks: false,
+      reportCompressedSize: config.build.reportCompressedSize,
+      logInfo: (msg) => logger.info(msg)
+    });
+  } catch (err) {
+    debug4?.(`native viteReporterPlugin unavailable, falling back to JS table: ${err}`);
+    return null;
+  }
+}
+function displaySize(bytes) {
+  return `${numberFormatter.format(bytes / 1e3)} kB`;
+}
+function byteLength(content) {
+  if (content == null) return 0;
+  return typeof content === "string" ? Buffer.byteLength(content) : content.byteLength;
+}
+function reportBuildOutput(output, config, logger) {
+  const entries = [];
+  const compressed = config.build.reportCompressedSize;
+  for (const file of output) {
+    const content = file.type === "chunk" ? file.code : file.source;
+    const size = byteLength(content);
+    let gzip = null;
+    if (compressed && content != null) {
+      gzip = gzipSync(typeof content === "string" ? Buffer.from(content) : content).byteLength;
+    }
+    const ext = path11.extname(file.fileName);
+    const group = file.type === "chunk" ? "js" : ext === ".css" ? "css" : "assets";
+    entries.push({ name: file.fileName, size, gzip, group });
+  }
+  const groupOrder = { assets: 0, css: 1, js: 2 };
+  entries.sort((a, b) => groupOrder[a.group] - groupOrder[b.group] || a.size - b.size);
+  const outDirPrefix = `${config.build.outDir.replace(/\/$/, "")}/`;
+  const maxNameLen = Math.max(...entries.map((e) => (outDirPrefix + e.name).length), 0);
+  const maxSizeLen = Math.max(...entries.map((e) => displaySize(e.size).length), 0);
+  const groupColor = { assets: pc5.green, css: pc5.magenta, js: pc5.cyan };
+  for (const e of entries) {
+    const color = groupColor[e.group];
+    const namePart = pc5.dim(outDirPrefix) + color(e.name.padEnd(maxNameLen - outDirPrefix.length));
+    const sizePart = pc5.dim(pc5.bold(displaySize(e.size).padStart(maxSizeLen)));
+    const gzipPart = e.gzip != null ? pc5.dim(` \u2502 gzip: ${displaySize(e.gzip)}`) : "";
+    logger.info(`${namePart} ${sizePart}${gzipPart}`);
+  }
+}
+function warnLargeChunks(output, config, logger) {
+  const limit = config.build.chunkSizeWarningLimit;
+  const large = output.filter(
+    (f) => f.type === "chunk" && byteLength(f.code) / 1e3 > limit
+  );
+  if (large.length === 0) return;
+  logger.warn(
+    pc5.yellow(
+      `
+(!) Some chunks are larger than ${limit} kB after minification. Consider:
+- Using dynamic import() to code-split the application
+- Configuring build.rolldownOptions.output.advancedChunks to isolate large dependencies
+- Adjusting build.chunkSizeWarningLimit to silence this warning`
+    )
+  );
+}
+var debug4, numberFormatter;
+var init_reporter = __esm({
+  "src/build/reporter.ts"() {
+    "use strict";
+    init_debug();
+    debug4 = createDebugger("nasti:reporter");
+    numberFormatter = new Intl.NumberFormat("en", {
+      maximumFractionDigits: 2,
+      minimumFractionDigits: 2
+    });
+  }
+});
+
+// src/build/index.ts
+var build_exports = {};
+__export(build_exports, {
+  build: () => build,
+  getRolldownOptions: () => getRolldownOptions,
+  resolveClientEntries: () => resolveClientEntries,
+  toRolldownPlugins: () => toRolldownPlugins
+});
+import path12 from "path";
+import fs9 from "fs";
+import { builtinModules as builtinModules2 } from "module";
+import { rolldown } from "rolldown";
+import pc6 from "picocolors";
+function getRolldownOptions(environment, entryPoints, rolldownPlugins) {
+  const config = environment.config;
+  const envOptions = environment.options;
+  const isServer = environment.consumer === "server";
+  const outDir = path12.resolve(config.root, envOptions.build.outDir);
+  const assetsDir = envOptions.build.assetsDir;
+  const { output: userOutput, transform: userTransform, ...restInputOptions } = envOptions.build.rolldownOptions;
+  const vueDefine = config.framework === "vue" ? {
+    __VUE_OPTIONS_API__: "true",
+    __VUE_PROD_DEVTOOLS__: "false",
+    __VUE_PROD_HYDRATION_MISMATCH_DETAILS__: "false"
+  } : {};
+  const env = loadEnv(config.mode, config.root, config.envPrefix);
+  const envDefine = buildEnvDefine(env, config.mode, ssrDefineOverrides(environment.consumer));
+  const mergedDefine = { ...vueDefine, ...userTransform?.define ?? {}, ...envDefine };
+  const inputOptions = {
+    ...restInputOptions,
+    input: entryPoints,
+    transform: { ...userTransform, define: mergedDefine },
+    plugins: rolldownPlugins,
+    ...isServer ? {
+      platform: restInputOptions.platform ?? "node",
+      resolve: {
+        conditionNames: envOptions.resolve.conditions,
+        mainFields: envOptions.resolve.mainFields,
+        ...restInputOptions.resolve
+      },
+      // server 产物：node 内建恒外部化；bare specifier 默认外部化
+      //（同 Vite ssr.external 默认 —— 依赖由 node_modules 运行时解析），
+      // 相对/绝对/虚拟模块照常打包。需要内联依赖时经 rolldownOptions.external 覆盖。
+      external: restInputOptions.external ?? ((id) => {
+        if (NODE_BUILTINS2.has(id)) return true;
+        return !id.startsWith(".") && !path12.isAbsolute(id) && !id.startsWith("\0");
+      })
+    } : {}
+  };
+  const outputOptions = isServer ? {
+    format: "esm",
+    sourcemap: !!envOptions.build.sourcemap,
+    minify: !!envOptions.build.minify,
+    entryFileNames: "[name].js",
+    chunkFileNames: "chunks/[name]-[hash].js",
+    assetFileNames: `${assetsDir}/[name].[hash][extname]`,
+    ...userOutput,
+    dir: outDir
+  } : {
+    format: "esm",
+    sourcemap: !!envOptions.build.sourcemap,
+    minify: !!envOptions.build.minify,
+    entryFileNames: `${assetsDir}/[name].[hash].js`,
+    chunkFileNames: `${assetsDir}/[name].[hash].js`,
+    assetFileNames: `${assetsDir}/[name].[hash][extname]`,
+    // 用户可覆盖默认输出：代码拆分（advancedChunks / codeSplitting）、chunk 命名等
+    ...userOutput,
+    // dir 始终由 Nasti 掌管 —— HTML 改写依赖固定的产物目录，故放在最后强制生效
+    dir: outDir
+  };
+  return { inputOptions, outputOptions, outDir };
+}
+function toRolldownPlugins(plugins) {
+  return plugins.map((p) => ({
+    name: p.name,
+    resolveId: p.resolveId,
+    load: p.load,
+    transform: p.transform,
+    buildStart: p.buildStart,
+    buildEnd: p.buildEnd,
+    // closeBundle 在 bundle.close() 时触发 —— PWA manifest/SW 等终态产物依赖
+    closeBundle: p.closeBundle,
+    renderChunk: p.renderChunk,
+    augmentChunkHash: p.augmentChunkHash,
+    generateBundle: p.generateBundle
+  }));
+}
+function resolveClientEntries(config, html) {
+  const entryPoints = [];
+  if (html) {
+    const scriptMatches = html.matchAll(/<script[^>]+src=["']([^"']+)["'][^>]*>/gi);
+    for (const match of scriptMatches) {
+      const src = match[1];
+      if (src && !src.startsWith("http")) {
+        entryPoints.push(path12.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 = path12.resolve(config.root, entry);
+      if (fs9.existsSync(fullPath)) {
+        entryPoints.push(fullPath);
+        break;
+      }
+    }
+  }
+  return entryPoints;
+}
+function createOxcTransformPlugin(config, environment) {
+  return {
+    name: "nasti:oxc-transform",
+    transform(code, id) {
+      if (!shouldTransform(id)) return null;
+      const result = transformCode(id, code, {
+        sourcemap: !!environment.options.build.sourcemap,
+        jsxRuntime: "automatic",
+        jsxImportSource: config.framework === "vue" ? "vue" : "react"
+      });
+      return { code: result.code, map: result.map ? JSON.parse(result.map) : void 0 };
+    }
+  };
+}
+async function build(inlineConfig = {}) {
+  const config = await resolveConfig(inlineConfig, "build");
+  const logger = config.logger;
+  const startTime = performance.now();
+  logger.info(
+    pc6.cyan(`
+nasti v${"2.0.1"} `) + pc6.green(`building for ${config.mode}...`)
+  );
+  debug5?.(`root: ${config.root}`);
+  const buildableNames = Object.keys(config.environments).filter(
+    (name) => name === "client" || config.environments[name].entry.length > 0
+  );
+  buildableNames.sort((a, b) => a === "client" ? -1 : b === "client" ? 1 : 0);
+  const environments = {};
+  let clientOutput = [];
+  for (const name of buildableNames) {
+    const output = name === "client" ? await buildClientEnvironment(config) : await buildServerEnvironment(config, name);
+    environments[name] = output;
+    if (name === "client") clientOutput = output;
+    if (buildableNames.length > 1) {
+      debug5?.(`environment "${name}" built (${output.length} files)`);
+    }
+  }
+  const elapsed = ((performance.now() - startTime) / 1e3).toFixed(2);
+  const totalSize = Object.values(environments).flat().reduce((sum, chunk) => {
+    const content = chunk.type === "chunk" ? chunk.code : chunk.source;
+    if (content == null) return sum;
+    return sum + (typeof content === "string" ? Buffer.byteLength(content) : content.byteLength);
+  }, 0);
+  const fileCount = Object.values(environments).flat().length;
+  const envSuffix = buildableNames.length > 1 ? ` (${buildableNames.join(" + ")})` : "";
+  logger.info(pc6.green(`\u2713 built in ${elapsed}s`) + pc6.dim(envSuffix));
+  logger.info(pc6.dim(`  ${fileCount} files, ${displaySize(totalSize)} total \u2192 ${config.build.outDir}/`));
+  return { output: clientOutput, environments };
+}
+async function buildClientEnvironment(config) {
+  const logger = config.logger;
+  const outDir = path12.resolve(config.root, config.build.outDir);
+  if (config.build.emptyOutDir && fs9.existsSync(outDir)) {
+    fs9.rmSync(outDir, { recursive: true, force: true });
+  }
+  fs9.mkdirSync(outDir, { recursive: true });
+  const html = await readHtmlFile(config.root);
+  const entryPoints = resolveClientEntries(config, html);
+  if (entryPoints.length === 0) {
+    throw new Error("No entry point found. Add a <script> tag to index.html or create src/main.ts");
+  }
+  const cssEngine = createCssEngine();
+  const pluginList = resolvePluginList(config, config.plugins, { cssEngine });
+  const clientEnv = new NastiEnvironment("client", { ...config, plugins: pluginList }, {
+    mode: "build",
+    plugins: pluginList
+  });
+  await clientEnv.init();
+  const allPlugins = clientEnv.plugins;
+  const nativeReporter = config.logLevel === "silent" ? null : await tryNativeReporterPlugin(config, logger);
+  const rolldownPlugins = [
+    createOxcTransformPlugin(config, clientEnv),
+    ...toRolldownPlugins(allPlugins),
+    ...nativeReporter ? [nativeReporter] : []
+  ];
+  const { inputOptions, outputOptions } = getRolldownOptions(clientEnv, entryPoints, rolldownPlugins);
+  const bundle2 = await rolldown(inputOptions);
+  const { output } = await bundle2.write(outputOptions);
+  await bundle2.close();
+  if (html) {
+    let processedHtml = html;
+    const htmlPlugins = [...allPlugins.filter((p) => p.transformIndexHtml), htmlPlugin(config)];
+    for (const p of htmlPlugins) {
+      const result = await p.transformIndexHtml(processedHtml);
+      if (typeof result === "string") {
+        processedHtml = result;
+      } else if (result && "html" in result) {
+        processedHtml = processHtml(result.html, result.tags);
+      } else if (Array.isArray(result)) {
+        processedHtml = processHtml(processedHtml, result);
+      }
     }
-  };
+    processedHtml = injectCssLinks(processedHtml, cssEngine, config);
+    for (const chunk of output) {
+      if (chunk.type === "chunk" && chunk.isEntry && chunk.facadeModuleId) {
+        const originalEntry = path12.relative(config.root, chunk.facadeModuleId);
+        processedHtml = processedHtml.replace(
+          new RegExp(`(src=["'])/?(${escapeRegExp(originalEntry)})(["'])`, "g"),
+          `$1${config.base}${chunk.fileName}$3`
+        );
+      }
+    }
+    fs9.writeFileSync(path12.resolve(outDir, "index.html"), processedHtml);
+  }
+  if (!nativeReporter && config.logLevel !== "silent") {
+    reportBuildOutput(output, config, logger);
+  }
+  warnLargeChunks(output, config, logger);
+  return output;
 }
-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;
+async function buildServerEnvironment(config, name) {
+  const envOptions = config.environments[name];
+  const logger = config.logger;
+  for (const entry of envOptions.entry) {
+    if (!fs9.existsSync(entry)) {
+      throw new Error(`[nasti] environment "${name}" entry not found: ${entry}`);
     }
-    const resolved = path8.resolve(path8.dirname(from), url);
-    const relative = "/" + path8.relative(root, resolved);
-    return `url(${relative})`;
+  }
+  const pluginList = resolvePluginList(config, config.plugins, { consumer: envOptions.consumer });
+  const environment = new NastiEnvironment(name, { ...config, plugins: pluginList }, {
+    mode: "build",
+    plugins: pluginList
   });
-}
-var init_css = __esm({
-  "src/plugins/css.ts"() {
-    "use strict";
-    init_tailwind();
+  await environment.init();
+  const rolldownPlugins = [
+    createOxcTransformPlugin(config, environment),
+    ...toRolldownPlugins(environment.plugins)
+  ];
+  const { inputOptions, outputOptions, outDir } = getRolldownOptions(
+    environment,
+    envOptions.entry,
+    rolldownPlugins
+  );
+  if (envOptions.build.emptyOutDir && fs9.existsSync(outDir)) {
+    fs9.rmSync(outDir, { recursive: true, force: true });
   }
-});
-
-// src/plugins/assets.ts
-import path9 from "path";
-import fs7 from "fs";
-import crypto from "crypto";
-function assetsPlugin(config) {
-  return {
-    name: "nasti:assets",
-    resolveId(source) {
-      if (source.endsWith("?url") || source.endsWith("?raw")) {
-        return source;
-      }
-      return null;
-    },
-    load(id) {
-      const ext = path9.extname(id.replace(/\?.*$/, ""));
-      if (id.endsWith("?raw")) {
-        const file = id.slice(0, -4);
-        if (fs7.existsSync(file)) {
-          const content = fs7.readFileSync(file, "utf-8");
-          return `export default ${JSON.stringify(content)}`;
-        }
-      }
-      if (id.endsWith("?url") || ASSET_EXTENSIONS.has(ext)) {
-        const file = id.replace(/\?.*$/, "");
-        if (!fs7.existsSync(file)) return null;
-        if (config.command === "serve") {
-          const url = "/" + path9.relative(config.root, file);
-          return `export default ${JSON.stringify(url)}`;
-        }
-        const content = fs7.readFileSync(file);
-        const hash = crypto.createHash("sha256").update(content).digest("hex").slice(0, 8);
-        const basename = path9.basename(file, ext);
-        const hashedName = `${config.build.assetsDir}/${basename}.${hash}${ext}`;
-        return `export default ${JSON.stringify(config.base + hashedName)}`;
+  fs9.mkdirSync(outDir, { recursive: true });
+  const bundle2 = await rolldown(inputOptions);
+  const { output } = await bundle2.write(outputOptions);
+  await bundle2.close();
+  logger.info(
+    pc6.dim(`  [${name}] `) + output.map((o) => path12.join(envOptions.build.outDir, o.fileName)).join(pc6.dim(", "))
+  );
+  return output;
+}
+function injectCssLinks(html, cssEngine, config) {
+  const cssLinkTags = [];
+  if (cssEngine.singleFileName) {
+    cssLinkTags.push({
+      tag: "link",
+      attrs: { rel: "stylesheet", href: config.base + cssEngine.singleFileName },
+      injectTo: "head"
+    });
+  } else {
+    for (const files of cssEngine.entryCss.values()) {
+      for (const file of files) {
+        cssLinkTags.push({
+          tag: "link",
+          attrs: { rel: "stylesheet", href: config.base + file },
+          injectTo: "head"
+        });
       }
-      return null;
     }
-  };
+  }
+  return cssLinkTags.length > 0 ? processHtml(html, cssLinkTags) : html;
 }
-var ASSET_EXTENSIONS;
-var init_assets = __esm({
-  "src/plugins/assets.ts"() {
+function escapeRegExp(string) {
+  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+var debug5, NODE_BUILTINS2;
+var init_build = __esm({
+  "src/build/index.ts"() {
     "use strict";
-    ASSET_EXTENSIONS = /* @__PURE__ */ new Set([
-      ".png",
-      ".jpg",
-      ".jpeg",
-      ".gif",
-      ".svg",
-      ".ico",
-      ".webp",
-      ".avif",
-      ".mp4",
-      ".webm",
-      ".ogg",
-      ".mp3",
-      ".wav",
-      ".flac",
-      ".aac",
-      ".woff",
-      ".woff2",
-      ".eot",
-      ".ttf",
-      ".otf",
-      ".pdf",
-      ".txt"
-    ]);
+    init_config();
+    init_builtins();
+    init_environment();
+    init_css_engine();
+    init_html();
+    init_transformer();
+    init_env();
+    init_reporter();
+    init_debug();
+    debug5 = createDebugger("nasti:build");
+    NODE_BUILTINS2 = /* @__PURE__ */ new Set([...builtinModules2, ...builtinModules2.map((m) => `node:${m}`)]);
   }
 });
 
-// src/plugins/vue.ts
-import crypto2 from "crypto";
-async function loadVueCompiler() {
-  if (compiler) return compiler;
+// src/server/bundled/dev-engine.ts
+var dev_engine_exports = {};
+__export(dev_engine_exports, {
+  createBundledDevServer: () => createBundledDevServer
+});
+import path13 from "path";
+import crypto3 from "crypto";
+import { WebSocketServer as WsServer2 } from "ws";
+import pc7 from "picocolors";
+async function createBundledDevServer(opts) {
+  const { config, clientEnv, httpServer } = opts;
+  const logger = config.logger;
+  let devFn;
+  let refreshWrapperFn = null;
   try {
-    compiler = await import("@vue/compiler-sfc");
-    return compiler;
-  } catch {
-    return null;
+    const experimental = await import("rolldown/experimental");
+    devFn = experimental.dev;
+    if (typeof devFn !== "function") throw new Error("dev() export missing");
+    if (typeof experimental.viteReactRefreshWrapperPlugin === "function") {
+      refreshWrapperFn = experimental.viteReactRefreshWrapperPlugin;
+    }
+  } catch (err) {
+    throw new Error(
+      `[nasti] experimental.bundledDev requires rolldown's experimental dev() API (locked to the installed rc; got: ${err.message}). Remove --bundle / experimental.bundledDev to use the default unbundled dev server.`
+    );
   }
-}
-function vuePlugin(config) {
-  const isDev = config.command === "serve";
-  const descriptorCache = /* @__PURE__ */ new Map();
-  return {
-    name: "nasti:vue",
-    enforce: "pre",
-    async resolveId(source) {
-      if (VUE_QUERY_RE.test(source)) {
-        return source;
+  const html = await readHtmlFile(config.root);
+  const entryPoints = resolveClientEntries(config, html);
+  if (entryPoints.length === 0) {
+    throw new Error("No entry point found. Add a <script> tag to index.html or create src/main.ts");
+  }
+  const memoryFiles = new MemoryFiles();
+  const patches = new MemoryFiles();
+  const entryFileNames = /* @__PURE__ */ new Map();
+  const bundledClients = /* @__PURE__ */ new Map();
+  const useReactRefresh = config.framework !== "vue" && refreshWrapperFn != null;
+  const rolldownPlugins = [
+    ...useReactRefresh ? [
+      createReactRefreshRuntimePlugin(entryPoints),
+      createBundledOxcRefreshPlugin()
+    ] : [],
+    ...stripCatchAllLoad(toRolldownPlugins(clientEnv.plugins)),
+    ...useReactRefresh ? [
+      refreshWrapperFn({
+        cwd: config.root,
+        include: [/\.[jt]sx(\?.*)?$/],
+        exclude: [/node_modules/],
+        jsxImportSource: "react",
+        reactRefreshHost: ""
+      })
+    ] : []
+  ];
+  const { inputOptions, outputOptions } = getRolldownOptions(clientEnv, entryPoints, rolldownPlugins);
+  let fullReloadTimer = null;
+  const scheduleFullReload = () => {
+    if (fullReloadTimer) clearTimeout(fullReloadTimer);
+    fullReloadTimer = setTimeout(() => {
+      logger.info(pc7.green("page reload ") + pc7.dim("(bundled)"), { timestamp: true });
+      broadcast({ type: "hmr:reload" });
+    }, 30);
+  };
+  const broadcast = (payload) => {
+    const data = JSON.stringify(payload);
+    for (const ws of bundledClients.values()) {
+      if (ws.readyState === 1) ws.send(data);
+    }
+  };
+  const sendTo = (clientId, payload) => {
+    const ws = bundledClients.get(clientId);
+    if (ws && ws.readyState === 1) ws.send(JSON.stringify(payload));
+  };
+  async function processUpdates(updates, changedFiles) {
+    let needsLatestOutput = false;
+    for (const { clientId, update } of updates) {
+      if (update.type === "Noop") continue;
+      if (update.type === "FullReload") {
+        debug6?.(`full reload for ${clientId}: ${update.reason ?? ""}`);
+        needsLatestOutput = true;
+        continue;
+      }
+      const patchPath = `__nasti_patch/${update.filename}`;
+      patches.set(patchPath, update.code + "\n;export {}");
+      if (update.sourcemap && update.sourcemapFilename) {
+        patches.set(`__nasti_patch/${update.sourcemapFilename}`, update.sourcemap);
+      }
+      const url = `/${patchPath}`;
+      logger.info(
+        pc7.green("hmr update ") + pc7.dim(changedFiles.map((f) => path13.relative(config.root, f)).join(", ")),
+        { timestamp: true }
+      );
+      sendTo(clientId, { type: "hmr:update", path: url, url });
+    }
+    if (needsLatestOutput) {
+      await engine.ensureLatestBuildOutput();
+      scheduleFullReload();
+    }
+  }
+  const engine = await devFn(
+    {
+      ...inputOptions,
+      cwd: config.root,
+      // Rolldown bug 规避：inlineConst 与 dev patch 机制冲突（vitejs/vite#21843）
+      optimization: { ...inputOptions.optimization, inlineConst: false },
+      experimental: {
+        ...inputOptions.experimental,
+        devMode: {
+          lazy: true,
+          // 默认 DevRuntime 把 ws 地址烤进 bundle：指向 Nasti dev server 本身
+          //（端口被占自动 +1 时 HMR ws 会失联 —— 已知限制，产物仍可服务）
+          host: config.server.host === true ? "localhost" : config.server.host || "localhost",
+          port: config.server.port
+        }
       }
-      return null;
     },
-    async transform(code, id) {
-      if (!VUE_FILE_RE.test(id) && !VUE_QUERY_RE.test(id)) return null;
-      const sfc = await loadVueCompiler();
-      if (!sfc) {
-        console.warn("[nasti:vue] @vue/compiler-sfc not found. Install it: npm install @vue/compiler-sfc");
-        return null;
+    {
+      ...outputOptions,
+      entryFileNames: "assets/[name].js",
+      chunkFileNames: "assets/[name]-[hash].js",
+      minify: false,
+      sourcemap: true
+    },
+    {
+      watch: { skipWrite: true },
+      rebuildStrategy: "auto",
+      onOutput(result) {
+        if (result instanceof Error) {
+          logger.error(pc7.red(`[bundled] build error: ${result.message}`), { error: result });
+          return;
+        }
+        for (const file of result.output) {
+          const content = file.type === "chunk" ? file.code : file.source;
+          if (content != null) memoryFiles.set(file.fileName, content);
+          if (file.type === "chunk" && file.isEntry && file.facadeModuleId) {
+            entryFileNames.set(file.facadeModuleId, file.fileName);
+          }
+          if (file.type === "chunk" && file.map) {
+            memoryFiles.set(`${file.fileName}.map`, JSON.stringify(file.map));
+          }
+        }
+        debug6?.(`bundle output refreshed (${result.output.length} files)`);
+      },
+      async onHmrUpdates(result) {
+        if (result instanceof Error) {
+          logger.error(pc7.red(`[bundled] hmr error: ${result.message}`), { error: result });
+          broadcast({ type: "error", err: { message: result.message, stack: result.stack } });
+          return;
+        }
+        const { updates, changedFiles } = result;
+        debug6?.(
+          `onHmrUpdates(engine watcher): ${changedFiles.length} changed, ${updates.length} updates`
+        );
+        if (changedFiles.length === 0) return;
+        await processUpdates(updates, changedFiles);
       }
-      if (VUE_QUERY_RE.test(id)) {
-        return handleVueSubBlock(id, sfc, descriptorCache, config);
+    }
+  );
+  await engine.run();
+  await engine.ensureCurrentBuildFinish();
+  logger.info(pc7.dim(`  bundled dev engine ready (${entryPoints.length} entries, in-memory)`));
+  const wss = new WsServer2({ noServer: true });
+  httpServer.on("upgrade", (req, socket, head) => {
+    if (req.headers["sec-websocket-protocol"] === "nasti-hmr") return;
+    const url = new URL(req.url ?? "/", "http://localhost");
+    const clientId = url.searchParams.get("clientId");
+    if (!clientId) return;
+    wss.handleUpgrade(req, socket, head, (ws) => {
+      bundledClients.set(clientId, ws);
+      debug6?.(`bundled client connected: ${clientId}`);
+      ws.send(JSON.stringify({ type: "connected" }));
+      ws.on("message", async (raw) => {
+        try {
+          const msg = JSON.parse(String(raw));
+          if (msg.type === "hmr:module-registered" && Array.isArray(msg.modules)) {
+            await engine.registerModules(clientId, msg.modules);
+            debug6?.(`registered ${msg.modules.length} modules for ${clientId}`);
+          } else if (msg.type === "hmr:invalidate") {
+            scheduleFullReload();
+          }
+        } catch (err) {
+          debug6?.(`bundled ws message error: ${err.message}`);
+        }
+      });
+      ws.on("close", () => {
+        bundledClients.delete(clientId);
+        engine.removeClient(clientId).catch((err) => debug6?.(`removeClient failed for ${clientId}: ${err?.message ?? err}`));
+      });
+    });
+  });
+  const middleware = (req, res, next) => {
+    void (async () => {
+      const rawUrl = req.url ?? "/";
+      const url = new URL(rawUrl, "http://localhost");
+      const pathname = decodeURIComponent(url.pathname);
+      if (pathname === "/@vite/lazy" || pathname === "/@nasti/lazy") {
+        const id = url.searchParams.get("id");
+        const clientId = url.searchParams.get("clientId");
+        if (!id || !clientId) {
+          res.statusCode = 400;
+          res.end("// [nasti] lazy endpoint requires id & clientId");
+          return;
+        }
+        const code = await engine.compileEntry(id, clientId);
+        res.setHeader("Content-Type", "application/javascript");
+        res.setHeader("Cache-Control", "no-store");
+        res.end(code + "\n;export {}");
+        return;
       }
-      const { descriptor, errors } = sfc.parse(code, { filename: id });
-      if (errors.length) {
-        console.error(`[nasti:vue] Parse error in ${id}:`, errors[0].message);
-        return null;
+      const patchHit = patches.get(pathname.replace(/^\//, ""));
+      if (patchHit) {
+        res.setHeader("Content-Type", "application/javascript");
+        res.setHeader("Cache-Control", "no-store");
+        res.end(patchHit.content);
+        return;
       }
-      descriptorCache.set(id, descriptor);
-      const scopeId = hashId(id);
-      let scriptCode = "";
-      if (descriptor.script || descriptor.scriptSetup) {
-        const compiled = sfc.compileScript(descriptor, {
-          id: scopeId,
-          isProd: !isDev,
-          inlineTemplate: true,
-          // 让 compileScript 产出 `const __sfc__ = ...`（而非默认的 `export default {...}`）。
-          // 否则下方追加的 `__sfc__.render` / `__sfc__.__scopeId` / HMR 记录会引用一个
-          // 不存在的 `__sfc__`，并与 compileScript 自带的 `export default` 形成双重默认导出。
-          genDefaultAs: "__sfc__"
-        });
-        scriptCode = compiled.content;
+      const fileName = pathname.replace(/^\//, "");
+      const hit = memoryFiles.get(fileName);
+      if (hit) {
+        if (req.headers["if-none-match"] === hit.etag) {
+          res.statusCode = 304;
+          res.end();
+          return;
+        }
+        res.setHeader("ETag", hit.etag);
+        res.setHeader("Content-Type", MIME_TYPES[path13.extname(fileName)] ?? "application/octet-stream");
+        res.setHeader("Cache-Control", "no-cache");
+        res.end(hit.content);
+        return;
       }
-      let templateCode = "";
-      if (descriptor.template && !descriptor.scriptSetup) {
-        const compiled = sfc.compileTemplate({
-          source: descriptor.template.content,
-          filename: id,
-          id: scopeId,
-          compilerOptions: { scopeId: `data-v-${scopeId}` }
-        });
-        templateCode = compiled.code;
+      if (pathname === "/" || pathname.endsWith(".html")) {
+        const rawHtml = await readHtmlFile(config.root);
+        if (rawHtml) {
+          res.setHeader("Content-Type", "text/html");
+          res.setHeader("Cache-Control", "no-store");
+          res.end(await renderBundledIndexHtml(rawHtml, config, entryFileNames));
+          return;
+        }
       }
-      let output = scriptCode || "const __sfc__ = {}";
-      if (templateCode) {
-        output += `
-${templateCode}
-`;
-        output += `
-__sfc__.render = render
-`;
+      next();
+    })().catch((err) => {
+      config.logger.error(pc7.red(`[bundled] ${err.message}`), { error: err });
+      res.statusCode = 500;
+      res.end(`[nasti bundled] ${err.message}`);
+    });
+  };
+  return {
+    middleware,
+    async close() {
+      if (fullReloadTimer) clearTimeout(fullReloadTimer);
+      wss.close();
+      await engine.close();
+    }
+  };
+}
+function stripCatchAllLoad(plugins) {
+  return plugins.map(
+    (p) => p?.name === "nasti:resolve" ? { ...p, load: void 0 } : p
+  );
+}
+function createReactRefreshRuntimePlugin(entryPoints) {
+  const entryIds = new Set(entryPoints.map((p) => path13.resolve(p)));
+  return {
+    name: "nasti:bundled-react-refresh",
+    resolveId(source) {
+      if (source === REFRESH_RUNTIME_URL) return REFRESH_RUNTIME_URL;
+      if (source === PREAMBLE_SPEC) return RESOLVED_PREAMBLE_ID;
+      return null;
+    },
+    load(id) {
+      if (id === REFRESH_RUNTIME_URL) {
+        return { code: getReactRefreshRuntimeEsm() + WRAPPER_RUNTIME_HELPERS, moduleType: "js" };
       }
-      if (descriptor.styles.length > 0) {
-        for (let i = 0; i < descriptor.styles.length; i++) {
-          const style = descriptor.styles[i];
-          const lang2 = style.lang ?? "css";
-          output += `
-import "${id}?vue&type=style&index=${i}&lang=${lang2}"
-`;
-        }
+      if (id === RESOLVED_PREAMBLE_ID) {
+        return { code: BUNDLED_PREAMBLE_CODE, moduleType: "js" };
       }
-      output += `
-__sfc__.__scopeId = "data-v-${scopeId}"
-`;
-      if (isDev) {
-        output += `
-__sfc__.__hmrId = ${JSON.stringify(scopeId)}
-if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
-  __VUE_HMR_RUNTIME__.createRecord(__sfc__.__hmrId, __sfc__)
+      return null;
+    },
+    transform(code, id) {
+      if (!entryIds.has(path13.resolve(id.split("?")[0]))) return null;
+      return { code: `import ${JSON.stringify(PREAMBLE_SPEC)};
+${code}`, map: null };
+    }
+  };
 }
-if (import.meta.hot) {
-  import.meta.hot.accept((mod) => {
-    if (!mod) return
-    const { default: updated } = mod
-    if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
-      __VUE_HMR_RUNTIME__.rerender(updated.__hmrId, updated.render)
+function createBundledOxcRefreshPlugin() {
+  return {
+    name: "nasti:bundled-oxc-refresh",
+    transform(code, id) {
+      const clean = id.split("?")[0];
+      if (!/\.[jt]sx$/.test(clean) || clean.includes("/node_modules/")) return null;
+      const result = transformCode(clean, code, {
+        sourcemap: true,
+        jsxRuntime: "automatic",
+        jsxImportSource: "react",
+        reactRefresh: true
+      });
+      return { code: result.code, map: result.map ? JSON.parse(result.map) : void 0 };
     }
-  })
+  };
 }
-`;
+async function renderBundledIndexHtml(html, config, entryFileNames) {
+  let processed = html;
+  for (const plugin of config.plugins) {
+    if (!plugin.transformIndexHtml || plugin.name === "nasti:html") continue;
+    const result = await plugin.transformIndexHtml(processed);
+    if (typeof result === "string") {
+      processed = result;
+    } else if (result && "html" in result) {
+      processed = processHtml(result.html, result.tags);
+    } else if (Array.isArray(result)) {
+      processed = processHtml(processed, result);
+    }
+  }
+  for (const [facadeModuleId, fileName] of entryFileNames) {
+    const originalEntry = path13.relative(config.root, facadeModuleId);
+    processed = processed.replace(
+      new RegExp(`(src=["'])/?(${originalEntry.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")})(["'])`, "g"),
+      `$1/${fileName}$3`
+    );
+  }
+  return processed;
+}
+var debug6, 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";
+    init_build();
+    init_html();
+    init_transformer();
+    init_middleware();
+    init_debug();
+    debug6 = createDebugger("nasti:bundled");
+    MIME_TYPES = {
+      ".js": "application/javascript",
+      ".mjs": "application/javascript",
+      ".css": "text/css",
+      ".html": "text/html",
+      ".json": "application/json",
+      ".map": "application/json",
+      ".svg": "image/svg+xml",
+      ".png": "image/png",
+      ".jpg": "image/jpeg",
+      ".wasm": "application/wasm"
+    };
+    MemoryFiles = class {
+      files = /* @__PURE__ */ new Map();
+      set(fileName, content) {
+        const etag = `"${crypto3.createHash("sha1").update(content).digest("base64").slice(0, 27)}"`;
+        this.files.set(fileName, { content, etag });
       }
-      output += `
-export default __sfc__
-`;
-      const lang = descriptor.scriptSetup?.lang ?? descriptor.script?.lang;
-      if (lang === "ts") {
-        const transpiled = transformCode(`${id}.ts`, output, { sourcemap: false });
-        return { code: transpiled.code };
+      get(fileName) {
+        return this.files.get(fileName);
       }
-      return { code: output };
-    },
-    handleHotUpdate(ctx) {
-      const { file, modules } = ctx;
-      if (VUE_FILE_RE.test(file)) {
-        for (const mod of modules) {
-          mod.isSelfAccepting = true;
-        }
-        descriptorCache.delete(file);
+      clear() {
+        this.files.clear();
+      }
+    };
+    PREAMBLE_SPEC = "nasti:react-preamble";
+    RESOLVED_PREAMBLE_ID = "\0nasti:react-preamble";
+    REFRESH_RUNTIME_URL = "/@react-refresh";
+    BUNDLED_PREAMBLE_CODE = `
+import __rt from ${JSON.stringify(REFRESH_RUNTIME_URL)};
+__rt.injectIntoGlobalHook(window);
+window.$RefreshReg$ = () => {};
+window.$RefreshSig$ = () => (type) => type;
+window.__vite_plugin_react_preamble_installed__ = true;
+`;
+    WRAPPER_RUNTIME_HELPERS = `
+// \u2500\u2500 viteReactRefreshWrapperPlugin \u8FD0\u884C\u65F6\u5951\u7EA6\uFF08@vitejs/plugin-react \u540C\u6B3E\uFF09\u2500\u2500
+function __isPlainObject(obj) {
+  return Object.prototype.toString.call(obj) === '[object Object]' &&
+    (obj.constructor === Object || obj.constructor === undefined);
+}
+function __isCompoundComponent(type) {
+  if (!__isPlainObject(type)) return false;
+  for (const key in type) {
+    if (!isLikelyComponentType(type[key])) return false;
+  }
+  return true;
+}
+export function registerExportsForReactRefresh(filename, moduleExports) {
+  for (const key in moduleExports) {
+    if (key === '__esModule') continue;
+    const exportValue = moduleExports[key];
+    if (isLikelyComponentType(exportValue)) {
+      register(exportValue, filename + ' export ' + key);
+    } else if (__isCompoundComponent(exportValue)) {
+      for (const subKey in exportValue) {
+        register(exportValue[subKey], filename + ' export ' + key + '-' + subKey);
       }
-      return modules;
     }
-  };
+  }
 }
-async function handleVueSubBlock(id, sfc, cache, config) {
-  const match = id.match(/(.+\.vue)\?vue&type=(\w+)(?:&index=(\d+))?(?:&lang=(\w+))?/);
-  if (!match) return null;
-  const [, filePath, type, indexStr, lang] = match;
-  const descriptor = cache.get(filePath);
-  if (!descriptor) return null;
-  if (type === "style") {
-    const index = parseInt(indexStr ?? "0", 10);
-    const style = descriptor.styles[index];
-    if (!style) return null;
-    const scopeId = hashId(filePath);
-    const result = await sfc.compileStyleAsync({
-      source: style.content,
-      filename: filePath,
-      id: `data-v-${scopeId}`,
-      scoped: style.scoped ?? false
-    });
-    const cssCode = JSON.stringify(result.code);
-    return {
-      code: `
-const css = ${cssCode};
-const style = document.createElement('style');
-style.setAttribute('data-v-${scopeId}', '');
-style.textContent = css;
-document.head.appendChild(style);
-
-if (import.meta.hot) {
-  import.meta.hot.accept();
-  import.meta.hot.prune(() => style.remove());
+let __enqueueTimer;
+const __hooks = [];
+window.__registerBeforePerformReactRefresh = (cb) => { __hooks.push(cb); };
+function __enqueueUpdate() {
+  clearTimeout(__enqueueTimer);
+  __enqueueTimer = setTimeout(async () => {
+    if (__hooks.length) await Promise.all(__hooks.map((cb) => cb()));
+    performReactRefresh();
+  }, 16);
 }
-`
-    };
+function __predicateOnExport(ignoredExports, moduleExports, predicate) {
+  for (const key in moduleExports) {
+    if (ignoredExports.includes(key)) continue;
+    if (!predicate(key, moduleExports[key])) return key;
   }
-  return null;
+  return true;
 }
-function hashId(filename) {
-  return crypto2.createHash("sha256").update(filename).digest("hex").slice(0, 8);
+export function validateRefreshBoundaryAndEnqueueUpdate(id, prevExports, nextExports) {
+  const ignoredExports = window.__getReactRefreshIgnoredExports?.({ id }) ?? [];
+  if (__predicateOnExport(ignoredExports, prevExports, (key) => key in nextExports) !== true) {
+    return 'Could not Fast Refresh (export removed)';
+  }
+  if (__predicateOnExport(ignoredExports, nextExports, (key) => key in prevExports) !== true) {
+    return 'Could not Fast Refresh (new export)';
+  }
+  let hasExports = false;
+  const allExportsAreComponentsOrUnchanged = __predicateOnExport(
+    ignoredExports,
+    nextExports,
+    (key, value) => {
+      hasExports = true;
+      if (isLikelyComponentType(value)) return true;
+      if (__isCompoundComponent(value)) return true;
+      return prevExports[key] === nextExports[key];
+    },
+  );
+  if (hasExports && allExportsAreComponentsOrUnchanged === true) {
+    __enqueueUpdate();
+  } else {
+    return 'Could not Fast Refresh ("' + allExportsAreComponentsOrUnchanged + '" export is incompatible)';
+  }
 }
-var VUE_FILE_RE, VUE_QUERY_RE, compiler;
-var init_vue = __esm({
-  "src/plugins/vue.ts"() {
-    "use strict";
-    init_transformer();
-    VUE_FILE_RE = /\.vue$/;
-    VUE_QUERY_RE = /\.vue\?vue&type=(script|template|style)(&index=\d+)?(&lang=\w+)?/;
-    compiler = null;
+export const __hmr_import = (module) => import(/* @vite-ignore */ module);
+`;
   }
 });
 
@@ -2061,45 +4649,78 @@ __export(server_exports, {
   createServer: () => createServer
 });
 import http from "http";
-import path10 from "path";
+import path14 from "path";
 import os from "os";
 import connect from "connect";
 import sirv from "sirv";
 import { watch } from "chokidar";
-import pc from "picocolors";
+import pc8 from "picocolors";
 async function createServer(inlineConfig = {}) {
+  const startTime = performance.now();
   const config = await resolveConfig(inlineConfig, "serve");
-  const allPlugins = [
-    ...config.framework === "vue" ? [vuePlugin(config)] : [],
-    resolvePlugin(config),
-    cssPlugin(config),
-    assetsPlugin(config),
-    htmlPlugin(config),
-    ...config.plugins
-  ];
+  const logger = config.logger;
+  const allPlugins = resolvePluginList(config, config.plugins);
   const configWithPlugins = { ...config, plugins: allPlugins };
-  const moduleGraph = new ModuleGraph();
-  const pluginContainer = new PluginContainer(configWithPlugins);
   const app = connect();
+  const httpServer = http.createServer(app);
+  const ws = createWebSocketServer(httpServer);
+  const clientEnv = new NastiEnvironment("client", configWithPlugins, {
+    hot: createWsHotChannel(ws),
+    mode: "dev",
+    plugins: allPlugins
+  });
+  await clientEnv.init();
+  const environments = { client: clientEnv };
+  for (const name of Object.keys(config.environments)) {
+    if (name === "client") continue;
+    const consumer = config.environments[name].consumer;
+    const envPlugins = resolvePluginList(config, config.plugins, { consumer });
+    environments[name] = new NastiEnvironment(name, { ...config, plugins: envPlugins }, {
+      mode: "dev",
+      plugins: envPlugins
+    });
+  }
+  let ssrRunner = null;
+  async function getSsrRunner() {
+    if (ssrRunner) return ssrRunner;
+    const ssrEnv = environments.ssr;
+    if (!ssrEnv) {
+      throw new Error('[nasti] no "ssr" environment configured (config.environments.ssr)');
+    }
+    await ssrEnv.init();
+    const { createModuleRunner: createModuleRunner2 } = await Promise.resolve().then(() => (init_runnable_environment(), runnable_environment_exports));
+    ssrRunner = createModuleRunner2(ssrEnv);
+    return ssrRunner;
+  }
+  const moduleGraph = clientEnv.moduleGraph;
+  const pluginContainer = clientEnv.pluginContainer;
+  let bundledServer = null;
+  if (config.experimental.bundledDev) {
+    const { createBundledDevServer: createBundledDevServer2 } = await Promise.resolve().then(() => (init_dev_engine(), dev_engine_exports));
+    bundledServer = await createBundledDevServer2({
+      config: configWithPlugins,
+      clientEnv,
+      httpServer
+    });
+    app.use(bundledServer.middleware);
+  }
   app.use(transformMiddleware({
     config: configWithPlugins,
     pluginContainer,
     moduleGraph
   }));
-  const publicDir = path10.resolve(config.root, "public");
+  const publicDir = path14.resolve(config.root, "public");
   app.use(sirv(publicDir, { dev: true, etag: true }));
   app.use(sirv(config.root, { dev: true, etag: true }));
-  const httpServer = http.createServer(app);
-  const ws = createWebSocketServer(httpServer);
   const ignoredSegments = /* @__PURE__ */ new Set(["node_modules", ".git", ".nasti"]);
-  const outDirAbs = path10.resolve(config.root, config.build.outDir);
+  const outDirAbs = path14.resolve(config.root, config.build.outDir);
   const watcher = watch(config.root, {
     ignored: (filePath) => {
       if (filePath === config.root) return false;
-      if (filePath === outDirAbs || filePath.startsWith(outDirAbs + path10.sep)) return true;
-      const rel = path10.relative(config.root, filePath);
-      if (!rel || rel.startsWith("..") || path10.isAbsolute(rel)) return false;
-      for (const seg of rel.split(path10.sep)) {
+      if (filePath === outDirAbs || filePath.startsWith(outDirAbs + path14.sep)) return true;
+      const rel = path14.relative(config.root, filePath);
+      if (!rel || rel.startsWith("..") || path14.isAbsolute(rel)) return false;
+      for (const seg of rel.split(path14.sep)) {
         if (ignoredSegments.has(seg)) return true;
       }
       return false;
@@ -2108,9 +4729,11 @@ async function createServer(inlineConfig = {}) {
   });
   let server;
   watcher.on("change", (file) => {
+    ssrRunner?.invalidateFile(file);
     handleFileChange(file, server);
   });
   watcher.on("add", (file) => {
+    ssrRunner?.invalidateFile(file);
     handleFileChange(file, server);
   });
   server = {
@@ -2119,6 +4742,7 @@ async function createServer(inlineConfig = {}) {
     moduleGraph,
     watcher,
     ws,
+    environments,
     async listen(port) {
       const finalPort = port ?? config.server.port;
       const host = config.server.host === true ? "0.0.0.0" : config.server.host;
@@ -2128,23 +4752,27 @@ async function createServer(inlineConfig = {}) {
         const onListening = () => {
           const actualPort = httpServer.address()?.port ?? currentPort;
           config.server.port = actualPort;
-          const localUrl = `http://localhost:${actualPort}`;
-          const networkUrl = host === "0.0.0.0" ? `http://${getNetworkAddress()}:${actualPort}` : null;
-          console.log();
-          console.log(pc.cyan("  nasti dev server") + pc.dim(` v${"1.7.1"}`));
-          console.log();
-          console.log(`  ${pc.green(">")} Local:   ${pc.cyan(localUrl)}`);
-          if (networkUrl) {
-            console.log(`  ${pc.green(">")} Network: ${pc.cyan(networkUrl)}`);
-          }
-          console.log();
+          const localUrl = `http://localhost:${actualPort}/`;
+          const networkUrl = host === "0.0.0.0" ? `http://${getNetworkAddress()}:${actualPort}/` : null;
+          logger.clearScreen("info");
+          const readyIn = Math.ceil(performance.now() - startTime);
+          logger.info(
+            `
+  ${pc8.cyan(pc8.bold("NASTI"))} ${pc8.cyan(`v${"2.0.1"}`)}  ${pc8.dim("ready in")} ${pc8.bold(readyIn)} ${pc8.dim("ms")}
+`
+          );
+          printServerUrls(
+            { local: [localUrl], network: networkUrl ? [networkUrl] : [] },
+            logger.info
+          );
+          logger.info("");
           resolve(server);
         };
         httpServer.on("listening", onListening);
         httpServer.on("error", (err) => {
           if (err.code === "EADDRINUSE") {
             currentPort++;
-            console.log(pc.yellow(`Port ${currentPort - 1} is in use, trying ${currentPort}...`));
+            logger.info(pc8.yellow(`Port ${currentPort - 1} is in use, trying ${currentPort}...`));
             httpServer.listen(currentPort, host);
           } else {
             reject(err);
@@ -2157,8 +4785,13 @@ async function createServer(inlineConfig = {}) {
       const { transformRequest: transformRequest2 } = await Promise.resolve().then(() => (init_middleware(), middleware_exports));
       return transformRequest2(url, { config: configWithPlugins, pluginContainer, moduleGraph });
     },
+    async ssrLoadModule(url) {
+      const runner = await getSsrRunner();
+      return runner.import(url);
+    },
     async close() {
       await pluginContainer.buildEnd();
+      await bundledServer?.close();
       watcher.close();
       ws.close();
       httpServer.close();
@@ -2191,25 +4824,22 @@ var init_server = __esm({
   "src/server/index.ts"() {
     "use strict";
     init_config();
-    init_plugin_container();
-    init_module_graph();
+    init_environment();
+    init_hot_channel();
+    init_logger();
     init_ws();
     init_middleware();
     init_hmr();
-    init_resolve();
-    init_css();
-    init_assets();
-    init_vue();
-    init_html();
+    init_builtins();
   }
 });
 
 // src/plugins/electron.ts
-import { builtinModules } from "module";
+import { builtinModules as builtinModules3 } from "module";
 function electronPlugin(config) {
   const external = /* @__PURE__ */ new Set([
     ...ELECTRON_MODULES,
-    ...NODE_BUILTINS,
+    ...NODE_BUILTINS3,
     ...config.electron.external ?? []
   ]);
   return {
@@ -2226,13 +4856,13 @@ function electronPlugin(config) {
     }
   };
 }
-var NODE_BUILTINS, ELECTRON_MODULES;
+var NODE_BUILTINS3, ELECTRON_MODULES;
 var init_electron = __esm({
   "src/plugins/electron.ts"() {
     "use strict";
-    NODE_BUILTINS = /* @__PURE__ */ new Set([
-      ...builtinModules,
-      ...builtinModules.map((m) => `node:${m}`)
+    NODE_BUILTINS3 = /* @__PURE__ */ new Set([
+      ...builtinModules3,
+      ...builtinModules3.map((m) => `node:${m}`)
     ]);
     ELECTRON_MODULES = /* @__PURE__ */ new Set([
       "electron",
@@ -2243,179 +4873,6 @@ var init_electron = __esm({
   }
 });
 
-// src/build/index.ts
-var build_exports = {};
-__export(build_exports, {
-  build: () => build
-});
-import path11 from "path";
-import fs8 from "fs";
-import { rolldown } from "rolldown";
-import pc2 from "picocolors";
-async function build(inlineConfig = {}) {
-  const config = await resolveConfig(inlineConfig, "build");
-  const startTime = performance.now();
-  console.log(pc2.cyan("\n\u{1F528} nasti build") + pc2.dim(` v${"1.7.1"}`));
-  console.log(pc2.dim(`  root: ${config.root}`));
-  console.log(pc2.dim(`  mode: ${config.mode}`));
-  const outDir = path11.resolve(config.root, config.build.outDir);
-  if (config.build.emptyOutDir && fs8.existsSync(outDir)) {
-    fs8.rmSync(outDir, { recursive: true, force: true });
-  }
-  fs8.mkdirSync(outDir, { recursive: true });
-  const html = await readHtmlFile(config.root);
-  let entryPoints = [];
-  if (html) {
-    const scriptMatches = html.matchAll(/<script[^>]+src=["']([^"']+)["'][^>]*>/gi);
-    for (const match of scriptMatches) {
-      const src = match[1];
-      if (src && !src.startsWith("http")) {
-        entryPoints.push(path11.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 = path11.resolve(config.root, entry);
-      if (fs8.existsSync(fullPath)) {
-        entryPoints.push(fullPath);
-        break;
-      }
-    }
-  }
-  if (entryPoints.length === 0) {
-    throw new Error("No entry point found. Add a <script> tag to index.html or create src/main.ts");
-  }
-  const builtinPlugins = [
-    ...config.framework === "vue" ? [vuePlugin(config)] : [],
-    resolvePlugin(config),
-    cssPlugin(config),
-    assetsPlugin(config)
-  ];
-  const allPlugins = [...builtinPlugins, ...config.plugins];
-  const pluginContainer = new PluginContainer(config);
-  await pluginContainer.buildStart();
-  const oxcTransformPlugin = {
-    name: "nasti:oxc-transform",
-    transform(code, id) {
-      if (!shouldTransform(id)) return null;
-      const result = transformCode(id, code, {
-        sourcemap: !!config.build.sourcemap,
-        jsxRuntime: "automatic",
-        jsxImportSource: config.framework === "vue" ? "vue" : "react"
-      });
-      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 { output: userOutput, transform: userTransform, ...restInputOptions } = config.build.rolldownOptions;
-  const vueDefine = config.framework === "vue" ? {
-    __VUE_OPTIONS_API__: "true",
-    __VUE_PROD_DEVTOOLS__: "false",
-    __VUE_PROD_HYDRATION_MISMATCH_DETAILS__: "false"
-  } : {};
-  const mergedDefine = { ...vueDefine, ...userTransform?.define ?? {}, ...envDefine };
-  const bundle = await rolldown({
-    ...restInputOptions,
-    input: entryPoints,
-    transform: { ...userTransform, define: mergedDefine },
-    plugins: [
-      oxcTransformPlugin,
-      // 转换 Nasti 插件为 Rolldown 插件格式
-      ...allPlugins.map((p) => ({
-        name: p.name,
-        resolveId: p.resolveId,
-        load: p.load,
-        transform: p.transform,
-        buildStart: p.buildStart,
-        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
-      }))
-    ]
-  });
-  const { output } = await bundle.write({
-    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]",
-    // 用户可覆盖默认输出：代码拆分（advancedChunks / codeSplitting）、chunk 命名等
-    ...userOutput,
-    // dir 始终由 Nasti 掌管 —— 下方 HTML 改写依赖固定的产物目录，故放在最后强制生效
-    dir: outDir
-  });
-  await bundle.close();
-  await pluginContainer.buildEnd();
-  for (const ef of pluginContainer.getEmittedFiles()) {
-    const dest = path11.resolve(outDir, ef.fileName);
-    fs8.mkdirSync(path11.dirname(dest), { recursive: true });
-    fs8.writeFileSync(dest, ef.source);
-  }
-  if (html) {
-    let processedHtml = html;
-    const htmlPlugin_ = htmlPlugin(config);
-    if (htmlPlugin_.transformIndexHtml) {
-      const result = await htmlPlugin_.transformIndexHtml(processedHtml);
-      if (typeof result === "string") {
-        processedHtml = result;
-      } else if (result && "html" in result) {
-        processedHtml = processHtml(result.html, result.tags);
-      } else if (Array.isArray(result)) {
-        processedHtml = processHtml(processedHtml, result);
-      }
-    }
-    for (const chunk of output) {
-      if (chunk.type === "chunk" && chunk.isEntry && chunk.facadeModuleId) {
-        const originalEntry = path11.relative(config.root, chunk.facadeModuleId);
-        processedHtml = processedHtml.replace(
-          new RegExp(`(src=["'])/?(${escapeRegExp(originalEntry)})(["'])`, "g"),
-          `$1${config.base}${chunk.fileName}$3`
-        );
-      }
-    }
-    fs8.writeFileSync(path11.resolve(outDir, "index.html"), processedHtml);
-  }
-  const elapsed = ((performance.now() - startTime) / 1e3).toFixed(2);
-  const totalSize = output.reduce((sum, chunk) => {
-    if (chunk.type === "chunk" && chunk.code) return sum + chunk.code.length;
-    return sum;
-  }, 0);
-  console.log(pc2.green(`
-\u2713 Built in ${elapsed}s`));
-  console.log(pc2.dim(`  ${output.length} files, ${formatSize(totalSize)} total`));
-  console.log(pc2.dim(`  output: ${config.build.outDir}/
-`));
-  return { output };
-}
-function formatSize(bytes) {
-  if (bytes < 1024) return `${bytes} B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(2)} kB`;
-  return `${(bytes / 1024 / 1024).toFixed(2)} MB`;
-}
-function escapeRegExp(string) {
-  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-var init_build = __esm({
-  "src/build/index.ts"() {
-    "use strict";
-    init_config();
-    init_resolve();
-    init_css();
-    init_assets();
-    init_vue();
-    init_html();
-    init_transformer();
-    init_env();
-    init_plugin_container();
-  }
-});
-
 // src/build/electron.ts
 var electron_exports = {};
 __export(electron_exports, {
@@ -2423,24 +4880,24 @@ __export(electron_exports, {
   detectInstalledElectron: () => detectInstalledElectron,
   normalizePreload: () => normalizePreload
 });
-import path12 from "path";
-import fs9 from "fs";
+import path15 from "path";
+import fs10 from "fs";
 import { rolldown as rolldown2 } from "rolldown";
-import pc3 from "picocolors";
+import pc9 from "picocolors";
 async function buildElectron(inlineConfig = {}) {
   const config = await resolveConfig({ ...inlineConfig, target: "electron" }, "build");
   const startTime = performance.now();
   assertElectronVersion(config);
-  console.log(pc3.cyan("\n\u26A1 nasti build (electron)") + pc3.dim(` v${"1.7.1"}`));
-  console.log(pc3.dim(`  root: ${config.root}`));
-  console.log(pc3.dim(`  mode: ${config.mode}`));
-  console.log(pc3.dim(`  target: electron (\u2265 ${config.electron.minVersion})`));
-  const outDir = path12.resolve(config.root, config.build.outDir);
-  if (config.build.emptyOutDir && fs9.existsSync(outDir)) {
-    fs9.rmSync(outDir, { recursive: true, force: true });
+  console.log(pc9.cyan("\n\u26A1 nasti build (electron)") + pc9.dim(` v${"2.0.1"}`));
+  console.log(pc9.dim(`  root: ${config.root}`));
+  console.log(pc9.dim(`  mode: ${config.mode}`));
+  console.log(pc9.dim(`  target: electron (\u2265 ${config.electron.minVersion})`));
+  const outDir = path15.resolve(config.root, config.build.outDir);
+  if (config.build.emptyOutDir && fs10.existsSync(outDir)) {
+    fs10.rmSync(outDir, { recursive: true, force: true });
   }
-  fs9.mkdirSync(outDir, { recursive: true });
-  const rendererOutDir = path12.join(outDir, "renderer");
+  fs10.mkdirSync(outDir, { recursive: true });
+  const rendererOutDir = path15.join(outDir, "renderer");
   const { build: build2 } = await Promise.resolve().then(() => (init_build(), build_exports));
   await build2({
     ...inlineConfig,
@@ -2451,8 +4908,8 @@ async function buildElectron(inlineConfig = {}) {
       emptyOutDir: false
     }
   });
-  const mainEntry = path12.resolve(config.root, config.electron.main);
-  if (!fs9.existsSync(mainEntry)) {
+  const mainEntry = path15.resolve(config.root, config.electron.main);
+  if (!fs10.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`
@@ -2466,11 +4923,11 @@ async function buildElectron(inlineConfig = {}) {
   const preloadEntries = normalizePreload(config.electron.preload, config.root);
   const preloadFiles = [];
   for (const entry of preloadEntries) {
-    if (!fs9.existsSync(entry)) {
-      console.warn(pc3.yellow(`  \u26A0 preload entry not found, skipped: ${entry}`));
+    if (!fs10.existsSync(entry)) {
+      console.warn(pc9.yellow(`  \u26A0 preload entry not found, skipped: ${entry}`));
       continue;
     }
-    const base = path12.basename(entry).replace(/\.[^.]+$/, "");
+    const base = path15.basename(entry).replace(/\.[^.]+$/, "");
     const out = outFileName(outDir, base, config.electron.preloadFormat);
     await bundleNode(config, entry, {
       outFile: out,
@@ -2480,12 +4937,12 @@ async function buildElectron(inlineConfig = {}) {
     preloadFiles.push(out);
   }
   const elapsed = ((performance.now() - startTime) / 1e3).toFixed(2);
-  console.log(pc3.green(`
+  console.log(pc9.green(`
 \u2713 Electron build complete in ${elapsed}s`));
-  console.log(pc3.dim(`  renderer: ${path12.relative(config.root, rendererOutDir)}/`));
-  console.log(pc3.dim(`  main:     ${path12.relative(config.root, mainFile)}`));
+  console.log(pc9.dim(`  renderer: ${path15.relative(config.root, rendererOutDir)}/`));
+  console.log(pc9.dim(`  main:     ${path15.relative(config.root, mainFile)}`));
   for (const pf of preloadFiles) {
-    console.log(pc3.dim(`  preload:  ${path12.relative(config.root, pf)}`));
+    console.log(pc9.dim(`  preload:  ${path15.relative(config.root, pf)}`));
   }
   console.log();
   return { rendererOutDir, mainFile, preloadFiles };
@@ -2511,15 +4968,15 @@ async function bundleNode(config, entry, opts) {
   };
   const { output: userOutput, transform: userTransform, ...restInputOptions } = config.build.rolldownOptions;
   const mergedDefine = { ...userTransform?.define ?? {}, ...envDefine };
-  const bundle = await rolldown2({
+  const bundle2 = await rolldown2({
     ...restInputOptions,
     input: entry,
     platform: "node",
     transform: { ...userTransform, define: mergedDefine },
     plugins: [oxcTransformPlugin, electronPlugin(config), resolvePlugin(config)]
   });
-  fs9.mkdirSync(path12.dirname(opts.outFile), { recursive: true });
-  await bundle.write({
+  fs10.mkdirSync(path15.dirname(opts.outFile), { recursive: true });
+  await bundle2.write({
     sourcemap: !!config.build.sourcemap,
     minify: !!config.build.minify,
     // 允许用户微调 output；但主进程 / preload 的单文件约束由下方键强制保证
@@ -2528,24 +4985,24 @@ async function bundleNode(config, entry, opts) {
     format: opts.format === "cjs" ? "cjs" : "esm",
     codeSplitting: false
   });
-  await bundle.close();
-  console.log(pc3.dim(`  \u2713 ${opts.label} \u2192 ${path12.relative(config.root, opts.outFile)}`));
+  await bundle2.close();
+  console.log(pc9.dim(`  \u2713 ${opts.label} \u2192 ${path15.relative(config.root, opts.outFile)}`));
   return opts.outFile;
 }
 function outFileName(outDir, base, format) {
   const ext = format === "cjs" ? ".cjs" : ".mjs";
-  return path12.join(outDir, base + ext);
+  return path15.join(outDir, base + ext);
 }
 function normalizePreload(preload, root) {
   const list = Array.isArray(preload) ? preload : preload ? [preload] : [];
-  return list.map((p) => path12.resolve(root, p));
+  return list.map((p) => path15.resolve(root, p));
 }
 function assertElectronVersion(config) {
   const min = config.electron.minVersion;
   const installed = detectInstalledElectron(config.root);
   if (installed && installed < min) {
     console.warn(
-      pc3.yellow(
+      pc9.yellow(
         `  \u26A0 \u68C0\u6D4B\u5230 Electron ${installed}\uFF0CNasti \u8981\u6C42 \u2265 ${min}\u3002\u65E7\u7248\u672C\u53EF\u80FD\u7F3A\u5C11 ESM \u4E3B\u8FDB\u7A0B\u652F\u6301\u3002`
       )
     );
@@ -2553,9 +5010,9 @@ function assertElectronVersion(config) {
 }
 function detectInstalledElectron(root) {
   try {
-    const pkgPath = path12.resolve(root, "node_modules/electron/package.json");
-    if (!fs9.existsSync(pkgPath)) return null;
-    const pkg = JSON.parse(fs9.readFileSync(pkgPath, "utf-8"));
+    const pkgPath = path15.resolve(root, "node_modules/electron/package.json");
+    if (!fs10.existsSync(pkgPath)) return null;
+    const pkg = JSON.parse(fs10.readFileSync(pkgPath, "utf-8"));
     const major = parseInt(String(pkg.version).split(".")[0], 10);
     return Number.isFinite(major) ? major : null;
   } catch {
@@ -2578,28 +5035,28 @@ var electron_dev_exports = {};
 __export(electron_dev_exports, {
   startElectronDev: () => startElectronDev
 });
-import path13 from "path";
-import fs10 from "fs";
-import { createRequire as createRequire4 } from "module";
+import path16 from "path";
+import fs11 from "fs";
+import { createRequire as createRequire5 } from "module";
 import { spawn } from "child_process";
 import chokidar from "chokidar";
-import pc4 from "picocolors";
+import pc10 from "picocolors";
 import { rolldown as rolldown3 } from "rolldown";
 async function startElectronDev(inlineConfig = {}) {
   const { noSpawn, ...rest } = inlineConfig;
   const config = await resolveConfig({ ...rest, target: "electron" }, "serve");
   warnElectronVersion(config);
-  console.log(pc4.cyan("\n\u26A1 nasti electron dev") + pc4.dim(` v${"1.7.1"}`));
+  console.log(pc10.cyan("\n\u26A1 nasti electron dev") + pc10.dim(` v${"2.0.1"}`));
   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(pc4.dim(`  renderer: ${devUrl}`));
-  const stageDir = path13.resolve(config.root, ".nasti");
-  fs10.mkdirSync(stageDir, { recursive: true });
-  const mainEntry = path13.resolve(config.root, config.electron.main);
+  console.log(pc10.dim(`  renderer: ${devUrl}`));
+  const stageDir = path16.resolve(config.root, ".nasti");
+  fs11.mkdirSync(stageDir, { recursive: true });
+  const mainEntry = path16.resolve(config.root, config.electron.main);
   const preloadEntries = normalizePreload(config.electron.preload, config.root);
-  const builtMainFile = path13.join(stageDir, "main" + extFor(config.electron.mainFormat));
+  const builtMainFile = path16.join(stageDir, "main" + extFor(config.electron.mainFormat));
   const builtPreloadFiles = [];
   const compileAll = async () => {
     await compileNode(config, mainEntry, {
@@ -2609,9 +5066,9 @@ async function startElectronDev(inlineConfig = {}) {
     });
     builtPreloadFiles.length = 0;
     for (const entry of preloadEntries) {
-      if (!fs10.existsSync(entry)) continue;
-      const base = path13.basename(entry).replace(/\.[^.]+$/, "");
-      const out = path13.join(stageDir, base + extFor(config.electron.preloadFormat));
+      if (!fs11.existsSync(entry)) continue;
+      const base = path16.basename(entry).replace(/\.[^.]+$/, "");
+      const out = path16.join(stageDir, base + extFor(config.electron.preloadFormat));
       await compileNode(config, entry, {
         outFile: out,
         format: config.electron.preloadFormat,
@@ -2622,13 +5079,13 @@ async function startElectronDev(inlineConfig = {}) {
   };
   await compileAll();
   if (noSpawn) {
-    console.log(pc4.dim("  (noSpawn) \u5DF2\u7F16\u8BD1\u4E3B/preload\uFF0C\u8DF3\u8FC7\u542F\u52A8 Electron\u3002"));
+    console.log(pc10.dim("  (noSpawn) \u5DF2\u7F16\u8BD1\u4E3B/preload\uFF0C\u8DF3\u8FC7\u542F\u52A8 Electron\u3002"));
     return;
   }
   const electronBin = resolveElectronBinary(config);
   if (!electronBin) {
     console.warn(
-      pc4.yellow(
+      pc10.yellow(
         "  \u26A0 \u672A\u627E\u5230 Electron \u53EF\u6267\u884C\u6587\u4EF6\uFF0C\u8BF7\u5148\u5B89\u88C5\uFF1Anpm install -D electron\n    \u5DF2\u7F16\u8BD1\u4E3B/preload \u81F3 .nasti/\uFF0C\u53EF\u624B\u52A8\u8FD0\u884C\u3002"
       )
     );
@@ -2643,14 +5100,14 @@ async function startElectronDev(inlineConfig = {}) {
     });
     child.on("exit", (code) => {
       if (code !== null && child && child.__nastiKilled !== true) {
-        console.log(pc4.dim(`  Electron exited (${code}).`));
+        console.log(pc10.dim(`  Electron exited (${code}).`));
         process.exit(code ?? 0);
       }
     });
   };
   spawnElectron();
   if (config.electron.autoRestart) {
-    const watchTargets = [mainEntry, ...preloadEntries].filter(fs10.existsSync);
+    const watchTargets = [mainEntry, ...preloadEntries].filter(fs11.existsSync);
     const watcher = chokidar.watch(watchTargets, { ignoreInitial: true });
     let restarting = null;
     let pending = false;
@@ -2662,7 +5119,7 @@ async function startElectronDev(inlineConfig = {}) {
       restarting = (async () => {
         do {
           pending = false;
-          console.log(pc4.cyan("\n  \u267B \u4E3B/preload \u53D8\u66F4\uFF0C\u91CD\u542F Electron..."));
+          console.log(pc10.cyan("\n  \u267B \u4E3B/preload \u53D8\u66F4\uFF0C\u91CD\u542F Electron..."));
           if (child && !child.killed) {
             ;
             child.__nastiKilled = true;
@@ -2680,7 +5137,7 @@ async function startElectronDev(inlineConfig = {}) {
             await compileAll();
             spawnElectron();
           } catch (e) {
-            console.warn(pc4.yellow(`  \u26A0 \u91CD\u542F\u7F16\u8BD1\u5931\u8D25\uFF0C\u4FDD\u7559\u4E0A\u4E00\u6B21\u8FDB\u7A0B: ${e.message}`));
+            console.warn(pc10.yellow(`  \u26A0 \u91CD\u542F\u7F16\u8BD1\u5931\u8D25\uFF0C\u4FDD\u7559\u4E0A\u4E00\u6B21\u8FDB\u7A0B: ${e.message}`));
           }
         } while (pending);
         restarting = null;
@@ -2720,14 +5177,14 @@ async function compileNode(config, entry, opts) {
       return { code: result.code, map: result.map ? JSON.parse(result.map) : void 0 };
     }
   };
-  const bundle = await rolldown3({
+  const bundle2 = await rolldown3({
     input: entry,
     transform: { define: envDefine },
     platform: "node",
     plugins: [oxcTransformPlugin, electronPlugin(config), resolvePlugin(config)]
   });
-  fs10.mkdirSync(path13.dirname(opts.outFile), { recursive: true });
-  await bundle.write({
+  fs11.mkdirSync(path16.dirname(opts.outFile), { recursive: true });
+  await bundle2.write({
     file: opts.outFile,
     format: opts.format === "cjs" ? "cjs" : "esm",
     sourcemap: false,
@@ -2736,17 +5193,17 @@ async function compileNode(config, entry, opts) {
     // 同样语义（单 chunk、内联 dynamic import）
     codeSplitting: false
   });
-  await bundle.close();
+  await bundle2.close();
 }
 function resolveElectronBinary(config) {
-  if (config.electron.electronPath && fs10.existsSync(config.electron.electronPath)) {
+  if (config.electron.electronPath && fs11.existsSync(config.electron.electronPath)) {
     return config.electron.electronPath;
   }
   try {
-    const require2 = createRequire4(path13.resolve(config.root, "package.json"));
+    const require2 = createRequire5(path16.resolve(config.root, "package.json"));
     const pathFile = require2.resolve("electron");
     const electronModule = require2(pathFile);
-    if (typeof electronModule === "string" && fs10.existsSync(electronModule)) {
+    if (typeof electronModule === "string" && fs11.existsSync(electronModule)) {
       return electronModule;
     }
   } catch {
@@ -2757,7 +5214,7 @@ function warnElectronVersion(config) {
   const installed = detectInstalledElectron(config.root);
   if (installed === null) {
     console.warn(
-      pc4.yellow(
+      pc10.yellow(
         `  \u26A0 \u672A\u68C0\u6D4B\u5230 Electron\uFF0C\u8BF7\u5B89\u88C5\uFF1Anpm install -D electron@^${config.electron.minVersion}`
       )
     );
@@ -2765,7 +5222,7 @@ function warnElectronVersion(config) {
   }
   if (installed < config.electron.minVersion) {
     console.warn(
-      pc4.yellow(
+      pc10.yellow(
         `  \u26A0 Electron ${installed} \u4F4E\u4E8E Nasti \u8981\u6C42\u7684 ${config.electron.minVersion}\uFF0C\u67D0\u4E9B\u7279\u6027\uFF08\u5982 ESM \u4E3B\u8FDB\u7A0B\uFF09\u4E0D\u53EF\u7528\u3002`
       )
     );
@@ -2784,15 +5241,48 @@ var init_electron_dev = __esm({
 });
 
 // src/cli.ts
+init_logger();
 import { cac } from "cac";
-import pc5 from "picocolors";
+import pc11 from "picocolors";
 var cli = cac("nasti");
-cli.command("[root]", "Start dev server").alias("dev").option("--port <port>", "Port number", { default: 3e3 }).option("--host [host]", "Hostname").option("--open [path]", "Open browser on startup").option("--mode <mode>", "Set env mode").action(async (root, options) => {
+function setupDebug(options) {
+  if (options.debug || options.verbose) {
+    const namespaces = typeof options.debug === "string" ? options.debug.split(",").map((s) => s.includes(":") ? s : `nasti:${s}`).join(",") : "nasti:*";
+    process.env.DEBUG = process.env.DEBUG ? `${process.env.DEBUG},${namespaces}` : namespaces;
+  }
+  if (options.filter) {
+    process.env.NASTI_DEBUG_FILTER = options.filter;
+  }
+}
+function createCliLogger(options) {
+  return createLogger(options.logLevel ?? "info", {
+    allowClearScreen: options.clearScreen !== false
+  });
+}
+function logCliError(logger, prefix, err) {
+  const error = err instanceof Error ? err : new Error(typeof err === "string" ? err : String(err));
+  if (!logger.hasErrorLogged(error)) {
+    logger.error(pc11.red(`
+  ${prefix}:
+  ${error.message}
+`), { error });
+    if (error.stack) logger.error(pc11.dim(error.stack));
+  }
+  process.exit(1);
+}
+cli.option("--logLevel <level>", "Log level: info | warn | error | silent").option("--clearScreen", "Allow/disable clear screen when logging", { default: true }).option("-d, --debug [namespaces]", "Show debug logs (e.g. -d build,hmr)").option("-f, --filter <filter>", "Filter debug logs by content").option("--verbose", "Shorthand for --debug (all nasti:* namespaces)");
+cli.command("[root]", "Start dev server").alias("dev").option("--port <port>", "Port number", { default: 3e3 }).option("--host [host]", "Hostname").option("--open [path]", "Open browser on startup").option("--mode <mode>", "Set env mode").option("--bundle", "Experimental: serve a full in-memory bundle via the Rolldown dev engine").action(async (root, options) => {
+  setupDebug(options);
+  const logger = createCliLogger(options);
   try {
     const { createServer: createServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
     const server = await createServer2({
       root: root ?? ".",
       mode: options.mode ?? "development",
+      logLevel: options.logLevel,
+      clearScreen: options.clearScreen,
+      customLogger: logger,
+      ...options.bundle ? { experimental: { bundledDev: true } } : {},
       server: {
         port: options.port,
         host: options.host,
@@ -2801,15 +5291,12 @@ cli.command("[root]", "Start dev server").alias("dev").option("--port <port>", "
     });
     await server.listen();
   } catch (err) {
-    console.error(pc5.red(`
-  Error starting dev server:
-  ${err.message}
-`));
-    if (err.stack) console.error(pc5.dim(err.stack));
-    process.exit(1);
+    logCliError(logger, "Error starting dev server", err);
   }
 });
 cli.command("build [root]", "Build for production").option("--outDir <dir>", "Output directory", { default: "dist" }).option("--sourcemap", "Generate source map").option("--minify", "Minify output", { default: true }).option("--mode <mode>", "Set env mode").option("--target <target>", "Build target: web | electron", { default: "web" }).action(async (root, options) => {
+  setupDebug(options);
+  const logger = createCliLogger(options);
   try {
     const target = options.target;
     if (target !== "web" && target !== "electron") {
@@ -2819,6 +5306,9 @@ cli.command("build [root]", "Build for production").option("--outDir <dir>", "Ou
       root: root ?? ".",
       mode: options.mode ?? "production",
       target,
+      logLevel: options.logLevel,
+      clearScreen: options.clearScreen,
+      customLogger: logger,
       build: {
         outDir: options.outDir,
         sourcemap: options.sourcemap,
@@ -2833,21 +5323,21 @@ cli.command("build [root]", "Build for production").option("--outDir <dir>", "Ou
       await build2(inline);
     }
   } catch (err) {
-    console.error(pc5.red(`
-  Build failed:
-  ${err.message}
-`));
-    if (err.stack) console.error(pc5.dim(err.stack));
-    process.exit(1);
+    logCliError(logger, "Build failed", err);
   }
 });
 cli.command("electron [root]", "Start Electron dev mode (requires electron ^41)").alias("electron-dev").option("--port <port>", "Renderer dev server port", { default: 3e3 }).option("--host [host]", "Hostname").option("--mode <mode>", "Set env mode").option("--no-spawn", "Compile main/preload but do not spawn Electron").option("--no-restart", "Disable auto-restart on main/preload changes").action(async (root, options) => {
+  setupDebug(options);
+  const logger = createCliLogger(options);
   try {
     const { startElectronDev: startElectronDev2 } = await Promise.resolve().then(() => (init_electron_dev(), electron_dev_exports));
     await startElectronDev2({
       root: root ?? ".",
       mode: options.mode ?? "development",
       target: "electron",
+      logLevel: options.logLevel,
+      clearScreen: options.clearScreen,
+      customLogger: logger,
       server: {
         port: options.port,
         host: options.host
@@ -2858,21 +5348,21 @@ cli.command("electron [root]", "Start Electron dev mode (requires electron ^41)"
       noSpawn: options.spawn === false
     });
   } catch (err) {
-    console.error(pc5.red(`
-  Electron dev failed:
-  ${err.message}
-`));
-    if (err.stack) console.error(pc5.dim(err.stack));
-    process.exit(1);
+    logCliError(logger, "Electron dev failed", err);
   }
 });
 cli.command("electron-build [root]", "Build Electron app for production").option("--outDir <dir>", "Output directory", { default: "dist" }).option("--sourcemap", "Generate source map").option("--minify", "Minify output", { default: true }).option("--mode <mode>", "Set env mode").action(async (root, options) => {
+  setupDebug(options);
+  const logger = createCliLogger(options);
   try {
     const { buildElectron: buildElectron2 } = await Promise.resolve().then(() => (init_electron2(), electron_exports));
     await buildElectron2({
       root: root ?? ".",
       mode: options.mode ?? "production",
       target: "electron",
+      logLevel: options.logLevel,
+      clearScreen: options.clearScreen,
+      customLogger: logger,
       build: {
         outDir: options.outDir,
         sourcemap: options.sourcemap,
@@ -2880,42 +5370,44 @@ cli.command("electron-build [root]", "Build Electron app for production").option
       }
     });
   } catch (err) {
-    console.error(pc5.red(`
-  Electron build failed:
-  ${err.message}
-`));
-    if (err.stack) console.error(pc5.dim(err.stack));
-    process.exit(1);
+    logCliError(logger, "Electron build failed", err);
   }
 });
 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) => {
+  setupDebug(options);
+  const logger = createCliLogger(options);
   try {
     const http2 = await import("http");
-    const path14 = await import("path");
+    const path17 = await import("path");
+    const os2 = await import("os");
     const sirv2 = (await import("sirv")).default;
     const connect2 = (await import("connect")).default;
-    const resolvedRoot = path14.resolve(root ?? ".");
-    const outDir = path14.resolve(resolvedRoot, options.outDir);
+    const { printServerUrls: printServerUrls2 } = await Promise.resolve().then(() => (init_logger(), logger_exports));
+    const resolvedRoot = path17.resolve(root ?? ".");
+    const outDir = path17.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, () => {
-      console.log();
-      console.log(pc5.cyan("  \u{1F50D} nasti preview"));
-      console.log();
-      console.log(`  ${pc5.green("\u279C")} Local: ${pc5.cyan(`http://localhost:${port}`)}`);
-      console.log();
+      logger.info(`
+  ${pc11.cyan(pc11.bold("NASTI"))} ${pc11.cyan(`v${"2.0.1"}`)}  ${pc11.dim("preview")}
+`);
+      printServerUrls2(
+        {
+          local: [`http://localhost:${port}/`],
+          // 0.0.0.0 本身不可访问：枚举真实网卡的非内网 IPv4 地址
+          network: host === "0.0.0.0" ? Object.values(os2.networkInterfaces()).flat().filter((i) => i && i.family === "IPv4" && !i.internal).map((i) => `http://${i.address}:${port}/`) : []
+        },
+        logger.info
+      );
+      logger.info("");
     });
   } catch (err) {
-    console.error(pc5.red(`
-  Preview failed:
-  ${err.message}
-`));
-    process.exit(1);
+    logCliError(logger, "Preview failed", err);
   }
 });
 cli.help();
-cli.version("1.7.1");
+cli.version("2.0.1");
 cli.parse();
 //# sourceMappingURL=cli.js.map