@nocobase/build 2.1.0-beta.15 → 2.1.0-beta.16

package/lib/build.js

@@ -28,12 +28,10 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var build_exports = {};
 __export(build_exports, {
   build: () => build,
-  buildPackage: () => buildPackage,
   buildPackages: () => buildPackages
 });
 module.exports = __toCommonJS(build_exports);
 var import_chalk = __toESM(require("chalk"));
-var import_execa = __toESM(require("execa"));
 var import_path = __toESM(require("path"));
 var import_buildCjs = require("./buildCjs");
 var import_buildClient = require("./buildClient");
@@ -46,107 +44,297 @@ var import_utils = require("./utils");
 var import_addlicense = require("./utils/addlicense");
 var import_getPackages = require("./utils/getPackages");
 const BUILD_ERROR = "build-error";
+const DEFAULT_LAYER_CONCURRENCY = 2;
+const DEFAULT_PLUGIN_LAYER_CONCURRENCY = 1;
+const ENABLE_BUILD_PROFILE = process.env.BUILD_PROFILE === "true";
 async function build(pkgs) {
+  const profile = ENABLE_BUILD_PROFILE ? (0, import_utils.createBuildProfileCollector)() : null;
+  const buildStart = (0, import_utils.nowMs)();
   const isDev = process.argv.includes("--development");
   process.env.NODE_ENV = isDev ? "development" : "production";
-  let packages = (0, import_getPackages.getPackages)(pkgs);
-  const cachePkg = (0, import_utils.readFromCache)(BUILD_ERROR);
-  if (process.argv.includes("--retry") && cachePkg?.pkg) {
-    packages = packages.slice(packages.findIndex((item) => item.name === cachePkg.pkg));
+  try {
+    let packages = (0, import_getPackages.getPackages)(pkgs);
+    const cachePkg = (0, import_utils.readFromCache)(BUILD_ERROR);
+    if (process.argv.includes("--retry") && cachePkg?.pkg) {
+      packages = packages.slice(packages.findIndex((item) => item.name === cachePkg.pkg));
+    }
+    const cliPackages = packages.find((item) => item.name === "@nocobase/cli");
+    if (cliPackages) {
+      const log = (0, import_utils.getPkgLog)(cliPackages.name);
+      log('running package script "build" (clean + tsc)');
+      await (0, import_utils.runScript)(["build"], cliPackages.location);
+      if (packages.length === 1) {
+        return;
+      }
+    }
+    if (packages.length === 0) {
+      let msg = "";
+      if (pkgs.length) {
+        msg = `'${pkgs.join(", ")}' did not match any packages`;
+      } else {
+        msg = "No package matched";
+      }
+      console.warn(import_chalk.default.yellow(`[@nocobase/build]: ${msg}`));
+      return;
+    }
+    const pluginPackages = (0, import_constant.getPluginPackages)(packages);
+    const cjsPackages = (0, import_constant.getCjsPackages)(packages);
+    const presetsPackages = (0, import_constant.getPresetsPackages)(packages);
+    await buildPackages(cjsPackages, "lib", import_buildCjs.buildCjs, {
+      sourceConcurrency: DEFAULT_LAYER_CONCURRENCY,
+      declarationConcurrency: 1,
+      stageName: "core cjs",
+      profile
+    });
+    const clientCore = packages.find((item) => item.location === import_constant.CORE_CLIENT);
+    if (clientCore) {
+      await buildSinglePackage(clientCore, "es", import_buildClient.buildClient, {
+        stageName: "core client",
+        profile
+      });
+    }
+    const esmPackages = packages.filter((pkg) => import_constant.ESM_PACKAGES.includes(pkg.name));
+    await buildPackages(esmPackages, "lib", import_buildCjs.buildCjs, {
+      sourceConcurrency: DEFAULT_LAYER_CONCURRENCY,
+      declarationConcurrency: 1,
+      stageName: "esm cjs",
+      profile
+    });
+    await buildPackages(esmPackages, "es", import_buildEsm.buildEsm, {
+      sourceConcurrency: DEFAULT_LAYER_CONCURRENCY,
+      declarationConcurrency: 1,
+      stageName: "esm",
+      profile
+    });
+    await buildPackages(pluginPackages, "dist", import_buildPlugin.buildPlugin, {
+      sourceConcurrency: DEFAULT_PLUGIN_LAYER_CONCURRENCY,
+      declarationConcurrency: 1,
+      stageName: "plugins",
+      profile
+    });
+    await buildPackages(presetsPackages, "lib", import_buildCjs.buildCjs, {
+      sourceConcurrency: DEFAULT_LAYER_CONCURRENCY,
+      declarationConcurrency: 1,
+      stageName: "presets",
+      profile
+    });
+    const appClient = packages.find((item) => item.location === import_constant.CORE_APP);
+    if (appClient) {
+      await (0, import_utils.runProfiledStage)(profile, "app shell", async () => {
+        await (0, import_utils.runScript)(["rsbuild", "build", "--config", import_path.default.join(import_constant.CORE_APP, "client", "rsbuild.config.ts")], import_constant.ROOT_PATH, {
+          APP_ROOT: import_path.default.join(import_constant.CORE_APP, "client"),
+          ANALYZE: process.env.BUILD_ANALYZE === "true" ? "1" : void 0
+        });
+      });
+    }
+    (0, import_utils.writeToCache)(BUILD_ERROR, {});
+  } finally {
+    if (profile) {
+      (0, import_utils.printBuildProfile)(profile, (0, import_utils.nowMs)() - buildStart);
+    }
   }
-  if (packages.length === 0) {
-    let msg = "";
-    if (pkgs.length) {
-      msg = `'${pkgs.join(", ")}' did not match any packages`;
-    } else {
-      msg = "No package matched";
+}
+async function buildPackages(packages, targetDir, doBuildPackage, options = {}) {
+  const {
+    sourceConcurrency = DEFAULT_LAYER_CONCURRENCY,
+    declarationConcurrency = 1,
+    stageName = "packages",
+    profile = null
+  } = options;
+  const layers = (0, import_getPackages.groupPackagesByTopoLevel)(packages);
+  const shouldRunDeclaration = !process.argv.includes("--no-dts") && !process.argv.includes("--only-tar");
+  await (0, import_utils.runProfiledStage)(profile, `${stageName} source`, async () => {
+    for (let index = 0; index < layers.length; index++) {
+      const layer = layers[index];
+      console.log(import_chalk.default.cyan(`[@nocobase/build]: ${stageName} source layer ${index + 1}/${layers.length} (${layer.length} packages)`));
+      const layerStart = (0, import_utils.nowMs)();
+      await (0, import_utils.runWithConcurrency)(layer, sourceConcurrency, async (pkg) => {
+        await buildPackageSourceLifecycle(pkg, targetDir, doBuildPackage, profile);
+      });
+      const layerDurationMs = (0, import_utils.nowMs)() - layerStart;
+      if (profile) {
+        profile.layers.push({
+          stageName: `${stageName} source`,
+          layerIndex: index + 1,
+          layerCount: layers.length,
+          packageCount: layer.length,
+          durationMs: layerDurationMs
+        });
+      }
+      if (ENABLE_BUILD_PROFILE) {
+        console.log(import_chalk.default.gray(`[@nocobase/build]: ${stageName} source layer ${index + 1}/${layers.length} finished in ${(0, import_utils.formatDuration)(layerDurationMs)}`));
+      }
     }
-    console.warn(import_chalk.default.yellow(`[@nocobase/build]: ${msg}`));
+  });
+  if (!shouldRunDeclaration) {
     return;
   }
-  const pluginPackages = (0, import_constant.getPluginPackages)(packages);
-  const cjsPackages = (0, import_constant.getCjsPackages)(packages);
-  const presetsPackages = (0, import_constant.getPresetsPackages)(packages);
-  await buildPackages(cjsPackages, "lib", import_buildCjs.buildCjs);
-  const clientCore = packages.find((item) => item.location === import_constant.CORE_CLIENT);
-  if (clientCore) {
-    await buildPackage(clientCore, "es", import_buildClient.buildClient);
-  }
-  const esmPackages = packages.filter((pkg) => import_constant.ESM_PACKAGES.includes(pkg.name));
-  await buildPackages(esmPackages, "lib", import_buildCjs.buildCjs);
-  await buildPackages(esmPackages, "es", import_buildEsm.buildEsm);
-  await buildPackages(pluginPackages, "dist", import_buildPlugin.buildPlugin);
-  await buildPackages(presetsPackages, "lib", import_buildCjs.buildCjs);
-  const appClient = packages.find((item) => item.location === import_constant.CORE_APP);
-  if (appClient) {
-    await runScript(["umi", "build"], import_constant.ROOT_PATH, {
-      APP_ROOT: import_path.default.join(import_constant.CORE_APP, "client"),
-      ANALYZE: process.env.BUILD_ANALYZE === "true" ? "1" : void 0
-    });
-  }
-  (0, import_utils.writeToCache)(BUILD_ERROR, {});
+  await (0, import_utils.runProfiledStage)(profile, `${stageName} declaration`, async () => {
+    for (let index = 0; index < layers.length; index++) {
+      const layer = layers[index];
+      console.log(import_chalk.default.cyan(`[@nocobase/build]: ${stageName} declaration layer ${index + 1}/${layers.length} (${layer.length} packages)`));
+      const layerStart = (0, import_utils.nowMs)();
+      await (0, import_utils.runWithConcurrency)(layer, declarationConcurrency, async (pkg) => {
+        await buildPackageDeclarationLifecycle(pkg, targetDir, profile);
+      });
+      const layerDurationMs = (0, import_utils.nowMs)() - layerStart;
+      if (profile) {
+        profile.layers.push({
+          stageName: `${stageName} declaration`,
+          layerIndex: index + 1,
+          layerCount: layers.length,
+          packageCount: layer.length,
+          durationMs: layerDurationMs
+        });
+      }
+      if (ENABLE_BUILD_PROFILE) {
+        console.log(import_chalk.default.gray(`[@nocobase/build]: ${stageName} declaration layer ${index + 1}/${layers.length} finished in ${(0, import_utils.formatDuration)(layerDurationMs)}`));
+      }
+    }
+  });
 }
-async function buildPackages(packages, targetDir, doBuildPackage) {
-  for await (const pkg of packages) {
-    (0, import_utils.writeToCache)(BUILD_ERROR, { pkg: pkg.name });
-    await buildPackage(pkg, targetDir, doBuildPackage);
+async function buildSinglePackage(pkg, targetDir, doBuildPackage, options) {
+  const { stageName, profile = null } = options;
+  await (0, import_utils.runProfiledStage)(profile, `${stageName} source`, async () => {
+    await buildPackageSourceLifecycle(pkg, targetDir, doBuildPackage, profile);
+  });
+  if (process.argv.includes("--no-dts") || process.argv.includes("--only-tar")) {
+    return;
   }
+  await (0, import_utils.runProfiledStage)(profile, `${stageName} declaration`, async () => {
+    await buildPackageDeclarationLifecycle(pkg, targetDir, profile);
+  });
 }
-async function buildPackage(pkg, targetDir, doBuildPackage) {
+async function buildPackageSourceLifecycle(pkg, targetDir, doBuildPackage, profile = null) {
   const sourcemap = process.argv.includes("--sourcemap");
-  const noDeclaration = process.argv.includes("--no-dts");
   const hasTar = process.argv.includes("--tar");
   const onlyTar = process.argv.includes("--only-tar");
   const log = (0, import_utils.getPkgLog)(pkg.name);
   const packageJson = (0, import_utils.getPackageJson)(pkg.location);
   if (onlyTar) {
+    const packageStart2 = (0, import_utils.nowMs)();
     await (0, import_tarPlugin.tarPlugin)(pkg.location, log);
+    if (profile) {
+      profile.packages.push({
+        name: pkg.name,
+        targetDir,
+        kind: "source",
+        durationMs: (0, import_utils.nowMs)() - packageStart2,
+        status: "success",
+        phases: { tar: (0, import_utils.nowMs)() - packageStart2 }
+      });
+    }
     return;
   }
   log(`${import_chalk.default.bold((0, import_utils.toUnixPath)(pkg.location.replace(import_constant.PACKAGES_PATH, "").slice(1)))} build start`);
   const userConfig = (0, import_utils.getUserConfig)(pkg.location);
+  const packageStart = (0, import_utils.nowMs)();
+  const phaseDurations = {};
+  let status = "success";
+  const runPhase = async (phaseName, task) => {
+    const phaseStart = (0, import_utils.nowMs)();
+    await task();
+    phaseDurations[phaseName] = (phaseDurations[phaseName] || 0) + ((0, import_utils.nowMs)() - phaseStart);
+  };
   if (packageJson?.scripts?.prebuild) {
     log("prebuild");
-    await runScript(["prebuild"], pkg.location);
-    await packageJson.prebuild(pkg.location);
+    await runPhase("prebuild", async () => {
+      await (0, import_utils.runScript)(["prebuild"], pkg.location);
+      await packageJson.prebuild(pkg.location);
+    });
   }
   if (userConfig.beforeBuild) {
     log("beforeBuild");
-    await userConfig.beforeBuild(log);
-  }
-  await doBuildPackage(pkg.location, userConfig, sourcemap, log);
-  if (!noDeclaration) {
-    log("build declaration");
-    await (0, import_buildDeclaration.buildDeclaration)(pkg.location, targetDir);
-  }
-  if (packageJson?.scripts?.postbuild) {
-    log("postbuild");
-    await runScript(["postbuild"], pkg.location);
-  }
-  if (userConfig.afterBuild) {
-    log("afterBuild");
-    await userConfig.afterBuild(log);
+    await runPhase("beforeBuild", async () => {
+      await userConfig.beforeBuild(log);
+    });
   }
-  await (0, import_addlicense.addLicense)(import_path.default.join(pkg.location, targetDir), log);
-  if (hasTar) {
-    await (0, import_tarPlugin.tarPlugin)(pkg.location, log);
+  try {
+    await runPhase("build", async () => {
+      await doBuildPackage(pkg.location, userConfig, sourcemap, log);
+    });
+    if (packageJson?.scripts?.postbuild) {
+      log("postbuild");
+      await runPhase("postbuild", async () => {
+        await (0, import_utils.runScript)(["postbuild"], pkg.location);
+      });
+    }
+    if (userConfig.afterBuild) {
+      log("afterBuild");
+      await runPhase("afterBuild", async () => {
+        await userConfig.afterBuild(log);
+      });
+    }
+    await runPhase("addLicense", async () => {
+      await (0, import_addlicense.addLicense)(import_path.default.join(pkg.location, targetDir), log);
+    });
+    if (hasTar) {
+      await runPhase("tar", async () => {
+        await (0, import_tarPlugin.tarPlugin)(pkg.location, log);
+      });
+    }
+  } catch (error) {
+    status = "failed";
+    (0, import_utils.writeToCache)(BUILD_ERROR, { pkg: pkg.name });
+    throw error;
+  } finally {
+    if (profile) {
+      profile.packages.push({
+        name: pkg.name,
+        targetDir,
+        kind: "source",
+        durationMs: (0, import_utils.nowMs)() - packageStart,
+        status,
+        phases: phaseDurations
+      });
+      if (ENABLE_BUILD_PROFILE) {
+        const summary = Object.entries(phaseDurations).sort((a, b) => b[1] - a[1]).map(([name, duration]) => `${name}=${(0, import_utils.formatDuration)(duration)}`).join(", ");
+        console.log(
+          import_chalk.default.gray(
+            `[@nocobase/build:profile] ${pkg.name} ${status} in ${(0, import_utils.formatDuration)((0, import_utils.nowMs)() - packageStart)}${summary ? ` (${summary})` : ""}`
+          )
+        );
+      }
+    }
   }
 }
-function runScript(args, cwd, envs = {}) {
-  return (0, import_execa.default)("yarn", args, {
-    cwd,
-    stdio: "inherit",
-    env: {
-      ...process.env,
-      ...envs,
-      sourcemap: process.argv.includes("--sourcemap") ? "sourcemap" : void 0,
-      NODE_ENV: process.env.NODE_ENV || "production"
+async function buildPackageDeclarationLifecycle(pkg, targetDir, profile = null) {
+  const log = (0, import_utils.getPkgLog)(pkg.name);
+  const packageStart = (0, import_utils.nowMs)();
+  const phaseDurations = {};
+  let status = "success";
+  try {
+    log("build declaration");
+    const phaseStart = (0, import_utils.nowMs)();
+    await (0, import_buildDeclaration.buildDeclaration)(pkg.location, targetDir);
+    phaseDurations.declaration = (0, import_utils.nowMs)() - phaseStart;
+  } catch (error) {
+    status = "failed";
+    (0, import_utils.writeToCache)(BUILD_ERROR, { pkg: pkg.name });
+    throw error;
+  } finally {
+    if (profile) {
+      profile.packages.push({
+        name: pkg.name,
+        targetDir,
+        kind: "declaration",
+        durationMs: (0, import_utils.nowMs)() - packageStart,
+        status,
+        phases: phaseDurations
+      });
+      if (ENABLE_BUILD_PROFILE) {
+        const summary = Object.entries(phaseDurations).sort((a, b) => b[1] - a[1]).map(([name, duration]) => `${name}=${(0, import_utils.formatDuration)(duration)}`).join(", ");
+        console.log(
+          import_chalk.default.gray(
+            `[@nocobase/build:profile] ${pkg.name} declaration ${status} in ${(0, import_utils.formatDuration)((0, import_utils.nowMs)() - packageStart)}${summary ? ` (${summary})` : ""}`
+          )
+        );
+      }
     }
-  });
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   build,
-  buildPackage,
   buildPackages
 });

package/lib/buildClient.js

@@ -31,13 +31,14 @@ __export(buildClient_exports, {
   buildLocale: () => buildLocale
 });
 module.exports = __toCommonJS(buildClient_exports);
-var import_plugin_react = __toESM(require("@vitejs/plugin-react"));
+var import_core = require("@rsbuild/core");
+var import_plugin_less = require("@rsbuild/plugin-less");
+var import_plugin_react = require("@rsbuild/plugin-react");
+var import_plugin_svgr = require("@rsbuild/plugin-svgr");
 var import_fast_glob = __toESM(require("fast-glob"));
 var import_fs_extra = __toESM(require("fs-extra"));
 var import_path = __toESM(require("path"));
 var import_tsup = require("tsup");
-var import_vite = require("vite");
-var import_vite_plugin_lib_inject_css = require("vite-plugin-lib-inject-css");
 var import_constant = require("./constant");
 var import_utils = require("./utils");
 async function buildClient(cwd, userConfig, sourcemap = false, log) {
@@ -45,7 +46,7 @@ async function buildClient(cwd, userConfig, sourcemap = false, log) {
   const cwdWin = cwd.replaceAll(/\\/g, "/");
   const cwdUnix = cwd.replaceAll(/\//g, "\\");
   const external = function(id) {
-    if (id.startsWith(".") || id.startsWith(cwdUnix) || id.startsWith(cwdWin)) {
+    if (!id || import_path.default.isAbsolute(id) || id.startsWith(".") || id.startsWith(cwdUnix) || id.startsWith(cwdWin)) {
       return false;
     }
     return true;
@@ -54,35 +55,12 @@ async function buildClient(cwd, userConfig, sourcemap = false, log) {
   await buildClientLib(cwd, userConfig, sourcemap, external, log);
   await buildLocale(cwd, userConfig, log);
 }
-function buildClientEsm(cwd, userConfig, sourcemap, external, log) {
+async function buildClientEsm(cwd, userConfig, sourcemap, external, log) {
   log("build client esm");
   const entry = import_path.default.join(cwd, "src/index.ts").replaceAll(/\\/g, "/");
   const outDir = import_path.default.resolve(cwd, "es");
-  return (0, import_vite.build)(
-    userConfig.modifyViteConfig({
-      mode: process.env.NODE_ENV || "production",
-      define: (0, import_utils.getEnvDefine)(),
-      build: {
-        minify: process.env.NODE_ENV === "production",
-        outDir,
-        cssCodeSplit: true,
-        emptyOutDir: true,
-        sourcemap,
-        lib: {
-          entry,
-          formats: ["es"],
-          fileName: "index"
-        },
-        target: ["es2015", "edge88", "firefox78", "chrome87", "safari14"],
-        rollupOptions: {
-          cache: true,
-          treeshake: true,
-          external
-        }
-      },
-      plugins: [(0, import_plugin_react.default)(), (0, import_vite_plugin_lib_inject_css.libInjectCss)()]
-    })
-  );
+  await buildClientWithRsbuild(cwd, userConfig, sourcemap, external, entry, outDir, "esm");
+  await injectEntryStyleReference(import_path.default.join(outDir, "index.mjs"), 'import "./index.css";');
 }
 async function buildClientLib(cwd, userConfig, sourcemap, external, log) {
   log("build client lib");
@@ -91,32 +69,114 @@ async function buildClientLib(cwd, userConfig, sourcemap, external, log) {
   const entry = import_path.default.join(esDir, "index.ts");
   import_fs_extra.default.removeSync(entry);
   import_fs_extra.default.linkSync(import_path.default.join(cwd, "es/index.mjs"), entry);
-  await (0, import_vite.build)(
-    userConfig.modifyViteConfig({
-      mode: process.env.NODE_ENV || "production",
-      esbuild: {
-        format: "cjs"
+  try {
+    await buildClientWithRsbuild(cwd, userConfig, sourcemap, external, entry, outDir, "cjs");
+  } finally {
+    import_fs_extra.default.removeSync(entry);
+  }
+  await injectEntryStyleReference(import_path.default.join(outDir, "index.js"), 'require("./index.css");');
+}
+async function buildClientWithRsbuild(cwd, userConfig, sourcemap, external, entry, outDir, format) {
+  const config = createClientRsbuildConfig(cwd, entry, outDir, sourcemap, external, format);
+  const rsbuild = await (0, import_core.createRsbuild)({
+    cwd,
+    config: userConfig.modifyRsbuildConfig?.(config) ?? config
+  });
+  const result = await rsbuild.build();
+  await result.close();
+}
+function createClientRsbuildConfig(cwd, entry, outDir, sourcemap, external, format) {
+  return {
+    plugins: [(0, import_plugin_react.pluginReact)(), (0, import_plugin_less.pluginLess)(), (0, import_plugin_svgr.pluginSvgr)()],
+    source: {
+      entry: {
+        index: {
+          import: entry,
+          html: false
+        }
+      },
+      tsconfigPath: import_path.default.join(cwd, "tsconfig.json"),
+      define: (0, import_utils.getEnvDefine)(),
+      decorators: {
+        version: "legacy"
+      }
+    },
+    output: {
+      target: "web",
+      distPath: {
+        root: outDir,
+        js: ".",
+        jsAsync: ".",
+        css: ".",
+        cssAsync: ".",
+        svg: ".",
+        font: ".",
+        image: ".",
+        media: ".",
+        assets: "."
       },
-      build: {
-        outDir,
-        minify: process.env.NODE_ENV === "production",
-        sourcemap,
-        lib: {
-          entry: import_path.default.join(cwd, "es/index.ts"),
-          formats: ["cjs"],
-          fileName: "index"
-        },
-        rollupOptions: {
-          external
+      filename: {
+        js: format === "esm" ? "[name].mjs" : "[name].js",
+        css: "[name].css",
+        svg: "[name][ext][query]",
+        font: "[name][ext][query]",
+        image: "[name][ext][query]",
+        media: "[name][ext][query]",
+        assets: "[name][ext][query]"
+      },
+      cleanDistPath: true,
+      sourceMap: sourcemap,
+      minify: process.env.NODE_ENV === "production",
+      emitCss: true,
+      externals: [
+        function({ request }, callback) {
+          if (request && external(request)) {
+            return callback(null, true);
+          }
+          callback();
         }
+      ]
+    },
+    performance: {
+      chunkSplit: {
+        strategy: "all-in-one"
       }
-    })
-  );
-  import_fs_extra.default.removeSync(entry);
-  const css = import_fast_glob.default.sync("*.css", { cwd: esDir, absolute: true });
-  css.forEach((file) => {
-    import_fs_extra.default.copySync(file, import_path.default.join(outDir, import_path.default.basename(file)));
-  });
+    },
+    tools: {
+      rspack(config) {
+        config.output = config.output || {};
+        config.output.asyncChunks = false;
+        if (format === "esm") {
+          config.output.library = { type: "module" };
+          config.output.module = true;
+          config.output.chunkFormat = "module";
+          config.output.chunkLoading = "import";
+          config.output.workerChunkLoading = "import";
+          config.experiments = {
+            ...config.experiments,
+            outputModule: true
+          };
+          config.externalsType = "module-import";
+        } else {
+          config.output.library = { type: "commonjs-static" };
+        }
+        config.performance = false;
+        config.stats = "errors-warnings";
+      }
+    }
+  };
+}
+async function injectEntryStyleReference(entryFile, styleReference) {
+  const cssFile = import_path.default.join(import_path.default.dirname(entryFile), "index.css");
+  if (!import_fs_extra.default.existsSync(entryFile) || !import_fs_extra.default.existsSync(cssFile)) {
+    return;
+  }
+  const content = await import_fs_extra.default.readFile(entryFile, "utf8");
+  if (content.startsWith(styleReference)) {
+    return;
+  }
+  await import_fs_extra.default.writeFile(entryFile, `${styleReference}
+${content}`);
 }
 function buildLocale(cwd, userConfig, log) {
   log("build client locale");

package/lib/buildDeclaration.js

@@ -53,7 +53,11 @@ const diagnosticHost = {
   getCanonicalFileName: (fileName) => import_typescript.default.sys.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase(),
   getNewLine: () => import_typescript.default.sys.newLine
 };
+let cachedBaseCompilerOptions = null;
 function loadCompilerOptions() {
+  if (cachedBaseCompilerOptions) {
+    return { ...cachedBaseCompilerOptions };
+  }
   const configPath = import_path.default.join(import_constant.ROOT_PATH, "tsconfig.json");
   const configFile = import_typescript.default.readConfigFile(configPath, import_typescript.default.sys.readFile);
   if (configFile.error) {
@@ -70,7 +74,8 @@ function loadCompilerOptions() {
     ...parsedConfig.options
   };
   delete options.paths;
-  return options;
+  cachedBaseCompilerOptions = Object.freeze({ ...options });
+  return { ...cachedBaseCompilerOptions };
 }
 const buildDeclaration = async (cwd, targetDir) => {
   const srcPath = import_path.default.join(cwd, "src");
@@ -92,7 +97,17 @@ const buildDeclaration = async (cwd, targetDir) => {
     outDir: targetPath,
     rootDir: srcPath
   };
-  const program = import_typescript.default.createProgram(files, compilerOptions);
+  const host = import_typescript.default.createCompilerHost(compilerOptions);
+  const originalDirectoryExists = host.directoryExists?.bind(host);
+  const rootPrefix = import_constant.ROOT_PATH.endsWith(import_path.default.sep) ? import_constant.ROOT_PATH : import_constant.ROOT_PATH + import_path.default.sep;
+  host.directoryExists = (dirPath) => {
+    const resolved = import_path.default.resolve(dirPath);
+    if (resolved !== import_constant.ROOT_PATH && !resolved.startsWith(rootPrefix) && resolved.includes(`${import_path.default.sep}node_modules`)) {
+      return false;
+    }
+    return originalDirectoryExists ? originalDirectoryExists(dirPath) : import_typescript.default.sys.directoryExists(dirPath);
+  };
+  const program = import_typescript.default.createProgram(files, compilerOptions, host);
   const emitResult = program.emit(void 0, void 0, void 0, true);
   const diagnostics = import_typescript.default.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
   if (diagnostics.length) {

package/lib/buildPlugin.js

@@ -51,10 +51,29 @@ var import_utils = require("./utils");
 var import_buildPluginUtils = require("./utils/buildPluginUtils");
 var import_getDepsConfig = require("./utils/getDepsConfig");
 var import_obfuscationResult = require("./utils/obfuscationResult");
+var import_injectPublicPathPlugin = require("./injectPublicPathPlugin");
 const validExts = [".ts", ".tsx", ".js", ".jsx", ".mjs"];
-const serverGlobalFiles = ["src/**", "!src/client/**", ...import_constant.globExcludeFiles];
-const clientGlobalFiles = ["src/**", "!src/server/**", ...import_constant.globExcludeFiles];
+const serverGlobalFiles = ["src/**", "!src/client/**", "!src/client-v2/**", ...import_constant.globExcludeFiles];
 const sourceGlobalFiles = ["src/**/*.{ts,js,tsx,jsx,mjs}", "!src/**/__tests__", "!src/**/__benchmarks__"];
+const pluginClientLaneConfig = {
+  client: {
+    distDir: "client",
+    entryDir: "client",
+    rootEntryFile: "client.js",
+    externalSubpaths: ["client"]
+  },
+  "client-v2": {
+    distDir: "client-v2",
+    entryDir: "client-v2",
+    rootEntryFile: "client-v2.js",
+    externalSubpaths: ["client", "client-v2"]
+  }
+};
+function getClientGlobalFiles(lane) {
+  const entryDir = pluginClientLaneConfig[lane].entryDir;
+  const excludedClientDirs = Object.values(pluginClientLaneConfig).map((item) => item.entryDir).filter((dir) => dir !== entryDir).map((dir) => `!src/${dir}/**`);
+  return ["src/**", "!src/server/**", ...excludedClientDirs, ...import_constant.globExcludeFiles];
+}
 const external = [
   // nocobase
   "@nocobase/ai",
@@ -152,7 +171,8 @@ const external = [
   "@langchain/anthropic",
   "@langchain/google-genai",
   "@langchain/deepseek",
-  "@langchain/ollama"
+  "@langchain/ollama",
+  "@langchain/mcp-adapters"
 ];
 const pluginPrefix = (process.env.PLUGIN_PACKAGE_PREFIX || "@nocobase/plugin-,@nocobase/preset-,@nocobase/plugin-pro-").split(",");
 const target_dir = "dist";
@@ -243,7 +263,19 @@ function deleteServerFiles(cwd, log) {
     deep: 1,
     onlyDirectories: true
   });
-  [...files, ...dirs].forEach((item) => {
+  const extraClientDirs = import_fast_glob.default.globSync(["client-v2"], {
+    cwd: import_path.default.join(cwd, target_dir),
+    absolute: true,
+    deep: 1,
+    onlyDirectories: true
+  });
+  [...files, ...dirs.filter((item) => !extraClientDirs.includes(item)), ...extraClientDirs].forEach((item) => {
+    if (item.endsWith(`${import_path.default.sep}client-v2`)) {
+      return;
+    }
+    if (item.endsWith(`${import_path.default.sep}client`)) {
+      return;
+    }
     import_fs_extra.default.removeSync(item);
   });
 }
@@ -468,9 +500,27 @@ async function buildProPluginServer(cwd, userConfig, sourcemap, log) {
   import_fs_extra.default.removeSync(tsconfig.path);
   await buildServerDeps(cwd, serverFiles, log);
 }
-async function buildPluginClient(cwd, userConfig, sourcemap, log, isCommercial = false) {
-  log("build plugin client");
+async function buildPluginClient(cwd, userConfig, sourcemap, log, lane = "client", isCommercial = false) {
+  const laneConfig = pluginClientLaneConfig[lane];
+  const entryDir = import_path.default.join(cwd, "src", laneConfig.entryDir);
+  const rootEntryFile = import_path.default.join(cwd, laneConfig.rootEntryFile);
+  if (!import_fs_extra.default.existsSync(rootEntryFile)) {
+    log("skip plugin %s build, root entry not found", lane);
+    return false;
+  }
+  if (!import_fs_extra.default.existsSync(entryDir)) {
+    log("Missing %s. Please create it.", import_chalk.default.red(`src/${laneConfig.entryDir}`));
+    process.exit(-1);
+  }
+  const entry = import_fast_glob.default.globSync("index.{ts,tsx,js,jsx}", { absolute: false, cwd: entryDir });
+  if (!entry[0]) {
+    log("Missing %s entry file.", import_chalk.default.red(`src/${laneConfig.entryDir}/index.{ts,tsx,js,jsx}`));
+    process.exit(-1);
+    return false;
+  }
+  log("build plugin %s", lane);
   const packageJson = (0, import_utils.getPackageJson)(cwd);
+  const clientGlobalFiles = getClientGlobalFiles(lane);
   const clientFiles = import_fast_glob.default.globSync(clientGlobalFiles, { cwd, absolute: true });
   if (isCommercial) {
     const commercialFiles = import_fast_glob.default.globSync(clientGlobalFiles, {
@@ -483,22 +533,23 @@ async function buildPluginClient(cwd, userConfig, sourcemap, log, isCommercial =
   const sourcePackages = (0, import_buildPluginUtils.getPackagesFromFiles)(clientFileSource);
   const excludePackages = (0, import_buildPluginUtils.getExcludePackages)(sourcePackages, external, pluginPrefix);
   (0, import_buildPluginUtils.checkRequire)(clientFiles, log);
-  (0, import_buildPluginUtils.buildCheck)({ cwd, packageJson, entry: "client", files: clientFiles, log });
-  const outDir = import_path.default.join(cwd, target_dir, "client");
+  (0, import_buildPluginUtils.buildCheck)({ cwd, packageJson, entry: lane, files: clientFiles, log });
+  const outDir = import_path.default.join(cwd, target_dir, laneConfig.distDir);
   const globals = excludePackages.reduce((prev, curr) => {
     if (curr.startsWith("@nocobase")) {
-      prev[`${curr}/client`] = `${curr}/client`;
+      laneConfig.externalSubpaths.forEach((subpath) => {
+        prev[`${curr}/${subpath}`] = `${curr}/${subpath}`;
+      });
     }
     prev[curr] = curr;
     return prev;
   }, {});
-  const entry = import_fast_glob.default.globSync("index.{ts,tsx,js,jsx}", { absolute: false, cwd: import_path.default.join(cwd, "src/client") });
   const outputFileName = "index.js";
   const compiler = (0, import_core.rspack)({
     mode: "production",
     // mode: "development",
     context: cwd,
-    entry: "./src/client/" + entry[0],
+    entry: `./src/${laneConfig.entryDir}/` + entry[0],
     target: ["web", "es5"],
     output: {
       path: outDir,
@@ -580,18 +631,6 @@ async function buildPluginClient(cwd, userConfig, sourcemap, log, isCommercial =
           // *.svg?react
           use: ["@svgr/webpack"]
         },
-        {
-          test: /\.(?:js|mjs|cjs|ts|tsx)$/,
-          exclude: /node_modules/,
-          use: {
-            loader: "babel-loader",
-            options: {
-              targets: "defaults",
-              // presets: [['@babel/preset-env']],
-              plugins: ["react-imported-component/babel"]
-            }
-          }
-        },
         {
           test: /\.jsx$/,
           exclude: /[\\/]node_modules[\\/]/,
@@ -671,27 +710,7 @@ async function buildPluginClient(cwd, userConfig, sourcemap, log, isCommercial =
         "process.env.NODE_ENV": JSON.stringify("production"),
         "process.env.NODE_DEBUG": false
       }),
-      {
-        apply(compiler2) {
-          compiler2.hooks.compilation.tap("CustomPublicPathPlugin", (compilation) => {
-            compilation.hooks.runtimeModule.tap("CustomPublicPathPlugin", (module2) => {
-              if (module2.name === "auto_public_path") {
-                module2.source = {
-                  source: `
-__webpack_require__.p = (function() {
-  var publicPath = window['__webpack_public_path__'] || '/';
-  // \u786E\u4FDD\u8DEF\u5F84\u4EE5 / \u7ED3\u5C3E
-  if (!publicPath.endsWith('/')) {
-    publicPath += '/';
-  }
-  return publicPath + 'static/plugins/${packageJson.name}/dist/client/';
-})();`
-                };
-              }
-            });
-          });
-        }
-      },
+      new import_injectPublicPathPlugin.AutoInjectPublicPathPlugin(packageJson.name, laneConfig.distDir),
       process.env.BUILD_ANALYZE === "true" && new import_rspack_plugin.RsdoctorRspackPlugin({
         // plugin options
         // supports: {
@@ -728,10 +747,12 @@ __webpack_require__.p = (function() {
 }
 async function buildPlugin(cwd, userConfig, sourcemap, log) {
   if (cwd.includes("/pro-plugins/") && import_fs_extra.default.existsSync(import_path.default.join(process.cwd(), "packages/pro-plugins/", import_constant.PLUGIN_COMMERCIAL))) {
-    await buildPluginClient(cwd, userConfig, sourcemap, log, true);
+    await buildPluginClient(cwd, userConfig, sourcemap, log, "client", true);
+    await buildPluginClient(cwd, userConfig, sourcemap, log, "client-v2", true);
     await buildProPluginServer(cwd, userConfig, sourcemap, log);
   } else {
-    await buildPluginClient(cwd, userConfig, sourcemap, log);
+    await buildPluginClient(cwd, userConfig, sourcemap, log, "client");
+    await buildPluginClient(cwd, userConfig, sourcemap, log, "client-v2");
     await buildPluginServer(cwd, userConfig, sourcemap, log);
   }
   writeExternalPackageVersion(cwd, log);

package/lib/constant.js

@@ -30,6 +30,7 @@ __export(constant_exports, {
   CJS_EXCLUDE_PACKAGES: () => CJS_EXCLUDE_PACKAGES,
   CORE_APP: () => CORE_APP,
   CORE_CLIENT: () => CORE_CLIENT,
+  CORE_CLIENT_V2: () => CORE_CLIENT_V2,
   ESM_PACKAGES: () => ESM_PACKAGES,
   EsbuildSupportExts: () => EsbuildSupportExts,
   NODE_MODULES: () => NODE_MODULES,
@@ -90,20 +91,31 @@ const getPluginPackages = (packages) => packages.filter((item) => PLUGINS_DIR.so
 const getPresetsPackages = (packages) => packages.filter((item) => item.location.startsWith(PRESETS_DIR));
 const CORE_APP = import_path.default.join(PACKAGES_PATH, "core/app");
 const CORE_CLIENT = import_path.default.join(PACKAGES_PATH, "core/client");
-const ESM_PACKAGES = ["@nocobase/test"];
+const CORE_CLIENT_V2 = import_path.default.join(PACKAGES_PATH, "core/client-v2");
+const ESM_PACKAGES = ["@nocobase/client-v2", "@nocobase/test"];
 const CJS_EXCLUDE_PACKAGES = [
   import_path.default.join(PACKAGES_PATH, "core/build"),
+  import_path.default.join(PACKAGES_PATH, "core/cli-v1"),
   import_path.default.join(PACKAGES_PATH, "core/cli"),
-  CORE_CLIENT
+  CORE_CLIENT,
+  CORE_CLIENT_V2
 ];
 const getCjsPackages = (packages) => packages.filter((item) => !PLUGINS_DIR.some((dir) => item.location.startsWith(dir))).filter((item) => !item.location.startsWith(PRESETS_DIR)).filter((item) => !ESM_PACKAGES.includes(item.name)).filter((item) => !CJS_EXCLUDE_PACKAGES.includes(item.location));
 const tarIncludesFiles = ["package.json", "README.md", "LICENSE", "dist", "!node_modules"];
-const TAR_OUTPUT_DIR = process.env.TAR_PATH ? process.env.TAR_PATH : import_path.default.join(ROOT_PATH, "storage", "tar");
+function resolveStorageRoot() {
+  const raw = process.env.STORAGE_PATH;
+  if (raw) {
+    return import_path.default.isAbsolute(raw) ? raw : import_path.default.resolve(process.cwd(), raw);
+  }
+  return import_path.default.join(ROOT_PATH, "storage");
+}
+const TAR_OUTPUT_DIR = process.env.TAR_PATH || import_path.default.join(resolveStorageRoot(), "tar");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CJS_EXCLUDE_PACKAGES,
   CORE_APP,
   CORE_CLIENT,
+  CORE_CLIENT_V2,
   ESM_PACKAGES,
   EsbuildSupportExts,
   NODE_MODULES,

package/lib/index.d.ts

@@ -7,15 +7,14 @@
  * For more information, please refer to: https://www.nocobase.com/agreement.
  */
 
-
+import type { RsbuildConfig } from '@rsbuild/core'
 import { Options as TsupConfig } from 'tsup'
-import { InlineConfig as ViteConfig } from 'vite'
 
 export type PkgLog = (msg: string, ...args: any[]) => void;
 
 interface UserConfig {
   modifyTsupConfig?: (config: TsupConfig) => TsupConfig;
-  modifyViteConfig?: (config: ViteConfig) => ViteConfig;
+  modifyRsbuildConfig?: (config: RsbuildConfig) => RsbuildConfig;
   beforeBuild?: (log: PkgLog) => void | Promise<void>;
   afterBuild?: (log: PkgLog) => void | Promise<void>;
 }

package/lib/injectPublicPathPlugin.js

@@ -0,0 +1,109 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var injectPublicPathPlugin_exports = {};
+__export(injectPublicPathPlugin_exports, {
+  AutoInjectPublicPathPlugin: () => AutoInjectPublicPathPlugin
+});
+module.exports = __toCommonJS(injectPublicPathPlugin_exports);
+function createPluginClientPublicPathDataUri(packageName, clientDistDir) {
+  const code = `
+var publicPath = '';
+var currentScript = typeof document !== 'undefined' ? document.currentScript : null;
+if (currentScript && currentScript.src) {
+  publicPath = currentScript.src
+    .replace(/^blob:/, '')
+    .replace(/#.*$/, '')
+    .replace(/\\?.*$/, '')
+    .replace(/\\/[^\\/]+$/, '/');
+}
+if (!publicPath) {
+  var runtimeAssetBase = window['__webpack_public_path__'] || '';
+  if (runtimeAssetBase) {
+    if (runtimeAssetBase.charAt(runtimeAssetBase.length - 1) !== '/') {
+      runtimeAssetBase += '/';
+    }
+    publicPath = runtimeAssetBase + 'static/plugins/${packageName}/dist/${clientDistDir}/';
+  }
+}
+if (!publicPath) {
+  publicPath = window['__nocobase_public_path__'] || '';
+  if (!publicPath && window.location && window.location.pathname) {
+    var marker = '/v2/';
+    var pathname = window.location.pathname || '/';
+    var index = pathname.indexOf(marker);
+    publicPath = index >= 0 ? pathname.slice(0, index + 1) : '/';
+  }
+  if (publicPath) {
+    publicPath = publicPath.replace(/\\/v2\\/?$/, '/');
+  }
+  if (!publicPath) {
+    publicPath = '/';
+  }
+  if (publicPath.charAt(publicPath.length - 1) !== '/') {
+    publicPath += '/';
+  }
+  publicPath += 'static/plugins/${packageName}/dist/${clientDistDir}/';
+}
+__webpack_public_path__ = publicPath;
+`;
+  return `data:text/javascript,${encodeURIComponent(code)}`;
+}
+function prependPluginClientPublicPathEntry(entry, packageName, clientDistDir) {
+  const dataUri = createPluginClientPublicPathDataUri(packageName, clientDistDir);
+  if (typeof entry === "string") {
+    return [dataUri, entry];
+  }
+  if (Array.isArray(entry)) {
+    return [dataUri, ...entry];
+  }
+  if (!entry || typeof entry !== "object") {
+    return entry;
+  }
+  const entryConfig = entry;
+  if (entryConfig.import) {
+    return {
+      ...entryConfig,
+      import: Array.isArray(entryConfig.import) ? [dataUri, ...entryConfig.import] : [dataUri, entryConfig.import]
+    };
+  }
+  return Object.fromEntries(
+    Object.entries(entryConfig).map(([name, value]) => [
+      name,
+      prependPluginClientPublicPathEntry(value, packageName, clientDistDir)
+    ])
+  );
+}
+class AutoInjectPublicPathPlugin {
+  constructor(pluginName, clientDistDir = "client") {
+    this.pluginName = pluginName;
+    this.clientDistDir = clientDistDir;
+  }
+  apply(compiler) {
+    compiler.hooks.environment.tap("AutoInjectPublicPathPlugin", () => {
+      compiler.options.entry = prependPluginClientPublicPathEntry(
+        compiler.options.entry,
+        this.pluginName,
+        this.clientDistDir
+      );
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AutoInjectPublicPathPlugin
+});

package/lib/utils/buildPluginUtils.js

@@ -54,7 +54,7 @@ function isNotBuiltinModule(packageName) {
   return !import_module.builtinModules.includes(packageName);
 }
 const isValidPackageName = (str) => {
-  const pattern = /^(?:@[a-zA-Z0-9_-]+\/)?[a-zA-Z0-9_-]+$/;
+  const pattern = /^(?:@[a-zA-Z0-9._-]+\/)?[a-zA-Z0-9._-]+$/;
   return pattern.test(str);
 };
 function getPackageNameFromString(str) {

package/lib/utils/getDepsConfig.js

@@ -76,7 +76,7 @@ function getDepsConfig(cwd, outDir, depsName, external) {
     acc[depEntryPath] = {
       nccConfig: {
         minify: true,
-        target: "es5",
+        target: "es2020",
         quiet: true,
         externals: {}
       },

package/lib/utils/getPackages.js

@@ -28,6 +28,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var getPackages_exports = {};
 __export(getPackages_exports, {
   getPackages: () => getPackages,
+  groupPackagesByTopoLevel: () => groupPackagesByTopoLevel,
   sortPackages: () => sortPackages
 });
 module.exports = __toCommonJS(getPackages_exports);
@@ -76,8 +77,55 @@ function sortPackages(packages) {
   }
   return sorter.nodes;
 }
+function groupPackagesByTopoLevel(packages) {
+  const filteredPackages = packages.filter((pkg) => pkg.name !== "@nocobase/docs");
+  const packageMap = new Map(filteredPackages.map((pkg) => [pkg.name, pkg]));
+  const dependencyMap = /* @__PURE__ */ new Map();
+  const reverseDependencyMap = /* @__PURE__ */ new Map();
+  for (const pkg of filteredPackages) {
+    const pkgJson = require(`${pkg.location}/package.json`);
+    const internalDeps = Object.keys({
+      ...pkgJson.dependencies,
+      ...pkgJson.devDependencies,
+      ...pkgJson.peerDependencies
+    }).filter((dep) => packageMap.has(dep));
+    dependencyMap.set(pkg.name, new Set(internalDeps));
+    for (const dep of internalDeps) {
+      if (!reverseDependencyMap.has(dep)) {
+        reverseDependencyMap.set(dep, /* @__PURE__ */ new Set());
+      }
+      reverseDependencyMap.get(dep).add(pkg.name);
+    }
+  }
+  const remainingDeps = new Map(
+    Array.from(dependencyMap.entries()).map(([name, deps]) => [name, new Set(deps)])
+  );
+  const pending = new Set(filteredPackages.map((pkg) => pkg.name));
+  const layers = [];
+  while (pending.size > 0) {
+    const layer = Array.from(pending).filter((name) => (remainingDeps.get(name)?.size ?? 0) === 0).map((name) => packageMap.get(name)).filter(Boolean);
+    if (layer.length === 0) {
+      throw new Error(
+        `Unable to group packages by topo level, possible circular dependency among: ${Array.from(pending).join(", ")}`
+      );
+    }
+    layers.push(layer);
+    for (const pkg of layer) {
+      pending.delete(pkg.name);
+      const dependents = reverseDependencyMap.get(pkg.name);
+      if (!dependents) {
+        continue;
+      }
+      for (const dependent of dependents) {
+        remainingDeps.get(dependent)?.delete(pkg.name);
+      }
+    }
+  }
+  return layers;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   getPackages,
+  groupPackagesByTopoLevel,
   sortPackages
 });

package/lib/utils/utils.js

@@ -27,17 +27,25 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var utils_exports = {};
 __export(utils_exports, {
+  createBuildProfileCollector: () => createBuildProfileCollector,
   defineConfig: () => defineConfig,
+  formatDuration: () => formatDuration,
   getEnvDefine: () => getEnvDefine,
   getPackageJson: () => getPackageJson,
   getPkgLog: () => getPkgLog,
   getUserConfig: () => getUserConfig,
+  nowMs: () => nowMs,
+  printBuildProfile: () => printBuildProfile,
   readFromCache: () => readFromCache,
+  runProfiledStage: () => runProfiledStage,
+  runScript: () => runScript,
+  runWithConcurrency: () => runWithConcurrency,
   toUnixPath: () => toUnixPath,
   writeToCache: () => writeToCache
 });
 module.exports = __toCommonJS(utils_exports);
 var import_chalk = __toESM(require("chalk"));
+var import_execa = __toESM(require("execa"));
 var import_path = __toESM(require("path"));
 var import_fast_glob = __toESM(require("fast-glob"));
 var import_fs_extra = __toESM(require("fs-extra"));
@@ -86,7 +94,7 @@ function defineConfig(config) {
 function getUserConfig(cwd) {
   const config = defineConfig({
     modifyTsupConfig: (config2) => config2,
-    modifyViteConfig: (config2) => config2
+    modifyRsbuildConfig: (config2) => config2
   });
   const buildConfigs = import_fast_glob.default.sync(["build.config.js", "build.config.ts"], { cwd });
   if (buildConfigs.length > 1) {
@@ -121,14 +129,128 @@ function getEnvDefine() {
     "process.env.APP_ENV": process.env.APP_ENV
   };
 }
+function createBuildProfileCollector() {
+  return {
+    stages: [],
+    layers: [],
+    packages: []
+  };
+}
+async function runProfiledStage(profile, stageName, task) {
+  const startedAt = nowMs();
+  await task();
+  if (profile) {
+    profile.stages.push({
+      name: stageName,
+      durationMs: nowMs() - startedAt
+    });
+  }
+}
+async function runWithConcurrency(items, concurrency, worker) {
+  const queue = [...items];
+  const workers = Array.from({ length: Math.min(concurrency, queue.length) }, async () => {
+    while (queue.length > 0) {
+      const item = queue.shift();
+      if (!item) {
+        return;
+      }
+      await worker(item);
+    }
+  });
+  await Promise.all(workers);
+}
+function printBuildProfile(profile, totalDurationMs) {
+  const phaseTotals = /* @__PURE__ */ new Map();
+  for (const pkg of profile.packages) {
+    for (const [phaseName, duration] of Object.entries(pkg.phases)) {
+      phaseTotals.set(phaseName, (phaseTotals.get(phaseName) || 0) + duration);
+    }
+  }
+  console.log(import_chalk.default.cyan(`[@nocobase/build:profile] total build time ${formatDuration(totalDurationMs)}`));
+  if (profile.stages.length > 0) {
+    console.log(import_chalk.default.cyan("[@nocobase/build:profile] stage totals"));
+    for (const stage of [...profile.stages].sort((a, b) => b.durationMs - a.durationMs)) {
+      console.log(import_chalk.default.gray(`  ${stage.name}: ${formatDuration(stage.durationMs)}`));
+    }
+  }
+  if (profile.layers.length > 0) {
+    console.log(import_chalk.default.cyan("[@nocobase/build:profile] slowest layers"));
+    for (const layer of [...profile.layers].sort((a, b) => b.durationMs - a.durationMs).slice(0, 12)) {
+      console.log(
+        import_chalk.default.gray(
+          `  ${layer.stageName} layer ${layer.layerIndex}/${layer.layerCount} (${layer.packageCount} packages): ${formatDuration(layer.durationMs)}`
+        )
+      );
+    }
+  }
+  if (phaseTotals.size > 0) {
+    console.log(import_chalk.default.cyan("[@nocobase/build:profile] aggregated package phases"));
+    for (const [phaseName, duration] of [...phaseTotals.entries()].sort((a, b) => b[1] - a[1])) {
+      console.log(import_chalk.default.gray(`  ${phaseName}: ${formatDuration(duration)}`));
+    }
+  }
+  if (profile.packages.length > 0) {
+    const sourcePackages = profile.packages.filter((pkg) => pkg.kind === "source");
+    const declarationPackages = profile.packages.filter((pkg) => pkg.kind === "declaration");
+    console.log(import_chalk.default.cyan("[@nocobase/build:profile] slowest source packages"));
+    for (const pkg of [...sourcePackages].sort((a, b) => b.durationMs - a.durationMs).slice(0, 20)) {
+      const summary = Object.entries(pkg.phases).sort((a, b) => b[1] - a[1]).slice(0, 4).map(([name, duration]) => `${name}=${formatDuration(duration)}`).join(", ");
+      console.log(
+        import_chalk.default.gray(
+          `  ${pkg.name} [${pkg.status}] ${formatDuration(pkg.durationMs)}${summary ? ` (${summary})` : ""}`
+        )
+      );
+    }
+    console.log(import_chalk.default.cyan("[@nocobase/build:profile] slowest declaration packages"));
+    for (const pkg of [...declarationPackages].sort((a, b) => b.durationMs - a.durationMs).slice(0, 20)) {
+      const summary = Object.entries(pkg.phases).sort((a, b) => b[1] - a[1]).slice(0, 4).map(([name, duration]) => `${name}=${formatDuration(duration)}`).join(", ");
+      console.log(
+        import_chalk.default.gray(
+          `  ${pkg.name} [${pkg.status}] ${formatDuration(pkg.durationMs)}${summary ? ` (${summary})` : ""}`
+        )
+      );
+    }
+  }
+}
+function nowMs() {
+  return Date.now();
+}
+function formatDuration(durationMs) {
+  if (durationMs >= 6e4) {
+    return `${(durationMs / 6e4).toFixed(2)}m`;
+  }
+  if (durationMs >= 1e3) {
+    return `${(durationMs / 1e3).toFixed(2)}s`;
+  }
+  return `${Math.round(durationMs)}ms`;
+}
+function runScript(args, cwd, envs = {}) {
+  return (0, import_execa.default)("yarn", args, {
+    cwd,
+    stdio: "inherit",
+    env: {
+      ...process.env,
+      ...envs,
+      sourcemap: process.argv.includes("--sourcemap") ? "sourcemap" : void 0,
+      NODE_ENV: process.env.NODE_ENV || "production"
+    }
+  });
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  createBuildProfileCollector,
   defineConfig,
+  formatDuration,
   getEnvDefine,
   getPackageJson,
   getPkgLog,
   getUserConfig,
+  nowMs,
+  printBuildProfile,
   readFromCache,
+  runProfiledStage,
+  runScript,
+  runWithConcurrency,
   toUnixPath,
   writeToCache
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/build",
-  "version": "2.1.0-beta.15",
+  "version": "2.1.0-beta.16",
   "description": "Library build tool based on rollup.",
   "main": "lib/index.js",
   "types": "./lib/index.d.ts",
@@ -15,9 +15,13 @@
     "@babel/preset-env": "^7.26.0",
     "@hapi/topo": "^6.0.0",
     "@lerna/project": "4.0.0",
+    "@rsbuild/core": "1.7.3",
     "@rsbuild/plugin-babel": "^1.0.3",
+    "@rsbuild/plugin-less": "^1.6.2",
+    "@rsbuild/plugin-react": "1.4.6",
+    "@rsbuild/plugin-svgr": "^1.3.1",
     "@rsdoctor/rspack-plugin": "^0.4.8",
-    "@rspack/core": "1.3.2",
+    "@rspack/core": "1.7.8",
     "@svgr/webpack": "^8.1.0",
     "@types/lerna__package": "5.1.0",
     "@types/lerna__project": "5.1.0",
@@ -42,8 +46,6 @@
     "tsup": "8.2.4",
     "typescript": "5.1.3",
     "update-notifier": "3.0.0",
-    "vite-plugin-css-injected-by-js": "^3.2.1",
-    "vite-plugin-lib-inject-css": "1.2.0",
     "yargs-parser": "13.1.2"
   },
   "license": "Apache-2.0",
@@ -51,5 +53,5 @@
     "build": "tsup",
     "build:watch": "tsup --watch"
   },
-  "gitHead": "dc1aceea6357e6ab149976c2a236fc4b6bee1370"
+  "gitHead": "b9a191705a440a336c85d82fd877fdf152bec70f"
 }