@nasti-toolchain/nasti 2.4.4 → 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) => (path20) => {
-  var fn = map[path20];
+var __glob = (map) => (path21) => {
+  var fn = map[path21];
   if (fn) return fn();
-  throw new Error("Module not found in bundle: " + path20);
+  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 fs15 = __require("fs");
+    var fs16 = __require("fs");
     var LDD_PATH = "/usr/bin/ldd";
     var SELF_PATH = "/proc/self/exe";
     var MAX_LENGTH = 2048;
-    var readFileSync = (path20) => {
-      const fd = fs15.openSync(path20, "r");
+    var readFileSync = (path21) => {
+      const fd = fs16.openSync(path21, "r");
       const buffer = Buffer.alloc(MAX_LENGTH);
-      const bytesRead = fs15.readSync(fd, buffer, 0, MAX_LENGTH, 0);
-      fs15.close(fd, () => {
+      const bytesRead = fs16.readSync(fd, buffer, 0, MAX_LENGTH, 0);
+      fs16.close(fd, () => {
       });
       return buffer.subarray(0, bytesRead);
     };
-    var readFile = (path20) => new Promise((resolve, reject) => {
-      fs15.open(path20, "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);
-          fs15.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
+          fs16.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
             resolve(buffer.subarray(0, bytesRead));
-            fs15.close(fd, () => {
+            fs16.close(fd, () => {
             });
           });
         }
@@ -1008,11 +1023,11 @@ var require_detect_libc = __commonJS({
       }
       return null;
     };
-    var familyFromInterpreterPath = (path20) => {
-      if (path20) {
-        if (path20.includes("/ld-musl-")) {
+    var familyFromInterpreterPath = (path21) => {
+      if (path21) {
+        if (path21.includes("/ld-musl-")) {
           return MUSL;
-        } else if (path20.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 path20 = interpreterPath(selfContent);
-        cachedFamilyInterpreter = familyFromInterpreterPath(path20);
+        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 path20 = interpreterPath(selfContent);
-        cachedFamilyInterpreter = familyFromInterpreterPath(path20);
+        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 fs15 = await import("fs");
-          const rawSource = fs15.readFileSync(filePath, "utf-8");
+          const fs16 = await import("fs");
+          const rawSource = fs16.readFileSync(filePath, "utf-8");
           const transformedSfc = await applySourceTransform(
             vueOptions.transformSfc,
             rawSource,
@@ -3281,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";
@@ -3641,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:");
       })
     } : {}
   };
@@ -3864,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) {
@@ -3884,7 +4013,7 @@ async function build(inlineConfig = {}) {
   const startTime = performance.now();
   logger.info(
     pc4.cyan(`
-nasti v${"2.4.4"} `) + 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) => {
@@ -4166,6 +4295,7 @@ var init_build = __esm({
     init_environment();
     init_css_engine();
     init_html();
+    init_react();
     init_transformer();
     init_env();
     init_reporter();
@@ -4618,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;
@@ -5796,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;
         }
@@ -5952,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 ? [
@@ -6227,18 +6390,21 @@ ${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 };
     }
   };
@@ -6677,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.4"}`)}  ${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(
@@ -6870,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.4"}`));
+  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})`));
@@ -6936,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 };
     }
   };
@@ -7051,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.4"}`));
+  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,
@@ -7176,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 };
     }
   };
@@ -7462,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();
@@ -7489,6 +8008,7 @@ export {
   printServerUrls,
   resolveConfig,
   resolveEnvironmentPlugins,
+  rsc,
   ssrDefineOverrides,
   startElectronDev
 };