@nasti-toolchain/nasti 2.2.0 → 2.3.1

package/dist/cli.js

@@ -231,6 +231,92 @@ var init_defaults = __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
 import { pathToFileURL } from "url";
 import path from "path";
@@ -268,6 +354,43 @@ async function loadConfigFromFile(root) {
   }
   return {};
 }
+function detectFramework(root) {
+  const sourceRoot = path.resolve(root, "src");
+  if (containsVueFile(sourceRoot)) return "vue";
+  const packagePath = path.resolve(root, "package.json");
+  if (fs.existsSync(packagePath)) {
+    try {
+      const pkg = JSON.parse(fs.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 || !fs.existsSync(dir)) return false;
+  try {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+      if (entry.isFile() && entry.name.endsWith(".vue")) return true;
+      if (entry.isDirectory() && entry.name !== "node_modules" && entry.name !== "dist" && containsVueFile(path.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 = fs.readFileSync(filePath, "utf-8");
@@ -314,7 +437,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
@@ -361,7 +484,12 @@ async function resolveConfig(inlineConfig = {}, command) {
       if (envOptions.build) Object.assign(resolved.build, envOptions.build);
       resolved.environments.client = {
         consumer,
-        entry: [],
+        entry: normalizeEnvironmentEntries(envOptions.entry, root),
+        html: path.resolve(
+          root,
+          envOptions.html ?? (resolved.target === "electron" ? resolved.electron.renderer : "index.html")
+        ),
+        driver: envOptions.driver,
         // 同引用 —— 精确镜像（assertClientEnvironmentMirror 校验）
         resolve: resolved.resolve,
         build: resolved.build
@@ -370,7 +498,9 @@ async function resolveConfig(inlineConfig = {}, command) {
     }
     resolved.environments[name] = {
       consumer,
-      entry: (Array.isArray(envOptions.entry) ? envOptions.entry : envOptions.entry ? [envOptions.entry] : []).map((e) => path.resolve(root, e)),
+      entry: normalizeEnvironmentEntries(envOptions.entry, root),
+      html: envOptions.consumer === "client" && envOptions.html ? path.resolve(root, envOptions.html) : void 0,
+      driver: envOptions.driver,
       resolve: {
         alias: { ...resolved.resolve.alias, ...envOptions.resolve?.alias },
         extensions: envOptions.resolve?.extensions ?? [...resolved.resolve.extensions],
@@ -389,12 +519,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) {
@@ -410,6 +541,10 @@ async function resolveConfig(inlineConfig = {}, command) {
   }
   return resolved;
 }
+function normalizeEnvironmentEntries(entry, root) {
+  const entries = Array.isArray(entry) ? entry : entry ? [entry] : [];
+  return entries.map((item) => path.resolve(root, item));
+}
 function detectNativeDeps(root) {
   const result = /* @__PURE__ */ new Set();
   const pkgJsonPath = path.resolve(root, "package.json");
@@ -527,6 +662,7 @@ var init_config = __esm({
     "use strict";
     init_defaults();
     init_logger();
+    init_plugin_api();
     CONFIG_FILES = [
       "nasti.config.ts",
       "nasti.config.js",
@@ -537,21 +673,11 @@ var init_config = __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;
@@ -562,7 +688,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() {
@@ -901,6 +1027,7 @@ var init_environment = __esm({
     init_module_graph();
     init_hot_channel();
     init_debug();
+    init_plugin_api();
     debug = createDebugger("nasti:environment");
     NastiEnvironment = class {
       name;
@@ -909,6 +1036,7 @@ var init_environment = __esm({
       config;
       options;
       hot;
+      driver;
       /** applyToEnvironment 过滤后的插件（init() 后可用） */
       plugins = [];
       /** per-env 插件容器（init() 后可用；dev 管线使用） */
@@ -916,6 +1044,7 @@ var init_environment = __esm({
       /** per-env 模块图（dev 管线使用） */
       moduleGraph;
       candidatePlugins;
+      pluginApi;
       initialized = false;
       constructor(name, config, init = {}) {
         const options = config.environments[name];
@@ -932,6 +1061,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() {
@@ -942,10 +1072,41 @@ 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;
+          debug?.(`env "${this.name}" uses driver "${this.driver.name}"`);
+        }
         debug?.(`env "${this.name}" initialized (${this.plugins.length} plugins)`);
       }
+      getDriverContext() {
+        return {
+          environment: this,
+          config: this.config,
+          api: this.pluginApi,
+          logger: this.config.logger
+        };
+      }
       async close() {
-        await this.hot.close?.();
+        try {
+          await this.driver?.close?.(this.getDriverContext());
+        } finally {
+          await this.hot.close?.();
+        }
       }
     };
   }
@@ -1010,7 +1171,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");
@@ -1042,7 +1204,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",
@@ -1096,8 +1258,8 @@ function serializeTag(tag) {
   }
   return `  <${tag.tag}${attrs}>${children}</${tag.tag}>`;
 }
-async function readHtmlFile(root) {
-  const htmlPath = path2.resolve(root, "index.html");
+async function readHtmlFile(root, htmlFile = "index.html") {
+  const htmlPath = path2.isAbsolute(htmlFile) ? htmlFile : path2.resolve(root, htmlFile);
   if (!fs2.existsSync(htmlPath)) return null;
   return fs2.readFileSync(htmlPath, "utf-8");
 }
@@ -1296,7 +1458,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) {
@@ -3922,6 +4087,7 @@ var build_exports = {};
 __export(build_exports, {
   build: () => build,
   getRolldownOptions: () => getRolldownOptions,
+  replaceEntryScript: () => replaceEntryScript,
   resolveClientEntries: () => resolveClientEntries,
   toRolldownPlugins: () => toRolldownPlugins
 });
@@ -4005,13 +4171,20 @@ function toRolldownPlugins(plugins) {
   }));
 }
 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 ? path12.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(path12.resolve(config.root, src.replace(/^\//, "")));
+        const cleanSrc = src.split(/[?#]/, 1)[0];
+        entryPoints.push(
+          cleanSrc.startsWith("/") ? path12.resolve(config.root, cleanSrc.replace(/^\//, "")) : path12.resolve(htmlDir, cleanSrc)
+        );
       }
     }
   }
@@ -4047,21 +4220,55 @@ async function build(inlineConfig = {}) {
   const startTime = performance.now();
   logger.info(
     pc6.cyan(`
-nasti v${"2.2.0"} `) + pc6.green(`building for ${config.mode}...`)
+nasti v${"2.3.1"} `) + pc6.green(`building for ${config.mode}...`)
   );
   debug5?.(`root: ${config.root}`);
   const buildableNames = Object.keys(config.environments).filter(
-    (name) => name === "client" || config.environments[name].entry.length > 0
+    (name) => name === "client" || config.environments[name].entry.length > 0 || !!config.environments[name].driver
   );
   buildableNames.sort((a, b) => a === "client" ? -1 : b === "client" ? 1 : 0);
   const environments = {};
+  const environmentResults = {};
+  const initializedEnvironments = [];
   let clientOutput = [];
-  for (const name of buildableNames) {
-    const output = name === "client" ? await buildClientEnvironment(config) : await buildServerEnvironment(config, name);
-    environments[name] = output;
-    if (name === "client") clientOutput = output;
-    if (buildableNames.length > 1) {
-      debug5?.(`environment "${name}" built (${output.length} files)`);
+  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) {
+        debug5?.(`environment "${name}" built (${built.result.output.length} files)`);
+      }
+    }
+    const pluginApi = getPluginApi(config);
+    for (const plugin of config.plugins) {
+      await plugin.afterBuildApp?.(environmentResults, pluginApi);
+    }
+  } 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);
@@ -4074,83 +4281,130 @@ nasti v${"2.2.0"} `) + pc6.green(`building for ${config.mode}...`)
   const envSuffix = buildableNames.length > 1 ? ` (${buildableNames.join(" + ")})` : "";
   logger.info(pc6.green(`\u2713 built in ${elapsed}s`) + pc6.dim(envSuffix));
   logger.info(pc6.dim(`  ${fileCount} files, ${displaySize(totalSize)} total \u2192 ${config.build.outDir}/`));
-  return { output: clientOutput, environments };
+  return { output: clientOutput, environments, environmentResults };
 }
 async function buildClientEnvironment(config) {
   const logger = config.logger;
   const outDir = path12.resolve(config.root, config.build.outDir);
-  if (config.build.emptyOutDir && fs9.existsSync(outDir)) {
-    fs9.rmSync(outDir, { recursive: true, force: true });
-  }
-  fs9.mkdirSync(outDir, { recursive: true });
-  const html = await readHtmlFile(config.root);
-  const entryPoints = resolveClientEntries(config, html);
-  if (entryPoints.length === 0) {
-    throw new Error("No entry point found. Add a <script> tag to index.html or create src/main.ts");
-  }
   const cssEngine = createCssEngine();
   const pluginList = resolvePluginList(config, config.plugins, { cssEngine });
-  const clientEnv = new NastiEnvironment("client", { ...config, plugins: pluginList }, {
+  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 rolldown(inputOptions);
-  const { output } = await bundle2.write(outputOptions);
-  await bundle2.close();
-  if (html) {
-    let processedHtml = html;
-    const htmlPlugins = [...allPlugins.filter((p) => p.transformIndexHtml), htmlPlugin(config)];
-    for (const p of htmlPlugins) {
-      const result = await p.transformIndexHtml(processedHtml);
-      if (typeof result === "string") {
-        processedHtml = result;
-      } else if (result && "html" in result) {
-        processedHtml = processHtml(result.html, result.tags);
-      } else if (Array.isArray(result)) {
-        processedHtml = processHtml(processedHtml, result);
-      }
-    }
-    processedHtml = injectCssLinks(processedHtml, cssEngine, config);
-    for (const chunk of output) {
-      if (chunk.type === "chunk" && chunk.isEntry && chunk.facadeModuleId) {
-        const originalEntry = path12.relative(config.root, chunk.facadeModuleId);
-        processedHtml = processedHtml.replace(
-          new RegExp(`(src=["'])/?(${escapeRegExp(originalEntry)})(["'])`, "g"),
-          `$1${config.base}${chunk.fileName}$3`
+  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());
+      return { environment: clientEnv, result };
     }
-    fs9.writeFileSync(path12.resolve(outDir, "index.html"), processedHtml);
-  }
-  if (!nativeReporter && config.logLevel !== "silent") {
-    reportBuildOutput(output, config, logger);
+    if (config.build.emptyOutDir && fs9.existsSync(outDir)) {
+      fs9.rmSync(outDir, { recursive: true, force: true });
+    }
+    fs9.mkdirSync(outDir, { recursive: true });
+    const htmlFile = config.environments.client.html ?? path12.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),
+      ...nativeReporter ? [nativeReporter] : []
+    ];
+    const { inputOptions, outputOptions } = getRolldownOptions(
+      clientEnv,
+      entryPoints,
+      rolldownPlugins
+    );
+    const bundle2 = await rolldown(inputOptions);
+    const { output } = await bundle2.write(outputOptions);
+    await bundle2.close();
+    if (html) {
+      let processedHtml = html;
+      const htmlPlugins = [...allPlugins.filter((p) => p.transformIndexHtml), htmlPlugin(config)];
+      for (const p of htmlPlugins) {
+        const result = await p.transformIndexHtml(processedHtml);
+        if (typeof result === "string") {
+          processedHtml = result;
+        } else if (result && "html" in result) {
+          processedHtml = processHtml(result.html, result.tags);
+        } else if (Array.isArray(result)) {
+          processedHtml = processHtml(processedHtml, result);
+        }
+      }
+      processedHtml = injectCssLinks(processedHtml, cssEngine, config);
+      for (const chunk of output) {
+        if (chunk.type === "chunk" && chunk.isEntry && chunk.facadeModuleId) {
+          processedHtml = replaceEntryScript(
+            processedHtml,
+            chunk.facadeModuleId,
+            chunk.fileName,
+            config,
+            htmlFile,
+            config.base
+          );
+        }
+      }
+      fs9.writeFileSync(path12.resolve(outDir, "index.html"), processedHtml);
+    }
+    if (!nativeReporter && config.logLevel !== "silent") {
+      reportBuildOutput(output, config, logger);
+    }
+    warnLargeChunks(output, config, logger);
+    return { environment: clientEnv, result: { 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 });
+  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());
+      return { environment, result };
+    } catch (error) {
+      await environment.close();
+      throw error;
+    }
+  }
   for (const entry of envOptions.entry) {
     if (!fs9.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)
@@ -4170,7 +4424,7 @@ async function buildServerEnvironment(config, name) {
   logger.info(
     pc6.dim(`  [${name}] `) + output.map((o) => path12.join(envOptions.build.outDir, o.fileName)).join(pc6.dim(", "))
   );
-  return output;
+  return { environment, result: { output } };
 }
 function injectCssLinks(html, cssEngine, config) {
   const cssLinkTags = [];
@@ -4196,6 +4450,25 @@ function injectCssLinks(html, cssEngine, config) {
 function escapeRegExp(string) {
   return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+function replaceEntryScript(html, facadeModuleId, fileName, config, htmlFile, urlPrefix) {
+  const rootRelative = path12.relative(config.root, facadeModuleId).split(path12.sep).join("/");
+  const resolvedHtmlFile = path12.resolve(config.root, htmlFile);
+  const htmlRelative = path12.relative(path12.dirname(resolvedHtmlFile), facadeModuleId).split(path12.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 debug5, NODE_BUILTINS2;
 var init_build = __esm({
   "src/build/index.ts"() {
@@ -4209,6 +4482,7 @@ var init_build = __esm({
     init_env();
     init_reporter();
     init_debug();
+    init_plugin_api();
     debug5 = createDebugger("nasti:build");
     NODE_BUILTINS2 = /* @__PURE__ */ new Set([...builtinModules2, ...builtinModules2.map((m) => `node:${m}`)]);
   }
@@ -4240,7 +4514,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");
@@ -4446,7 +4720,7 @@ async function createBundledDevServer(opts) {
         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");
@@ -4530,10 +4804,13 @@ async function renderBundledIndexHtml(html, config, entryFileNames) {
     }
   }
   for (const [facadeModuleId, fileName] of entryFileNames) {
-    const originalEntry = path13.relative(config.root, facadeModuleId);
-    processed = processed.replace(
-      new RegExp(`(src=["'])/?(${originalEntry.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")})(["'])`, "g"),
-      `$1/${fileName}$3`
+    processed = replaceEntryScript(
+      processed,
+      facadeModuleId,
+      fileName,
+      config,
+      config.environments.client?.html ?? "index.html",
+      "/"
     );
   }
   return processed;
@@ -4677,10 +4954,12 @@ async function createServer(inlineConfig = {}) {
   const app = connect();
   const httpServer = http.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 };
@@ -4688,11 +4967,15 @@ async function createServer(inlineConfig = {}) {
     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 }, {
+    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;
@@ -4717,14 +5000,6 @@ async function createServer(inlineConfig = {}) {
     });
     app.use(bundledServer.middleware);
   }
-  app.use(transformMiddleware({
-    config: configWithPlugins,
-    pluginContainer,
-    moduleGraph
-  }));
-  const publicDir = path14.resolve(config.root, "public");
-  app.use(sirv(publicDir, { dev: true, etag: true }));
-  app.use(sirv(config.root, { dev: true, etag: true }));
   const ignoredSegments = /* @__PURE__ */ new Set(["node_modules", ".git", ".nasti"]);
   const outDirAbs = path14.resolve(config.root, config.build.outDir);
   const watcher = watch(config.root, {
@@ -4741,13 +5016,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,
@@ -4756,10 +5090,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 = () => {
@@ -4767,15 +5103,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(
             `
-  ${pc8.cyan(pc8.bold("NASTI"))} ${pc8.cyan(`v${"2.2.0"}`)}  ${pc8.dim("ready in")} ${pc8.bold(readyIn)} ${pc8.dim("ms")}
+  ${pc8.cyan(pc8.bold("NASTI"))} ${pc8.cyan(`v${"2.3.1"}`)}  ${pc8.dim("ready in")} ${pc8.bold(readyIn)} ${pc8.dim("ms")}
 `
           );
           printServerUrls(
-            { local: [localUrl], network: networkUrl ? [networkUrl] : [] },
+            {
+              local: [localUrl, ...driverLocalUrls],
+              network: [...networkUrl ? [networkUrl] : [], ...driverNetworkUrls]
+            },
             logger.info
           );
           logger.info("");
@@ -4805,11 +5146,62 @@ 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
+  }));
+  const publicDir = path14.resolve(config.root, "public");
+  app.use(sirv(publicDir, { dev: true, etag: true }));
+  app.use(sirv(config.root, { dev: true, etag: true }));
   const postMiddlewares = [];
   for (const plugin of allPlugins) {
     if (plugin.configureServer) {
@@ -4844,6 +5236,7 @@ var init_server = __esm({
     init_middleware();
     init_hmr();
     init_builtins();
+    init_plugin_api();
   }
 });
 
@@ -4890,6 +5283,7 @@ var init_electron = __esm({
 var electron_exports = {};
 __export(electron_exports, {
   buildElectron: () => buildElectron,
+  createElectronRendererConfig: () => createElectronRendererConfig,
   detectInstalledElectron: () => detectInstalledElectron,
   normalizePreload: () => normalizePreload
 });
@@ -4901,7 +5295,7 @@ async function buildElectron(inlineConfig = {}) {
   const config = await resolveConfig({ ...inlineConfig, target: "electron" }, "build");
   const startTime = performance.now();
   assertElectronVersion(config);
-  console.log(pc9.cyan("\n\u26A1 nasti build (electron)") + pc9.dim(` v${"2.2.0"}`));
+  console.log(pc9.cyan("\n\u26A1 nasti build (electron)") + pc9.dim(` v${"2.3.1"}`));
   console.log(pc9.dim(`  root: ${config.root}`));
   console.log(pc9.dim(`  mode: ${config.mode}`));
   console.log(pc9.dim(`  target: electron (\u2265 ${config.electron.minVersion})`));
@@ -4912,15 +5306,13 @@ async function buildElectron(inlineConfig = {}) {
   fs10.mkdirSync(outDir, { recursive: true });
   const rendererOutDir = path15.join(outDir, "renderer");
   const { build: build2 } = await Promise.resolve().then(() => (init_build(), build_exports));
-  await build2({
-    ...inlineConfig,
-    target: "web",
+  await build2(createElectronRendererConfig(config, inlineConfig, {
     build: {
       ...inlineConfig.build,
       outDir: rendererOutDir,
       emptyOutDir: false
     }
-  });
+  }));
   const mainEntry = path15.resolve(config.root, config.electron.main);
   if (!fs10.existsSync(mainEntry)) {
     throw new Error(
@@ -4974,7 +5366,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 };
     }
@@ -4985,7 +5378,11 @@ 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)]
   });
   fs10.mkdirSync(path15.dirname(opts.outFile), { recursive: true });
@@ -5002,6 +5399,25 @@ async function bundleNode(config, entry, opts) {
   console.log(pc9.dim(`  \u2713 ${opts.label} \u2192 ${path15.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 path15.join(outDir, base + ext);
@@ -5046,6 +5462,7 @@ var init_electron2 = __esm({
 // src/server/electron-dev.ts
 var electron_dev_exports = {};
 __export(electron_dev_exports, {
+  electronRendererDevPath: () => electronRendererDevPath,
   startElectronDev: () => startElectronDev
 });
 import path16 from "path";
@@ -5059,11 +5476,15 @@ async function startElectronDev(inlineConfig = {}) {
   const { noSpawn, ...rest } = inlineConfig;
   const config = await resolveConfig({ ...rest, target: "electron" }, "serve");
   warnElectronVersion(config);
-  console.log(pc10.cyan("\n\u26A1 nasti electron dev") + pc10.dim(` v${"2.2.0"}`));
+  console.log(pc10.cyan("\n\u26A1 nasti electron dev") + pc10.dim(` v${"2.3.1"}`));
   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(pc10.dim(`  renderer: ${devUrl}`));
   const stageDir = path16.resolve(config.root, ".nasti");
   fs11.mkdirSync(stageDir, { recursive: true });
@@ -5185,14 +5606,18 @@ 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 rolldown3({
     input: entry,
-    transform: { define: envDefine },
+    transform: {
+      target: config.electron.nodeTarget,
+      define: envDefine
+    },
     platform: "node",
     plugins: [oxcTransformPlugin, electronPlugin(config), resolvePlugin(config)]
   });
@@ -5208,6 +5633,10 @@ async function compileNode(config, entry, opts) {
   });
   await bundle2.close();
 }
+function electronRendererDevPath(renderer) {
+  const normalized = renderer.split(path16.sep).join("/").replace(/^\.?\//, "");
+  return normalized === "index.html" ? "/" : `/${normalized}`;
+}
 function resolveElectronBinary(config) {
   if (config.electron.electronPath && fs11.existsSync(config.electron.electronPath)) {
     return config.electron.electronPath;
@@ -5404,7 +5833,7 @@ cli.command("preview [root]", "Preview production build").option("--port <port>"
     const host = options.host === true ? "0.0.0.0" : options.host ?? "localhost";
     http2.createServer(app).listen(port, host, () => {
       logger.info(`
-  ${pc11.cyan(pc11.bold("NASTI"))} ${pc11.cyan(`v${"2.2.0"}`)}  ${pc11.dim("preview")}
+  ${pc11.cyan(pc11.bold("NASTI"))} ${pc11.cyan(`v${"2.3.1"}`)}  ${pc11.dim("preview")}
 `);
       printServerUrls2(
         {
@@ -5421,6 +5850,6 @@ cli.command("preview [root]", "Preview production build").option("--port <port>"
   }
 });
 cli.help();
-cli.version("2.2.0");
+cli.version("2.3.1");
 cli.parse();
 //# sourceMappingURL=cli.js.map