@nasti-toolchain/nasti 2.4.4 → 2.5.1

package/dist/index.js

@@ -10,16 +10,25 @@ 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) => (path23) => {
+  var fn = map[path23];
   if (fn) return fn();
-  throw new Error("Module not found in bundle: " + path20);
+  throw new Error("Module not found in bundle: " + path23);
 };
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+var __esm = (fn, res, err) => function __init() {
+  if (err) throw err[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err = [e], e;
+  }
 };
 var __commonJS = (cb, mod) => function __require3() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
 };
 var __export = (target, all) => {
   for (var name in all)
@@ -43,7 +52,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 +105,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,
@@ -136,7 +153,7 @@ function createLogger(level = "info", options = {}) {
   const canClearScreen = allowClearScreen && process.stdout.isTTY && !process.env.CI;
   const clear = canClearScreen ? clearScreen : () => {
   };
-  function format(type, msg, options2 = {}) {
+  function format2(type, msg, options2 = {}) {
     if (options2.timestamp) {
       const tag = type === "info" ? pc.cyan(pc.bold(prefix)) : type === "warn" ? pc.yellow(pc.bold(prefix)) : pc.red(pc.bold(prefix));
       return `${pc.dim(timeFormatter.format(/* @__PURE__ */ new Date()))} ${tag} ${msg}`;
@@ -153,16 +170,16 @@ function createLogger(level = "info", options = {}) {
       if (type === lastType && msg === lastMsg) {
         sameCount++;
         clear();
-        console_[method](format(type, msg, options2), pc.yellow(`(x${sameCount + 1})`));
+        console_[method](format2(type, msg, options2), pc.yellow(`(x${sameCount + 1})`));
       } else {
         sameCount = 0;
         lastMsg = msg;
         lastType = type;
         if (options2.clear) clear();
-        console_[method](format(type, msg, options2));
+        console_[method](format2(type, msg, options2));
       }
     } else {
-      console_[method](format(type, msg, options2));
+      console_[method](format2(type, msg, options2));
     }
   }
   const warnedMessages = /* @__PURE__ */ new Set();
@@ -442,6 +459,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 +900,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 fs17 = __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 = (path23) => {
+      const fd = fs17.openSync(path23, "r");
       const buffer = Buffer.alloc(MAX_LENGTH);
-      const bytesRead = fs15.readSync(fd, buffer, 0, MAX_LENGTH, 0);
-      fs15.close(fd, () => {
+      const bytesRead = fs17.readSync(fd, buffer, 0, MAX_LENGTH, 0);
+      fs17.close(fd, () => {
       });
       return buffer.subarray(0, bytesRead);
     };
-    var readFile = (path20) => new Promise((resolve, reject) => {
-      fs15.open(path20, "r", (err, fd) => {
+    var readFile = (path23) => new Promise((resolve, reject) => {
+      fs17.open(path23, "r", (err, fd) => {
         if (err) {
           reject(err);
         } else {
           const buffer = Buffer.alloc(MAX_LENGTH);
-          fs15.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
+          fs17.read(fd, buffer, 0, MAX_LENGTH, 0, (_, bytesRead) => {
             resolve(buffer.subarray(0, bytesRead));
-            fs15.close(fd, () => {
+            fs17.close(fd, () => {
             });
           });
         }
@@ -1008,11 +1032,11 @@ var require_detect_libc = __commonJS({
       }
       return null;
     };
-    var familyFromInterpreterPath = (path20) => {
-      if (path20) {
-        if (path20.includes("/ld-musl-")) {
+    var familyFromInterpreterPath = (path23) => {
+      if (path23) {
+        if (path23.includes("/ld-musl-")) {
           return MUSL;
-        } else if (path20.includes("/ld-linux-")) {
+        } else if (path23.includes("/ld-linux-")) {
           return GLIBC;
         }
       }
@@ -1059,8 +1083,8 @@ var require_detect_libc = __commonJS({
       cachedFamilyInterpreter = null;
       try {
         const selfContent = await readFile(SELF_PATH);
-        const path20 = interpreterPath(selfContent);
-        cachedFamilyInterpreter = familyFromInterpreterPath(path20);
+        const path23 = interpreterPath(selfContent);
+        cachedFamilyInterpreter = familyFromInterpreterPath(path23);
       } catch (e) {
       }
       return cachedFamilyInterpreter;
@@ -1072,8 +1096,8 @@ var require_detect_libc = __commonJS({
       cachedFamilyInterpreter = null;
       try {
         const selfContent = readFileSync(SELF_PATH);
-        const path20 = interpreterPath(selfContent);
-        cachedFamilyInterpreter = familyFromInterpreterPath(path20);
+        const path23 = interpreterPath(selfContent);
+        cachedFamilyInterpreter = familyFromInterpreterPath(path23);
       } catch (e) {
       }
       return cachedFamilyInterpreter;
@@ -2174,13 +2198,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 +2325,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 fs17 = await import("fs");
+          const rawSource = fs17.readFileSync(filePath, "utf-8");
           const transformedSfc = await applySourceTransform(
             vueOptions.transformSfc,
             rawSource,
@@ -3281,6 +3380,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 +3778,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 +4001,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 +4022,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.1"} `) + pc4.green(`building for ${config.mode}...`)
   );
   debug5?.(`root: ${config.root}`);
   const buildableNames = Object.keys(config.environments).filter((name) => {
@@ -4166,6 +4304,7 @@ var init_build = __esm({
     init_environment();
     init_css_engine();
     init_html();
+    init_react();
     init_transformer();
     init_env();
     init_reporter();
@@ -4618,22 +4757,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;
@@ -4844,8 +4996,8 @@ function rewriteExternalRequires(code, baseDir, root) {
 }
 async function injectCjsNamedExports(code, entryFile) {
   try {
-    const { createRequire: createRequire8 } = await import("module");
-    const req = createRequire8(entryFile);
+    const { createRequire: createRequire7 } = await import("module");
+    const req = createRequire7(entryFile);
     const cjsExports = req(entryFile);
     if (!cjsExports || typeof cjsExports !== "object" && typeof cjsExports !== "function" || Array.isArray(cjsExports)) return code;
     const namedKeys = Object.keys(cjsExports).filter(
@@ -5696,223 +5848,1555 @@ var init_hmr = __esm({
   }
 });
 
-// src/server/runnable-environment.ts
-var runnable_environment_exports = {};
-__export(runnable_environment_exports, {
-  NastiModuleRunner: () => NastiModuleRunner,
-  createModuleRunner: () => createModuleRunner
-});
-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") {
-    throw new Error(
-      `[nasti] module runner requires a server-consumer environment (got "${environment.name}" / ${environment.consumer})`
+// node_modules/import-meta-resolve/lib/errors.js
+import v8 from "v8";
+import assert from "assert";
+import { format, inspect } from "util";
+function formatList(array, type = "and") {
+  return array.length < 3 ? array.join(` ${type} `) : `${array.slice(0, -1).join(", ")}, ${type} ${array[array.length - 1]}`;
+}
+function createError(sym, value, constructor) {
+  messages.set(sym, value);
+  return makeNodeErrorWithCode(constructor, sym);
+}
+function makeNodeErrorWithCode(Base, key) {
+  return NodeError;
+  function NodeError(...parameters) {
+    const limit = Error.stackTraceLimit;
+    if (isErrorStackTraceLimitWritable()) Error.stackTraceLimit = 0;
+    const error = new Base();
+    if (isErrorStackTraceLimitWritable()) Error.stackTraceLimit = limit;
+    const message = getMessage(key, parameters, error);
+    Object.defineProperties(error, {
+      // Note: no need to implement `kIsNodeError` symbol, would be hard,
+      // probably.
+      message: {
+        value: message,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      },
+      toString: {
+        /** @this {Error} */
+        value() {
+          return `${this.name} [${key}]: ${this.message}`;
+        },
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+    captureLargerStackTrace(error);
+    error.code = key;
+    return error;
+  }
+}
+function isErrorStackTraceLimitWritable() {
+  try {
+    if (v8.startupSnapshot.isBuildingSnapshot()) {
+      return false;
+    }
+  } catch {
+  }
+  const desc = Object.getOwnPropertyDescriptor(Error, "stackTraceLimit");
+  if (desc === void 0) {
+    return Object.isExtensible(Error);
+  }
+  return own.call(desc, "writable") && desc.writable !== void 0 ? desc.writable : desc.set !== void 0;
+}
+function hideStackFrames(wrappedFunction) {
+  const hidden = nodeInternalPrefix + wrappedFunction.name;
+  Object.defineProperty(wrappedFunction, "name", { value: hidden });
+  return wrappedFunction;
+}
+function getMessage(key, parameters, self) {
+  const message = messages.get(key);
+  assert.ok(message !== void 0, "expected `message` to be found");
+  if (typeof message === "function") {
+    assert.ok(
+      message.length <= parameters.length,
+      // Default options do not count.
+      `Code: ${key}; The provided arguments length (${parameters.length}) does not match the required ones (${message.length}).`
     );
+    return Reflect.apply(message, self, parameters);
+  }
+  const regex = /%[dfijoOs]/g;
+  let expectedLength = 0;
+  while (regex.exec(message) !== null) expectedLength++;
+  assert.ok(
+    expectedLength === parameters.length,
+    `Code: ${key}; The provided arguments length (${parameters.length}) does not match the required ones (${expectedLength}).`
+  );
+  if (parameters.length === 0) return message;
+  parameters.unshift(message);
+  return Reflect.apply(format, null, parameters);
+}
+function determineSpecificType(value) {
+  if (value === null || value === void 0) {
+    return String(value);
   }
-  return new NastiModuleRunner(environment);
+  if (typeof value === "function" && value.name) {
+    return `function ${value.name}`;
+  }
+  if (typeof value === "object") {
+    if (value.constructor && value.constructor.name) {
+      return `an instance of ${value.constructor.name}`;
+    }
+    return `${inspect(value, { depth: -1 })}`;
+  }
+  let inspected = inspect(value, { colors: false });
+  if (inspected.length > 28) {
+    inspected = `${inspected.slice(0, 25)}...`;
+  }
+  return `type ${typeof value} (${inspected})`;
 }
-var debug6, NODE_BUILTINS3, NastiModuleRunner, AsyncFunction;
-var init_runnable_environment = __esm({
-  "src/server/runnable-environment.ts"() {
+var own, classRegExp, kTypes, codes, messages, nodeInternalPrefix, userStackTraceLimit, captureLargerStackTrace;
+var init_errors = __esm({
+  "node_modules/import-meta-resolve/lib/errors.js"() {
     "use strict";
-    init_transformer();
-    init_env();
-    init_debug();
-    debug6 = createDebugger("nasti:ssr");
-    NODE_BUILTINS3 = /* @__PURE__ */ new Set([...builtinModules3, ...builtinModules3.map((m) => `node:${m}`)]);
-    NastiModuleRunner = class {
-      environment;
-      config;
-      cache = /* @__PURE__ */ new Map();
-      envDefine;
-      require;
-      constructor(environment) {
-        this.environment = environment;
-        this.config = environment.config;
-        this.envDefine = buildEnvDefine(
-          loadEnv(this.config.mode, this.config.root, this.config.envPrefix),
-          this.config.mode,
-          ssrDefineOverrides(environment.consumer)
-        );
-        this.require = createRequire5(path15.join(this.config.root, "package.json"));
-        const handlers = {
-          fetchModule: async (id, importer) => this.fetchModule(id, importer),
-          getBuiltins: () => [/^node:/, ...builtinModules3]
-        };
-        environment.hot.setInvokeHandler?.(handlers);
-      }
-      /** 入口：加载并执行一个模块（url 为根相对或绝对路径） */
-      async import(rawUrl) {
-        const id = this.resolveToId(rawUrl);
-        return this.instantiate(id);
-      }
-      /** 文件变更时按文件失效（含其所属的虚拟子模块） */
-      invalidateFile(file) {
-        for (const key of [...this.cache.keys()]) {
-          if (key === file || key.startsWith(file + "?")) {
-            this.cache.delete(key);
-          }
-        }
-      }
-      invalidateAll() {
-        this.cache.clear();
-      }
-      resolveToId(rawUrl) {
-        if (path15.isAbsolute(rawUrl) && fs12.existsSync(rawUrl.split("?")[0])) return rawUrl;
-        const clean = rawUrl.replace(/^\//, "");
-        return path15.resolve(this.config.root, clean);
-      }
+    own = {}.hasOwnProperty;
+    classRegExp = /^([A-Z][a-z\d]*)+$/;
+    kTypes = /* @__PURE__ */ new Set([
+      "string",
+      "function",
+      "number",
+      "object",
+      // Accept 'Function' and 'Object' as alternative to the lower cased version.
+      "Function",
+      "Object",
+      "boolean",
+      "bigint",
+      "symbol"
+    ]);
+    codes = {};
+    messages = /* @__PURE__ */ new Map();
+    nodeInternalPrefix = "__node_internal_";
+    codes.ERR_INVALID_ARG_TYPE = createError(
+      "ERR_INVALID_ARG_TYPE",
       /**
-       * fetchModule（invoke 契约方法）：环境管线产出 runner 可执行代码。
-       * resolve（插件 resolveId → 文件系统）→ load/读盘 → 插件 transform →
-       * oxc（TS/JSX）→ moduleRunnerTransform。
+       * @param {string} name
+       * @param {Array<string> | string} expected
+       * @param {unknown} actual
        */
-      async fetchModule(id, importer) {
-        if (NODE_BUILTINS3.has(id)) return { externalize: id };
-        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 : path15.resolve(path15.dirname(importer.split("?")[0]), id);
+      (name, expected, actual) => {
+        assert.ok(typeof name === "string", "'name' must be a string");
+        if (!Array.isArray(expected)) {
+          expected = [expected];
         }
-        resolvedId = this.completeExtension(resolvedId);
-        const cleanId = resolvedId.split("?")[0];
-        let code;
-        const loaded = await container.load(resolvedId);
-        if (loaded != null) {
-          code = typeof loaded === "string" ? loaded : loaded.code;
-        } else if (fs12.existsSync(cleanId)) {
-          code = fs12.readFileSync(cleanId, "utf-8");
+        let message = "The ";
+        if (name.endsWith(" argument")) {
+          message += `${name} `;
         } else {
-          throw new Error(`[nasti:ssr] cannot load module: ${resolvedId}`);
-        }
-        const transformed = await container.transform(code, resolvedId);
-        if (transformed != null) {
-          code = typeof transformed === "string" ? transformed : transformed.code;
-        }
-        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"
-          });
-          code = result.code;
+          const type = name.includes(".") ? "property" : "argument";
+          message += `"${name}" ${type} `;
         }
-        code = replaceEnvInCode(code, this.envDefine);
-        let moduleRunnerTransform;
-        try {
-          ;
-          ({ moduleRunnerTransform } = await import("rolldown/experimental"));
-        } catch (err) {
-          throw new Error(
-            `[nasti:ssr] rolldown/experimental moduleRunnerTransform unavailable (installed rolldown incompatible?): ${err.message}`
+        message += "must be ";
+        const types = [];
+        const instances = [];
+        const other = [];
+        for (const value of expected) {
+          assert.ok(
+            typeof value === "string",
+            "All expected entries have to be of type string"
           );
-        }
-        const runnerResult = await moduleRunnerTransform(resolvedId, code);
-        debug6?.(`fetchModule ${resolvedId} (${runnerResult.deps?.length ?? 0} deps)`);
-        return { id: resolvedId, code: runnerResult.code };
-      }
-      completeExtension(id) {
-        const clean = id.split("?")[0];
-        const query = id.includes("?") ? id.slice(id.indexOf("?")) : "";
-        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 (fs12.existsSync(jsMatch[1] + tsExt)) return jsMatch[1] + tsExt + query;
+          if (kTypes.has(value)) {
+            types.push(value.toLowerCase());
+          } else if (classRegExp.exec(value) === null) {
+            assert.ok(
+              value !== "object",
+              'The value "object" should be written as "Object"'
+            );
+            other.push(value);
+          } else {
+            instances.push(value);
           }
         }
-        for (const ext of this.config.resolve.extensions) {
-          if (fs12.existsSync(clean + ext)) return clean + ext + query;
+        if (instances.length > 0) {
+          const pos = types.indexOf("object");
+          if (pos !== -1) {
+            types.slice(pos, 1);
+            instances.push("Object");
+          }
         }
-        for (const ext of this.config.resolve.extensions) {
-          const indexPath = path15.join(clean, `index${ext}`);
-          if (fs12.existsSync(indexPath)) return indexPath;
+        if (types.length > 0) {
+          message += `${types.length > 1 ? "one of type" : "of type"} ${formatList(
+            types,
+            "or"
+          )}`;
+          if (instances.length > 0 || other.length > 0) message += " or ";
         }
-        return id;
-      }
-      async instantiate(id) {
-        const cached2 = this.cache.get(id);
-        if (cached2) return cached2.promise ?? Promise.resolve(cached2.exports);
-        const entry = { exports: {}, promise: null };
-        this.cache.set(id, entry);
-        entry.promise = this.evaluate(id, entry).then(() => {
-          entry.promise = null;
-          return entry.exports;
-        }).catch((err) => {
-          this.cache.delete(id);
-          throw err;
-        });
-        return entry.promise;
-      }
-      async evaluate(id, entry) {
-        const fetched = await this.fetchModule(id);
-        if ("externalize" in fetched) {
-          const spec = fetched.externalize;
-          const mod = await this.importExternal(spec);
-          entry.exports = mod;
-          return;
+        if (instances.length > 0) {
+          message += `an instance of ${formatList(instances, "or")}`;
+          if (other.length > 0) message += " or ";
         }
-        const ssrImport = async (dep) => {
-          if (NODE_BUILTINS3.has(dep) || !dep.startsWith(".") && !path15.isAbsolute(dep) && !dep.startsWith("\0")) {
-            return this.importExternal(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) => {
-          for (const key of Object.keys(sourceModule)) {
-            if (key !== "default" && !(key in entry.exports)) {
-              Object.defineProperty(entry.exports, key, {
-                enumerable: true,
-                configurable: true,
-                get: () => sourceModule[key]
-              });
-            }
+        if (other.length > 0) {
+          if (other.length > 1) {
+            message += `one of ${formatList(other, "or")}`;
+          } else {
+            if (other[0].toLowerCase() !== other[0]) message += "an ";
+            message += `${other[0]}`;
           }
-        };
-        const importMeta = {
-          url: pathToFileURL4(fetched.id.split("?")[0]).href,
-          env: { SSR: true, MODE: this.config.mode, DEV: this.config.mode !== "production", PROD: this.config.mode === "production" },
-          hot: void 0
-        };
-        const fn = new AsyncFunction(
-          "__vite_ssr_exports__",
-          "__vite_ssr_import__",
-          "__vite_ssr_dynamic_import__",
-          "__vite_ssr_exportAll__",
-          "__vite_ssr_import_meta__",
-          `"use strict";${fetched.code}
-//# sourceURL=${fetched.id}`
-        );
-        await fn(entry.exports, ssrImport, ssrImport, ssrExportAll, importMeta);
-      }
-      async importExternal(spec) {
-        try {
-          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}`);
-        }
-      }
-      /** bare specifier → 项目 node_modules 的绝对 URL（避免相对 Nasti 自身解析） */
-      resolveExternalSpecifier(spec) {
-        if (spec.startsWith("node:")) return spec;
-        if (NODE_BUILTINS3.has(spec)) return `node:${spec}`;
-        try {
-          return pathToFileURL4(this.require.resolve(spec)).href;
-        } catch {
-          return spec;
         }
-      }
-    };
-    AsyncFunction = Object.getPrototypeOf(async function() {
+        message += `. Received ${determineSpecificType(actual)}`;
+        return message;
+      },
+      TypeError
+    );
+    codes.ERR_INVALID_MODULE_SPECIFIER = createError(
+      "ERR_INVALID_MODULE_SPECIFIER",
+      /**
+       * @param {string} request
+       * @param {string} reason
+       * @param {string} [base]
+       */
+      (request, reason, base = void 0) => {
+        return `Invalid module "${request}" ${reason}${base ? ` imported from ${base}` : ""}`;
+      },
+      TypeError
+    );
+    codes.ERR_INVALID_PACKAGE_CONFIG = createError(
+      "ERR_INVALID_PACKAGE_CONFIG",
+      /**
+       * @param {string} path
+       * @param {string} [base]
+       * @param {string} [message]
+       */
+      (path23, base, message) => {
+        return `Invalid package config ${path23}${base ? ` while importing ${base}` : ""}${message ? `. ${message}` : ""}`;
+      },
+      Error
+    );
+    codes.ERR_INVALID_PACKAGE_TARGET = createError(
+      "ERR_INVALID_PACKAGE_TARGET",
+      /**
+       * @param {string} packagePath
+       * @param {string} key
+       * @param {unknown} target
+       * @param {boolean} [isImport=false]
+       * @param {string} [base]
+       */
+      (packagePath, key, target, isImport = false, base = void 0) => {
+        const relatedError = typeof target === "string" && !isImport && target.length > 0 && !target.startsWith("./");
+        if (key === ".") {
+          assert.ok(isImport === false);
+          return `Invalid "exports" main target ${JSON.stringify(target)} defined in the package config ${packagePath}package.json${base ? ` imported from ${base}` : ""}${relatedError ? '; targets must start with "./"' : ""}`;
+        }
+        return `Invalid "${isImport ? "imports" : "exports"}" target ${JSON.stringify(
+          target
+        )} defined for '${key}' in the package config ${packagePath}package.json${base ? ` imported from ${base}` : ""}${relatedError ? '; targets must start with "./"' : ""}`;
+      },
+      Error
+    );
+    codes.ERR_MODULE_NOT_FOUND = createError(
+      "ERR_MODULE_NOT_FOUND",
+      /**
+       * @param {string} path
+       * @param {string} base
+       * @param {boolean} [exactUrl]
+       */
+      (path23, base, exactUrl = false) => {
+        return `Cannot find ${exactUrl ? "module" : "package"} '${path23}' imported from ${base}`;
+      },
+      Error
+    );
+    codes.ERR_NETWORK_IMPORT_DISALLOWED = createError(
+      "ERR_NETWORK_IMPORT_DISALLOWED",
+      "import of '%s' by %s is not supported: %s",
+      Error
+    );
+    codes.ERR_PACKAGE_IMPORT_NOT_DEFINED = createError(
+      "ERR_PACKAGE_IMPORT_NOT_DEFINED",
+      /**
+       * @param {string} specifier
+       * @param {string} packagePath
+       * @param {string} base
+       */
+      (specifier, packagePath, base) => {
+        return `Package import specifier "${specifier}" is not defined${packagePath ? ` in package ${packagePath}package.json` : ""} imported from ${base}`;
+      },
+      TypeError
+    );
+    codes.ERR_PACKAGE_PATH_NOT_EXPORTED = createError(
+      "ERR_PACKAGE_PATH_NOT_EXPORTED",
+      /**
+       * @param {string} packagePath
+       * @param {string} subpath
+       * @param {string} [base]
+       */
+      (packagePath, subpath, base = void 0) => {
+        if (subpath === ".")
+          return `No "exports" main defined in ${packagePath}package.json${base ? ` imported from ${base}` : ""}`;
+        return `Package subpath '${subpath}' is not defined by "exports" in ${packagePath}package.json${base ? ` imported from ${base}` : ""}`;
+      },
+      Error
+    );
+    codes.ERR_UNSUPPORTED_DIR_IMPORT = createError(
+      "ERR_UNSUPPORTED_DIR_IMPORT",
+      "Directory import '%s' is not supported resolving ES modules imported from %s",
+      Error
+    );
+    codes.ERR_UNSUPPORTED_RESOLVE_REQUEST = createError(
+      "ERR_UNSUPPORTED_RESOLVE_REQUEST",
+      'Failed to resolve module specifier "%s" from "%s": Invalid relative URL or base scheme is not hierarchical.',
+      TypeError
+    );
+    codes.ERR_UNKNOWN_FILE_EXTENSION = createError(
+      "ERR_UNKNOWN_FILE_EXTENSION",
+      /**
+       * @param {string} extension
+       * @param {string} path
+       */
+      (extension, path23) => {
+        return `Unknown file extension "${extension}" for ${path23}`;
+      },
+      TypeError
+    );
+    codes.ERR_INVALID_ARG_VALUE = createError(
+      "ERR_INVALID_ARG_VALUE",
+      /**
+       * @param {string} name
+       * @param {unknown} value
+       * @param {string} [reason='is invalid']
+       */
+      (name, value, reason = "is invalid") => {
+        let inspected = inspect(value);
+        if (inspected.length > 128) {
+          inspected = `${inspected.slice(0, 128)}...`;
+        }
+        const type = name.includes(".") ? "property" : "argument";
+        return `The ${type} '${name}' ${reason}. Received ${inspected}`;
+      },
+      TypeError
+      // Note: extra classes have been shaken out.
+      // , RangeError
+    );
+    captureLargerStackTrace = hideStackFrames(
+      /**
+       * @param {Error} error
+       * @returns {Error}
+       */
+      // @ts-expect-error: fine
+      function(error) {
+        const stackTraceLimitIsWritable = isErrorStackTraceLimitWritable();
+        if (stackTraceLimitIsWritable) {
+          userStackTraceLimit = Error.stackTraceLimit;
+          Error.stackTraceLimit = Number.POSITIVE_INFINITY;
+        }
+        Error.captureStackTrace(error);
+        if (stackTraceLimitIsWritable) Error.stackTraceLimit = userStackTraceLimit;
+        return error;
+      }
+    );
+  }
+});
+
+// node_modules/import-meta-resolve/lib/package-json-reader.js
+import fs12 from "fs";
+import path15 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+function read(jsonPath, { base, specifier }) {
+  const existing = cache.get(jsonPath);
+  if (existing) {
+    return existing;
+  }
+  let string;
+  try {
+    string = fs12.readFileSync(path15.toNamespacedPath(jsonPath), "utf8");
+  } catch (error) {
+    const exception = (
+      /** @type {ErrnoException} */
+      error
+    );
+    if (exception.code !== "ENOENT") {
+      throw exception;
+    }
+  }
+  const result = {
+    exists: false,
+    pjsonPath: jsonPath,
+    main: void 0,
+    name: void 0,
+    type: "none",
+    // Ignore unknown types for forwards compatibility
+    exports: void 0,
+    imports: void 0
+  };
+  if (string !== void 0) {
+    let parsed;
+    try {
+      parsed = JSON.parse(string);
+    } catch (error_) {
+      const cause = (
+        /** @type {ErrnoException} */
+        error_
+      );
+      const error = new ERR_INVALID_PACKAGE_CONFIG(
+        jsonPath,
+        (base ? `"${specifier}" from ` : "") + fileURLToPath2(base || specifier),
+        cause.message
+      );
+      error.cause = cause;
+      throw error;
+    }
+    result.exists = true;
+    if (hasOwnProperty.call(parsed, "name") && typeof parsed.name === "string") {
+      result.name = parsed.name;
+    }
+    if (hasOwnProperty.call(parsed, "main") && typeof parsed.main === "string") {
+      result.main = parsed.main;
+    }
+    if (hasOwnProperty.call(parsed, "exports")) {
+      result.exports = parsed.exports;
+    }
+    if (hasOwnProperty.call(parsed, "imports")) {
+      result.imports = parsed.imports;
+    }
+    if (hasOwnProperty.call(parsed, "type") && (parsed.type === "commonjs" || parsed.type === "module")) {
+      result.type = parsed.type;
+    }
+  }
+  cache.set(jsonPath, result);
+  return result;
+}
+function getPackageScopeConfig(resolved) {
+  let packageJSONUrl = new URL("package.json", resolved);
+  while (true) {
+    const packageJSONPath2 = packageJSONUrl.pathname;
+    if (packageJSONPath2.endsWith("node_modules/package.json")) {
+      break;
+    }
+    const packageConfig = read(fileURLToPath2(packageJSONUrl), {
+      specifier: resolved
+    });
+    if (packageConfig.exists) {
+      return packageConfig;
+    }
+    const lastPackageJSONUrl = packageJSONUrl;
+    packageJSONUrl = new URL("../package.json", packageJSONUrl);
+    if (packageJSONUrl.pathname === lastPackageJSONUrl.pathname) {
+      break;
+    }
+  }
+  const packageJSONPath = fileURLToPath2(packageJSONUrl);
+  return {
+    pjsonPath: packageJSONPath,
+    exists: false,
+    type: "none"
+  };
+}
+function getPackageType(url) {
+  return getPackageScopeConfig(url).type;
+}
+var hasOwnProperty, ERR_INVALID_PACKAGE_CONFIG, cache;
+var init_package_json_reader = __esm({
+  "node_modules/import-meta-resolve/lib/package-json-reader.js"() {
+    "use strict";
+    init_errors();
+    hasOwnProperty = {}.hasOwnProperty;
+    ({ ERR_INVALID_PACKAGE_CONFIG } = codes);
+    cache = /* @__PURE__ */ new Map();
+  }
+});
+
+// node_modules/import-meta-resolve/lib/get-format.js
+import { fileURLToPath as fileURLToPath3 } from "url";
+function mimeToFormat(mime) {
+  if (mime && /\s*(text|application)\/javascript\s*(;\s*charset=utf-?8\s*)?/i.test(mime))
+    return "module";
+  if (mime === "application/json") return "json";
+  return null;
+}
+function getDataProtocolModuleFormat(parsed) {
+  const { 1: mime } = /^([^/]+\/[^;,]+)[^,]*?(;base64)?,/.exec(
+    parsed.pathname
+  ) || [null, null, null];
+  return mimeToFormat(mime);
+}
+function extname(url) {
+  const pathname = url.pathname;
+  let index2 = pathname.length;
+  while (index2--) {
+    const code = pathname.codePointAt(index2);
+    if (code === 47) {
+      return "";
+    }
+    if (code === 46) {
+      return pathname.codePointAt(index2 - 1) === 47 ? "" : pathname.slice(index2);
+    }
+  }
+  return "";
+}
+function getFileProtocolModuleFormat(url, _context, ignoreErrors) {
+  const value = extname(url);
+  if (value === ".js") {
+    const packageType = getPackageType(url);
+    if (packageType !== "none") {
+      return packageType;
+    }
+    return "commonjs";
+  }
+  if (value === "") {
+    const packageType = getPackageType(url);
+    if (packageType === "none" || packageType === "commonjs") {
+      return "commonjs";
+    }
+    return "module";
+  }
+  const format2 = extensionFormatMap[value];
+  if (format2) return format2;
+  if (ignoreErrors) {
+    return void 0;
+  }
+  const filepath = fileURLToPath3(url);
+  throw new ERR_UNKNOWN_FILE_EXTENSION(value, filepath);
+}
+function getHttpProtocolModuleFormat() {
+}
+function defaultGetFormatWithoutErrors(url, context) {
+  const protocol = url.protocol;
+  if (!hasOwnProperty2.call(protocolHandlers, protocol)) {
+    return null;
+  }
+  return protocolHandlers[protocol](url, context, true) || null;
+}
+var ERR_UNKNOWN_FILE_EXTENSION, hasOwnProperty2, extensionFormatMap, protocolHandlers;
+var init_get_format = __esm({
+  "node_modules/import-meta-resolve/lib/get-format.js"() {
+    "use strict";
+    init_package_json_reader();
+    init_errors();
+    ({ ERR_UNKNOWN_FILE_EXTENSION } = codes);
+    hasOwnProperty2 = {}.hasOwnProperty;
+    extensionFormatMap = {
+      // @ts-expect-error: hush.
+      __proto__: null,
+      ".cjs": "commonjs",
+      ".js": "module",
+      ".json": "json",
+      ".mjs": "module"
+    };
+    protocolHandlers = {
+      // @ts-expect-error: hush.
+      __proto__: null,
+      "data:": getDataProtocolModuleFormat,
+      "file:": getFileProtocolModuleFormat,
+      "http:": getHttpProtocolModuleFormat,
+      "https:": getHttpProtocolModuleFormat,
+      "node:"() {
+        return "builtin";
+      }
+    };
+  }
+});
+
+// node_modules/import-meta-resolve/lib/utils.js
+function getDefaultConditions() {
+  return DEFAULT_CONDITIONS;
+}
+function getDefaultConditionsSet() {
+  return DEFAULT_CONDITIONS_SET;
+}
+function getConditionsSet(conditions) {
+  if (conditions !== void 0 && conditions !== getDefaultConditions()) {
+    if (!Array.isArray(conditions)) {
+      throw new ERR_INVALID_ARG_VALUE(
+        "conditions",
+        conditions,
+        "expected an array"
+      );
+    }
+    return new Set(conditions);
+  }
+  return getDefaultConditionsSet();
+}
+var ERR_INVALID_ARG_VALUE, DEFAULT_CONDITIONS, DEFAULT_CONDITIONS_SET;
+var init_utils = __esm({
+  "node_modules/import-meta-resolve/lib/utils.js"() {
+    "use strict";
+    init_errors();
+    ({ ERR_INVALID_ARG_VALUE } = codes);
+    DEFAULT_CONDITIONS = Object.freeze(["node", "import"]);
+    DEFAULT_CONDITIONS_SET = new Set(DEFAULT_CONDITIONS);
+  }
+});
+
+// node_modules/import-meta-resolve/lib/resolve.js
+import assert2 from "assert";
+import { statSync, realpathSync } from "fs";
+import process2 from "process";
+import { fileURLToPath as fileURLToPath4, pathToFileURL as pathToFileURL4 } from "url";
+import path16 from "path";
+import { builtinModules as builtinModules3 } from "module";
+function emitInvalidSegmentDeprecation(target, request, match, packageJsonUrl, internal, base, isTarget) {
+  if (process2.noDeprecation) {
+    return;
+  }
+  const pjsonPath = fileURLToPath4(packageJsonUrl);
+  const double = doubleSlashRegEx.exec(isTarget ? target : request) !== null;
+  process2.emitWarning(
+    `Use of deprecated ${double ? "double slash" : "leading or trailing slash matching"} resolving "${target}" for module request "${request}" ${request === match ? "" : `matched to "${match}" `}in the "${internal ? "imports" : "exports"}" field module resolution of the package at ${pjsonPath}${base ? ` imported from ${fileURLToPath4(base)}` : ""}.`,
+    "DeprecationWarning",
+    "DEP0166"
+  );
+}
+function emitLegacyIndexDeprecation(url, packageJsonUrl, base, main) {
+  if (process2.noDeprecation) {
+    return;
+  }
+  const format2 = defaultGetFormatWithoutErrors(url, { parentURL: base.href });
+  if (format2 !== "module") return;
+  const urlPath = fileURLToPath4(url.href);
+  const packagePath = fileURLToPath4(new URL(".", packageJsonUrl));
+  const basePath = fileURLToPath4(base);
+  if (!main) {
+    process2.emitWarning(
+      `No "main" or "exports" field defined in the package.json for ${packagePath} resolving the main entry point "${urlPath.slice(
+        packagePath.length
+      )}", imported from ${basePath}.
+Default "index" lookups for the main are deprecated for ES modules.`,
+      "DeprecationWarning",
+      "DEP0151"
+    );
+  } else if (path16.resolve(packagePath, main) !== urlPath) {
+    process2.emitWarning(
+      `Package ${packagePath} has a "main" field set to "${main}", excluding the full filename and extension to the resolved file at "${urlPath.slice(
+        packagePath.length
+      )}", imported from ${basePath}.
+ Automatic extension resolution of the "main" field is deprecated for ES modules.`,
+      "DeprecationWarning",
+      "DEP0151"
+    );
+  }
+}
+function tryStatSync(path23) {
+  try {
+    return statSync(path23);
+  } catch {
+  }
+}
+function fileExists(url) {
+  const stats = statSync(url, { throwIfNoEntry: false });
+  const isFile = stats ? stats.isFile() : void 0;
+  return isFile === null || isFile === void 0 ? false : isFile;
+}
+function legacyMainResolve(packageJsonUrl, packageConfig, base) {
+  let guess;
+  if (packageConfig.main !== void 0) {
+    guess = new URL(packageConfig.main, packageJsonUrl);
+    if (fileExists(guess)) return guess;
+    const tries2 = [
+      `./${packageConfig.main}.js`,
+      `./${packageConfig.main}.json`,
+      `./${packageConfig.main}.node`,
+      `./${packageConfig.main}/index.js`,
+      `./${packageConfig.main}/index.json`,
+      `./${packageConfig.main}/index.node`
+    ];
+    let i2 = -1;
+    while (++i2 < tries2.length) {
+      guess = new URL(tries2[i2], packageJsonUrl);
+      if (fileExists(guess)) break;
+      guess = void 0;
+    }
+    if (guess) {
+      emitLegacyIndexDeprecation(
+        guess,
+        packageJsonUrl,
+        base,
+        packageConfig.main
+      );
+      return guess;
+    }
+  }
+  const tries = ["./index.js", "./index.json", "./index.node"];
+  let i = -1;
+  while (++i < tries.length) {
+    guess = new URL(tries[i], packageJsonUrl);
+    if (fileExists(guess)) break;
+    guess = void 0;
+  }
+  if (guess) {
+    emitLegacyIndexDeprecation(guess, packageJsonUrl, base, packageConfig.main);
+    return guess;
+  }
+  throw new ERR_MODULE_NOT_FOUND(
+    fileURLToPath4(new URL(".", packageJsonUrl)),
+    fileURLToPath4(base)
+  );
+}
+function finalizeResolution(resolved, base, preserveSymlinks) {
+  if (encodedSeparatorRegEx.exec(resolved.pathname) !== null) {
+    throw new ERR_INVALID_MODULE_SPECIFIER(
+      resolved.pathname,
+      'must not include encoded "/" or "\\" characters',
+      fileURLToPath4(base)
+    );
+  }
+  let filePath;
+  try {
+    filePath = fileURLToPath4(resolved);
+  } catch (error) {
+    const cause = (
+      /** @type {ErrnoException} */
+      error
+    );
+    Object.defineProperty(cause, "input", { value: String(resolved) });
+    Object.defineProperty(cause, "module", { value: String(base) });
+    throw cause;
+  }
+  const stats = tryStatSync(
+    filePath.endsWith("/") ? filePath.slice(-1) : filePath
+  );
+  if (stats && stats.isDirectory()) {
+    const error = new ERR_UNSUPPORTED_DIR_IMPORT(filePath, fileURLToPath4(base));
+    error.url = String(resolved);
+    throw error;
+  }
+  if (!stats || !stats.isFile()) {
+    const error = new ERR_MODULE_NOT_FOUND(
+      filePath || resolved.pathname,
+      base && fileURLToPath4(base),
+      true
+    );
+    error.url = String(resolved);
+    throw error;
+  }
+  if (!preserveSymlinks) {
+    const real = realpathSync(filePath);
+    const { search, hash } = resolved;
+    resolved = pathToFileURL4(real + (filePath.endsWith(path16.sep) ? "/" : ""));
+    resolved.search = search;
+    resolved.hash = hash;
+  }
+  return resolved;
+}
+function importNotDefined(specifier, packageJsonUrl, base) {
+  return new ERR_PACKAGE_IMPORT_NOT_DEFINED(
+    specifier,
+    packageJsonUrl && fileURLToPath4(new URL(".", packageJsonUrl)),
+    fileURLToPath4(base)
+  );
+}
+function exportsNotFound(subpath, packageJsonUrl, base) {
+  return new ERR_PACKAGE_PATH_NOT_EXPORTED(
+    fileURLToPath4(new URL(".", packageJsonUrl)),
+    subpath,
+    base && fileURLToPath4(base)
+  );
+}
+function throwInvalidSubpath(request, match, packageJsonUrl, internal, base) {
+  const reason = `request is not a valid match in pattern "${match}" for the "${internal ? "imports" : "exports"}" resolution of ${fileURLToPath4(packageJsonUrl)}`;
+  throw new ERR_INVALID_MODULE_SPECIFIER(
+    request,
+    reason,
+    base && fileURLToPath4(base)
+  );
+}
+function invalidPackageTarget(subpath, target, packageJsonUrl, internal, base) {
+  target = typeof target === "object" && target !== null ? JSON.stringify(target, null, "") : `${target}`;
+  return new ERR_INVALID_PACKAGE_TARGET(
+    fileURLToPath4(new URL(".", packageJsonUrl)),
+    subpath,
+    target,
+    internal,
+    base && fileURLToPath4(base)
+  );
+}
+function resolvePackageTargetString(target, subpath, match, packageJsonUrl, base, pattern, internal, isPathMap, conditions) {
+  if (subpath !== "" && !pattern && target[target.length - 1] !== "/")
+    throw invalidPackageTarget(match, target, packageJsonUrl, internal, base);
+  if (!target.startsWith("./")) {
+    if (internal && !target.startsWith("../") && !target.startsWith("/")) {
+      let isURL = false;
+      try {
+        new URL(target);
+        isURL = true;
+      } catch {
+      }
+      if (!isURL) {
+        const exportTarget = pattern ? RegExpPrototypeSymbolReplace.call(
+          patternRegEx,
+          target,
+          () => subpath
+        ) : target + subpath;
+        return packageResolve(exportTarget, packageJsonUrl, conditions);
+      }
+    }
+    throw invalidPackageTarget(match, target, packageJsonUrl, internal, base);
+  }
+  if (invalidSegmentRegEx.exec(target.slice(2)) !== null) {
+    if (deprecatedInvalidSegmentRegEx.exec(target.slice(2)) === null) {
+      if (!isPathMap) {
+        const request = pattern ? match.replace("*", () => subpath) : match + subpath;
+        const resolvedTarget = pattern ? RegExpPrototypeSymbolReplace.call(
+          patternRegEx,
+          target,
+          () => subpath
+        ) : target;
+        emitInvalidSegmentDeprecation(
+          resolvedTarget,
+          request,
+          match,
+          packageJsonUrl,
+          internal,
+          base,
+          true
+        );
+      }
+    } else {
+      throw invalidPackageTarget(match, target, packageJsonUrl, internal, base);
+    }
+  }
+  const resolved = new URL(target, packageJsonUrl);
+  const resolvedPath = resolved.pathname;
+  const packagePath = new URL(".", packageJsonUrl).pathname;
+  if (!resolvedPath.startsWith(packagePath))
+    throw invalidPackageTarget(match, target, packageJsonUrl, internal, base);
+  if (subpath === "") return resolved;
+  if (invalidSegmentRegEx.exec(subpath) !== null) {
+    const request = pattern ? match.replace("*", () => subpath) : match + subpath;
+    if (deprecatedInvalidSegmentRegEx.exec(subpath) === null) {
+      if (!isPathMap) {
+        const resolvedTarget = pattern ? RegExpPrototypeSymbolReplace.call(
+          patternRegEx,
+          target,
+          () => subpath
+        ) : target;
+        emitInvalidSegmentDeprecation(
+          resolvedTarget,
+          request,
+          match,
+          packageJsonUrl,
+          internal,
+          base,
+          false
+        );
+      }
+    } else {
+      throwInvalidSubpath(request, match, packageJsonUrl, internal, base);
+    }
+  }
+  if (pattern) {
+    return new URL(
+      RegExpPrototypeSymbolReplace.call(
+        patternRegEx,
+        resolved.href,
+        () => subpath
+      )
+    );
+  }
+  return new URL(subpath, resolved);
+}
+function isArrayIndex(key) {
+  const keyNumber = Number(key);
+  if (`${keyNumber}` !== key) return false;
+  return keyNumber >= 0 && keyNumber < 4294967295;
+}
+function resolvePackageTarget(packageJsonUrl, target, subpath, packageSubpath, base, pattern, internal, isPathMap, conditions) {
+  if (typeof target === "string") {
+    return resolvePackageTargetString(
+      target,
+      subpath,
+      packageSubpath,
+      packageJsonUrl,
+      base,
+      pattern,
+      internal,
+      isPathMap,
+      conditions
+    );
+  }
+  if (Array.isArray(target)) {
+    const targetList = target;
+    if (targetList.length === 0) return null;
+    let lastException;
+    let i = -1;
+    while (++i < targetList.length) {
+      const targetItem = targetList[i];
+      let resolveResult;
+      try {
+        resolveResult = resolvePackageTarget(
+          packageJsonUrl,
+          targetItem,
+          subpath,
+          packageSubpath,
+          base,
+          pattern,
+          internal,
+          isPathMap,
+          conditions
+        );
+      } catch (error) {
+        const exception = (
+          /** @type {ErrnoException} */
+          error
+        );
+        lastException = exception;
+        if (exception.code === "ERR_INVALID_PACKAGE_TARGET") continue;
+        throw error;
+      }
+      if (resolveResult === void 0) continue;
+      if (resolveResult === null) {
+        lastException = null;
+        continue;
+      }
+      return resolveResult;
+    }
+    if (lastException === void 0 || lastException === null) {
+      return null;
+    }
+    throw lastException;
+  }
+  if (typeof target === "object" && target !== null) {
+    const keys = Object.getOwnPropertyNames(target);
+    let i = -1;
+    while (++i < keys.length) {
+      const key = keys[i];
+      if (isArrayIndex(key)) {
+        throw new ERR_INVALID_PACKAGE_CONFIG2(
+          fileURLToPath4(packageJsonUrl),
+          base,
+          '"exports" cannot contain numeric property keys.'
+        );
+      }
+    }
+    i = -1;
+    while (++i < keys.length) {
+      const key = keys[i];
+      if (key === "default" || conditions && conditions.has(key)) {
+        const conditionalTarget = (
+          /** @type {unknown} */
+          target[key]
+        );
+        const resolveResult = resolvePackageTarget(
+          packageJsonUrl,
+          conditionalTarget,
+          subpath,
+          packageSubpath,
+          base,
+          pattern,
+          internal,
+          isPathMap,
+          conditions
+        );
+        if (resolveResult === void 0) continue;
+        return resolveResult;
+      }
+    }
+    return null;
+  }
+  if (target === null) {
+    return null;
+  }
+  throw invalidPackageTarget(
+    packageSubpath,
+    target,
+    packageJsonUrl,
+    internal,
+    base
+  );
+}
+function isConditionalExportsMainSugar(exports, packageJsonUrl, base) {
+  if (typeof exports === "string" || Array.isArray(exports)) return true;
+  if (typeof exports !== "object" || exports === null) return false;
+  const keys = Object.getOwnPropertyNames(exports);
+  let isConditionalSugar = false;
+  let i = 0;
+  let keyIndex = -1;
+  while (++keyIndex < keys.length) {
+    const key = keys[keyIndex];
+    const currentIsConditionalSugar = key === "" || key[0] !== ".";
+    if (i++ === 0) {
+      isConditionalSugar = currentIsConditionalSugar;
+    } else if (isConditionalSugar !== currentIsConditionalSugar) {
+      throw new ERR_INVALID_PACKAGE_CONFIG2(
+        fileURLToPath4(packageJsonUrl),
+        base,
+        `"exports" cannot contain some keys starting with '.' and some not. The exports object must either be an object of package subpath keys or an object of main entry condition name keys only.`
+      );
+    }
+  }
+  return isConditionalSugar;
+}
+function emitTrailingSlashPatternDeprecation(match, pjsonUrl, base) {
+  if (process2.noDeprecation) {
+    return;
+  }
+  const pjsonPath = fileURLToPath4(pjsonUrl);
+  if (emittedPackageWarnings.has(pjsonPath + "|" + match)) return;
+  emittedPackageWarnings.add(pjsonPath + "|" + match);
+  process2.emitWarning(
+    `Use of deprecated trailing slash pattern mapping "${match}" in the "exports" field module resolution of the package at ${pjsonPath}${base ? ` imported from ${fileURLToPath4(base)}` : ""}. Mapping specifiers ending in "/" is no longer supported.`,
+    "DeprecationWarning",
+    "DEP0155"
+  );
+}
+function packageExportsResolve(packageJsonUrl, packageSubpath, packageConfig, base, conditions) {
+  let exports = packageConfig.exports;
+  if (isConditionalExportsMainSugar(exports, packageJsonUrl, base)) {
+    exports = { ".": exports };
+  }
+  if (own2.call(exports, packageSubpath) && !packageSubpath.includes("*") && !packageSubpath.endsWith("/")) {
+    const target = exports[packageSubpath];
+    const resolveResult = resolvePackageTarget(
+      packageJsonUrl,
+      target,
+      "",
+      packageSubpath,
+      base,
+      false,
+      false,
+      false,
+      conditions
+    );
+    if (resolveResult === null || resolveResult === void 0) {
+      throw exportsNotFound(packageSubpath, packageJsonUrl, base);
+    }
+    return resolveResult;
+  }
+  let bestMatch = "";
+  let bestMatchSubpath = "";
+  const keys = Object.getOwnPropertyNames(exports);
+  let i = -1;
+  while (++i < keys.length) {
+    const key = keys[i];
+    const patternIndex = key.indexOf("*");
+    if (patternIndex !== -1 && packageSubpath.startsWith(key.slice(0, patternIndex))) {
+      if (packageSubpath.endsWith("/")) {
+        emitTrailingSlashPatternDeprecation(
+          packageSubpath,
+          packageJsonUrl,
+          base
+        );
+      }
+      const patternTrailer = key.slice(patternIndex + 1);
+      if (packageSubpath.length >= key.length && packageSubpath.endsWith(patternTrailer) && patternKeyCompare(bestMatch, key) === 1 && key.lastIndexOf("*") === patternIndex) {
+        bestMatch = key;
+        bestMatchSubpath = packageSubpath.slice(
+          patternIndex,
+          packageSubpath.length - patternTrailer.length
+        );
+      }
+    }
+  }
+  if (bestMatch) {
+    const target = (
+      /** @type {unknown} */
+      exports[bestMatch]
+    );
+    const resolveResult = resolvePackageTarget(
+      packageJsonUrl,
+      target,
+      bestMatchSubpath,
+      bestMatch,
+      base,
+      true,
+      false,
+      packageSubpath.endsWith("/"),
+      conditions
+    );
+    if (resolveResult === null || resolveResult === void 0) {
+      throw exportsNotFound(packageSubpath, packageJsonUrl, base);
+    }
+    return resolveResult;
+  }
+  throw exportsNotFound(packageSubpath, packageJsonUrl, base);
+}
+function patternKeyCompare(a, b) {
+  const aPatternIndex = a.indexOf("*");
+  const bPatternIndex = b.indexOf("*");
+  const baseLengthA = aPatternIndex === -1 ? a.length : aPatternIndex + 1;
+  const baseLengthB = bPatternIndex === -1 ? b.length : bPatternIndex + 1;
+  if (baseLengthA > baseLengthB) return -1;
+  if (baseLengthB > baseLengthA) return 1;
+  if (aPatternIndex === -1) return 1;
+  if (bPatternIndex === -1) return -1;
+  if (a.length > b.length) return -1;
+  if (b.length > a.length) return 1;
+  return 0;
+}
+function packageImportsResolve(name, base, conditions) {
+  if (name === "#" || name.startsWith("#/") || name.endsWith("/")) {
+    const reason = "is not a valid internal imports specifier name";
+    throw new ERR_INVALID_MODULE_SPECIFIER(name, reason, fileURLToPath4(base));
+  }
+  let packageJsonUrl;
+  const packageConfig = getPackageScopeConfig(base);
+  if (packageConfig.exists) {
+    packageJsonUrl = pathToFileURL4(packageConfig.pjsonPath);
+    const imports = packageConfig.imports;
+    if (imports) {
+      if (own2.call(imports, name) && !name.includes("*")) {
+        const resolveResult = resolvePackageTarget(
+          packageJsonUrl,
+          imports[name],
+          "",
+          name,
+          base,
+          false,
+          true,
+          false,
+          conditions
+        );
+        if (resolveResult !== null && resolveResult !== void 0) {
+          return resolveResult;
+        }
+      } else {
+        let bestMatch = "";
+        let bestMatchSubpath = "";
+        const keys = Object.getOwnPropertyNames(imports);
+        let i = -1;
+        while (++i < keys.length) {
+          const key = keys[i];
+          const patternIndex = key.indexOf("*");
+          if (patternIndex !== -1 && name.startsWith(key.slice(0, -1))) {
+            const patternTrailer = key.slice(patternIndex + 1);
+            if (name.length >= key.length && name.endsWith(patternTrailer) && patternKeyCompare(bestMatch, key) === 1 && key.lastIndexOf("*") === patternIndex) {
+              bestMatch = key;
+              bestMatchSubpath = name.slice(
+                patternIndex,
+                name.length - patternTrailer.length
+              );
+            }
+          }
+        }
+        if (bestMatch) {
+          const target = imports[bestMatch];
+          const resolveResult = resolvePackageTarget(
+            packageJsonUrl,
+            target,
+            bestMatchSubpath,
+            bestMatch,
+            base,
+            true,
+            true,
+            false,
+            conditions
+          );
+          if (resolveResult !== null && resolveResult !== void 0) {
+            return resolveResult;
+          }
+        }
+      }
+    }
+  }
+  throw importNotDefined(name, packageJsonUrl, base);
+}
+function parsePackageName(specifier, base) {
+  let separatorIndex = specifier.indexOf("/");
+  let validPackageName = true;
+  let isScoped = false;
+  if (specifier[0] === "@") {
+    isScoped = true;
+    if (separatorIndex === -1 || specifier.length === 0) {
+      validPackageName = false;
+    } else {
+      separatorIndex = specifier.indexOf("/", separatorIndex + 1);
+    }
+  }
+  const packageName = separatorIndex === -1 ? specifier : specifier.slice(0, separatorIndex);
+  if (invalidPackageNameRegEx.exec(packageName) !== null) {
+    validPackageName = false;
+  }
+  if (!validPackageName) {
+    throw new ERR_INVALID_MODULE_SPECIFIER(
+      specifier,
+      "is not a valid package name",
+      fileURLToPath4(base)
+    );
+  }
+  const packageSubpath = "." + (separatorIndex === -1 ? "" : specifier.slice(separatorIndex));
+  return { packageName, packageSubpath, isScoped };
+}
+function packageResolve(specifier, base, conditions) {
+  if (builtinModules3.includes(specifier)) {
+    return new URL("node:" + specifier);
+  }
+  const { packageName, packageSubpath, isScoped } = parsePackageName(
+    specifier,
+    base
+  );
+  const packageConfig = getPackageScopeConfig(base);
+  if (packageConfig.exists) {
+    const packageJsonUrl2 = pathToFileURL4(packageConfig.pjsonPath);
+    if (packageConfig.name === packageName && packageConfig.exports !== void 0 && packageConfig.exports !== null) {
+      return packageExportsResolve(
+        packageJsonUrl2,
+        packageSubpath,
+        packageConfig,
+        base,
+        conditions
+      );
+    }
+  }
+  let packageJsonUrl = new URL(
+    "./node_modules/" + packageName + "/package.json",
+    base
+  );
+  let packageJsonPath = fileURLToPath4(packageJsonUrl);
+  let lastPath;
+  do {
+    const stat = tryStatSync(packageJsonPath.slice(0, -13));
+    if (!stat || !stat.isDirectory()) {
+      lastPath = packageJsonPath;
+      packageJsonUrl = new URL(
+        (isScoped ? "../../../../node_modules/" : "../../../node_modules/") + packageName + "/package.json",
+        packageJsonUrl
+      );
+      packageJsonPath = fileURLToPath4(packageJsonUrl);
+      continue;
+    }
+    const packageConfig2 = read(packageJsonPath, { base, specifier });
+    if (packageConfig2.exports !== void 0 && packageConfig2.exports !== null) {
+      return packageExportsResolve(
+        packageJsonUrl,
+        packageSubpath,
+        packageConfig2,
+        base,
+        conditions
+      );
+    }
+    if (packageSubpath === ".") {
+      return legacyMainResolve(packageJsonUrl, packageConfig2, base);
+    }
+    return new URL(packageSubpath, packageJsonUrl);
+  } while (packageJsonPath.length !== lastPath.length);
+  throw new ERR_MODULE_NOT_FOUND(packageName, fileURLToPath4(base), false);
+}
+function isRelativeSpecifier(specifier) {
+  if (specifier[0] === ".") {
+    if (specifier.length === 1 || specifier[1] === "/") return true;
+    if (specifier[1] === "." && (specifier.length === 2 || specifier[2] === "/")) {
+      return true;
+    }
+  }
+  return false;
+}
+function shouldBeTreatedAsRelativeOrAbsolutePath(specifier) {
+  if (specifier === "") return false;
+  if (specifier[0] === "/") return true;
+  return isRelativeSpecifier(specifier);
+}
+function moduleResolve(specifier, base, conditions, preserveSymlinks) {
+  if (conditions === void 0) {
+    conditions = getConditionsSet();
+  }
+  const protocol = base.protocol;
+  const isData = protocol === "data:";
+  const isRemote = isData || protocol === "http:" || protocol === "https:";
+  let resolved;
+  if (shouldBeTreatedAsRelativeOrAbsolutePath(specifier)) {
+    try {
+      resolved = new URL(specifier, base);
+    } catch (error_) {
+      const error = new ERR_UNSUPPORTED_RESOLVE_REQUEST(specifier, base);
+      error.cause = error_;
+      throw error;
+    }
+  } else if (protocol === "file:" && specifier[0] === "#") {
+    resolved = packageImportsResolve(specifier, base, conditions);
+  } else {
+    try {
+      resolved = new URL(specifier);
+    } catch (error_) {
+      if (isRemote && !builtinModules3.includes(specifier)) {
+        const error = new ERR_UNSUPPORTED_RESOLVE_REQUEST(specifier, base);
+        error.cause = error_;
+        throw error;
+      }
+      resolved = packageResolve(specifier, base, conditions);
+    }
+  }
+  assert2.ok(resolved !== void 0, "expected to be defined");
+  if (resolved.protocol !== "file:") {
+    return resolved;
+  }
+  return finalizeResolution(resolved, base, preserveSymlinks);
+}
+var RegExpPrototypeSymbolReplace, ERR_NETWORK_IMPORT_DISALLOWED, ERR_INVALID_MODULE_SPECIFIER, ERR_INVALID_PACKAGE_CONFIG2, ERR_INVALID_PACKAGE_TARGET, ERR_MODULE_NOT_FOUND, ERR_PACKAGE_IMPORT_NOT_DEFINED, ERR_PACKAGE_PATH_NOT_EXPORTED, ERR_UNSUPPORTED_DIR_IMPORT, ERR_UNSUPPORTED_RESOLVE_REQUEST, own2, invalidSegmentRegEx, deprecatedInvalidSegmentRegEx, invalidPackageNameRegEx, patternRegEx, encodedSeparatorRegEx, emittedPackageWarnings, doubleSlashRegEx;
+var init_resolve2 = __esm({
+  "node_modules/import-meta-resolve/lib/resolve.js"() {
+    "use strict";
+    init_get_format();
+    init_errors();
+    init_package_json_reader();
+    init_utils();
+    RegExpPrototypeSymbolReplace = RegExp.prototype[Symbol.replace];
+    ({
+      ERR_NETWORK_IMPORT_DISALLOWED,
+      ERR_INVALID_MODULE_SPECIFIER,
+      ERR_INVALID_PACKAGE_CONFIG: ERR_INVALID_PACKAGE_CONFIG2,
+      ERR_INVALID_PACKAGE_TARGET,
+      ERR_MODULE_NOT_FOUND,
+      ERR_PACKAGE_IMPORT_NOT_DEFINED,
+      ERR_PACKAGE_PATH_NOT_EXPORTED,
+      ERR_UNSUPPORTED_DIR_IMPORT,
+      ERR_UNSUPPORTED_RESOLVE_REQUEST
+    } = codes);
+    own2 = {}.hasOwnProperty;
+    invalidSegmentRegEx = /(^|\\|\/)((\.|%2e)(\.|%2e)?|(n|%6e|%4e)(o|%6f|%4f)(d|%64|%44)(e|%65|%45)(_|%5f)(m|%6d|%4d)(o|%6f|%4f)(d|%64|%44)(u|%75|%55)(l|%6c|%4c)(e|%65|%45)(s|%73|%53))?(\\|\/|$)/i;
+    deprecatedInvalidSegmentRegEx = /(^|\\|\/)((\.|%2e)(\.|%2e)?|(n|%6e|%4e)(o|%6f|%4f)(d|%64|%44)(e|%65|%45)(_|%5f)(m|%6d|%4d)(o|%6f|%4f)(d|%64|%44)(u|%75|%55)(l|%6c|%4c)(e|%65|%45)(s|%73|%53))(\\|\/|$)/i;
+    invalidPackageNameRegEx = /^\.|%|\\/;
+    patternRegEx = /\*/g;
+    encodedSeparatorRegEx = /%2f|%5c/i;
+    emittedPackageWarnings = /* @__PURE__ */ new Set();
+    doubleSlashRegEx = /[/\\]{2}/;
+  }
+});
+
+// node_modules/import-meta-resolve/index.js
+var init_import_meta_resolve = __esm({
+  "node_modules/import-meta-resolve/index.js"() {
+    "use strict";
+    init_resolve2();
+  }
+});
+
+// src/server/runnable-environment.ts
+var runnable_environment_exports = {};
+__export(runnable_environment_exports, {
+  NastiModuleRunner: () => NastiModuleRunner,
+  createModuleRunner: () => createModuleRunner
+});
+import path17 from "path";
+import fs13 from "fs";
+import { builtinModules as builtinModules4 } from "module";
+import { pathToFileURL as pathToFileURL5 } from "url";
+function createModuleRunner(environment) {
+  if (environment.consumer !== "server") {
+    throw new Error(
+      `[nasti] module runner requires a server-consumer environment (got "${environment.name}" / ${environment.consumer})`
+    );
+  }
+  return new NastiModuleRunner(environment);
+}
+var debug6, NODE_BUILTINS3, NastiModuleRunner, AsyncFunction;
+var init_runnable_environment = __esm({
+  "src/server/runnable-environment.ts"() {
+    "use strict";
+    init_import_meta_resolve();
+    init_transformer();
+    init_env();
+    init_debug();
+    debug6 = createDebugger("nasti:ssr");
+    NODE_BUILTINS3 = /* @__PURE__ */ new Set([...builtinModules4, ...builtinModules4.map((m) => `node:${m}`)]);
+    NastiModuleRunner = class {
+      environment;
+      config;
+      cache = /* @__PURE__ */ new Map();
+      envDefine;
+      externalImportParent;
+      externalImportConditions;
+      constructor(environment) {
+        this.environment = environment;
+        this.config = environment.config;
+        this.envDefine = buildEnvDefine(
+          loadEnv(this.config.mode, this.config.root, this.config.envPrefix),
+          this.config.mode,
+          ssrDefineOverrides(environment.consumer)
+        );
+        this.externalImportParent = pathToFileURL5(path17.join(this.config.root, "package.json"));
+        this.externalImportConditions = /* @__PURE__ */ new Set([
+          ...environment.options.resolve.conditions.filter((condition) => condition !== "require"),
+          "node",
+          "import"
+        ]);
+        const handlers = {
+          fetchModule: async (id, importer) => this.fetchModule(id, importer),
+          getBuiltins: () => [/^node:/, ...builtinModules4]
+        };
+        environment.hot.setInvokeHandler?.(handlers);
+      }
+      /** 入口：加载并执行一个模块（url 为根相对或绝对路径） */
+      async import(rawUrl) {
+        const id = this.resolveToId(rawUrl);
+        return this.instantiate(id);
+      }
+      /** 文件变更时按文件失效（含其所属的虚拟子模块） */
+      invalidateFile(file) {
+        for (const key of [...this.cache.keys()]) {
+          if (key === file || key.startsWith(file + "?")) {
+            this.cache.delete(key);
+          }
+        }
+      }
+      invalidateAll() {
+        this.cache.clear();
+      }
+      resolveToId(rawUrl) {
+        if (path17.isAbsolute(rawUrl) && fs13.existsSync(rawUrl.split("?")[0])) return rawUrl;
+        const clean = rawUrl.replace(/^\//, "");
+        return path17.resolve(this.config.root, clean);
+      }
+      /**
+       * fetchModule（invoke 契约方法）：环境管线产出 runner 可执行代码。
+       * resolve（插件 resolveId → 文件系统）→ load/读盘 → 插件 transform →
+       * oxc（TS/JSX）→ moduleRunnerTransform。
+       */
+      async fetchModule(id, importer) {
+        if (NODE_BUILTINS3.has(id)) return { externalize: id };
+        if (!id.startsWith(".") && !path17.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 : path17.resolve(path17.dirname(importer.split("?")[0]), id);
+        }
+        resolvedId = this.completeExtension(resolvedId);
+        const cleanId = resolvedId.split("?")[0];
+        let code;
+        const loaded = await container.load(resolvedId);
+        if (loaded != null) {
+          code = typeof loaded === "string" ? loaded : loaded.code;
+        } else if (fs13.existsSync(cleanId)) {
+          code = fs13.readFileSync(cleanId, "utf-8");
+        } else {
+          throw new Error(`[nasti:ssr] cannot load module: ${resolvedId}`);
+        }
+        const transformed = await container.transform(code, resolvedId);
+        if (transformed != null) {
+          code = typeof transformed === "string" ? transformed : transformed.code;
+        }
+        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: "vue"
+          });
+          code = result.code;
+        }
+        code = replaceEnvInCode(code, this.envDefine);
+        let moduleRunnerTransform;
+        try {
+          ;
+          ({ moduleRunnerTransform } = await import("rolldown/experimental"));
+        } catch (err) {
+          throw new Error(
+            `[nasti:ssr] rolldown/experimental moduleRunnerTransform unavailable (installed rolldown incompatible?): ${err.message}`
+          );
+        }
+        const runnerResult = await moduleRunnerTransform(resolvedId, code);
+        debug6?.(`fetchModule ${resolvedId} (${runnerResult.deps?.length ?? 0} deps)`);
+        return { id: resolvedId, code: runnerResult.code };
+      }
+      completeExtension(id) {
+        const clean = id.split("?")[0];
+        const query = id.includes("?") ? id.slice(id.indexOf("?")) : "";
+        if (fs13.existsSync(clean) && fs13.statSync(clean).isFile()) return id;
+        const jsMatch = clean.match(/^(.*)\.([mc]?)jsx?$/);
+        if (jsMatch) {
+          for (const tsExt of [`.${jsMatch[2]}ts`, `.${jsMatch[2]}tsx`]) {
+            if (fs13.existsSync(jsMatch[1] + tsExt)) return jsMatch[1] + tsExt + query;
+          }
+        }
+        for (const ext of this.config.resolve.extensions) {
+          if (fs13.existsSync(clean + ext)) return clean + ext + query;
+        }
+        for (const ext of this.config.resolve.extensions) {
+          const indexPath = path17.join(clean, `index${ext}`);
+          if (fs13.existsSync(indexPath)) return indexPath;
+        }
+        return id;
+      }
+      async instantiate(id) {
+        const cached2 = this.cache.get(id);
+        if (cached2) return cached2.promise ?? Promise.resolve(cached2.exports);
+        const entry = { exports: {}, promise: null };
+        this.cache.set(id, entry);
+        entry.promise = this.evaluate(id, entry).then(() => {
+          entry.promise = null;
+          return entry.exports;
+        }).catch((err) => {
+          this.cache.delete(id);
+          throw err;
+        });
+        return entry.promise;
+      }
+      async evaluate(id, entry) {
+        const fetched = await this.fetchModule(id);
+        if ("externalize" in fetched) {
+          const spec = fetched.externalize;
+          const mod = await this.importExternal(spec);
+          entry.exports = mod;
+          return;
+        }
+        const ssrImport = async (dep) => {
+          if (NODE_BUILTINS3.has(dep) || !dep.startsWith(".") && !path17.isAbsolute(dep) && !dep.startsWith("\0")) {
+            return this.importExternal(dep);
+          }
+          const depId = dep.startsWith(".") ? this.completeExtension(path17.resolve(path17.dirname(fetched.id.split("?")[0]), dep)) : this.completeExtension(dep);
+          return this.instantiate(depId);
+        };
+        const ssrExportAll = (sourceModule) => {
+          for (const key of Object.keys(sourceModule)) {
+            if (key !== "default" && !(key in entry.exports)) {
+              Object.defineProperty(entry.exports, key, {
+                enumerable: true,
+                configurable: true,
+                get: () => sourceModule[key]
+              });
+            }
+          }
+        };
+        const importMeta = {
+          url: pathToFileURL5(fetched.id.split("?")[0]).href,
+          env: { SSR: true, MODE: this.config.mode, DEV: this.config.mode !== "production", PROD: this.config.mode === "production" },
+          hot: void 0
+        };
+        const fn = new AsyncFunction(
+          "__vite_ssr_exports__",
+          "__vite_ssr_import__",
+          "__vite_ssr_dynamic_import__",
+          "__vite_ssr_exportAll__",
+          "__vite_ssr_import_meta__",
+          `"use strict";${fetched.code}
+//# sourceURL=${fetched.id}`
+        );
+        await fn(entry.exports, ssrImport, ssrImport, ssrExportAll, importMeta);
+      }
+      async importExternal(spec) {
+        try {
+          return await (spec.startsWith("node:") || !path17.isAbsolute(spec) ? import(this.resolveExternalSpecifier(spec)) : import(pathToFileURL5(spec).href));
+        } catch (err) {
+          throw new Error(`[nasti:ssr] failed to import external "${spec}": ${err.message}`);
+        }
+      }
+      /** bare specifier → 项目 node_modules 的 ESM URL（避免相对 Nasti 自身解析） */
+      resolveExternalSpecifier(spec) {
+        if (spec.startsWith("node:")) return spec;
+        if (NODE_BUILTINS3.has(spec)) return `node:${spec}`;
+        return moduleResolve(
+          spec,
+          this.externalImportParent,
+          this.externalImportConditions,
+          false
+        ).href;
+      }
+    };
+    AsyncFunction = Object.getPrototypeOf(async function() {
     }).constructor;
   }
 });
@@ -5922,7 +7406,7 @@ var dev_engine_exports = {};
 __export(dev_engine_exports, {
   createBundledDevServer: () => createBundledDevServer
 });
-import path16 from "path";
+import path18 from "path";
 import crypto3 from "crypto";
 import { WebSocketServer as WsServer2 } from "ws";
 import pc8 from "picocolors";
@@ -5952,11 +7436,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 ? [
@@ -6007,7 +7491,7 @@ async function createBundledDevServer(opts) {
       }
       const url = `/${patchPath}`;
       logger.info(
-        pc8.green("hmr update ") + pc8.dim(changedFiles.map((f) => path16.relative(config.root, f)).join(", ")),
+        pc8.green("hmr update ") + pc8.dim(changedFiles.map((f) => path18.relative(config.root, f)).join(", ")),
         { timestamp: true }
       );
       sendTo(clientId, { type: "hmr:update", path: url, url });
@@ -6162,7 +7646,7 @@ async function createBundledDevServer(opts) {
           return;
         }
         res.setHeader("ETag", hit.etag);
-        res.setHeader("Content-Type", MIME_TYPES[path16.extname(fileName)] ?? "application/octet-stream");
+        res.setHeader("Content-Type", MIME_TYPES[path18.extname(fileName)] ?? "application/octet-stream");
         res.setHeader("Cache-Control", "no-cache");
         res.once("finish", () => {
           void engine.notifyPayloadDelivered(fileName).catch(
@@ -6203,7 +7687,7 @@ function stripCatchAllLoad(plugins) {
   );
 }
 function createReactRefreshRuntimePlugin(entryPoints) {
-  const entryIds = new Set(entryPoints.map((p) => path16.resolve(p)));
+  const entryIds = new Set(entryPoints.map((p) => path18.resolve(p)));
   return {
     name: "nasti:bundled-react-refresh",
     resolveId(source) {
@@ -6221,24 +7705,27 @@ function createReactRefreshRuntimePlugin(entryPoints) {
       return null;
     },
     transform(code, id) {
-      if (!entryIds.has(path16.resolve(id.split("?")[0]))) return null;
+      if (!entryIds.has(path18.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 };
     }
   };
@@ -6392,7 +7879,7 @@ __export(server_exports, {
   createServer: () => createServer
 });
 import http from "http";
-import path17 from "path";
+import path19 from "path";
 import os from "os";
 import connect from "connect";
 import sirv from "sirv";
@@ -6485,19 +7972,19 @@ async function createServer(inlineConfig = {}) {
     app.use(bundledServer.middleware);
   }
   const ignoredSegments = /* @__PURE__ */ new Set(["node_modules", ".git", ".nasti"]);
-  const outDirAbs = path17.resolve(config.root, config.build.outDir);
+  const outDirAbs = path19.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 === outDirAbs || filePath.startsWith(outDirAbs + path17.sep)) return true;
+      if (filePath === outDirAbs || filePath.startsWith(outDirAbs + path19.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)) {
+        const rel = path19.relative(watchRoot, filePath);
+        if (!rel || rel.startsWith("..") || path19.isAbsolute(rel)) continue;
+        for (const seg of rel.split(path19.sep)) {
           if (ignoredSegments.has(seg)) return true;
         }
         return false;
@@ -6629,7 +8116,7 @@ async function createServer(inlineConfig = {}) {
     });
   };
   watcher.on("change", (file) => {
-    if (file.includes(`${path17.sep}node_modules${path17.sep}`) || file.endsWith(`${path17.sep}node_modules`)) {
+    if (file.includes(`${path19.sep}node_modules${path19.sep}`) || file.endsWith(`${path19.sep}node_modules`)) {
       clearLinkedPackageRootsCache();
     }
     ssrRunner?.invalidateFile(file);
@@ -6637,7 +8124,7 @@ async function createServer(inlineConfig = {}) {
     notifyEnvironmentDrivers(file, "change");
   });
   watcher.on("add", (file) => {
-    if (file.includes(`${path17.sep}node_modules${path17.sep}`) || file.endsWith(`${path17.sep}node_modules`)) {
+    if (file.includes(`${path19.sep}node_modules${path19.sep}`) || file.endsWith(`${path19.sep}node_modules`)) {
       clearLinkedPackageRootsCache();
     }
     ssrRunner?.invalidateFile(file);
@@ -6645,7 +8132,7 @@ async function createServer(inlineConfig = {}) {
     notifyEnvironmentDrivers(file, "add");
   });
   watcher.on("unlink", (file) => {
-    if (file.includes(`${path17.sep}node_modules${path17.sep}`) || file.endsWith(`${path17.sep}node_modules`)) {
+    if (file.includes(`${path19.sep}node_modules${path19.sep}`) || file.endsWith(`${path19.sep}node_modules`)) {
       clearLinkedPackageRootsCache();
     }
     ssrRunner?.invalidateFile(file);
@@ -6677,7 +8164,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.1"}`)}  ${pc9.dim("ready in")} ${pc9.bold(readyIn)} ${pc9.dim("ms")}
 `
           );
           printServerUrls(
@@ -6774,7 +8261,7 @@ async function createServer(inlineConfig = {}) {
     throw error;
   }
   app.use(transformMiddleware(transformContexts.get("client")));
-  const publicDir = path17.resolve(config.root, "public");
+  const publicDir = path19.resolve(config.root, "public");
   app.use(sirv(publicDir, { dev: true, etag: true }));
   app.use(sirv(config.root, { dev: true, etag: true }));
   const postMiddlewares = [];
@@ -6870,7 +8357,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.1"}`));
   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 +8423,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 };
     }
   };
@@ -6993,8 +8487,8 @@ function createElectronRendererConfig(config, inlineConfig = {}, overrides = {})
     }
   };
 }
-function outFileName(outDir, base, format) {
-  const ext = format === "cjs" ? ".cjs" : ".mjs";
+function outFileName(outDir, base, format2) {
+  const ext = format2 === "cjs" ? ".cjs" : ".mjs";
   return path11.join(outDir, base + ext);
 }
 function normalizePreload(preload, root) {
@@ -7037,9 +8531,9 @@ init_server();
 
 // src/server/electron-dev.ts
 init_config();
-import path18 from "path";
-import fs13 from "fs";
-import { createRequire as createRequire6 } from "module";
+import path20 from "path";
+import fs14 from "fs";
+import { createRequire as createRequire5 } from "module";
 import { spawn } from "child_process";
 import chokidar from "chokidar";
 import pc10 from "picocolors";
@@ -7051,7 +8545,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.1"}`));
   const { createServer: createServer2 } = await Promise.resolve().then(() => (init_server(), server_exports));
   const server = await createServer2({
     ...rest,
@@ -7061,11 +8555,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 = path18.resolve(config.root, ".nasti");
-  fs13.mkdirSync(stageDir, { recursive: true });
-  const mainEntry = path18.resolve(config.root, config.electron.main);
+  const stageDir = path20.resolve(config.root, ".nasti");
+  fs14.mkdirSync(stageDir, { recursive: true });
+  const mainEntry = path20.resolve(config.root, config.electron.main);
   const preloadEntries = normalizePreload(config.electron.preload, config.root);
-  const builtMainFile = path18.join(stageDir, "main" + extFor(config.electron.mainFormat));
+  const builtMainFile = path20.join(stageDir, "main" + extFor(config.electron.mainFormat));
   const builtPreloadFiles = [];
   const compileAll = async () => {
     await compileNode(config, mainEntry, {
@@ -7075,9 +8569,9 @@ async function startElectronDev(inlineConfig = {}) {
     });
     builtPreloadFiles.length = 0;
     for (const entry of preloadEntries) {
-      if (!fs13.existsSync(entry)) continue;
-      const base = path18.basename(entry).replace(/\.[^.]+$/, "");
-      const out = path18.join(stageDir, base + extFor(config.electron.preloadFormat));
+      if (!fs14.existsSync(entry)) continue;
+      const base = path20.basename(entry).replace(/\.[^.]+$/, "");
+      const out = path20.join(stageDir, base + extFor(config.electron.preloadFormat));
       await compileNode(config, entry, {
         outFile: out,
         format: config.electron.preloadFormat,
@@ -7116,7 +8610,7 @@ async function startElectronDev(inlineConfig = {}) {
   };
   spawnElectron();
   if (config.electron.autoRestart) {
-    const watchTargets = [mainEntry, ...preloadEntries].filter(fs13.existsSync);
+    const watchTargets = [mainEntry, ...preloadEntries].filter(fs14.existsSync);
     const watcher = chokidar.watch(watchTargets, { ignoreInitial: true });
     let restarting = null;
     let pending = false;
@@ -7163,8 +8657,8 @@ async function startElectronDev(inlineConfig = {}) {
     });
   }
 }
-function extFor(format) {
-  return format === "cjs" ? ".cjs" : ".mjs";
+function extFor(format2) {
+  return format2 === "cjs" ? ".cjs" : ".mjs";
 }
 async function compileNode(config, entry, opts) {
   const env = loadEnv(config.mode, config.root, config.envPrefix);
@@ -7176,14 +8670,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 };
     }
   };
@@ -7196,7 +8697,7 @@ async function compileNode(config, entry, opts) {
     platform: "node",
     plugins: [oxcTransformPlugin, electronPlugin(config), resolvePlugin(config)]
   });
-  fs13.mkdirSync(path18.dirname(opts.outFile), { recursive: true });
+  fs14.mkdirSync(path20.dirname(opts.outFile), { recursive: true });
   await bundle2.write({
     file: opts.outFile,
     format: opts.format === "cjs" ? "cjs" : "esm",
@@ -7209,18 +8710,18 @@ async function compileNode(config, entry, opts) {
   await bundle2.close();
 }
 function electronRendererDevPath(renderer) {
-  const normalized = renderer.split(path18.sep).join("/").replace(/^\.?\//, "");
+  const normalized = renderer.split(path20.sep).join("/").replace(/^\.?\//, "");
   return normalized === "index.html" ? "/" : `/${normalized}`;
 }
 function resolveElectronBinary(config) {
-  if (config.electron.electronPath && fs13.existsSync(config.electron.electronPath)) {
+  if (config.electron.electronPath && fs14.existsSync(config.electron.electronPath)) {
     return config.electron.electronPath;
   }
   try {
-    const require2 = createRequire6(path18.resolve(config.root, "package.json"));
+    const require2 = createRequire5(path20.resolve(config.root, "package.json"));
     const pathFile = require2.resolve("electron");
     const electronModule = require2(pathFile);
-    if (typeof electronModule === "string" && fs13.existsSync(electronModule)) {
+    if (typeof electronModule === "string" && fs14.existsSync(electronModule)) {
       return electronModule;
     }
   } catch {
@@ -7247,10 +8748,10 @@ function warnElectronVersion(config) {
 }
 
 // src/plugins/monaco-editor.ts
-import path19 from "path";
-import fs14 from "fs";
+import path21 from "path";
+import fs15 from "fs";
 import crypto4 from "crypto";
-import { createRequire as createRequire7 } from "module";
+import { createRequire as createRequire6 } from "module";
 var DEFAULT_WORKERS = {
   editorWorkerService: "monaco-editor/esm/vs/editor/editor.worker",
   css: "monaco-editor/esm/vs/language/css/css.worker",
@@ -7269,9 +8770,9 @@ function normalizePublicPath(p) {
 }
 function readMonacoVersion(root) {
   try {
-    const require2 = createRequire7(path19.resolve(root, "package.json"));
+    const require2 = createRequire6(path21.resolve(root, "package.json"));
     const pkgJsonPath = require2.resolve("monaco-editor/package.json", { paths: [root] });
-    const pkg = JSON.parse(fs14.readFileSync(pkgJsonPath, "utf-8"));
+    const pkg = JSON.parse(fs15.readFileSync(pkgJsonPath, "utf-8"));
     return typeof pkg.version === "string" ? pkg.version : "unknown";
   } catch {
     return "unknown";
@@ -7291,20 +8792,20 @@ function monacoEditorPlugin(options = {}) {
   let cacheDir = "";
   const building = /* @__PURE__ */ new Map();
   async function buildWorker(worker) {
-    const cacheFile = path19.join(cacheDir, `${worker.label}.worker.js`);
-    if (fs14.existsSync(cacheFile)) return cacheFile;
+    const cacheFile = path21.join(cacheDir, `${worker.label}.worker.js`);
+    if (fs15.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 = createRequire7(path19.resolve(resolvedConfig.root, "package.json"));
+      const require2 = createRequire6(path21.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] });
       }
-      fs14.mkdirSync(cacheDir, { recursive: true });
+      fs15.mkdirSync(cacheDir, { recursive: true });
       const bundle2 = await rolldown4({
         input: entry,
         platform: "browser"
@@ -7364,15 +8865,15 @@ function monacoEditorPlugin(options = {}) {
       resolvedConfig = config;
       const version = readMonacoVersion(config.root);
       const key = crypto4.createHash("sha1").update(version + "|" + publicPath).digest("hex").slice(0, 8);
-      cacheDir = path19.resolve(config.root, "node_modules/.nasti/monaco", key);
+      cacheDir = path21.resolve(config.root, "node_modules/.nasti/monaco", key);
     },
     async configureServer(server) {
       const shouldBuild = !isCDN(publicPath) || forceBuildCDN;
       const watcher = server.watcher;
-      const monacoLogical = path19.resolve(resolvedConfig.root, "node_modules/monaco-editor");
+      const monacoLogical = path21.resolve(resolvedConfig.root, "node_modules/monaco-editor");
       const monacoPaths = /* @__PURE__ */ new Set([monacoLogical]);
       try {
-        monacoPaths.add(fs14.realpathSync(monacoLogical));
+        monacoPaths.add(fs15.realpathSync(monacoLogical));
       } catch {
       }
       for (const monacoDir of monacoPaths) {
@@ -7406,7 +8907,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");
-            fs14.createReadStream(file).pipe(res);
+            fs15.createReadStream(file).pipe(res);
           } catch (e) {
             res.statusCode = 500;
             res.end(`Monaco worker build failed: ${e.message}`);
@@ -7441,16 +8942,16 @@ self.monaco = monaco;`,
         resolvedConfig.root,
         resolvedConfig.build.outDir,
         resolvedConfig.base
-      ) : isCDN(publicPath) ? path19.resolve(resolvedConfig.root, resolvedConfig.build.outDir, "monaco") : path19.resolve(
+      ) : isCDN(publicPath) ? path21.resolve(resolvedConfig.root, resolvedConfig.build.outDir, "monaco") : path21.resolve(
         resolvedConfig.root,
         resolvedConfig.build.outDir,
         publicPath.replace(/^\//, "")
       );
-      fs14.mkdirSync(outDir, { recursive: true });
+      fs15.mkdirSync(outDir, { recursive: true });
       for (const worker of workers) {
         try {
           const cacheFile = await buildWorker(worker);
-          fs14.copyFileSync(cacheFile, path19.join(outDir, `${worker.label}.worker.js`));
+          fs15.copyFileSync(cacheFile, path21.join(outDir, `${worker.label}.worker.js`));
         } catch (e) {
           throw new Error(
             `[nasti:monaco-editor] worker build failed for "${worker.label}": ${e.message}
@@ -7462,6 +8963,345 @@ ${e.stack || ""}`
   };
 }
 
+// src/plugins/rsc.ts
+init_transformer();
+import fs16 from "fs";
+import path22 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 = path22.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) => path22.resolve(root, directory)).filter((directory) => fs16.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 fs16.readdirSync(directory, { withFileTypes: true })) {
+      if (entry.name === "node_modules" || entry.name === ".git" || entry.name === ".nasti") continue;
+      const id = path22.join(directory, entry.name);
+      if (entry.isDirectory()) {
+        walk(id);
+        continue;
+      }
+      if (!entry.isFile() || !matchesReactFilter(id, include, exclude)) continue;
+      const module = scanModule(id, fs16.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 = path22.resolve(root, client.html ?? "index.html");
+  if (fs16.existsSync(htmlFile)) {
+    const html = fs16.readFileSync(htmlFile, "utf-8");
+    const htmlDir = path22.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("/") ? path22.resolve(root, entry.slice(1)) : path22.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 (fs16.existsSync(path22.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 || !path22.isAbsolute(id)) return id.replaceAll(path22.sep, "/");
+  const relative = path22.relative(root, id).replaceAll(path22.sep, "/");
+  return relative.startsWith("../") ? id.replaceAll(path22.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 +9329,7 @@ export {
   printServerUrls,
   resolveConfig,
   resolveEnvironmentPlugins,
+  rsc,
   ssrDefineOverrides,
   startElectronDev
 };