@meteorjs/rspack 1.1.0-beta.22 → 1.1.0-beta.30

package/index.d.ts

@@ -75,12 +75,6 @@ type MeteorEnv = Record<string, any> & {
   disablePlugins: (
     matchers: string | RegExp | ((plugin: any, index: number) => boolean) | Array<string | RegExp | ((plugin: any, index: number) => boolean)>
   ) => Record<string, any>;
-  /**
-   * Omit `Meteor.isDevelopment` and `Meteor.isProduction` from the DefinePlugin so
-   * the bundle is not tied to a specific Meteor environment (portable / isomorphic builds).
-   * @returns A config fragment with `meteor.enablePortableBuild: true`
-   */
-  enablePortableBuild: () => Record<string, any>;
 }
 
 export type ConfigFactory = (

package/lib/ignore.js

@@ -117,7 +117,7 @@ function createIgnoreRegex(globPatterns) {
 
     // For absolute paths, we don't want to force the pattern to match from the beginning
     // but we still want to ensure it matches to the end of the path segment
-    regexPattern = '(?:^|/)' + regexPattern + '$';
+    regexPattern = '(?:^|/)' + regexPattern;
 
     return regexPattern;
   }).filter(pattern => pattern !== null);

package/lib/meteorRspackHelpers.js

@@ -152,19 +152,6 @@ function extendSwcConfig(swcConfig) {
   });
 }
 
-/**
- * Signal that `Meteor.isDevelopment` and `Meteor.isProduction` should be omitted
- * from DefinePlugin, making the bundle portable across Meteor environments.
- * Usage: return Meteor.enablePortableBuild() in your rspack.config.js
- *
- * @returns {Record<string, object>} config fragment with `meteor.enablePortableBuild: true`
- */
-function enablePortableBuild() {
-  return prepareMeteorRspackConfig({
-    "meteor.enablePortableBuild": true,
-  });
-}
-
 /**
  * Remove plugins from a Rspack config by name, RegExp, predicate, or array of them.
  * When using a function predicate, it receives both the plugin and its index in the plugins array.
@@ -215,6 +202,12 @@ function disablePlugins(config, matchers) {
   return config;
 }
 
+function outputMeteorRspack(data) {
+  const jsonString = JSON.stringify(data);
+  const output = `[Meteor-Rspack]${jsonString}[/Meteor-Rspack]`;
+  console.log(output);
+}
+
 module.exports = {
   compileWithMeteor,
   compileWithRspack,
@@ -223,5 +216,5 @@ module.exports = {
   extendSwcConfig,
   makeWebNodeBuiltinsAlias,
   disablePlugins,
-  enablePortableBuild,
+  outputMeteorRspack,
 };

package/lib/test.js

@@ -9,6 +9,7 @@ const { createIgnoreRegex, createIgnoreGlobConfig } = require("./ignore.js");
  * @param {string} options.projectDir - The project directory
  * @param {string} options.buildContext - The build context
  * @param {string[]} options.ignoreEntries - Array of ignore patterns
+ * @param {string[]} options.meteorIgnoreEntries - Array of meteor ignore patterns
  * @param {string} options.extraEntry - Extra entry to load
  * @returns {string} The path to the generated file
  */
@@ -17,6 +18,7 @@ const generateEagerTestFile = ({
   projectDir,
   buildContext,
   ignoreEntries: inIgnoreEntries = [],
+  meteorIgnoreEntries: inMeteorIgnoreEntries = [],
   prefix: inPrefix = '',
   extraEntry,
   globalImportPath,
@@ -40,6 +42,11 @@ const generateEagerTestFile = ({
   const excludeFoldersRegex = createIgnoreRegex(
     createIgnoreGlobConfig(ignoreEntries)
   );
+  console.log("inMeteorIgnoreEntries", inMeteorIgnoreEntries);
+  // Create regex from meteor ignore entries
+  const excludeMeteorIgnoreRegex = inMeteorIgnoreEntries.length > 0
+    ? createIgnoreRegex(createIgnoreGlobConfig(inMeteorIgnoreEntries))
+    : null;
 
   const prefix = (inPrefix && `${inPrefix}-`) || "";
   const filename = isAppTest
@@ -51,15 +58,27 @@ const generateEagerTestFile = ({
     : "/\\.(?:test|spec)s?\\.[^.]+$/";
 
   const content = `${
-    globalImportPath ? `import '${globalImportPath}';\n\n` : ''
-  }{
-  const ctx = import.meta.webpackContext('/', {
+    globalImportPath ? `import '${globalImportPath}';\n\n` : ""
+  }${
+    excludeMeteorIgnoreRegex
+      ? `const MeteorIgnoreRegex = ${excludeMeteorIgnoreRegex.toString()};`
+      : ""
+  }
+{
+  const ctx = import.meta.webpackContext('${projectDir}', {
     recursive: true,
     regExp: ${regExp},
     exclude: ${excludeFoldersRegex.toString()},
     mode: 'eager',
   });
-  ctx.keys().forEach(ctx);
+  ctx.keys().filter((k) => {
+    ${
+      excludeMeteorIgnoreRegex
+        ? `// Only exclude based on *relative* path segments.
+    return !MeteorIgnoreRegex.test(k);`
+        : "return true;"
+    }
+  }).forEach(ctx);
   ${
     extraEntry
       ? `const extra = import.meta.webpackContext('${path.dirname(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meteorjs/rspack",
-  "version": "1.1.0-beta.22",
+  "version": "1.1.0-beta.30",
   "description": "Configuration logic for using Rspack in Meteor projects",
   "main": "index.js",
   "type": "commonjs",

package/plugins/MeteorRspackOutputPlugin.js

@@ -0,0 +1,36 @@
+// MeteorRspackOutputPlugin.js
+//
+// This plugin outputs a JSON stringified with a tag delimiter each time
+// a new Rspack compilation happens. The JSON content is configurable
+// via plugin instantiation options.
+
+const { outputMeteorRspack } = require('../lib/meteorRspackHelpers');
+
+class MeteorRspackOutputPlugin {
+  constructor(options = {}) {
+    this.pluginName = 'MeteorRspackOutputPlugin';
+    this.options = options;
+    this.compilationCount = 0;
+    // The data to be output as JSON, can be a static object or a function
+    this.getData =
+      typeof options.getData === 'function'
+        ? options.getData
+        : () => options.data || {};
+  }
+
+  apply(compiler) {
+    // Hook into the 'done' event which fires after each compilation completes
+    compiler.hooks.done.tap(this.pluginName, stats => {
+      this.compilationCount++;
+      const data = {
+        ...(this.getData(stats, {
+          compilationCount: this.compilationCount,
+          isRebuild: this.compilationCount > 1,
+        }) || {}),
+      };
+      outputMeteorRspack(data);
+    });
+  }
+}
+
+module.exports = { MeteorRspackOutputPlugin };

package/rspack.config.js

@@ -10,8 +10,10 @@ const { getMeteorAppSwcConfig } = require('./lib/swc.js');
 const HtmlRspackPlugin = require('./plugins/HtmlRspackPlugin.js');
 const { RequireExternalsPlugin } = require('./plugins/RequireExtenalsPlugin.js');
 const { AssetExternalsPlugin } = require('./plugins/AssetExternalsPlugin.js');
+const { MeteorRspackOutputPlugin } = require('./plugins/MeteorRspackOutputPlugin.js');
 const { generateEagerTestFile } = require("./lib/test.js");
 const { getMeteorIgnoreEntries, createIgnoreGlobConfig } = require("./lib/ignore");
+const { mergeMeteorRspackFragments } = require("./lib/meteorRspackConfigFactory.js");
 const {
   compileWithMeteor,
   compileWithRspack,
@@ -20,9 +22,8 @@ const {
   extendSwcConfig,
   makeWebNodeBuiltinsAlias,
   disablePlugins,
-  enablePortableBuild,
+  outputMeteorRspack,
 } = require('./lib/meteorRspackHelpers.js');
-const { loadUserAndOverrideConfig } = require('./lib/meteorRspackConfigHelpers.js');
 const { prepareMeteorRspackConfig } = require("./lib/meteorRspackConfigFactory");
 
 // Safe require that doesn't throw if the module isn't found
@@ -41,7 +42,11 @@ function safeRequire(moduleName) {
 }
 
 // Persistent filesystem cache strategy
-function createCacheStrategy(mode, side, { projectConfigPath, configPath } = {}) {
+function createCacheStrategy(
+  mode,
+  side,
+  { projectConfigPath, configPath, buildContext } = {},
+) {
   // Check for configuration files
   const tsconfigPath = path.join(process.cwd(), 'tsconfig.json');
   const hasTsconfig = fs.existsSync(tsconfigPath);
@@ -82,7 +87,9 @@ function createCacheStrategy(mode, side, { projectConfigPath, configPath } = {})
         type: "persistent",
         storage: {
           type: "filesystem",
-          directory: `node_modules/.cache/rspack${(side && `/${side}`) || ""}`,
+          directory: `node_modules/.cache/rspack${
+            (buildContext && `-${buildContext}`) || ''
+          }${(side && `/${side}`) || ''}`,
         },
         ...(buildDependencies.length > 0 && {
           buildDependencies: buildDependencies,
@@ -205,29 +212,15 @@ module.exports = async function (inMeteor = {}, argv = {}) {
   const Meteor = { ...inMeteor };
   // Convert string boolean values to actual booleans
   for (const key in Meteor) {
-    if (Meteor[key] === "true" || Meteor[key] === true) {
+    if (Meteor[key] === 'true' || Meteor[key] === true) {
       Meteor[key] = true;
-    } else if (Meteor[key] === "false" || Meteor[key] === false) {
+    } else if (Meteor[key] === 'false' || Meteor[key] === false) {
       Meteor[key] = false;
     }
   }
 
-  const isTestLike = !!Meteor.isTestLike;
-  const swcExternalHelpers = !!Meteor.swcExternalHelpers;
-  const isNative = !!Meteor.isNative;
-  const devServerPort = Meteor.devServerPort || 8080;
-
-  const projectDir = process.cwd();
-  const projectConfigPath =
-    Meteor.projectConfigPath || path.resolve(projectDir, "rspack.config.js");
-
-  // Compute build paths before loading user config (needed by Meteor helpers below)
-  const buildContext = Meteor.buildContext || "_build";
-  const outputPath = Meteor.outputPath;
-  const outputDir = path.dirname(Meteor.outputPath || "");
-  Meteor.buildOutputDir = path.resolve(projectDir, buildContext, outputDir);
-
-  // Meteor flags derived purely from input; independent of loaded user/override configs
+  const isProd = !!Meteor.isProduction || argv.mode === 'production';
+  const isDev = !!Meteor.isDevelopment || !isProd;
   const isTest = !!Meteor.isTest;
   const isClient = !!Meteor.isClient;
   const isServer = !!Meteor.isServer;
@@ -237,6 +230,17 @@ module.exports = async function (inMeteor = {}, argv = {}) {
   const isTestModule = !!Meteor.isTestModule;
   const isTestEager = !!Meteor.isTestEager;
   const isTestFullApp = !!Meteor.isTestFullApp;
+  const isTestLike = !!Meteor.isTestLike;
+  const swcExternalHelpers = !!Meteor.swcExternalHelpers;
+  const isNative = !!Meteor.isNative;
+  const isProfile = !!Meteor.isProfile;
+  const isVerbose = !!Meteor.isVerbose;
+  const mode = isProd ? 'production' : 'development';
+  const projectDir = process.cwd();
+  const projectConfigPath = Meteor.projectConfigPath || path.resolve(projectDir, 'rspack.config.js');
+  const configPath = Meteor.configPath;
+  const testEntry = Meteor.testEntry;
+
   const isTypescriptEnabled = Meteor.isTypescriptEnabled || false;
   const isJsxEnabled =
     Meteor.isJsxEnabled || (!isTypescriptEnabled && isReactEnabled) || false;
@@ -244,65 +248,70 @@ module.exports = async function (inMeteor = {}, argv = {}) {
     Meteor.isTsxEnabled || (isTypescriptEnabled && isReactEnabled) || false;
   const isBundleVisualizerEnabled = Meteor.isBundleVisualizerEnabled || false;
   const isAngularEnabled = Meteor.isAngularEnabled || false;
-  const enableSwcExternalHelpers = !isServer && swcExternalHelpers;
 
-  // Defined here so it can be called both before and after the first config load;
-  // without loaded configs it falls through to argv/Meteor flags.
-  const getModeFromConfig = (userConfig, overrideConfig) => {
-    if (overrideConfig?.mode) return overrideConfig.mode;
-    if (userConfig?.mode) return userConfig.mode;
-    if (argv.mode) return argv.mode;
-    if (Meteor.isProduction) return "production";
-    if (Meteor.isDevelopment) return "development";
-    return null;
-  };
+  // Determine entry points
+  const entryPath = Meteor.entryPath;
+
+  // Determine output points
+  const outputPath = Meteor.outputPath;
+  const outputDir = path.dirname(Meteor.outputPath || '');
+
+  const outputFilename = Meteor.outputFilename;
+
+  // Determine run point
+  const runPath = Meteor.runPath;
+
+  // Determine banner
+  const bannerOutput = JSON.parse(Meteor.bannerOutput || process.env.RSPACK_BANNER || '""');
 
-  // Initial mode before user/override configs are loaded
-  const initialCurrentMode = getModeFromConfig();
-  const initialIsProd = initialCurrentMode
-    ? initialCurrentMode === "production"
-    : !!Meteor.isProduction;
-  const initialIsDev = initialCurrentMode
-    ? initialCurrentMode === "development"
-    : !!Meteor.isDevelopment || !initialIsProd;
-  const initialMode = initialIsProd ? "production" : "development";
-
-  // Initialized with pre-load values so helpers work during the first config load;
-  // reassigned after load once mode is fully resolved.
-  let cacheStrategy = createCacheStrategy(
-    initialMode,
-    (isClient && "client") || "server",
-    { projectConfigPath, configPath: Meteor.configPath }
+  // Determine output directories
+  const clientOutputDir = path.resolve(projectDir, 'public');
+  const serverOutputDir = path.resolve(projectDir, 'private');
+
+  // Determine context for bundles and assets
+  const meteorLocalDirName = process.env.METEOR_LOCAL_DIR
+    ? path.basename(process.env.METEOR_LOCAL_DIR.replace(/\\/g, '/'))
+    : '';
+  const buildContext =
+    Meteor.buildContext ||
+    process.env.RSPACK_BUILD_CONTEXT ||
+    `_build${(meteorLocalDirName && `-${meteorLocalDirName}`) || ''}`;
+  const assetsContext =
+    Meteor.assetsContext ||
+    process.env.RSPACK_ASSETS_CONTEXT ||
+    `build-assets${(meteorLocalDirName && `-${meteorLocalDirName}`) || ''}`;
+  const chunksContext =
+    Meteor.chunksContext ||
+    process.env.RSPACK_CHUNKS_CONTEXT ||
+    `build-chunks${(meteorLocalDirName && `-${meteorLocalDirName}`) || ''}`;
+
+  // Determine build output and pass to Meteor
+  const buildOutputDir = path.resolve(projectDir, buildContext, outputDir);
+  Meteor.buildOutputDir = buildOutputDir;
+
+  const cacheStrategy = createCacheStrategy(
+    mode,
+    (Meteor.isClient && 'client') || 'server',
+    { projectConfigPath, configPath, buildContext }
   );
-  let swcConfigRule = createSwcConfig({
-    isTypescriptEnabled,
-    isReactEnabled,
-    isJsxEnabled,
-    isTsxEnabled,
-    externalHelpers: enableSwcExternalHelpers,
-    isDevEnvironment: isRun && initialIsDev && !isTest && !isNative,
-    isClient,
-    isAngularEnabled,
-  });
-  Meteor.swcConfigOptions = swcConfigRule.options;
 
   // Expose Meteor's helpers to expand Rspack configs
-  Meteor.compileWithMeteor = (deps) => compileWithMeteor(deps);
+  Meteor.compileWithMeteor = deps => compileWithMeteor(deps);
   Meteor.compileWithRspack = (deps, options = {}) =>
     compileWithRspack(deps, {
       options: mergeSplitOverlap(Meteor.swcConfigOptions, options),
     });
-  Meteor.setCache = (enabled) =>
-    setCache(!!enabled, enabled === "memory" ? undefined : cacheStrategy);
+  Meteor.setCache = enabled =>
+    setCache(
+      !!enabled,
+      enabled === 'memory' ? undefined : cacheStrategy
+    );
   Meteor.splitVendorChunk = () => splitVendorChunk();
-  Meteor.extendSwcConfig = (customSwcConfig) =>
-    extendSwcConfig(customSwcConfig);
+  Meteor.extendSwcConfig = (customSwcConfig) => extendSwcConfig(customSwcConfig);
   Meteor.extendConfig = (...configs) => mergeSplitOverlap(...configs);
-  Meteor.disablePlugins = (matchers) =>
-    prepareMeteorRspackConfig({
-      disablePlugins: matchers,
-    });
-  Meteor.enablePortableBuild = () => enablePortableBuild();
+  Meteor.disablePlugins = matchers => prepareMeteorRspackConfig({
+    disablePlugins: matchers,
+  });
 
   // Add HtmlRspackPlugin function to Meteor
   Meteor.HtmlRspackPlugin = (options = {}) => {
@@ -326,57 +335,6 @@ module.exports = async function (inMeteor = {}, argv = {}) {
     });
   };
 
-  // First pass: resolve user/override configs early so mode overrides (e.g. "production")
-  // are available before computing isProd/isDev and the rest of the build flags.
-  // Skipped for Angular since it manages its own mode via the second pass.
-  let { nextUserConfig, nextOverrideConfig } = isAngularEnabled
-    ? {}
-    : await loadUserAndOverrideConfig(projectConfigPath, Meteor, argv);
-
-  // Determine the final mode with loaded configs
-  const currentMode = getModeFromConfig(nextUserConfig, nextOverrideConfig);
-  const isProd = currentMode
-    ? currentMode === "production"
-    : !!Meteor.isProduction;
-  const isDev = currentMode
-    ? currentMode === "development"
-    : !!Meteor.isDevelopment || !isProd;
-  const mode = isProd ? "production" : "development";
-  const isPortableBuild = !!(
-    nextUserConfig?.["meteor.enablePortableBuild"] ||
-    nextOverrideConfig?.["meteor.enablePortableBuild"]
-  );
-  const configPath = Meteor.configPath;
-  const testEntry = Meteor.testEntry;
-
-  // Determine entry points
-  const entryPath = Meteor.entryPath || "";
-
-  // Determine output points
-  const outputFilename = Meteor.outputFilename;
-
-  // Determine context for bundles and assets
-  const assetsContext = Meteor.assetsContext || "build-assets";
-  const chunksContext = Meteor.chunksContext || "build-chunks";
-
-  cacheStrategy = createCacheStrategy(
-    mode,
-    (Meteor.isClient && "client") || "server",
-    { projectConfigPath, configPath }
-  );
-
-  // Determine run point
-  const runPath = Meteor.runPath || "";
-
-  // Determine banner
-  const bannerOutput = JSON.parse(
-    Meteor.bannerOutput || process.env.RSPACK_BANNER || '""'
-  );
-
-  // Determine output directories
-  const clientOutputDir = path.resolve(projectDir, "public");
-  const serverOutputDir = path.resolve(projectDir, "private");
-
   // Get Meteor ignore entries
   const meteorIgnoreEntries = getMeteorIgnoreEntries(projectDir);
 
@@ -392,17 +350,21 @@ module.exports = async function (inMeteor = {}, argv = {}) {
   // Set default watch options
   const watchOptions = {
     ignored: [
-      ...createIgnoreGlobConfig([...meteorIgnoreEntries, ...additionalEntries]),
+      ...createIgnoreGlobConfig([
+        ...meteorIgnoreEntries,
+        ...additionalEntries,
+      ]),
     ],
   };
 
   if (Meteor.isDebug || Meteor.isVerbose) {
-    console.log("[i] Rspack mode:", mode);
-    console.log("[i] Meteor flags:", Meteor);
+    console.log('[i] Rspack mode:', mode);
+    console.log('[i] Meteor flags:', Meteor);
   }
 
+  const enableSwcExternalHelpers = !isServer && swcExternalHelpers;
   const isDevEnvironment = isRun && isDev && !isTest && !isNative;
-  swcConfigRule = createSwcConfig({
+  const swcConfigRule = createSwcConfig({
     isTypescriptEnabled,
     isReactEnabled,
     isJsxEnabled,
@@ -412,6 +374,7 @@ module.exports = async function (inMeteor = {}, argv = {}) {
     isClient,
     isAngularEnabled,
   });
+  // Expose swc config to use in custom configs
   Meteor.swcConfigOptions = swcConfigRule.options;
 
   const externals = [
@@ -420,34 +383,34 @@ module.exports = async function (inMeteor = {}, argv = {}) {
     ...(isServer ? [/^bcrypt$/] : []),
   ];
   const alias = {
-    "/": path.resolve(process.cwd()),
+    '/': path.resolve(process.cwd()),
   };
   const fallback = {
     ...(isClient && makeWebNodeBuiltinsAlias()),
   };
   const extensions = [
-    ".ts",
-    ".tsx",
-    ".mts",
-    ".cts",
-    ".js",
-    ".jsx",
-    ".mjs",
-    ".cjs",
-    ".json",
-    ".wasm",
+    '.ts',
+    '.tsx',
+    '.mts',
+    '.cts',
+    '.js',
+    '.jsx',
+    '.mjs',
+    '.cjs',
+    '.json',
+    '.wasm',
   ];
   const extraRules = [];
 
   const reactRefreshModule = isReactEnabled
-    ? safeRequire("@rspack/plugin-react-refresh")
+    ? safeRequire('@rspack/plugin-react-refresh')
     : null;
 
   const requireExternalsPlugin = new RequireExternalsPlugin({
     filePath: path.join(buildContext, runPath),
     ...(Meteor.isBlazeEnabled && {
       externals: /\.html$/,
-      isEagerImport: (module) => module.endsWith(".html"),
+      isEagerImport: module => module.endsWith('.html'),
       ...(isProd && {
         lastImports: [`./${outputFilename}`],
       }),
@@ -457,26 +420,25 @@ module.exports = async function (inMeteor = {}, argv = {}) {
 
   // Handle assets
   const assetExternalsPlugin = new AssetExternalsPlugin();
-  const assetModuleFilename = (_fileInfo) => {
+  const assetModuleFilename = _fileInfo => {
     const filename = _fileInfo.filename;
-    const isPublic = filename.startsWith("/") || filename.startsWith("public");
+    const isPublic = filename.startsWith('/') || filename.startsWith('public');
     if (isPublic) return `[name][ext][query]`;
     return `${assetsContext}/[hash][ext][query]`;
   };
 
   const rsdoctorModule = isBundleVisualizerEnabled
-    ? safeRequire("@rsdoctor/rspack-plugin")
+    ? safeRequire('@rsdoctor/rspack-plugin')
     : null;
-  const doctorPluginConfig =
-    isRun && isBundleVisualizerEnabled && rsdoctorModule?.RsdoctorRspackPlugin
-      ? [
-          new rsdoctorModule.RsdoctorRspackPlugin({
-            port: isClient
-              ? parseInt(Meteor.rsdoctorClientPort || "8888", 10)
-              : parseInt(Meteor.rsdoctorServerPort || "8889", 10),
-          }),
-        ]
-      : [];
+  const doctorPluginConfig = isRun && isBundleVisualizerEnabled && rsdoctorModule?.RsdoctorRspackPlugin
+    ? [
+        new rsdoctorModule.RsdoctorRspackPlugin({
+          port: isClient
+            ? (parseInt(Meteor.rsdoctorClientPort || '8888', 10))
+            : (parseInt(Meteor.rsdoctorServerPort || '8889', 10)),
+        }),
+      ]
+    : [];
   const bannerPluginConfig = !isBuild
     ? [
         new BannerPlugin({
@@ -487,6 +449,10 @@ module.exports = async function (inMeteor = {}, argv = {}) {
     : [];
   // Not supported in Meteor yet (Rspack 1.7+ is enabled by default)
   const lazyCompilationConfig = { lazyCompilation: false };
+  const shouldLogVerbose = isProfile || isVerbose;
+  const loggingConfig = shouldLogVerbose
+    ? {}
+    : { stats: "errors-warnings", infrastructureLogging: { level: "warn" } };
 
   const clientEntry =
     isClient && isTest && isTestEager && isTestFullApp
@@ -494,7 +460,8 @@ module.exports = async function (inMeteor = {}, argv = {}) {
           isAppTest: true,
           projectDir,
           buildContext,
-          ignoreEntries: [...meteorIgnoreEntries, "**/server/**"],
+          ignoreEntries: ["**/server/**"],
+          meteorIgnoreEntries,
           prefix: "client",
           extraEntry: path.resolve(process.cwd(), Meteor.mainClientEntry),
           globalImportPath: path.resolve(projectDir, buildContext, entryPath),
@@ -505,18 +472,19 @@ module.exports = async function (inMeteor = {}, argv = {}) {
           isClient: true,
           projectDir,
           buildContext,
-          ignoreEntries: [...meteorIgnoreEntries, "**/server/**"],
+          ignoreEntries: ["**/server/**"],
+          meteorIgnoreEntries,
           prefix: "client",
           globalImportPath: path.resolve(projectDir, buildContext, entryPath),
         })
       : isClient && isTest && testEntry
       ? path.resolve(process.cwd(), testEntry)
       : path.resolve(process.cwd(), buildContext, entryPath);
-  const clientNameConfig = `[${(isTest && "test-") || ""}client-rspack]`;
+  const clientNameConfig = `[${(isTest && 'test-') || ''}client-rspack]`;
   // Base client config
   let clientConfig = {
     name: clientNameConfig,
-    target: "web",
+    target: 'web',
     mode,
     entry: clientEntry,
     output: {
@@ -525,7 +493,7 @@ module.exports = async function (inMeteor = {}, argv = {}) {
         const chunkName = _module.chunk?.name;
         const isMainChunk = !chunkName || chunkName === "main";
         const chunkSuffix = `${chunksContext}/[id]${
-          isProd ? ".[chunkhash]" : ""
+          isProd ? '.[chunkhash]' : ''
         }.js`;
         if (isDevEnvironment) {
           if (isMainChunk) return outputFilename;
@@ -534,21 +502,21 @@ module.exports = async function (inMeteor = {}, argv = {}) {
         if (isMainChunk) return `../${buildContext}/${outputPath}`;
         return chunkSuffix;
       },
-      libraryTarget: "commonjs2",
-      publicPath: "/",
-      chunkFilename: `${chunksContext}/[id]${isProd ? ".[chunkhash]" : ""}.js`,
+      libraryTarget: 'commonjs2',
+      publicPath: '/',
+      chunkFilename: `${chunksContext}/[id]${isProd ? '.[chunkhash]' : ''}.js`,
       assetModuleFilename,
       cssFilename: `${chunksContext}/[name]${
-        isProd ? ".[contenthash]" : ""
+        isProd ? '.[contenthash]' : ''
       }.css`,
       cssChunkFilename: `${chunksContext}/[id]${
-        isProd ? ".[contenthash]" : ""
+        isProd ? '.[contenthash]' : ''
       }.css`,
       ...(isProd && { clean: { keep: keepOutsideBuild() } }),
     },
     optimization: {
       usedExports: true,
-      splitChunks: { chunks: "async" },
+      splitChunks: { chunks: 'async' },
     },
     module: {
       rules: [
@@ -557,7 +525,7 @@ module.exports = async function (inMeteor = {}, argv = {}) {
           ? [
               {
                 test: /\.html$/i,
-                loader: "ignore-loader",
+                loader: 'ignore-loader',
               },
             ]
           : []),
@@ -575,43 +543,46 @@ module.exports = async function (inMeteor = {}, argv = {}) {
         assetExternalsPlugin,
       ].filter(Boolean),
       new DefinePlugin({
-        "Meteor.isClient": JSON.stringify(true),
-        "Meteor.isServer": JSON.stringify(false),
-        "Meteor.isTest": JSON.stringify(isTestLike && !isTestFullApp),
-        "Meteor.isAppTest": JSON.stringify(isTestLike && isTestFullApp),
-        ...(!isPortableBuild && {
-          "Meteor.isDevelopment": JSON.stringify(isDev),
-          "Meteor.isProduction": JSON.stringify(isProd),
-        }),
+        'Meteor.isClient': JSON.stringify(true),
+        'Meteor.isServer': JSON.stringify(false),
+        'Meteor.isTest': JSON.stringify(isTestLike && !isTestFullApp),
+        'Meteor.isAppTest': JSON.stringify(isTestLike && isTestFullApp),
+        'Meteor.isDevelopment': JSON.stringify(isDev),
+        'Meteor.isProduction': JSON.stringify(isProd),
       }),
       ...bannerPluginConfig,
       Meteor.HtmlRspackPlugin(),
       ...doctorPluginConfig,
       new NormalModuleReplacementPlugin(/^node:(.*)$/, (res) => {
-        res.request = res.request.replace(/^node:/, "");
+        res.request = res.request.replace(/^node:/, '');
       }),
     ],
     watchOptions,
-    devtool:
-      isDevEnvironment || isNative || isTest
-        ? "source-map"
-        : "hidden-source-map",
+    devtool: isDevEnvironment || isNative || isTest ? 'source-map' : 'hidden-source-map',
     ...(isDevEnvironment && {
       devServer: {
         ...createRemoteDevServerConfig(),
-        static: { directory: clientOutputDir, publicPath: "/__rspack__/" },
+        static: { directory: clientOutputDir, publicPath: '/__rspack__/' },
         hot: true,
         liveReload: true,
         ...(Meteor.isBlazeEnabled && { hot: false }),
-        port: devServerPort,
+        port: Meteor.devServerPort || 8080,
         devMiddleware: {
-          writeToDisk: (filePath) =>
-            /\.(html)$/.test(filePath) && !filePath.includes(".hot-update."),
+          writeToDisk: filePath =>
+            /\.(html)$/.test(filePath) && !filePath.includes('.hot-update.'),
+        },
+        onListening(devServer) {
+          if (!devServer) return;
+          const { host, port } = devServer.options;
+          const protocol = devServer.options.server?.type === "https" ? "https" : "http";
+          const devServerUrl = `${protocol}://${host || "localhost"}:${port}`;
+          outputMeteorRspack({ devServerUrl });
         },
       },
     }),
     ...merge(cacheStrategy, { experiments: { css: true } }),
     ...lazyCompilationConfig,
+    ...loggingConfig,
   };
 
   const serverEntry =
@@ -620,7 +591,8 @@ module.exports = async function (inMeteor = {}, argv = {}) {
           isAppTest: true,
           projectDir,
           buildContext,
-          ignoreEntries: [...meteorIgnoreEntries, "**/client/**"],
+          ignoreEntries: ["**/client/**"],
+          meteorIgnoreEntries,
           prefix: "server",
           globalImportPath: path.resolve(projectDir, buildContext, entryPath),
         })
@@ -629,25 +601,26 @@ module.exports = async function (inMeteor = {}, argv = {}) {
           isAppTest: false,
           projectDir,
           buildContext,
-          ignoreEntries: [...meteorIgnoreEntries, "**/client/**"],
+          ignoreEntries: ["**/client/**"],
+          meteorIgnoreEntries,
           prefix: "server",
           globalImportPath: path.resolve(projectDir, buildContext, entryPath),
         })
       : isServer && isTest && testEntry
       ? path.resolve(process.cwd(), testEntry)
       : path.resolve(projectDir, buildContext, entryPath);
-  const serverNameConfig = `[${(isTest && "test-") || ""}server-rspack]`;
+  const serverNameConfig = `[${(isTest && 'test-') || ''}server-rspack]`;
   // Base server config
   let serverConfig = {
     name: serverNameConfig,
-    target: "node",
+    target: 'node',
     mode,
     entry: serverEntry,
     output: {
       path: serverOutputDir,
       filename: () => `../${buildContext}/${outputPath}`,
-      libraryTarget: "commonjs2",
-      chunkFilename: `${chunksContext}/[id]${isProd ? ".[chunkhash]" : ""}.js`,
+      libraryTarget: 'commonjs2',
+      chunkFilename: `${chunksContext}/[id]${isProd ? '.[chunkhash]' : ''}.js`,
       assetModuleFilename,
       ...(isProd && { clean: { keep: keepOutsideBuild() } }),
     },
@@ -661,15 +634,15 @@ module.exports = async function (inMeteor = {}, argv = {}) {
       parser: {
         javascript: {
           // Dynamic imports on the server are treated as bundled in the same chunk
-          dynamicImportMode: "eager",
+          dynamicImportMode: 'eager',
         },
       },
     },
     resolve: {
       extensions,
       alias,
-      modules: ["node_modules", path.resolve(projectDir)],
-      conditionNames: ["import", "require", "node", "default"],
+      modules: ['node_modules', path.resolve(projectDir)],
+      conditionNames: ['import', 'require', 'node', 'default'],
     },
     externals,
     externalsPresets: { node: true },
@@ -677,22 +650,18 @@ module.exports = async function (inMeteor = {}, argv = {}) {
       new DefinePlugin(
         isTest && (isTestModule || isTestEager)
           ? {
-              "Meteor.isTest": JSON.stringify(isTest && !isTestFullApp),
-              "Meteor.isAppTest": JSON.stringify(isTest && isTestFullApp),
-              ...(!isPortableBuild && {
-                "Meteor.isDevelopment": JSON.stringify(isDev),
-              }),
+              'Meteor.isTest': JSON.stringify(isTest && !isTestFullApp),
+              'Meteor.isAppTest': JSON.stringify(isTest && isTestFullApp),
+              'Meteor.isDevelopment': JSON.stringify(isDev),
             }
           : {
-              "Meteor.isClient": JSON.stringify(false),
-              "Meteor.isServer": JSON.stringify(true),
-              "Meteor.isTest": JSON.stringify(isTestLike && !isTestFullApp),
-              "Meteor.isAppTest": JSON.stringify(isTestLike && isTestFullApp),
-              ...(!isPortableBuild && {
-                "Meteor.isDevelopment": JSON.stringify(isDev),
-                "Meteor.isProduction": JSON.stringify(isProd),
-              }),
-            }
+              'Meteor.isClient': JSON.stringify(false),
+              'Meteor.isServer': JSON.stringify(true),
+              'Meteor.isTest': JSON.stringify(isTestLike && !isTestFullApp),
+              'Meteor.isAppTest': JSON.stringify(isTestLike && isTestFullApp),
+              'Meteor.isDevelopment': JSON.stringify(isDev),
+              'Meteor.isProduction': JSON.stringify(isProd),
+            },
       ),
       ...bannerPluginConfig,
       requireExternalsPlugin,
@@ -700,20 +669,111 @@ module.exports = async function (inMeteor = {}, argv = {}) {
       ...doctorPluginConfig,
     ],
     watchOptions,
-    devtool:
-      isDevEnvironment || isNative || isTest
-        ? "source-map"
-        : "hidden-source-map",
+    devtool: isDevEnvironment || isNative || isTest ? 'source-map' : 'hidden-source-map',
     ...((isDevEnvironment || (isTest && !isTestEager) || isNative) &&
       cacheStrategy),
     ...lazyCompilationConfig,
+    ...loggingConfig,
   };
 
+  // Helper function to load and process config files
+  async function loadAndProcessConfig(configPath, configType, Meteor, argv, isAngularEnabled) {
+    try {
+      // Load the config file
+      let config;
+      if (path.extname(configPath) === '.mjs') {
+        // For ESM modules, we need to use dynamic import
+        const fileUrl = `file://${configPath}`;
+        const module = await import(fileUrl);
+        config = module.default || module;
+      } else {
+        // For CommonJS modules, we can use require
+        config = require(configPath)?.default || require(configPath);
+      }
+
+      // Process the config
+      const rawConfig = typeof config === 'function' ? config(Meteor, argv) : config;
+      const resolvedConfig = await Promise.resolve(rawConfig);
+      const userConfig = resolvedConfig && '0' in resolvedConfig ? resolvedConfig[0] : resolvedConfig;
+
+      // Define omitted paths and warning function
+      const omitPaths = [
+        "name",
+        "target",
+        "entry",
+        "output.path",
+        "output.filename",
+        ...(Meteor.isServer ? ["optimization.splitChunks", "optimization.runtimeChunk"] : []),
+      ].filter(Boolean);
+
+      const warningFn = path => {
+        if (isAngularEnabled) return;
+        console.warn(
+          `[${configType}] Ignored custom "${path}" — reserved for Meteor-Rspack integration.`,
+        );
+      };
+
+      // Clean omitted paths and merge Meteor Rspack fragments
+      let nextConfig = cleanOmittedPaths(userConfig, {
+        omitPaths,
+        warningFn,
+      });
+      nextConfig = mergeMeteorRspackFragments(nextConfig);
+
+      return nextConfig;
+    } catch (error) {
+      console.error(`Error loading ${configType} from ${configPath}:`, error);
+      if (configType === 'rspack.config.js') {
+        throw error; // Only rethrow for project config
+      }
+      return null;
+    }
+  }
+
+  // Load and apply project-level overrides for the selected build
+  // Check if we're in a Meteor package directory by looking at the path
+  const isMeteorPackageConfig = projectDir.includes('/packages/rspack');
+  // Track if user config overrides stats and infrastructureLogging
+  let statsOverrided = false;
+  if (fs.existsSync(projectConfigPath) && !isMeteorPackageConfig) {
+    // Check if there's a .mjs or .cjs version of the config file
+    const mjsConfigPath = projectConfigPath.replace(/\.js$/, '.mjs');
+    const cjsConfigPath = projectConfigPath.replace(/\.js$/, '.cjs');
+
+    let projectConfigPathToUse = projectConfigPath;
+    if (fs.existsSync(mjsConfigPath)) {
+      projectConfigPathToUse = mjsConfigPath;
+    } else if (fs.existsSync(cjsConfigPath)) {
+      projectConfigPathToUse = cjsConfigPath;
+    }
+
+    const nextUserConfig = await loadAndProcessConfig(
+      projectConfigPathToUse,
+      'rspack.config.js',
+      Meteor,
+      argv,
+      isAngularEnabled
+    );
+
+    // Track if user config overrides stats
+    if (nextUserConfig) {
+      if (nextUserConfig.stats != null) {
+        statsOverrided = true;
+      }
+      if (Meteor.isClient) {
+        clientConfig = mergeSplitOverlap(clientConfig, nextUserConfig);
+      }
+      if (Meteor.isServer) {
+        serverConfig = mergeSplitOverlap(serverConfig, nextUserConfig);
+      }
+    }
+  }
+
   // Establish Angular overrides to ensure proper integration
   const angularExpandConfig = isAngularEnabled
     ? {
         mode: isProd ? "production" : "development",
-        devServer: { port: devServerPort },
+        devServer: { port: Meteor.devServerPort },
         stats: { preset: "normal" },
         infrastructureLogging: { level: "info" },
         ...(isProd && isClient && { output: { module: false } }),
@@ -740,26 +800,35 @@ module.exports = async function (inMeteor = {}, argv = {}) {
         }
       : {};
 
-
-  // Second pass: re-run only when a mode override was detected, so the user config
-  // can depend on fully-computed Meteor flags and helpers (swcConfigOptions, buildOutputDir, etc.).
-  if (nextUserConfig?.mode || nextOverrideConfig?.mode || isAngularEnabled) {
-    ({ nextUserConfig, nextOverrideConfig } = await loadUserAndOverrideConfig(
-      projectConfigPath,
-      Meteor,
-      argv
-    ));
-  }
-  let config = isClient ? clientConfig : serverConfig;
-  if (nextUserConfig) {
-    config = mergeSplitOverlap(config, nextUserConfig);
-  }
-
-  config = mergeSplitOverlap(config, angularExpandConfig);
+  let config = mergeSplitOverlap(
+    isClient ? clientConfig : serverConfig,
+    angularExpandConfig
+  );
   config = mergeSplitOverlap(config, testClientExpandConfig);
 
-  if (nextOverrideConfig) {
-    config = mergeSplitOverlap(config, nextOverrideConfig);
+  // Check for override config file (extra file to override everything)
+  if (projectConfigPath) {
+    const configDir = path.dirname(projectConfigPath);
+    const configFileName = path.basename(projectConfigPath);
+    const configExt = path.extname(configFileName);
+    const configNameWithoutExt = configFileName.replace(configExt, '');
+    const configNameFull = `${configNameWithoutExt}.override${configExt}`;
+    const overrideConfigPath = path.join(configDir, configNameFull);
+
+    if (fs.existsSync(overrideConfigPath)) {
+      const nextOverrideConfig = await loadAndProcessConfig(
+        overrideConfigPath,
+        configNameFull,
+        Meteor,
+        argv,
+        isAngularEnabled
+      );
+
+      if (nextOverrideConfig) {
+        // Apply override config as the last step
+        config = mergeSplitOverlap(config, nextOverrideConfig);
+      }
+    }
   }
 
   const shouldDisablePlugins = config?.disablePlugins != null;
@@ -768,23 +837,33 @@ module.exports = async function (inMeteor = {}, argv = {}) {
     delete config.disablePlugins;
   }
 
-  delete config["meteor.enablePortableBuild"];
-
-  // if (Meteor.isDebug || Meteor.isVerbose) {
-    console.log("Config:", inspect(config, { depth: null, colors: true }));
-  // }
+  if (Meteor.isDebug || Meteor.isVerbose) {
+    console.log('Config:', inspect(config, { depth: null, colors: true }));
+  }
 
   // Check if lazyCompilation is enabled and warn the user
-  if (
-    config.lazyCompilation === true ||
-    typeof config.lazyCompilation === "object"
-  ) {
+  if (config.lazyCompilation === true || typeof config.lazyCompilation === 'object') {
     console.warn(
-      "\n⚠️  Warning: lazyCompilation may not work correctly in the current Meteor-Rspack integration.\n" +
-        "   This feature will be evaluated for support in future Meteor versions.\n" +
-        "   If you encounter any issues, please disable it in your rspack config.\n"
+      '\n⚠️  Warning: lazyCompilation may not work correctly in the current Meteor-Rspack integration.\n' +
+        '   This feature will be evaluated for support in future Meteor versions.\n' +
+        '   If you encounter any issues, please disable it in your rspack config.\n',
     );
   }
 
+  // Add MeteorRspackOutputPlugin as the last plugin to output compilation info
+  const meteorRspackOutputPlugin = new MeteorRspackOutputPlugin({
+    getData: (stats, { isRebuild, compilationCount }) => ({
+      name: config.name,
+      mode: config.mode,
+      hasErrors: stats.hasErrors(),
+      hasWarnings: stats.hasWarnings(),
+      timestamp: Date.now(),
+      statsOverrided,
+      compilationCount,
+      isRebuild,
+    }),
+  });
+  config.plugins = [meteorRspackOutputPlugin, ...(config.plugins || [])];
+
   return [config];
 }

package/lib/meteorRspackConfigHelpers.js

@@ -1,121 +0,0 @@
-const path = require('path');
-const fs = require('fs');
-const { cleanOmittedPaths } = require("./mergeRulesSplitOverlap.js");
-const { mergeMeteorRspackFragments } = require("./meteorRspackConfigFactory.js");
-
-// Helper function to load and process config files
-async function loadAndProcessConfig(configPath, configType, Meteor, argv, disableWarnings) {
-  try {
-    // Load the config file
-    let config;
-    if (path.extname(configPath) === '.mjs') {
-      // For ESM modules, we need to use dynamic import
-      const fileUrl = `file://${configPath}`;
-      const module = await import(fileUrl);
-      config = module.default || module;
-    } else {
-      // For CommonJS modules, we can use require
-      config = require(configPath)?.default || require(configPath);
-    }
-
-    // Process the config
-    const rawConfig = typeof config === 'function' ? config(Meteor, argv) : config;
-    const resolvedConfig = await Promise.resolve(rawConfig);
-    const userConfig = resolvedConfig && '0' in resolvedConfig ? resolvedConfig[0] : resolvedConfig;
-
-    // Define omitted paths and warning function
-    const omitPaths = [
-      "name",
-      "target",
-      "entry",
-      "output.path",
-      "output.filename",
-      ...(Meteor.isServer ? ["optimization.splitChunks", "optimization.runtimeChunk"] : []),
-    ].filter(Boolean);
-
-    const warningFn = path => {
-      if (disableWarnings) return;
-      console.warn(
-        `[${configType}] Ignored custom "${path}" — reserved for Meteor-Rspack integration.`,
-      );
-    };
-
-    // Clean omitted paths and merge Meteor Rspack fragments
-    let nextConfig = cleanOmittedPaths(userConfig, {
-      omitPaths,
-      warningFn,
-    });
-    nextConfig = mergeMeteorRspackFragments(nextConfig);
-
-    return nextConfig;
-  } catch (error) {
-    console.error(`Error loading ${configType} from ${configPath}:`, error);
-    if (configType === 'rspack.config.js') {
-      throw error; // Only rethrow for project config
-    }
-    return null;
-  }
-}
-
-/**
- * Loads both the user's Rspack configuration and its potential override.
- *
- * @param {string|undefined} projectConfigPath
- * @param {object} Meteor
- * @param {object} argv
- * @returns {Promise<{ nextUserConfig: object|null, nextOverrideConfig: object|null }>}
- */
-async function loadUserAndOverrideConfig(projectConfigPath, Meteor, argv) {
-  let nextUserConfig = null;
-  let nextOverrideConfig = null;
-
-  const projectDir = process.cwd();
-  const isMeteorPackageConfig = projectDir.includes("/packages/rspack");
-
-  if (projectConfigPath) {
-    const configDir = path.dirname(projectConfigPath);
-    const configFileName = path.basename(projectConfigPath);
-    const configExt = path.extname(configFileName);
-    const configNameWithoutExt = configFileName.replace(configExt, '');
-    const configNameFull = `${configNameWithoutExt}.override${configExt}`;
-    const overrideConfigPath = path.join(configDir, configNameFull);
-
-    if (fs.existsSync(overrideConfigPath)) {
-      nextOverrideConfig = await loadAndProcessConfig(
-        overrideConfigPath,
-        configNameFull,
-        Meteor,
-        argv,
-        Meteor.isAngularEnabled
-      );
-    }
-
-    if (fs.existsSync(projectConfigPath) && !isMeteorPackageConfig) {
-      // Check if there's a .mjs or .cjs version of the config file
-      const mjsConfigPath = projectConfigPath.replace(/\.js$/, '.mjs');
-      const cjsConfigPath = projectConfigPath.replace(/\.js$/, '.cjs');
-
-      let projectConfigPathToUse = projectConfigPath;
-      if (fs.existsSync(mjsConfigPath)) {
-        projectConfigPathToUse = mjsConfigPath;
-      } else if (fs.existsSync(cjsConfigPath)) {
-        projectConfigPathToUse = cjsConfigPath;
-      }
-
-      nextUserConfig = await loadAndProcessConfig(
-        projectConfigPathToUse,
-        'rspack.config.js',
-        Meteor,
-        argv,
-        Meteor.isAngularEnabled
-      );
-    }
-  }
-
-  return { nextUserConfig, nextOverrideConfig };
-}
-
-module.exports = {
-  loadAndProcessConfig,
-  loadUserAndOverrideConfig,
-};