@meteorjs/rspack 3.0.0-beta.0 → 3.0.0-beta.2

package/lib/ignore.js

@@ -85,15 +85,25 @@ function createIgnoreGlobConfig(entries = []) {
 /**
  * Creates a regex pattern to match the specified glob patterns.
  * Converts glob patterns with * and ** into regex equivalents.
- * 
+ *
  * @param {string[]} globPatterns - Array of glob patterns from createIgnoreGlobConfig
+ * @param {string} [rootPath] - Absolute root that matched paths must belong to
  * @returns {RegExp} - Regex pattern to match the specified patterns
  */
-function createIgnoreRegex(globPatterns) {
+function createIgnoreRegex(globPatterns, rootPath) {
   if (!Array.isArray(globPatterns) || globPatterns.length === 0) {
     throw new Error('globPatterns must be a non-empty array');
   }
 
+  // Rspack applies context exclusions to absolute module paths. Anchor rooted
+  // patterns here so matching starts inside the app, not in a parent folder.
+  const pathPrefix = rootPath
+    ? `^${rootPath
+        .replace(/\\/g, '/')
+        .replace(/\/+$/, '')
+        .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?=/|$)`
+    : '(?:^|/)';
+
   // Process each glob pattern and convert to regex
   const regexPatterns = globPatterns.map(pattern => {
     // Skip negation patterns for the regex
@@ -115,9 +125,7 @@ function createIgnoreRegex(globPatterns) {
     // Convert the ** placeholder to its regex equivalent (any number of characters including /)
     regexPattern = regexPattern.replace(new RegExp(DOUBLE_ASTERISK_PLACEHOLDER, 'g'), '.*');
 
-    // 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 = pathPrefix + regexPattern;
 
     return regexPattern;
   }).filter(pattern => pattern !== null);

package/lib/localDependenciesHelpers.js

@@ -20,7 +20,7 @@ function extractLocalDependencies(configFilePath) {
 
     // Parse the file into an AST
     const ast = swc.parseSync(content, {
-      syntax: 'ecmascript',
+      syntax: /\.[mc]?tsx?$/.test(configFilePath) ? 'typescript' : 'ecmascript',
       dynamicImport: true,
       target: 'es2020',
     });
@@ -30,10 +30,10 @@ function extractLocalDependencies(configFilePath) {
       let modulePath = null;
 
       // Handle require() calls: require('./plugin')
-      if (node.type === 'CallExpression' && 
-          node.callee.type === 'Identifier' && 
-          node.callee.value === 'require' &&
-          node.arguments.length > 0) {
+      if (node.type === 'CallExpression' &&
+        node.callee.type === 'Identifier' &&
+        node.callee.value === 'require' &&
+        node.arguments.length > 0) {
         const arg = node.arguments[0];
         if (arg.expression?.type === 'StringLiteral') {
           modulePath = arg.expression.value;
@@ -42,8 +42,8 @@ function extractLocalDependencies(configFilePath) {
 
       // Handle dynamic import() calls: import('./plugin')
       if (node.type === 'CallExpression' &&
-          node.callee.type === 'Import' &&
-          node.arguments.length > 0) {
+        node.callee.type === 'Import' &&
+        node.arguments.length > 0) {
         const arg = node.arguments[0];
         if (arg.expression?.type === 'StringLiteral') {
           modulePath = arg.expression.value;
@@ -163,7 +163,7 @@ function resolveLocalModule(modulePath, configDir, projectDir) {
     const resolvedReal = fs.realpathSync(resolvedPath);
     const projectReal = fs.realpathSync(projectDir);
 
-    const isWithinProject = 
+    const isWithinProject =
       resolvedReal === projectReal ||
       resolvedReal.startsWith(projectReal + path.sep);
     const hasNodeModulesSegment = resolvedReal.split(path.sep).includes('node_modules');

package/lib/mergeRulesSplitOverlap.js

@@ -3,7 +3,7 @@
  * overlapping file extensions in module rules.
  */
 
-const { mergeWithCustomize } = require('webpack-merge');
+const { mergeWithCustomize } = require('rspack-merge');
 const isEqual = require('fast-deep-equal');
 
 /**

package/lib/meteorRspackHelpers.js

@@ -56,17 +56,12 @@ function compileWithRspack(deps, { options = {} } = {}) {
  */
 function setCache(
   enabled,
-  cacheConfig = { cache: true, experiments: { cache: true } }
+  cacheConfig = { cache: true }
 ) {
   return prepareMeteorRspackConfig(
     enabled
       ? cacheConfig
-      : {
-          cache: false, // disable cache
-          experiments: {
-            cache: false, // disable persistent cache (experimental flag)
-          },
-        }
+      : { cache: false }
   );
 }
 

package/lib/swc.js

@@ -14,7 +14,13 @@ function getMeteorAppSwcrc(file = '.swcrc') {
       
       if (file.endsWith('.ts')) {
         try {
-          const swc = require('@swc/core');
+          let swc;
+          try {
+            swc = require(require.resolve('@swc/core', { paths: [process.cwd()] }));
+          } catch (e) {
+            if (e.code !== 'MODULE_NOT_FOUND') throw e;
+            swc = require('@swc/core');
+          }
           const result = swc.transformSync(content, {
             jsc: {
               parser: {

package/lib/test.js

@@ -44,7 +44,8 @@ const generateEagerTestFile = ({
 
   // Create regex from ignore entries
   const excludeFoldersRegex = createIgnoreRegex(
-    createIgnoreGlobConfig(ignoreEntries)
+    createIgnoreGlobConfig(ignoreEntries),
+    projectDir,
   );
   // Create regex from meteor ignore entries
   const excludeMeteorIgnoreRegex = inMeteorIgnoreEntries.length > 0
@@ -74,14 +75,14 @@ const generateEagerTestFile = ({
     exclude: ${excludeFoldersRegex.toString()},
     mode: 'eager',
   });
-  ctx.keys().filter((k) => {
+  await Promise.all(ctx.keys().filter((k) => {
     ${
       excludeMeteorIgnoreRegex
         ? `// Only exclude based on *relative* path segments.
     return !MeteorIgnoreRegex.test(k);`
         : "return true;"
     }
-  }).forEach(ctx);
+  }).map(ctx));
   ${
     extraEntry
       ? `const extra = import.meta.webpackContext('${toPosix(path.dirname(

package/lib/testClientNodePolyfills.js

@@ -0,0 +1,66 @@
+const { ProvidePlugin } = require("@rspack/core");
+
+let meteorNodeStubs;
+try {
+  const stubPath = require.resolve("meteor-node-stubs", { paths: [process.cwd()] });
+  meteorNodeStubs = require(stubPath);
+} catch (e) {
+  if (e.code !== 'MODULE_NOT_FOUND') throw e;
+  try {
+    meteorNodeStubs = require("meteor-node-stubs");
+  } catch (fallbackError) {
+    if (fallbackError.code !== 'MODULE_NOT_FOUND') throw fallbackError;
+    // It's optional. If not installed, meteorNodeStubs remains undefined.
+  }
+}
+
+const TEST_CLIENT_NODE_POLYFILLS = [
+  "assert",
+  "buffer",
+  "constants",
+  "crypto",
+  "events",
+  "fs",
+  "http",
+  "https",
+  "os",
+  "path",
+  "querystring",
+  "stream",
+  "string_decoder",
+  "sys",
+  "timers",
+  "tty",
+  "url",
+  "util",
+  "vm",
+  "zlib",
+];
+
+function createTestClientNodePolyfillConfig() {
+  const fallback = Object.fromEntries(
+    TEST_CLIENT_NODE_POLYFILLS.map((name) => [name, meteorNodeStubs?.[name] ?? false]),
+  );
+
+  const plugins = [];
+  
+  if (meteorNodeStubs?.buffer) {
+    plugins.push(
+      new ProvidePlugin({
+        Buffer: [meteorNodeStubs.buffer, "Buffer"],
+      })
+    );
+  }
+
+  return {
+    resolve: {
+      alias: {
+        "timers/promises$": require.resolve("isomorphic-timers-promises"),
+      },
+      fallback,
+    },
+    plugins,
+  };
+}
+
+module.exports = { createTestClientNodePolyfillConfig };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meteorjs/rspack",
-  "version": "3.0.0-beta.0",
+  "version": "3.0.0-beta.2",
   "description": "Configuration logic for using Rspack in Meteor projects",
   "main": "index.js",
   "type": "commonjs",
@@ -13,16 +13,22 @@
   "dependencies": {
     "fast-deep-equal": "^3.1.3",
     "ignore-loader": "^0.1.2",
-    "node-polyfill-webpack-plugin": "^4.1.0",
-    "webpack-merge": "^6.0.1"
+    "isomorphic-timers-promises": "^1.0.1",
+    "rspack-merge": "^1.0.1"
   },
   "devDependencies": {
     "semver": "^7.7.4"
   },
   "peerDependencies": {
-    "@rspack/cli": ">=2.0.0",
-    "@rspack/core": ">=2.0.0",
-    "@rspack/dev-server": ">=2.0.0",
-    "@swc/core": ">=1.3.0"
+    "@rspack/cli": ">=2.2.0",
+    "@rspack/core": ">=2.2.0",
+    "@rspack/dev-server": ">=2.2.0",
+    "@swc/core": ">=1.3.0",
+    "meteor-node-stubs": ">=1.2.0"
+  },
+  "peerDependenciesMeta": {
+    "meteor-node-stubs": {
+      "optional": true
+    }
   }
 }

package/plugins/RequireExtenalsPlugin.js

@@ -13,6 +13,18 @@ const path = require('path');
 // Normalize a path to always use forward slashes (POSIX style).
 // Module identifiers in bundled JS must use '/' regardless of OS.
 const toPosix = (p) => p.replace(/\\/g, '/');
+const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const buildStandaloneRequireRegex = (pkg) =>
+  new RegExp(`^\\s*require\\('${escapeRegExp(pkg)}'\\);?.*(\\r?\\n)?`, 'gm');
+const buildStandaloneImportRegex = (pkg) =>
+  new RegExp(
+    `^[\\t ]*import[\\t ]+'${escapeRegExp(pkg)}';?[^\\r\\n]*(?:\\r?\\n|$)`,
+    'gm'
+  );
+const MANAGED_IMPORT_BLOCK_REGEX =
+  /^\/\/\s*\(function\s+(?:eagerExternalImports\d+|lastImports(?:\d+)?)\s*\(\)\s*\{\s*\r?\n[\s\S]*?^\/\/\s*\}\)\s*(?:\r?\n|$)/gm;
+const STANDALONE_REQUIRE_REGEX = /^\s*require\('([^']+)'\)/gm;
+const STANDALONE_IMPORT_REGEX = /^\s*import\s+'([^']+)'/gm;
 
 class RequireExternalsPlugin {
   constructor({
@@ -152,6 +164,13 @@ class RequireExternalsPlugin {
     }
 
     compiler.hooks.done.tap({ name: this.pluginName, stage: -10 }, (stats) => {
+      // Preserve the last known-good Meteor runtime entry when compilation
+      // fails. Rewriting externals from incomplete stats would make Meteor
+      // restart against a broken Rspack bundle.
+      if (stats.hasErrors()) {
+        return;
+      }
+
       // 1) Ensure globalThis.module / exports block is present if enabled
       if (this._enableGlobalPolyfill) {
         this._ensureGlobalThisModule();
@@ -160,8 +179,24 @@ class RequireExternalsPlugin {
       // 2) Re-load existing requires from disk on every run
       const existing = this._readExistingRequires();
 
-      // 2a) Compute the *current* externals in this build
-      const info = stats.toJson({ modules: true });
+      // 2a) Compute the *current* externals in this build.
+      // Only module names are needed, so start from `all: false` instead of
+      // serializing the whole stats object (chunks, assets, reasons, ...)
+      // on every compilation — a fixed cost per rebuild that grows with app
+      // size. `cachedModules: true` keeps unchanged modules in the list on
+      // incremental rebuilds, so their requires are not wrongly removed.
+      // `orphanModules: true` is required in production: module
+      // concatenation absorbs the externals' importers, marking the
+      // external modules themselves as orphans, and without this flag
+      // they vanish from the list entirely — which stripped every
+      // mirrored require (meteor/*, Blaze .html) from the meteor entry.
+      // See meteor/meteor#14568.
+      const info = stats.toJson({
+        all: false,
+        modules: true,
+        cachedModules: true,
+        orphanModules: true,
+      });
       const current = new Set();
       for (const m of info.modules) {
         const matchInfo = this._isExternalModule(m.name);
@@ -173,15 +208,22 @@ class RequireExternalsPlugin {
         }
       }
 
-      // 2b) Remove any requires that are no longer in `current`
+      // 2b) Remove any dependencies that are no longer in `current`
       const toRemove = [...existing].filter(p => !current.has(p));
       if (toRemove.length) {
         let content = fs.readFileSync(this.filePath, 'utf-8');
 
-        // Strip stale require(...) lines
+        // Strip stale requires and imports generated by this plugin. Other
+        // standalone imports link Meteor entry and Rspack output files and
+        // must remain intact.
         for (const pkg of toRemove) {
-          const re = new RegExp(`^.*require\\('${pkg}'\\);?.*(\\r?\\n)?`, 'gm');
-          content = content.replace(re, '');
+          const requireRe = buildStandaloneRequireRegex(pkg);
+          const importRe = buildStandaloneImportRegex(pkg);
+          content = content.replace(requireRe, '');
+          content = content.replace(
+            MANAGED_IMPORT_BLOCK_REGEX,
+            (block) => block.replace(importRe, '')
+          );
         }
 
         // Strip out any now-empty helper functions:
@@ -206,11 +248,11 @@ class RequireExternalsPlugin {
         // Re-populate `existing` so the add-diff is accurate
         existing.clear();
         // Check for require statements
-        for (const match of content.matchAll(/require\('([^']+)'\)/g)) {
+        for (const match of content.matchAll(STANDALONE_REQUIRE_REGEX)) {
           existing.add(match[1]);
         }
         // Also check for import statements (used in the new format)
-        for (const match of content.matchAll(/import\s+'([^']+)'/g)) {
+        for (const match of content.matchAll(STANDALONE_IMPORT_REGEX)) {
           existing.add(match[1]);
         }
       }
@@ -478,19 +520,22 @@ class RequireExternalsPlugin {
 
   _readExistingRequires() {
     const existing = new Set();
+    // Generated Rspack bridge imports are not managed externals. Relative
+    // imports such as Blaze HTML files still belong to this plugin.
+    const isRspackBridgeImport = (modulePath) =>
+      typeof modulePath === 'string' &&
+      /(?:^|[/\\])[^/\\]*-rspack\.(?:js|cjs)$/.test(modulePath);
     try {
       const content = fs.readFileSync(this.filePath, 'utf-8');
       // Check for require statements
-      const requireRegex = /require\('([^']+)'\)/g;
       let match;
-      while ((match = requireRegex.exec(content)) !== null) {
-        existing.add(match[1]);
+      while ((match = STANDALONE_REQUIRE_REGEX.exec(content)) !== null) {
+        if (!isRspackBridgeImport(match[1])) existing.add(match[1]);
       }
 
       // Also check for import statements (used in the new format)
-      const importRegex = /import\s+'([^']+)'/g;
-      while ((match = importRegex.exec(content)) !== null) {
-        existing.add(match[1]);
+      while ((match = STANDALONE_IMPORT_REGEX.exec(content)) !== null) {
+        if (!isRspackBridgeImport(match[1])) existing.add(match[1]);
       }
     } catch {
       // ignore if file missing or unreadable

package/rspack.config.js

@@ -2,8 +2,7 @@ const { DefinePlugin, BannerPlugin, NormalModuleReplacementPlugin } = require('@
 const fs = require('fs');
 const { inspect } = require('node:util');
 const path = require('path');
-const { merge } = require('webpack-merge');
-const NodePolyfillPlugin = require('node-polyfill-webpack-plugin');
+const { merge } = require('rspack-merge');
 
 const { cleanOmittedPaths, mergeSplitOverlap } = require("./lib/mergeRulesSplitOverlap.js");
 const { getMeteorAppSwcConfig } = require('./lib/swc.js');
@@ -30,7 +29,7 @@ const {
 const { loadUserAndOverrideConfig } = require('./lib/meteorRspackConfigHelpers.js');
 const { prepareMeteorRspackConfig } = require("./lib/meteorRspackConfigFactory");
 const { extractLocalDependencies } = require('./lib/localDependenciesHelpers.js');
-
+const { createTestClientNodePolyfillConfig } = require("./lib/testClientNodePolyfills.js");
 
 // Safe require that doesn't throw if the module isn't found
 function safeRequire(moduleName) {
@@ -95,21 +94,22 @@ function createCacheStrategy(
   ].filter(Boolean);
 
   return {
-    cache: true,
-    experiments: {
-      cache: {
-        version: `cache-${mode}${(side && `-${side}`) || ""}`,
-        type: "persistent",
-        storage: {
-          type: "filesystem",
-          directory: `node_modules/.cache/rspack/${
-            [buildContext, side].filter(Boolean).join('-') || 'default'
-          }`,
-        },
-        ...(buildDependencies.length > 0 && {
-          buildDependencies: buildDependencies,
-        })
+    cache: {
+      version: `cache-${mode}${(side && `-${side}`) || ""}`,
+      type: "persistent",
+      storage: {
+        type: "filesystem",
+        // Rspack invalidates a persistent cache on version mismatch. Keep
+        // development and production in separate directories so switching
+        // between `meteor run` and `meteor build` leaves both caches warm.
+        // See meteor/meteor#14568.
+        directory: `node_modules/.cache/rspack/${
+          [buildContext, side, mode].filter(Boolean).join('-') || 'default'
+        }`,
       },
+      ...(buildDependencies.length > 0 && {
+        buildDependencies: buildDependencies,
+      })
     },
   };
 }
@@ -127,15 +127,13 @@ function createSwcConfig({
 }) {
   const defaultConfig = {
     jsc: {
-      baseUrl: process.cwd(),
-      paths: { '/*': ['*', '/*'] },
       parser: {
         syntax: isTypescriptEnabled ? 'typescript' : 'ecmascript',
         ...(isTsxEnabled && { tsx: true }),
         ...(isJsxEnabled && { jsx: true }),
         ...(isAngularEnabled && { decorators: true }),
       },
-      target: 'es2015',
+      target: isClient ? 'es2015' : 'es2022',
       ...(isReactEnabled && {
         transform: {
           react: {
@@ -404,7 +402,11 @@ module.exports = async function (inMeteor = {}, argv = {}) {
   cacheStrategy = createCacheStrategy(
     mode,
     (Meteor.isClient && "client") || "server",
-    { projectConfigPath, configPath }
+    // buildContext must be passed here too: this reassignment is the
+    // effective cache strategy, and omitting it made the cache directory
+    // collide across build contexts (e.g. custom METEOR_LOCAL_DIR setups).
+    // See meteor/meteor#14568.
+    { projectConfigPath, configPath, buildContext }
   );
 
   // Determine run point
@@ -426,7 +428,7 @@ module.exports = async function (inMeteor = {}, argv = {}) {
   // Additional ignore entries
   const additionalEntries = [
     "**/.meteor/local/**",
-    "**/dist/**",
+    path.join(projectDir, "dist", "**").replace(/\\/g, "/"),
     ...(isTest && isTestEager
       ? [`**/${buildContext}/**`, "**/.meteor/local/**", "node_modules/**"]
       : []),
@@ -439,7 +441,7 @@ module.exports = async function (inMeteor = {}, argv = {}) {
     ],
   };
 
-  if (Meteor.isDebug || Meteor.isVerbose) {
+  if (Meteor.isVerbose) {
     console.log("[i] Rspack mode:", mode);
     console.log("[i] Meteor flags:", Meteor);
   }
@@ -462,9 +464,6 @@ module.exports = async function (inMeteor = {}, argv = {}) {
     ...(isReactEnabled ? [/^react$/, /^react-dom$/] : []),
     ...(isServer ? [/^bcrypt$/] : []),
   ];
-  const alias = {
-    "/": path.resolve(process.cwd()),
-  };
   const fallback = {
     ...(isClient && makeWebNodeBuiltinsAlias()),
   };
@@ -485,13 +484,15 @@ module.exports = async function (inMeteor = {}, argv = {}) {
   const reactRefreshModule = isReactEnabled
     ? safeRequire("@rspack/plugin-react-refresh")
     : null;
+  const ReactRefreshRspackPlugin =
+    reactRefreshModule?.ReactRefreshRspackPlugin || reactRefreshModule;
 
   const requireExternalsPlugin = new RequireExternalsPlugin({
     filePath: path.join(buildContext, runPath),
     ...(Meteor.isBlazeEnabled && {
       externals: /\.html$/,
       isEagerImport: (module) => module.endsWith(".html"),
-      ...(isProd && {
+      ...((isProd || (isTest && isClient)) && {
         lastImports: [`./${outputFilename}`],
       }),
     }),
@@ -620,7 +621,7 @@ module.exports = async function (inMeteor = {}, argv = {}) {
         if (isMainChunk) return `../${buildContext}/${outputPath}`;
         return chunkSuffix;
       },
-      libraryTarget: "commonjs2",
+      library: { type: "commonjs2" },
       publicPath: "/",
       chunkFilename: `${chunksContext}/[id]${isProd ? ".[chunkhash]" : ""}.js`,
       assetModuleFilename,
@@ -650,14 +651,24 @@ module.exports = async function (inMeteor = {}, argv = {}) {
         { test: /\.css$/, type: "css/auto" },
         ...extraRules,
       ],
+      parser: {
+        javascript: {
+          // Relax Rspack 2.0 strict ESM linking; SWC-stripped TS type re-exports otherwise fail the build.
+          exportsPresence: "warn",
+        },
+      },
+    },
+    resolve: {
+      extensions,
+      fallback,
+      roots: [path.resolve(projectDir)],
     },
-    resolve: { extensions, alias, fallback },
     externals,
     externalsType: "commonjs2",
     plugins: [
       ...[
-        ...(isReactEnabled && reactRefreshModule && isDevEnvironment
-          ? [new reactRefreshModule()]
+        ...(isReactEnabled && ReactRefreshRspackPlugin && isDevEnvironment
+          ? [new ReactRefreshRspackPlugin()]
           : []),
         requireExternalsPlugin,
         assetExternalsPlugin,
@@ -740,7 +751,7 @@ module.exports = async function (inMeteor = {}, argv = {}) {
     output: {
       path: serverOutputDir,
       filename: () => `../${buildContext}/${outputPath}`,
-      libraryTarget: "commonjs2",
+      library: { type: "commonjs2" },
       chunkFilename: `${chunksContext}/[id]${isProd ? ".[chunkhash]" : ""}.js`,
       assetModuleFilename,
       ...(isProd && { clean: { keep: keepOutsideBuild() } }),
@@ -771,14 +782,16 @@ module.exports = async function (inMeteor = {}, argv = {}) {
         javascript: {
           // Dynamic imports on the server are treated as bundled in the same chunk
           dynamicImportMode: "eager",
+          // Relax Rspack 2.0 strict ESM linking; SWC-stripped TS type re-exports otherwise fail the build.
+          exportsPresence: "warn",
         },
       },
     },
     resolve: {
       extensions,
-      alias,
       modules: ["node_modules", path.resolve(projectDir)],
       conditionNames: ["import", "require", "node", "default"],
+      roots: [path.resolve(projectDir)],
     },
     externals,
     externalsType: "commonjs2",
@@ -814,8 +827,12 @@ module.exports = async function (inMeteor = {}, argv = {}) {
       isDevEnvironment || isNative || isTest
         ? "source-map"
         : "hidden-source-map",
-    ...((isDevEnvironment || (isTest && !isTestEager) || isNative) &&
-      cacheStrategy),
+    // Apply the persistent cache to production builds too (the client
+    // config always has it); previously `meteor build` recompiled the
+    // entire server bundle cold every time. Eager server test builds are
+    // still excluded, since their generated entry changes on every run.
+    // See meteor/meteor#14568.
+    ...(!(isTest && isTestEager) && cacheStrategy),
     ...lazyCompilationConfig,
     ...loggingConfig,
   };
@@ -827,7 +844,18 @@ module.exports = async function (inMeteor = {}, argv = {}) {
         devServer: { port: devServerPort },
         stats: { preset: "normal" },
         infrastructureLogging: { level: "info" },
-        ...(isProd && isClient && { output: { module: false } }),
+        ...(isProd &&
+          isClient && {
+            output: {
+              // Nx Angular config emits ESM chunks in production by default.
+              // Meteor serves and minifies classic browser bundles here.
+              module: false,
+              scriptType: false,
+              chunkFormat: "array-push",
+              chunkLoading: "jsonp",
+              workerChunkLoading: "import-scripts",
+            },
+          }),
       }
     : {};
 
@@ -847,7 +875,7 @@ module.exports = async function (inMeteor = {}, argv = {}) {
           optimization: {
             splitChunks: false,
           },
-          plugins: [new NodePolyfillPlugin()],
+          ...createTestClientNodePolyfillConfig(),
         }
       : {};
 
@@ -904,8 +932,8 @@ module.exports = async function (inMeteor = {}, argv = {}) {
 
   delete config["meteor.enablePortableBuild"];
 
-  if (Meteor.isDebug || Meteor.isVerbose) {
-  console.log("Config:", inspect(config, { depth: null, colors: true }));
+  if (Meteor.isVerbose) {
+    console.log("Config:", inspect(config, { depth: null, colors: true }));
   }
 
   // Check if lazyCompilation is enabled and warn the user
@@ -922,19 +950,42 @@ module.exports = async function (inMeteor = {}, argv = {}) {
 
   // Add MeteorRspackOutputPlugin as the last plugin to output compilation info
   const meteorRspackOutputPlugin = new MeteorRspackOutputPlugin({
-    getData: (stats, { isRebuild, compilationCount, compiler }) => ({
-      name: config.name,
-      mode: config.mode,
-      hasErrors: stats.hasErrors(),
-      hasWarnings: stats.hasWarnings(),
-      timestamp: Date.now(),
-      statsOverrided,
-      compilationCount,
-      isRebuild,
-      ...(!isRebuild && compiler && {
-        delegatedExtensions: extractDelegatedExtensions(stats, compiler),
-      }),
-    }),
+    getData: (stats, { isRebuild, compilationCount, compiler }) => {
+      const generatedAppPaths = [
+        path.join('.meteor', 'local'),
+        path.join('.meteor', 'types'),
+        buildContext,
+      ];
+      const changedFiles = [
+        ...(compiler?.modifiedFiles || []),
+        ...(compiler?.removedFiles || []),
+      ];
+      const hasAppSourceChanges =
+        changedFiles.length === 0 ||
+        changedFiles.some(file => {
+          const relativePath = path.relative(projectDir, file);
+          return !generatedAppPaths.some(generatedPath =>
+            relativePath === generatedPath ||
+            relativePath.startsWith(`${generatedPath}${path.sep}`)
+          );
+        });
+
+      return {
+        name: config.name,
+        mode: config.mode,
+        hasErrors: stats.hasErrors(),
+        hasWarnings: stats.hasWarnings(),
+        hasAppSourceChanges,
+        hash: stats.hash,
+        timestamp: Date.now(),
+        statsOverrided,
+        compilationCount,
+        isRebuild,
+        ...(!isRebuild && compiler && {
+          delegatedExtensions: extractDelegatedExtensions(stats, compiler),
+        }),
+      };
+    },
   });
   config.plugins = [meteorRspackOutputPlugin, ...(config.plugins || [])];
 

package/.claude/settings.local.json

@@ -1,10 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(chmod +x:*)",
-      "Bash(bash:*)",
-      "Bash(npm install:*)",
-      "Bash(node:*)"
-    ]
-  }
-}