@webiny/build-tools 0.0.0-unstable.6f45466a1d → 0.0.0-unstable.7be00a75a9

package/bundling/admin/createBuildAdmin.js

@@ -1,4 +1,3 @@
-import { createRsbuild } from "@rsbuild/core";
 import { createRsbuildConfig } from "./createRsbuildConfig.js";
 import { printBuildStats } from "../printBuildStats.js";
 
@@ -7,6 +6,8 @@ export const createBuildAdmin =
     async ({ cwd }) => {
         process.env.NODE_ENV = "production";
 
+        // Must be a dynamic import — see rslibCompile.js for the reason.
+        const { createRsbuild } = await import("@rsbuild/core");
         const rsbuildConfig = createRsbuildConfig({ cwd });
 
         const rsbuild = await createRsbuild({ rsbuildConfig });

package/bundling/admin/createRsbuildConfig.js

@@ -19,12 +19,6 @@ export const createRsbuildConfig = ({ cwd }) => {
             },
             define: envVars
         },
-        resolve: {
-            alias: {
-                // This is a temporary fix, until we sort out the `react-butterfiles` dependency.
-                "react-butterfiles": "@webiny/app/react-butterfiles"
-            }
-        },
         output: { distPath: { root: paths.admin.outputFolder } },
         mode,
         dev: { hmr: true },
@@ -33,14 +27,25 @@ export const createRsbuildConfig = ({ cwd }) => {
         },
         tools: {
             postcss: (_, { addPlugins }) => {
-                addPlugins(
+                addPlugins([
+                    createInjectTailwindSourcePlugin(
+                        path.join(paths.projectRootFolder, "extensions")
+                    ),
                     tailwindcss({
                         base: getTailwindBasePath(paths.projectRootFolder)
-                    })
-                );
+                    }),
+                    createStripTailwindSourceLeftoverPlugin()
+                ]);
+            },
+            rspack: {
+                watchOptions: {
+                    // Wait for dependency builds to finish before triggering a recompilation.
+                    aggregateTimeout: 500,
+                    ignored: ["**/node_modules/**", "**/.git/**"]
+                }
             }
         },
-        server: { port: 3001 },
+        server: { port: process.env.PORT || 3001, host: "0.0.0.0" },
         html: {
             template: paths.projectRootFolder + "/public/index.html"
         },
@@ -52,7 +57,9 @@ export const createRsbuildConfig = ({ cwd }) => {
                     async: mode === "development"
                 }
             }),
-            pluginReact(),
+            pluginReact({
+                splitChunks: false
+            }),
             pluginSass(),
             pluginSvgr({
                 mixedImport: true,
@@ -102,6 +109,31 @@ const getTailwindBasePath = projectRootFolderPath => {
     return path.join(projectRootFolderPath, "node_modules", "@webiny");
 };
 
+/*
+    Injects an `@source` directive into the Tailwind CSS AST at build time, pointing to the
+    given absolute path. https://tailwindcss.com/docs/functions-and-directives#source-directive
+*/
+const createInjectTailwindSourcePlugin = sourcePath => ({
+    postcssPlugin: "inject-tailwind-source",
+    Once(root) {
+        root.prepend(`@source "${sourcePath}";`);
+    }
+});
+
+/*
+    Removes any leftover `@source` at-rule from the output. Tailwind v4 strips the
+    directive from files it processes, but `@tailwindcss/postcss` only processes
+    files containing one of its trigger at-rules; for other files (e.g., pre-bundled
+    component CSS imported through JS), the injected directive would otherwise
+    survive into the production bundle, exposing the absolute build-machine path.
+*/
+const createStripTailwindSourceLeftoverPlugin = () => ({
+    postcssPlugin: "strip-tailwind-source-leftover",
+    Once(root) {
+        root.walkAtRules("source", node => node.remove());
+    }
+});
+
 const getEnvVars = () => {
     const raw = Object.keys(process.env)
         .filter(key => {

package/bundling/admin/createWatchAdmin.js

@@ -1,4 +1,3 @@
-import { createRsbuild } from "@rsbuild/core";
 import { createRsbuildConfig } from "./createRsbuildConfig.js";
 
 export const createWatchAdmin =
@@ -6,6 +5,8 @@ export const createWatchAdmin =
     async ({ cwd }) => {
         process.env.NODE_ENV = "development";
 
+        // Must be a dynamic import — see rslibCompile.js for the reason.
+        const { createRsbuild } = await import("@rsbuild/core");
         const rsbuildConfig = createRsbuildConfig({ cwd });
 
         const rsbuild = await createRsbuild({ rsbuildConfig });

package/bundling/function/createBuildFunction.js

@@ -1,4 +1,3 @@
-import { createRsbuild } from "@rsbuild/core";
 import { createRsbuildConfig } from "./createRsbuildConfig.js";
 import { printBuildStats } from "../printBuildStats.js";
 
@@ -7,7 +6,9 @@ export const createBuildFunction =
     async ({ cwd }) => {
         process.env.NODE_ENV = "production";
 
-        const rsbuildConfig = createRsbuildConfig({ cwd });
+        // Must be a dynamic import — see rslibCompile.js for the reason.
+        const { createRsbuild } = await import("@rsbuild/core");
+        const rsbuildConfig = await createRsbuildConfig({ cwd });
 
         const rsbuild = await createRsbuild({ rsbuildConfig });
 

package/bundling/function/createRsbuildConfig.js

@@ -1,19 +1,29 @@
 import path from "path";
-import rspack from "@rspack/core";
 import { pluginTypeCheck } from "@rsbuild/plugin-type-check";
 import { createImportValidatorPlugin } from "../importValidatorPlugin.js";
 
-export const createRsbuildConfig = ({ cwd }) => {
+const DEFAULT_WEBINY_INFRA_API_MAX_BUNDLE_SIZE = 4_718_592; // 4.5 MB
+
+export const createRsbuildConfig = async ({ cwd }) => {
+    // Must be a dynamic import — see rslibCompile.js for the reason.
+    const { default: rspack } = await import("@rspack/core");
     const paths = getPaths(cwd);
     const mode = getMode();
+    const isDebugEnabled = process.env.DEBUG === "true";
+
+    // Configurable via WEBINY_INFRA_API_MAX_BUNDLE_SIZE (bytes).
+    const maxBundleSize =
+        parseInt(process.env.WEBINY_INFRA_API_MAX_BUNDLE_SIZE) ||
+        DEFAULT_WEBINY_INFRA_API_MAX_BUNDLE_SIZE;
 
     return /** @type {import("@rsbuild/core").RsbuildConfig} */ ({
         source: { entry: { index: paths.fn.entryFile } },
         output: {
             module: true,
             target: "node",
+            minify: true,
             sourceMap: {
-                js: process.env.DEBUG === "true" ? "source-map" : false
+                js: isDebugEnabled ? "source-map" : false
             },
             filename: {
                 js: pathData => {
@@ -30,7 +40,12 @@ export const createRsbuildConfig = ({ cwd }) => {
         },
         tools: {
             rspack: {
-                externals: [/^@aws-sdk/, /^sharp$/],
+                performance: {
+                    hints: "error",
+                    maxEntrypointSize: maxBundleSize,
+                    maxAssetSize: maxBundleSize
+                },
+                externals: [/^@aws-sdk/, /^aws-sdk$/, /^sharp$/],
                 plugins: [
                     // This is necessary to enable JSDOM usage in Lambda.
                     // https://rspack.dev/plugins/webpack/ignore-plugin

package/bundling/function/createWatchFunction.js

@@ -1,4 +1,3 @@
-import { createRsbuild } from "@rsbuild/core";
 import { createRsbuildConfig } from "./createRsbuildConfig.js";
 
 export const createWatchFunction =
@@ -6,7 +5,9 @@ export const createWatchFunction =
     async ({ cwd }) => {
         process.env.NODE_ENV = "development";
 
-        const rsbuildConfig = createRsbuildConfig({ cwd });
+        // Must be a dynamic import — see rslibCompile.js for the reason.
+        const { createRsbuild } = await import("@rsbuild/core");
+        const rsbuildConfig = await createRsbuildConfig({ cwd });
 
         const rsbuild = await createRsbuild({ rsbuildConfig });
 

package/bundling/importValidatorPlugin.js

@@ -5,7 +5,7 @@ const cyan = "\x1b[36m";
 const reset = "\x1b[0m";
 const bold = "\x1b[1m";
 
-const whitelist = ["@webiny/cognito", "@webiny/auth0", "@webiny/okta"];
+const whitelist = ["@webiny/cognito", "@webiny/auth0", "@webiny/okta", "@webiny/plugins"];
 
 export const createImportValidatorPlugin = () => {
     return {

package/bundling/printBuildStats.js

@@ -4,7 +4,9 @@ import chalk from "chalk";
 export const printBuildStats =
     ({ cwd, label = "build", extensions = [".js", ".mjs", ".css"] }) =>
     ({ stats }) => {
-        if (!stats) return;
+        if (!stats) {
+            return;
+        }
 
         const statsJson = stats.toJson({ assets: true, children: false });
         const assets = statsJson.assets || [];

package/index.d.ts

@@ -5,10 +5,6 @@ export { RspackConfig };
 // Build commands.
 export type BuildCommand<TOptions = Record<string, any>> = (options: TOptions) => Promise<void>;
 
-export interface BabelConfig {
-    [key: string]: any;
-}
-
 export interface SwcConfig {
     [key: string]: any;
 }
@@ -20,7 +16,6 @@ export interface DefinePluginOptions {
 export interface BuildAppConfigOverrides {
     entry?: string;
     openBrowser?: boolean;
-    babel?: (config: BabelConfig) => BabelConfig;
 }
 // Build commands - apps.
 export interface BuildAppConfig {
@@ -51,7 +46,6 @@ interface BuildFunctionConfig {
         };
         define?: DefinePluginOptions;
         rspack?: (config: RspackConfig) => RspackConfig;
-        babel?: (config: BabelConfig) => BabelConfig;
         swc?: (config: SwcConfig) => SwcConfig;
     };
 }
@@ -71,12 +65,5 @@ interface BuildPackageConfig {
     };
 }
 
-interface BabelConfigParams {
-    path: string;
-    esm?: boolean;
-}
-
 export function createBuildPackage(options: BuildPackageConfig): BuildCommand;
 export function createWatchPackage(options: BuildPackageConfig): BuildCommand;
-export function createBabelConfigForNode(options: BabelConfigParams): BabelConfig;
-export function createBabelConfigForReact(options: BabelConfigParams): BabelConfig;

package/index.js

@@ -1,8 +1,3 @@
 export { createWatchAdmin, createBuildAdmin } from "./bundling/admin/index.js";
 export { createBuildFunction, createWatchFunction } from "./bundling/function/index.js";
-export {
-    createWatchPackage,
-    createBuildPackage,
-    createBabelConfigForNode,
-    createBabelConfigForReact
-} from "./packages/index.js";
+export { createWatchPackage, createBuildPackage } from "./packages/index.js";

package/package.json

@@ -1,8 +1,11 @@
 {
 	"name": "@webiny/build-tools",
-	"version": "0.0.0-unstable.6f45466a1d",
+	"version": "0.0.0-unstable.7be00a75a9",
 	"type": "module",
-	"main": "index.js",
+	"exports": {
+		".": "./index.js",
+		"./*": "./*"
+	},
 	"description": "A collection of utilities for Webiny project.",
 	"repository": {
 		"type": "git",
@@ -14,43 +17,34 @@
 		"Adrian Smijulj <adrian@webiny.com>"
 	],
 	"dependencies": {
-		"@babel/core": "7.29.0",
-		"@babel/preset-env": "7.29.0",
-		"@babel/preset-react": "7.28.5",
-		"@babel/preset-typescript": "7.28.5",
-		"@babel/runtime": "7.28.6",
-		"@rsbuild/core": "1.7.3",
-		"@rsbuild/plugin-react": "1.4.5",
-		"@rsbuild/plugin-sass": "1.5.0",
-		"@rsbuild/plugin-svgr": "1.3.0",
-		"@rsbuild/plugin-type-check": "1.3.3",
-		"@rspack/core": "1.7.6",
-		"@svgr/webpack": "6.5.1",
-		"@swc/plugin-emotion": "11.5.0",
-		"@tailwindcss/postcss": "4.1.18",
-		"@types/webpack-env": "1.18.8",
-		"chalk": "4.1.2",
-		"chokidar": "4.0.3",
-		"css-loader": "7.1.3",
-		"eslint": "9.39.2",
+		"@rsbuild/core": "2.0.6",
+		"@rsbuild/plugin-react": "2.0.0",
+		"@rsbuild/plugin-sass": "1.5.2",
+		"@rsbuild/plugin-svgr": "2.0.2",
+		"@rsbuild/plugin-type-check": "1.3.4",
+		"@rslib/core": "0.21.5",
+		"@rspack/core": "2.0.3",
+		"@swc/plugin-emotion": "14.9.0",
+		"@tailwindcss/postcss": "4.3.0",
+		"chalk": "5.6.2",
+		"css-loader": "7.1.4",
 		"fast-glob": "3.3.3",
-		"find-up": "5.0.0",
-		"fs-extra": "11.3.3",
+		"find-up": "8.0.0",
+		"fs-extra": "11.3.5",
 		"get-yarn-workspaces": "1.0.2",
-		"lodash": "4.17.23",
-		"postcss-loader": "8.2.0",
-		"process": "0.11.10",
+		"load-json-file": "7.0.1",
+		"lodash": "4.18.1",
+		"postcss-loader": "8.2.1",
 		"raw-loader": "4.0.2",
-		"react-dom": "18.2.0",
-		"react-refresh": "0.11.0",
-		"read-json-sync": "2.0.1",
-		"rimraf": "6.1.2",
-		"sass": "1.97.3",
-		"sass-loader": "16.0.7",
-		"style-loader": "3.3.4",
-		"ts-morph": "27.0.2",
+		"react-dom": "18.3.1",
+		"react-refresh": "0.18.0",
+		"rimraf": "6.1.3",
+		"sass": "1.99.0",
+		"sass-loader": "17.0.0",
+		"style-loader": "4.0.0",
+		"ts-morph": "28.0.0",
 		"tsx": "4.21.0",
-		"typescript": "5.9.3",
+		"typescript": "6.0.3",
 		"url-loader": "4.1.1",
 		"utf-8-validate": "6.0.6"
 	},
@@ -63,19 +57,12 @@
 				"!!raw-loader!"
 			],
 			"dependencies": [
-				"@babel/preset-react",
-				"@svgr/webpack",
-				"@babel/preset-env",
-				"@babel/preset-typescript",
 				"@swc/plugin-emotion",
-				"@types/webpack-env",
 				"postcss-loader",
 				"raw-loader",
 				"react-refresh",
 				"style-loader",
 				"typescript",
-				"eslint",
-				"process",
 				"sass-loader",
 				"sass",
 				"bufferutil",
@@ -86,8 +73,7 @@
 		}
 	},
 	"publishConfig": {
-		"access": "public",
-		"directory": "."
+		"access": "public"
 	},
-	"gitHead": "6f45466a1d9fb94f6156923501eb90ac303b81a5"
+	"gitHead": "b8aec8a1be3f25c3b428b357fe1e352c7cbff9ae"
 }

package/packages/buildPackage/copyToDist.js

@@ -1,9 +1,9 @@
 import fs from "fs";
 import { join } from "path";
 
-export const copyToDist = (path, { cwd, logs }) => {
+export const copyToDist = (path, { cwd, logs, outputDir }) => {
     const from = join(cwd, path);
-    const to = join(cwd, "dist", path);
+    const to = join(outputDir || join(cwd, "dist"), path);
     if (fs.existsSync(from)) {
         fs.copyFileSync(from, to);
         logs !== false && console.log(`Copied ${path}.`);

package/packages/buildPackage/rslibCompile.js

@@ -0,0 +1,63 @@
+import path from "path";
+import fs from "fs";
+import { dirname } from "path";
+import glob from "fast-glob";
+
+const COMPILE_EXTENSIONS = [".js", ".jsx", ".ts", ".tsx"];
+const SKIP_EXTENSIONS = [".d.ts"];
+
+export const rslibCompile = async ({ cwd }) => {
+    // Copy non-compilable files (assets, json, graphql, etc.) as-is.
+    const pattern = path.join(cwd, "src/**/*.*").replace(/\\/g, "/");
+    const allFiles = glob.sync(pattern, { onlyFiles: true, dot: true });
+
+    for (const file of allFiles) {
+        const shouldCompile = COMPILE_EXTENSIONS.some(ext => file.endsWith(ext));
+        const shouldSkip = SKIP_EXTENSIONS.some(ext => file.endsWith(ext));
+
+        if (!shouldCompile || shouldSkip) {
+            const destPath = file.replace(path.join(cwd, "src"), path.join(cwd, "dist"));
+            fs.mkdirSync(dirname(destPath), { recursive: true });
+            fs.copyFileSync(file, destPath);
+        }
+    }
+
+    // Must be a dynamic import. @rslib/core statically loads rspack's native
+    // binding. Workers that also run createBuildAdmin load a different rspack
+    // version via rsbuild, so two native binaries end up in the same process
+    // and cause a SIGSEGV. Deferring the import keeps each rspack isolated to
+    // the workers that actually need it.
+    const [{ createRslib }, { pluginSvgr }] = await Promise.all([
+        import("@rslib/core"),
+        import("@rsbuild/plugin-svgr")
+    ]);
+
+    const rslib = await createRslib({
+        cwd,
+        config: {
+            lib: [{ format: "esm", bundle: false }],
+            source: {
+                // SVGs included so rslib runs them through pluginSvgr and emits
+                // a .js React-component module alongside the copied .svg asset.
+                entry: ["./src/**/*.{ts,tsx,js,jsx,svg}"],
+                alias: { "~": "./src" }
+            },
+            output: {
+                target: "web",
+                distPath: { root: "./dist" },
+                cleanDistPath: false,
+                sourceMap: { js: "source-map" },
+                // mixedImport emits each SVG as a static asset for the default URL
+                // export. Without a hash, two files named the same (e.g. fullscreen.svg
+                // in different dirs) collide at static/svg/fullscreen.svg.
+                // loader-utils [ext] has no leading dot, so "[name].[hash][ext]" produces
+                // "foo.hashsvg". Use an explicit ".svg" suffix instead.
+                filename: { svg: "[name].[contenthash:8].svg" }
+            },
+            plugins: [pluginSvgr({ mixedImport: true, svgrOptions: { exportType: "named" } })]
+        }
+    });
+
+    const { close } = await rslib.build();
+    await close();
+};

package/packages/buildPackage/tsAliasReplacer.js

@@ -1,25 +1,38 @@
-import { dirname, relative } from "path";
+import { dirname, join, relative, resolve } from "node:path";
 import fg from "fast-glob";
-import fs from "fs";
+import fs from "node:fs";
 
+/**
+ *
+ * @param distDir {String}
+ * @param cwd {String}
+ * @param debug {Boolean}
+ * @returns {Promise<void>}
+ */
 export const replaceTscAliases = async ({ distDir, cwd, debug = false }) => {
     const dtsFiles = await fg("**/*.d.ts", {
         cwd: distDir,
         absolute: true
     });
 
+    // Build a map of absolute src paths → package names, by scanning sibling packages.
+    // This is used to rewrite cross-package src paths (e.g. "../../api/src") back to
+    // proper package names (e.g. "@webiny/api") in generated .d.ts files.
+    const srcToPackageName = buildSrcToPackageNameMap(cwd);
+
     for (const dtsFile of dtsFiles) {
-        let content = fs.readFileSync(dtsFile, "utf8");
+        let content = fs.readFileSync(dtsFile, "utf8").toString();
         let modified = false;
 
         // Replace all imports/exports with ~/ alias
         content = content.replace(
             /(from\s+["'])~\/([^"']+)(["'])/g,
-            (match, prefix, importPath, suffix) => {
+            (_, prefix, importPath, suffix) => {
                 modified = true;
                 // Calculate relative path from current file to dist root
-                const fileDir = dirname(dtsFile);
-                const relativePath = relative(fileDir, distDir);
+                const fileDir = dirname(dtsFile).replace(/\\/g, "/");
+                const normalizedDistDir = distDir.replace(/\\/g, "/");
+                const relativePath = relative(fileDir, normalizedDistDir).replace(/\\/g, "/");
                 const finalPath = relativePath
                     ? `${relativePath}/${importPath}`
                     : `./${importPath}`;
@@ -29,11 +42,84 @@ export const replaceTscAliases = async ({ distDir, cwd, debug = false }) => {
             }
         );
 
+        // Replace cross-package src paths (e.g. "../../api/src/types") with proper package
+        // names (e.g. "@webiny/api/types"). TypeScript inlines these relative paths when
+        // project references are used and dependencies have paths pointing to src/.
+        if (srcToPackageName.size > 0) {
+            content = content.replace(
+                /["'](\.\.[^"']*\/src(?:\/[^"']*)?)['"]/g,
+                (match, relPath) => {
+                    const quote = match[0];
+                    const absPath = resolve(dirname(dtsFile), relPath);
+                    const packageName = resolveToPackageName(absPath, srcToPackageName);
+                    if (packageName) {
+                        modified = true;
+                        return `${quote}${packageName}${quote}`;
+                    }
+                    return match;
+                }
+            );
+        }
+
         if (modified) {
             fs.writeFileSync(dtsFile, content, "utf8");
             if (debug) {
-                console.log(`Resolved ~ aliases in: ${relative(cwd, dtsFile)}`);
+                console.log(`Resolved aliases in: ${relative(cwd, dtsFile)}`);
             }
         }
     }
 };
+
+/**
+ * Scans sibling packages to build a map of absolute src directory paths → package names.
+ * @param {string} cwd - The current package directory.
+ * @returns {Map<string, string>}
+ */
+function buildSrcToPackageNameMap(cwd) {
+    const map = new Map();
+    // Go up to the packages/ directory (cwd is packages/xxx, parent is packages/)
+    const packagesDir = resolve(cwd, "..");
+    if (!fs.existsSync(packagesDir)) {
+        return map;
+    }
+    let entries;
+    try {
+        entries = fs.readdirSync(packagesDir);
+    } catch {
+        return map;
+    }
+    for (const entry of entries) {
+        const pkgDir = join(packagesDir, entry);
+        const pkgJsonPath = join(pkgDir, "package.json");
+        if (!fs.existsSync(pkgJsonPath)) {
+            continue;
+        }
+        try {
+            const pkgJson = JSON.parse(fs.readFileSync(pkgJsonPath, "utf8"));
+            if (pkgJson.name) {
+                const srcDir = join(pkgDir, "src");
+                map.set(srcDir, pkgJson.name);
+            }
+        } catch {
+            // ignore
+        }
+    }
+    return map;
+}
+
+/**
+ * Given an absolute path that points into a package's src directory, returns the
+ * corresponding package name + sub-path (e.g. "@webiny/api/types").
+ * @param {string} absPath - Absolute path resolved from the relative import.
+ * @param {Map<string, string>} srcToPackageName
+ * @returns {string|null}
+ */
+function resolveToPackageName(absPath, srcToPackageName) {
+    for (const [srcDir, packageName] of srcToPackageName) {
+        if (absPath === srcDir || absPath.startsWith(srcDir + "/")) {
+            const subPath = absPath.slice(srcDir.length).replace(/^\//, "");
+            return subPath ? `${packageName}/${subPath}` : packageName;
+        }
+    }
+    return null;
+}

package/packages/buildPackage/tsCompile.js

@@ -3,8 +3,11 @@ import ts from "typescript";
 import merge from "lodash/merge.js";
 import { replaceTscAliases } from "./tsAliasReplacer.js";
 
-export const tsCompile = async ({ cwd = "", overrides, debug }) => {
-    const tsConfigPath = join(cwd, "tsconfig.build.json");
+export const tsCompile = async ({ cwd = "", overrides, debug, outputDir, checkOnly = false }) => {
+    // Normalize path separators to forward slashes for consistent behavior on Windows.
+    const normalizedCwd = cwd.replace(/\\/g, "/");
+
+    const tsConfigPath = join(normalizedCwd, "tsconfig.build.json");
 
     let { config: readTsConfig } = ts.readConfigFile(tsConfigPath, ts.sys.readFile);
 
@@ -20,13 +23,22 @@ export const tsCompile = async ({ cwd = "", overrides, debug }) => {
             console.log(readTsConfig);
         }
     }
-    const parsedJsonConfigFile = ts.parseJsonConfigFileContent(readTsConfig, ts.sys, cwd);
+    if (outputDir) {
+        readTsConfig.compilerOptions = readTsConfig.compilerOptions || {};
+        readTsConfig.compilerOptions.outDir = outputDir;
+        readTsConfig.compilerOptions.declarationDir = outputDir;
+    }
+
+    const parsedJsonConfigFile = ts.parseJsonConfigFileContent(readTsConfig, ts.sys, normalizedCwd);
 
     const { projectReferences, options, fileNames, errors } = parsedJsonConfigFile;
 
-    // Exclude .d.ts files from TypeScript compilation
     const filteredFileNames = fileNames.filter(fileName => !fileName.endsWith(".d.ts"));
 
+    if (checkOnly) {
+        options.noEmit = true;
+    }
+
     const program = ts.createProgram({
         projectReferences,
         options,
@@ -34,12 +46,31 @@ export const tsCompile = async ({ cwd = "", overrides, debug }) => {
         configFileParsingDiagnostics: errors
     });
 
+    if (checkOnly) {
+        const allDiagnostics = ts.getPreEmitDiagnostics(program).concat(errors);
+
+        if (allDiagnostics.length) {
+            const formatHost = {
+                getCanonicalFileName: path => path,
+                getCurrentDirectory: () => normalizedCwd,
+                getNewLine: () => ts.sys.newLine
+            };
+            const message = ts.formatDiagnostics(allDiagnostics, formatHost);
+            if (message) {
+                throw { message };
+            }
+        }
+        return;
+    }
+
     const { diagnostics, emitSkipped } = program.emit(
         undefined, // targetSourceFile
-        (fileName, data, writeByteOrderMark, onError, sourceFiles) => {
-            // Only emit files within the current package directory
-            const relativePath = fileName.replace(cwd, "");
-            if (fileName.startsWith(cwd) && !relativePath.includes("../")) {
+        (fileName, data, writeByteOrderMark) => {
+            // Only emit files within the current package directory.
+            // Normalize path separators to handle Windows backslashes vs forward slashes.
+            const normalizedFileName = fileName.replace(/\\/g, "/");
+            const relativePath = normalizedFileName.replace(normalizedCwd, "");
+            if (normalizedFileName.startsWith(normalizedCwd) && !relativePath.includes("../")) {
                 ts.sys.writeFile(fileName, data, writeByteOrderMark);
             }
         }
@@ -50,7 +81,7 @@ export const tsCompile = async ({ cwd = "", overrides, debug }) => {
     if (allDiagnostics.length) {
         const formatHost = {
             getCanonicalFileName: path => path,
-            getCurrentDirectory: () => cwd,
+            getCurrentDirectory: () => normalizedCwd,
             getNewLine: () => ts.sys.newLine
         };
         const message = ts.formatDiagnostics(allDiagnostics, formatHost);
@@ -63,7 +94,6 @@ export const tsCompile = async ({ cwd = "", overrides, debug }) => {
         throw { message: "TypeScript compilation failed." };
     }
 
-    // Resolve ~ path aliases in .d.ts files
-    const distDir = options.outDir || join(cwd, "dist");
-    await replaceTscAliases({ distDir, cwd, debug });
+    const distDir = outputDir || options.outDir || join(normalizedCwd, "dist");
+    await replaceTscAliases({ distDir, cwd: normalizedCwd, debug });
 };

package/packages/buildPackage.js

@@ -1,6 +1,7 @@
 import * as rimraf from "rimraf";
 import { join } from "path";
-import { babelCompile } from "./buildPackage/babelCompile.js";
+import fs from "node:fs";
+import { rslibCompile } from "./buildPackage/rslibCompile.js";
 import { tsCompile } from "./buildPackage/tsCompile.js";
 import { copyToDist } from "./buildPackage/copyToDist.js";
 import { validateEsmImports } from "./buildPackage/validateEsmImports.js";
@@ -12,8 +13,7 @@ export default async options => {
         options.cwd = "";
     }
     const { cwd = "" } = options;
-    options.logs !== false && console.log("Deleting existing build files...");
-    rimraf.sync(join(cwd, "./dist"));
+
     rimraf.sync(join(cwd, "*.tsbuildinfo"), { glob: true });
 
     options.logs !== false && console.log("Building...");
@@ -26,15 +26,68 @@ export default async options => {
     // Validate ESM imports before compiling
     await validateEsmImports({ cwd, logs: options.logs });
 
-    await babelCompile(options);
-    await tsCompile(options);
+    const distDir = join(cwd, "dist");
 
-    options.logs !== false && console.log("Copying meta files...");
-    copyToDist("package.json", options);
-    copyToDist("LICENSE", options);
+    if (options.safeReplace) {
+        await buildWithSafeReplace(options, distDir);
+    } else {
+        await buildDirect(options, distDir);
+    }
 
     const duration = (new Date() - start) / 1000;
     options.logs !== false && console.log(`Done! Build finished in ${duration + "s"}.`);
 
     return { duration };
 };
+
+async function buildDirect(options, distDir) {
+    // Clear dist/ contents without removing the directory itself.
+    // node_modules/@webiny/<pkg> symlinks directly to dist/, so deleting
+    // the directory would leave a dangling symlink and break Rspack resolution.
+    if (fs.existsSync(distDir)) {
+        for (const entry of fs.readdirSync(distDir)) {
+            fs.rmSync(join(distDir, entry), { recursive: true, force: true });
+        }
+    }
+
+    await rslibCompile(options);
+    await tsCompile(options);
+
+    options.logs !== false && console.log("Copying meta files...");
+    copyToDist("package.json", options);
+    copyToDist("LICENSE", options);
+}
+
+async function buildWithSafeReplace(options, distDir) {
+    const stagingDir = distDir + "._build";
+
+    // Clean up any leftover staging dir from a previous failed build.
+    if (fs.existsSync(stagingDir)) {
+        fs.rmSync(stagingDir, { recursive: true, force: true });
+    }
+    fs.mkdirSync(stagingDir, { recursive: true });
+
+    const stagingOptions = { ...options, outputDir: stagingDir };
+
+    await babelCompile(stagingOptions);
+    await tsCompile(stagingOptions);
+
+    stagingOptions.logs !== false && console.log("Copying meta files...");
+    copyToDist("package.json", stagingOptions);
+    copyToDist("LICENSE", stagingOptions);
+
+    // Fast-swap: clear dist contents and move staged files in.
+    if (fs.existsSync(distDir)) {
+        for (const entry of fs.readdirSync(distDir)) {
+            fs.rmSync(join(distDir, entry), { recursive: true, force: true });
+        }
+    } else {
+        fs.mkdirSync(distDir, { recursive: true });
+    }
+
+    for (const entry of fs.readdirSync(stagingDir)) {
+        fs.renameSync(join(stagingDir, entry), join(distDir, entry));
+    }
+
+    fs.rmSync(stagingDir, { recursive: true, force: true });
+}

package/packages/index.js

@@ -2,5 +2,3 @@ export { default as watchPackage } from "./watchPackage.js";
 export { default as createWatchPackage } from "./createWatchPackage.js";
 export { default as buildPackage } from "./buildPackage.js";
 export { default as createBuildPackage } from "./createBuildPackage.js";
-export { default as createBabelConfigForNode } from "./createBabelConfigForNode.js";
-export { default as createBabelConfigForReact } from "./createBabelConfigForReact.js";

package/packages/watchPackage.js

@@ -1,117 +1,29 @@
-import path from "path";
-import fs from "fs/promises";
-import { transformFileAsync } from "@babel/core";
-import chokidar from "chokidar";
-import baseFs from "node:fs";
-
-let compilationQueue = [];
-let debounceTimer = null;
-const DEBOUNCE_DELAY = 1000; // 1 second
-
-const flushCompilationQueue = () => {
-    if (compilationQueue.length > 0) {
-        if (compilationQueue.length === 1) {
-            console.log(`Successfully compiled ${compilationQueue[0]}.`);
-        } else {
-            console.log(`Successfully compiled ${compilationQueue.length} files.`);
-        }
-        compilationQueue = [];
-    }
-};
-
-const logCompilation = inputPathRelative => {
-    compilationQueue.push(inputPathRelative);
-
-    clearTimeout(debounceTimer);
-    debounceTimer = setTimeout(() => {
-        flushCompilationQueue();
-    }, DEBOUNCE_DELAY);
-};
-
-const getBabelFile = cwd => {
-    const babelJs = path.join(cwd, ".babelrc.js");
-    const babelCjs = path.join(cwd, ".babelrc.cjs");
-
-    if (baseFs.existsSync(babelJs)) {
-        return babelJs;
-    } else if (baseFs.existsSync(babelCjs)) {
-        return babelCjs;
-    }
-    throw new Error("No Babel configuration file found (.babelrc.js or .babelrc.cjs).");
-};
-
-const compileFile = async (cwd, inputPath, outputPath) => {
-    const inputPathRelative = path.relative(cwd, inputPath);
-
-    const configFile = getBabelFile(cwd);
-
-    const result = await transformFileAsync(inputPath, {
-        configFile: configFile,
-        sourceMaps: true
-    });
-
-    if (!result || !result.code) {
-        throw new Error(`Failed to compile: ${inputPath}`);
-    }
-
-    // Write compiled file
-    await fs.mkdir(path.dirname(outputPath), { recursive: true });
-    await fs.writeFile(outputPath, result.code);
-
-    // Write source map
-    if (result.map) {
-        await fs.writeFile(`${outputPath}.map`, JSON.stringify(result.map));
-    }
-
-    logCompilation(inputPathRelative);
-};
-
-const srcToDist = filePath =>
-    path.join(
-        filePath
-            .replace(`${path.sep}src${path.sep}`, `${path.sep}dist${path.sep}`)
-            .replace(/\.(ts|tsx)$/, ".js")
-    );
-
 export default async options => {
-    const srcDir = path.join(options.cwd, "src");
-
-    // Watch the src directory recursively for new files
-    const watcher = chokidar.watch(srcDir, {
-        ignored: /(^|[\/\\])\../, // ignore dotfiles
-        persistent: true,
-        ignoreInitial: false
-    });
-
-    const isTsFile = filePath => /\.(ts|tsx)$/.test(filePath);
-
-    watcher.on("add", async srcPath => {
-        if (!isTsFile(srcPath)) {
-            return;
-        }
-
-        const distPath = srcToDist(srcPath);
-
-        try {
-            await compileFile(options.cwd, srcPath, distPath);
-        } catch (err) {
-            console.error("Error compiling:", err);
-        }
-    });
-
-    watcher.on("change", async srcPath => {
-        if (!isTsFile(srcPath)) {
-            return;
-        }
-
-        const distPath = srcToDist(srcPath);
-
-        try {
-            await compileFile(options.cwd, srcPath, distPath);
-        } catch (err) {
-            console.error("Error compiling:", err);
+    const { cwd } = options;
+
+    // Must be a dynamic import — see rslibCompile.js for the reason.
+    const [{ createRslib }, { pluginSvgr }] = await Promise.all([
+        import("@rslib/core"),
+        import("@rsbuild/plugin-svgr")
+    ]);
+
+    const rslib = await createRslib({
+        cwd,
+        config: {
+            lib: [{ format: "esm", bundle: false }],
+            source: {
+                entry: ["./src/**/*.{ts,tsx,js,jsx}"],
+                alias: { "~": "./src" }
+            },
+            output: {
+                target: "web",
+                distPath: { root: "./dist" },
+                cleanDistPath: false,
+                sourceMap: { js: "source-map" }
+            },
+            plugins: [pluginSvgr({ mixedImport: true, svgrOptions: { exportType: "named" } })]
         }
     });
 
-    console.log("Watching for changes...");
+    await rslib.build({ watch: true });
 };

package/utils/PackageJson.backup.ts

@@ -1,14 +1,13 @@
 // We'll use this class once the package is converted to TS!
-
-import readJson from "read-json-sync";
-import findUp from "find-up";
+import { loadJsonFileSync } from "load-json-file";
+import { findUp } from "find-up";
 
 export class PackageJson {
     private readonly filePath: string;
     private readonly json: Record<string, any>;
 
     static fromFile(filePath: string) {
-        return new PackageJson(filePath, readJson(filePath));
+        return new PackageJson(filePath, loadJsonFileSync(filePath));
     }
 
     static async findClosest(fromPath: string) {

package/utils/PackageJson.js

@@ -1,12 +1,12 @@
-import readJson from "read-json-sync";
-import findUp from "find-up";
+import { loadJsonFileSync } from "load-json-file";
+import { findUp } from "find-up";
 
 export class PackageJson {
     filePath;
     json;
 
     static fromFile(filePath) {
-        return new PackageJson(filePath, readJson(filePath));
+        return new PackageJson(filePath, loadJsonFileSync(filePath));
     }
 
     static async findClosest(fromPath) {

package/workspaces/linkWorkspaces.js

@@ -1,7 +1,6 @@
 /**
  * This tool will re-link monorepo packages to one of the following directories (by priority):
- * - {package}/package.json -> publishConfig.directory
- * - lerna.json -> command.publish.contents
+ * - {package}/package.json -> webiny.publishFrom
  * - package root directory
  */
 
@@ -11,7 +10,6 @@ import path from "path";
 import get from "lodash/get.js";
 import fs from "fs-extra";
 import * as rimraf from "rimraf";
-import readJsonSync from "read-json-sync";
 
 async function symlink(src, dest) {
     if (process.platform !== "win32") {
@@ -53,13 +51,11 @@ const defaults = {
 
 export const linkWorkspaces = async ({ whitelist, blacklist } = defaults) => {
     console.log(`Linking project workspaces...`);
-    //eslint-disable-next-line import/dynamic-import-chunkname
     const { PackageJson } = await import("../utils/PackageJson.js");
 
     whitelist = (whitelist || []).map(p => path.resolve(p));
     blacklist = (blacklist || []).map(p => path.resolve(p));
     // Filter packages to only those in the whitelisted folders
-    //eslint-disable-next-line import/dynamic-import-chunkname
     const getYarnWorkspaces = await import("get-yarn-workspaces").then(m => m.default ?? m);
     const packages = getYarnWorkspaces(process.cwd())
         .map(pkg => pkg.replace(/\//g, path.sep))
@@ -73,9 +69,6 @@ export const linkWorkspaces = async ({ whitelist, blacklist } = defaults) => {
             return whitelist.some(w => pkg.startsWith(w));
         });
 
-    const lernaJson = path.resolve("lerna.json");
-    const lerna = fs.existsSync(lernaJson) ? readJsonSync(lernaJson) : null;
-
     for (let i = 0; i < packages.length; i++) {
         const packageJson = path.resolve(packages[i], "package.json");
         if (!fs.existsSync(packageJson)) {
@@ -85,11 +78,7 @@ export const linkWorkspaces = async ({ whitelist, blacklist } = defaults) => {
         const pkgJson = await PackageJson.fromFile(packageJson);
         const pkg = pkgJson.getJson();
 
-        let targetDirectory = get(pkg, "publishConfig.directory");
-        if (!targetDirectory && lerna) {
-            targetDirectory = get(lerna, "command.publish.contents");
-        }
-
+        const targetDirectory = get(pkg, "webiny.publishFrom");
         const link = path.resolve("node_modules", pkg.name);
         const target = path.resolve(packages[i], targetDirectory || ".");
 

package/.babelrc.js

@@ -1 +0,0 @@
-module.exports = require("./packages").createBabelConfigForNode({ path: __dirname });

package/.eslintrc.cjs

@@ -1,6 +0,0 @@
-module.exports = {
-    extends: ["../../.eslintrc.cjs"],
-    rules: {
-        "import/dynamic-import-chunkname": 0
-    }
-};

package/packages/buildPackage/babelCompile.js

@@ -1,103 +0,0 @@
-import fs from "fs";
-import { dirname, extname, join, parse, relative } from "path";
-import * as babel from "@babel/core";
-import glob from "fast-glob";
-
-const BABEL_COMPILE_EXTENSIONS = [".js", ".jsx", ".ts", ".tsx"];
-const BABEL_SKIP_EXTENSIONS = [".d.ts"];
-
-const withSourceMapUrl = (file, code) => {
-    const { name } = parse(file);
-    return [code, "", `//# sourceMappingURL=${name}.js.map`].join("\n");
-};
-
-const getDistCopyFilePath = ({ file, cwd }) => {
-    const relativeDir = relative(cwd, file);
-    return join(cwd, relativeDir.replace("src", "dist"));
-};
-
-const getDistFilePaths = ({ file, cwd }) => {
-    const { dir, name } = parse(file);
-
-    const relativeDir = relative(cwd, dir);
-
-    const code = join(cwd, relativeDir.replace("src", "dist"), name + ".js");
-    const map = join(cwd, relativeDir.replace("src", "dist"), name + ".js.map");
-    return { code, map };
-};
-
-export const babelCompile = async ({ cwd }) => {
-    // We're passing "*.*" just because we want to copy all files that cannot be compiled.
-    // We want to have the same behaviour that the Babel CLI's "--copy-files" flag provides.
-    const pattern = join(cwd, "src/**/*.*").replace(/\\/g, "/");
-    const files = glob.sync(pattern, {
-        onlyFiles: true,
-        dot: true
-    });
-
-    const compilations = [];
-    const copies = [];
-
-    for (let i = 0; i < files.length; i++) {
-        const file = files[i];
-        if (
-            fileEndsWith(file, BABEL_COMPILE_EXTENSIONS) &&
-            !fileEndsWith(file, BABEL_SKIP_EXTENSIONS)
-        ) {
-            compilations.push(
-                babel
-                    .transformFileAsync(file, {
-                        cwd,
-                        sourceMaps: true
-                    })
-                    .then(results => [file, results])
-            );
-            continue;
-        }
-
-        // All other files should be copied as-is.
-        copies.push(copyFile(file, cwd));
-    }
-
-    // At this point, just wait for compilations to be completed, so we can proceed with writing the files ASAP.
-    await Promise.all(compilations);
-
-    const writes = [];
-    for (let i = 0; i < compilations.length; i++) {
-        const [file, result] = await compilations[i];
-        const { code, map } = result;
-
-        const paths = getDistFilePaths({ file, cwd });
-        fs.mkdirSync(dirname(paths.code), { recursive: true });
-
-        // Save the compiled JS file.
-        writes.push(fs.promises.writeFile(paths.code, withSourceMapUrl(file, code), "utf8"));
-
-        // Save source maps file.
-        const mapJson = JSON.stringify(map);
-        writes.push(fs.promises.writeFile(paths.map, mapJson, "utf8"));
-    }
-
-    // Wait until all files have been written to disk.
-    return Promise.all([...writes, ...copies]);
-};
-
-function copyFile(file, cwd) {
-    return new Promise((resolve, reject) => {
-        try {
-            const destPath = getDistCopyFilePath({ file, cwd });
-            if (!fs.existsSync(dirname(destPath))) {
-                fs.mkdirSync(dirname(destPath), { recursive: true });
-            }
-
-            fs.copyFileSync(file, destPath);
-            resolve();
-        } catch (e) {
-            reject(e);
-        }
-    });
-}
-
-function fileEndsWith(file, extensions) {
-    return extensions.some(ext => file.endsWith(ext));
-}

package/packages/createBabelConfigForNode.js

@@ -1,19 +0,0 @@
-export default ({ path }) => {
-    return {
-        presets: [
-            ["@babel/preset-react", { useBuiltIns: true }],
-            ["@babel/preset-typescript", { isTSX: true, allExtensions: true }]
-        ],
-        plugins: [
-            [
-                "babel-plugin-module-resolver",
-                {
-                    cwd: path,
-                    alias: {
-                        "~": "./src"
-                    }
-                }
-            ]
-        ]
-    };
-};

package/packages/createBabelConfigForReact.js

@@ -1,20 +0,0 @@
-export default ({ path }) => ({
-    presets: [
-        ["@babel/preset-react", { useBuiltIns: true }],
-        ["@babel/preset-typescript", { isTSX: true, allExtensions: true }]
-    ],
-    plugins: [
-        "babel-plugin-macros",
-        "@babel/plugin-proposal-throw-expressions",
-        ["@emotion/babel-plugin", { autoLabel: "dev-only" }],
-        [
-            "babel-plugin-module-resolver",
-            {
-                cwd: path,
-                alias: {
-                    "~": "./src"
-                }
-            }
-        ]
-    ]
-});

package/packages/createSwcConfigForNode.js

@@ -1,45 +0,0 @@
-import readJsonSync from "read-json-sync";
-
-export default ({ path, esm }) => {
-    return {
-        presets: [
-            [
-                "@babel/preset-env",
-                {
-                    targets: {
-                        node: "18"
-                    },
-                    modules: esm ? false : "auto",
-                    exclude: [
-                        "transform-typeof-symbol",
-                        "@babel/plugin-proposal-optional-chaining",
-                        "@babel/plugin-proposal-nullish-coalescing-operator",
-                        "@babel/plugin-proposal-class-properties",
-                        "@babel/plugin-transform-async-to-generator",
-                        "@babel/plugin-transform-regenerator",
-                        "@babel/plugin-proposal-dynamic-import"
-                    ]
-                }
-            ],
-            "@babel/preset-typescript"
-        ],
-        plugins: [
-            [
-                "@babel/plugin-transform-runtime",
-                {
-                    useESModules: !!esm,
-                    version: readJsonSync(require.resolve("@babel/runtime/package.json")).version
-                }
-            ],
-            [
-                "babel-plugin-module-resolver",
-                {
-                    cwd: path,
-                    alias: {
-                        "~": "./src"
-                    }
-                }
-            ]
-        ]
-    };
-};