@nasti-toolchain/nasti 1.7.1 → 2.0.0

package/dist/index.js

@@ -1,15 +1,49 @@
+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) => (path18) => {
+  var fn = map[path18];
+  if (fn) return fn();
+  throw new Error("Module not found in bundle: " + path18);
+};
 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/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 +70,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 +90,9 @@ var init_defaults = __esm({
       minVersion: 41,
       external: ["electron"]
     };
+    defaultExperimental = {
+      bundledDev: false
+    };
     defaults = {
       root: ".",
       base: "/",
@@ -63,8 +105,123 @@ var init_defaults = __esm({
       electron: defaultElectron,
       plugins: [],
       envPrefix: ["NASTI_", "VITE_"],
-      logLevel: "info"
+      logLevel: "info",
+      clearScreen: true,
+      experimental: defaultExperimental
+    };
+  }
+});
+
+// src/core/logger.ts
+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;
   }
 });
 
@@ -131,17 +288,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,
@@ -154,11 +322,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);
@@ -247,11 +474,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
@@ -267,6 +523,7 @@ var init_config = __esm({
   "src/config/index.ts"() {
     "use strict";
     init_defaults();
+    init_logger();
     CONFIG_FILES = [
       "nasti.config.ts",
       "nasti.config.js",
@@ -381,199 +638,1243 @@ var init_resolve = __esm({
   }
 });
 
-// src/plugins/tailwind.ts
-import path3 from "path";
-import { createRequire as createRequire2 } from "module";
-import { pathToFileURL as pathToFileURL2 } 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 = createRequire2(path3.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(pathToFileURL2(nodePath).href);
-  const oxide = await import(pathToFileURL2(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: path3.dirname(fromFile),
-    from: fromFile,
-    onDependency: (p) => dependencies.push(p)
+// 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;
   });
-  const scanner = new oxide.Scanner({ sources: compiler2.sources });
-  const candidates = scanner.scan();
-  return {
-    css: compiler2.build(candidates),
-    dependencies: [...dependencies, ...scanner.files]
+  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 TAILWIND_DIRECTIVE_RE, cached, cachedRoot;
-var init_tailwind = __esm({
-  "src/plugins/tailwind.ts"() {
+var DEBUG, filter;
+var init_debug = __esm({
+  "src/core/debug.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;
+    DEBUG = process.env.DEBUG;
+    filter = process.env.NASTI_DEBUG_FILTER || process.env.VITE_DEBUG_FILTER;
   }
 });
 
-// src/plugins/css.ts
-import path4 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;
-      }
-      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);
-
-// HMR
-if (import.meta.hot) {
-  import.meta.hot.accept();
-  import.meta.hot.prune(() => {
-    style.remove();
-  });
-}
-
-export default css;
-`
-        };
-      }
-      const cssConfig = config.build.css || {};
-      const nonce = cssConfig.nonce;
-      const emitCssFile = cssConfig.emitCssFile;
-      if (emitCssFile) {
-        const fileName = `assets/${path4.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);
+// 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({});
+  }
+});
 
-export default ${escaped};
-`,
-          moduleType: "js"
-        };
+// 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 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);
+      return report;
+    };
+    module.exports = { isLinux, getReport };
+  }
+});
 
-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 = path4.resolve(path4.dirname(from), url);
-    const relative = "/" + path4.relative(root, resolved);
-    return `url(${relative})`;
-  });
-}
-var init_css = __esm({
-  "src/plugins/css.ts"() {
+// node_modules/detect-libc/lib/filesystem.js
+var require_filesystem = __commonJS({
+  "node_modules/detect-libc/lib/filesystem.js"(exports, module) {
     "use strict";
-    init_tailwind();
+    var fs13 = __require("fs");
+    var LDD_PATH = "/usr/bin/ldd";
+    var SELF_PATH = "/proc/self/exe";
+    var MAX_LENGTH = 2048;
+    var readFileSync = (path18) => {
+      const fd = fs13.openSync(path18, "r");
+      const buffer = Buffer.alloc(MAX_LENGTH);
+      const bytesRead = fs13.readSync(fd, buffer, 0, MAX_LENGTH, 0);
+      fs13.close(fd, () => {
+      });
+      return buffer.subarray(0, bytesRead);
+    };
+    var readFile = (path18) => new Promise((resolve, reject) => {
+      fs13.open(path18, "r", (err, fd) => {
+        if (err) {
+          reject(err);
+        } else {
+          const buffer = Buffer.alloc(MAX_LENGTH);
+          fs13.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
+            resolve(buffer.subarray(0, bytesRead));
+            fs13.close(fd, () => {
+            });
+          });
+        }
+      });
+    });
+    module.exports = {
+      LDD_PATH,
+      SELF_PATH,
+      readFileSync,
+      readFile
+    };
   }
 });
 
-// src/plugins/assets.ts
-import path5 from "path";
-import fs3 from "fs";
-import crypto from "crypto";
-function assetsPlugin(config) {
-  return {
-    name: "nasti:assets",
-    resolveId(source) {
-      if (source.endsWith("?url") || source.endsWith("?raw")) {
-        return source;
+// 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;
+      }
+      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;
-    },
-    load(id) {
-      const ext = path5.extname(id.replace(/\?.*$/, ""));
-      if (id.endsWith("?raw")) {
-        const file = id.slice(0, -4);
-        if (fs3.existsSync(file)) {
-          const content = fs3.readFileSync(file, "utf-8");
-          return `export default ${JSON.stringify(content)}`;
+    };
+    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 = " ";
         }
       }
-      if (id.endsWith("?url") || ASSET_EXTENSIONS.has(ext)) {
-        const file = id.replace(/\?.*$/, "");
-        if (!fs3.existsSync(file)) return null;
-        if (config.command === "serve") {
-          const url = "/" + path5.relative(config.root, file);
-          return `export default ${JSON.stringify(url)}`;
+      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;
         }
-        const content = fs3.readFileSync(file);
-        const hash = crypto.createHash("sha256").update(content).digest("hex").slice(0, 8);
-        const basename = path5.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"() {
+    };
+    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 = (path18) => {
+      if (path18) {
+        if (path18.includes("/ld-musl-")) {
+          return MUSL;
+        } else if (path18.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 path18 = interpreterPath(selfContent);
+        cachedFamilyInterpreter = familyFromInterpreterPath(path18);
+      } catch (e) {
+      }
+      return cachedFamilyInterpreter;
+    };
+    var familyFromInterpreterSync = () => {
+      if (cachedFamilyInterpreter !== void 0) {
+        return cachedFamilyInterpreter;
+      }
+      cachedFamilyInterpreter = null;
+      try {
+        const selfContent = readFileSync(SELF_PATH);
+        const path18 = interpreterPath(selfContent);
+        cachedFamilyInterpreter = familyFromInterpreterPath(path18);
+      } 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;
+      debug?.("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 debug, lightningCss;
+var init_css_engine = __esm({
+  "src/core/css-engine.ts"() {
+    "use strict";
+    init_debug();
+    debug = createDebugger("nasti:css");
+  }
+});
+
+// src/plugins/tailwind.ts
+import path3 from "path";
+import { createRequire as createRequire2 } from "module";
+import { pathToFileURL as pathToFileURL2 } 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 = createRequire2(path3.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(pathToFileURL2(nodePath).href);
+  const oxide = await import(pathToFileURL2(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: path3.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 path4 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"
+        };
+      }
+      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 = path4.resolve(path4.dirname(from), url);
+    const relative = "/" + path4.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 path5 from "path";
+import fs3 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 = path5.extname(id.replace(/\?.*$/, ""));
+      if (id.endsWith("?raw")) {
+        const file = id.slice(0, -4);
+        if (fs3.existsSync(file)) {
+          const content = fs3.readFileSync(file, "utf-8");
+          return `export default ${JSON.stringify(content)}`;
+        }
+      }
+      if (id.endsWith("?url") || ASSET_EXTENSIONS.has(ext)) {
+        const file = id.replace(/\?.*$/, "");
+        if (!fs3.existsSync(file)) return null;
+        if (config.command === "serve") {
+          const url = "/" + path5.relative(config.root, file);
+          return `export default ${JSON.stringify(url)}`;
+        }
+        const content = fs3.readFileSync(file);
+        const hash = crypto.createHash("sha256").update(content).digest("hex").slice(0, 8);
+        const basename = path5.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",
@@ -662,6 +1963,43 @@ function vuePlugin(config) {
       }
       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 fs13 = await import("fs");
+          const source = fs13.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();
@@ -670,7 +2008,7 @@ function vuePlugin(config) {
         return null;
       }
       if (VUE_QUERY_RE.test(id)) {
-        return handleVueSubBlock(id, sfc, descriptorCache, config);
+        return null;
       }
       const { descriptor, errors } = sfc.parse(code, { filename: id });
       if (errors.length) {
@@ -713,10 +2051,8 @@ __sfc__.render = render
       }
       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}"
+import "${id}?vue&type=style&index=${i}&lang.css"
 `;
         }
       }
@@ -762,41 +2098,6 @@ export default __sfc__
     }
   };
 }
-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());
-}
-`
-    };
-  }
-  return null;
-}
 function hashId(filename) {
   return crypto2.createHash("sha256").update(filename).digest("hex").slice(0, 8);
 }
@@ -806,7 +2107,7 @@ var init_vue = __esm({
     "use strict";
     init_transformer();
     VUE_FILE_RE = /\.vue$/;
-    VUE_QUERY_RE = /\.vue\?vue&type=(script|template|style)(&index=\d+)?(&lang=\w+)?/;
+    VUE_QUERY_RE = /\.vue\?vue&type=(script|template|style)(&index=\d+)?(&lang[.=]\w+)?/;
     compiler = null;
   }
 });
@@ -892,66 +2193,32 @@ window.$RefreshSig$ = () => (type) => type;
 window.__vite_plugin_react_preamble_installed__ = true;
 `.trim();
   }
-});
-
-// src/core/env.ts
-import path7 from "path";
-import fs5 from "fs";
-function loadEnv(mode, root, prefixes) {
-  const envFiles = [
-    ".env",
-    `.env.${mode}`,
-    ".env.local",
-    `.env.${mode}.local`
-  ];
-  const raw = {};
-  for (const file of envFiles) {
-    const filePath = path7.resolve(root, file);
-    if (!fs5.existsSync(filePath)) continue;
-    const content = fs5.readFileSync(filePath, "utf-8");
-    for (const line of content.split("\n")) {
-      const trimmed = line.trim();
-      if (!trimmed || trimmed.startsWith("#")) continue;
-      const eqIdx = trimmed.indexOf("=");
-      if (eqIdx === -1) continue;
-      const key = trimmed.slice(0, eqIdx).trim();
-      let value = trimmed.slice(eqIdx + 1).trim();
-      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
-        value = value.slice(1, -1);
-      }
-      raw[key] = value;
-    }
-  }
-  const filtered = {};
-  for (const [key, value] of Object.entries(raw)) {
-    if (prefixes.some((prefix) => key.startsWith(prefix))) {
-      filtered[key] = value;
-    }
-  }
-  return filtered;
-}
-function buildEnvDefine(env, mode) {
-  const define = {};
-  for (const [key, value] of Object.entries(env)) {
-    define[`import.meta.env.${key}`] = JSON.stringify(value);
-  }
-  define["import.meta.env.MODE"] = JSON.stringify(mode);
-  define["import.meta.env.DEV"] = mode !== "production" ? "true" : "false";
-  define["import.meta.env.PROD"] = mode === "production" ? "true" : "false";
-  define["import.meta.env.SSR"] = "false";
-  return define;
-}
-function replaceEnvInCode(code, define) {
-  let result = code;
-  for (const [key, value] of Object.entries(define)) {
-    const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    result = result.replace(new RegExp(escaped, "g"), value);
-  }
-  return result;
+});
+
+// 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_env = __esm({
-  "src/core/env.ts"() {
+var init_builtins = __esm({
+  "src/plugins/builtins.ts"() {
     "use strict";
+    init_resolve();
+    init_css();
+    init_css_post();
+    init_assets();
+    init_vue();
+    init_html();
   }
 });
 
@@ -976,8 +2243,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();
       }
@@ -998,7 +2268,8 @@ var init_plugin_container = __esm({
           },
           getModuleInfo(_id) {
             return null;
-          }
+          },
+          environment: container.environment
         };
       }
       /** 返回所有通过 emitFile() 输出的文件 */
@@ -1020,13 +2291,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;
         }
@@ -1075,125 +2347,600 @@ var init_plugin_container = __esm({
   }
 });
 
+// src/core/module-graph.ts
+var ModuleGraph;
+var init_module_graph = __esm({
+  "src/core/module-graph.ts"() {
+    "use strict";
+    ModuleGraph = class {
+      urlToModuleMap = /* @__PURE__ */ new Map();
+      idToModuleMap = /* @__PURE__ */ new Map();
+      fileToModulesMap = /* @__PURE__ */ new Map();
+      getModuleByUrl(url) {
+        return this.urlToModuleMap.get(url);
+      }
+      getModuleById(id) {
+        return this.idToModuleMap.get(id);
+      }
+      getModulesByFile(file) {
+        return this.fileToModulesMap.get(file);
+      }
+      async ensureEntryFromUrl(url) {
+        let mod = this.urlToModuleMap.get(url);
+        if (mod) return mod;
+        mod = this.createModule(url);
+        this.urlToModuleMap.set(url, mod);
+        return mod;
+      }
+      createModule(url, id) {
+        const mod = {
+          id: id ?? url,
+          file: null,
+          url,
+          type: url.endsWith(".css") ? "css" : "js",
+          importers: /* @__PURE__ */ new Set(),
+          importedModules: /* @__PURE__ */ new Set(),
+          acceptedHmrDeps: /* @__PURE__ */ new Set(),
+          transformResult: null,
+          lastHMRTimestamp: 0,
+          isSelfAccepting: false
+        };
+        this.idToModuleMap.set(mod.id, mod);
+        return mod;
+      }
+      /** 注册文件路径到模块的映射 */
+      registerModule(mod, file) {
+        mod.file = file;
+        let mods = this.fileToModulesMap.get(file);
+        if (!mods) {
+          mods = /* @__PURE__ */ new Set();
+          this.fileToModulesMap.set(file, mods);
+        }
+        mods.add(mod);
+      }
+      /**
+       * Reindex a module under a plugin-provided canonical id (e.g. a `\0virtual:foo`
+       * id returned from `resolveId`). Plugins look up their own virtual modules via
+       * `getModuleById(RESOLVED_ID)` to invalidate them on watcher events; without
+       * this remap they'd never find the node because `ensureEntryFromUrl` keys by
+       * the public URL only.
+       */
+      setModuleId(mod, id) {
+        if (mod.id === id) return;
+        this.idToModuleMap.delete(mod.id);
+        mod.id = id;
+        this.idToModuleMap.set(id, mod);
+      }
+      /** 更新模块依赖关系 */
+      updateModuleImports(mod, importedIds) {
+        for (const imported of mod.importedModules) {
+          imported.importers.delete(mod);
+        }
+        mod.importedModules.clear();
+        for (const id of importedIds) {
+          const importedMod = this.idToModuleMap.get(id);
+          if (importedMod) {
+            mod.importedModules.add(importedMod);
+            importedMod.importers.add(mod);
+          }
+        }
+      }
+      /** 使模块的转换缓存失效 */
+      invalidateModule(mod) {
+        mod.transformResult = null;
+        mod.lastHMRTimestamp = Date.now();
+      }
+      /** 使所有模块缓存失效 */
+      invalidateAll() {
+        for (const mod of this.idToModuleMap.values()) {
+          this.invalidateModule(mod);
+        }
+      }
+      /** 获取 HMR 传播边界 - 从变更模块向上遍历找到接受更新的边界 */
+      getHmrBoundaries(mod) {
+        const boundaries = [];
+        const visited = /* @__PURE__ */ new Set();
+        const propagate = (node, via) => {
+          if (visited.has(node)) return true;
+          visited.add(node);
+          if (node.isSelfAccepting) {
+            boundaries.push({ boundary: node, acceptedVia: via });
+            return true;
+          }
+          if (node.acceptedHmrDeps.has(via)) {
+            boundaries.push({ boundary: node, acceptedVia: via });
+            return true;
+          }
+          if (node.importers.size === 0) return false;
+          for (const importer of node.importers) {
+            if (!propagate(importer, node)) return false;
+          }
+          return true;
+        };
+        if (mod.isSelfAccepting) {
+          boundaries.push({ boundary: mod, acceptedVia: mod });
+          return boundaries;
+        }
+        for (const importer of mod.importers) {
+          if (!propagate(importer, mod)) {
+            return [];
+          }
+        }
+        return boundaries;
+      }
+    };
+  }
+});
+
+// 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/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 debug2, NastiEnvironment;
+var init_environment = __esm({
+  "src/core/environment.ts"() {
+    "use strict";
+    init_plugin_container();
+    init_module_graph();
+    init_hot_channel();
+    init_debug();
+    debug2 = 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
+        );
+        debug2?.(`env "${this.name}" initialized (${this.plugins.length} plugins)`);
+      }
+      async close() {
+        await this.hot.close?.();
+      }
+    };
+  }
+});
+
+// src/core/env.ts
+import path7 from "path";
+import fs5 from "fs";
+function loadEnv(mode, root, prefixes) {
+  const envFiles = [
+    ".env",
+    `.env.${mode}`,
+    ".env.local",
+    `.env.${mode}.local`
+  ];
+  const raw = {};
+  for (const file of envFiles) {
+    const filePath = path7.resolve(root, file);
+    if (!fs5.existsSync(filePath)) continue;
+    const content = fs5.readFileSync(filePath, "utf-8");
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("#")) continue;
+      const eqIdx = trimmed.indexOf("=");
+      if (eqIdx === -1) continue;
+      const key = trimmed.slice(0, eqIdx).trim();
+      let value = trimmed.slice(eqIdx + 1).trim();
+      if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+        value = value.slice(1, -1);
+      }
+      raw[key] = value;
+    }
+  }
+  const filtered = {};
+  for (const [key, value] of Object.entries(raw)) {
+    if (prefixes.some((prefix) => key.startsWith(prefix))) {
+      filtered[key] = value;
+    }
+  }
+  return filtered;
+}
+function buildEnvDefine(env, mode, overrides = {}) {
+  const define = {};
+  for (const [key, value] of Object.entries(env)) {
+    define[`import.meta.env.${key}`] = JSON.stringify(value);
+  }
+  define["import.meta.env.MODE"] = JSON.stringify(mode);
+  define["import.meta.env.DEV"] = mode !== "production" ? "true" : "false";
+  define["import.meta.env.PROD"] = mode === "production" ? "true" : "false";
+  define["import.meta.env.SSR"] = "false";
+  return { ...define, ...overrides };
+}
+function ssrDefineOverrides(consumer) {
+  return { "import.meta.env.SSR": consumer === "server" ? "true" : "false" };
+}
+function replaceEnvInCode(code, define) {
+  let result = code;
+  for (const [key, value] of Object.entries(define)) {
+    const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    result = result.replace(new RegExp(escaped, "g"), value);
+  }
+  return result;
+}
+var init_env = __esm({
+  "src/core/env.ts"() {
+    "use strict";
+  }
+});
+
+// src/build/reporter.ts
+import path8 from "path";
+import { gzipSync } from "zlib";
+import pc3 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) {
+    debug3?.(`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 = path8.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: pc3.green, css: pc3.magenta, js: pc3.cyan };
+  for (const e of entries) {
+    const color = groupColor[e.group];
+    const namePart = pc3.dim(outDirPrefix) + color(e.name.padEnd(maxNameLen - outDirPrefix.length));
+    const sizePart = pc3.dim(pc3.bold(displaySize(e.size).padStart(maxSizeLen)));
+    const gzipPart = e.gzip != null ? pc3.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(
+    pc3.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 debug3, numberFormatter;
+var init_reporter = __esm({
+  "src/build/reporter.ts"() {
+    "use strict";
+    init_debug();
+    debug3 = createDebugger("nasti:reporter");
+    numberFormatter = new Intl.NumberFormat("en", {
+      maximumFractionDigits: 2,
+      minimumFractionDigits: 2
+    });
+  }
+});
+
 // src/build/index.ts
 var build_exports = {};
 __export(build_exports, {
-  build: () => build
+  build: () => build,
+  getRolldownOptions: () => getRolldownOptions,
+  resolveClientEntries: () => resolveClientEntries,
+  toRolldownPlugins: () => toRolldownPlugins
 });
-import path8 from "path";
+import path9 from "path";
 import fs6 from "fs";
+import { builtinModules } from "module";
 import { rolldown } from "rolldown";
-import pc from "picocolors";
-async function build(inlineConfig = {}) {
-  const config = await resolveConfig(inlineConfig, "build");
-  const startTime = performance.now();
-  console.log(pc.cyan("\n\u{1F528} nasti build") + pc.dim(` v${"1.7.1"}`));
-  console.log(pc.dim(`  root: ${config.root}`));
-  console.log(pc.dim(`  mode: ${config.mode}`));
-  const outDir = path8.resolve(config.root, config.build.outDir);
-  if (config.build.emptyOutDir && fs6.existsSync(outDir)) {
-    fs6.rmSync(outDir, { recursive: true, force: true });
-  }
-  fs6.mkdirSync(outDir, { recursive: true });
-  const html = await readHtmlFile(config.root);
-  let entryPoints = [];
+import pc4 from "picocolors";
+function getRolldownOptions(environment, entryPoints, rolldownPlugins) {
+  const config = environment.config;
+  const envOptions = environment.options;
+  const isServer = environment.consumer === "server";
+  const outDir = path9.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_BUILTINS.has(id)) return true;
+        return !id.startsWith(".") && !path9.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(path8.resolve(config.root, src.replace(/^\//, "")));
+        entryPoints.push(path9.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 = path8.resolve(config.root, entry);
+      const fullPath = path9.resolve(config.root, entry);
       if (fs6.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 = {
+  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: !!config.build.sourcemap,
+        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 };
     }
   };
-  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 = path8.resolve(outDir, ef.fileName);
-    fs6.mkdirSync(path8.dirname(dest), { recursive: true });
-    fs6.writeFileSync(dest, ef.source);
+}
+async function build(inlineConfig = {}) {
+  const config = await resolveConfig(inlineConfig, "build");
+  const logger = config.logger;
+  const startTime = performance.now();
+  logger.info(
+    pc4.cyan(`
+nasti v${"2.0.0"} `) + pc4.green(`building for ${config.mode}...`)
+  );
+  debug4?.(`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) {
+      debug4?.(`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(pc4.green(`\u2713 built in ${elapsed}s`) + pc4.dim(envSuffix));
+  logger.info(pc4.dim(`  ${fileCount} files, ${displaySize(totalSize)} total \u2192 ${config.build.outDir}/`));
+  return { output: clientOutput, environments };
+}
+async function buildClientEnvironment(config) {
+  const logger = config.logger;
+  const outDir = path9.resolve(config.root, config.build.outDir);
+  if (config.build.emptyOutDir && fs6.existsSync(outDir)) {
+    fs6.rmSync(outDir, { recursive: true, force: true });
+  }
+  fs6.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 htmlPlugin_ = htmlPlugin(config);
-    if (htmlPlugin_.transformIndexHtml) {
-      const result = await htmlPlugin_.transformIndexHtml(processedHtml);
+    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) {
@@ -1202,174 +2949,98 @@ async function build(inlineConfig = {}) {
         processedHtml = processHtml(processedHtml, result);
       }
     }
+    processedHtml = injectCssLinks(processedHtml, cssEngine, config);
     for (const chunk of output) {
       if (chunk.type === "chunk" && chunk.isEntry && chunk.facadeModuleId) {
-        const originalEntry = path8.relative(config.root, chunk.facadeModuleId);
+        const originalEntry = path9.relative(config.root, chunk.facadeModuleId);
         processedHtml = processedHtml.replace(
           new RegExp(`(src=["'])/?(${escapeRegExp(originalEntry)})(["'])`, "g"),
           `$1${config.base}${chunk.fileName}$3`
         );
       }
     }
-    fs6.writeFileSync(path8.resolve(outDir, "index.html"), processedHtml);
+    fs6.writeFileSync(path9.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(pc.green(`
-\u2713 Built in ${elapsed}s`));
-  console.log(pc.dim(`  ${output.length} files, ${formatSize(totalSize)} total`));
-  console.log(pc.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`;
+  if (!nativeReporter && config.logLevel !== "silent") {
+    reportBuildOutput(output, config, logger);
+  }
+  warnLargeChunks(output, config, logger);
+  return output;
+}
+async function buildServerEnvironment(config, name) {
+  const envOptions = config.environments[name];
+  const logger = config.logger;
+  for (const entry of envOptions.entry) {
+    if (!fs6.existsSync(entry)) {
+      throw new Error(`[nasti] environment "${name}" entry not found: ${entry}`);
+    }
+  }
+  const pluginList = resolvePluginList(config, config.plugins, { consumer: envOptions.consumer });
+  const environment = new NastiEnvironment(name, { ...config, plugins: pluginList }, {
+    mode: "build",
+    plugins: pluginList
+  });
+  await environment.init();
+  const rolldownPlugins = [
+    createOxcTransformPlugin(config, environment),
+    ...toRolldownPlugins(environment.plugins)
+  ];
+  const { inputOptions, outputOptions, outDir } = getRolldownOptions(
+    environment,
+    envOptions.entry,
+    rolldownPlugins
+  );
+  if (envOptions.build.emptyOutDir && fs6.existsSync(outDir)) {
+    fs6.rmSync(outDir, { recursive: true, force: true });
+  }
+  fs6.mkdirSync(outDir, { recursive: true });
+  const bundle2 = await rolldown(inputOptions);
+  const { output } = await bundle2.write(outputOptions);
+  await bundle2.close();
+  logger.info(
+    pc4.dim(`  [${name}] `) + output.map((o) => path9.join(envOptions.build.outDir, o.fileName)).join(pc4.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 cssLinkTags.length > 0 ? processHtml(html, cssLinkTags) : html;
 }
 function escapeRegExp(string) {
   return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+var debug4, NODE_BUILTINS;
 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/core/module-graph.ts
-var ModuleGraph;
-var init_module_graph = __esm({
-  "src/core/module-graph.ts"() {
-    "use strict";
-    ModuleGraph = class {
-      urlToModuleMap = /* @__PURE__ */ new Map();
-      idToModuleMap = /* @__PURE__ */ new Map();
-      fileToModulesMap = /* @__PURE__ */ new Map();
-      getModuleByUrl(url) {
-        return this.urlToModuleMap.get(url);
-      }
-      getModuleById(id) {
-        return this.idToModuleMap.get(id);
-      }
-      getModulesByFile(file) {
-        return this.fileToModulesMap.get(file);
-      }
-      async ensureEntryFromUrl(url) {
-        let mod = this.urlToModuleMap.get(url);
-        if (mod) return mod;
-        mod = this.createModule(url);
-        this.urlToModuleMap.set(url, mod);
-        return mod;
-      }
-      createModule(url, id) {
-        const mod = {
-          id: id ?? url,
-          file: null,
-          url,
-          type: url.endsWith(".css") ? "css" : "js",
-          importers: /* @__PURE__ */ new Set(),
-          importedModules: /* @__PURE__ */ new Set(),
-          acceptedHmrDeps: /* @__PURE__ */ new Set(),
-          transformResult: null,
-          lastHMRTimestamp: 0,
-          isSelfAccepting: false
-        };
-        this.idToModuleMap.set(mod.id, mod);
-        return mod;
-      }
-      /** 注册文件路径到模块的映射 */
-      registerModule(mod, file) {
-        mod.file = file;
-        let mods = this.fileToModulesMap.get(file);
-        if (!mods) {
-          mods = /* @__PURE__ */ new Set();
-          this.fileToModulesMap.set(file, mods);
-        }
-        mods.add(mod);
-      }
-      /**
-       * Reindex a module under a plugin-provided canonical id (e.g. a `\0virtual:foo`
-       * id returned from `resolveId`). Plugins look up their own virtual modules via
-       * `getModuleById(RESOLVED_ID)` to invalidate them on watcher events; without
-       * this remap they'd never find the node because `ensureEntryFromUrl` keys by
-       * the public URL only.
-       */
-      setModuleId(mod, id) {
-        if (mod.id === id) return;
-        this.idToModuleMap.delete(mod.id);
-        mod.id = id;
-        this.idToModuleMap.set(id, mod);
-      }
-      /** 更新模块依赖关系 */
-      updateModuleImports(mod, importedIds) {
-        for (const imported of mod.importedModules) {
-          imported.importers.delete(mod);
-        }
-        mod.importedModules.clear();
-        for (const id of importedIds) {
-          const importedMod = this.idToModuleMap.get(id);
-          if (importedMod) {
-            mod.importedModules.add(importedMod);
-            importedMod.importers.add(mod);
-          }
-        }
-      }
-      /** 使模块的转换缓存失效 */
-      invalidateModule(mod) {
-        mod.transformResult = null;
-        mod.lastHMRTimestamp = Date.now();
-      }
-      /** 使所有模块缓存失效 */
-      invalidateAll() {
-        for (const mod of this.idToModuleMap.values()) {
-          this.invalidateModule(mod);
-        }
-      }
-      /** 获取 HMR 传播边界 - 从变更模块向上遍历找到接受更新的边界 */
-      getHmrBoundaries(mod) {
-        const boundaries = [];
-        const visited = /* @__PURE__ */ new Set();
-        const propagate = (node, via) => {
-          if (visited.has(node)) return true;
-          visited.add(node);
-          if (node.isSelfAccepting) {
-            boundaries.push({ boundary: node, acceptedVia: via });
-            return true;
-          }
-          if (node.acceptedHmrDeps.has(via)) {
-            boundaries.push({ boundary: node, acceptedVia: via });
-            return true;
-          }
-          if (node.importers.size === 0) return false;
-          for (const importer of node.importers) {
-            if (!propagate(importer, node)) return false;
-          }
-          return true;
-        };
-        if (mod.isSelfAccepting) {
-          boundaries.push({ boundary: mod, acceptedVia: mod });
-          return boundaries;
-        }
-        for (const importer of mod.importers) {
-          if (!propagate(importer, mod)) {
-            return [];
-          }
-        }
-        return boundaries;
-      }
-    };
+  "src/build/index.ts"() {
+    "use strict";
+    init_config();
+    init_builtins();
+    init_environment();
+    init_css_engine();
+    init_html();
+    init_transformer();
+    init_env();
+    init_reporter();
+    init_debug();
+    debug4 = createDebugger("nasti:build");
+    NODE_BUILTINS = /* @__PURE__ */ new Set([...builtinModules, ...builtinModules.map((m) => `node:${m}`)]);
   }
 });
 
@@ -1421,21 +3092,23 @@ var init_ws = __esm({
 var middleware_exports = {};
 __export(middleware_exports, {
   REACT_REFRESH_GLOBAL_PREAMBLE: () => REACT_REFRESH_GLOBAL_PREAMBLE,
+  getReactRefreshRuntimeEsm: () => getReactRefreshRuntimeEsm,
   transformMiddleware: () => transformMiddleware,
   transformRequest: () => transformRequest
 });
-import path10 from "path";
+import path11 from "path";
 import fs8 from "fs";
 import { createRequire as createRequire3 } from "module";
 import { fileURLToPath, pathToFileURL as pathToFileURL3 } from "url";
+import pc6 from "picocolors";
 function getReactRefreshRuntimeEsm() {
   if (__refreshRuntimeCache) return __refreshRuntimeCache;
   let cjsPath;
   try {
-    const pkgPath = __require.resolve("react-refresh/package.json");
-    cjsPath = path10.join(path10.dirname(pkgPath), "cjs", "react-refresh-runtime.development.js");
+    const pkgPath = __require2.resolve("react-refresh/package.json");
+    cjsPath = path11.join(path11.dirname(pkgPath), "cjs", "react-refresh-runtime.development.js");
   } catch (err) {
-    cjsPath = path10.resolve(__dirname_esm, "../../node_modules/react-refresh/cjs/react-refresh-runtime.development.js");
+    cjsPath = path11.resolve(__dirname_esm, "../../node_modules/react-refresh/cjs/react-refresh-runtime.development.js");
     if (!fs8.existsSync(cjsPath)) {
       const origMsg = err instanceof Error ? err.message : String(err);
       throw new Error(
@@ -1563,7 +3236,11 @@ function transformMiddleware(ctx) {
           return;
         }
       } catch (err) {
-        console.error(`[nasti] Transform error: ${url}`, err.message);
+        ctx.config.logger.error(
+          pc6.red(`Transform error: ${url}
+`) + (err.stack ?? err.message),
+          { timestamp: true, error: err }
+        );
         res.statusCode = 500;
         res.end(`Transform error: ${err.message}`);
         return;
@@ -1592,6 +3269,28 @@ 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 || !fs8.existsSync(filePath)) return null;
   const mod = await moduleGraph.ensureEntryFromUrl(url);
@@ -1656,7 +3355,7 @@ async function loadVirtualModule(spec, ctx) {
     loadEnv(config.mode, config.root, config.envPrefix),
     config.mode
   ));
-  const anchor = path10.join(config.root, "__nasti_virtual__.ts");
+  const anchor = path11.join(config.root, "__nasti_virtual__.ts");
   code = rewriteImports(code, config, anchor);
   return { id: resolvedId, result: { code } };
 }
@@ -1670,7 +3369,7 @@ async function doBundlePackage(entryFile) {
   const shim = await tryGenerateSubpathShim(entryFile);
   if (shim != null) return shim;
   const { rolldown: rolldown4 } = await import("rolldown");
-  const bundle = await rolldown4({
+  const bundle2 = await rolldown4({
     input: entryFile,
     // 仅将其他 npm 包外部化；相对路径（包内部文件）全部内联打包
     external: (id) => {
@@ -1678,8 +3377,8 @@ 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"');
   code = code.replace(
@@ -1699,13 +3398,13 @@ async function doBundlePackage(entryFile) {
   return code;
 }
 async function tryGenerateSubpathShim(entryFile) {
-  const NM = `${path10.sep}node_modules${path10.sep}`;
+  const NM = `${path11.sep}node_modules${path11.sep}`;
   if (!entryFile.includes(NM)) return null;
   let pkgDir = null;
   let pkgName = null;
-  let dir = path10.dirname(entryFile);
+  let dir = path11.dirname(entryFile);
   while (true) {
-    const pkgJsonPath = path10.join(dir, "package.json");
+    const pkgJsonPath = path11.join(dir, "package.json");
     if (fs8.existsSync(pkgJsonPath)) {
       try {
         const pkg = JSON.parse(fs8.readFileSync(pkgJsonPath, "utf-8"));
@@ -1717,16 +3416,16 @@ async function tryGenerateSubpathShim(entryFile) {
       } catch {
       }
     }
-    const parent = path10.dirname(dir);
+    const parent = path11.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
     if (!dir.includes(NM)) return null;
   }
   if (!pkgDir || !pkgName) return null;
-  const entryExt = path10.extname(entryFile);
+  const entryExt = path11.extname(entryFile);
   const mainEntry = pickMainEntryByExtension(pkgDir, entryExt);
   if (!mainEntry) return null;
-  if (path10.resolve(mainEntry) === path10.resolve(entryFile)) return null;
+  if (path11.resolve(mainEntry) === path11.resolve(entryFile)) return null;
   let mainNs;
   let subNs;
   try {
@@ -1762,7 +3461,7 @@ async function tryGenerateSubpathShim(entryFile) {
   return lines.join("\n") + "\n";
 }
 function pickMainEntryByExtension(pkgDir, preferredExt) {
-  const pkgJsonPath = path10.join(pkgDir, "package.json");
+  const pkgJsonPath = path11.join(pkgDir, "package.json");
   let pkg;
   try {
     pkg = JSON.parse(fs8.readFileSync(pkgJsonPath, "utf-8"));
@@ -1784,13 +3483,13 @@ function pickMainEntryByExtension(pkgDir, preferredExt) {
   if (typeof pkg.module === "string") candidates.push(pkg.module);
   if (typeof pkg.main === "string") candidates.push(pkg.main);
   for (const cand of candidates) {
-    if (path10.extname(cand) === preferredExt) {
-      const full = path10.resolve(pkgDir, cand);
+    if (path11.extname(cand) === preferredExt) {
+      const full = path11.resolve(pkgDir, cand);
       if (fs8.existsSync(full)) return full;
     }
   }
   for (const cand of candidates) {
-    const full = path10.resolve(pkgDir, cand);
+    const full = path11.resolve(pkgDir, cand);
     if (fs8.existsSync(full)) return full;
   }
   return null;
@@ -1816,8 +3515,8 @@ function rewriteExternalRequires(code) {
 }
 async function injectCjsNamedExports(code, entryFile) {
   try {
-    const { createRequire: createRequire6 } = await import("module");
-    const req = createRequire6(entryFile);
+    const { createRequire: createRequire7 } = await import("module");
+    const req = createRequire7(entryFile);
     const cjsExports = req(entryFile);
     if (!cjsExports || typeof cjsExports !== "object" && typeof cjsExports !== "function" || Array.isArray(cjsExports)) return code;
     const namedKeys = Object.keys(cjsExports).filter(
@@ -1839,11 +3538,11 @@ async function injectCjsNamedExports(code, entryFile) {
 }
 function rewriteImports(code, config, filePath) {
   const root = config.root;
-  const fileDir = path10.dirname(filePath);
+  const fileDir = path11.dirname(filePath);
   const aliasEntries = Object.entries(config.resolve.alias).sort(
     ([a], [b]) => b.length - a.length
   );
-  const toRootUrl = (abs) => "/" + path10.relative(root, abs).replace(/\\/g, "/");
+  const toRootUrl = (abs) => "/" + path11.relative(root, abs).replace(/\\/g, "/");
   const transformSpec = (spec) => {
     const suffixMatch = spec.match(/[?#].*$/);
     const suffix = suffixMatch ? suffixMatch[0] : "";
@@ -1852,18 +3551,18 @@ function rewriteImports(code, config, filePath) {
       if (baseSpec === key || baseSpec.startsWith(key + "/")) {
         const aliasBase = resolveAliasTarget2(value, root);
         const sub = baseSpec.slice(key.length).replace(/^\//, "");
-        const target = sub ? path10.join(aliasBase, sub) : aliasBase;
+        const target = sub ? path11.join(aliasBase, sub) : aliasBase;
         const resolved = tryResolveDiskPath(target);
         return resolved && isUnderRoot(resolved, root) ? toRootUrl(resolved) + suffix : spec;
       }
     }
     if (baseSpec.startsWith("./") || baseSpec.startsWith("../")) {
-      const target = path10.resolve(fileDir, baseSpec);
+      const target = path11.resolve(fileDir, baseSpec);
       const resolved = tryResolveDiskPath(target);
       return resolved && isUnderRoot(resolved, root) ? toRootUrl(resolved) + suffix : spec;
     }
     if (baseSpec.startsWith("/") && !baseSpec.startsWith("/@")) {
-      const target = path10.join(root, baseSpec.replace(/^\//, ""));
+      const target = path11.join(root, baseSpec.replace(/^\//, ""));
       const resolved = tryResolveDiskPath(target);
       return resolved && isUnderRoot(resolved, root) ? toRootUrl(resolved) + suffix : spec;
     }
@@ -1882,9 +3581,9 @@ function rewriteImports(code, config, filePath) {
   );
 }
 function resolveAliasTarget2(value, root) {
-  if (path10.isAbsolute(value) && fs8.existsSync(value)) return value;
-  if (value.startsWith("/")) return path10.join(root, value.slice(1));
-  return path10.resolve(root, value);
+  if (path11.isAbsolute(value) && fs8.existsSync(value)) return value;
+  if (value.startsWith("/")) return path11.join(root, value.slice(1));
+  return path11.resolve(root, value);
 }
 function tryResolveDiskPath(target) {
   if (fs8.existsSync(target) && fs8.statSync(target).isFile()) return target;
@@ -1894,15 +3593,15 @@ function tryResolveDiskPath(target) {
   }
   if (fs8.existsSync(target) && fs8.statSync(target).isDirectory()) {
     for (const ext of RESOLVE_EXTENSIONS) {
-      const idx = path10.join(target, "index" + ext);
+      const idx = path11.join(target, "index" + ext);
       if (fs8.existsSync(idx) && fs8.statSync(idx).isFile()) return idx;
     }
   }
   return null;
 }
 function isUnderRoot(abs, root) {
-  const rel = path10.relative(root, abs);
-  return !!rel && !rel.startsWith("..") && !path10.isAbsolute(rel);
+  const rel = path11.relative(root, abs);
+  return !!rel && !rel.startsWith("..") && !path11.isAbsolute(rel);
 }
 function resolveNodeModule(root, moduleName) {
   let pkgName;
@@ -1919,17 +3618,17 @@ function resolveNodeModule(root, moduleName) {
   let pkgDir = null;
   let dir = root;
   for (; ; ) {
-    const candidate = path10.join(dir, "node_modules", pkgName);
+    const candidate = path11.join(dir, "node_modules", pkgName);
     if (fs8.existsSync(candidate)) {
       pkgDir = candidate;
       break;
     }
-    const parent = path10.dirname(dir);
+    const parent = path11.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
   if (!pkgDir) return null;
-  const pkgJsonPath = path10.join(pkgDir, "package.json");
+  const pkgJsonPath = path11.join(pkgDir, "package.json");
   if (!fs8.existsSync(pkgJsonPath)) return null;
   let pkg;
   try {
@@ -1946,12 +3645,12 @@ function resolveNodeModule(root, moduleName) {
     const subDirs = [""];
     for (const field of ["module", "main"]) {
       if (typeof pkg[field] === "string") {
-        const dir2 = path10.dirname(pkg[field]);
+        const dir2 = path11.dirname(pkg[field]);
         if (dir2 && dir2 !== "." && !subDirs.includes(dir2)) subDirs.push(dir2);
       }
     }
     for (const dir2 of subDirs) {
-      const direct = path10.join(pkgDir, dir2, subpath);
+      const direct = path11.join(pkgDir, dir2, subpath);
       if (fs8.existsSync(direct) && fs8.statSync(direct).isFile()) return direct;
       for (const ext of RESOLVE_EXTENSIONS) {
         if (fs8.existsSync(direct + ext)) return direct + ext;
@@ -1961,24 +3660,24 @@ function resolveNodeModule(root, moduleName) {
   }
   for (const field of ["module", "jsnext:main", "jsnext", "main"]) {
     if (typeof pkg[field] === "string") {
-      const entry = path10.join(pkgDir, pkg[field]);
+      const entry = path11.join(pkgDir, pkg[field]);
       if (fs8.existsSync(entry)) return entry;
     }
   }
-  const indexFallback = path10.join(pkgDir, "index.js");
+  const indexFallback = path11.join(pkgDir, "index.js");
   if (fs8.existsSync(indexFallback)) return indexFallback;
   return null;
 }
 function resolvePackageExports(exports, key, pkgDir) {
   if (typeof exports === "string") {
-    return key === "." ? path10.join(pkgDir, exports) : null;
+    return key === "." ? path11.join(pkgDir, exports) : null;
   }
   const entry = exports[key];
   if (entry === void 0) return null;
   return resolveExportValue(entry, pkgDir);
 }
 function resolveExportValue(value, pkgDir) {
-  if (typeof value === "string") return path10.join(pkgDir, value);
+  if (typeof value === "string") return path11.join(pkgDir, value);
   if (Array.isArray(value)) {
     for (const item of value) {
       const r = resolveExportValue(item, pkgDir);
@@ -2002,7 +3701,7 @@ function resolveUrlToFile(url, root) {
     const moduleName = cleanUrl.slice("/@modules/".length);
     return resolveNodeModule(root, moduleName);
   }
-  const filePath = path10.resolve(root, cleanUrl.replace(/^\//, ""));
+  const filePath = path11.resolve(root, cleanUrl.replace(/^\//, ""));
   if (fs8.existsSync(filePath) && fs8.statSync(filePath).isFile()) {
     return filePath;
   }
@@ -2011,7 +3710,7 @@ function resolveUrlToFile(url, root) {
     if (fs8.existsSync(withExt)) return withExt;
   }
   for (const ext of RESOLVE_EXTENSIONS) {
-    const indexFile = path10.join(filePath, "index" + ext);
+    const indexFile = path11.join(filePath, "index" + ext);
     if (fs8.existsSync(indexFile)) return indexFile;
   }
   return null;
@@ -2020,7 +3719,7 @@ function isModuleRequest(url) {
   const cleanUrl = url.split("?")[0];
   if (/\.(ts|tsx|jsx|js|mjs|vue|css|json)$/.test(cleanUrl)) return true;
   if (cleanUrl.startsWith("/@modules/")) return true;
-  if (!path10.extname(cleanUrl)) return true;
+  if (!path11.extname(cleanUrl)) return true;
   return false;
 }
 function getHmrClientCode() {
@@ -2151,15 +3850,15 @@ 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";
     init_transformer();
     init_html();
     init_env();
-    __dirname_esm = path10.dirname(fileURLToPath(import.meta.url));
-    __require = createRequire3(import.meta.url);
+    __dirname_esm = path11.dirname(fileURLToPath(import.meta.url));
+    __require2 = createRequire3(import.meta.url);
     __refreshRuntimeCache = null;
     REACT_REFRESH_GLOBAL_PREAMBLE = `
 import RefreshRuntime from "/@react-refresh";
@@ -2176,11 +3875,14 @@ window.__vite_plugin_react_preamble_installed__ = true;
 });
 
 // src/server/hmr.ts
-import path11 from "path";
+import path12 from "path";
 import fs9 from "fs";
+import pc7 from "picocolors";
 async function handleFileChange(file, server) {
   const { moduleGraph, ws, config } = server;
-  const relativePath = "/" + path11.relative(config.root, file);
+  const logger = config.logger;
+  const relativePath = "/" + path12.relative(config.root, file);
+  const shortFile = path12.relative(config.root, file);
   const mods = moduleGraph.getModulesByFile(file);
   if (!mods || mods.size === 0) {
     return;
@@ -2208,6 +3910,7 @@ async function handleFileChange(file, server) {
     for (const affected of affectedModules) {
       const boundaries = moduleGraph.getHmrBoundaries(affected);
       if (boundaries.length === 0) {
+        logger.info(pc7.green("page reload ") + pc7.dim(shortFile), { timestamp: true });
         ws.send({ type: "full-reload", path: relativePath });
         return;
       }
@@ -2222,6 +3925,10 @@ async function handleFileChange(file, server) {
     }
   }
   if (updates.length > 0) {
+    logger.info(
+      updates.map((u) => pc7.green("hmr update ") + pc7.dim(u.path)).join("\n"),
+      { timestamp: true }
+    );
     ws.send({ type: "update", updates });
   }
 }
@@ -2231,51 +3938,743 @@ var init_hmr = __esm({
   }
 });
 
+// src/server/runnable-environment.ts
+var runnable_environment_exports = {};
+__export(runnable_environment_exports, {
+  NastiModuleRunner: () => NastiModuleRunner,
+  createModuleRunner: () => createModuleRunner
+});
+import path13 from "path";
+import fs10 from "fs";
+import { builtinModules as builtinModules3, 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 debug5, NODE_BUILTINS3, NastiModuleRunner, AsyncFunction;
+var init_runnable_environment = __esm({
+  "src/server/runnable-environment.ts"() {
+    "use strict";
+    init_transformer();
+    init_env();
+    init_debug();
+    debug5 = createDebugger("nasti:ssr");
+    NODE_BUILTINS3 = /* @__PURE__ */ new Set([...builtinModules3, ...builtinModules3.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(path13.join(this.config.root, "package.json"));
+        const handlers = {
+          fetchModule: async (id, importer) => this.fetchModule(id, importer),
+          getBuiltins: () => [/^node:/, ...builtinModules3]
+        };
+        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 (path13.isAbsolute(rawUrl) && fs10.existsSync(rawUrl.split("?")[0])) return rawUrl;
+        const clean = rawUrl.replace(/^\//, "");
+        return path13.resolve(this.config.root, clean);
+      }
+      /**
+       * fetchModule（invoke 契约方法）：环境管线产出 runner 可执行代码。
+       * resolve（插件 resolveId → 文件系统）→ load/读盘 → 插件 transform →
+       * oxc（TS/JSX）→ moduleRunnerTransform。
+       */
+      async fetchModule(id, importer) {
+        if (NODE_BUILTINS3.has(id)) return { externalize: id };
+        if (!id.startsWith(".") && !path13.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 : path13.resolve(path13.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 (fs10.existsSync(cleanId)) {
+          code = fs10.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);
+        debug5?.(`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 (fs10.existsSync(clean) && fs10.statSync(clean).isFile()) return id;
+        const jsMatch = clean.match(/^(.*)\.([mc]?)jsx?$/);
+        if (jsMatch) {
+          for (const tsExt of [`.${jsMatch[2]}ts`, `.${jsMatch[2]}tsx`]) {
+            if (fs10.existsSync(jsMatch[1] + tsExt)) return jsMatch[1] + tsExt + query;
+          }
+        }
+        for (const ext of this.config.resolve.extensions) {
+          if (fs10.existsSync(clean + ext)) return clean + ext + query;
+        }
+        for (const ext of this.config.resolve.extensions) {
+          const indexPath = path13.join(clean, `index${ext}`);
+          if (fs10.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_BUILTINS3.has(dep) || !dep.startsWith(".") && !path13.isAbsolute(dep) && !dep.startsWith("\0")) {
+            return this.importExternal(dep);
+          }
+          const depId = dep.startsWith(".") ? this.completeExtension(path13.resolve(path13.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:") || !path13.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_BUILTINS3.has(spec)) return `node:${spec}`;
+        try {
+          return pathToFileURL4(this.require.resolve(spec)).href;
+        } catch {
+          return spec;
+        }
+      }
+    };
+    AsyncFunction = Object.getPrototypeOf(async function() {
+    }).constructor;
+  }
+});
+
+// src/server/bundled/dev-engine.ts
+var dev_engine_exports = {};
+__export(dev_engine_exports, {
+  createBundledDevServer: () => createBundledDevServer
+});
+import path14 from "path";
+import crypto3 from "crypto";
+import { WebSocketServer as WsServer2 } from "ws";
+import pc8 from "picocolors";
+async function createBundledDevServer(opts) {
+  const { config, clientEnv, httpServer } = opts;
+  const logger = config.logger;
+  let devFn;
+  let refreshWrapperFn = null;
+  try {
+    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.`
+    );
+  }
+  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(pc8.green("page reload ") + pc8.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(
+        pc8.green("hmr update ") + pc8.dim(changedFiles.map((f) => path14.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
+        }
+      }
+    },
+    {
+      ...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(pc8.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(pc8.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);
+      }
+    }
+  );
+  await engine.run();
+  await engine.ensureCurrentBuildFinish();
+  logger.info(pc8.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 patchHit = patches.get(pathname.replace(/^\//, ""));
+      if (patchHit) {
+        res.setHeader("Content-Type", "application/javascript");
+        res.setHeader("Cache-Control", "no-store");
+        res.end(patchHit.content);
+        return;
+      }
+      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[path14.extname(fileName)] ?? "application/octet-stream");
+        res.setHeader("Cache-Control", "no-cache");
+        res.end(hit.content);
+        return;
+      }
+      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;
+        }
+      }
+      next();
+    })().catch((err) => {
+      config.logger.error(pc8.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) => path14.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 (id === RESOLVED_PREAMBLE_ID) {
+        return { code: BUNDLED_PREAMBLE_CODE, moduleType: "js" };
+      }
+      return null;
+    },
+    transform(code, id) {
+      if (!entryIds.has(path14.resolve(id.split("?")[0]))) return null;
+      return { code: `import ${JSON.stringify(PREAMBLE_SPEC)};
+${code}`, map: null };
+    }
+  };
+}
+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 = path14.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 });
+      }
+      get(fileName) {
+        return this.files.get(fileName);
+      }
+      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);
+      }
+    }
+  }
+}
+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 true;
+}
+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)';
+  }
+}
+export const __hmr_import = (module) => import(/* @vite-ignore */ module);
+`;
+  }
+});
+
 // src/server/index.ts
 var server_exports = {};
 __export(server_exports, {
   createServer: () => createServer
 });
 import http from "http";
-import path12 from "path";
+import path15 from "path";
 import os from "os";
 import connect from "connect";
 import sirv from "sirv";
 import { watch } from "chokidar";
-import pc3 from "picocolors";
+import pc9 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 = path12.resolve(config.root, "public");
+  const publicDir = path15.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 = path12.resolve(config.root, config.build.outDir);
+  const outDirAbs = path15.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 + path12.sep)) return true;
-      const rel = path12.relative(config.root, filePath);
-      if (!rel || rel.startsWith("..") || path12.isAbsolute(rel)) return false;
-      for (const seg of rel.split(path12.sep)) {
+      if (filePath === outDirAbs || filePath.startsWith(outDirAbs + path15.sep)) return true;
+      const rel = path15.relative(config.root, filePath);
+      if (!rel || rel.startsWith("..") || path15.isAbsolute(rel)) return false;
+      for (const seg of rel.split(path15.sep)) {
         if (ignoredSegments.has(seg)) return true;
       }
       return false;
@@ -2284,9 +4683,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 = {
@@ -2295,6 +4696,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;
@@ -2304,23 +4706,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(pc3.cyan("  nasti dev server") + pc3.dim(` v${"1.7.1"}`));
-          console.log();
-          console.log(`  ${pc3.green(">")} Local:   ${pc3.cyan(localUrl)}`);
-          if (networkUrl) {
-            console.log(`  ${pc3.green(">")} Network: ${pc3.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(
+            `
+  ${pc9.cyan(pc9.bold("NASTI"))} ${pc9.cyan(`v${"2.0.0"}`)}  ${pc9.dim("ready in")} ${pc9.bold(readyIn)} ${pc9.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(pc3.yellow(`Port ${currentPort - 1} is in use, trying ${currentPort}...`));
+            logger.info(pc9.yellow(`Port ${currentPort - 1} is in use, trying ${currentPort}...`));
             httpServer.listen(currentPort, host);
           } else {
             reject(err);
@@ -2333,8 +4739,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();
@@ -2367,16 +4778,13 @@ 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();
   }
 });
 
@@ -2387,16 +4795,16 @@ init_build();
 // src/build/electron.ts
 init_config();
 init_resolve();
-import path9 from "path";
+import path10 from "path";
 import fs7 from "fs";
 import { rolldown as rolldown2 } from "rolldown";
-import pc2 from "picocolors";
+import pc5 from "picocolors";
 
 // src/plugins/electron.ts
-import { builtinModules } from "module";
-var NODE_BUILTINS = /* @__PURE__ */ new Set([
-  ...builtinModules,
-  ...builtinModules.map((m) => `node:${m}`)
+import { builtinModules as builtinModules2 } from "module";
+var NODE_BUILTINS2 = /* @__PURE__ */ new Set([
+  ...builtinModules2,
+  ...builtinModules2.map((m) => `node:${m}`)
 ]);
 var ELECTRON_MODULES = /* @__PURE__ */ new Set([
   "electron",
@@ -2407,7 +4815,7 @@ var ELECTRON_MODULES = /* @__PURE__ */ new Set([
 function electronPlugin(config) {
   const external = /* @__PURE__ */ new Set([
     ...ELECTRON_MODULES,
-    ...NODE_BUILTINS,
+    ...NODE_BUILTINS2,
     ...config.electron.external ?? []
   ]);
   return {
@@ -2432,16 +4840,16 @@ async function buildElectron(inlineConfig = {}) {
   const config = await resolveConfig({ ...inlineConfig, target: "electron" }, "build");
   const startTime = performance.now();
   assertElectronVersion(config);
-  console.log(pc2.cyan("\n\u26A1 nasti build (electron)") + pc2.dim(` v${"1.7.1"}`));
-  console.log(pc2.dim(`  root: ${config.root}`));
-  console.log(pc2.dim(`  mode: ${config.mode}`));
-  console.log(pc2.dim(`  target: electron (\u2265 ${config.electron.minVersion})`));
-  const outDir = path9.resolve(config.root, config.build.outDir);
+  console.log(pc5.cyan("\n\u26A1 nasti build (electron)") + pc5.dim(` v${"2.0.0"}`));
+  console.log(pc5.dim(`  root: ${config.root}`));
+  console.log(pc5.dim(`  mode: ${config.mode}`));
+  console.log(pc5.dim(`  target: electron (\u2265 ${config.electron.minVersion})`));
+  const outDir = path10.resolve(config.root, config.build.outDir);
   if (config.build.emptyOutDir && fs7.existsSync(outDir)) {
     fs7.rmSync(outDir, { recursive: true, force: true });
   }
   fs7.mkdirSync(outDir, { recursive: true });
-  const rendererOutDir = path9.join(outDir, "renderer");
+  const rendererOutDir = path10.join(outDir, "renderer");
   const { build: build2 } = await Promise.resolve().then(() => (init_build(), build_exports));
   await build2({
     ...inlineConfig,
@@ -2452,7 +4860,7 @@ async function buildElectron(inlineConfig = {}) {
       emptyOutDir: false
     }
   });
-  const mainEntry = path9.resolve(config.root, config.electron.main);
+  const mainEntry = path10.resolve(config.root, config.electron.main);
   if (!fs7.existsSync(mainEntry)) {
     throw new Error(
       `Electron main entry not found: ${config.electron.main}
@@ -2468,10 +4876,10 @@ async function buildElectron(inlineConfig = {}) {
   const preloadFiles = [];
   for (const entry of preloadEntries) {
     if (!fs7.existsSync(entry)) {
-      console.warn(pc2.yellow(`  \u26A0 preload entry not found, skipped: ${entry}`));
+      console.warn(pc5.yellow(`  \u26A0 preload entry not found, skipped: ${entry}`));
       continue;
     }
-    const base = path9.basename(entry).replace(/\.[^.]+$/, "");
+    const base = path10.basename(entry).replace(/\.[^.]+$/, "");
     const out = outFileName(outDir, base, config.electron.preloadFormat);
     await bundleNode(config, entry, {
       outFile: out,
@@ -2481,12 +4889,12 @@ async function buildElectron(inlineConfig = {}) {
     preloadFiles.push(out);
   }
   const elapsed = ((performance.now() - startTime) / 1e3).toFixed(2);
-  console.log(pc2.green(`
+  console.log(pc5.green(`
 \u2713 Electron build complete in ${elapsed}s`));
-  console.log(pc2.dim(`  renderer: ${path9.relative(config.root, rendererOutDir)}/`));
-  console.log(pc2.dim(`  main:     ${path9.relative(config.root, mainFile)}`));
+  console.log(pc5.dim(`  renderer: ${path10.relative(config.root, rendererOutDir)}/`));
+  console.log(pc5.dim(`  main:     ${path10.relative(config.root, mainFile)}`));
   for (const pf of preloadFiles) {
-    console.log(pc2.dim(`  preload:  ${path9.relative(config.root, pf)}`));
+    console.log(pc5.dim(`  preload:  ${path10.relative(config.root, pf)}`));
   }
   console.log();
   return { rendererOutDir, mainFile, preloadFiles };
@@ -2512,15 +4920,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)]
   });
-  fs7.mkdirSync(path9.dirname(opts.outFile), { recursive: true });
-  await bundle.write({
+  fs7.mkdirSync(path10.dirname(opts.outFile), { recursive: true });
+  await bundle2.write({
     sourcemap: !!config.build.sourcemap,
     minify: !!config.build.minify,
     // 允许用户微调 output；但主进程 / preload 的单文件约束由下方键强制保证
@@ -2529,24 +4937,24 @@ async function bundleNode(config, entry, opts) {
     format: opts.format === "cjs" ? "cjs" : "esm",
     codeSplitting: false
   });
-  await bundle.close();
-  console.log(pc2.dim(`  \u2713 ${opts.label} \u2192 ${path9.relative(config.root, opts.outFile)}`));
+  await bundle2.close();
+  console.log(pc5.dim(`  \u2713 ${opts.label} \u2192 ${path10.relative(config.root, opts.outFile)}`));
   return opts.outFile;
 }
 function outFileName(outDir, base, format) {
   const ext = format === "cjs" ? ".cjs" : ".mjs";
-  return path9.join(outDir, base + ext);
+  return path10.join(outDir, base + ext);
 }
 function normalizePreload(preload, root) {
   const list = Array.isArray(preload) ? preload : preload ? [preload] : [];
-  return list.map((p) => path9.resolve(root, p));
+  return list.map((p) => path10.resolve(root, p));
 }
 function assertElectronVersion(config) {
   const min = config.electron.minVersion;
   const installed = detectInstalledElectron(config.root);
   if (installed && installed < min) {
     console.warn(
-      pc2.yellow(
+      pc5.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`
       )
     );
@@ -2554,7 +4962,7 @@ function assertElectronVersion(config) {
 }
 function detectInstalledElectron(root) {
   try {
-    const pkgPath = path9.resolve(root, "node_modules/electron/package.json");
+    const pkgPath = path10.resolve(root, "node_modules/electron/package.json");
     if (!fs7.existsSync(pkgPath)) return null;
     const pkg = JSON.parse(fs7.readFileSync(pkgPath, "utf-8"));
     const major = parseInt(String(pkg.version).split(".")[0], 10);
@@ -2569,12 +4977,12 @@ init_server();
 
 // src/server/electron-dev.ts
 init_config();
-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";
 init_resolve();
 init_transformer();
@@ -2583,17 +4991,17 @@ 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.0"}`));
   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, {
@@ -2603,9 +5011,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,
@@ -2616,13 +5024,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"
       )
     );
@@ -2637,14 +5045,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;
@@ -2656,7 +5064,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;
@@ -2674,7 +5082,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;
@@ -2714,14 +5122,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,
@@ -2730,17 +5138,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 {
@@ -2751,7 +5159,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}`
       )
     );
@@ -2759,7 +5167,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`
       )
     );
@@ -2767,10 +5175,10 @@ function warnElectronVersion(config) {
 }
 
 // src/plugins/monaco-editor.ts
-import path14 from "path";
-import fs11 from "fs";
-import crypto3 from "crypto";
-import { createRequire as createRequire5 } from "module";
+import path17 from "path";
+import fs12 from "fs";
+import crypto4 from "crypto";
+import { createRequire as createRequire6 } from "module";
 var DEFAULT_WORKERS = {
   editorWorkerService: "monaco-editor/esm/vs/editor/editor.worker",
   css: "monaco-editor/esm/vs/language/css/css.worker",
@@ -2789,9 +5197,9 @@ function normalizePublicPath(p) {
 }
 function readMonacoVersion(root) {
   try {
-    const require2 = createRequire5(path14.resolve(root, "package.json"));
+    const require2 = createRequire6(path17.resolve(root, "package.json"));
     const pkgJsonPath = require2.resolve("monaco-editor/package.json", { paths: [root] });
-    const pkg = JSON.parse(fs11.readFileSync(pkgJsonPath, "utf-8"));
+    const pkg = JSON.parse(fs12.readFileSync(pkgJsonPath, "utf-8"));
     return typeof pkg.version === "string" ? pkg.version : "unknown";
   } catch {
     return "unknown";
@@ -2811,32 +5219,32 @@ function monacoEditorPlugin(options = {}) {
   let cacheDir = "";
   const building = /* @__PURE__ */ new Map();
   async function buildWorker(worker) {
-    const cacheFile = path14.join(cacheDir, `${worker.label}.worker.js`);
-    if (fs11.existsSync(cacheFile)) return cacheFile;
+    const cacheFile = path17.join(cacheDir, `${worker.label}.worker.js`);
+    if (fs12.existsSync(cacheFile)) return cacheFile;
     const existing = building.get(worker.label);
     if (existing) return existing;
     const task = (async () => {
       const { rolldown: rolldown4 } = await import("rolldown");
-      const require2 = createRequire5(path14.resolve(resolvedConfig.root, "package.json"));
+      const require2 = createRequire6(path17.resolve(resolvedConfig.root, "package.json"));
       let entry;
       try {
         entry = require2.resolve(worker.entry, { paths: [resolvedConfig.root] });
       } catch {
         entry = require2.resolve(worker.entry + ".js", { paths: [resolvedConfig.root] });
       }
-      fs11.mkdirSync(cacheDir, { recursive: true });
-      const bundle = await rolldown4({
+      fs12.mkdirSync(cacheDir, { recursive: true });
+      const bundle2 = await rolldown4({
         input: entry,
         platform: "browser"
       });
-      await bundle.write({
+      await bundle2.write({
         file: cacheFile,
         format: "iife",
         sourcemap: false,
         minify: true,
         codeSplitting: false
       });
-      await bundle.close();
+      await bundle2.close();
       return cacheFile;
     })();
     building.set(worker.label, task);
@@ -2883,13 +5291,13 @@ function monacoEditorPlugin(options = {}) {
     configResolved(config) {
       resolvedConfig = config;
       const version = readMonacoVersion(config.root);
-      const key = crypto3.createHash("sha1").update(version + "|" + publicPath).digest("hex").slice(0, 8);
-      cacheDir = path14.resolve(config.root, "node_modules/.nasti/monaco", key);
+      const key = crypto4.createHash("sha1").update(version + "|" + publicPath).digest("hex").slice(0, 8);
+      cacheDir = path17.resolve(config.root, "node_modules/.nasti/monaco", key);
     },
     async configureServer(server) {
       const shouldBuild = !isCDN(publicPath) || forceBuildCDN;
       const watcher = server.watcher;
-      const monacoDir = path14.resolve(resolvedConfig.root, "node_modules/monaco-editor");
+      const monacoDir = path17.resolve(resolvedConfig.root, "node_modules/monaco-editor");
       try {
         watcher?.unwatch?.(monacoDir);
       } catch {
@@ -2919,7 +5327,7 @@ function monacoEditorPlugin(options = {}) {
             const file = await buildWorker(worker);
             res.setHeader("Content-Type", "application/javascript; charset=utf-8");
             res.setHeader("Cache-Control", "public, max-age=604800, immutable");
-            fs11.createReadStream(file).pipe(res);
+            fs12.createReadStream(file).pipe(res);
           } catch (e) {
             res.statusCode = 500;
             res.end(`Monaco worker build failed: ${e.message}`);
@@ -2954,16 +5362,16 @@ self.monaco = monaco;`,
         resolvedConfig.root,
         resolvedConfig.build.outDir,
         resolvedConfig.base
-      ) : isCDN(publicPath) ? path14.resolve(resolvedConfig.root, resolvedConfig.build.outDir, "monaco") : path14.resolve(
+      ) : isCDN(publicPath) ? path17.resolve(resolvedConfig.root, resolvedConfig.build.outDir, "monaco") : path17.resolve(
         resolvedConfig.root,
         resolvedConfig.build.outDir,
         publicPath.replace(/^\//, "")
       );
-      fs11.mkdirSync(outDir, { recursive: true });
+      fs12.mkdirSync(outDir, { recursive: true });
       for (const worker of workers) {
         try {
           const cacheFile = await buildWorker(worker);
-          fs11.copyFileSync(cacheFile, path14.join(outDir, `${worker.label}.worker.js`));
+          fs12.copyFileSync(cacheFile, path17.join(outDir, `${worker.label}.worker.js`));
         } catch (e) {
           throw new Error(
             `[nasti:monaco-editor] worker build failed for "${worker.label}": ${e.message}
@@ -2974,14 +5382,32 @@ ${e.stack || ""}`
     }
   };
 }
+
+// src/index.ts
+init_environment();
+init_hot_channel();
+init_logger();
+init_debug();
+init_env();
 export {
+  LogLevels,
+  NastiEnvironment,
   build,
   buildElectron,
+  buildEnvDefine,
+  createDebugger,
+  createLogger,
+  createNoopHotChannel,
   createServer,
+  createWsHotChannel,
   defineConfig,
   electronPlugin,
+  loadEnv,
   monacoEditorPlugin,
+  printServerUrls,
   resolveConfig,
+  resolveEnvironmentPlugins,
+  ssrDefineOverrides,
   startElectronDev
 };
 //# sourceMappingURL=index.js.map