@nasti-toolchain/nasti 2.2.0 → 2.4.0

package/dist/index.cjs

@@ -5,10 +5,10 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __glob = (map) => (path18) => {
-  var fn = map[path18];
+var __glob = (map) => (path19) => {
+  var fn = map[path19];
   if (fn) return fn();
-  throw new Error("Module not found in bundle: " + path18);
+  throw new Error("Module not found in bundle: " + path19);
 };
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
@@ -221,6 +221,92 @@ var init_logger = __esm({
   }
 });
 
+// src/core/plugin-api.ts
+function orderPlugins(plugins) {
+  const baseline = plugins.map((plugin, index2) => ({ plugin, index: index2 })).sort((a, b) => enforceRank(a.plugin) - enforceRank(b.plugin) || a.index - b.index).map(({ plugin }) => plugin);
+  const indexesByName = /* @__PURE__ */ new Map();
+  baseline.forEach((plugin, index2) => {
+    const indexes = indexesByName.get(plugin.name) ?? [];
+    indexes.push(index2);
+    indexesByName.set(plugin.name, indexes);
+  });
+  const edges = baseline.map(() => /* @__PURE__ */ new Set());
+  const indegree = baseline.map(() => 0);
+  const addEdge = (from, to) => {
+    if (from === to || edges[from].has(to)) return;
+    edges[from].add(to);
+    indegree[to]++;
+  };
+  baseline.forEach((plugin, current) => {
+    for (const dependency of plugin.pre ?? []) {
+      for (const before of indexesByName.get(dependency) ?? []) addEdge(before, current);
+    }
+    for (const dependency of plugin.post ?? []) {
+      for (const after of indexesByName.get(dependency) ?? []) addEdge(current, after);
+    }
+  });
+  const ready = indegree.map((degree, index2) => ({ degree, index: index2 })).filter(({ degree }) => degree === 0).map(({ index: index2 }) => index2);
+  const ordered = [];
+  while (ready.length > 0) {
+    ready.sort((a, b) => a - b);
+    const current = ready.shift();
+    ordered.push(baseline[current]);
+    for (const next of edges[current]) {
+      indegree[next]--;
+      if (indegree[next] === 0) ready.push(next);
+    }
+  }
+  if (ordered.length !== baseline.length) {
+    const cyclic = baseline.filter((_, index2) => indegree[index2] > 0).map((plugin) => plugin.name);
+    throw new Error(
+      `[nasti] circular plugin setup dependency: ${[...new Set(cyclic)].join(", ")}`
+    );
+  }
+  return ordered;
+}
+async function setupPluginApi(config, plugins) {
+  const exposed = /* @__PURE__ */ new Map();
+  const api = {
+    config,
+    logger: config.logger,
+    expose(key, value) {
+      if (exposed.has(key) && exposed.get(key) !== value) {
+        throw new Error(`[nasti] plugin API key already exposed: ${String(key)}`);
+      }
+      exposed.set(key, value);
+    },
+    useExposed(key) {
+      return exposed.get(key);
+    }
+  };
+  apiByConfig.set(config, api);
+  for (const plugin of plugins) {
+    await plugin.setup?.(api);
+  }
+  return api;
+}
+function getPluginApi(config) {
+  const api = apiByConfig.get(config);
+  if (!api) {
+    throw new Error(
+      "[nasti] internal: plugin API requested before setup; getPluginApi requires the original ResolvedConfig reference registered by setupPluginApi, not a shallow copy"
+    );
+  }
+  return api;
+}
+function enforceRank(plugin) {
+  if (plugin.enforce === "pre") return 0;
+  if (plugin.enforce === "post") return 2;
+  return 1;
+}
+var apiByConfig;
+var init_plugin_api = __esm({
+  "src/core/plugin-api.ts"() {
+    "use strict";
+    apiByConfig = /* @__PURE__ */ new WeakMap();
+  }
+});
+
 // src/config/index.ts
 function loadTsconfigPaths(root) {
   const tsconfigPath = import_node_path.default.resolve(root, "tsconfig.json");
@@ -258,6 +344,43 @@ async function loadConfigFromFile(root) {
   }
   return {};
 }
+function detectFramework(root) {
+  const sourceRoot = import_node_path.default.resolve(root, "src");
+  if (containsVueFile(sourceRoot)) return "vue";
+  const packagePath = import_node_path.default.resolve(root, "package.json");
+  if (import_node_fs.default.existsSync(packagePath)) {
+    try {
+      const pkg = JSON.parse(import_node_fs.default.readFileSync(packagePath, "utf-8"));
+      const dependencies = {
+        ...pkg.dependencies ?? {},
+        ...pkg.devDependencies ?? {},
+        ...pkg.peerDependencies ?? {},
+        ...pkg.optionalDependencies ?? {}
+      };
+      const hasVue = "vue" in dependencies || "@vue/runtime-dom" in dependencies;
+      const hasReact = "react" in dependencies || "react-dom" in dependencies;
+      if (hasVue && !hasReact) return "vue";
+      if (hasReact) return "react";
+      if (hasVue) return "vue";
+    } catch {
+    }
+  }
+  return "react";
+}
+function containsVueFile(dir, depth = 0) {
+  if (depth > 5 || !import_node_fs.default.existsSync(dir)) return false;
+  try {
+    for (const entry of import_node_fs.default.readdirSync(dir, { withFileTypes: true })) {
+      if (entry.isFile() && entry.name.endsWith(".vue")) return true;
+      if (entry.isDirectory() && entry.name !== "node_modules" && entry.name !== "dist" && containsVueFile(import_node_path.default.join(dir, entry.name), depth + 1)) {
+        return true;
+      }
+    }
+  } catch {
+    return false;
+  }
+  return false;
+}
 async function loadTsConfig(filePath) {
   const { transformSync: transformSync2 } = await import("oxc-transform");
   const code = import_node_fs.default.readFileSync(filePath, "utf-8");
@@ -304,7 +427,7 @@ async function resolveConfig(inlineConfig = {}, command) {
     base: merged.base ?? defaults.base,
     mode,
     target: merged.target ?? defaults.target,
-    framework: merged.framework ?? defaults.framework,
+    framework: (merged.framework ?? defaults.framework) === "auto" ? detectFramework(root) : merged.framework,
     command,
     resolve: {
       // tsconfig paths 优先级最低：tsconfig < defaults < user config
@@ -351,7 +474,13 @@ async function resolveConfig(inlineConfig = {}, command) {
       if (envOptions.build) Object.assign(resolved.build, envOptions.build);
       resolved.environments.client = {
         consumer,
-        entry: [],
+        buildEnabled: envOptions.buildEnabled ?? true,
+        entry: normalizeEnvironmentEntries(envOptions.entry, root),
+        html: import_node_path.default.resolve(
+          root,
+          envOptions.html ?? (resolved.target === "electron" ? resolved.electron.renderer : "index.html")
+        ),
+        driver: envOptions.driver,
         // 同引用 —— 精确镜像（assertClientEnvironmentMirror 校验）
         resolve: resolved.resolve,
         build: resolved.build
@@ -360,7 +489,10 @@ async function resolveConfig(inlineConfig = {}, command) {
     }
     resolved.environments[name] = {
       consumer,
-      entry: (Array.isArray(envOptions.entry) ? envOptions.entry : envOptions.entry ? [envOptions.entry] : []).map((e) => import_node_path.default.resolve(root, e)),
+      buildEnabled: envOptions.buildEnabled ?? true,
+      entry: normalizeEnvironmentEntries(envOptions.entry, root),
+      html: envOptions.consumer === "client" && envOptions.html ? import_node_path.default.resolve(root, envOptions.html) : void 0,
+      driver: envOptions.driver,
       resolve: {
         alias: { ...resolved.resolve.alias, ...envOptions.resolve?.alias },
         extensions: envOptions.resolve?.extensions ?? [...resolved.resolve.extensions],
@@ -379,12 +511,13 @@ async function resolveConfig(inlineConfig = {}, command) {
     };
   }
   assertClientEnvironmentMirror(resolved);
-  const filteredPlugins = rawPlugins.filter((p) => {
+  const filteredPlugins = orderPlugins(rawPlugins.filter((p) => {
     if (!p.apply) return true;
     if (typeof p.apply === "function") return p.apply(resolved, env);
     return p.apply === command;
-  });
+  }));
   resolved.plugins = filteredPlugins;
+  await setupPluginApi(resolved, filteredPlugins);
   if (resolved.target === "electron") {
     const autoExternal = detectNativeDeps(root);
     if (autoExternal.length > 0) {
@@ -400,6 +533,10 @@ async function resolveConfig(inlineConfig = {}, command) {
   }
   return resolved;
 }
+function normalizeEnvironmentEntries(entry, root) {
+  const entries = Array.isArray(entry) ? entry : entry ? [entry] : [];
+  return entries.map((item) => import_node_path.default.resolve(root, item));
+}
 function detectNativeDeps(root) {
   const result = /* @__PURE__ */ new Set();
   const pkgJsonPath = import_node_path.default.resolve(root, "package.json");
@@ -520,6 +657,7 @@ var init_config = __esm({
     import_node_fs = __toESM(require("fs"), 1);
     init_defaults();
     init_logger();
+    init_plugin_api();
     CONFIG_FILES = [
       "nasti.config.ts",
       "nasti.config.js",
@@ -578,6 +716,7 @@ function resolvePlugin(config) {
       }
       if (!source.startsWith("/") && !source.startsWith(".")) {
         if (vueRuntimeEntry && source === "vue") return vueRuntimeEntry;
+        if (config.command === "build") return null;
         try {
           const resolved = require2.resolve(source, {
             paths: [importer ? import_node_path2.default.dirname(importer) : config.root]
@@ -713,27 +852,27 @@ var require_process = __commonJS({
 var require_filesystem = __commonJS({
   "node_modules/detect-libc/lib/filesystem.js"(exports2, module2) {
     "use strict";
-    var fs13 = require("fs");
+    var fs14 = require("fs");
     var LDD_PATH = "/usr/bin/ldd";
     var SELF_PATH = "/proc/self/exe";
     var MAX_LENGTH = 2048;
-    var readFileSync = (path18) => {
-      const fd = fs13.openSync(path18, "r");
+    var readFileSync = (path19) => {
+      const fd = fs14.openSync(path19, "r");
       const buffer = Buffer.alloc(MAX_LENGTH);
-      const bytesRead = fs13.readSync(fd, buffer, 0, MAX_LENGTH, 0);
-      fs13.close(fd, () => {
+      const bytesRead = fs14.readSync(fd, buffer, 0, MAX_LENGTH, 0);
+      fs14.close(fd, () => {
       });
       return buffer.subarray(0, bytesRead);
     };
-    var readFile = (path18) => new Promise((resolve, reject) => {
-      fs13.open(path18, "r", (err, fd) => {
+    var readFile = (path19) => new Promise((resolve, reject) => {
+      fs14.open(path19, "r", (err, fd) => {
         if (err) {
           reject(err);
         } else {
           const buffer = Buffer.alloc(MAX_LENGTH);
-          fs13.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
+          fs14.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
             resolve(buffer.subarray(0, bytesRead));
-            fs13.close(fd, () => {
+            fs14.close(fd, () => {
             });
           });
         }
@@ -845,11 +984,11 @@ var require_detect_libc = __commonJS({
       }
       return null;
     };
-    var familyFromInterpreterPath = (path18) => {
-      if (path18) {
-        if (path18.includes("/ld-musl-")) {
+    var familyFromInterpreterPath = (path19) => {
+      if (path19) {
+        if (path19.includes("/ld-musl-")) {
           return MUSL;
-        } else if (path18.includes("/ld-linux-")) {
+        } else if (path19.includes("/ld-linux-")) {
           return GLIBC;
         }
       }
@@ -896,8 +1035,8 @@ var require_detect_libc = __commonJS({
       cachedFamilyInterpreter = null;
       try {
         const selfContent = await readFile(SELF_PATH);
-        const path18 = interpreterPath(selfContent);
-        cachedFamilyInterpreter = familyFromInterpreterPath(path18);
+        const path19 = interpreterPath(selfContent);
+        cachedFamilyInterpreter = familyFromInterpreterPath(path19);
       } catch (e) {
       }
       return cachedFamilyInterpreter;
@@ -909,8 +1048,8 @@ var require_detect_libc = __commonJS({
       cachedFamilyInterpreter = null;
       try {
         const selfContent = readFileSync(SELF_PATH);
-        const path18 = interpreterPath(selfContent);
-        cachedFamilyInterpreter = familyFromInterpreterPath(path18);
+        const path19 = interpreterPath(selfContent);
+        cachedFamilyInterpreter = familyFromInterpreterPath(path19);
       } catch (e) {
       }
       return cachedFamilyInterpreter;
@@ -1915,7 +2054,8 @@ function transformCode(filename, code, options = {}) {
       importSource: options.jsxImportSource ?? "react",
       refresh: options.reactRefresh ?? false
     } : void 0,
-    sourcemap: options.sourcemap ?? true
+    sourcemap: options.sourcemap ?? true,
+    target: options.target
   });
   if (result.errors && result.errors.length > 0) {
     const msg = result.errors.map((e) => e.message ?? String(e)).join("\n");
@@ -1973,8 +2113,8 @@ function vuePlugin(config) {
       let descriptor = descriptorCache.get(filePath);
       if (!descriptor) {
         try {
-          const fs13 = await import("fs");
-          const source = fs13.readFileSync(filePath, "utf-8");
+          const fs14 = await import("fs");
+          const source = fs14.readFileSync(filePath, "utf-8");
           const parsed = sfc.parse(source, { filename: filePath });
           if (parsed.errors.length) return null;
           descriptor = parsed.descriptor;
@@ -2118,7 +2258,7 @@ function htmlPlugin(config) {
     transformIndexHtml(html) {
       const tags = [];
       if (config.command === "serve") {
-        const isReactLike = config.framework === "react" || config.framework === "auto";
+        const isReactLike = config.framework === "react";
         if (isReactLike) {
           tags.push({
             tag: "script",
@@ -2172,8 +2312,8 @@ function serializeTag(tag) {
   }
   return `  <${tag.tag}${attrs}>${children}</${tag.tag}>`;
 }
-async function readHtmlFile(root) {
-  const htmlPath = import_node_path6.default.resolve(root, "index.html");
+async function readHtmlFile(root, htmlFile = "index.html") {
+  const htmlPath = import_node_path6.default.isAbsolute(htmlFile) ? htmlFile : import_node_path6.default.resolve(root, htmlFile);
   if (!import_node_fs4.default.existsSync(htmlPath)) return null;
   return import_node_fs4.default.readFileSync(htmlPath, "utf-8");
 }
@@ -2196,16 +2336,27 @@ window.__vite_plugin_react_preamble_installed__ = true;
 // src/plugins/builtins.ts
 function resolvePluginList(config, userPlugins, opts = {}) {
   const isServe = config.command === "serve";
+  let environmentOptions;
+  if (opts.environmentName) {
+    environmentOptions = config.environments[opts.environmentName];
+    if (!environmentOptions) {
+      throw new Error(
+        `[nasti] unknown environment "${opts.environmentName}" \u2014 declare it in config.environments`
+      );
+    }
+  }
+  const pluginConfig = environmentOptions ? { ...config, resolve: environmentOptions.resolve, build: environmentOptions.build } : config;
+  const consumer = opts.consumer ?? environmentOptions?.consumer;
   return [
     // vuePlugin 排最前（enforce: 'pre' 语义）：.vue 先编译成 JS 再走后续管道
-    ...config.framework === "vue" ? [vuePlugin(config)] : [],
-    resolvePlugin(config),
-    cssPlugin(config, opts.cssEngine, opts.consumer),
-    assetsPlugin(config),
-    ...isServe ? [htmlPlugin(config)] : [],
+    ...config.framework === "vue" ? [vuePlugin(pluginConfig)] : [],
+    resolvePlugin(pluginConfig),
+    cssPlugin(pluginConfig, opts.cssEngine, consumer),
+    assetsPlugin(pluginConfig),
+    ...isServe ? [htmlPlugin(pluginConfig)] : [],
     ...userPlugins,
     // cssPostPlugin 最后（enforce: 'post' 语义）：renderChunk 聚合抽取
-    ...!isServe && opts.cssEngine ? [cssPostPlugin(config, opts.cssEngine)] : []
+    ...!isServe && opts.cssEngine ? [cssPostPlugin(pluginConfig, opts.cssEngine)] : []
   ];
 }
 var init_builtins = __esm({
@@ -2221,21 +2372,11 @@ var init_builtins = __esm({
 });
 
 // src/core/plugin-container.ts
-function sortPlugins(plugins) {
-  const pre = [];
-  const normal = [];
-  const post = [];
-  for (const plugin of plugins) {
-    if (plugin.enforce === "pre") pre.push(plugin);
-    else if (plugin.enforce === "post") post.push(plugin);
-    else normal.push(plugin);
-  }
-  return [...pre, ...normal, ...post];
-}
 var PluginContainer;
 var init_plugin_container = __esm({
   "src/core/plugin-container.ts"() {
     "use strict";
+    init_plugin_api();
     PluginContainer = class {
       plugins;
       config;
@@ -2246,7 +2387,7 @@ var init_plugin_container = __esm({
       constructor(config, environment) {
         this.config = config;
         this.environment = environment;
-        this.plugins = sortPlugins(config.plugins);
+        this.plugins = orderPlugins(config.plugins);
         this.ctx = this.createContext();
       }
       createContext() {
@@ -2345,17 +2486,35 @@ var init_plugin_container = __esm({
   }
 });
 
+// src/core/url.ts
+function removeTimestampQuery(url) {
+  const hashIndex = url.indexOf("#");
+  const hash = hashIndex >= 0 ? url.slice(hashIndex) : "";
+  const withoutHash = hashIndex >= 0 ? url.slice(0, hashIndex) : url;
+  const queryIndex = withoutHash.indexOf("?");
+  if (queryIndex < 0) return url;
+  const pathname = withoutHash.slice(0, queryIndex);
+  const query = withoutHash.slice(queryIndex + 1).split("&").filter((part) => !/^t=\d+$/.test(part)).join("&");
+  return pathname + (query ? `?${query}` : "") + hash;
+}
+var init_url = __esm({
+  "src/core/url.ts"() {
+    "use strict";
+  }
+});
+
 // src/core/module-graph.ts
 var ModuleGraph;
 var init_module_graph = __esm({
   "src/core/module-graph.ts"() {
     "use strict";
+    init_url();
     ModuleGraph = class {
       urlToModuleMap = /* @__PURE__ */ new Map();
       idToModuleMap = /* @__PURE__ */ new Map();
       fileToModulesMap = /* @__PURE__ */ new Map();
       getModuleByUrl(url) {
-        return this.urlToModuleMap.get(url);
+        return this.urlToModuleMap.get(removeTimestampQuery(url));
       }
       getModuleById(id) {
         return this.idToModuleMap.get(id);
@@ -2364,10 +2523,11 @@ var init_module_graph = __esm({
         return this.fileToModulesMap.get(file);
       }
       async ensureEntryFromUrl(url) {
-        let mod = this.urlToModuleMap.get(url);
+        const normalizedUrl = removeTimestampQuery(url);
+        let mod = this.urlToModuleMap.get(normalizedUrl);
         if (mod) return mod;
-        mod = this.createModule(url);
-        this.urlToModuleMap.set(url, mod);
+        mod = this.createModule(normalizedUrl);
+        this.urlToModuleMap.set(normalizedUrl, mod);
         return mod;
       }
       createModule(url, id) {
@@ -2381,6 +2541,7 @@ var init_module_graph = __esm({
           acceptedHmrDeps: /* @__PURE__ */ new Set(),
           transformResult: null,
           lastHMRTimestamp: 0,
+          invalidationVersion: 0,
           isSelfAccepting: false
         };
         this.idToModuleMap.set(mod.id, mod);
@@ -2423,10 +2584,64 @@ var init_module_graph = __esm({
           }
         }
       }
+      /**
+       * 用一次转换得到的信息原子更新 import 与 HMR accept 关系。
+       * 依赖节点会在真正被浏览器请求前预先创建，这样入口模块先转换时也能建立完整图。
+       */
+      async updateModuleInfo(mod, importedUrls, acceptedUrls, isSelfAccepting, expectedInvalidationVersion) {
+        const importedModules = await Promise.all(
+          [...importedUrls].map((url) => this.ensureEntryFromUrl(url))
+        );
+        const acceptedModules = await Promise.all(
+          [...acceptedUrls].map((url) => this.ensureEntryFromUrl(url))
+        );
+        if (expectedInvalidationVersion !== void 0 && mod.invalidationVersion !== expectedInvalidationVersion) {
+          return null;
+        }
+        const previousImports = new Set(mod.importedModules);
+        for (const imported of previousImports) {
+          imported.importers.delete(mod);
+        }
+        mod.importedModules.clear();
+        mod.acceptedHmrDeps.clear();
+        for (const imported of importedModules) {
+          mod.importedModules.add(imported);
+          imported.importers.add(mod);
+        }
+        for (const accepted of acceptedModules) {
+          mod.acceptedHmrDeps.add(accepted);
+        }
+        mod.isSelfAccepting = isSelfAccepting;
+        const pruned = /* @__PURE__ */ new Set();
+        for (const imported of previousImports) {
+          if (!mod.importedModules.has(imported) && imported.importers.size === 0) {
+            pruned.add(imported);
+          }
+        }
+        return pruned;
+      }
       /** 使模块的转换缓存失效 */
-      invalidateModule(mod) {
+      invalidateModule(mod, timestamp = Date.now()) {
         mod.transformResult = null;
-        mod.lastHMRTimestamp = Date.now();
+        mod.lastHMRTimestamp = timestamp;
+        mod.invalidationVersion++;
+      }
+      /**
+       * 仅失效到 HMR 边界：显式接受依赖的模块本身不会重执行；自接受模块需要失效，
+       * 但不再继续影响其 importer。这样既能传播依赖时间戳，也不会隐式重复副作用。
+       */
+      invalidateModuleAndImporters(mod, timestamp = Date.now(), seen = /* @__PURE__ */ new Set()) {
+        if (seen.has(mod)) return;
+        seen.add(mod);
+        this.invalidateModule(mod, timestamp);
+        for (const importer of mod.importers) {
+          if (importer.acceptedHmrDeps.has(mod)) continue;
+          if (importer.isSelfAccepting) {
+            this.invalidateModule(importer, timestamp);
+            continue;
+          }
+          this.invalidateModuleAndImporters(importer, timestamp, seen);
+        }
       }
       /** 使所有模块缓存失效 */
       invalidateAll() {
@@ -2437,34 +2652,32 @@ var init_module_graph = __esm({
       /** 获取 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;
+        const traversed = /* @__PURE__ */ new Set();
+        const addBoundary = (boundary, acceptedVia) => {
+          if (!boundaries.some(
+            (item) => item.boundary === boundary && item.acceptedVia === acceptedVia
+          )) {
+            boundaries.push({ boundary, acceptedVia });
           }
-          if (node.acceptedHmrDeps.has(via)) {
-            boundaries.push({ boundary: node, acceptedVia: via });
+        };
+        const propagate = (node) => {
+          if (traversed.has(node)) return true;
+          traversed.add(node);
+          if (node.isSelfAccepting) {
+            addBoundary(node, node);
             return true;
           }
           if (node.importers.size === 0) return false;
           for (const importer of node.importers) {
-            if (!propagate(importer, node)) return false;
+            if (importer.acceptedHmrDeps.has(node)) {
+              addBoundary(importer, node);
+              continue;
+            }
+            if (!propagate(importer)) 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;
+        return propagate(mod) ? boundaries : [];
       }
     };
   }
@@ -2542,6 +2755,7 @@ var init_environment = __esm({
     init_module_graph();
     init_hot_channel();
     init_debug();
+    init_plugin_api();
     debug2 = createDebugger("nasti:environment");
     NastiEnvironment = class {
       name;
@@ -2550,6 +2764,7 @@ var init_environment = __esm({
       config;
       options;
       hot;
+      driver;
       /** applyToEnvironment 过滤后的插件（init() 后可用） */
       plugins = [];
       /** per-env 插件容器（init() 后可用；dev 管线使用） */
@@ -2557,6 +2772,8 @@ var init_environment = __esm({
       /** per-env 模块图（dev 管线使用） */
       moduleGraph;
       candidatePlugins;
+      pluginApi;
+      buildMetadata = {};
       initialized = false;
       constructor(name, config, init = {}) {
         const options = config.environments[name];
@@ -2573,6 +2790,7 @@ var init_environment = __esm({
         this.hot = init.hot ?? createNoopHotChannel();
         this.moduleGraph = new ModuleGraph();
         this.candidatePlugins = init.plugins ?? config.plugins;
+        this.pluginApi = init.pluginApi ?? getPluginApi(config);
       }
       /** 过滤插件并建 per-env PluginContainer */
       async init() {
@@ -2583,10 +2801,57 @@ var init_environment = __esm({
           { ...this.config, plugins: this.plugins },
           this
         );
+        if (this.options.driver) {
+          const claimed = [];
+          for (const plugin of this.plugins) {
+            const driver = await plugin.createEnvironmentDriver?.(this, this.pluginApi);
+            if (driver) claimed.push({ plugin, driver });
+          }
+          if (claimed.length === 0) {
+            throw new Error(
+              `[nasti] environment "${this.name}" requested driver "${this.options.driver}", but no plugin provided it`
+            );
+          }
+          if (claimed.length > 1) {
+            throw new Error(
+              `[nasti] environment "${this.name}" was claimed by multiple drivers: ` + claimed.map(({ plugin, driver }) => `${plugin.name} (${driver.name})`).join(", ")
+            );
+          }
+          this.driver = claimed[0].driver;
+          debug2?.(`env "${this.name}" uses driver "${this.driver.name}"`);
+        }
         debug2?.(`env "${this.name}" initialized (${this.plugins.length} plugins)`);
       }
+      getDriverContext() {
+        return {
+          environment: this,
+          config: this.config,
+          api: this.pluginApi,
+          logger: this.config.logger
+        };
+      }
+      setBuildMetadata(metadata) {
+        const { entries: currentEntries, ...currentMetadata } = this.buildMetadata;
+        const { entries, ...nextMetadata } = metadata;
+        this.buildMetadata = {
+          ...currentMetadata,
+          ...nextMetadata,
+          ...currentEntries || entries ? { entries: { ...currentEntries, ...entries } } : {}
+        };
+      }
+      getBuildMetadata() {
+        const { entries, ...metadata } = this.buildMetadata;
+        return {
+          ...metadata,
+          ...entries ? { entries: { ...entries } } : {}
+        };
+      }
       async close() {
-        await this.hot.close?.();
+        try {
+          await this.driver?.close?.(this.getDriverContext());
+        } finally {
+          await this.hot.close?.();
+        }
       }
     };
   }
@@ -2746,11 +3011,141 @@ var init_reporter = __esm({
   }
 });
 
+// src/core/build-app-context.ts
+function createBuildAppContext(config, results) {
+  const output = [];
+  const emitted = /* @__PURE__ */ new Set();
+  const outDir = import_node_path9.default.resolve(config.root, config.build.outDir);
+  let environmentArtifacts;
+  return {
+    config,
+    results,
+    get output() {
+      return Object.freeze([...output]);
+    },
+    getResult(environmentName) {
+      return results[environmentName];
+    },
+    getArtifact(environmentName, fileName) {
+      const normalized = normalizeEnvironmentFileName(fileName);
+      return results[environmentName]?.output.find(
+        (artifact) => normalizeEnvironmentFileName(artifact.fileName) === normalized
+      );
+    },
+    getEntry(environmentName, entryName) {
+      const result = results[environmentName];
+      const fileName = result?.entries?.[entryName];
+      if (!fileName) return void 0;
+      return result.output.find(
+        (artifact) => normalizeEnvironmentFileName(artifact.fileName) === normalizeEnvironmentFileName(fileName)
+      );
+    },
+    getManifest(environmentName) {
+      return results[environmentName]?.manifest;
+    },
+    emitFile(file) {
+      const fileName = normalizeAppFileName(file.fileName);
+      const collisionKey = artifactCollisionKey(fileName);
+      if (emitted.has(collisionKey)) {
+        throw new Error(`[nasti] app artifact already emitted: ${fileName}`);
+      }
+      environmentArtifacts ??= collectEnvironmentArtifacts(config, results, outDir);
+      if (environmentArtifacts.has(collisionKey)) {
+        throw new Error(`[nasti] app artifact conflicts with environment output: ${fileName}`);
+      }
+      const target = import_node_path9.default.resolve(outDir, ...fileName.split("/"));
+      const relative = import_node_path9.default.relative(outDir, target);
+      if (relative.startsWith("..") || import_node_path9.default.isAbsolute(relative)) {
+        throw new Error(`[nasti] app artifact must stay inside build.outDir: ${file.fileName}`);
+      }
+      assertNoSymlinkComponents(outDir, fileName);
+      import_node_fs6.default.mkdirSync(import_node_path9.default.dirname(target), { recursive: true });
+      import_node_fs6.default.writeFileSync(target, file.source);
+      const artifact = {
+        ...file,
+        fileName,
+        type: "asset"
+      };
+      emitted.add(collisionKey);
+      output.push(artifact);
+      return fileName;
+    }
+  };
+}
+function normalizeEnvironmentFileName(fileName) {
+  return import_node_path9.default.posix.normalize(fileName.replace(/\\/g, "/").replace(/^\.\//, ""));
+}
+function isInvalidEnvironmentFileName(fileName) {
+  return !fileName || fileName === "." || fileName === ".." || fileName.startsWith("../") || import_node_path9.default.posix.isAbsolute(fileName) || /^[A-Za-z]:\//.test(fileName);
+}
+function normalizeAppFileName(fileName) {
+  const normalized = normalizeEnvironmentFileName(fileName);
+  if (isInvalidEnvironmentFileName(normalized)) {
+    throw new Error(`[nasti] invalid app artifact fileName: ${fileName}`);
+  }
+  return normalized;
+}
+function artifactCollisionKey(fileName) {
+  return normalizeEnvironmentFileName(fileName).toLowerCase();
+}
+function collectEnvironmentArtifacts(config, results, appOutDir) {
+  const occupied = /* @__PURE__ */ new Set();
+  for (const [environmentName, result] of Object.entries(results)) {
+    const environment = config.environments[environmentName];
+    if (!environment) continue;
+    const environmentOutDir = import_node_path9.default.resolve(config.root, environment.build.outDir);
+    for (const artifact of result.output) {
+      const artifactPath = import_node_path9.default.resolve(
+        environmentOutDir,
+        ...normalizeEnvironmentFileName(artifact.fileName).split("/")
+      );
+      const relative = import_node_path9.default.relative(appOutDir, artifactPath);
+      if (!relative.startsWith("..") && !import_node_path9.default.isAbsolute(relative)) {
+        occupied.add(artifactCollisionKey(relative));
+      }
+    }
+  }
+  return occupied;
+}
+function assertNoSymlinkComponents(outDir, fileName) {
+  let current = outDir;
+  for (const segment of fileName.split("/")) {
+    current = import_node_path9.default.join(current, segment);
+    let stats;
+    try {
+      stats = import_node_fs6.default.lstatSync(current);
+    } catch (error) {
+      if (error.code === "ENOENT") continue;
+      throw error;
+    }
+    if (stats.isSymbolicLink()) {
+      throw new Error(`[nasti] app artifact path cannot traverse a symlink: ${fileName}`);
+    }
+  }
+}
+function inferEnvironmentEntries(output) {
+  const entries = {};
+  for (const artifact of output) {
+    if (artifact.type !== "chunk" || !artifact.isEntry || !artifact.name) continue;
+    entries[artifact.name] = normalizeEnvironmentFileName(artifact.fileName);
+  }
+  return Object.keys(entries).length > 0 ? entries : void 0;
+}
+var import_node_fs6, import_node_path9;
+var init_build_app_context = __esm({
+  "src/core/build-app-context.ts"() {
+    "use strict";
+    import_node_fs6 = __toESM(require("fs"), 1);
+    import_node_path9 = __toESM(require("path"), 1);
+  }
+});
+
 // src/build/index.ts
 var build_exports = {};
 __export(build_exports, {
   build: () => build,
   getRolldownOptions: () => getRolldownOptions,
+  replaceEntryScript: () => replaceEntryScript,
   resolveClientEntries: () => resolveClientEntries,
   toRolldownPlugins: () => toRolldownPlugins
 });
@@ -2758,9 +3153,14 @@ function getRolldownOptions(environment, entryPoints, rolldownPlugins) {
   const config = environment.config;
   const envOptions = environment.options;
   const isServer = environment.consumer === "server";
-  const outDir = import_node_path9.default.resolve(config.root, envOptions.build.outDir);
+  const outDir = import_node_path10.default.resolve(config.root, envOptions.build.outDir);
   const assetsDir = envOptions.build.assetsDir;
-  const { output: userOutput, transform: userTransform, ...restInputOptions } = envOptions.build.rolldownOptions;
+  const {
+    output: userOutput,
+    transform: userTransform,
+    resolve: userResolve,
+    ...restInputOptions
+  } = envOptions.build.rolldownOptions;
   const vueDefine = config.framework === "vue" ? {
     __VUE_OPTIONS_API__: "true",
     __VUE_PROD_DEVTOOLS__: "false",
@@ -2774,19 +3174,22 @@ function getRolldownOptions(environment, entryPoints, rolldownPlugins) {
     input: entryPoints,
     transform: { ...userTransform, define: mergedDefine },
     plugins: rolldownPlugins,
+    // client/server consumer 都必须使用当前环境的 conditions/mainFields；Lynx
+    // BG/MT 通常同为 client consumer，但仍可能声明不同的运行时条件。
+    resolve: {
+      ...userResolve ?? {},
+      // Environment API 是条件解析的唯一高层入口，优先于继承来的底层选项。
+      conditionNames: envOptions.resolve.conditions,
+      mainFields: envOptions.resolve.mainFields
+    },
     ...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(".") && !import_node_path9.default.isAbsolute(id) && !id.startsWith("\0");
+        return !id.startsWith(".") && !import_node_path10.default.isAbsolute(id) && !id.startsWith("\0");
       })
     } : {}
   };
@@ -2813,37 +3216,139 @@ function getRolldownOptions(environment, entryPoints, rolldownPlugins) {
   };
   return { inputOptions, outputOptions, outDir };
 }
-function toRolldownPlugins(plugins) {
+function toRolldownPlugins(plugins, environment) {
+  const wrap = (hook) => {
+    if (!hook) return hook;
+    return function(...args) {
+      return hook.apply(attachEnvironment(this, environment), args);
+    };
+  };
   return plugins.map((p) => ({
     name: p.name,
-    resolveId: p.resolveId,
-    load: p.load,
-    transform: p.transform,
-    buildStart: p.buildStart,
-    buildEnd: p.buildEnd,
+    resolveId: wrap(p.resolveId),
+    load: wrap(p.load),
+    transform: wrap(p.transform),
+    buildStart: wrap(p.buildStart),
+    buildEnd: wrap(p.buildEnd),
     // closeBundle 在 bundle.close() 时触发 —— PWA manifest/SW 等终态产物依赖
-    closeBundle: p.closeBundle,
-    renderChunk: p.renderChunk,
-    augmentChunkHash: p.augmentChunkHash,
-    generateBundle: p.generateBundle
+    closeBundle: wrap(p.closeBundle),
+    renderChunk: wrap(p.renderChunk),
+    augmentChunkHash: wrap(p.augmentChunkHash),
+    generateBundle: wrap(p.generateBundle)
   }));
 }
+function attachEnvironment(context, environment) {
+  if (context?.environment === environment) return context;
+  try {
+    Object.defineProperty(context, "environment", {
+      configurable: true,
+      enumerable: false,
+      writable: false,
+      value: environment
+    });
+    return context;
+  } catch {
+    return new Proxy(context, {
+      get(target, property) {
+        if (property === "environment") return environment;
+        const value = Reflect.get(target, property, target);
+        return typeof value === "function" ? value.bind(target) : value;
+      },
+      set(target, property, value) {
+        return Reflect.set(target, property, value, target);
+      }
+    });
+  }
+}
+function finalizeEnvironmentResult(environment, result) {
+  const metadata = environment.getBuildMetadata();
+  const inferredEntries = inferEnvironmentEntries(result.output);
+  const entries = {
+    ...inferredEntries,
+    ...metadata.entries,
+    ...result.entries
+  };
+  const normalizedEntries = Object.fromEntries(
+    Object.entries(entries).map(([name, fileName]) => {
+      const normalized = normalizeEnvironmentFileName(fileName);
+      if (isInvalidEnvironmentFileName(normalized)) {
+        throw new Error(
+          `[nasti] environment "${environment.name}" returned invalid entry "${name}": ${fileName}`
+        );
+      }
+      return [name, normalized];
+    })
+  );
+  return {
+    ...metadata,
+    ...result,
+    output: result.output,
+    ...Object.keys(normalizedEntries).length > 0 ? { entries: normalizedEntries } : {}
+  };
+}
+function prepareBuildOutputDirectories(config, buildableNames) {
+  const directories = /* @__PURE__ */ new Set();
+  const protectedPaths = /* @__PURE__ */ new Set();
+  const clientIsBuilt = buildableNames.includes("client");
+  if (!clientIsBuilt && config.build.emptyOutDir) {
+    directories.add(import_node_path10.default.resolve(config.root, config.build.outDir));
+  }
+  for (const name of buildableNames) {
+    const environment = config.environments[name];
+    const outDir = import_node_path10.default.resolve(config.root, environment.build.outDir);
+    if (!environment.build.emptyOutDir) {
+      protectedPaths.add(outDir);
+      continue;
+    }
+    if (!environment.driver) directories.add(outDir);
+  }
+  const containsPath = (parent, child) => {
+    const relative = import_node_path10.default.relative(parent, child);
+    return relative === "" || !relative.startsWith("..") && !import_node_path10.default.isAbsolute(relative);
+  };
+  const roots = [...directories].filter(
+    (directory) => ![...protectedPaths].some((protectedPath) => containsPath(directory, protectedPath))
+  ).sort((a, b) => a.length - b.length).filter(
+    (directory, index2, all) => !all.slice(0, index2).some((parent) => containsPath(parent, directory))
+  );
+  for (const directory of roots) {
+    if (import_node_fs7.default.existsSync(directory)) import_node_fs7.default.rmSync(directory, { recursive: true, force: true });
+  }
+}
+function assertDriverBuildResult(environment, result) {
+  const output = result != null && typeof result === "object" ? result.output : void 0;
+  const hasValidOutput = Array.isArray(output) && output.every(
+    (artifact) => artifact != null && typeof artifact === "object" && typeof artifact.fileName === "string" && typeof artifact.type === "string"
+  );
+  if (!hasValidOutput) {
+    throw new Error(
+      `[nasti] environment "${environment.name}" driver "${environment.driver?.name}" returned an invalid build result; expected { output: EnvironmentBuildOutput[] }`
+    );
+  }
+}
 function resolveClientEntries(config, html) {
+  const configuredEntries = config.environments.client?.entry ?? [];
+  if (configuredEntries.length > 0) return configuredEntries;
   const entryPoints = [];
+  const htmlFile = config.environments.client?.html;
+  const htmlDir = htmlFile ? import_node_path10.default.dirname(htmlFile) : config.root;
   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(import_node_path9.default.resolve(config.root, src.replace(/^\//, "")));
+        const cleanSrc = src.split(/[?#]/, 1)[0];
+        entryPoints.push(
+          cleanSrc.startsWith("/") ? import_node_path10.default.resolve(config.root, cleanSrc.replace(/^\//, "")) : import_node_path10.default.resolve(htmlDir, cleanSrc)
+        );
       }
     }
   }
   if (entryPoints.length === 0) {
     const fallbackEntries = ["src/main.ts", "src/main.tsx", "src/main.js", "src/index.ts", "src/index.tsx", "src/index.js"];
     for (const entry of fallbackEntries) {
-      const fullPath = import_node_path9.default.resolve(config.root, entry);
-      if (import_node_fs6.default.existsSync(fullPath)) {
+      const fullPath = import_node_path10.default.resolve(config.root, entry);
+      if (import_node_fs7.default.existsSync(fullPath)) {
         entryPoints.push(fullPath);
         break;
       }
@@ -2871,130 +3376,229 @@ async function build(inlineConfig = {}) {
   const startTime = performance.now();
   logger.info(
     import_picocolors4.default.cyan(`
-nasti v${"2.2.0"} `) + import_picocolors4.default.green(`building for ${config.mode}...`)
+nasti v${"2.4.0"} `) + import_picocolors4.default.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
-  );
+  const buildableNames = Object.keys(config.environments).filter((name) => {
+    const environment = config.environments[name];
+    if (!environment.buildEnabled) return false;
+    return name === "client" || environment.entry.length > 0 || !!environment.driver;
+  });
   buildableNames.sort((a, b) => a === "client" ? -1 : b === "client" ? 1 : 0);
+  prepareBuildOutputDirectories(config, buildableNames);
   const environments = {};
+  const environmentResults = {};
+  const initializedEnvironments = [];
+  const buildAppContext = createBuildAppContext(config, environmentResults);
   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)`);
+  let buildFailed = false;
+  try {
+    for (const name of buildableNames) {
+      const built = name === "client" ? await buildClientEnvironment(config) : await buildServerEnvironment(config, name);
+      initializedEnvironments.push(built.environment);
+      environments[name] = built.result.output;
+      environmentResults[name] = built.result;
+      if (name === "client") clientOutput = built.result.output;
+      if (buildableNames.length > 1) {
+        debug4?.(`environment "${name}" built (${built.result.output.length} files)`);
+      }
+    }
+    const pluginApi = getPluginApi(config);
+    for (const plugin of config.plugins) {
+      await plugin.afterBuildApp?.(environmentResults, pluginApi, buildAppContext);
+    }
+  } catch (error) {
+    buildFailed = true;
+    throw error;
+  } finally {
+    let closeFailed = false;
+    let firstCloseError;
+    for (const environment of [...initializedEnvironments].reverse()) {
+      try {
+        await environment.close();
+      } catch (error) {
+        if (!closeFailed) {
+          closeFailed = true;
+          firstCloseError = error;
+        }
+        const closeError = error instanceof Error ? error : new Error(String(error));
+        logger.error(`[nasti] failed to close environment "${environment.name}"`, {
+          error: closeError
+        });
+      }
+    }
+    if (closeFailed && !buildFailed) {
+      throw firstCloseError;
     }
   }
   const elapsed = ((performance.now() - startTime) / 1e3).toFixed(2);
-  const totalSize = Object.values(environments).flat().reduce((sum, chunk) => {
+  const allOutput = [...Object.values(environments).flat(), ...buildAppContext.output];
+  const totalSize = allOutput.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 fileCount = allOutput.length;
   const envSuffix = buildableNames.length > 1 ? ` (${buildableNames.join(" + ")})` : "";
   logger.info(import_picocolors4.default.green(`\u2713 built in ${elapsed}s`) + import_picocolors4.default.dim(envSuffix));
   logger.info(import_picocolors4.default.dim(`  ${fileCount} files, ${displaySize(totalSize)} total \u2192 ${config.build.outDir}/`));
-  return { output: clientOutput, environments };
+  return {
+    output: clientOutput,
+    environments,
+    environmentResults,
+    appOutput: [...buildAppContext.output]
+  };
 }
 async function buildClientEnvironment(config) {
   const logger = config.logger;
-  const outDir = import_node_path9.default.resolve(config.root, config.build.outDir);
-  if (config.build.emptyOutDir && import_node_fs6.default.existsSync(outDir)) {
-    import_node_fs6.default.rmSync(outDir, { recursive: true, force: true });
-  }
-  import_node_fs6.default.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 outDir = import_node_path10.default.resolve(config.root, config.build.outDir);
   const cssEngine = createCssEngine();
-  const pluginList = resolvePluginList(config, config.plugins, { cssEngine });
-  const clientEnv = new NastiEnvironment("client", { ...config, plugins: pluginList }, {
+  const pluginList = resolvePluginList(config, config.plugins, {
+    cssEngine,
+    environmentName: "client"
+  });
+  const clientEnv = new NastiEnvironment("client", config, {
     mode: "build",
-    plugins: pluginList
+    plugins: pluginList,
+    pluginApi: getPluginApi(config)
   });
   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 (0, import_rolldown.rolldown)(inputOptions);
-  const { output } = await bundle2.write(outputOptions);
-  await bundle2.close();
-  if (html) {
-    let processedHtml = html;
-    const htmlPlugins = [...allPlugins.filter((p) => p.transformIndexHtml), htmlPlugin(config)];
-    for (const p of htmlPlugins) {
-      const result = await p.transformIndexHtml(processedHtml);
-      if (typeof result === "string") {
-        processedHtml = result;
-      } else if (result && "html" in result) {
-        processedHtml = processHtml(result.html, result.tags);
-      } else if (Array.isArray(result)) {
-        processedHtml = processHtml(processedHtml, result);
-      }
-    }
-    processedHtml = injectCssLinks(processedHtml, cssEngine, config);
-    for (const chunk of output) {
-      if (chunk.type === "chunk" && chunk.isEntry && chunk.facadeModuleId) {
-        const originalEntry = import_node_path9.default.relative(config.root, chunk.facadeModuleId);
-        processedHtml = processedHtml.replace(
-          new RegExp(`(src=["'])/?(${escapeRegExp(originalEntry)})(["'])`, "g"),
-          `$1${config.base}${chunk.fileName}$3`
+  try {
+    if (clientEnv.driver) {
+      if (!clientEnv.driver.build) {
+        throw new Error(
+          `[nasti] environment "client" driver "${clientEnv.driver.name}" does not implement build()`
         );
       }
+      const result = await clientEnv.driver.build(clientEnv.getDriverContext());
+      assertDriverBuildResult(clientEnv, result);
+      return { environment: clientEnv, result: finalizeEnvironmentResult(clientEnv, result) };
     }
-    import_node_fs6.default.writeFileSync(import_node_path9.default.resolve(outDir, "index.html"), processedHtml);
-  }
-  if (!nativeReporter && config.logLevel !== "silent") {
-    reportBuildOutput(output, config, logger);
+    import_node_fs7.default.mkdirSync(outDir, { recursive: true });
+    const htmlFile = config.environments.client.html ?? import_node_path10.default.resolve(config.root, "index.html");
+    const html = await readHtmlFile(config.root, htmlFile);
+    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 allPlugins = clientEnv.plugins;
+    const nativeReporter = config.logLevel === "silent" ? null : await tryNativeReporterPlugin(config, logger);
+    const rolldownPlugins = [
+      createOxcTransformPlugin(config, clientEnv),
+      ...toRolldownPlugins(allPlugins, clientEnv),
+      ...nativeReporter ? [nativeReporter] : []
+    ];
+    const { inputOptions, outputOptions } = getRolldownOptions(
+      clientEnv,
+      entryPoints,
+      rolldownPlugins
+    );
+    const bundle2 = await (0, import_rolldown.rolldown)(inputOptions);
+    const { output } = await bundle2.write(outputOptions);
+    await bundle2.close();
+    if (html) {
+      let processedHtml = html;
+      const htmlPlugins = [...allPlugins.filter((p) => p.transformIndexHtml), htmlPlugin(config)];
+      for (const p of htmlPlugins) {
+        const result = await p.transformIndexHtml(processedHtml);
+        if (typeof result === "string") {
+          processedHtml = result;
+        } else if (result && "html" in result) {
+          processedHtml = processHtml(result.html, result.tags);
+        } else if (Array.isArray(result)) {
+          processedHtml = processHtml(processedHtml, result);
+        }
+      }
+      processedHtml = injectCssLinks(processedHtml, cssEngine, config);
+      for (const chunk of output) {
+        if (chunk.type === "chunk" && chunk.isEntry && chunk.facadeModuleId) {
+          processedHtml = replaceEntryScript(
+            processedHtml,
+            chunk.facadeModuleId,
+            chunk.fileName,
+            config,
+            htmlFile,
+            config.base
+          );
+        }
+      }
+      import_node_fs7.default.writeFileSync(import_node_path10.default.resolve(outDir, "index.html"), processedHtml);
+    }
+    if (!nativeReporter && config.logLevel !== "silent") {
+      reportBuildOutput(output, config, logger);
+    }
+    warnLargeChunks(output, config, logger);
+    return {
+      environment: clientEnv,
+      result: finalizeEnvironmentResult(clientEnv, { output })
+    };
+  } catch (error) {
+    try {
+      await clientEnv.close();
+    } catch (closeError) {
+      const normalized = closeError instanceof Error ? closeError : new Error(String(closeError));
+      logger.error("[nasti] failed to close client environment after build failure", {
+        error: normalized
+      });
+    }
+    throw error;
   }
-  warnLargeChunks(output, config, logger);
-  return output;
 }
 async function buildServerEnvironment(config, name) {
   const envOptions = config.environments[name];
   const logger = config.logger;
+  const pluginList = resolvePluginList(config, config.plugins, {
+    consumer: envOptions.consumer,
+    environmentName: name
+  });
+  const environment = new NastiEnvironment(name, config, {
+    mode: "build",
+    plugins: pluginList,
+    pluginApi: getPluginApi(config)
+  });
+  await environment.init();
+  if (environment.driver) {
+    if (!environment.driver.build) {
+      await environment.close();
+      throw new Error(
+        `[nasti] environment "${name}" driver "${environment.driver.name}" does not implement build()`
+      );
+    }
+    try {
+      const result = await environment.driver.build(environment.getDriverContext());
+      assertDriverBuildResult(environment, result);
+      return { environment, result: finalizeEnvironmentResult(environment, result) };
+    } catch (error) {
+      await environment.close();
+      throw error;
+    }
+  }
   for (const entry of envOptions.entry) {
-    if (!import_node_fs6.default.existsSync(entry)) {
+    if (!import_node_fs7.default.existsSync(entry)) {
+      await environment.close();
       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)
+    ...toRolldownPlugins(environment.plugins, environment)
   ];
   const { inputOptions, outputOptions, outDir } = getRolldownOptions(
     environment,
     envOptions.entry,
     rolldownPlugins
   );
-  if (envOptions.build.emptyOutDir && import_node_fs6.default.existsSync(outDir)) {
-    import_node_fs6.default.rmSync(outDir, { recursive: true, force: true });
-  }
-  import_node_fs6.default.mkdirSync(outDir, { recursive: true });
+  import_node_fs7.default.mkdirSync(outDir, { recursive: true });
   const bundle2 = await (0, import_rolldown.rolldown)(inputOptions);
   const { output } = await bundle2.write(outputOptions);
   await bundle2.close();
   logger.info(
-    import_picocolors4.default.dim(`  [${name}] `) + output.map((o) => import_node_path9.default.join(envOptions.build.outDir, o.fileName)).join(import_picocolors4.default.dim(", "))
+    import_picocolors4.default.dim(`  [${name}] `) + output.map((o) => import_node_path10.default.join(envOptions.build.outDir, o.fileName)).join(import_picocolors4.default.dim(", "))
   );
-  return output;
+  return {
+    environment,
+    result: finalizeEnvironmentResult(environment, { output })
+  };
 }
 function injectCssLinks(html, cssEngine, config) {
   const cssLinkTags = [];
@@ -3020,12 +3624,31 @@ function injectCssLinks(html, cssEngine, config) {
 function escapeRegExp(string) {
   return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
-var import_node_path9, import_node_fs6, import_node_module3, import_rolldown, import_picocolors4, debug4, NODE_BUILTINS;
+function replaceEntryScript(html, facadeModuleId, fileName, config, htmlFile, urlPrefix) {
+  const rootRelative = import_node_path10.default.relative(config.root, facadeModuleId).split(import_node_path10.default.sep).join("/");
+  const resolvedHtmlFile = import_node_path10.default.resolve(config.root, htmlFile);
+  const htmlRelative = import_node_path10.default.relative(import_node_path10.default.dirname(resolvedHtmlFile), facadeModuleId).split(import_node_path10.default.sep).join("/");
+  const candidates = /* @__PURE__ */ new Set([
+    rootRelative,
+    `/${rootRelative}`,
+    htmlRelative,
+    `./${htmlRelative}`
+  ]);
+  let processed = html;
+  for (const candidate of candidates) {
+    processed = processed.replace(
+      new RegExp(`(src=["'])${escapeRegExp(candidate)}([?#][^"']*)?(["'])`, "g"),
+      `$1${urlPrefix}${fileName}$3`
+    );
+  }
+  return processed;
+}
+var import_node_path10, import_node_fs7, import_node_module3, import_rolldown, import_picocolors4, debug4, NODE_BUILTINS;
 var init_build = __esm({
   "src/build/index.ts"() {
     "use strict";
-    import_node_path9 = __toESM(require("path"), 1);
-    import_node_fs6 = __toESM(require("fs"), 1);
+    import_node_path10 = __toESM(require("path"), 1);
+    import_node_fs7 = __toESM(require("fs"), 1);
     import_node_module3 = require("module");
     import_rolldown = require("rolldown");
     init_config();
@@ -3037,6 +3660,8 @@ var init_build = __esm({
     init_env();
     init_reporter();
     init_debug();
+    init_plugin_api();
+    init_build_app_context();
     import_picocolors4 = __toESM(require("picocolors"), 1);
     debug4 = createDebugger("nasti:build");
     NODE_BUILTINS = /* @__PURE__ */ new Set([...import_node_module3.builtinModules, ...import_node_module3.builtinModules.map((m) => `node:${m}`)]);
@@ -3096,15 +3721,17 @@ __export(middleware_exports, {
   transformMiddleware: () => transformMiddleware,
   transformRequest: () => transformRequest
 });
-function getReactRefreshRuntimeEsm() {
-  if (__refreshRuntimeCache) return __refreshRuntimeCache;
+function getReactRefreshRuntimeEsm(includeBoundaryHelpers = false) {
+  if (__refreshRuntimeCache) {
+    return includeBoundaryHelpers ? __refreshRuntimeCache + REACT_REFRESH_BOUNDARY_HELPERS : __refreshRuntimeCache;
+  }
   let cjsPath;
   try {
     const pkgPath = __require.resolve("react-refresh/package.json");
-    cjsPath = import_node_path11.default.join(import_node_path11.default.dirname(pkgPath), "cjs", "react-refresh-runtime.development.js");
+    cjsPath = import_node_path12.default.join(import_node_path12.default.dirname(pkgPath), "cjs", "react-refresh-runtime.development.js");
   } catch (err) {
-    cjsPath = import_node_path11.default.resolve(__dirname_esm, "../../node_modules/react-refresh/cjs/react-refresh-runtime.development.js");
-    if (!import_node_fs8.default.existsSync(cjsPath)) {
+    cjsPath = import_node_path12.default.resolve(__dirname_esm, "../../node_modules/react-refresh/cjs/react-refresh-runtime.development.js");
+    if (!import_node_fs9.default.existsSync(cjsPath)) {
       const origMsg = err instanceof Error ? err.message : String(err);
       throw new Error(
         `[nasti] Missing dependency "react-refresh". Install it with: npm install react-refresh
@@ -3112,7 +3739,7 @@ Original resolve error: ${origMsg}`
       );
     }
   }
-  const cjsSource = import_node_fs8.default.readFileSync(cjsPath, "utf-8");
+  const cjsSource = import_node_fs9.default.readFileSync(cjsPath, "utf-8");
   __refreshRuntimeCache = `// Wrapped react-refresh runtime -> ESM
 const exports = {};
 const module = { exports };
@@ -3132,7 +3759,7 @@ export const findAffectedHostInstances = __rt.findAffectedHostInstances;
 export const collectCustomHooksForSignature = __rt.collectCustomHooksForSignature;
 export default __rt;
 `;
-  return __refreshRuntimeCache;
+  return includeBoundaryHelpers ? __refreshRuntimeCache + REACT_REFRESH_BOUNDARY_HELPERS : __refreshRuntimeCache;
 }
 function buildReactRefreshWrapper(moduleUrl, transformedCode) {
   const urlLit = JSON.stringify(moduleUrl);
@@ -3158,22 +3785,40 @@ window.$RefreshReg$ = prevRefreshReg;
 window.$RefreshSig$ = prevRefreshSig;
 
 if (__nasti_hot__) {
-  __nasti_hot__.accept(() => {
-    clearTimeout(window.__nasti_refresh_timer__);
-    window.__nasti_refresh_timer__ = setTimeout(() => {
-      RefreshRuntime.performReactRefresh();
-    }, 30);
+  let __nasti_current_exports__;
+  __nasti_hot__.accept((nextExports) => {
+    if (!nextExports) return;
+    if (!__nasti_current_exports__) {
+      __nasti_hot__.invalidate('Could not Fast Refresh (previous exports unavailable)');
+      return;
+    }
+    const invalidateMessage = RefreshRuntime.validateRefreshBoundaryAndEnqueueUpdate(
+      ${urlLit},
+      __nasti_current_exports__,
+      nextExports,
+    );
+    if (invalidateMessage) __nasti_hot__.invalidate(invalidateMessage);
+  });
+  RefreshRuntime.__hmr_import(import.meta.url).then((currentExports) => {
+    __nasti_current_exports__ = currentExports;
+    RefreshRuntime.registerExportsForReactRefresh(${urlLit}, currentExports);
   });
 }
 `;
 }
 function injectImportMetaHot(code, moduleUrl) {
-  if (!/\bimport\.meta\.hot\b/.test(code)) return code;
+  const hotRE = /\bimport\.meta\.hot\b/g;
+  const matches = [...maskStringsAndComments(code).matchAll(hotRE)];
+  if (matches.length === 0) return code;
+  for (const match of matches.reverse()) {
+    const start = match.index;
+    code = code.slice(0, start) + "__nasti_hot__" + code.slice(start + match[0].length);
+  }
   const urlLit = JSON.stringify(moduleUrl);
   const header = `import { createHotContext as __nasti_createHotContext__ } from "/@nasti/client";
 const __nasti_hot__ = __nasti_createHotContext__(${urlLit});
 `;
-  return header + code.replace(/\bimport\.meta\.hot\b/g, "__nasti_hot__");
+  return header + code;
 }
 function transformMiddleware(ctx) {
   ctx.envDefine = buildEnvDefine(
@@ -3200,7 +3845,10 @@ function transformMiddleware(ctx) {
       return;
     }
     if (url === "/" || url.endsWith(".html")) {
-      const html = await readHtmlFile(ctx.config.root);
+      const html = await readHtmlFile(
+        ctx.config.root,
+        ctx.config.environments.client?.html
+      );
       if (html) {
         let processedHtml = html;
         for (const plugin of ctx.config.plugins) {
@@ -3246,13 +3894,14 @@ function transformMiddleware(ctx) {
 }
 async function transformRequest(url, ctx) {
   const { config, pluginContainer, moduleGraph } = ctx;
+  url = removeTimestampQuery(url);
   const cleanReqUrl = url.split("?")[0];
   const cached2 = moduleGraph.getModuleByUrl(url);
   if (cached2?.transformResult) {
     return cached2.transformResult;
   }
   if (cleanReqUrl === "/@react-refresh") {
-    return { code: getReactRefreshRuntimeEsm() };
+    return { code: getReactRefreshRuntimeEsm(true) };
   }
   if (cleanReqUrl.startsWith("/@modules/") && url.includes("?")) {
     const idParam = new URLSearchParams(url.slice(url.indexOf("?") + 1)).get("id");
@@ -3260,8 +3909,8 @@ async function transformRequest(url, ctx) {
     let realIdValid = false;
     try {
       if (idParam) {
-        realId = import_node_fs8.default.realpathSync(idParam);
-        realIdValid = import_node_fs8.default.statSync(realId).isFile() && (realId.includes(`${import_node_path11.default.sep}node_modules${import_node_path11.default.sep}`) || isUnderRoot(realId, config.root));
+        realId = import_node_fs9.default.realpathSync(idParam);
+        realIdValid = import_node_fs9.default.statSync(realId).isFile() && (realId.includes(`${import_node_path12.default.sep}node_modules${import_node_path12.default.sep}`) || isUnderRoot(realId, config.root));
       }
     } catch {
       realId = null;
@@ -3288,6 +3937,8 @@ async function transformRequest(url, ctx) {
   }
   const rawQuery = url.includes("?") ? url.slice(url.indexOf("?") + 1) : "";
   if (rawQuery && !/^t=\d+$/.test(rawQuery)) {
+    const mod2 = await moduleGraph.ensureEntryFromUrl(url);
+    const transformVersion2 = mod2.invalidationVersion;
     const loaded = await pluginContainer.load(url);
     if (loaded != null) {
       let code2 = typeof loaded === "string" ? loaded : loaded.code;
@@ -3295,30 +3946,43 @@ async function transformRequest(url, ctx) {
       if (transformed != null) {
         code2 = typeof transformed === "string" ? transformed : transformed.code;
       }
-      const mod2 = await moduleGraph.ensureEntryFromUrl(url);
-      moduleGraph.registerModule(mod2, cleanReqUrl);
-      code2 = injectImportMetaHot(code2, url);
+      const parentFile = resolveUrlToFile(cleanReqUrl, config.root) ?? cleanReqUrl;
+      moduleGraph.registerModule(mod2, parentFile);
+      const hotInfo2 = rewriteHotAcceptDeps(code2, config, parentFile);
+      code2 = injectImportMetaHot(hotInfo2.code, url);
       code2 = replaceEnvInCode(code2, ctx.envDefine ?? buildEnvDefine(
         loadEnv(config.mode, config.root, config.envPrefix),
         config.mode
       ));
-      code2 = rewriteImports(code2, config, cleanReqUrl);
+      const importedUrls2 = /* @__PURE__ */ new Set();
+      code2 = rewriteImports(code2, config, parentFile, importedUrls2, moduleGraph);
+      const pruned2 = await moduleGraph.updateModuleInfo(
+        mod2,
+        importedUrls2,
+        hotInfo2.acceptedUrls,
+        hotInfo2.isSelfAccepting,
+        transformVersion2
+      );
       const transformResult2 = { code: code2 };
-      mod2.transformResult = transformResult2;
+      if (pruned2) {
+        if (pruned2.size > 0) ctx.onPrune?.([...pruned2].map((item) => item.url));
+        mod2.transformResult = transformResult2;
+      }
       return transformResult2;
     }
   }
   const filePath = resolveUrlToFile(url, config.root);
-  if (!filePath || !import_node_fs8.default.existsSync(filePath)) return null;
+  if (!filePath || !import_node_fs9.default.existsSync(filePath)) return null;
   const mod = await moduleGraph.ensureEntryFromUrl(url);
   moduleGraph.registerModule(mod, filePath);
+  const transformVersion = mod.invalidationVersion;
   if (cleanReqUrl.startsWith("/@modules/")) {
     const code2 = await bundlePackageAsEsm(filePath, config.root);
     const transformResult2 = { code: code2 };
     mod.transformResult = transformResult2;
     return transformResult2;
   }
-  let code = import_node_fs8.default.readFileSync(filePath, "utf-8");
+  let code = import_node_fs9.default.readFileSync(filePath, "utf-8");
   const pluginResult = await pluginContainer.transform(code, filePath);
   if (pluginResult) {
     code = typeof pluginResult === "string" ? pluginResult : pluginResult.code;
@@ -3338,9 +4002,10 @@ async function transformRequest(url, ctx) {
     if (useRefresh) {
       code = buildReactRefreshWrapper(stableUrl, code);
       wrappedWithRefresh = true;
-      mod.isSelfAccepting = true;
     }
   }
+  const hotInfo = rewriteHotAcceptDeps(code, config, filePath);
+  code = hotInfo.code;
   if (!wrappedWithRefresh) {
     code = injectImportMetaHot(code, stableUrl);
   }
@@ -3349,9 +4014,20 @@ async function transformRequest(url, ctx) {
     config.mode
   );
   code = replaceEnvInCode(code, envDefine);
-  code = rewriteImports(code, config, filePath);
+  const importedUrls = /* @__PURE__ */ new Set();
+  code = rewriteImports(code, config, filePath, importedUrls, moduleGraph);
+  const pruned = await moduleGraph.updateModuleInfo(
+    mod,
+    importedUrls,
+    hotInfo.acceptedUrls,
+    wrappedWithRefresh || hotInfo.isSelfAccepting,
+    transformVersion
+  );
   const transformResult = { code };
-  mod.transformResult = transformResult;
+  if (pruned) {
+    if (pruned.size > 0) ctx.onPrune?.([...pruned].map((item) => item.url));
+    mod.transformResult = transformResult;
+  }
   return transformResult;
 }
 async function loadVirtualModule(spec, ctx) {
@@ -3359,7 +4035,7 @@ async function loadVirtualModule(spec, ctx) {
   const resolved = await pluginContainer.resolveId(spec);
   if (resolved == null) return null;
   const resolvedId = typeof resolved === "string" ? resolved : resolved.id;
-  const looksVirtual = resolvedId.startsWith("\0") || !import_node_fs8.default.existsSync(resolvedId);
+  const looksVirtual = resolvedId.startsWith("\0") || !import_node_fs9.default.existsSync(resolvedId);
   if (!looksVirtual) return null;
   const loadResult = await pluginContainer.load(resolvedId);
   if (loadResult == null) return null;
@@ -3372,7 +4048,7 @@ async function loadVirtualModule(spec, ctx) {
     loadEnv(config.mode, config.root, config.envPrefix),
     config.mode
   ));
-  const anchor = import_node_path11.default.join(config.root, "__nasti_virtual__.ts");
+  const anchor = import_node_path12.default.join(config.root, "__nasti_virtual__.ts");
   code = rewriteImports(code, config, anchor);
   return { id: resolvedId, result: { code } };
 }
@@ -3398,7 +4074,7 @@ async function doBundlePackage(entryFile, root) {
   await bundle2.close();
   let code = result.output[0].code;
   code = code.replace(/process\.env\.NODE_ENV/g, '"development"');
-  const externalBaseDir = import_node_path11.default.dirname(entryFile);
+  const externalBaseDir = import_node_path12.default.dirname(entryFile);
   code = code.replace(
     /^(import\b[^;'"]*?\bfrom\s+)(['"])([^'"./][^'"]*)(\2)/gm,
     (_, prefix, q, spec) => `${prefix}${q}${externalSpecToModuleUrl(spec, externalBaseDir, root)}${q}`
@@ -3416,16 +4092,16 @@ async function doBundlePackage(entryFile, root) {
   return code;
 }
 async function tryGenerateSubpathShim(entryFile, root) {
-  const NM = `${import_node_path11.default.sep}node_modules${import_node_path11.default.sep}`;
+  const NM = `${import_node_path12.default.sep}node_modules${import_node_path12.default.sep}`;
   if (!entryFile.includes(NM)) return null;
   let pkgDir = null;
   let pkgName = null;
-  let dir = import_node_path11.default.dirname(entryFile);
+  let dir = import_node_path12.default.dirname(entryFile);
   while (true) {
-    const pkgJsonPath = import_node_path11.default.join(dir, "package.json");
-    if (import_node_fs8.default.existsSync(pkgJsonPath)) {
+    const pkgJsonPath = import_node_path12.default.join(dir, "package.json");
+    if (import_node_fs9.default.existsSync(pkgJsonPath)) {
       try {
-        const pkg = JSON.parse(import_node_fs8.default.readFileSync(pkgJsonPath, "utf-8"));
+        const pkg = JSON.parse(import_node_fs9.default.readFileSync(pkgJsonPath, "utf-8"));
         if (typeof pkg?.name === "string" && pkg.name) {
           pkgDir = dir;
           pkgName = pkg.name;
@@ -3434,16 +4110,16 @@ async function tryGenerateSubpathShim(entryFile, root) {
       } catch {
       }
     }
-    const parent = import_node_path11.default.dirname(dir);
+    const parent = import_node_path12.default.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
     if (!dir.includes(NM)) return null;
   }
   if (!pkgDir || !pkgName) return null;
-  const entryExt = import_node_path11.default.extname(entryFile);
+  const entryExt = import_node_path12.default.extname(entryFile);
   const mainEntry = pickMainEntryByExtension(pkgDir, entryExt);
   if (!mainEntry) return null;
-  if (import_node_path11.default.resolve(mainEntry) === import_node_path11.default.resolve(entryFile)) return null;
+  if (import_node_path12.default.resolve(mainEntry) === import_node_path12.default.resolve(entryFile)) return null;
   let mainNs;
   let subNs;
   try {
@@ -3467,7 +4143,7 @@ async function tryGenerateSubpathShim(entryFile, root) {
     if (mainNs["default"] !== subNs["default"]) return null;
   }
   const rootMain = resolveNodeModule(root, pkgName);
-  const mainEntryUrl = rootMain && rootMain.startsWith(pkgDir + import_node_path11.default.sep) ? `/@modules/${pkgName}` : `/@modules/${pkgName}?id=${encodeURIComponent(mainEntry)}`;
+  const mainEntryUrl = rootMain && rootMain.startsWith(pkgDir + import_node_path12.default.sep) ? `/@modules/${pkgName}` : `/@modules/${pkgName}?id=${encodeURIComponent(mainEntry)}`;
   const lines = [
     `// Nasti subpath shim \u2192 ${pkgName} (avoid duplicate bundling)`,
     `import * as __pkg from "${mainEntryUrl}";`
@@ -3481,10 +4157,10 @@ async function tryGenerateSubpathShim(entryFile, root) {
   return lines.join("\n") + "\n";
 }
 function pickMainEntryByExtension(pkgDir, preferredExt) {
-  const pkgJsonPath = import_node_path11.default.join(pkgDir, "package.json");
+  const pkgJsonPath = import_node_path12.default.join(pkgDir, "package.json");
   let pkg;
   try {
-    pkg = JSON.parse(import_node_fs8.default.readFileSync(pkgJsonPath, "utf-8"));
+    pkg = JSON.parse(import_node_fs9.default.readFileSync(pkgJsonPath, "utf-8"));
   } catch {
     return null;
   }
@@ -3503,14 +4179,14 @@ function pickMainEntryByExtension(pkgDir, preferredExt) {
   if (typeof pkg.module === "string") candidates.push(pkg.module);
   if (typeof pkg.main === "string") candidates.push(pkg.main);
   for (const cand of candidates) {
-    if (import_node_path11.default.extname(cand) === preferredExt) {
-      const full = import_node_path11.default.resolve(pkgDir, cand);
-      if (import_node_fs8.default.existsSync(full)) return full;
+    if (import_node_path12.default.extname(cand) === preferredExt) {
+      const full = import_node_path12.default.resolve(pkgDir, cand);
+      if (import_node_fs9.default.existsSync(full)) return full;
     }
   }
   for (const cand of candidates) {
-    const full = import_node_path11.default.resolve(pkgDir, cand);
-    if (import_node_fs8.default.existsSync(full)) return full;
+    const full = import_node_path12.default.resolve(pkgDir, cand);
+    if (import_node_fs9.default.existsSync(full)) return full;
   }
   return null;
 }
@@ -3556,72 +4232,231 @@ async function injectCjsNamedExports(code, entryFile) {
     return code;
   }
 }
-function rewriteImports(code, config, filePath) {
+function rewriteImports(code, config, filePath, importedUrls, moduleGraph) {
+  const resolveSpec = createModuleSpecifierResolver(config, filePath);
+  const transformSpec = (spec) => {
+    const resolved = removeTimestampQuery(resolveSpec(spec));
+    importedUrls?.add(resolved);
+    const timestamp = moduleGraph?.getModuleByUrl(resolved)?.lastHMRTimestamp ?? 0;
+    return timestamp > 0 ? appendTimestampQuery(resolved, timestamp) : resolved;
+  };
+  return code.replace(
+    /\bfrom\s+(['"])([^'"]+)\1/g,
+    (_m, q, s) => `from ${q}${transformSpec(s)}${q}`
+  ).replace(
+    /\bimport\s+(['"])([^'"]+)\1/g,
+    (_m, q, s) => `import ${q}${transformSpec(s)}${q}`
+  ).replace(
+    /\bimport\s*\(\s*(['"])([^'"]+)\1\s*\)/g,
+    (_m, q, s) => `import(${q}${transformSpec(s)}${q})`
+  );
+}
+function createModuleSpecifierResolver(config, filePath) {
   const root = config.root;
-  const fileDir = import_node_path11.default.dirname(filePath);
+  const fileDir = import_node_path12.default.dirname(filePath);
   const aliasEntries = Object.entries(config.resolve.alias).sort(
     ([a], [b]) => b.length - a.length
   );
-  const toRootUrl = (abs) => "/" + import_node_path11.default.relative(root, abs).replace(/\\/g, "/");
-  const transformSpec = (spec) => {
-    const suffixMatch = spec.match(/[?#].*$/);
+  const toRootUrl = (abs) => "/" + import_node_path12.default.relative(root, abs).replace(/\\/g, "/");
+  return (specifier) => {
+    const suffixMatch = specifier.match(/[?#].*$/);
     const suffix = suffixMatch ? suffixMatch[0] : "";
-    const baseSpec = suffix ? spec.slice(0, -suffix.length) : spec;
+    const baseSpec = suffix ? specifier.slice(0, -suffix.length) : specifier;
     for (const [key, value] of aliasEntries) {
       if (baseSpec === key || baseSpec.startsWith(key + "/")) {
         const aliasBase = resolveAliasTarget2(value, root);
         const sub = baseSpec.slice(key.length).replace(/^\//, "");
-        const target = sub ? import_node_path11.default.join(aliasBase, sub) : aliasBase;
+        const target = sub ? import_node_path12.default.join(aliasBase, sub) : aliasBase;
         const resolved = tryResolveDiskPath(target);
-        return resolved && isUnderRoot(resolved, root) ? toRootUrl(resolved) + suffix : spec;
+        return resolved && isUnderRoot(resolved, root) ? toRootUrl(resolved) + suffix : specifier;
       }
     }
     if (baseSpec.startsWith("./") || baseSpec.startsWith("../")) {
-      const target = import_node_path11.default.resolve(fileDir, baseSpec);
-      const resolved = tryResolveDiskPath(target);
-      return resolved && isUnderRoot(resolved, root) ? toRootUrl(resolved) + suffix : spec;
+      const resolved = tryResolveDiskPath(import_node_path12.default.resolve(fileDir, baseSpec));
+      return resolved && isUnderRoot(resolved, root) ? toRootUrl(resolved) + suffix : specifier;
     }
     if (baseSpec.startsWith("/") && !baseSpec.startsWith("/@")) {
-      const target = import_node_path11.default.join(root, baseSpec.replace(/^\//, ""));
-      const resolved = tryResolveDiskPath(target);
-      return resolved && isUnderRoot(resolved, root) ? toRootUrl(resolved) + suffix : spec;
+      const resolved = tryResolveDiskPath(import_node_path12.default.join(root, baseSpec.replace(/^\//, "")));
+      return resolved && isUnderRoot(resolved, root) ? toRootUrl(resolved) + suffix : specifier;
     }
-    if (baseSpec.startsWith("/")) return spec;
-    return `/@modules/${spec}`;
+    if (baseSpec.startsWith("/")) return specifier;
+    return `/@modules/${specifier}`;
   };
-  return code.replace(
-    /\bfrom\s+(['"])([^'"]+)\1/g,
-    (_m, q, s) => `from ${q}${transformSpec(s)}${q}`
-  ).replace(
-    /\bimport\s+(['"])([^'"]+)\1/g,
-    (_m, q, s) => `import ${q}${transformSpec(s)}${q}`
-  ).replace(
-    /\bimport\s*\(\s*(['"])([^'"]+)\1\s*\)/g,
-    (_m, q, s) => `import(${q}${transformSpec(s)}${q})`
-  );
+}
+function rewriteHotAcceptDeps(code, config, filePath) {
+  const acceptedUrls = /* @__PURE__ */ new Set();
+  const edits = [];
+  const resolveSpec = createModuleSpecifierResolver(config, filePath);
+  const acceptRE = /(?:\bimport\.meta\.hot|\b__nasti_hot__)(?:(?:\?\.)|\.)accept\s*\(/g;
+  const searchableCode = maskStringsAndComments(code);
+  let isSelfAccepting = false;
+  let match;
+  while (match = acceptRE.exec(searchableCode)) {
+    let cursor = match.index + match[0].length;
+    const skipTrivia = () => {
+      while (cursor < code.length) {
+        if (/\s/.test(code[cursor])) {
+          cursor++;
+          continue;
+        }
+        if (code[cursor] === "/" && code[cursor + 1] === "/") {
+          cursor += 2;
+          while (cursor < code.length && code[cursor] !== "\n") cursor++;
+          continue;
+        }
+        if (code[cursor] === "/" && code[cursor + 1] === "*") {
+          cursor += 2;
+          while (cursor < code.length && !(code[cursor] === "*" && code[cursor + 1] === "/")) cursor++;
+          cursor += 2;
+          continue;
+        }
+        break;
+      }
+    };
+    skipTrivia();
+    const first = code[cursor];
+    if (!first || first === ")" || first !== "[" && first !== "'" && first !== '"' && first !== "`") {
+      isSelfAccepting = true;
+      continue;
+    }
+    const readLiteral = () => {
+      const quote = code[cursor];
+      if (quote !== "'" && quote !== '"' && quote !== "`") return;
+      const start = cursor;
+      cursor++;
+      let raw = "";
+      while (cursor < code.length) {
+        const char = code[cursor];
+        if (char === "\\") {
+          raw += code[cursor + 1] ?? "";
+          cursor += 2;
+          continue;
+        }
+        if (char === quote) {
+          cursor++;
+          const resolved = removeTimestampQuery(resolveSpec(raw));
+          acceptedUrls.add(resolved);
+          edits.push({ start, end: cursor, value: JSON.stringify(resolved) });
+          return;
+        }
+        if (quote === "`" && char === "$" && code[cursor + 1] === "{") return;
+        raw += char;
+        cursor++;
+      }
+    };
+    if (first === "[") {
+      cursor++;
+      while (cursor < code.length) {
+        skipTrivia();
+        if (code[cursor] === ",") {
+          cursor++;
+          skipTrivia();
+        }
+        if (code[cursor] === "]") break;
+        const before = cursor;
+        readLiteral();
+        if (cursor === before) break;
+      }
+    } else {
+      readLiteral();
+    }
+  }
+  for (const edit of edits.sort((a, b) => b.start - a.start)) {
+    code = code.slice(0, edit.start) + edit.value + code.slice(edit.end);
+  }
+  return { code, acceptedUrls, isSelfAccepting };
+}
+function maskStringsAndComments(code) {
+  const masked = code.split("");
+  let state = "code";
+  const isRegexStart = (index2) => {
+    let previous = index2 - 1;
+    while (previous >= 0 && /\s/.test(code[previous])) previous--;
+    return previous < 0 || "=(:,!&|?{};[]+-*%^~<>".includes(code[previous]);
+  };
+  for (let i = 0; i < code.length; i++) {
+    const char = code[i];
+    const next = code[i + 1];
+    if (state === "code") {
+      if (char === "'") state = "single";
+      else if (char === '"') state = "double";
+      else if (char === "`") state = "template";
+      else if (char === "/" && next === "/") state = "line-comment";
+      else if (char === "/" && next === "*") state = "block-comment";
+      else if (char === "/" && isRegexStart(i)) state = "regex";
+      else continue;
+      masked[i] = " ";
+      continue;
+    }
+    if (state === "line-comment") {
+      if (char === "\n") {
+        state = "code";
+      } else {
+        masked[i] = " ";
+      }
+      continue;
+    }
+    if (state === "block-comment") {
+      masked[i] = char === "\n" ? "\n" : " ";
+      if (char === "*" && next === "/") {
+        masked[i + 1] = " ";
+        i++;
+        state = "code";
+      }
+      continue;
+    }
+    if (state === "regex" || state === "regex-class") {
+      masked[i] = char === "\n" ? "\n" : " ";
+      if (char === "\\") {
+        if (i + 1 < code.length) masked[++i] = " ";
+      } else if (state === "regex" && char === "[") {
+        state = "regex-class";
+      } else if (state === "regex-class" && char === "]") {
+        state = "regex";
+      } else if (state === "regex" && char === "/") {
+        state = "code";
+      }
+      continue;
+    }
+    masked[i] = char === "\n" ? "\n" : " ";
+    if (char === "\\") {
+      if (i + 1 < code.length) masked[++i] = " ";
+      continue;
+    }
+    if (state === "single" && char === "'" || state === "double" && char === '"' || state === "template" && char === "`") {
+      state = "code";
+    }
+  }
+  return masked.join("");
 }
 function resolveAliasTarget2(value, root) {
-  if (import_node_path11.default.isAbsolute(value) && import_node_fs8.default.existsSync(value)) return value;
-  if (value.startsWith("/")) return import_node_path11.default.join(root, value.slice(1));
-  return import_node_path11.default.resolve(root, value);
+  if (import_node_path12.default.isAbsolute(value) && import_node_fs9.default.existsSync(value)) return value;
+  if (value.startsWith("/")) return import_node_path12.default.join(root, value.slice(1));
+  return import_node_path12.default.resolve(root, value);
 }
 function tryResolveDiskPath(target) {
-  if (import_node_fs8.default.existsSync(target) && import_node_fs8.default.statSync(target).isFile()) return target;
+  if (import_node_fs9.default.existsSync(target) && import_node_fs9.default.statSync(target).isFile()) return target;
   for (const ext of RESOLVE_EXTENSIONS) {
     const withExt = target + ext;
-    if (import_node_fs8.default.existsSync(withExt) && import_node_fs8.default.statSync(withExt).isFile()) return withExt;
+    if (import_node_fs9.default.existsSync(withExt) && import_node_fs9.default.statSync(withExt).isFile()) return withExt;
   }
-  if (import_node_fs8.default.existsSync(target) && import_node_fs8.default.statSync(target).isDirectory()) {
+  if (import_node_fs9.default.existsSync(target) && import_node_fs9.default.statSync(target).isDirectory()) {
     for (const ext of RESOLVE_EXTENSIONS) {
-      const idx = import_node_path11.default.join(target, "index" + ext);
-      if (import_node_fs8.default.existsSync(idx) && import_node_fs8.default.statSync(idx).isFile()) return idx;
+      const idx = import_node_path12.default.join(target, "index" + ext);
+      if (import_node_fs9.default.existsSync(idx) && import_node_fs9.default.statSync(idx).isFile()) return idx;
     }
   }
   return null;
 }
 function isUnderRoot(abs, root) {
-  const rel = import_node_path11.default.relative(root, abs);
-  return !!rel && !rel.startsWith("..") && !import_node_path11.default.isAbsolute(rel);
+  const rel = import_node_path12.default.relative(root, abs);
+  return !!rel && !rel.startsWith("..") && !import_node_path12.default.isAbsolute(rel);
+}
+function appendTimestampQuery(url, timestamp) {
+  const hashIndex = url.indexOf("#");
+  const hash = hashIndex >= 0 ? url.slice(hashIndex) : "";
+  const withoutHash = hashIndex >= 0 ? url.slice(0, hashIndex) : url;
+  return `${withoutHash}${withoutHash.includes("?") ? "&" : "?"}t=${timestamp}${hash}`;
 }
 function externalSpecToModuleUrl(spec, baseDir, root) {
   const resolved = resolveNodeModule(baseDir, spec);
@@ -3634,7 +4469,7 @@ function resolveNodeModule(baseDir, moduleName) {
   const resolved = resolveNodeModuleEntry(baseDir, moduleName);
   if (!resolved) return null;
   try {
-    return import_node_fs8.default.realpathSync(resolved);
+    return import_node_fs9.default.realpathSync(resolved);
   } catch {
     return resolved;
   }
@@ -3654,21 +4489,21 @@ function resolveNodeModuleEntry(root, moduleName) {
   let pkgDir = null;
   let dir = root;
   for (; ; ) {
-    const candidate = import_node_path11.default.join(dir, "node_modules", pkgName);
-    if (import_node_fs8.default.existsSync(candidate)) {
+    const candidate = import_node_path12.default.join(dir, "node_modules", pkgName);
+    if (import_node_fs9.default.existsSync(candidate)) {
       pkgDir = candidate;
       break;
     }
-    const parent = import_node_path11.default.dirname(dir);
+    const parent = import_node_path12.default.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
   if (!pkgDir) return null;
-  const pkgJsonPath = import_node_path11.default.join(pkgDir, "package.json");
-  if (!import_node_fs8.default.existsSync(pkgJsonPath)) return null;
+  const pkgJsonPath = import_node_path12.default.join(pkgDir, "package.json");
+  if (!import_node_fs9.default.existsSync(pkgJsonPath)) return null;
   let pkg;
   try {
-    pkg = JSON.parse(import_node_fs8.default.readFileSync(pkgJsonPath, "utf-8"));
+    pkg = JSON.parse(import_node_fs9.default.readFileSync(pkgJsonPath, "utf-8"));
   } catch {
     return null;
   }
@@ -3681,32 +4516,32 @@ function resolveNodeModuleEntry(root, moduleName) {
     const subDirs = [""];
     for (const field of ["module", "main"]) {
       if (typeof pkg[field] === "string") {
-        const dir2 = import_node_path11.default.dirname(pkg[field]);
+        const dir2 = import_node_path12.default.dirname(pkg[field]);
         if (dir2 && dir2 !== "." && !subDirs.includes(dir2)) subDirs.push(dir2);
       }
     }
     for (const dir2 of subDirs) {
-      const direct = import_node_path11.default.join(pkgDir, dir2, subpath);
-      if (import_node_fs8.default.existsSync(direct) && import_node_fs8.default.statSync(direct).isFile()) return direct;
+      const direct = import_node_path12.default.join(pkgDir, dir2, subpath);
+      if (import_node_fs9.default.existsSync(direct) && import_node_fs9.default.statSync(direct).isFile()) return direct;
       for (const ext of RESOLVE_EXTENSIONS) {
-        if (import_node_fs8.default.existsSync(direct + ext)) return direct + ext;
+        if (import_node_fs9.default.existsSync(direct + ext)) return direct + ext;
       }
     }
     return null;
   }
   for (const field of ["module", "jsnext:main", "jsnext", "main"]) {
     if (typeof pkg[field] === "string") {
-      const entry = import_node_path11.default.join(pkgDir, pkg[field]);
-      if (import_node_fs8.default.existsSync(entry)) return entry;
+      const entry = import_node_path12.default.join(pkgDir, pkg[field]);
+      if (import_node_fs9.default.existsSync(entry)) return entry;
     }
   }
-  const indexFallback = import_node_path11.default.join(pkgDir, "index.js");
-  if (import_node_fs8.default.existsSync(indexFallback)) return indexFallback;
+  const indexFallback = import_node_path12.default.join(pkgDir, "index.js");
+  if (import_node_fs9.default.existsSync(indexFallback)) return indexFallback;
   return null;
 }
 function resolvePackageExports(exports2, key, pkgDir) {
   if (typeof exports2 === "string") {
-    return key === "." ? import_node_path11.default.join(pkgDir, exports2) : null;
+    return key === "." ? import_node_path12.default.join(pkgDir, exports2) : null;
   }
   const entry = exports2[key];
   if (entry === void 0) {
@@ -3718,7 +4553,7 @@ function resolvePackageExports(exports2, key, pkgDir) {
   return resolveExportValue(entry, pkgDir);
 }
 function resolveExportValue(value, pkgDir) {
-  if (typeof value === "string") return import_node_path11.default.join(pkgDir, value);
+  if (typeof value === "string") return import_node_path12.default.join(pkgDir, value);
   if (Array.isArray(value)) {
     for (const item of value) {
       const r = resolveExportValue(item, pkgDir);
@@ -3742,17 +4577,17 @@ function resolveUrlToFile(url, root) {
     const moduleName = cleanUrl.slice("/@modules/".length);
     return resolveNodeModule(root, moduleName);
   }
-  const filePath = import_node_path11.default.resolve(root, cleanUrl.replace(/^\//, ""));
-  if (import_node_fs8.default.existsSync(filePath) && import_node_fs8.default.statSync(filePath).isFile()) {
+  const filePath = import_node_path12.default.resolve(root, cleanUrl.replace(/^\//, ""));
+  if (import_node_fs9.default.existsSync(filePath) && import_node_fs9.default.statSync(filePath).isFile()) {
     return filePath;
   }
   for (const ext of RESOLVE_EXTENSIONS) {
     const withExt = filePath + ext;
-    if (import_node_fs8.default.existsSync(withExt)) return withExt;
+    if (import_node_fs9.default.existsSync(withExt)) return withExt;
   }
   for (const ext of RESOLVE_EXTENSIONS) {
-    const indexFile = import_node_path11.default.join(filePath, "index" + ext);
-    if (import_node_fs8.default.existsSync(indexFile)) return indexFile;
+    const indexFile = import_node_path12.default.join(filePath, "index" + ext);
+    if (import_node_fs9.default.existsSync(indexFile)) return indexFile;
   }
   return null;
 }
@@ -3760,36 +4595,35 @@ 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 (!import_node_path11.default.extname(cleanUrl)) return true;
+  if (!import_node_path12.default.extname(cleanUrl)) return true;
   return false;
 }
 function getHmrClientCode() {
   return `
 // Nasti HMR Client
-const socket = new WebSocket(\`ws://\${location.host}\`, 'nasti-hmr');
+const socketProtocol = location.protocol === 'https:' ? 'wss' : 'ws';
+const socket = new WebSocket(socketProtocol + '://' + location.host, 'nasti-hmr');
 const hotModulesMap = new Map();
 const disposeMap = new Map();
 const pruneMap = new Map();
+const dataMap = new Map();
+let updateQueue = [];
+let pendingUpdateQueue = false;
 
 socket.addEventListener('message', async ({ data }) => {
   const payload = JSON.parse(data);
   switch (payload.type) {
     case 'connected':
-      console.log('[nasti] connected.');
+      console.debug('[nasti] connected.');
       clearErrorOverlay();
       break;
     case 'update':
       try {
-        await Promise.all(payload.updates.map((update) => {
-          if (update.type === 'js-update') {
-            return fetchUpdate(update);
-          } else if (update.type === 'css-update') {
-            return updateCss(update.path);
-          }
-        }));
+        // CSS \u5728 unbundled \u6A21\u5F0F\u4E0B\u4E5F\u662F\u4F1A\u6CE8\u5165 <style> \u7684 JS \u6A21\u5757\uFF0C\u548C\u666E\u901A JS
+        // \u4E00\u6837\u91CD\u65B0 import \u624D\u80FD\u6267\u884C dispose/accept \u5E76\u4FDD\u6301\u9875\u9762\u72B6\u6001\u3002
+        await Promise.all(payload.updates.map(queueUpdate));
         clearErrorOverlay();
-        console.log('[nasti] HMR update complete, reloading page');
-        location.reload();
+        console.debug('[nasti] HMR update complete.');
       } catch (err) {
         console.error('[nasti] HMR update failed:', err);
         showErrorOverlay(err);
@@ -3800,10 +4634,17 @@ socket.addEventListener('message', async ({ data }) => {
       location.reload();
       break;
     case 'prune':
-      payload.paths.forEach((p) => {
-        const cb = pruneMap.get(p);
-        if (cb) cb();
-      });
+      await Promise.all(payload.paths.map(async (path) => {
+        const data = dataMap.get(path);
+        const dispose = disposeMap.get(path);
+        const prune = pruneMap.get(path);
+        if (dispose) await dispose(data);
+        if (prune) await prune(data);
+        hotModulesMap.delete(path);
+        disposeMap.delete(path);
+        pruneMap.delete(path);
+        dataMap.delete(path);
+      }));
       break;
     case 'error':
       console.error('[nasti] error:', payload.err.message);
@@ -3812,33 +4653,64 @@ socket.addEventListener('message', async ({ data }) => {
   }
 });
 
-// \u81EA\u52A8\u91CD\u8FDE\uFF08\u65AD\u7EBF\u65F6\u6307\u6570\u9000\u907F\uFF09
+// \u670D\u52A1\u91CD\u542F\u540E\u65E7\u6A21\u5757\u56FE\u5DF2\u5931\u6548\uFF0C\u91CD\u8FDE\u65F6\u6574\u9875\u5237\u65B0\u662F\u5FC5\u8981\u515C\u5E95\uFF1B\u6B63\u5E38 update \u4E0D\u518D\u5237\u65B0\u3002
 let reconnectTimer = 0;
 socket.addEventListener('close', () => {
   clearTimeout(reconnectTimer);
   reconnectTimer = setTimeout(() => location.reload(), 1000);
 });
 
+/**
+ * \u540C\u4E00\u6279\u66F4\u65B0\u5148\u5168\u90E8\u62C9\u53D6\uFF0C\u518D\u6309\u670D\u52A1\u7AEF\u6D88\u606F\u987A\u5E8F\u6267\u884C accept \u56DE\u8C03\uFF0C\u907F\u514D HTTP \u5F80\u8FD4\u901F\u5EA6
+ * \u6539\u53D8\u6A21\u5757\u5E94\u7528\u987A\u5E8F\u3002\u8FD9\u4E0E Vite HMRClient \u7684 fetch/apply \u4E24\u9636\u6BB5\u4E00\u81F4\u3002
+ */
+async function queueUpdate(update) {
+  updateQueue.push(fetchUpdate(update));
+  if (pendingUpdateQueue) return;
+
+  pendingUpdateQueue = true;
+  await Promise.resolve();
+  pendingUpdateQueue = false;
+  const loading = updateQueue;
+  updateQueue = [];
+  const applyUpdates = await Promise.all(loading);
+  for (const apply of applyUpdates) {
+    if (apply) apply();
+  }
+}
+
 async function fetchUpdate(update) {
   const mod = hotModulesMap.get(update.path);
-  // \u5148\u8DD1 dispose\uFF08\u7ED9\u6A21\u5757\u673A\u4F1A\u6E05\u7406\u526F\u4F5C\u7528\uFF09
-  const dispose = disposeMap.get(update.path);
-  if (dispose) dispose();
+  // \u5C1A\u672A\u5728\u5F53\u524D\u9875\u9762\u52A0\u8F7D\u7684\u52A8\u6001\u6A21\u5757\u4E0D\u9700\u8981\u66F4\u65B0\u3002
+  if (!mod) return;
 
-  const newMod = await import(update.acceptedPath + '?t=' + update.timestamp);
-  if (mod) {
-    // \u590D\u5236\u56DE\u8C03\u6570\u7EC4\u907F\u514D\u56DE\u8C03\u5185\u90E8\u53C8\u4FEE\u6539 hotModulesMap \u9020\u6210\u8FED\u4EE3\u5F02\u5E38
-    [...mod.callbacks].forEach((cb) => cb(newMod));
-  }
+  // \u5FC5\u987B\u5728\u91CD\u65B0 import \u524D\u786E\u5B9A\u65E7\u56DE\u8C03\uFF1B\u65B0\u6A21\u5757\u6267\u884C createHotContext \u65F6\u4F1A\u6E05\u7A7A\u5E76\u6CE8\u518C\u65B0\u56DE\u8C03\u3002
+  const qualifiedCallbacks = mod.callbacks.filter(({ deps }) =>
+    deps.includes(update.acceptedPath)
+  );
+  const isSelfUpdate = update.path === update.acceptedPath;
+  if (!isSelfUpdate && qualifiedCallbacks.length === 0) return;
+
+  const dispose = disposeMap.get(update.acceptedPath);
+  if (dispose) await dispose(dataMap.get(update.acceptedPath));
+  const newMod = await import(appendTimestampQuery(update.acceptedPath, update.timestamp));
+
+  return () => {
+    for (const { deps, fn } of qualifiedCallbacks) {
+      fn(deps.map((dep) => dep === update.acceptedPath ? newMod : undefined));
+    }
+    const detail = isSelfUpdate
+      ? update.path
+      : update.acceptedPath + ' via ' + update.path;
+    console.debug('[nasti] hot updated:', detail);
+  };
 }
 
-function updateCss(path) {
-  const el = document.querySelector(\`style[data-nasti-css="\${path}"]\`);
-  if (el) {
-    return fetch(path + '?t=' + Date.now())
-      .then(r => r.text())
-      .then(css => { el.textContent = css; });
-  }
+function appendTimestampQuery(url, timestamp) {
+  const hashIndex = url.indexOf('#');
+  const hash = hashIndex >= 0 ? url.slice(hashIndex) : '';
+  const withoutHash = hashIndex >= 0 ? url.slice(0, hashIndex) : url;
+  return withoutHash + (withoutHash.includes('?') ? '&' : '?') + 't=' + timestamp + hash;
 }
 
 function clearErrorOverlay() {
@@ -3866,23 +4738,30 @@ function showErrorOverlay(err) {
   document.body.appendChild(overlay);
 }
 
-/**
- * \u751F\u6210 import.meta.hot \u7684 hot context\u3002
- * \u5173\u952E\u7EA6\u675F\uFF1A\u540C\u4E00 ownerPath \u7684 accept \u56DE\u8C03\u5FC5\u987B\u66FF\u6362\uFF08\u4E0D\u662F append\uFF09\u3002
- * \u6BCF\u6B21\u6A21\u5757\u91CD\u65B0 import \u90FD\u4F1A\u8C03\u7528 createHotContext\uFF0C\u65E7\u56DE\u8C03\u4F1A\u88AB fetchUpdate \u8C03\u7528\u540E\u7ACB\u5373\u88AB\u65B0 import
- * \u91CC\u7684 accept \u66FF\u6362\u3002\u4E0D\u66FF\u6362\u7684\u8BDD\u6BCF\u7F16\u8F91\u4E00\u6B21\u5C31\u591A\u4E00\u4E2A\u56DE\u8C03\uFF0C\u8D8A\u8DD1\u8D8A\u6162\u3002
- */
 export function createHotContext(ownerPath) {
+  if (!dataMap.has(ownerPath)) dataMap.set(ownerPath, {});
+
+  // \u6A21\u5757\u91CD\u65B0\u6267\u884C\u65F6\u4E22\u5F03\u65E7 accept \u56DE\u8C03\uFF0C\u4F46\u4FDD\u7559\u540C\u4E00\u4E2A hot.data \u5BF9\u8C61\u3002
+  const existing = hotModulesMap.get(ownerPath);
+  if (existing) existing.callbacks = [];
+
+  const acceptDeps = (deps, callback = () => {}) => {
+    const mod = hotModulesMap.get(ownerPath) || { id: ownerPath, callbacks: [] };
+    mod.callbacks.push({ deps, fn: callback });
+    hotModulesMap.set(ownerPath, mod);
+  };
+
   return {
     accept(deps, callback) {
-      // \u81EA\u63A5\u53D7: hot.accept() \u6216 hot.accept(callback)
       if (typeof deps === 'function' || deps === undefined) {
-        hotModulesMap.set(ownerPath, { callbacks: [deps || (() => {})] });
-        return;
+        acceptDeps([ownerPath], ([mod]) => deps?.(mod));
+      } else if (typeof deps === 'string') {
+        acceptDeps([deps], ([mod]) => callback?.(mod));
+      } else if (Array.isArray(deps)) {
+        acceptDeps(deps, callback);
+      } else {
+        throw new Error('invalid hot.accept() usage');
       }
-      // \u4F9D\u8D56\u63A5\u53D7: hot.accept(deps, callback)\uFF0C\u591A\u6B21\u8C03\u7528\u8FFD\u52A0
-      const existing = hotModulesMap.get(ownerPath)?.callbacks ?? [];
-      hotModulesMap.set(ownerPath, { callbacks: [...existing, callback] });
     },
     prune(callback) {
       pruneMap.set(ownerPath, callback);
@@ -3893,27 +4772,91 @@ export function createHotContext(ownerPath) {
     invalidate() {
       location.reload();
     },
-    data: {},
+    data: dataMap.get(ownerPath),
   };
 }
 `;
 }
-var import_node_path11, import_node_fs8, import_node_module5, import_node_url3, import_picocolors6, import_meta, __dirname_esm, __require, __refreshRuntimeCache, REACT_REFRESH_GLOBAL_PREAMBLE, esmBundleCache, VALID_IDENT, RESOLVE_EXTENSIONS, ESM_CONDITIONS;
+var import_node_path12, import_node_fs9, import_node_module5, import_node_url3, import_picocolors6, import_meta, __dirname_esm, __require, __refreshRuntimeCache, REACT_REFRESH_BOUNDARY_HELPERS, REACT_REFRESH_GLOBAL_PREAMBLE, esmBundleCache, VALID_IDENT, RESOLVE_EXTENSIONS, ESM_CONDITIONS;
 var init_middleware = __esm({
   "src/server/middleware.ts"() {
     "use strict";
-    import_node_path11 = __toESM(require("path"), 1);
-    import_node_fs8 = __toESM(require("fs"), 1);
+    import_node_path12 = __toESM(require("path"), 1);
+    import_node_fs9 = __toESM(require("fs"), 1);
     import_node_module5 = require("module");
     import_node_url3 = require("url");
     import_picocolors6 = __toESM(require("picocolors"), 1);
     init_transformer();
     init_html();
     init_env();
+    init_url();
     import_meta = {};
-    __dirname_esm = import_node_path11.default.dirname((0, import_node_url3.fileURLToPath)(import_meta.url));
+    __dirname_esm = import_node_path12.default.dirname((0, import_node_url3.fileURLToPath)(import_meta.url));
     __require = (0, import_node_module5.createRequire)(import_meta.url);
     __refreshRuntimeCache = null;
+    REACT_REFRESH_BOUNDARY_HELPERS = `
+function __nastiIsPlainObject(obj) {
+  return Object.prototype.toString.call(obj) === '[object Object]' &&
+    (obj.constructor === Object || obj.constructor === undefined);
+}
+function __nastiIsCompoundComponent(type) {
+  if (!__nastiIsPlainObject(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 value = moduleExports[key];
+    if (isLikelyComponentType(value)) {
+      register(value, filename + ' export ' + key);
+    } else if (__nastiIsCompoundComponent(value)) {
+      for (const subKey in value) {
+        register(value[subKey], filename + ' export ' + key + '-' + subKey);
+      }
+    }
+  }
+}
+let __nastiRefreshTimer;
+function __nastiEnqueueRefresh() {
+  clearTimeout(__nastiRefreshTimer);
+  __nastiRefreshTimer = setTimeout(() => performReactRefresh(), 16);
+}
+function __nastiCheckExports(ignored, exports, predicate) {
+  for (const key in exports) {
+    if (ignored.includes(key)) continue;
+    if (!predicate(key, exports[key])) return key;
+  }
+  return true;
+}
+export function validateRefreshBoundaryAndEnqueueUpdate(id, prevExports, nextExports) {
+  const ignored = window.__getReactRefreshIgnoredExports?.({ id }) ?? [];
+  if (__nastiCheckExports(ignored, prevExports, (key) => key in nextExports) !== true) {
+    return 'Could not Fast Refresh (export removed)';
+  }
+  if (__nastiCheckExports(ignored, nextExports, (key) => key in prevExports) !== true) {
+    return 'Could not Fast Refresh (new export)';
+  }
+  let hasExports = false;
+  const compatible = __nastiCheckExports(ignored, nextExports, (key, value) => {
+    hasExports = true;
+    return isLikelyComponentType(value) ||
+      __nastiIsCompoundComponent(value) ||
+      prevExports[key] === value;
+  });
+  if (!hasExports) {
+    return 'Could not Fast Refresh (no exports)';
+  }
+  if (compatible === true) {
+    __nastiEnqueueRefresh();
+    return;
+  }
+  return 'Could not Fast Refresh ("' + compatible + '" export is incompatible)';
+}
+export const __hmr_import = (module) => import(module);
+`;
     REACT_REFRESH_GLOBAL_PREAMBLE = `
 import RefreshRuntime from "/@react-refresh";
 RefreshRuntime.injectIntoGlobalHook(window);
@@ -3932,21 +4875,23 @@ window.__vite_plugin_react_preamble_installed__ = true;
 async function handleFileChange(file, server) {
   const { moduleGraph, ws, config } = server;
   const logger = config.logger;
-  const relativePath = "/" + import_node_path12.default.relative(config.root, file);
-  const shortFile = import_node_path12.default.relative(config.root, file);
+  const relativePath = "/" + import_node_path13.default.relative(config.root, file);
+  const shortFile = import_node_path13.default.relative(config.root, file);
   const mods = moduleGraph.getModulesByFile(file);
   if (!mods || mods.size === 0) {
     return;
   }
   const updates = [];
   const timestamp = Date.now();
+  const graph = moduleGraph;
+  const invalidatedModules = /* @__PURE__ */ new Set();
   for (const mod of mods) {
-    moduleGraph.invalidateModule(mod);
+    graph.invalidateModuleAndImporters(mod, timestamp, invalidatedModules);
     const ctx = {
       file,
       timestamp,
       modules: [mod],
-      read: () => import_node_fs9.default.readFileSync(file, "utf-8"),
+      read: () => import_node_fs10.default.readFileSync(file, "utf-8"),
       server
     };
     let affectedModules = [mod];
@@ -3959,19 +4904,25 @@ async function handleFileChange(file, server) {
       }
     }
     for (const affected of affectedModules) {
-      const boundaries = moduleGraph.getHmrBoundaries(affected);
+      graph.invalidateModuleAndImporters(affected, timestamp, invalidatedModules);
+      const boundaries = graph.getHmrBoundaries(affected);
       if (boundaries.length === 0) {
         logger.info(import_picocolors7.default.green("page reload ") + import_picocolors7.default.dim(shortFile), { timestamp: true });
         ws.send({ type: "full-reload", path: relativePath });
         return;
       }
-      for (const { boundary } of boundaries) {
-        updates.push({
+      for (const { boundary, acceptedVia } of boundaries) {
+        const update = {
           type: boundary.type === "css" ? "css-update" : "js-update",
           path: boundary.url,
-          acceptedPath: affected.url,
+          acceptedPath: acceptedVia.url,
           timestamp
-        });
+        };
+        if (!updates.some(
+          (existing) => existing.type === update.type && existing.path === update.path && existing.acceptedPath === update.acceptedPath
+        )) {
+          updates.push(update);
+        }
       }
     }
   }
@@ -3983,12 +4934,12 @@ async function handleFileChange(file, server) {
     ws.send({ type: "update", updates });
   }
 }
-var import_node_path12, import_node_fs9, import_picocolors7;
+var import_node_path13, import_node_fs10, import_picocolors7;
 var init_hmr = __esm({
   "src/server/hmr.ts"() {
     "use strict";
-    import_node_path12 = __toESM(require("path"), 1);
-    import_node_fs9 = __toESM(require("fs"), 1);
+    import_node_path13 = __toESM(require("path"), 1);
+    import_node_fs10 = __toESM(require("fs"), 1);
     import_picocolors7 = __toESM(require("picocolors"), 1);
   }
 });
@@ -4007,12 +4958,12 @@ function createModuleRunner(environment) {
   }
   return new NastiModuleRunner(environment);
 }
-var import_node_path13, import_node_fs10, import_node_module6, import_node_url4, debug5, NODE_BUILTINS3, NastiModuleRunner, AsyncFunction;
+var import_node_path14, import_node_fs11, import_node_module6, import_node_url4, debug5, NODE_BUILTINS3, NastiModuleRunner, AsyncFunction;
 var init_runnable_environment = __esm({
   "src/server/runnable-environment.ts"() {
     "use strict";
-    import_node_path13 = __toESM(require("path"), 1);
-    import_node_fs10 = __toESM(require("fs"), 1);
+    import_node_path14 = __toESM(require("path"), 1);
+    import_node_fs11 = __toESM(require("fs"), 1);
     import_node_module6 = require("module");
     import_node_url4 = require("url");
     init_transformer();
@@ -4034,7 +4985,7 @@ var init_runnable_environment = __esm({
           this.config.mode,
           ssrDefineOverrides(environment.consumer)
         );
-        this.require = (0, import_node_module6.createRequire)(import_node_path13.default.join(this.config.root, "package.json"));
+        this.require = (0, import_node_module6.createRequire)(import_node_path14.default.join(this.config.root, "package.json"));
         const handlers = {
           fetchModule: async (id, importer) => this.fetchModule(id, importer),
           getBuiltins: () => [/^node:/, ...import_node_module6.builtinModules]
@@ -4058,9 +5009,9 @@ var init_runnable_environment = __esm({
         this.cache.clear();
       }
       resolveToId(rawUrl) {
-        if (import_node_path13.default.isAbsolute(rawUrl) && import_node_fs10.default.existsSync(rawUrl.split("?")[0])) return rawUrl;
+        if (import_node_path14.default.isAbsolute(rawUrl) && import_node_fs11.default.existsSync(rawUrl.split("?")[0])) return rawUrl;
         const clean = rawUrl.replace(/^\//, "");
-        return import_node_path13.default.resolve(this.config.root, clean);
+        return import_node_path14.default.resolve(this.config.root, clean);
       }
       /**
        * fetchModule（invoke 契约方法）：环境管线产出 runner 可执行代码。
@@ -4069,14 +5020,14 @@ var init_runnable_environment = __esm({
        */
       async fetchModule(id, importer) {
         if (NODE_BUILTINS3.has(id)) return { externalize: id };
-        if (!id.startsWith(".") && !import_node_path13.default.isAbsolute(id) && !id.startsWith("\0")) {
+        if (!id.startsWith(".") && !import_node_path14.default.isAbsolute(id) && !id.startsWith("\0")) {
           return { externalize: id };
         }
         const container = this.environment.pluginContainer;
         let resolvedId = id;
         if (id.startsWith(".") && importer) {
           const resolved = await container.resolveId(id, importer);
-          resolvedId = resolved ? typeof resolved === "string" ? resolved : resolved.id : import_node_path13.default.resolve(import_node_path13.default.dirname(importer.split("?")[0]), id);
+          resolvedId = resolved ? typeof resolved === "string" ? resolved : resolved.id : import_node_path14.default.resolve(import_node_path14.default.dirname(importer.split("?")[0]), id);
         }
         resolvedId = this.completeExtension(resolvedId);
         const cleanId = resolvedId.split("?")[0];
@@ -4084,8 +5035,8 @@ var init_runnable_environment = __esm({
         const loaded = await container.load(resolvedId);
         if (loaded != null) {
           code = typeof loaded === "string" ? loaded : loaded.code;
-        } else if (import_node_fs10.default.existsSync(cleanId)) {
-          code = import_node_fs10.default.readFileSync(cleanId, "utf-8");
+        } else if (import_node_fs11.default.existsSync(cleanId)) {
+          code = import_node_fs11.default.readFileSync(cleanId, "utf-8");
         } else {
           throw new Error(`[nasti:ssr] cannot load module: ${resolvedId}`);
         }
@@ -4118,19 +5069,19 @@ var init_runnable_environment = __esm({
       completeExtension(id) {
         const clean = id.split("?")[0];
         const query = id.includes("?") ? id.slice(id.indexOf("?")) : "";
-        if (import_node_fs10.default.existsSync(clean) && import_node_fs10.default.statSync(clean).isFile()) return id;
+        if (import_node_fs11.default.existsSync(clean) && import_node_fs11.default.statSync(clean).isFile()) return id;
         const jsMatch = clean.match(/^(.*)\.([mc]?)jsx?$/);
         if (jsMatch) {
           for (const tsExt of [`.${jsMatch[2]}ts`, `.${jsMatch[2]}tsx`]) {
-            if (import_node_fs10.default.existsSync(jsMatch[1] + tsExt)) return jsMatch[1] + tsExt + query;
+            if (import_node_fs11.default.existsSync(jsMatch[1] + tsExt)) return jsMatch[1] + tsExt + query;
           }
         }
         for (const ext of this.config.resolve.extensions) {
-          if (import_node_fs10.default.existsSync(clean + ext)) return clean + ext + query;
+          if (import_node_fs11.default.existsSync(clean + ext)) return clean + ext + query;
         }
         for (const ext of this.config.resolve.extensions) {
-          const indexPath = import_node_path13.default.join(clean, `index${ext}`);
-          if (import_node_fs10.default.existsSync(indexPath)) return indexPath;
+          const indexPath = import_node_path14.default.join(clean, `index${ext}`);
+          if (import_node_fs11.default.existsSync(indexPath)) return indexPath;
         }
         return id;
       }
@@ -4157,10 +5108,10 @@ var init_runnable_environment = __esm({
           return;
         }
         const ssrImport = async (dep) => {
-          if (NODE_BUILTINS3.has(dep) || !dep.startsWith(".") && !import_node_path13.default.isAbsolute(dep) && !dep.startsWith("\0")) {
+          if (NODE_BUILTINS3.has(dep) || !dep.startsWith(".") && !import_node_path14.default.isAbsolute(dep) && !dep.startsWith("\0")) {
             return this.importExternal(dep);
           }
-          const depId = dep.startsWith(".") ? this.completeExtension(import_node_path13.default.resolve(import_node_path13.default.dirname(fetched.id.split("?")[0]), dep)) : this.completeExtension(dep);
+          const depId = dep.startsWith(".") ? this.completeExtension(import_node_path14.default.resolve(import_node_path14.default.dirname(fetched.id.split("?")[0]), dep)) : this.completeExtension(dep);
           return this.instantiate(depId);
         };
         const ssrExportAll = (sourceModule) => {
@@ -4192,7 +5143,7 @@ var init_runnable_environment = __esm({
       }
       async importExternal(spec) {
         try {
-          return await (spec.startsWith("node:") || !import_node_path13.default.isAbsolute(spec) ? import(this.resolveExternalSpecifier(spec)) : import((0, import_node_url4.pathToFileURL)(spec).href));
+          return await (spec.startsWith("node:") || !import_node_path14.default.isAbsolute(spec) ? import(this.resolveExternalSpecifier(spec)) : import((0, import_node_url4.pathToFileURL)(spec).href));
         } catch (err) {
           throw new Error(`[nasti:ssr] failed to import external "${spec}": ${err.message}`);
         }
@@ -4235,7 +5186,7 @@ async function createBundledDevServer(opts) {
       `[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 html = await readHtmlFile(config.root, config.environments.client?.html);
   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");
@@ -4250,7 +5201,7 @@ async function createBundledDevServer(opts) {
       createReactRefreshRuntimePlugin(entryPoints),
       createBundledOxcRefreshPlugin()
     ] : [],
-    ...stripCatchAllLoad(toRolldownPlugins(clientEnv.plugins)),
+    ...stripCatchAllLoad(toRolldownPlugins(clientEnv.plugins, clientEnv)),
     ...useReactRefresh ? [
       refreshWrapperFn({
         cwd: config.root,
@@ -4299,7 +5250,7 @@ async function createBundledDevServer(opts) {
       }
       const url = `/${patchPath}`;
       logger.info(
-        import_picocolors8.default.green("hmr update ") + import_picocolors8.default.dim(changedFiles.map((f) => import_node_path14.default.relative(config.root, f)).join(", ")),
+        import_picocolors8.default.green("hmr update ") + import_picocolors8.default.dim(changedFiles.map((f) => import_node_path15.default.relative(config.root, f)).join(", ")),
         { timestamp: true }
       );
       sendTo(clientId, { type: "hmr:update", path: url, url });
@@ -4435,13 +5386,13 @@ async function createBundledDevServer(opts) {
           return;
         }
         res.setHeader("ETag", hit.etag);
-        res.setHeader("Content-Type", MIME_TYPES[import_node_path14.default.extname(fileName)] ?? "application/octet-stream");
+        res.setHeader("Content-Type", MIME_TYPES[import_node_path15.default.extname(fileName)] ?? "application/octet-stream");
         res.setHeader("Cache-Control", "no-cache");
         res.end(hit.content);
         return;
       }
       if (pathname === "/" || pathname.endsWith(".html")) {
-        const rawHtml = await readHtmlFile(config.root);
+        const rawHtml = await readHtmlFile(config.root, config.environments.client?.html);
         if (rawHtml) {
           res.setHeader("Content-Type", "text/html");
           res.setHeader("Cache-Control", "no-store");
@@ -4471,7 +5422,7 @@ function stripCatchAllLoad(plugins) {
   );
 }
 function createReactRefreshRuntimePlugin(entryPoints) {
-  const entryIds = new Set(entryPoints.map((p) => import_node_path14.default.resolve(p)));
+  const entryIds = new Set(entryPoints.map((p) => import_node_path15.default.resolve(p)));
   return {
     name: "nasti:bundled-react-refresh",
     resolveId(source) {
@@ -4489,7 +5440,7 @@ function createReactRefreshRuntimePlugin(entryPoints) {
       return null;
     },
     transform(code, id) {
-      if (!entryIds.has(import_node_path14.default.resolve(id.split("?")[0]))) return null;
+      if (!entryIds.has(import_node_path15.default.resolve(id.split("?")[0]))) return null;
       return { code: `import ${JSON.stringify(PREAMBLE_SPEC)};
 ${code}`, map: null };
     }
@@ -4525,19 +5476,22 @@ async function renderBundledIndexHtml(html, config, entryFileNames) {
     }
   }
   for (const [facadeModuleId, fileName] of entryFileNames) {
-    const originalEntry = import_node_path14.default.relative(config.root, facadeModuleId);
-    processed = processed.replace(
-      new RegExp(`(src=["'])/?(${originalEntry.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")})(["'])`, "g"),
-      `$1/${fileName}$3`
+    processed = replaceEntryScript(
+      processed,
+      facadeModuleId,
+      fileName,
+      config,
+      config.environments.client?.html ?? "index.html",
+      "/"
     );
   }
   return processed;
 }
-var import_node_path14, import_node_crypto3, import_ws2, import_picocolors8, debug6, MIME_TYPES, MemoryFiles, PREAMBLE_SPEC, RESOLVED_PREAMBLE_ID, REFRESH_RUNTIME_URL, BUNDLED_PREAMBLE_CODE, WRAPPER_RUNTIME_HELPERS;
+var import_node_path15, import_node_crypto3, import_ws2, import_picocolors8, 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";
-    import_node_path14 = __toESM(require("path"), 1);
+    import_node_path15 = __toESM(require("path"), 1);
     import_node_crypto3 = __toESM(require("crypto"), 1);
     import_ws2 = require("ws");
     import_picocolors8 = __toESM(require("picocolors"), 1);
@@ -4664,27 +5618,38 @@ async function createServer(inlineConfig = {}) {
   const startTime = performance.now();
   const config = await resolveConfig(inlineConfig, "serve");
   const logger = config.logger;
-  const allPlugins = resolvePluginList(config, config.plugins);
+  const allPlugins = resolvePluginList(config, config.plugins, {
+    environmentName: "client"
+  });
   const configWithPlugins = { ...config, plugins: allPlugins };
   const app = (0, import_connect.default)();
   const httpServer = import_node_http.default.createServer(app);
   const ws = createWebSocketServer(httpServer);
-  const clientEnv = new NastiEnvironment("client", configWithPlugins, {
+  const pluginApi = getPluginApi(config);
+  const clientEnv = new NastiEnvironment("client", config, {
     hot: createWsHotChannel(ws),
     mode: "dev",
-    plugins: allPlugins
+    plugins: allPlugins,
+    pluginApi
   });
   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 }, {
+    const envPlugins = resolvePluginList(config, config.plugins, {
+      consumer,
+      environmentName: name
+    });
+    environments[name] = new NastiEnvironment(name, config, {
       mode: "dev",
-      plugins: envPlugins
+      plugins: envPlugins,
+      pluginApi
     });
   }
+  for (const [name, environment] of Object.entries(environments)) {
+    if (name !== "client" && environment.options.driver) await environment.init();
+  }
   let ssrRunner = null;
   async function getSsrRunner() {
     if (ssrRunner) return ssrRunner;
@@ -4709,23 +5674,15 @@ async function createServer(inlineConfig = {}) {
     });
     app.use(bundledServer.middleware);
   }
-  app.use(transformMiddleware({
-    config: configWithPlugins,
-    pluginContainer,
-    moduleGraph
-  }));
-  const publicDir = import_node_path15.default.resolve(config.root, "public");
-  app.use((0, import_sirv.default)(publicDir, { dev: true, etag: true }));
-  app.use((0, import_sirv.default)(config.root, { dev: true, etag: true }));
   const ignoredSegments = /* @__PURE__ */ new Set(["node_modules", ".git", ".nasti"]);
-  const outDirAbs = import_node_path15.default.resolve(config.root, config.build.outDir);
+  const outDirAbs = import_node_path16.default.resolve(config.root, config.build.outDir);
   const watcher = (0, import_chokidar.watch)(config.root, {
     ignored: (filePath) => {
       if (filePath === config.root) return false;
-      if (filePath === outDirAbs || filePath.startsWith(outDirAbs + import_node_path15.default.sep)) return true;
-      const rel = import_node_path15.default.relative(config.root, filePath);
-      if (!rel || rel.startsWith("..") || import_node_path15.default.isAbsolute(rel)) return false;
-      for (const seg of rel.split(import_node_path15.default.sep)) {
+      if (filePath === outDirAbs || filePath.startsWith(outDirAbs + import_node_path16.default.sep)) return true;
+      const rel = import_node_path16.default.relative(config.root, filePath);
+      if (!rel || rel.startsWith("..") || import_node_path16.default.isAbsolute(rel)) return false;
+      for (const seg of rel.split(import_node_path16.default.sep)) {
         if (ignoredSegments.has(seg)) return true;
       }
       return false;
@@ -4733,13 +5690,72 @@ async function createServer(inlineConfig = {}) {
     ignoreInitial: true
   });
   let server;
+  const environmentServices = {};
+  let environmentDriversStarted = false;
+  const logCloseError = (target, error) => {
+    const normalized = error instanceof Error ? error : new Error(String(error));
+    logger.error(`[nasti] failed to close ${target}`, { error: normalized });
+  };
+  const startEnvironmentDrivers = async () => {
+    if (environmentDriversStarted) return;
+    environmentDriversStarted = true;
+    const started = [];
+    const attempted = [];
+    try {
+      for (const [name, environment] of Object.entries(environments)) {
+        if (!environment.driver?.serve) continue;
+        attempted.push(environment);
+        const result = await environment.driver.serve({
+          ...environment.getDriverContext(),
+          server
+        });
+        started.push({ name, environment, service: result ?? {} });
+      }
+      for (const { name, service } of started) {
+        environmentServices[name] = service;
+        if (service.middleware) app.use(service.middleware);
+      }
+    } catch (error) {
+      environmentDriversStarted = false;
+      for (const { name } of started) {
+        delete environmentServices[name];
+      }
+      for (const environment of attempted.reverse()) {
+        try {
+          await environment.driver?.close?.(environment.getDriverContext());
+        } catch (closeError) {
+          logCloseError(`environment driver "${environment.driver.name}"`, closeError);
+        }
+      }
+      throw error;
+    }
+  };
+  const notifyEnvironmentDrivers = (file, event) => {
+    for (const environment of Object.values(environments)) {
+      if (!environment.driver?.watchChange) continue;
+      void Promise.resolve(
+        environment.driver.watchChange(file, event, environment.getDriverContext())
+      ).catch((error) => {
+        logger.error(
+          `[nasti] environment driver "${environment.driver.name}" watchChange failed`,
+          { error }
+        );
+      });
+    }
+  };
   watcher.on("change", (file) => {
     ssrRunner?.invalidateFile(file);
     handleFileChange(file, server);
+    notifyEnvironmentDrivers(file, "change");
   });
   watcher.on("add", (file) => {
     ssrRunner?.invalidateFile(file);
     handleFileChange(file, server);
+    notifyEnvironmentDrivers(file, "add");
+  });
+  watcher.on("unlink", (file) => {
+    ssrRunner?.invalidateFile(file);
+    notifyEnvironmentDrivers(file, "unlink");
   });
   server = {
     config: configWithPlugins,
@@ -4748,10 +5764,12 @@ async function createServer(inlineConfig = {}) {
     watcher,
     ws,
     environments,
+    environmentServices,
     async listen(port) {
       const finalPort = port ?? config.server.port;
       const host = config.server.host === true ? "0.0.0.0" : config.server.host;
       await pluginContainer.buildStart();
+      await startEnvironmentDrivers();
       return new Promise((resolve, reject) => {
         let currentPort = finalPort;
         const onListening = () => {
@@ -4759,15 +5777,20 @@ async function createServer(inlineConfig = {}) {
           config.server.port = actualPort;
           const localUrl = `http://localhost:${actualPort}/`;
           const networkUrl = host === "0.0.0.0" ? `http://${getNetworkAddress()}:${actualPort}/` : null;
+          const driverLocalUrls = Object.values(environmentServices).flatMap((service) => service.localUrls ?? []);
+          const driverNetworkUrls = Object.values(environmentServices).flatMap((service) => service.networkUrls ?? []);
           logger.clearScreen("info");
           const readyIn = Math.ceil(performance.now() - startTime);
           logger.info(
             `
-  ${import_picocolors9.default.cyan(import_picocolors9.default.bold("NASTI"))} ${import_picocolors9.default.cyan(`v${"2.2.0"}`)}  ${import_picocolors9.default.dim("ready in")} ${import_picocolors9.default.bold(readyIn)} ${import_picocolors9.default.dim("ms")}
+  ${import_picocolors9.default.cyan(import_picocolors9.default.bold("NASTI"))} ${import_picocolors9.default.cyan(`v${"2.4.0"}`)}  ${import_picocolors9.default.dim("ready in")} ${import_picocolors9.default.bold(readyIn)} ${import_picocolors9.default.dim("ms")}
 `
           );
           printServerUrls(
-            { local: [localUrl], network: networkUrl ? [networkUrl] : [] },
+            {
+              local: [localUrl, ...driverLocalUrls],
+              network: [...networkUrl ? [networkUrl] : [], ...driverNetworkUrls]
+            },
             logger.info
           );
           logger.info("");
@@ -4788,7 +5811,12 @@ async function createServer(inlineConfig = {}) {
     },
     async transformRequest(url) {
       const { transformRequest: transformRequest2 } = await Promise.resolve().then(() => (init_middleware(), middleware_exports));
-      return transformRequest2(url, { config: configWithPlugins, pluginContainer, moduleGraph });
+      return transformRequest2(url, {
+        config: configWithPlugins,
+        pluginContainer,
+        moduleGraph,
+        onPrune: (paths) => ws.send({ type: "prune", paths })
+      });
     },
     async ssrLoadModule(url) {
       const runner = await getSsrRunner();
@@ -4797,11 +5825,63 @@ async function createServer(inlineConfig = {}) {
     async close() {
       await pluginContainer.buildEnd();
       await bundledServer?.close();
-      watcher.close();
+      let environmentCloseFailed = false;
+      let firstEnvironmentCloseError;
+      for (const environment of Object.values(environments).reverse()) {
+        try {
+          await environment.close();
+        } catch (error) {
+          if (!environmentCloseFailed) {
+            environmentCloseFailed = true;
+            firstEnvironmentCloseError = error;
+          }
+          logCloseError(`environment "${environment.name}"`, error);
+        }
+      }
+      await watcher.close();
       ws.close();
       httpServer.close();
+      if (environmentCloseFailed) {
+        throw firstEnvironmentCloseError;
+      }
     }
   };
+  try {
+    await startEnvironmentDrivers();
+  } catch (error) {
+    if (bundledServer) {
+      try {
+        await bundledServer.close();
+      } catch (closeError) {
+        logCloseError("bundled dev server after driver startup failure", closeError);
+      }
+    }
+    try {
+      await watcher.close();
+    } catch (closeError) {
+      logCloseError("file watcher after driver startup failure", closeError);
+    }
+    try {
+      ws.close();
+    } catch (closeError) {
+      logCloseError("WebSocket server after driver startup failure", closeError);
+    }
+    try {
+      httpServer.close();
+    } catch (closeError) {
+      logCloseError("HTTP server after driver startup failure", closeError);
+    }
+    throw error;
+  }
+  app.use(transformMiddleware({
+    config: configWithPlugins,
+    pluginContainer,
+    moduleGraph,
+    onPrune: (paths) => ws.send({ type: "prune", paths })
+  }));
+  const publicDir = import_node_path16.default.resolve(config.root, "public");
+  app.use((0, import_sirv.default)(publicDir, { dev: true, etag: true }));
+  app.use((0, import_sirv.default)(config.root, { dev: true, etag: true }));
   const postMiddlewares = [];
   for (const plugin of allPlugins) {
     if (plugin.configureServer) {
@@ -4825,12 +5905,12 @@ function getNetworkAddress() {
   }
   return "localhost";
 }
-var import_node_http, import_node_path15, import_node_os, import_connect, import_sirv, import_chokidar, import_picocolors9;
+var import_node_http, import_node_path16, import_node_os, import_connect, import_sirv, import_chokidar, import_picocolors9;
 var init_server = __esm({
   "src/server/index.ts"() {
     "use strict";
     import_node_http = __toESM(require("http"), 1);
-    import_node_path15 = __toESM(require("path"), 1);
+    import_node_path16 = __toESM(require("path"), 1);
     import_node_os = __toESM(require("os"), 1);
     import_connect = __toESM(require("connect"), 1);
     import_sirv = __toESM(require("sirv"), 1);
@@ -4844,6 +5924,7 @@ var init_server = __esm({
     init_middleware();
     init_hmr();
     init_builtins();
+    init_plugin_api();
   }
 });
 
@@ -4856,12 +5937,15 @@ __export(src_exports, {
   buildElectron: () => buildElectron,
   buildEnvDefine: () => buildEnvDefine,
   createDebugger: () => createDebugger,
+  createElectronRendererConfig: () => createElectronRendererConfig,
   createLogger: () => createLogger,
   createNoopHotChannel: () => createNoopHotChannel,
   createServer: () => createServer,
   createWsHotChannel: () => createWsHotChannel,
   defineConfig: () => defineConfig,
+  detectFramework: () => detectFramework,
   electronPlugin: () => electronPlugin,
+  electronRendererDevPath: () => electronRendererDevPath,
   loadEnv: () => loadEnv,
   monacoEditorPlugin: () => monacoEditorPlugin,
   printServerUrls: () => printServerUrls,
@@ -4875,8 +5959,8 @@ init_config();
 init_build();
 
 // src/build/electron.ts
-var import_node_path10 = __toESM(require("path"), 1);
-var import_node_fs7 = __toESM(require("fs"), 1);
+var import_node_path11 = __toESM(require("path"), 1);
+var import_node_fs8 = __toESM(require("fs"), 1);
 var import_rolldown2 = require("rolldown");
 var import_picocolors5 = __toESM(require("picocolors"), 1);
 init_config();
@@ -4922,28 +6006,26 @@ async function buildElectron(inlineConfig = {}) {
   const config = await resolveConfig({ ...inlineConfig, target: "electron" }, "build");
   const startTime = performance.now();
   assertElectronVersion(config);
-  console.log(import_picocolors5.default.cyan("\n\u26A1 nasti build (electron)") + import_picocolors5.default.dim(` v${"2.2.0"}`));
+  console.log(import_picocolors5.default.cyan("\n\u26A1 nasti build (electron)") + import_picocolors5.default.dim(` v${"2.4.0"}`));
   console.log(import_picocolors5.default.dim(`  root: ${config.root}`));
   console.log(import_picocolors5.default.dim(`  mode: ${config.mode}`));
   console.log(import_picocolors5.default.dim(`  target: electron (\u2265 ${config.electron.minVersion})`));
-  const outDir = import_node_path10.default.resolve(config.root, config.build.outDir);
-  if (config.build.emptyOutDir && import_node_fs7.default.existsSync(outDir)) {
-    import_node_fs7.default.rmSync(outDir, { recursive: true, force: true });
+  const outDir = import_node_path11.default.resolve(config.root, config.build.outDir);
+  if (config.build.emptyOutDir && import_node_fs8.default.existsSync(outDir)) {
+    import_node_fs8.default.rmSync(outDir, { recursive: true, force: true });
   }
-  import_node_fs7.default.mkdirSync(outDir, { recursive: true });
-  const rendererOutDir = import_node_path10.default.join(outDir, "renderer");
+  import_node_fs8.default.mkdirSync(outDir, { recursive: true });
+  const rendererOutDir = import_node_path11.default.join(outDir, "renderer");
   const { build: build2 } = await Promise.resolve().then(() => (init_build(), build_exports));
-  await build2({
-    ...inlineConfig,
-    target: "web",
+  await build2(createElectronRendererConfig(config, inlineConfig, {
     build: {
       ...inlineConfig.build,
       outDir: rendererOutDir,
       emptyOutDir: false
     }
-  });
-  const mainEntry = import_node_path10.default.resolve(config.root, config.electron.main);
-  if (!import_node_fs7.default.existsSync(mainEntry)) {
+  }));
+  const mainEntry = import_node_path11.default.resolve(config.root, config.electron.main);
+  if (!import_node_fs8.default.existsSync(mainEntry)) {
     throw new Error(
       `Electron main entry not found: ${config.electron.main}
 \u5728 nasti.config.ts \u7684 electron.main \u6307\u5B9A\u4E3B\u8FDB\u7A0B\u5165\u53E3\u6587\u4EF6\u3002`
@@ -4957,11 +6039,11 @@ async function buildElectron(inlineConfig = {}) {
   const preloadEntries = normalizePreload(config.electron.preload, config.root);
   const preloadFiles = [];
   for (const entry of preloadEntries) {
-    if (!import_node_fs7.default.existsSync(entry)) {
+    if (!import_node_fs8.default.existsSync(entry)) {
       console.warn(import_picocolors5.default.yellow(`  \u26A0 preload entry not found, skipped: ${entry}`));
       continue;
     }
-    const base = import_node_path10.default.basename(entry).replace(/\.[^.]+$/, "");
+    const base = import_node_path11.default.basename(entry).replace(/\.[^.]+$/, "");
     const out = outFileName(outDir, base, config.electron.preloadFormat);
     await bundleNode(config, entry, {
       outFile: out,
@@ -4973,10 +6055,10 @@ async function buildElectron(inlineConfig = {}) {
   const elapsed = ((performance.now() - startTime) / 1e3).toFixed(2);
   console.log(import_picocolors5.default.green(`
 \u2713 Electron build complete in ${elapsed}s`));
-  console.log(import_picocolors5.default.dim(`  renderer: ${import_node_path10.default.relative(config.root, rendererOutDir)}/`));
-  console.log(import_picocolors5.default.dim(`  main:     ${import_node_path10.default.relative(config.root, mainFile)}`));
+  console.log(import_picocolors5.default.dim(`  renderer: ${import_node_path11.default.relative(config.root, rendererOutDir)}/`));
+  console.log(import_picocolors5.default.dim(`  main:     ${import_node_path11.default.relative(config.root, mainFile)}`));
   for (const pf of preloadFiles) {
-    console.log(import_picocolors5.default.dim(`  preload:  ${import_node_path10.default.relative(config.root, pf)}`));
+    console.log(import_picocolors5.default.dim(`  preload:  ${import_node_path11.default.relative(config.root, pf)}`));
   }
   console.log();
   return { rendererOutDir, mainFile, preloadFiles };
@@ -4995,7 +6077,8 @@ async function bundleNode(config, entry, opts) {
       const result = transformCode(id, code, {
         sourcemap: !!config.build.sourcemap,
         jsxRuntime: "automatic",
-        jsxImportSource: config.framework === "vue" ? "vue" : "react"
+        jsxImportSource: config.framework === "vue" ? "vue" : "react",
+        target: config.electron.nodeTarget
       });
       return { code: result.code, map: result.map ? JSON.parse(result.map) : void 0 };
     }
@@ -5006,10 +6089,14 @@ async function bundleNode(config, entry, opts) {
     ...restInputOptions,
     input: entry,
     platform: "node",
-    transform: { ...userTransform, define: mergedDefine },
+    transform: {
+      ...userTransform,
+      target: config.electron.nodeTarget,
+      define: mergedDefine
+    },
     plugins: [oxcTransformPlugin, electronPlugin(config), resolvePlugin(config)]
   });
-  import_node_fs7.default.mkdirSync(import_node_path10.default.dirname(opts.outFile), { recursive: true });
+  import_node_fs8.default.mkdirSync(import_node_path11.default.dirname(opts.outFile), { recursive: true });
   await bundle2.write({
     sourcemap: !!config.build.sourcemap,
     minify: !!config.build.minify,
@@ -5020,16 +6107,35 @@ async function bundleNode(config, entry, opts) {
     codeSplitting: false
   });
   await bundle2.close();
-  console.log(import_picocolors5.default.dim(`  \u2713 ${opts.label} \u2192 ${import_node_path10.default.relative(config.root, opts.outFile)}`));
+  console.log(import_picocolors5.default.dim(`  \u2713 ${opts.label} \u2192 ${import_node_path11.default.relative(config.root, opts.outFile)}`));
   return opts.outFile;
 }
+function createElectronRendererConfig(config, inlineConfig = {}, overrides = {}) {
+  const inlineClient = inlineConfig.environments?.client ?? {};
+  return {
+    ...inlineConfig,
+    ...overrides,
+    root: config.root,
+    mode: config.mode,
+    target: "web",
+    framework: config.framework,
+    base: config.base === "/" ? "./" : config.base,
+    environments: {
+      ...inlineConfig.environments ?? {},
+      client: {
+        ...inlineClient,
+        html: config.electron.renderer
+      }
+    }
+  };
+}
 function outFileName(outDir, base, format) {
   const ext = format === "cjs" ? ".cjs" : ".mjs";
-  return import_node_path10.default.join(outDir, base + ext);
+  return import_node_path11.default.join(outDir, base + ext);
 }
 function normalizePreload(preload, root) {
   const list = Array.isArray(preload) ? preload : preload ? [preload] : [];
-  return list.map((p) => import_node_path10.default.resolve(root, p));
+  return list.map((p) => import_node_path11.default.resolve(root, p));
 }
 function assertElectronVersion(config) {
   const min = config.electron.minVersion;
@@ -5044,9 +6150,9 @@ function assertElectronVersion(config) {
 }
 function detectInstalledElectron(root) {
   try {
-    const pkgPath = import_node_path10.default.resolve(root, "node_modules/electron/package.json");
-    if (!import_node_fs7.default.existsSync(pkgPath)) return null;
-    const pkg = JSON.parse(import_node_fs7.default.readFileSync(pkgPath, "utf-8"));
+    const pkgPath = import_node_path11.default.resolve(root, "node_modules/electron/package.json");
+    if (!import_node_fs8.default.existsSync(pkgPath)) return null;
+    const pkg = JSON.parse(import_node_fs8.default.readFileSync(pkgPath, "utf-8"));
     const major = parseInt(String(pkg.version).split(".")[0], 10);
     return Number.isFinite(major) ? major : null;
   } catch {
@@ -5058,8 +6164,8 @@ function detectInstalledElectron(root) {
 init_server();
 
 // src/server/electron-dev.ts
-var import_node_path16 = __toESM(require("path"), 1);
-var import_node_fs11 = __toESM(require("fs"), 1);
+var import_node_path17 = __toESM(require("path"), 1);
+var import_node_fs12 = __toESM(require("fs"), 1);
 var import_node_module7 = require("module");
 var import_node_child_process = require("child_process");
 var import_chokidar2 = __toESM(require("chokidar"), 1);
@@ -5073,17 +6179,21 @@ async function startElectronDev(inlineConfig = {}) {
   const { noSpawn, ...rest } = inlineConfig;
   const config = await resolveConfig({ ...rest, target: "electron" }, "serve");
   warnElectronVersion(config);
-  console.log(import_picocolors10.default.cyan("\n\u26A1 nasti electron dev") + import_picocolors10.default.dim(` v${"2.2.0"}`));
+  console.log(import_picocolors10.default.cyan("\n\u26A1 nasti electron dev") + import_picocolors10.default.dim(` v${"2.4.0"}`));
   const { createServer: createServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
-  const server = await createServer2({ ...rest, target: "electron" });
+  const server = await createServer2({
+    ...rest,
+    target: "electron",
+    framework: config.framework
+  });
   await server.listen();
-  const devUrl = `http://localhost:${server.config.server.port}/`;
+  const devUrl = `http://localhost:${server.config.server.port}` + electronRendererDevPath(config.electron.renderer);
   console.log(import_picocolors10.default.dim(`  renderer: ${devUrl}`));
-  const stageDir = import_node_path16.default.resolve(config.root, ".nasti");
-  import_node_fs11.default.mkdirSync(stageDir, { recursive: true });
-  const mainEntry = import_node_path16.default.resolve(config.root, config.electron.main);
+  const stageDir = import_node_path17.default.resolve(config.root, ".nasti");
+  import_node_fs12.default.mkdirSync(stageDir, { recursive: true });
+  const mainEntry = import_node_path17.default.resolve(config.root, config.electron.main);
   const preloadEntries = normalizePreload(config.electron.preload, config.root);
-  const builtMainFile = import_node_path16.default.join(stageDir, "main" + extFor(config.electron.mainFormat));
+  const builtMainFile = import_node_path17.default.join(stageDir, "main" + extFor(config.electron.mainFormat));
   const builtPreloadFiles = [];
   const compileAll = async () => {
     await compileNode(config, mainEntry, {
@@ -5093,9 +6203,9 @@ async function startElectronDev(inlineConfig = {}) {
     });
     builtPreloadFiles.length = 0;
     for (const entry of preloadEntries) {
-      if (!import_node_fs11.default.existsSync(entry)) continue;
-      const base = import_node_path16.default.basename(entry).replace(/\.[^.]+$/, "");
-      const out = import_node_path16.default.join(stageDir, base + extFor(config.electron.preloadFormat));
+      if (!import_node_fs12.default.existsSync(entry)) continue;
+      const base = import_node_path17.default.basename(entry).replace(/\.[^.]+$/, "");
+      const out = import_node_path17.default.join(stageDir, base + extFor(config.electron.preloadFormat));
       await compileNode(config, entry, {
         outFile: out,
         format: config.electron.preloadFormat,
@@ -5134,7 +6244,7 @@ async function startElectronDev(inlineConfig = {}) {
   };
   spawnElectron();
   if (config.electron.autoRestart) {
-    const watchTargets = [mainEntry, ...preloadEntries].filter(import_node_fs11.default.existsSync);
+    const watchTargets = [mainEntry, ...preloadEntries].filter(import_node_fs12.default.existsSync);
     const watcher = import_chokidar2.default.watch(watchTargets, { ignoreInitial: true });
     let restarting = null;
     let pending = false;
@@ -5199,18 +6309,22 @@ async function compileNode(config, entry, opts) {
       const result = transformCode(id, code, {
         sourcemap: true,
         jsxRuntime: "automatic",
-        jsxImportSource: config.framework === "vue" ? "vue" : "react"
+        jsxImportSource: config.framework === "vue" ? "vue" : "react",
+        target: config.electron.nodeTarget
       });
       return { code: result.code, map: result.map ? JSON.parse(result.map) : void 0 };
     }
   };
   const bundle2 = await (0, import_rolldown3.rolldown)({
     input: entry,
-    transform: { define: envDefine },
+    transform: {
+      target: config.electron.nodeTarget,
+      define: envDefine
+    },
     platform: "node",
     plugins: [oxcTransformPlugin, electronPlugin(config), resolvePlugin(config)]
   });
-  import_node_fs11.default.mkdirSync(import_node_path16.default.dirname(opts.outFile), { recursive: true });
+  import_node_fs12.default.mkdirSync(import_node_path17.default.dirname(opts.outFile), { recursive: true });
   await bundle2.write({
     file: opts.outFile,
     format: opts.format === "cjs" ? "cjs" : "esm",
@@ -5222,15 +6336,19 @@ async function compileNode(config, entry, opts) {
   });
   await bundle2.close();
 }
+function electronRendererDevPath(renderer) {
+  const normalized = renderer.split(import_node_path17.default.sep).join("/").replace(/^\.?\//, "");
+  return normalized === "index.html" ? "/" : `/${normalized}`;
+}
 function resolveElectronBinary(config) {
-  if (config.electron.electronPath && import_node_fs11.default.existsSync(config.electron.electronPath)) {
+  if (config.electron.electronPath && import_node_fs12.default.existsSync(config.electron.electronPath)) {
     return config.electron.electronPath;
   }
   try {
-    const require2 = (0, import_node_module7.createRequire)(import_node_path16.default.resolve(config.root, "package.json"));
+    const require2 = (0, import_node_module7.createRequire)(import_node_path17.default.resolve(config.root, "package.json"));
     const pathFile = require2.resolve("electron");
     const electronModule = require2(pathFile);
-    if (typeof electronModule === "string" && import_node_fs11.default.existsSync(electronModule)) {
+    if (typeof electronModule === "string" && import_node_fs12.default.existsSync(electronModule)) {
       return electronModule;
     }
   } catch {
@@ -5257,8 +6375,8 @@ function warnElectronVersion(config) {
 }
 
 // src/plugins/monaco-editor.ts
-var import_node_path17 = __toESM(require("path"), 1);
-var import_node_fs12 = __toESM(require("fs"), 1);
+var import_node_path18 = __toESM(require("path"), 1);
+var import_node_fs13 = __toESM(require("fs"), 1);
 var import_node_crypto4 = __toESM(require("crypto"), 1);
 var import_node_module8 = require("module");
 var DEFAULT_WORKERS = {
@@ -5279,9 +6397,9 @@ function normalizePublicPath(p) {
 }
 function readMonacoVersion(root) {
   try {
-    const require2 = (0, import_node_module8.createRequire)(import_node_path17.default.resolve(root, "package.json"));
+    const require2 = (0, import_node_module8.createRequire)(import_node_path18.default.resolve(root, "package.json"));
     const pkgJsonPath = require2.resolve("monaco-editor/package.json", { paths: [root] });
-    const pkg = JSON.parse(import_node_fs12.default.readFileSync(pkgJsonPath, "utf-8"));
+    const pkg = JSON.parse(import_node_fs13.default.readFileSync(pkgJsonPath, "utf-8"));
     return typeof pkg.version === "string" ? pkg.version : "unknown";
   } catch {
     return "unknown";
@@ -5301,20 +6419,20 @@ function monacoEditorPlugin(options = {}) {
   let cacheDir = "";
   const building = /* @__PURE__ */ new Map();
   async function buildWorker(worker) {
-    const cacheFile = import_node_path17.default.join(cacheDir, `${worker.label}.worker.js`);
-    if (import_node_fs12.default.existsSync(cacheFile)) return cacheFile;
+    const cacheFile = import_node_path18.default.join(cacheDir, `${worker.label}.worker.js`);
+    if (import_node_fs13.default.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 = (0, import_node_module8.createRequire)(import_node_path17.default.resolve(resolvedConfig.root, "package.json"));
+      const require2 = (0, import_node_module8.createRequire)(import_node_path18.default.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] });
       }
-      import_node_fs12.default.mkdirSync(cacheDir, { recursive: true });
+      import_node_fs13.default.mkdirSync(cacheDir, { recursive: true });
       const bundle2 = await rolldown4({
         input: entry,
         platform: "browser"
@@ -5374,12 +6492,12 @@ function monacoEditorPlugin(options = {}) {
       resolvedConfig = config;
       const version = readMonacoVersion(config.root);
       const key = import_node_crypto4.default.createHash("sha1").update(version + "|" + publicPath).digest("hex").slice(0, 8);
-      cacheDir = import_node_path17.default.resolve(config.root, "node_modules/.nasti/monaco", key);
+      cacheDir = import_node_path18.default.resolve(config.root, "node_modules/.nasti/monaco", key);
     },
     async configureServer(server) {
       const shouldBuild = !isCDN(publicPath) || forceBuildCDN;
       const watcher = server.watcher;
-      const monacoDir = import_node_path17.default.resolve(resolvedConfig.root, "node_modules/monaco-editor");
+      const monacoDir = import_node_path18.default.resolve(resolvedConfig.root, "node_modules/monaco-editor");
       try {
         watcher?.unwatch?.(monacoDir);
       } catch {
@@ -5409,7 +6527,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");
-            import_node_fs12.default.createReadStream(file).pipe(res);
+            import_node_fs13.default.createReadStream(file).pipe(res);
           } catch (e) {
             res.statusCode = 500;
             res.end(`Monaco worker build failed: ${e.message}`);
@@ -5444,16 +6562,16 @@ self.monaco = monaco;`,
         resolvedConfig.root,
         resolvedConfig.build.outDir,
         resolvedConfig.base
-      ) : isCDN(publicPath) ? import_node_path17.default.resolve(resolvedConfig.root, resolvedConfig.build.outDir, "monaco") : import_node_path17.default.resolve(
+      ) : isCDN(publicPath) ? import_node_path18.default.resolve(resolvedConfig.root, resolvedConfig.build.outDir, "monaco") : import_node_path18.default.resolve(
         resolvedConfig.root,
         resolvedConfig.build.outDir,
         publicPath.replace(/^\//, "")
       );
-      import_node_fs12.default.mkdirSync(outDir, { recursive: true });
+      import_node_fs13.default.mkdirSync(outDir, { recursive: true });
       for (const worker of workers) {
         try {
           const cacheFile = await buildWorker(worker);
-          import_node_fs12.default.copyFileSync(cacheFile, import_node_path17.default.join(outDir, `${worker.label}.worker.js`));
+          import_node_fs13.default.copyFileSync(cacheFile, import_node_path18.default.join(outDir, `${worker.label}.worker.js`));
         } catch (e) {
           throw new Error(
             `[nasti:monaco-editor] worker build failed for "${worker.label}": ${e.message}
@@ -5479,12 +6597,15 @@ init_env();
   buildElectron,
   buildEnvDefine,
   createDebugger,
+  createElectronRendererConfig,
   createLogger,
   createNoopHotChannel,
   createServer,
   createWsHotChannel,
   defineConfig,
+  detectFramework,
   electronPlugin,
+  electronRendererDevPath,
   loadEnv,
   monacoEditorPlugin,
   printServerUrls,