@nasti-toolchain/nasti 2.4.3 → 2.5.0

package/dist/index.js

@@ -10,10 +10,10 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   if (typeof require !== "undefined") return require.apply(this, arguments);
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
-var __glob = (map) => (path19) => {
-  var fn = map[path19];
+var __glob = (map) => (path21) => {
+  var fn = map[path21];
   if (fn) return fn();
-  throw new Error("Module not found in bundle: " + path19);
+  throw new Error("Module not found in bundle: " + path21);
 };
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
@@ -43,7 +43,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/config/defaults.ts
-var defaultResolve, defaultServer, defaultBuild, defaultElectron, defaultExperimental, defaults;
+var defaultResolve, defaultServer, defaultBuild, defaultElectron, defaultExperimental, defaultReact, defaults;
 var init_defaults = __esm({
   "src/config/defaults.ts"() {
     "use strict";
@@ -96,12 +96,20 @@ var init_defaults = __esm({
     defaultExperimental = {
       bundledDev: false
     };
+    defaultReact = {
+      include: /\.[tj]sx?$/,
+      exclude: /node_modules/,
+      jsxImportSource: "react",
+      jsxRuntime: "automatic",
+      compiler: false
+    };
     defaults = {
       root: ".",
       base: "/",
       mode: "development",
       target: "web",
       framework: "auto",
+      react: defaultReact,
       resolve: defaultResolve,
       server: defaultServer,
       build: defaultBuild,
@@ -442,6 +450,13 @@ async function resolveConfig(inlineConfig = {}, command) {
     mode,
     target: merged.target ?? defaults.target,
     framework: (merged.framework ?? defaults.framework) === "auto" ? detectFramework(root) : merged.framework,
+    react: {
+      include: merged.react?.include ?? defaultReact.include,
+      exclude: merged.react?.exclude ?? defaultReact.exclude,
+      jsxImportSource: merged.react?.jsxImportSource ?? defaultReact.jsxImportSource,
+      jsxRuntime: merged.react?.jsxRuntime ?? defaultReact.jsxRuntime,
+      compiler: merged.react?.compiler === true ? {} : merged.react?.compiler ?? defaultReact.compiler
+    },
     command,
     resolve: {
       // tsconfig paths 优先级最低：tsconfig < defaults < user config
@@ -876,27 +891,27 @@ var require_process = __commonJS({
 var require_filesystem = __commonJS({
   "node_modules/detect-libc/lib/filesystem.js"(exports, module) {
     "use strict";
-    var fs14 = __require("fs");
+    var fs16 = __require("fs");
     var LDD_PATH = "/usr/bin/ldd";
     var SELF_PATH = "/proc/self/exe";
     var MAX_LENGTH = 2048;
-    var readFileSync = (path19) => {
-      const fd = fs14.openSync(path19, "r");
+    var readFileSync = (path21) => {
+      const fd = fs16.openSync(path21, "r");
       const buffer = Buffer.alloc(MAX_LENGTH);
-      const bytesRead = fs14.readSync(fd, buffer, 0, MAX_LENGTH, 0);
-      fs14.close(fd, () => {
+      const bytesRead = fs16.readSync(fd, buffer, 0, MAX_LENGTH, 0);
+      fs16.close(fd, () => {
       });
       return buffer.subarray(0, bytesRead);
     };
-    var readFile = (path19) => new Promise((resolve, reject) => {
-      fs14.open(path19, "r", (err, fd) => {
+    var readFile = (path21) => new Promise((resolve, reject) => {
+      fs16.open(path21, "r", (err, fd) => {
         if (err) {
           reject(err);
         } else {
           const buffer = Buffer.alloc(MAX_LENGTH);
-          fs14.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
+          fs16.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
             resolve(buffer.subarray(0, bytesRead));
-            fs14.close(fd, () => {
+            fs16.close(fd, () => {
             });
           });
         }
@@ -1008,11 +1023,11 @@ var require_detect_libc = __commonJS({
       }
       return null;
     };
-    var familyFromInterpreterPath = (path19) => {
-      if (path19) {
-        if (path19.includes("/ld-musl-")) {
+    var familyFromInterpreterPath = (path21) => {
+      if (path21) {
+        if (path21.includes("/ld-musl-")) {
           return MUSL;
-        } else if (path19.includes("/ld-linux-")) {
+        } else if (path21.includes("/ld-linux-")) {
           return GLIBC;
         }
       }
@@ -1059,8 +1074,8 @@ var require_detect_libc = __commonJS({
       cachedFamilyInterpreter = null;
       try {
         const selfContent = await readFile(SELF_PATH);
-        const path19 = interpreterPath(selfContent);
-        cachedFamilyInterpreter = familyFromInterpreterPath(path19);
+        const path21 = interpreterPath(selfContent);
+        cachedFamilyInterpreter = familyFromInterpreterPath(path21);
       } catch (e) {
       }
       return cachedFamilyInterpreter;
@@ -1072,8 +1087,8 @@ var require_detect_libc = __commonJS({
       cachedFamilyInterpreter = null;
       try {
         const selfContent = readFileSync(SELF_PATH);
-        const path19 = interpreterPath(selfContent);
-        cachedFamilyInterpreter = familyFromInterpreterPath(path19);
+        const path21 = interpreterPath(selfContent);
+        cachedFamilyInterpreter = familyFromInterpreterPath(path21);
       } catch (e) {
       }
       return cachedFamilyInterpreter;
@@ -2174,13 +2189,88 @@ ${msg}`);
     map: result.map ? JSON.stringify(result.map) : null
   };
 }
-var JS_EXTENSIONS, TS_EXTENSIONS, JSX_EXTENSIONS;
+async function transformReactCode(filename, code, options) {
+  if (!matchesReactFilter(filename, options.react.include, options.react.exclude)) {
+    return null;
+  }
+  if (!options.react.compiler) {
+    if (!shouldTransform(filename)) return null;
+    return transformCode(filename, code, {
+      sourcemap: options.sourcemap,
+      jsxRuntime: options.react.jsxRuntime,
+      jsxImportSource: options.react.jsxImportSource,
+      reactRefresh: options.reactRefresh,
+      target: options.target
+    });
+  }
+  if (!shouldTransform(filename)) return null;
+  const compiler2 = await loadReactCompiler();
+  const compilerOptions = options.react.compiler;
+  const shouldCompile = options.consumer === "client" && (compilerOptions.compilationMode === "annotation" ? /['"]use memo['"]/.test(code) : defaultReactCompilerCodeFilter.test(code));
+  const result = await compiler2.transform(cleanTransformId(filename), code, {
+    jsx: {
+      runtime: options.react.jsxRuntime,
+      development: options.development,
+      importSource: options.react.jsxImportSource,
+      refresh: options.consumer === "client" && !!options.reactRefresh
+    },
+    reactCompiler: shouldCompile ? compilerOptions : false,
+    sourcemap: options.sourcemap ?? true
+  });
+  const diagnostics = result.errors.map(
+    (error) => `${error.message}${error.codeframe ? `
+${error.codeframe}` : ""}`
+  );
+  if (result.fatal) {
+    throw new Error(
+      diagnostics.join("\n\n") || `React Compiler transform failed for ${filename}`
+    );
+  }
+  for (const diagnostic of diagnostics) options.onWarning?.(diagnostic);
+  return {
+    code: result.code,
+    map: result.map ? JSON.stringify(result.map) : null
+  };
+}
+function matchesReactFilter(id, include, exclude) {
+  const cleanId = cleanTransformId(id);
+  return matchesFilter(cleanId, include) && !matchesFilter(cleanId, exclude);
+}
+function matchesFilter(id, filter2) {
+  const patterns = Array.isArray(filter2) ? filter2 : [filter2];
+  return patterns.some((pattern) => {
+    if (pattern instanceof RegExp) {
+      pattern.lastIndex = 0;
+      return pattern.test(id);
+    }
+    if (!pattern.includes("*")) return id.includes(pattern);
+    const expression = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "\0").replace(/\*/g, "[^/]*").replace(/\0/g, ".*");
+    return new RegExp(`^${expression}$`).test(id);
+  });
+}
+function cleanTransformId(id) {
+  return id.split(/[?#]/, 1)[0];
+}
+async function loadReactCompiler() {
+  if (reactCompilerImplementation) return reactCompilerImplementation;
+  try {
+    reactCompilerImplementation = await import("oxc-transform-react");
+    return reactCompilerImplementation;
+  } catch (error) {
+    throw new Error(
+      '[nasti] React Compiler requires the optional "oxc-transform-react" package. Install it before setting react.compiler.' + (error instanceof Error ? `
+${error.message}` : "")
+    );
+  }
+}
+var JS_EXTENSIONS, TS_EXTENSIONS, JSX_EXTENSIONS, defaultReactCompilerCodeFilter, reactCompilerImplementation;
 var init_transformer = __esm({
   "src/core/transformer.ts"() {
     "use strict";
     JS_EXTENSIONS = /\.(js|mjs|cjs)$/;
     TS_EXTENSIONS = /\.(ts|mts|cts)$/;
     JSX_EXTENSIONS = /\.(jsx|tsx)$/;
+    defaultReactCompilerCodeFilter = /forwardRef|memo|\b(?:[A-Z]|use[A-Z0-9])/;
   }
 });
 
@@ -2226,8 +2316,8 @@ function vuePlugin(config, environmentName = "client") {
       let cached2 = descriptorCache.get(filePath);
       if (!cached2) {
         try {
-          const fs14 = await import("fs");
-          const rawSource = fs14.readFileSync(filePath, "utf-8");
+          const fs16 = await import("fs");
+          const rawSource = fs16.readFileSync(filePath, "utf-8");
           const transformedSfc = await applySourceTransform(
             vueOptions.transformSfc,
             rawSource,
@@ -2893,6 +2983,24 @@ var init_module_graph = __esm({
       getModulesByFile(file) {
         return this.fileToModulesMap.get(file);
       }
+      /**
+       * Modules whose registered entry file lives under `dir` (inclusive).
+       * Used when a non-entry source inside a prebundled workspace package changes:
+       * only the package entry was registered, so getModulesByFile(changedFile)
+       * misses — we invalidate every /@modules entry rooted in that package.
+       */
+      getModulesWithFileUnder(dir) {
+        const result = /* @__PURE__ */ new Set();
+        const normDir = dir.replace(/\\/g, "/");
+        const normPrefix = normDir.endsWith("/") ? normDir : normDir + "/";
+        for (const [file, mods] of this.fileToModulesMap) {
+          const normFile = file.replace(/\\/g, "/");
+          if (normFile === normDir || normFile.startsWith(normPrefix)) {
+            for (const m of mods) result.add(m);
+          }
+        }
+        return result;
+      }
       async ensureEntryFromUrl(url) {
         const normalizedUrl = removeTimestampQuery(url);
         let mod = this.urlToModuleMap.get(normalizedUrl);
@@ -3263,6 +3371,44 @@ var init_environment = __esm({
   }
 });
 
+// src/plugins/react.ts
+function reactPlugin(config, environment) {
+  return {
+    name: "nasti:oxc-transform",
+    async transform(code, id) {
+      const result = await transformReactCode(id, code, {
+        react: config.react,
+        consumer: environment.consumer,
+        development: config.mode === "development",
+        sourcemap: !!environment.options.build.sourcemap,
+        target: environment.options.build.target,
+        onWarning: (message) => config.logger.warn(`[nasti:react] ${message}`)
+      });
+      if (!result) return null;
+      return {
+        code: result.code,
+        map: result.map ? JSON.parse(result.map) : void 0
+      };
+    },
+    handleHotUpdate(ctx) {
+      for (const mod of ctx.modules) {
+        if (REACT_FILE_RE.test(mod.url) && matchesReactFilter(mod.url, config.react.include, config.react.exclude)) {
+          mod.isSelfAccepting = true;
+        }
+      }
+      return ctx.modules;
+    }
+  };
+}
+var REACT_FILE_RE;
+var init_react = __esm({
+  "src/plugins/react.ts"() {
+    "use strict";
+    init_transformer();
+    REACT_FILE_RE = /\.[jt]sx(?:[?#].*)?$/;
+  }
+});
+
 // src/core/env.ts
 import path7 from "path";
 import fs5 from "fs";
@@ -3623,7 +3769,7 @@ function getRolldownOptions(environment, entryPoints, rolldownPlugins) {
       // 相对/绝对/虚拟模块照常打包。需要内联依赖时经 rolldownOptions.external 覆盖。
       external: restInputOptions.external ?? ((id) => {
         if (NODE_BUILTINS.has(id)) return true;
-        return !id.startsWith(".") && !path10.isAbsolute(id) && !id.startsWith("\0");
+        return !id.startsWith(".") && !path10.isAbsolute(id) && !id.startsWith("\0") && !id.startsWith("virtual:");
       })
     } : {}
   };
@@ -3846,6 +3992,7 @@ function resolveClientEntries(config, html) {
   return entryPoints;
 }
 function createOxcTransformPlugin(config, environment) {
+  if (config.framework === "react") return reactPlugin(config, environment);
   return {
     name: "nasti:oxc-transform",
     transform(code, id) {
@@ -3866,7 +4013,7 @@ async function build(inlineConfig = {}) {
   const startTime = performance.now();
   logger.info(
     pc4.cyan(`
-nasti v${"2.4.3"} `) + pc4.green(`building for ${config.mode}...`)
+nasti v${"2.5.0"} `) + pc4.green(`building for ${config.mode}...`)
   );
   debug5?.(`root: ${config.root}`);
   const buildableNames = Object.keys(config.environments).filter((name) => {
@@ -4148,6 +4295,7 @@ var init_build = __esm({
     init_environment();
     init_css_engine();
     init_html();
+    init_react();
     init_transformer();
     init_env();
     init_reporter();
@@ -4203,10 +4351,124 @@ var init_ws = __esm({
   }
 });
 
-// src/server/middleware.ts
-import path12 from "path";
+// src/server/fs-allow.ts
 import fs9 from "fs";
-import { createRequire as createRequire3 } from "module";
+import path12 from "path";
+function isUnderRoot(abs, root) {
+  const rel = path12.relative(root, abs);
+  return !!rel && !rel.startsWith("..") && !path12.isAbsolute(rel);
+}
+function discoverLinkedPackageRoots(projectRoot, maxDepth = 4) {
+  const results = [];
+  const seenReal = /* @__PURE__ */ new Set();
+  const queued = /* @__PURE__ */ new Set([projectRoot]);
+  const queue = [projectRoot];
+  for (let depth = 0; depth < maxDepth && queue.length > 0; depth++) {
+    const levelCount = queue.length;
+    for (let i = 0; i < levelCount; i++) {
+      const dir = queue.shift();
+      const nm = path12.join(dir, "node_modules");
+      let entries;
+      try {
+        entries = fs9.readdirSync(nm, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+      for (const ent of entries) {
+        if (ent.name.startsWith(".") || ent.name === "node_modules") continue;
+        const pkgNames = ent.name.startsWith("@") ? listScopedPackages(nm, ent.name) : [ent.name];
+        for (const pkgName of pkgNames) {
+          const pkgPath = path12.join(nm, pkgName);
+          let real;
+          try {
+            real = fs9.realpathSync(pkgPath);
+          } catch {
+            continue;
+          }
+          if (seenReal.has(real)) continue;
+          seenReal.add(real);
+          if (!queued.has(real)) {
+            queued.add(real);
+            queue.push(real);
+          }
+          if (real !== projectRoot && !isUnderRoot(real, projectRoot) && !real.includes(NM)) {
+            results.push(real);
+          }
+        }
+      }
+    }
+  }
+  return results;
+}
+function listScopedPackages(nm, scope) {
+  try {
+    return fs9.readdirSync(path12.join(nm, scope)).filter((name) => !name.startsWith(".")).map((name) => path12.join(scope, name));
+  } catch {
+    return [];
+  }
+}
+function getLinkedPackageRoots(projectRoot) {
+  let mtimeMs = 0;
+  try {
+    mtimeMs = fs9.statSync(path12.join(projectRoot, "node_modules")).mtimeMs;
+  } catch {
+    mtimeMs = 0;
+  }
+  const cached2 = linkedRootsCache.get(projectRoot);
+  if (cached2 && cached2.mtimeMs === mtimeMs) {
+    return cached2.roots;
+  }
+  const roots = discoverLinkedPackageRoots(projectRoot);
+  linkedRootsCache.set(projectRoot, { roots, mtimeMs });
+  return roots;
+}
+function clearLinkedPackageRootsCache() {
+  linkedRootsCache.clear();
+}
+function isAllowedDevModulePath(realId, projectRoot) {
+  if (realId === projectRoot || isUnderRoot(realId, projectRoot)) return true;
+  for (const pkgRoot of getLinkedPackageRoots(projectRoot)) {
+    if (realId === pkgRoot || realId.startsWith(pkgRoot + path12.sep)) return true;
+  }
+  let dir = projectRoot;
+  for (; ; ) {
+    const nm = path12.join(dir, "node_modules");
+    if (realId === nm || realId.startsWith(nm + path12.sep)) return true;
+    const parent = path12.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return false;
+}
+function findNearestPackageRoot(file) {
+  let dir = path12.dirname(file);
+  for (; ; ) {
+    const pkgJson = path12.join(dir, "package.json");
+    if (fs9.existsSync(pkgJson)) {
+      try {
+        const pkg = JSON.parse(fs9.readFileSync(pkgJson, "utf-8"));
+        if (typeof pkg?.name === "string" && pkg.name) return dir;
+      } catch {
+      }
+    }
+    const parent = path12.dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+var NM, linkedRootsCache;
+var init_fs_allow = __esm({
+  "src/server/fs-allow.ts"() {
+    "use strict";
+    NM = `${path12.sep}node_modules${path12.sep}`;
+    linkedRootsCache = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/server/middleware.ts
+import path13 from "path";
+import fs10 from "fs";
+import { createRequire as createRequire4 } from "module";
 import { fileURLToPath, pathToFileURL as pathToFileURL3 } from "url";
 import pc6 from "picocolors";
 function getReactRefreshRuntimeEsm(includeBoundaryHelpers = false) {
@@ -4216,10 +4478,10 @@ function getReactRefreshRuntimeEsm(includeBoundaryHelpers = false) {
   let cjsPath;
   try {
     const pkgPath = __require2.resolve("react-refresh/package.json");
-    cjsPath = path12.join(path12.dirname(pkgPath), "cjs", "react-refresh-runtime.development.js");
+    cjsPath = path13.join(path13.dirname(pkgPath), "cjs", "react-refresh-runtime.development.js");
   } catch (err) {
-    cjsPath = path12.resolve(__dirname_esm, "../../node_modules/react-refresh/cjs/react-refresh-runtime.development.js");
-    if (!fs9.existsSync(cjsPath)) {
+    cjsPath = path13.resolve(__dirname_esm, "../../node_modules/react-refresh/cjs/react-refresh-runtime.development.js");
+    if (!fs10.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
@@ -4227,7 +4489,7 @@ Original resolve error: ${origMsg}`
       );
     }
   }
-  const cjsSource = fs9.readFileSync(cjsPath, "utf-8");
+  const cjsSource = fs10.readFileSync(cjsPath, "utf-8");
   __refreshRuntimeCache = `// Wrapped react-refresh runtime -> ESM
 const exports = {};
 const module = { exports };
@@ -4398,8 +4660,8 @@ async function transformRequest(url, ctx) {
     let realIdValid = false;
     try {
       if (idParam) {
-        realId = fs9.realpathSync(idParam);
-        realIdValid = fs9.statSync(realId).isFile() && (realId.includes(`${path12.sep}node_modules${path12.sep}`) || isUnderRoot(realId, config.root));
+        realId = fs10.realpathSync(idParam);
+        realIdValid = fs10.statSync(realId).isFile() && isAllowedDevModulePath(realId, config.root);
       }
     } catch {
       realId = null;
@@ -4466,7 +4728,7 @@ async function transformRequest(url, ctx) {
     }
   }
   const filePath = resolveUrlToFile(url, config.root);
-  if (!filePath || !fs9.existsSync(filePath)) return null;
+  if (!filePath || !fs10.existsSync(filePath)) return null;
   const mod = await moduleGraph.ensureEntryFromUrl(url);
   moduleGraph.registerModule(mod, filePath);
   const transformVersion = mod.invalidationVersion;
@@ -4477,7 +4739,7 @@ async function transformRequest(url, ctx) {
     return transformResult2;
   }
   const loaded = await pluginContainer.load(filePath);
-  let code = loaded == null ? fs9.readFileSync(filePath, "utf-8") : typeof loaded === "string" ? loaded : loaded.code;
+  let code = loaded == null ? fs10.readFileSync(filePath, "utf-8") : typeof loaded === "string" ? loaded : loaded.code;
   let map = loaded && typeof loaded !== "string" ? loaded.map : void 0;
   const pluginResult = await pluginContainer.transform(code, filePath);
   if (pluginResult) {
@@ -4486,22 +4748,35 @@ async function transformRequest(url, ctx) {
   }
   const stableUrl = cleanReqUrl;
   let wrappedWithRefresh = false;
-  if (shouldTransform(filePath)) {
-    const isJsx = /\.[jt]sx$/.test(filePath);
-    const useRefresh = isJsx && config.framework !== "vue";
+  if (config.framework === "react") {
+    const refreshEnabled = (ctx.environment?.consumer ?? "client") === "client" && config.server.hmr !== false;
+    const useRefresh = refreshEnabled && (!!config.react.compiler || /\.[jt]sx$/.test(filePath));
+    const result = await transformReactCode(filePath, code, {
+      react: config.react,
+      consumer: ctx.environment?.consumer ?? "client",
+      development: true,
+      reactRefresh: useRefresh,
+      sourcemap: true,
+      target: ctx.environment?.options.build.target ?? config.build.target,
+      onWarning: (message) => config.logger.warn(`[nasti:react] ${message}`)
+    });
+    if (result) {
+      code = result.code;
+      if (result.map) map = JSON.parse(result.map);
+      if (useRefresh) {
+        code = buildReactRefreshWrapper(stableUrl, code);
+        wrappedWithRefresh = true;
+      }
+    }
+  } else if (shouldTransform(filePath)) {
     const result = transformCode(filePath, code, {
       sourcemap: true,
       jsxRuntime: "automatic",
-      jsxImportSource: config.framework === "vue" ? "vue" : "react",
-      reactRefresh: useRefresh,
+      jsxImportSource: "vue",
       target: ctx.environment?.options.build.target ?? config.build.target
     });
     code = result.code;
     if (result.map) map = JSON.parse(result.map);
-    if (useRefresh) {
-      code = buildReactRefreshWrapper(stableUrl, code);
-      wrappedWithRefresh = true;
-    }
   }
   const hotInfo = rewriteHotAcceptDeps(code, config, filePath);
   code = hotInfo.code;
@@ -4535,7 +4810,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") || !fs9.existsSync(resolvedId);
+  const looksVirtual = resolvedId.startsWith("\0") || !fs10.existsSync(resolvedId);
   if (!looksVirtual) return null;
   const loadResult = await pluginContainer.load(resolvedId);
   if (loadResult == null) return null;
@@ -4549,7 +4824,7 @@ async function loadVirtualModule(spec, ctx) {
     config.mode,
     ssrDefineOverrides(ctx.environment?.consumer ?? "client")
   ));
-  const anchor = path12.join(config.root, "__nasti_virtual__.ts");
+  const anchor = path13.join(config.root, "__nasti_virtual__.ts");
   code = rewriteImports(code, config, anchor);
   return { id: resolvedId, result: { code } };
 }
@@ -4575,7 +4850,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 = path12.dirname(entryFile);
+  const externalBaseDir = path13.dirname(entryFile);
   code = code.replace(
     /^(import\b[^;'"]*?\bfrom\s+)(['"])([^'"./][^'"]*)(\2)/gm,
     (_, prefix, q, spec) => `${prefix}${q}${externalSpecToModuleUrl(spec, externalBaseDir, root)}${q}`
@@ -4593,16 +4868,16 @@ async function doBundlePackage(entryFile, root) {
   return code;
 }
 async function tryGenerateSubpathShim(entryFile, root) {
-  const NM = `${path12.sep}node_modules${path12.sep}`;
-  if (!entryFile.includes(NM)) return null;
+  const NM2 = `${path13.sep}node_modules${path13.sep}`;
+  if (!entryFile.includes(NM2)) return null;
   let pkgDir = null;
   let pkgName = null;
-  let dir = path12.dirname(entryFile);
+  let dir = path13.dirname(entryFile);
   while (true) {
-    const pkgJsonPath = path12.join(dir, "package.json");
-    if (fs9.existsSync(pkgJsonPath)) {
+    const pkgJsonPath = path13.join(dir, "package.json");
+    if (fs10.existsSync(pkgJsonPath)) {
       try {
-        const pkg = JSON.parse(fs9.readFileSync(pkgJsonPath, "utf-8"));
+        const pkg = JSON.parse(fs10.readFileSync(pkgJsonPath, "utf-8"));
         if (typeof pkg?.name === "string" && pkg.name) {
           pkgDir = dir;
           pkgName = pkg.name;
@@ -4611,16 +4886,16 @@ async function tryGenerateSubpathShim(entryFile, root) {
       } catch {
       }
     }
-    const parent = path12.dirname(dir);
+    const parent = path13.dirname(dir);
     if (parent === dir) return null;
     dir = parent;
-    if (!dir.includes(NM)) return null;
+    if (!dir.includes(NM2)) return null;
   }
   if (!pkgDir || !pkgName) return null;
-  const entryExt = path12.extname(entryFile);
+  const entryExt = path13.extname(entryFile);
   const mainEntry = pickMainEntryByExtension(pkgDir, entryExt);
   if (!mainEntry) return null;
-  if (path12.resolve(mainEntry) === path12.resolve(entryFile)) return null;
+  if (path13.resolve(mainEntry) === path13.resolve(entryFile)) return null;
   let mainNs;
   let subNs;
   try {
@@ -4644,7 +4919,7 @@ async function tryGenerateSubpathShim(entryFile, root) {
     if (mainNs["default"] !== subNs["default"]) return null;
   }
   const rootMain = resolveNodeModule(root, pkgName);
-  const mainEntryUrl = rootMain && rootMain.startsWith(pkgDir + path12.sep) ? `/@modules/${pkgName}` : `/@modules/${pkgName}?id=${encodeURIComponent(mainEntry)}`;
+  const mainEntryUrl = rootMain && rootMain.startsWith(pkgDir + path13.sep) ? `/@modules/${pkgName}` : `/@modules/${pkgName}?id=${encodeURIComponent(mainEntry)}`;
   const lines = [
     `// Nasti subpath shim \u2192 ${pkgName} (avoid duplicate bundling)`,
     `import * as __pkg from "${mainEntryUrl}";`
@@ -4658,10 +4933,10 @@ async function tryGenerateSubpathShim(entryFile, root) {
   return lines.join("\n") + "\n";
 }
 function pickMainEntryByExtension(pkgDir, preferredExt) {
-  const pkgJsonPath = path12.join(pkgDir, "package.json");
+  const pkgJsonPath = path13.join(pkgDir, "package.json");
   let pkg;
   try {
-    pkg = JSON.parse(fs9.readFileSync(pkgJsonPath, "utf-8"));
+    pkg = JSON.parse(fs10.readFileSync(pkgJsonPath, "utf-8"));
   } catch {
     return null;
   }
@@ -4680,14 +4955,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 (path12.extname(cand) === preferredExt) {
-      const full = path12.resolve(pkgDir, cand);
-      if (fs9.existsSync(full)) return full;
+    if (path13.extname(cand) === preferredExt) {
+      const full = path13.resolve(pkgDir, cand);
+      if (fs10.existsSync(full)) return full;
     }
   }
   for (const cand of candidates) {
-    const full = path12.resolve(pkgDir, cand);
-    if (fs9.existsSync(full)) return full;
+    const full = path13.resolve(pkgDir, cand);
+    if (fs10.existsSync(full)) return full;
   }
   return null;
 }
@@ -4712,8 +4987,8 @@ function rewriteExternalRequires(code, baseDir, root) {
 }
 async function injectCjsNamedExports(code, entryFile) {
   try {
-    const { createRequire: createRequire7 } = await import("module");
-    const req = createRequire7(entryFile);
+    const { createRequire: createRequire8 } = await import("module");
+    const req = createRequire8(entryFile);
     const cjsExports = req(entryFile);
     if (!cjsExports || typeof cjsExports !== "object" && typeof cjsExports !== "function" || Array.isArray(cjsExports)) return code;
     const namedKeys = Object.keys(cjsExports).filter(
@@ -4754,11 +5029,22 @@ function rewriteImports(code, config, filePath, importedUrls, moduleGraph) {
 }
 function createModuleSpecifierResolver(config, filePath) {
   const root = config.root;
-  const fileDir = path12.dirname(filePath);
+  const fileDir = path13.dirname(filePath);
   const aliasEntries = Object.entries(config.resolve.alias).sort(
     ([a], [b]) => b.length - a.length
   );
-  const toRootUrl = (abs) => "/" + path12.relative(root, abs).replace(/\\/g, "/");
+  const toServableUrl = (abs) => {
+    if (isUnderRoot(abs, root)) {
+      return "/" + path13.relative(root, abs).replace(/\\/g, "/");
+    }
+    for (const pkgRoot of getLinkedPackageRoots(root)) {
+      if (abs === pkgRoot || abs.startsWith(pkgRoot + path13.sep)) {
+        const normalized = abs.replace(/\\/g, "/");
+        return "/@fs/" + (normalized.startsWith("/") ? normalized.slice(1) : normalized);
+      }
+    }
+    return null;
+  };
   return (specifier) => {
     const suffixMatch = specifier.match(/[?#].*$/);
     const suffix = suffixMatch ? suffixMatch[0] : "";
@@ -4767,18 +5053,21 @@ function createModuleSpecifierResolver(config, filePath) {
       if (baseSpec === key || baseSpec.startsWith(key + "/")) {
         const aliasBase = resolveAliasTarget2(value, root);
         const sub = baseSpec.slice(key.length).replace(/^\//, "");
-        const target = sub ? path12.join(aliasBase, sub) : aliasBase;
+        const target = sub ? path13.join(aliasBase, sub) : aliasBase;
         const resolved = tryResolveDiskPath(target);
-        return resolved && isUnderRoot(resolved, root) ? toRootUrl(resolved) + suffix : specifier;
+        const url = resolved ? toServableUrl(resolved) : null;
+        return url ? url + suffix : specifier;
       }
     }
     if (baseSpec.startsWith("./") || baseSpec.startsWith("../")) {
-      const resolved = tryResolveDiskPath(path12.resolve(fileDir, baseSpec));
-      return resolved && isUnderRoot(resolved, root) ? toRootUrl(resolved) + suffix : specifier;
+      const resolved = tryResolveDiskPath(path13.resolve(fileDir, baseSpec));
+      const url = resolved ? toServableUrl(resolved) : null;
+      return url ? url + suffix : specifier;
     }
     if (baseSpec.startsWith("/") && !baseSpec.startsWith("/@")) {
-      const resolved = tryResolveDiskPath(path12.join(root, baseSpec.replace(/^\//, "")));
-      return resolved && isUnderRoot(resolved, root) ? toRootUrl(resolved) + suffix : specifier;
+      const resolved = tryResolveDiskPath(path13.join(root, baseSpec.replace(/^\//, "")));
+      const url = resolved ? toServableUrl(resolved) : null;
+      return url ? url + suffix : specifier;
     }
     if (baseSpec.startsWith("/")) return specifier;
     return `/@modules/${specifier}`;
@@ -4931,28 +5220,24 @@ function maskStringsAndComments(code) {
   return masked.join("");
 }
 function resolveAliasTarget2(value, root) {
-  if (path12.isAbsolute(value) && fs9.existsSync(value)) return value;
-  if (value.startsWith("/")) return path12.join(root, value.slice(1));
-  return path12.resolve(root, value);
+  if (path13.isAbsolute(value) && fs10.existsSync(value)) return value;
+  if (value.startsWith("/")) return path13.join(root, value.slice(1));
+  return path13.resolve(root, value);
 }
 function tryResolveDiskPath(target) {
-  if (fs9.existsSync(target) && fs9.statSync(target).isFile()) return target;
+  if (fs10.existsSync(target) && fs10.statSync(target).isFile()) return target;
   for (const ext of RESOLVE_EXTENSIONS) {
     const withExt = target + ext;
-    if (fs9.existsSync(withExt) && fs9.statSync(withExt).isFile()) return withExt;
+    if (fs10.existsSync(withExt) && fs10.statSync(withExt).isFile()) return withExt;
   }
-  if (fs9.existsSync(target) && fs9.statSync(target).isDirectory()) {
+  if (fs10.existsSync(target) && fs10.statSync(target).isDirectory()) {
     for (const ext of RESOLVE_EXTENSIONS) {
-      const idx = path12.join(target, "index" + ext);
-      if (fs9.existsSync(idx) && fs9.statSync(idx).isFile()) return idx;
+      const idx = path13.join(target, "index" + ext);
+      if (fs10.existsSync(idx) && fs10.statSync(idx).isFile()) return idx;
     }
   }
   return null;
 }
-function isUnderRoot(abs, root) {
-  const rel = path12.relative(root, abs);
-  return !!rel && !rel.startsWith("..") && !path12.isAbsolute(rel);
-}
 function appendTimestampQuery(url, timestamp) {
   const hashIndex = url.indexOf("#");
   const hash = hashIndex >= 0 ? url.slice(hashIndex) : "";
@@ -4970,7 +5255,7 @@ function resolveNodeModule(baseDir, moduleName) {
   const resolved = resolveNodeModuleEntry(baseDir, moduleName);
   if (!resolved) return null;
   try {
-    return fs9.realpathSync(resolved);
+    return fs10.realpathSync(resolved);
   } catch {
     return resolved;
   }
@@ -4990,21 +5275,21 @@ function resolveNodeModuleEntry(root, moduleName) {
   let pkgDir = null;
   let dir = root;
   for (; ; ) {
-    const candidate = path12.join(dir, "node_modules", pkgName);
-    if (fs9.existsSync(candidate)) {
+    const candidate = path13.join(dir, "node_modules", pkgName);
+    if (fs10.existsSync(candidate)) {
       pkgDir = candidate;
       break;
     }
-    const parent = path12.dirname(dir);
+    const parent = path13.dirname(dir);
     if (parent === dir) break;
     dir = parent;
   }
   if (!pkgDir) return null;
-  const pkgJsonPath = path12.join(pkgDir, "package.json");
-  if (!fs9.existsSync(pkgJsonPath)) return null;
+  const pkgJsonPath = path13.join(pkgDir, "package.json");
+  if (!fs10.existsSync(pkgJsonPath)) return null;
   let pkg;
   try {
-    pkg = JSON.parse(fs9.readFileSync(pkgJsonPath, "utf-8"));
+    pkg = JSON.parse(fs10.readFileSync(pkgJsonPath, "utf-8"));
   } catch {
     return null;
   }
@@ -5017,32 +5302,32 @@ function resolveNodeModuleEntry(root, moduleName) {
     const subDirs = [""];
     for (const field of ["module", "main"]) {
       if (typeof pkg[field] === "string") {
-        const dir2 = path12.dirname(pkg[field]);
+        const dir2 = path13.dirname(pkg[field]);
         if (dir2 && dir2 !== "." && !subDirs.includes(dir2)) subDirs.push(dir2);
       }
     }
     for (const dir2 of subDirs) {
-      const direct = path12.join(pkgDir, dir2, subpath);
-      if (fs9.existsSync(direct) && fs9.statSync(direct).isFile()) return direct;
+      const direct = path13.join(pkgDir, dir2, subpath);
+      if (fs10.existsSync(direct) && fs10.statSync(direct).isFile()) return direct;
       for (const ext of RESOLVE_EXTENSIONS) {
-        if (fs9.existsSync(direct + ext)) return direct + ext;
+        if (fs10.existsSync(direct + ext)) return direct + ext;
       }
     }
     return null;
   }
   for (const field of ["module", "jsnext:main", "jsnext", "main"]) {
     if (typeof pkg[field] === "string") {
-      const entry = path12.join(pkgDir, pkg[field]);
-      if (fs9.existsSync(entry)) return entry;
+      const entry = path13.join(pkgDir, pkg[field]);
+      if (fs10.existsSync(entry)) return entry;
     }
   }
-  const indexFallback = path12.join(pkgDir, "index.js");
-  if (fs9.existsSync(indexFallback)) return indexFallback;
+  const indexFallback = path13.join(pkgDir, "index.js");
+  if (fs10.existsSync(indexFallback)) return indexFallback;
   return null;
 }
 function resolvePackageExports(exports, key, pkgDir) {
   if (typeof exports === "string") {
-    return key === "." ? path12.join(pkgDir, exports) : null;
+    return key === "." ? path13.join(pkgDir, exports) : null;
   }
   const entry = exports[key];
   if (entry === void 0) {
@@ -5054,7 +5339,7 @@ function resolvePackageExports(exports, key, pkgDir) {
   return resolveExportValue(entry, pkgDir);
 }
 function resolveExportValue(value, pkgDir) {
-  if (typeof value === "string") return path12.join(pkgDir, value);
+  if (typeof value === "string") return path13.join(pkgDir, value);
   if (Array.isArray(value)) {
     for (const item of value) {
       const r = resolveExportValue(item, pkgDir);
@@ -5073,35 +5358,54 @@ function resolveExportValue(value, pkgDir) {
   return null;
 }
 function resolveUrlToFile(url, root) {
-  const cleanUrl = url.split("?")[0];
+  const cleanUrl = url.split(/[?#]/)[0];
   if (cleanUrl.startsWith("/@modules/")) {
     const moduleName = cleanUrl.slice("/@modules/".length);
     return resolveNodeModule(root, moduleName);
   }
-  const filePath = path12.resolve(root, cleanUrl.replace(/^\//, ""));
-  if (fs9.existsSync(filePath) && fs9.statSync(filePath).isFile()) {
+  if (cleanUrl.startsWith("/@fs/")) {
+    let abs = cleanUrl.slice("/@fs/".length);
+    if (process.platform === "win32") {
+      abs = abs.replace(/\//g, path13.sep);
+    } else if (!abs.startsWith("/")) {
+      abs = "/" + abs;
+    }
+    try {
+      const real = fs10.realpathSync(abs);
+      if (fs10.statSync(real).isFile() && isAllowedDevModulePath(real, root)) return real;
+    } catch {
+      return null;
+    }
+    return null;
+  }
+  const filePath = path13.resolve(root, cleanUrl.replace(/^\//, ""));
+  if (fs10.existsSync(filePath) && fs10.statSync(filePath).isFile()) {
     return filePath;
   }
   for (const ext of RESOLVE_EXTENSIONS) {
     const withExt = filePath + ext;
-    if (fs9.existsSync(withExt)) return withExt;
+    if (fs10.existsSync(withExt)) return withExt;
   }
   for (const ext of RESOLVE_EXTENSIONS) {
-    const indexFile = path12.join(filePath, "index" + ext);
-    if (fs9.existsSync(indexFile)) return indexFile;
+    const indexFile = path13.join(filePath, "index" + ext);
+    if (fs10.existsSync(indexFile)) return indexFile;
   }
   return null;
 }
 function isModuleRequest(url, destination) {
-  const cleanUrl = url.split("?")[0];
+  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 (cleanUrl.startsWith("/@fs/")) return true;
   if (isAssetFile(cleanUrl)) {
-    const query = url.includes("?") ? url.slice(url.indexOf("?") + 1) : "";
+    const qIdx = url.indexOf("?");
+    const hIdx = url.indexOf("#");
+    const queryEnd = hIdx === -1 ? url.length : hIdx;
+    const query = qIdx === -1 || qIdx > queryEnd ? "" : url.slice(qIdx + 1, queryEnd);
     const isExplicitAssetModule = /(?:^|&)(?:url|raw)(?:&|$)/.test(query);
     return isExplicitAssetModule || destination === "script";
   }
-  if (!path12.extname(cleanUrl)) return true;
+  if (!path13.extname(cleanUrl)) return true;
   return false;
 }
 function getHmrClientCode() {
@@ -5340,8 +5644,9 @@ var init_middleware = __esm({
     init_env();
     init_url();
     init_assets();
-    __dirname_esm = path12.dirname(fileURLToPath(import.meta.url));
-    __require2 = createRequire3(import.meta.url);
+    init_fs_allow();
+    __dirname_esm = path13.dirname(fileURLToPath(import.meta.url));
+    __require2 = createRequire4(import.meta.url);
     __refreshRuntimeCache = null;
     REACT_REFRESH_BOUNDARY_HELPERS = `
 function __nastiIsPlainObject(obj) {
@@ -5421,8 +5726,8 @@ window.__vite_plugin_react_preamble_installed__ = true;
 });
 
 // src/server/hmr.ts
-import path13 from "path";
-import fs10 from "fs";
+import path14 from "path";
+import fs11 from "fs";
 import pc7 from "picocolors";
 async function handleFileChange(file, server, environmentName = "client", timestamp = Date.now()) {
   const { config } = server;
@@ -5432,9 +5737,26 @@ async function handleFileChange(file, server, environmentName = "client", timest
   }
   const moduleGraph = environment.moduleGraph;
   const logger = config.logger;
-  const relativePath = "/" + path13.relative(config.root, file);
-  const shortFile = path13.relative(config.root, file);
-  const mods = moduleGraph.getModulesByFile(file);
+  const relativePath = "/" + path14.relative(config.root, file);
+  const shortFile = path14.relative(config.root, file);
+  let mods = moduleGraph.getModulesByFile(file);
+  if (!mods || mods.size === 0) {
+    try {
+      const real = fs11.realpathSync(file);
+      if (real !== file) mods = moduleGraph.getModulesByFile(real);
+      if (mods && mods.size > 0) file = real;
+    } catch {
+    }
+  }
+  if (!mods || mods.size === 0) {
+    const packageRoot = findNearestPackageRoot(file);
+    if (packageRoot && getLinkedPackageRoots(config.root).some(
+      (r) => packageRoot === r || packageRoot.startsWith(r + path14.sep)
+    )) {
+      const under = moduleGraph.getModulesWithFileUnder(packageRoot);
+      if (under.size > 0) mods = under;
+    }
+  }
   if (!mods || mods.size === 0) {
     return null;
   }
@@ -5449,7 +5771,7 @@ async function handleFileChange(file, server, environmentName = "client", timest
       file,
       timestamp,
       modules: [mod],
-      read: () => fs10.readFileSync(file, "utf-8"),
+      read: () => fs11.readFileSync(file, "utf-8"),
       server,
       environment
     };
@@ -5513,6 +5835,7 @@ async function handleFileChange(file, server, environmentName = "client", timest
 var init_hmr = __esm({
   "src/server/hmr.ts"() {
     "use strict";
+    init_fs_allow();
   }
 });
 
@@ -5522,9 +5845,9 @@ __export(runnable_environment_exports, {
   NastiModuleRunner: () => NastiModuleRunner,
   createModuleRunner: () => createModuleRunner
 });
-import path14 from "path";
-import fs11 from "fs";
-import { builtinModules as builtinModules3, createRequire as createRequire4 } from "module";
+import path15 from "path";
+import fs12 from "fs";
+import { builtinModules as builtinModules3, createRequire as createRequire5 } from "module";
 import { pathToFileURL as pathToFileURL4 } from "url";
 function createModuleRunner(environment) {
   if (environment.consumer !== "server") {
@@ -5557,7 +5880,7 @@ var init_runnable_environment = __esm({
           this.config.mode,
           ssrDefineOverrides(environment.consumer)
         );
-        this.require = createRequire4(path14.join(this.config.root, "package.json"));
+        this.require = createRequire5(path15.join(this.config.root, "package.json"));
         const handlers = {
           fetchModule: async (id, importer) => this.fetchModule(id, importer),
           getBuiltins: () => [/^node:/, ...builtinModules3]
@@ -5581,9 +5904,9 @@ var init_runnable_environment = __esm({
         this.cache.clear();
       }
       resolveToId(rawUrl) {
-        if (path14.isAbsolute(rawUrl) && fs11.existsSync(rawUrl.split("?")[0])) return rawUrl;
+        if (path15.isAbsolute(rawUrl) && fs12.existsSync(rawUrl.split("?")[0])) return rawUrl;
         const clean = rawUrl.replace(/^\//, "");
-        return path14.resolve(this.config.root, clean);
+        return path15.resolve(this.config.root, clean);
       }
       /**
        * fetchModule（invoke 契约方法）：环境管线产出 runner 可执行代码。
@@ -5592,14 +5915,14 @@ var init_runnable_environment = __esm({
        */
       async fetchModule(id, importer) {
         if (NODE_BUILTINS3.has(id)) return { externalize: id };
-        if (!id.startsWith(".") && !path14.isAbsolute(id) && !id.startsWith("\0")) {
+        if (!id.startsWith(".") && !path15.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 : path14.resolve(path14.dirname(importer.split("?")[0]), id);
+          resolvedId = resolved ? typeof resolved === "string" ? resolved : resolved.id : path15.resolve(path15.dirname(importer.split("?")[0]), id);
         }
         resolvedId = this.completeExtension(resolvedId);
         const cleanId = resolvedId.split("?")[0];
@@ -5607,8 +5930,8 @@ var init_runnable_environment = __esm({
         const loaded = await container.load(resolvedId);
         if (loaded != null) {
           code = typeof loaded === "string" ? loaded : loaded.code;
-        } else if (fs11.existsSync(cleanId)) {
-          code = fs11.readFileSync(cleanId, "utf-8");
+        } else if (fs12.existsSync(cleanId)) {
+          code = fs12.readFileSync(cleanId, "utf-8");
         } else {
           throw new Error(`[nasti:ssr] cannot load module: ${resolvedId}`);
         }
@@ -5616,12 +5939,32 @@ var init_runnable_environment = __esm({
         if (transformed != null) {
           code = typeof transformed === "string" ? transformed : transformed.code;
         }
-        if (shouldTransform(cleanId)) {
+        if (this.config.framework === "react") {
+          const result = await transformReactCode(cleanId, code, {
+            react: this.config.react,
+            consumer: this.environment.consumer,
+            development: true,
+            sourcemap: false,
+            target: this.environment.options.build.target,
+            onWarning: (message) => this.config.logger.warn(`[nasti:react] ${message}`)
+          });
+          if (result) {
+            code = result.code;
+          } else if (shouldTransform(cleanId)) {
+            const fallback = transformCode(cleanId, code, {
+              sourcemap: false,
+              jsxRuntime: this.config.react.jsxRuntime,
+              jsxImportSource: this.config.react.jsxImportSource,
+              target: this.environment.options.build.target
+            });
+            code = fallback.code;
+          }
+        } else if (shouldTransform(cleanId)) {
           const result = transformCode(cleanId, code, {
             sourcemap: false,
             target: this.environment.options.build.target,
             jsxRuntime: "automatic",
-            jsxImportSource: this.config.framework === "vue" ? "vue" : "react"
+            jsxImportSource: "vue"
           });
           code = result.code;
         }
@@ -5642,19 +5985,19 @@ var init_runnable_environment = __esm({
       completeExtension(id) {
         const clean = id.split("?")[0];
         const query = id.includes("?") ? id.slice(id.indexOf("?")) : "";
-        if (fs11.existsSync(clean) && fs11.statSync(clean).isFile()) return id;
+        if (fs12.existsSync(clean) && fs12.statSync(clean).isFile()) return id;
         const jsMatch = clean.match(/^(.*)\.([mc]?)jsx?$/);
         if (jsMatch) {
           for (const tsExt of [`.${jsMatch[2]}ts`, `.${jsMatch[2]}tsx`]) {
-            if (fs11.existsSync(jsMatch[1] + tsExt)) return jsMatch[1] + tsExt + query;
+            if (fs12.existsSync(jsMatch[1] + tsExt)) return jsMatch[1] + tsExt + query;
           }
         }
         for (const ext of this.config.resolve.extensions) {
-          if (fs11.existsSync(clean + ext)) return clean + ext + query;
+          if (fs12.existsSync(clean + ext)) return clean + ext + query;
         }
         for (const ext of this.config.resolve.extensions) {
-          const indexPath = path14.join(clean, `index${ext}`);
-          if (fs11.existsSync(indexPath)) return indexPath;
+          const indexPath = path15.join(clean, `index${ext}`);
+          if (fs12.existsSync(indexPath)) return indexPath;
         }
         return id;
       }
@@ -5681,10 +6024,10 @@ var init_runnable_environment = __esm({
           return;
         }
         const ssrImport = async (dep) => {
-          if (NODE_BUILTINS3.has(dep) || !dep.startsWith(".") && !path14.isAbsolute(dep) && !dep.startsWith("\0")) {
+          if (NODE_BUILTINS3.has(dep) || !dep.startsWith(".") && !path15.isAbsolute(dep) && !dep.startsWith("\0")) {
             return this.importExternal(dep);
           }
-          const depId = dep.startsWith(".") ? this.completeExtension(path14.resolve(path14.dirname(fetched.id.split("?")[0]), dep)) : this.completeExtension(dep);
+          const depId = dep.startsWith(".") ? this.completeExtension(path15.resolve(path15.dirname(fetched.id.split("?")[0]), dep)) : this.completeExtension(dep);
           return this.instantiate(depId);
         };
         const ssrExportAll = (sourceModule) => {
@@ -5716,7 +6059,7 @@ var init_runnable_environment = __esm({
       }
       async importExternal(spec) {
         try {
-          return await (spec.startsWith("node:") || !path14.isAbsolute(spec) ? import(this.resolveExternalSpecifier(spec)) : import(pathToFileURL4(spec).href));
+          return await (spec.startsWith("node:") || !path15.isAbsolute(spec) ? import(this.resolveExternalSpecifier(spec)) : import(pathToFileURL4(spec).href));
         } catch (err) {
           throw new Error(`[nasti:ssr] failed to import external "${spec}": ${err.message}`);
         }
@@ -5742,7 +6085,7 @@ var dev_engine_exports = {};
 __export(dev_engine_exports, {
   createBundledDevServer: () => createBundledDevServer
 });
-import path15 from "path";
+import path16 from "path";
 import crypto3 from "crypto";
 import { WebSocketServer as WsServer2 } from "ws";
 import pc8 from "picocolors";
@@ -5772,11 +6115,11 @@ async function createBundledDevServer(opts) {
   const patches = new MemoryFiles();
   const entryFileNames = /* @__PURE__ */ new Map();
   const bundledClients = /* @__PURE__ */ new Map();
-  const useReactRefresh = config.framework !== "vue" && refreshWrapperFn != null;
+  const useReactRefresh = config.framework === "react" && config.server.hmr !== false && refreshWrapperFn != null;
   const rolldownPlugins = [
     ...useReactRefresh ? [
       createReactRefreshRuntimePlugin(entryPoints),
-      createBundledOxcRefreshPlugin()
+      createBundledOxcRefreshPlugin(config)
     ] : [],
     ...stripCatchAllLoad(toRolldownPlugins(clientEnv.plugins, clientEnv)),
     ...useReactRefresh ? [
@@ -5827,7 +6170,7 @@ async function createBundledDevServer(opts) {
       }
       const url = `/${patchPath}`;
       logger.info(
-        pc8.green("hmr update ") + pc8.dim(changedFiles.map((f) => path15.relative(config.root, f)).join(", ")),
+        pc8.green("hmr update ") + pc8.dim(changedFiles.map((f) => path16.relative(config.root, f)).join(", ")),
         { timestamp: true }
       );
       sendTo(clientId, { type: "hmr:update", path: url, url });
@@ -5982,7 +6325,7 @@ async function createBundledDevServer(opts) {
           return;
         }
         res.setHeader("ETag", hit.etag);
-        res.setHeader("Content-Type", MIME_TYPES[path15.extname(fileName)] ?? "application/octet-stream");
+        res.setHeader("Content-Type", MIME_TYPES[path16.extname(fileName)] ?? "application/octet-stream");
         res.setHeader("Cache-Control", "no-cache");
         res.once("finish", () => {
           void engine.notifyPayloadDelivered(fileName).catch(
@@ -6023,7 +6366,7 @@ function stripCatchAllLoad(plugins) {
   );
 }
 function createReactRefreshRuntimePlugin(entryPoints) {
-  const entryIds = new Set(entryPoints.map((p) => path15.resolve(p)));
+  const entryIds = new Set(entryPoints.map((p) => path16.resolve(p)));
   return {
     name: "nasti:bundled-react-refresh",
     resolveId(source) {
@@ -6041,24 +6384,27 @@ function createReactRefreshRuntimePlugin(entryPoints) {
       return null;
     },
     transform(code, id) {
-      if (!entryIds.has(path15.resolve(id.split("?")[0]))) return null;
+      if (!entryIds.has(path16.resolve(id.split("?")[0]))) return null;
       return { code: `import ${JSON.stringify(PREAMBLE_SPEC)};
 ${code}`, map: null };
     }
   };
 }
-function createBundledOxcRefreshPlugin() {
+function createBundledOxcRefreshPlugin(config) {
   return {
     name: "nasti:bundled-oxc-refresh",
-    transform(code, id) {
+    async transform(code, id) {
       const clean = id.split("?")[0];
-      if (!/\.[jt]sx$/.test(clean) || clean.includes("/node_modules/")) return null;
-      const result = transformCode(clean, code, {
+      const result = await transformReactCode(clean, code, {
+        react: config.react,
+        consumer: "client",
+        development: true,
+        reactRefresh: true,
         sourcemap: true,
-        jsxRuntime: "automatic",
-        jsxImportSource: "react",
-        reactRefresh: true
+        target: config.build.target,
+        onWarning: (message) => config.logger.warn(`[nasti:react] ${message}`)
       });
+      if (!result) return null;
       return { code: result.code, map: result.map ? JSON.parse(result.map) : void 0 };
     }
   };
@@ -6212,7 +6558,7 @@ __export(server_exports, {
   createServer: () => createServer
 });
 import http from "http";
-import path16 from "path";
+import path17 from "path";
 import os from "os";
 import connect from "connect";
 import sirv from "sirv";
@@ -6305,20 +6651,39 @@ async function createServer(inlineConfig = {}) {
     app.use(bundledServer.middleware);
   }
   const ignoredSegments = /* @__PURE__ */ new Set(["node_modules", ".git", ".nasti"]);
-  const outDirAbs = path16.resolve(config.root, config.build.outDir);
-  const watcher = watch(config.root, {
+  const outDirAbs = path17.resolve(config.root, config.build.outDir);
+  const linkedPackageRoots = getLinkedPackageRoots(config.root).filter(
+    (r) => r !== config.root && !isUnderRoot(config.root, r)
+  );
+  const watchTargets = [config.root, ...linkedPackageRoots];
+  const watcher = watch(watchTargets, {
     ignored: (filePath) => {
-      if (filePath === config.root) return false;
-      if (filePath === outDirAbs || filePath.startsWith(outDirAbs + path16.sep)) return true;
-      const rel = path16.relative(config.root, filePath);
-      if (!rel || rel.startsWith("..") || path16.isAbsolute(rel)) return false;
-      for (const seg of rel.split(path16.sep)) {
-        if (ignoredSegments.has(seg)) return true;
+      if (filePath === outDirAbs || filePath.startsWith(outDirAbs + path17.sep)) return true;
+      for (const watchRoot of watchTargets) {
+        if (filePath === watchRoot) return false;
+        const rel = path17.relative(watchRoot, filePath);
+        if (!rel || rel.startsWith("..") || path17.isAbsolute(rel)) continue;
+        for (const seg of rel.split(path17.sep)) {
+          if (ignoredSegments.has(seg)) return true;
+        }
+        return false;
       }
       return false;
     },
     ignoreInitial: true
   });
+  await new Promise((resolve, reject) => {
+    const onReady = () => {
+      watcher.off("error", onError);
+      resolve();
+    };
+    const onError = (err) => {
+      watcher.off("ready", onReady);
+      reject(err);
+    };
+    watcher.once("ready", onReady);
+    watcher.once("error", onError);
+  });
   let server;
   const environmentServices = {};
   let environmentDriversStarted = false;
@@ -6430,16 +6795,25 @@ async function createServer(inlineConfig = {}) {
     });
   };
   watcher.on("change", (file) => {
+    if (file.includes(`${path17.sep}node_modules${path17.sep}`) || file.endsWith(`${path17.sep}node_modules`)) {
+      clearLinkedPackageRootsCache();
+    }
     ssrRunner?.invalidateFile(file);
     queueClientEnvironmentUpdate(file);
     notifyEnvironmentDrivers(file, "change");
   });
   watcher.on("add", (file) => {
+    if (file.includes(`${path17.sep}node_modules${path17.sep}`) || file.endsWith(`${path17.sep}node_modules`)) {
+      clearLinkedPackageRootsCache();
+    }
     ssrRunner?.invalidateFile(file);
     queueClientEnvironmentUpdate(file);
     notifyEnvironmentDrivers(file, "add");
   });
   watcher.on("unlink", (file) => {
+    if (file.includes(`${path17.sep}node_modules${path17.sep}`) || file.endsWith(`${path17.sep}node_modules`)) {
+      clearLinkedPackageRootsCache();
+    }
     ssrRunner?.invalidateFile(file);
     notifyEnvironmentDrivers(file, "unlink");
   });
@@ -6469,7 +6843,7 @@ async function createServer(inlineConfig = {}) {
           const readyIn = Math.ceil(performance.now() - startTime);
           logger.info(
             `
-  ${pc9.cyan(pc9.bold("NASTI"))} ${pc9.cyan(`v${"2.4.3"}`)}  ${pc9.dim("ready in")} ${pc9.bold(readyIn)} ${pc9.dim("ms")}
+  ${pc9.cyan(pc9.bold("NASTI"))} ${pc9.cyan(`v${"2.5.0"}`)}  ${pc9.dim("ready in")} ${pc9.bold(readyIn)} ${pc9.dim("ms")}
 `
           );
           printServerUrls(
@@ -6566,7 +6940,7 @@ async function createServer(inlineConfig = {}) {
     throw error;
   }
   app.use(transformMiddleware(transformContexts.get("client")));
-  const publicDir = path16.resolve(config.root, "public");
+  const publicDir = path17.resolve(config.root, "public");
   app.use(sirv(publicDir, { dev: true, etag: true }));
   app.use(sirv(config.root, { dev: true, etag: true }));
   const postMiddlewares = [];
@@ -6605,6 +6979,7 @@ var init_server = __esm({
     init_builtins();
     init_plugin_api();
     init_env();
+    init_fs_allow();
   }
 });
 
@@ -6617,6 +6992,7 @@ init_config();
 init_resolve();
 import path11 from "path";
 import fs8 from "fs";
+import { createRequire as createRequire3 } from "module";
 import { rolldown as rolldown2 } from "rolldown";
 import pc5 from "picocolors";
 
@@ -6660,7 +7036,7 @@ async function buildElectron(inlineConfig = {}) {
   const config = await resolveConfig({ ...inlineConfig, target: "electron" }, "build");
   const startTime = performance.now();
   assertElectronVersion(config);
-  console.log(pc5.cyan("\n\u26A1 nasti build (electron)") + pc5.dim(` v${"2.4.3"}`));
+  console.log(pc5.cyan("\n\u26A1 nasti build (electron)") + pc5.dim(` v${"2.5.0"}`));
   console.log(pc5.dim(`  root: ${config.root}`));
   console.log(pc5.dim(`  mode: ${config.mode}`));
   console.log(pc5.dim(`  target: electron (\u2265 ${config.electron.minVersion})`));
@@ -6726,14 +7102,21 @@ async function bundleNode(config, entry, opts) {
   };
   const oxcTransformPlugin = {
     name: "nasti:oxc-transform",
-    transform(code, id) {
-      if (!shouldTransform(id)) return null;
-      const result = transformCode(id, code, {
+    async transform(code, id) {
+      const result = config.framework === "react" ? await transformReactCode(id, code, {
+        react: config.react,
+        consumer: "server",
+        development: config.mode === "development",
+        sourcemap: !!config.build.sourcemap,
+        target: config.electron.nodeTarget,
+        onWarning: (message) => config.logger.warn(`[nasti:react] ${message}`)
+      }) : shouldTransform(id) ? transformCode(id, code, {
         sourcemap: !!config.build.sourcemap,
         jsxRuntime: "automatic",
-        jsxImportSource: config.framework === "vue" ? "vue" : "react",
+        jsxImportSource: "vue",
         target: config.electron.nodeTarget
-      });
+      }) : null;
+      if (!result) return null;
       return { code: result.code, map: result.map ? JSON.parse(result.map) : void 0 };
     }
   };
@@ -6804,13 +7187,21 @@ function assertElectronVersion(config) {
 }
 function detectInstalledElectron(root) {
   try {
-    const pkgPath = path11.resolve(root, "node_modules/electron/package.json");
-    if (!fs8.existsSync(pkgPath)) return null;
+    const require2 = createRequire3(path11.resolve(root, "package.json"));
+    const pkgPath = require2.resolve("electron/package.json");
     const pkg = JSON.parse(fs8.readFileSync(pkgPath, "utf-8"));
     const major = parseInt(String(pkg.version).split(".")[0], 10);
     return Number.isFinite(major) ? major : null;
   } catch {
-    return null;
+    try {
+      const pkgPath = path11.resolve(root, "node_modules/electron/package.json");
+      if (!fs8.existsSync(pkgPath)) return null;
+      const pkg = JSON.parse(fs8.readFileSync(pkgPath, "utf-8"));
+      const major = parseInt(String(pkg.version).split(".")[0], 10);
+      return Number.isFinite(major) ? major : null;
+    } catch {
+      return null;
+    }
   }
 }
 
@@ -6819,9 +7210,9 @@ init_server();
 
 // src/server/electron-dev.ts
 init_config();
-import path17 from "path";
-import fs12 from "fs";
-import { createRequire as createRequire5 } from "module";
+import path18 from "path";
+import fs13 from "fs";
+import { createRequire as createRequire6 } from "module";
 import { spawn } from "child_process";
 import chokidar from "chokidar";
 import pc10 from "picocolors";
@@ -6833,7 +7224,7 @@ 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.4.3"}`));
+  console.log(pc10.cyan("\n\u26A1 nasti electron dev") + pc10.dim(` v${"2.5.0"}`));
   const { createServer: createServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
   const server = await createServer2({
     ...rest,
@@ -6843,11 +7234,11 @@ async function startElectronDev(inlineConfig = {}) {
   await server.listen();
   const devUrl = `http://localhost:${server.config.server.port}` + electronRendererDevPath(config.electron.renderer);
   console.log(pc10.dim(`  renderer: ${devUrl}`));
-  const stageDir = path17.resolve(config.root, ".nasti");
-  fs12.mkdirSync(stageDir, { recursive: true });
-  const mainEntry = path17.resolve(config.root, config.electron.main);
+  const stageDir = path18.resolve(config.root, ".nasti");
+  fs13.mkdirSync(stageDir, { recursive: true });
+  const mainEntry = path18.resolve(config.root, config.electron.main);
   const preloadEntries = normalizePreload(config.electron.preload, config.root);
-  const builtMainFile = path17.join(stageDir, "main" + extFor(config.electron.mainFormat));
+  const builtMainFile = path18.join(stageDir, "main" + extFor(config.electron.mainFormat));
   const builtPreloadFiles = [];
   const compileAll = async () => {
     await compileNode(config, mainEntry, {
@@ -6857,9 +7248,9 @@ async function startElectronDev(inlineConfig = {}) {
     });
     builtPreloadFiles.length = 0;
     for (const entry of preloadEntries) {
-      if (!fs12.existsSync(entry)) continue;
-      const base = path17.basename(entry).replace(/\.[^.]+$/, "");
-      const out = path17.join(stageDir, base + extFor(config.electron.preloadFormat));
+      if (!fs13.existsSync(entry)) continue;
+      const base = path18.basename(entry).replace(/\.[^.]+$/, "");
+      const out = path18.join(stageDir, base + extFor(config.electron.preloadFormat));
       await compileNode(config, entry, {
         outFile: out,
         format: config.electron.preloadFormat,
@@ -6898,7 +7289,7 @@ async function startElectronDev(inlineConfig = {}) {
   };
   spawnElectron();
   if (config.electron.autoRestart) {
-    const watchTargets = [mainEntry, ...preloadEntries].filter(fs12.existsSync);
+    const watchTargets = [mainEntry, ...preloadEntries].filter(fs13.existsSync);
     const watcher = chokidar.watch(watchTargets, { ignoreInitial: true });
     let restarting = null;
     let pending = false;
@@ -6958,14 +7349,21 @@ async function compileNode(config, entry, opts) {
   };
   const oxcTransformPlugin = {
     name: "nasti:oxc-transform",
-    transform(code, id) {
-      if (!shouldTransform(id)) return null;
-      const result = transformCode(id, code, {
+    async transform(code, id) {
+      const result = config.framework === "react" ? await transformReactCode(id, code, {
+        react: config.react,
+        consumer: "server",
+        development: true,
+        sourcemap: true,
+        target: config.electron.nodeTarget,
+        onWarning: (message) => config.logger.warn(`[nasti:react] ${message}`)
+      }) : shouldTransform(id) ? transformCode(id, code, {
         sourcemap: true,
         jsxRuntime: "automatic",
-        jsxImportSource: config.framework === "vue" ? "vue" : "react",
+        jsxImportSource: "vue",
         target: config.electron.nodeTarget
-      });
+      }) : null;
+      if (!result) return null;
       return { code: result.code, map: result.map ? JSON.parse(result.map) : void 0 };
     }
   };
@@ -6978,7 +7376,7 @@ async function compileNode(config, entry, opts) {
     platform: "node",
     plugins: [oxcTransformPlugin, electronPlugin(config), resolvePlugin(config)]
   });
-  fs12.mkdirSync(path17.dirname(opts.outFile), { recursive: true });
+  fs13.mkdirSync(path18.dirname(opts.outFile), { recursive: true });
   await bundle2.write({
     file: opts.outFile,
     format: opts.format === "cjs" ? "cjs" : "esm",
@@ -6991,18 +7389,18 @@ async function compileNode(config, entry, opts) {
   await bundle2.close();
 }
 function electronRendererDevPath(renderer) {
-  const normalized = renderer.split(path17.sep).join("/").replace(/^\.?\//, "");
+  const normalized = renderer.split(path18.sep).join("/").replace(/^\.?\//, "");
   return normalized === "index.html" ? "/" : `/${normalized}`;
 }
 function resolveElectronBinary(config) {
-  if (config.electron.electronPath && fs12.existsSync(config.electron.electronPath)) {
+  if (config.electron.electronPath && fs13.existsSync(config.electron.electronPath)) {
     return config.electron.electronPath;
   }
   try {
-    const require2 = createRequire5(path17.resolve(config.root, "package.json"));
+    const require2 = createRequire6(path18.resolve(config.root, "package.json"));
     const pathFile = require2.resolve("electron");
     const electronModule = require2(pathFile);
-    if (typeof electronModule === "string" && fs12.existsSync(electronModule)) {
+    if (typeof electronModule === "string" && fs13.existsSync(electronModule)) {
       return electronModule;
     }
   } catch {
@@ -7029,10 +7427,10 @@ function warnElectronVersion(config) {
 }
 
 // src/plugins/monaco-editor.ts
-import path18 from "path";
-import fs13 from "fs";
+import path19 from "path";
+import fs14 from "fs";
 import crypto4 from "crypto";
-import { createRequire as createRequire6 } from "module";
+import { createRequire as createRequire7 } from "module";
 var DEFAULT_WORKERS = {
   editorWorkerService: "monaco-editor/esm/vs/editor/editor.worker",
   css: "monaco-editor/esm/vs/language/css/css.worker",
@@ -7051,9 +7449,9 @@ function normalizePublicPath(p) {
 }
 function readMonacoVersion(root) {
   try {
-    const require2 = createRequire6(path18.resolve(root, "package.json"));
+    const require2 = createRequire7(path19.resolve(root, "package.json"));
     const pkgJsonPath = require2.resolve("monaco-editor/package.json", { paths: [root] });
-    const pkg = JSON.parse(fs13.readFileSync(pkgJsonPath, "utf-8"));
+    const pkg = JSON.parse(fs14.readFileSync(pkgJsonPath, "utf-8"));
     return typeof pkg.version === "string" ? pkg.version : "unknown";
   } catch {
     return "unknown";
@@ -7073,20 +7471,20 @@ function monacoEditorPlugin(options = {}) {
   let cacheDir = "";
   const building = /* @__PURE__ */ new Map();
   async function buildWorker(worker) {
-    const cacheFile = path18.join(cacheDir, `${worker.label}.worker.js`);
-    if (fs13.existsSync(cacheFile)) return cacheFile;
+    const cacheFile = path19.join(cacheDir, `${worker.label}.worker.js`);
+    if (fs14.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 = createRequire6(path18.resolve(resolvedConfig.root, "package.json"));
+      const require2 = createRequire7(path19.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] });
       }
-      fs13.mkdirSync(cacheDir, { recursive: true });
+      fs14.mkdirSync(cacheDir, { recursive: true });
       const bundle2 = await rolldown4({
         input: entry,
         platform: "browser"
@@ -7146,16 +7544,23 @@ function monacoEditorPlugin(options = {}) {
       resolvedConfig = config;
       const version = readMonacoVersion(config.root);
       const key = crypto4.createHash("sha1").update(version + "|" + publicPath).digest("hex").slice(0, 8);
-      cacheDir = path18.resolve(config.root, "node_modules/.nasti/monaco", key);
+      cacheDir = path19.resolve(config.root, "node_modules/.nasti/monaco", key);
     },
     async configureServer(server) {
       const shouldBuild = !isCDN(publicPath) || forceBuildCDN;
       const watcher = server.watcher;
-      const monacoDir = path18.resolve(resolvedConfig.root, "node_modules/monaco-editor");
+      const monacoLogical = path19.resolve(resolvedConfig.root, "node_modules/monaco-editor");
+      const monacoPaths = /* @__PURE__ */ new Set([monacoLogical]);
       try {
-        watcher?.unwatch?.(monacoDir);
+        monacoPaths.add(fs14.realpathSync(monacoLogical));
       } catch {
       }
+      for (const monacoDir of monacoPaths) {
+        try {
+          watcher?.unwatch?.(monacoDir);
+        } catch {
+        }
+      }
       if (!shouldBuild) return;
       void Promise.all(
         workers.map(
@@ -7181,7 +7586,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");
-            fs13.createReadStream(file).pipe(res);
+            fs14.createReadStream(file).pipe(res);
           } catch (e) {
             res.statusCode = 500;
             res.end(`Monaco worker build failed: ${e.message}`);
@@ -7216,16 +7621,16 @@ self.monaco = monaco;`,
         resolvedConfig.root,
         resolvedConfig.build.outDir,
         resolvedConfig.base
-      ) : isCDN(publicPath) ? path18.resolve(resolvedConfig.root, resolvedConfig.build.outDir, "monaco") : path18.resolve(
+      ) : isCDN(publicPath) ? path19.resolve(resolvedConfig.root, resolvedConfig.build.outDir, "monaco") : path19.resolve(
         resolvedConfig.root,
         resolvedConfig.build.outDir,
         publicPath.replace(/^\//, "")
       );
-      fs13.mkdirSync(outDir, { recursive: true });
+      fs14.mkdirSync(outDir, { recursive: true });
       for (const worker of workers) {
         try {
           const cacheFile = await buildWorker(worker);
-          fs13.copyFileSync(cacheFile, path18.join(outDir, `${worker.label}.worker.js`));
+          fs14.copyFileSync(cacheFile, path19.join(outDir, `${worker.label}.worker.js`));
         } catch (e) {
           throw new Error(
             `[nasti:monaco-editor] worker build failed for "${worker.label}": ${e.message}
@@ -7237,6 +7642,345 @@ ${e.stack || ""}`
   };
 }
 
+// src/plugins/rsc.ts
+init_transformer();
+import fs15 from "fs";
+import path20 from "path";
+import { parseSync } from "oxc-parser";
+var SERVER_RUNTIME_ID = "virtual:nasti-rsc/server-runtime";
+var CLIENT_RUNTIME_ID = "virtual:nasti-rsc/client-runtime";
+var RESOLVED_SERVER_RUNTIME_ID = `\0${SERVER_RUNTIME_ID}`;
+var RESOLVED_CLIENT_RUNTIME_ID = `\0${CLIENT_RUNTIME_ID}`;
+function rsc(options = {}) {
+  const names = {
+    client: options.environment?.client ?? "client",
+    ssr: options.environment?.ssr ?? "ssr",
+    rsc: options.environment?.rsc ?? "rsc"
+  };
+  const clientReferences = /* @__PURE__ */ new Map();
+  const serverReferences = /* @__PURE__ */ new Map();
+  let resolvedConfig;
+  return {
+    name: "nasti:rsc",
+    enforce: "post",
+    config(config, env) {
+      const root = path20.resolve(config.root ?? ".");
+      const include = options.include ?? config.react?.include ?? /\.[tj]sx?$/;
+      const exclude = options.exclude ?? config.react?.exclude ?? /node_modules/;
+      const discoveredClients = env.command === "build" ? discoverDirectiveModules(root, options.scanDirectories, include, exclude) : [];
+      for (const item of discoveredClients) {
+        if (item.module.useClient) {
+          clientReferences.set(
+            item.id,
+            new Set(item.module.exports.map((entry) => entry.exported))
+          );
+        }
+        if (item.module.useServer) {
+          serverReferences.set(
+            item.id,
+            new Set(item.module.exports.map((entry) => entry.exported))
+          );
+        }
+      }
+      const environments = { ...config.environments ?? {} };
+      if (names.client !== "client") {
+        environments.client = {
+          ...environments.client ?? {},
+          buildEnabled: false
+        };
+      }
+      const client = { ...environments[names.client] ?? {} };
+      const clientSeeds = collectClientSeeds(root, config, client, options.entries?.client);
+      const generatedClientEntries = discoveredClients.filter((item) => item.module.useClient).map((item) => item.id);
+      client.consumer = "client";
+      client.entry = uniqueEntries([...clientSeeds, ...generatedClientEntries]);
+      environments[names.client] = client;
+      const rscEnvironment = { ...environments[names.rsc] ?? {} };
+      rscEnvironment.consumer = "server";
+      const rscEntries = normalizeEntries(options.entries?.rsc);
+      if (rscEntries.length > 0) rscEnvironment.entry = rscEntries;
+      environments[names.rsc] = rscEnvironment;
+      const ssrEntries = normalizeEntries(options.entries?.ssr);
+      if (ssrEntries.length > 0 || environments[names.ssr]) {
+        environments[names.ssr] = {
+          ...environments[names.ssr] ?? {},
+          consumer: "server",
+          ...ssrEntries.length > 0 ? { entry: ssrEntries } : {}
+        };
+      }
+      return { environments };
+    },
+    configEnvironment(name, environment) {
+      if (name !== names.rsc) return;
+      const conditions = environment.resolve?.conditions ?? ["node", "import", "module", "default"];
+      return {
+        consumer: "server",
+        resolve: {
+          ...environment.resolve,
+          conditions: ["react-server", ...conditions.filter((item) => item !== "react-server")]
+        }
+      };
+    },
+    configResolved(config) {
+      if (config.framework !== "react") {
+        throw new Error('[nasti:rsc] the RSC generator requires framework: "react"');
+      }
+      resolvedConfig = config;
+    },
+    resolveId(source) {
+      if (source === SERVER_RUNTIME_ID) return RESOLVED_SERVER_RUNTIME_ID;
+      if (source === CLIENT_RUNTIME_ID) return RESOLVED_CLIENT_RUNTIME_ID;
+      return null;
+    },
+    load(id) {
+      if (id === RESOLVED_SERVER_RUNTIME_ID) return createServerRuntimeModule();
+      if (id === RESOLVED_CLIENT_RUNTIME_ID) {
+        const browser = this.environment?.name === names.client;
+        return createClientRuntimeModule(browser);
+      }
+      return null;
+    },
+    transform(code, id) {
+      if (!resolvedConfig || !isSourceModule(id, resolvedConfig, options)) return null;
+      const cleanId = cleanModuleId(id);
+      const module = scanModule(cleanId, code);
+      if (!module) return null;
+      if (module.useClient && module.useServer) {
+        throw new Error(`[nasti:rsc] ${displayId(resolvedConfig.root, cleanId)} cannot contain both "use client" and "use server"`);
+      }
+      const moduleId = referenceModuleId(resolvedConfig.root, cleanId);
+      if (module.useClient) {
+        clientReferences.set(cleanId, new Set(module.exports.map((entry) => entry.exported)));
+        if (this.environment?.name === names.rsc) {
+          return {
+            code: createClientReferenceProxy(moduleId, module.exports),
+            map: { mappings: "" }
+          };
+        }
+      }
+      if (module.useServer) {
+        serverReferences.set(cleanId, new Set(module.exports.map((entry) => entry.exported)));
+        if (this.environment?.name === names.rsc) {
+          return {
+            code: registerServerReferences(code, moduleId, module.exports, cleanId),
+            map: { mappings: "" }
+          };
+        }
+        if (this.environment?.consumer === "client" || this.environment?.name === names.client || this.environment?.name === names.ssr) {
+          return {
+            code: createServerReferenceProxy(moduleId, module.exports),
+            map: { mappings: "" }
+          };
+        }
+      }
+      return null;
+    },
+    afterBuildApp(results, _api, context) {
+      if (options.manifestFile === false) return;
+      const manifest = createManifest(
+        names,
+        resolvedConfig?.root ?? "",
+        results,
+        clientReferences,
+        serverReferences
+      );
+      const output = {
+        type: "asset",
+        fileName: options.manifestFile ?? "rsc-manifest.json",
+        source: JSON.stringify(manifest, null, 2) + "\n"
+      };
+      context.emitFile(output);
+    }
+  };
+}
+function scanModule(filename, code) {
+  if (!code.includes("use client") && !code.includes("use server")) return null;
+  const parsed = parseSync(filename, code);
+  if (parsed.errors.length > 0) return null;
+  const directives = new Set(
+    parsed.program.body.filter((node) => node.type === "ExpressionStatement" && typeof node.directive === "string").map((node) => node.directive)
+  );
+  const useClient = directives.has("use client");
+  const useServer = directives.has("use server");
+  if (!useClient && !useServer) return null;
+  const exports = [];
+  for (const statement of parsed.module.staticExports) {
+    for (const entry of statement.entries) {
+      if (entry.isType) continue;
+      const exported = entry.exportName.kind === "Default" ? "default" : entry.exportName.name;
+      if (!exported) {
+        throw new Error(
+          `[nasti:rsc] ${filename} uses export * inside an RSC directive module; replace it with explicit named exports so reference identities are stable`
+        );
+      }
+      exports.push({
+        exported,
+        local: entry.localName.kind === "Name" ? entry.localName.name ?? void 0 : void 0,
+        reexported: entry.moduleRequest !== null
+      });
+    }
+  }
+  return { useClient, useServer, exports: dedupeExports(exports) };
+}
+function createClientReferenceProxy(moduleId, exports) {
+  const lines = [
+    `import { registerClientReference as __nasti_register_client__ } from ${JSON.stringify(SERVER_RUNTIME_ID)};`
+  ];
+  exports.forEach((entry, index2) => {
+    const local = `__nasti_client_reference_${index2}__`;
+    const message = `Cannot call client export ${moduleId}#${entry.exported} from the RSC server graph.`;
+    lines.push(
+      `const ${local} = __nasti_register_client__(function () { throw new Error(${JSON.stringify(message)}); }, ${JSON.stringify(moduleId)}, ${JSON.stringify(entry.exported)});`,
+      exportLocal(local, entry.exported)
+    );
+  });
+  return lines.join("\n") + "\n";
+}
+function registerServerReferences(code, moduleId, exports, filename) {
+  const registrations = [];
+  for (const entry of exports) {
+    if (entry.reexported || !entry.local) {
+      throw new Error(
+        `[nasti:rsc] ${filename} must use named local bindings for "use server" exports; ${entry.exported} cannot be registered safely`
+      );
+    }
+    registrations.push(
+      `__nasti_register_server__(${entry.local}, ${JSON.stringify(moduleId)}, ${JSON.stringify(entry.exported)});`
+    );
+  }
+  return [
+    code,
+    `import { registerServerReference as __nasti_register_server__ } from ${JSON.stringify(SERVER_RUNTIME_ID)};`,
+    ...registrations,
+    ""
+  ].join("\n");
+}
+function createServerReferenceProxy(moduleId, exports) {
+  const lines = [
+    `import { createServerReference as __nasti_create_server__ } from ${JSON.stringify(CLIENT_RUNTIME_ID)};`
+  ];
+  exports.forEach((entry, index2) => {
+    const local = `__nasti_server_reference_${index2}__`;
+    lines.push(
+      `const ${local} = __nasti_create_server__(${JSON.stringify(moduleId)}, ${JSON.stringify(entry.exported)});`,
+      exportLocal(local, entry.exported)
+    );
+  });
+  return lines.join("\n") + "\n";
+}
+function exportLocal(local, exported) {
+  if (exported === "default") return `export default ${local};`;
+  const name = /^[A-Za-z_$][\w$]*$/.test(exported) ? exported : JSON.stringify(exported);
+  return `export { ${local} as ${name} };`;
+}
+function createServerRuntimeModule() {
+  return [
+    `export { registerClientReference, registerServerReference } from "react-server-dom-webpack/server.edge";`,
+    ""
+  ].join("\n");
+}
+function createClientRuntimeModule(browser) {
+  const source = browser ? "react-server-dom-webpack/client.browser" : "react-server-dom-webpack/client.edge";
+  return `
+import { createServerReference as __createServerReference } from ${JSON.stringify(source)};
+const __callServer = (id, args) => {
+  const handler = globalThis[Symbol.for("nasti.rsc.callServer")];
+  if (typeof handler !== "function") {
+    throw new Error("No RSC callServer handler is installed. Set globalThis[Symbol.for('nasti.rsc.callServer')].");
+  }
+  return handler(id, args);
+};
+export function createServerReference(moduleId, name) {
+  return __createServerReference(moduleId + "#" + name, __callServer, undefined, undefined, name);
+}
+`.trimStart();
+}
+function createManifest(names, root, results, clients, servers) {
+  return {
+    version: 1,
+    environments: names,
+    clientReferences: manifestReferences(root, results[names.client], clients),
+    serverReferences: manifestReferences(root, results[names.rsc], servers)
+  };
+}
+function manifestReferences(root, result, references) {
+  const output = {};
+  for (const [id, names] of [...references].sort(([a], [b]) => a.localeCompare(b))) {
+    const chunks = Object.values(result?.chunks ?? {}).filter((chunk) => chunk.moduleIds.some((moduleId) => cleanModuleId(moduleId) === id)).map((chunk) => chunk.fileName).sort();
+    for (const name of [...names].sort()) {
+      const moduleId = referenceModuleId(root, id);
+      output[`${moduleId}#${name}`] = { id: moduleId, name, chunks };
+    }
+  }
+  return output;
+}
+function discoverDirectiveModules(root, scanDirectories, include, exclude) {
+  const requested = scanDirectories ?? ["app", "src"];
+  const roots = requested.map((directory) => path20.resolve(root, directory)).filter((directory) => fs15.existsSync(directory));
+  if (roots.length === 0) roots.push(root);
+  const output = [];
+  for (const directory of roots) walk(directory);
+  return output;
+  function walk(directory) {
+    for (const entry of fs15.readdirSync(directory, { withFileTypes: true })) {
+      if (entry.name === "node_modules" || entry.name === ".git" || entry.name === ".nasti") continue;
+      const id = path20.join(directory, entry.name);
+      if (entry.isDirectory()) {
+        walk(id);
+        continue;
+      }
+      if (!entry.isFile() || !matchesReactFilter(id, include, exclude)) continue;
+      const module = scanModule(id, fs15.readFileSync(id, "utf-8"));
+      if (module) output.push({ id, module });
+    }
+  }
+}
+function collectClientSeeds(root, config, client, configured) {
+  const explicit = [
+    ...normalizeEntries(client.entry),
+    ...normalizeEntries(configured)
+  ];
+  if (explicit.length > 0) return explicit;
+  const htmlFile = path20.resolve(root, client.html ?? "index.html");
+  if (fs15.existsSync(htmlFile)) {
+    const html = fs15.readFileSync(htmlFile, "utf-8");
+    const htmlDir = path20.dirname(htmlFile);
+    const entries = [...html.matchAll(/<script[^>]+src=["']([^"']+)["'][^>]*>/gi)].map((match) => match[1]?.split(/[?#]/, 1)[0]).filter((entry) => !!entry && !entry.startsWith("http")).map((entry) => entry.startsWith("/") ? path20.resolve(root, entry.slice(1)) : path20.resolve(htmlDir, entry));
+    if (entries.length > 0) return entries;
+  }
+  for (const entry of ["src/main.ts", "src/main.tsx", "src/main.js", "src/index.ts", "src/index.tsx", "src/index.js"]) {
+    if (fs15.existsSync(path20.resolve(root, entry))) return [entry];
+  }
+  return [];
+}
+function normalizeEntries(entries) {
+  return entries == null ? [] : Array.isArray(entries) ? entries : [entries];
+}
+function uniqueEntries(entries) {
+  return [...new Set(entries)];
+}
+function isSourceModule(id, config, options) {
+  const cleanId = cleanModuleId(id);
+  if (cleanId.startsWith("\0")) return false;
+  const include = options.include ?? config.react.include;
+  const exclude = options.exclude ?? config.react.exclude;
+  return matchesReactFilter(cleanId, include, exclude);
+}
+function cleanModuleId(id) {
+  return id.split(/[?#]/, 1)[0];
+}
+function referenceModuleId(root, id) {
+  if (!root || !path20.isAbsolute(id)) return id.replaceAll(path20.sep, "/");
+  const relative = path20.relative(root, id).replaceAll(path20.sep, "/");
+  return relative.startsWith("../") ? id.replaceAll(path20.sep, "/") : `/${relative}`;
+}
+function displayId(root, id) {
+  return referenceModuleId(root, id);
+}
+function dedupeExports(exports) {
+  return [...new Map(exports.map((entry) => [entry.exported, entry])).values()];
+}
+
 // src/index.ts
 init_environment();
 init_hot_channel();
@@ -7264,6 +8008,7 @@ export {
   printServerUrls,
   resolveConfig,
   resolveEnvironmentPlugins,
+  rsc,
   ssrDefineOverrides,
   startElectronDev
 };