@nasti-toolchain/nasti 1.4.1 → 1.5.1

package/dist/index.js

@@ -164,6 +164,14 @@ async function resolveConfig(inlineConfig = {}, command) {
     return p.apply === command;
   });
   resolved.plugins = filteredPlugins;
+  if (resolved.target === "electron") {
+    const autoExternal = detectNativeDeps(root);
+    if (autoExternal.length > 0) {
+      const current = new Set(resolved.electron.external ?? []);
+      for (const dep of autoExternal) current.add(dep);
+      resolved.electron.external = [...current];
+    }
+  }
   for (const plugin of resolved.plugins) {
     if (plugin.configResolved) {
       await plugin.configResolved(resolved);
@@ -171,6 +179,73 @@ async function resolveConfig(inlineConfig = {}, command) {
   }
   return resolved;
 }
+function detectNativeDeps(root) {
+  const result = /* @__PURE__ */ new Set();
+  const pkgJsonPath = path.resolve(root, "package.json");
+  if (!fs.existsSync(pkgJsonPath)) return [];
+  let pkg;
+  try {
+    pkg = JSON.parse(fs.readFileSync(pkgJsonPath, "utf-8"));
+  } catch {
+    return [];
+  }
+  const deps = {
+    ...pkg.dependencies ?? {},
+    ...pkg.optionalDependencies ?? {}
+  };
+  const KNOWN_NATIVE = /* @__PURE__ */ new Set([
+    "node-pty",
+    "better-sqlite3",
+    "sharp",
+    "serialport",
+    "@vscode/tree-sitter-wasm",
+    "keytar",
+    "nodegit",
+    "sqlite3",
+    "fsevents"
+  ]);
+  for (const dep of Object.keys(deps)) {
+    if (KNOWN_NATIVE.has(dep)) {
+      result.add(dep);
+      continue;
+    }
+    const depDir = path.resolve(root, "node_modules", dep);
+    if (!fs.existsSync(depDir)) continue;
+    if (fs.existsSync(path.join(depDir, "binding.gyp"))) {
+      result.add(dep);
+      continue;
+    }
+    const subPkg = path.join(depDir, "package.json");
+    if (fs.existsSync(subPkg)) {
+      try {
+        const sub = JSON.parse(fs.readFileSync(subPkg, "utf-8"));
+        if (sub.gypfile === true || sub.binary?.module_name) {
+          result.add(dep);
+          continue;
+        }
+      } catch {
+      }
+    }
+    if (hasDotNodeFile(depDir)) {
+      result.add(dep);
+    }
+  }
+  return [...result];
+}
+function hasDotNodeFile(dir, depth = 0) {
+  if (depth > 3) return false;
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const e of entries) {
+      if (e.isFile() && e.name.endsWith(".node")) return true;
+      if (e.isDirectory() && (e.name === "build" || e.name === "prebuilds" || e.name === "Release")) {
+        if (hasDotNodeFile(path.join(dir, e.name), depth + 1)) return true;
+      }
+    }
+  } catch {
+  }
+  return false;
+}
 function deepMerge(target, source) {
   const result = { ...target };
   for (const key of Object.keys(source)) {
@@ -415,6 +490,15 @@ function htmlPlugin(config) {
     transformIndexHtml(html) {
       const tags = [];
       if (config.command === "serve") {
+        const isReactLike = config.framework === "react" || config.framework === "auto";
+        if (isReactLike) {
+          tags.push({
+            tag: "script",
+            attrs: { type: "module" },
+            children: REACT_REFRESH_HTML_PREAMBLE,
+            injectTo: "head-prepend"
+          });
+        }
         tags.push({
           tag: "script",
           attrs: { type: "module", src: "/@nasti/client" },
@@ -465,9 +549,17 @@ async function readHtmlFile(root) {
   if (!fs4.existsSync(htmlPath)) return null;
   return fs4.readFileSync(htmlPath, "utf-8");
 }
+var REACT_REFRESH_HTML_PREAMBLE;
 var init_html = __esm({
   "src/plugins/html.ts"() {
     "use strict";
+    REACT_REFRESH_HTML_PREAMBLE = `
+import RefreshRuntime from "/@react-refresh";
+RefreshRuntime.injectIntoGlobalHook(window);
+window.$RefreshReg$ = () => {};
+window.$RefreshSig$ = () => (type) => type;
+window.__vite_plugin_react_preamble_installed__ = true;
+`.trim();
   }
 });
 
@@ -701,7 +793,7 @@ import pc from "picocolors";
 async function build(inlineConfig = {}) {
   const config = await resolveConfig(inlineConfig, "build");
   const startTime = performance.now();
-  console.log(pc.cyan("\n\u{1F528} nasti build") + pc.dim(` v${"1.4.1"}`));
+  console.log(pc.cyan("\n\u{1F528} nasti build") + pc.dim(` v${"1.5.1"}`));
   console.log(pc.dim(`  root: ${config.root}`));
   console.log(pc.dim(`  mode: ${config.mode}`));
   const outDir = path7.resolve(config.root, config.build.outDir);
@@ -1005,11 +1097,85 @@ var init_ws = __esm({
 // src/server/middleware.ts
 var middleware_exports = {};
 __export(middleware_exports, {
+  REACT_REFRESH_GLOBAL_PREAMBLE: () => REACT_REFRESH_GLOBAL_PREAMBLE,
   transformMiddleware: () => transformMiddleware,
   transformRequest: () => transformRequest
 });
 import path9 from "path";
 import fs8 from "fs";
+import { createRequire as createRequire2 } from "module";
+import { fileURLToPath } from "url";
+function getReactRefreshRuntimeEsm() {
+  if (__refreshRuntimeCache) return __refreshRuntimeCache;
+  let cjsPath;
+  try {
+    cjsPath = __require.resolve("react-refresh/cjs/react-refresh-runtime.development.js");
+  } catch {
+    cjsPath = path9.resolve(__dirname_esm, "../../node_modules/react-refresh/cjs/react-refresh-runtime.development.js");
+  }
+  const cjsSource = fs8.readFileSync(cjsPath, "utf-8");
+  __refreshRuntimeCache = `// Wrapped react-refresh runtime -> ESM
+const exports = {};
+const module = { exports };
+const process = { env: { NODE_ENV: 'development' } };
+${cjsSource}
+const __rt = module.exports;
+export const injectIntoGlobalHook = __rt.injectIntoGlobalHook;
+export const register = __rt.register;
+export const createSignatureFunctionForTransform = __rt.createSignatureFunctionForTransform;
+export const performReactRefresh = __rt.performReactRefresh;
+export const isLikelyComponentType = __rt.isLikelyComponentType;
+export const hasUnrecoverableErrors = __rt.hasUnrecoverableErrors;
+export const setSignature = __rt.setSignature;
+export const getFamilyByID = __rt.getFamilyByID;
+export const getFamilyByType = __rt.getFamilyByType;
+export const findAffectedHostInstances = __rt.findAffectedHostInstances;
+export const collectCustomHooksForSignature = __rt.collectCustomHooksForSignature;
+export default __rt;
+`;
+  return __refreshRuntimeCache;
+}
+function buildReactRefreshWrapper(moduleUrl, transformedCode) {
+  const urlLit = JSON.stringify(moduleUrl);
+  const userCode = transformedCode.replace(/\bimport\.meta\.hot\b/g, "__nasti_hot__");
+  return `import * as RefreshRuntime from "/@react-refresh";
+import { createHotContext as __nasti_createHotContext__ } from "/@nasti/client";
+const __nasti_hot__ = __nasti_createHotContext__(${urlLit});
+
+if (!window.__vite_plugin_react_preamble_installed__) {
+  throw new Error("[nasti] React Fast Refresh preamble missing. Make sure nasti:html is wired with framework: 'react'.");
+}
+
+const prevRefreshReg = window.$RefreshReg$;
+const prevRefreshSig = window.$RefreshSig$;
+window.$RefreshReg$ = (type, id) => {
+  RefreshRuntime.register(type, ${urlLit} + " " + id);
+};
+window.$RefreshSig$ = RefreshRuntime.createSignatureFunctionForTransform;
+
+${userCode}
+
+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);
+  });
+}
+`;
+}
+function injectImportMetaHot(code, moduleUrl) {
+  if (!/\bimport\.meta\.hot\b/.test(code)) return code;
+  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__");
+}
 function transformMiddleware(ctx) {
   ctx.envDefine = buildEnvDefine(
     loadEnv(ctx.config.mode, ctx.config.root, ctx.config.envPrefix),
@@ -1083,7 +1249,7 @@ async function transformRequest(url, ctx) {
     return cached.transformResult;
   }
   if (cleanReqUrl === "/@react-refresh") {
-    return { code: REACT_REFRESH_RUNTIME };
+    return { code: getReactRefreshRuntimeEsm() };
   }
   const filePath = resolveUrlToFile(url, config.root);
   if (!filePath || !fs8.existsSync(filePath)) return null;
@@ -1100,6 +1266,8 @@ async function transformRequest(url, ctx) {
   if (pluginResult) {
     code = typeof pluginResult === "string" ? pluginResult : pluginResult.code;
   }
+  const stableUrl = cleanReqUrl;
+  let wrappedWithRefresh = false;
   if (shouldTransform(filePath)) {
     const isJsx = /\.[jt]sx$/.test(filePath);
     const useRefresh = isJsx && config.framework !== "vue";
@@ -1111,9 +1279,14 @@ async function transformRequest(url, ctx) {
     });
     code = result.code;
     if (useRefresh) {
-      code = REACT_REFRESH_PREAMBLE + code + REACT_REFRESH_FOOTER;
+      code = buildReactRefreshWrapper(stableUrl, code);
+      wrappedWithRefresh = true;
+      mod.isSelfAccepting = true;
     }
   }
+  if (!wrappedWithRefresh) {
+    code = injectImportMetaHot(code, stableUrl);
+  }
   const envDefine = ctx.envDefine ?? buildEnvDefine(
     loadEnv(config.mode, config.root, config.envPrefix),
     config.mode
@@ -1181,8 +1354,8 @@ function rewriteExternalRequires(code) {
 }
 async function injectCjsNamedExports(code, entryFile) {
   try {
-    const { createRequire: createRequire3 } = await import("module");
-    const req = createRequire3(entryFile);
+    const { createRequire: createRequire5 } = await import("module");
+    const req = createRequire5(entryFile);
     const cjsExports = req(entryFile);
     if (!cjsExports || typeof cjsExports !== "object" && typeof cjsExports !== "function" || Array.isArray(cjsExports)) return code;
     const namedKeys = Object.keys(cjsExports).filter(
@@ -1345,12 +1518,15 @@ function getHmrClientCode() {
 // Nasti HMR Client
 const socket = new WebSocket(\`ws://\${location.host}\`, 'nasti-hmr');
 const hotModulesMap = new Map();
+const disposeMap = new Map();
+const pruneMap = new Map();
 
 socket.addEventListener('message', ({ data }) => {
   const payload = JSON.parse(data);
   switch (payload.type) {
     case 'connected':
       console.log('[nasti] connected.');
+      clearErrorOverlay();
       break;
     case 'update':
       payload.updates.forEach((update) => {
@@ -1360,11 +1536,18 @@ socket.addEventListener('message', ({ data }) => {
           updateCss(update.path);
         }
       });
+      clearErrorOverlay();
       break;
     case 'full-reload':
       console.log('[nasti] full reload');
       location.reload();
       break;
+    case 'prune':
+      payload.paths.forEach((p) => {
+        const cb = pruneMap.get(p);
+        if (cb) cb();
+      });
+      break;
     case 'error':
       console.error('[nasti] error:', payload.err.message);
       showErrorOverlay(payload.err);
@@ -1372,14 +1555,23 @@ socket.addEventListener('message', ({ data }) => {
   }
 });
 
+// \u81EA\u52A8\u91CD\u8FDE\uFF08\u65AD\u7EBF\u65F6\u6307\u6570\u9000\u907F\uFF09
+let reconnectTimer = 0;
+socket.addEventListener('close', () => {
+  clearTimeout(reconnectTimer);
+  reconnectTimer = setTimeout(() => location.reload(), 1000);
+});
+
 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();
+
+  const newMod = await import(update.acceptedPath + '?t=' + update.timestamp);
   if (mod) {
-    const newMod = await import(update.acceptedPath + '?t=' + update.timestamp);
-    mod.callbacks.forEach((cb) => cb(newMod));
-  } else {
-    // \u6CA1\u6709\u6CE8\u518C hot \u56DE\u8C03\uFF0C\u5C1D\u8BD5\u91CD\u65B0 import
-    await import(update.path + '?t=' + update.timestamp);
+    // \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));
   }
 }
 
@@ -1392,7 +1584,13 @@ function updateCss(path) {
   }
 }
 
+function clearErrorOverlay() {
+  const el = document.getElementById('nasti-error-overlay');
+  if (el) el.remove();
+}
+
 function showErrorOverlay(err) {
+  clearErrorOverlay();
   const overlay = document.createElement('div');
   overlay.id = 'nasti-error-overlay';
   overlay.style.cssText = 'position:fixed;inset:0;z-index:99999;background:rgba(0,0,0,0.85);color:#fff;font-family:monospace;padding:2rem;overflow:auto;';
@@ -1411,59 +1609,55 @@ function showErrorOverlay(err) {
   document.body.appendChild(overlay);
 }
 
-// import.meta.hot API
-const createHotContext = (ownerPath) => ({
-  accept(deps, callback) {
-    if (typeof deps === 'function' || !deps) {
-      // self-accepting
-      const callbacks = hotModulesMap.get(ownerPath)?.callbacks || [];
-      callbacks.push(deps || (() => {}));
-      hotModulesMap.set(ownerPath, { callbacks });
-    }
-  },
-  prune(callback) {
-    // \u6A21\u5757\u88AB\u79FB\u9664\u65F6\u6267\u884C
-  },
-  dispose(callback) {
-    // \u6A21\u5757\u66F4\u65B0\u524D\u6267\u884C\u6E05\u7406
-  },
-  invalidate() {
-    location.reload();
-  },
-  data: {},
-});
-
-// \u66B4\u9732\u7ED9\u6A21\u5757\u4F7F\u7528
-if (!window.__nasti_hot_map) window.__nasti_hot_map = new Map();
-window.__NASTI_HMR__ = { createHotContext };
+/**
+ * \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) {
+  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;
+      }
+      // \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);
+    },
+    dispose(callback) {
+      disposeMap.set(ownerPath, callback);
+    },
+    invalidate() {
+      location.reload();
+    },
+    data: {},
+  };
+}
 `;
 }
-var REACT_REFRESH_RUNTIME, REACT_REFRESH_PREAMBLE, REACT_REFRESH_FOOTER, esmBundleCache, VALID_IDENT, RESOLVE_EXTENSIONS, ESM_CONDITIONS;
+var __dirname_esm, __require, __refreshRuntimeCache, REACT_REFRESH_GLOBAL_PREAMBLE, esmBundleCache, VALID_IDENT, RESOLVE_EXTENSIONS, ESM_CONDITIONS;
 var init_middleware = __esm({
   "src/server/middleware.ts"() {
     "use strict";
     init_transformer();
     init_html();
     init_env();
-    REACT_REFRESH_RUNTIME = `
-export function createSignatureFunctionForTransform() {
-  return function(type, key, forceReset, getCustomHooks) { return type; };
-}
-export function register(type, id) {}
-export default { createSignatureFunctionForTransform, register };
-`;
-    REACT_REFRESH_PREAMBLE = `
-import RefreshRuntime from '/@react-refresh';
-if (!window.$RefreshReg$) {
-  window.$RefreshReg$ = (type, id) => RefreshRuntime.register(type, import.meta.url + ' ' + id);
-  window.$RefreshSig$ = RefreshRuntime.createSignatureFunctionForTransform;
-}
-`;
-    REACT_REFRESH_FOOTER = `
-if (import.meta.hot) {
-  import.meta.hot.accept();
-}
-`;
+    __dirname_esm = path9.dirname(fileURLToPath(import.meta.url));
+    __require = createRequire2(import.meta.url);
+    __refreshRuntimeCache = null;
+    REACT_REFRESH_GLOBAL_PREAMBLE = `
+import RefreshRuntime from "/@react-refresh";
+RefreshRuntime.injectIntoGlobalHook(window);
+window.$RefreshReg$ = () => {};
+window.$RefreshSig$ = () => (type) => type;
+window.__vite_plugin_react_preamble_installed__ = true;
+`.trim();
     esmBundleCache = /* @__PURE__ */ new Map();
     VALID_IDENT = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
     RESOLVE_EXTENSIONS = [".tsx", ".ts", ".jsx", ".js", ".mjs", ".json", ".vue"];
@@ -1577,15 +1771,6 @@ async function createServer(inlineConfig = {}) {
   watcher.on("add", (file) => {
     handleFileChange(file, server);
   });
-  const postMiddlewares = [];
-  for (const plugin of allPlugins) {
-    if (plugin.configureServer) {
-      const result = await plugin.configureServer(server);
-      if (typeof result === "function") {
-        postMiddlewares.push(result);
-      }
-    }
-  }
   server = {
     config: configWithPlugins,
     middlewares: app,
@@ -1604,7 +1789,7 @@ async function createServer(inlineConfig = {}) {
           const localUrl = `http://localhost:${actualPort}`;
           const networkUrl = host === "0.0.0.0" ? `http://${getNetworkAddress()}:${actualPort}` : null;
           console.log();
-          console.log(pc3.cyan("  nasti dev server") + pc3.dim(` v${"1.4.1"}`));
+          console.log(pc3.cyan("  nasti dev server") + pc3.dim(` v${"1.5.1"}`));
           console.log();
           console.log(`  ${pc3.green(">")} Local:   ${pc3.cyan(localUrl)}`);
           if (networkUrl) {
@@ -1637,6 +1822,16 @@ async function createServer(inlineConfig = {}) {
       httpServer.close();
     }
   };
+  const postMiddlewares = [];
+  for (const plugin of allPlugins) {
+    if (plugin.configureServer) {
+      const result = await plugin.configureServer(server);
+      if (typeof result === "function") {
+        postMiddlewares.push(result);
+      }
+    }
+  }
+  for (const run of postMiddlewares) run();
   return server;
 }
 function getNetworkAddress() {
@@ -1718,7 +1913,7 @@ async function buildElectron(inlineConfig = {}) {
   const config = await resolveConfig({ ...inlineConfig, target: "electron" }, "build");
   const startTime = performance.now();
   assertElectronVersion(config);
-  console.log(pc2.cyan("\n\u26A1 nasti build (electron)") + pc2.dim(` v${"1.4.1"}`));
+  console.log(pc2.cyan("\n\u26A1 nasti build (electron)") + pc2.dim(` v${"1.5.1"}`));
   console.log(pc2.dim(`  root: ${config.root}`));
   console.log(pc2.dim(`  mode: ${config.mode}`));
   console.log(pc2.dim(`  target: electron (\u2265 ${config.electron.minVersion})`));
@@ -1853,7 +2048,7 @@ init_server();
 init_config();
 import path12 from "path";
 import fs10 from "fs";
-import { createRequire as createRequire2 } from "module";
+import { createRequire as createRequire3 } from "module";
 import { spawn } from "child_process";
 import chokidar from "chokidar";
 import pc4 from "picocolors";
@@ -1865,7 +2060,7 @@ async function startElectronDev(inlineConfig = {}) {
   const { noSpawn, ...rest } = inlineConfig;
   const config = await resolveConfig({ ...rest, target: "electron" }, "serve");
   warnElectronVersion(config);
-  console.log(pc4.cyan("\n\u26A1 nasti electron dev") + pc4.dim(` v${"1.4.1"}`));
+  console.log(pc4.cyan("\n\u26A1 nasti electron dev") + pc4.dim(` v${"1.5.1"}`));
   const { createServer: createServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
   const server = await createServer2({ ...rest, target: "electron" });
   await server.listen();
@@ -1929,11 +2124,16 @@ async function startElectronDev(inlineConfig = {}) {
     const watchTargets = [mainEntry, ...preloadEntries].filter(fs10.existsSync);
     const watcher = chokidar.watch(watchTargets, { ignoreInitial: true });
     let restarting = null;
-    watcher.on("all", async () => {
-      if (restarting) return;
+    let pending = false;
+    const restart = async () => {
+      if (restarting) {
+        pending = true;
+        return;
+      }
       restarting = (async () => {
-        console.log(pc4.cyan("\n  \u267B \u4E3B/preload \u53D8\u66F4\uFF0C\u91CD\u542F Electron..."));
-        try {
+        do {
+          pending = false;
+          console.log(pc4.cyan("\n  \u267B \u4E3B/preload \u53D8\u66F4\uFF0C\u91CD\u542F Electron..."));
           if (child && !child.killed) {
             ;
             child.__nastiKilled = true;
@@ -1947,12 +2147,24 @@ async function startElectronDev(inlineConfig = {}) {
               dying.kill();
             });
           }
-          await compileAll();
-          spawnElectron();
-        } finally {
-          restarting = null;
-        }
+          try {
+            await compileAll();
+            spawnElectron();
+          } catch (e) {
+            console.warn(pc4.yellow(`  \u26A0 \u91CD\u542F\u7F16\u8BD1\u5931\u8D25\uFF0C\u4FDD\u7559\u4E0A\u4E00\u6B21\u8FDB\u7A0B: ${e.message}`));
+          }
+        } while (pending);
+        restarting = null;
       })();
+      return restarting;
+    };
+    let debounceTimer = null;
+    watcher.on("all", () => {
+      if (debounceTimer) clearTimeout(debounceTimer);
+      debounceTimer = setTimeout(() => {
+        debounceTimer = null;
+        void restart();
+      }, 80);
     });
   }
 }
@@ -2000,7 +2212,7 @@ function resolveElectronBinary(config) {
     return config.electron.electronPath;
   }
   try {
-    const require2 = createRequire2(path12.resolve(config.root, "package.json"));
+    const require2 = createRequire3(path12.resolve(config.root, "package.json"));
     const pathFile = require2.resolve("electron");
     const electronModule = require2(pathFile);
     if (typeof electronModule === "string" && fs10.existsSync(electronModule)) {
@@ -2028,12 +2240,222 @@ function warnElectronVersion(config) {
     );
   }
 }
+
+// src/plugins/monaco-editor.ts
+import path13 from "path";
+import fs11 from "fs";
+import crypto2 from "crypto";
+import { createRequire as createRequire4 } from "module";
+var DEFAULT_WORKERS = {
+  editorWorkerService: "monaco-editor/esm/vs/editor/editor.worker",
+  css: "monaco-editor/esm/vs/language/css/css.worker",
+  html: "monaco-editor/esm/vs/language/html/html.worker",
+  json: "monaco-editor/esm/vs/language/json/json.worker",
+  typescript: "monaco-editor/esm/vs/language/typescript/ts.worker"
+};
+var DEFAULT_PUBLIC_PATH = "monacoeditorwork";
+function isCDN(p) {
+  return /^((https?:)?\/\/|file:)/.test(p);
+}
+function normalizePublicPath(p) {
+  if (isCDN(p)) return p.replace(/\/+$/, "");
+  const withLead = p.startsWith("/") ? p : "/" + p;
+  return withLead.replace(/\/+$/, "") || "/";
+}
+function readMonacoVersion(root) {
+  try {
+    const require2 = createRequire4(path13.resolve(root, "package.json"));
+    const pkgJsonPath = require2.resolve("monaco-editor/package.json", { paths: [root] });
+    const pkg = JSON.parse(fs11.readFileSync(pkgJsonPath, "utf-8"));
+    return typeof pkg.version === "string" ? pkg.version : "unknown";
+  } catch {
+    return "unknown";
+  }
+}
+function monacoEditorPlugin(options = {}) {
+  const languageWorkers = options.languageWorkers ?? Object.keys(DEFAULT_WORKERS);
+  const customWorkers = options.customWorkers ?? [];
+  const publicPath = normalizePublicPath(options.publicPath ?? DEFAULT_PUBLIC_PATH);
+  const globalAPI = !!options.globalAPI;
+  const forceBuildCDN = !!options.forceBuildCDN;
+  const workers = [
+    ...languageWorkers.map((label) => ({ label, entry: DEFAULT_WORKERS[label] })),
+    ...customWorkers
+  ];
+  let resolvedConfig;
+  let cacheDir = "";
+  const building = /* @__PURE__ */ new Map();
+  async function buildWorker(worker) {
+    const cacheFile = path13.join(cacheDir, `${worker.label}.worker.js`);
+    if (fs11.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 = createRequire4(path13.resolve(resolvedConfig.root, "package.json"));
+      let entry;
+      try {
+        entry = require2.resolve(worker.entry, { paths: [resolvedConfig.root] });
+      } catch {
+        entry = require2.resolve(worker.entry + ".js", { paths: [resolvedConfig.root] });
+      }
+      fs11.mkdirSync(cacheDir, { recursive: true });
+      const bundle = await rolldown4({
+        input: entry,
+        platform: "browser"
+      });
+      await bundle.write({
+        file: cacheFile,
+        format: "iife",
+        sourcemap: false,
+        minify: true,
+        inlineDynamicImports: true
+      });
+      await bundle.close();
+      return cacheFile;
+    })();
+    building.set(worker.label, task);
+    try {
+      return await task;
+    } finally {
+      building.delete(worker.label);
+    }
+  }
+  function runtimeInitScript() {
+    let normalizedPrefix = publicPath;
+    if (!isCDN(publicPath)) {
+      const base = resolvedConfig.base.replace(/\/+$/, "") || "";
+      const pub = publicPath.replace(/^\/+/, "");
+      normalizedPrefix = base ? `${base}/${pub}` : `/${pub}`;
+    }
+    const map = {};
+    for (const w of workers) {
+      map[w.label] = `${normalizedPrefix}/${w.label}.worker.js`;
+    }
+    return `;(function () {
+  var map = ${JSON.stringify(map)};
+  function getWorkerUrl(_moduleId, label) {
+    var url = map[label] || map['editorWorkerService'];
+    if (/^(https?:)?\\/\\//.test(url)) {
+      // \u8DE8\u57DF Worker \u9700\u7528 Blob + importScripts \u7ED5\u8FC7\u540C\u6E90\u9650\u5236
+      var blob = new Blob(
+        ['importScripts(' + JSON.stringify(url) + ');'],
+        { type: 'application/javascript' }
+      );
+      return URL.createObjectURL(blob);
+    }
+    return url;
+  }
+  self.MonacoEnvironment = self.MonacoEnvironment || {};
+  if (!self.MonacoEnvironment.getWorker && !self.MonacoEnvironment.getWorkerUrl) {
+    self.MonacoEnvironment.getWorkerUrl = getWorkerUrl;
+  }
+})();`;
+  }
+  return {
+    name: "nasti:monaco-editor",
+    enforce: "pre",
+    configResolved(config) {
+      resolvedConfig = config;
+      const version = readMonacoVersion(config.root);
+      const key = crypto2.createHash("sha1").update(version + "|" + publicPath).digest("hex").slice(0, 8);
+      cacheDir = path13.resolve(config.root, "node_modules/.nasti/monaco", key);
+    },
+    async configureServer(server) {
+      const shouldBuild = !isCDN(publicPath) || forceBuildCDN;
+      const watcher = server.watcher;
+      const monacoDir = path13.resolve(resolvedConfig.root, "node_modules/monaco-editor");
+      try {
+        watcher?.unwatch?.(monacoDir);
+      } catch {
+      }
+      if (!shouldBuild) return;
+      void Promise.all(
+        workers.map(
+          (w) => buildWorker(w).catch((e) => {
+            console.warn(
+              `[nasti:monaco-editor] worker build failed for "${w.label}": ${e.message}`
+            );
+          })
+        )
+      );
+      const base = resolvedConfig.base.replace(/\/+$/, "") || "";
+      const pub = publicPath.replace(/^\/+/, "");
+      const prefix = (base ? `${base}/${pub}` : `/${pub}`) + "/";
+      server.middlewares.use(
+        async (req, res, next) => {
+          if (req.method !== "GET") return next();
+          const url = (req.url ?? "").split("?")[0];
+          if (!url.startsWith(prefix)) return next();
+          const name = url.slice(prefix.length).replace(/\.worker\.js$/, "");
+          const worker = workers.find((w) => w.label === name);
+          if (!worker) return next();
+          try {
+            const file = await buildWorker(worker);
+            res.setHeader("Content-Type", "application/javascript; charset=utf-8");
+            res.setHeader("Cache-Control", "public, max-age=604800, immutable");
+            fs11.createReadStream(file).pipe(res);
+          } catch (e) {
+            res.statusCode = 500;
+            res.end(`Monaco worker build failed: ${e.message}`);
+          }
+        }
+      );
+    },
+    transformIndexHtml(html) {
+      const tags = [
+        {
+          tag: "script",
+          children: runtimeInitScript(),
+          injectTo: "head-prepend"
+        }
+      ];
+      if (globalAPI) {
+        tags.push({
+          tag: "script",
+          attrs: { type: "module" },
+          children: `import * as monaco from 'monaco-editor';
+self.monaco = monaco;`,
+          injectTo: "head"
+        });
+      }
+      return { html, tags };
+    },
+    // 生产构建：把所有 Worker 预打包并拷到 outDir/<publicPath>/ 下
+    async buildStart() {
+      if (resolvedConfig.command !== "build") return;
+      if (isCDN(publicPath) && !forceBuildCDN) return;
+      const outDir = options.customDistPath ? options.customDistPath(
+        resolvedConfig.root,
+        resolvedConfig.build.outDir,
+        resolvedConfig.base
+      ) : isCDN(publicPath) ? path13.resolve(resolvedConfig.root, resolvedConfig.build.outDir, "monaco") : path13.resolve(
+        resolvedConfig.root,
+        resolvedConfig.build.outDir,
+        publicPath.replace(/^\//, "")
+      );
+      fs11.mkdirSync(outDir, { recursive: true });
+      for (const worker of workers) {
+        try {
+          const cacheFile = await buildWorker(worker);
+          fs11.copyFileSync(cacheFile, path13.join(outDir, `${worker.label}.worker.js`));
+        } catch (e) {
+          throw new Error(
+            `[nasti:monaco-editor] worker build failed for "${worker.label}": ${e.message}
+${e.stack || ""}`
+          );
+        }
+      }
+    }
+  };
+}
 export {
   build,
   buildElectron,
   createServer,
   defineConfig,
   electronPlugin,
+  monacoEditorPlugin,
   resolveConfig,
   startElectronDev
 };