@meteorjs/rspack 3.0.0-beta.1 → 3.0.0-beta.3

package/index.d.ts

@@ -18,6 +18,10 @@ type MeteorEnv = Record<string, any> & {
   isProduction: boolean;
   isClient: boolean;
   isServer: boolean;
+  /** Explicit client architecture, e.g. web.browser.legacy or web.cordova. */
+  arch?: string;
+  /** Whether this client compilation uses legacy (ES5) targets. */
+  isLegacy: boolean;
   isTest: boolean;
   isDebug: boolean;
   isRun: boolean;

package/lib/ignore.js

@@ -2,8 +2,26 @@ var fs = require('fs');
 var path = require('path');
 
 /**
- * Reads the .meteorignore file from the given project directory and returns
- * the parsed entries. Empty lines and comment lines (starting with #) are filtered out.
+ * Splits a whitespace-delimited list of ignore patterns, as accepted by the
+ * METEOR_IGNORE environment variable.
+ *
+ * @param {string} value - Raw environment variable value
+ * @returns {string[]} - Array of ignore patterns
+ */
+function parseIgnoreEnv(value) {
+  return (value || '').trim().split(/\s+/).filter(Boolean);
+}
+
+/**
+ * Reads the ignore patterns that apply to the given project directory: the
+ * entries of its .meteorignore file followed by the ones in the METEOR_IGNORE
+ * environment variable. Empty lines and comment lines (starting with #) are
+ * filtered out.
+ *
+ * The two sources are combined the way meteor-tool combines them (see
+ * optimisticReadMeteorIgnore in tools/fs/optimistic.ts), with METEOR_IGNORE
+ * last so that it can override the file under gitignore's last-match-wins
+ * rule.
  *
  * @param {string} projectDir - The project directory path
  * @returns {string[]} - Array of ignore patterns
@@ -11,20 +29,22 @@ var path = require('path');
 const getMeteorIgnoreEntries = function (projectDir) {
   const meteorIgnorePath = path.join(projectDir, '.meteorignore');
 
+  let fileEntries = [];
+
   // Check if .meteorignore file exists
   try {
     const fileContent = fs.readFileSync(meteorIgnorePath, 'utf8');
 
     // Process each line in the file
-    const entries = fileContent.split(/\r?\n/)
+    fileEntries = fileContent.split(/\r?\n/)
       .map(line => line.trim())
       .filter(line => line !== '' && !line.startsWith('#'));
-
-    return entries;
   } catch (e) {
-    // If the file doesn't exist or can't be read, return empty array
-    return [];
+    // If the file doesn't exist or can't be read, fall back to the
+    // environment variable alone.
   }
+
+  return [...fileEntries, ...parseIgnoreEnv(process.env.METEOR_IGNORE)];
 };
 
 /**
@@ -86,6 +106,11 @@ function createIgnoreGlobConfig(entries = []) {
  * Creates a regex pattern to match the specified glob patterns.
  * Converts glob patterns with * and ** into regex equivalents.
  *
+ * Negation patterns cannot be expressed in a single regex and are dropped, so
+ * this only suits pattern lists known to be positive-only — Rspack's `exclude`
+ * option, which accepts nothing but a RegExp. Patterns that come from the app
+ * author go through createIgnoreMatcherSource instead.
+ *
  * @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
@@ -95,14 +120,21 @@ function createIgnoreRegex(globPatterns, rootPath) {
     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.
+  // Rspack applies context exclusions to absolute module paths joined with the
+  // platform separator, so on Windows they arrive with backslashes. Every
+  // separator in the regex accepts both forms (meteor/meteor#14513).
+  const SEPARATOR = '[\\\\/]';
+  const NOT_SEPARATOR = '[^\\\\/]';
+
+  // Anchor rooted patterns so matching starts inside the app, not in a parent
+  // folder.
   const pathPrefix = rootPath
     ? `^${rootPath
         .replace(/\\/g, '/')
         .replace(/\/+$/, '')
-        .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(?=/|$)`
-    : '(?:^|/)';
+        .replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+        .replace(/\//g, SEPARATOR)}(?=${SEPARATOR}|$)`
+    : `(?:^|${SEPARATOR})`;
 
   // Process each glob pattern and convert to regex
   const regexPatterns = globPatterns.map(pattern => {
@@ -114,13 +146,16 @@ function createIgnoreRegex(globPatterns, rootPath) {
     // Escape special regex characters, but not * and /
     let regexPattern = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
 
+    // Accept either separator wherever the pattern has a /
+    regexPattern = regexPattern.replace(/\//g, SEPARATOR);
+
     // Use a temporary placeholder for ** that won't be affected by the * replacement
     // This is necessary because if we directly replace ** with .* and then replace * with [^/]*
     const DOUBLE_ASTERISK_PLACEHOLDER = '__DOUBLE_ASTERISK__';
     regexPattern = regexPattern.replace(/\*\*/g, DOUBLE_ASTERISK_PLACEHOLDER);
 
-    // Convert * to regex equivalent (any number of characters except /)
-    regexPattern = regexPattern.replace(/\*/g, '[^/]*');
+    // Convert * to regex equivalent (any number of characters except a separator)
+    regexPattern = regexPattern.replace(/\*/g, `${NOT_SEPARATOR}*`);
 
     // Convert the ** placeholder to its regex equivalent (any number of characters including /)
     regexPattern = regexPattern.replace(new RegExp(DOUBLE_ASTERISK_PLACEHOLDER, 'g'), '.*');
@@ -140,8 +175,51 @@ function createIgnoreRegex(globPatterns, rootPath) {
   return new RegExp(combinedPattern);
 }
 
+/**
+ * Builds the pieces a generated eager-test module needs to decide which test
+ * files .meteorignore keeps.
+ *
+ * .meteorignore uses gitignore syntax, where the last matching pattern wins and
+ * a `!pattern` re-includes a path an earlier pattern excluded. Reimplementing
+ * that on top of a RegExp lost every negation, which silently reduced a sharded
+ * test run to zero test files, so the generated module is handed the same
+ * `ignore` package meteor-tool applies to .meteorignore (see
+ * tools/fs/optimistic.ts). Both bundlers then agree on the semantics.
+ *
+ * Returned as source rather than as a predicate because it runs inside the
+ * bundle, not in this process: the paths it tests come from
+ * import.meta.webpackContext.
+ *
+ * @param {string[]} entries - .meteorignore-style patterns, in order
+ * @returns {{ modulePath: string, source: string }|null} - The `ignore` module
+ *   to import, and a `(createIgnore) => (contextKey) => boolean` factory
+ *   expression. Null when there is nothing to filter.
+ */
+function createIgnoreMatcherSource(entries = []) {
+  if (!Array.isArray(entries)) {
+    throw new Error('Entries must be an array');
+  }
+
+  if (entries.length === 0) {
+    return null;
+  }
+
+  return {
+    // Resolved here rather than at module load so that requiring this file
+    // stays cheap and does not depend on `ignore` being installed.
+    modulePath: require.resolve('ignore'),
+    source: `(createIgnore => {
+  const ig = createIgnore().add(${JSON.stringify(entries)});
+  // import.meta.webpackContext keys look like './imports/a.tests.ts', but
+  // \`ignore\` wants a path relative to the project root and rejects the './'.
+  return key => ig.ignores(key.replace(/^\\.\\//, ''));
+})`,
+  };
+}
+
 module.exports = {
+  createIgnoreGlobConfig,
+  createIgnoreMatcherSource,
   createIgnoreRegex,
   getMeteorIgnoreEntries,
-  createIgnoreGlobConfig,
 };

package/lib/ignore.test.js

@@ -0,0 +1,259 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const {
+  createIgnoreGlobConfig,
+  createIgnoreMatcherSource,
+  createIgnoreRegex,
+  getMeteorIgnoreEntries,
+} = require('./ignore.js');
+
+// Compiles the factory emitted into the generated eager-test module and wires
+// it to the same `ignore` module that module imports, so the assertions below
+// exercise the exact code that runs inside the bundle.
+const compileMatcher = entries => {
+  const { modulePath, source } = createIgnoreMatcherSource(entries);
+
+  // eslint-disable-next-line no-new-func -- the input is this package's own
+  // generated source, not user data.
+  return new Function('createIgnore', `return (${source})(createIgnore);`)(
+    require(modulePath),
+  );
+};
+
+const withMeteorIgnoreEnv = (value, fn) => {
+  const previous = process.env.METEOR_IGNORE;
+  if (value === undefined) {
+    delete process.env.METEOR_IGNORE;
+  } else {
+    process.env.METEOR_IGNORE = value;
+  }
+  try {
+    return fn();
+  } finally {
+    if (previous === undefined) {
+      delete process.env.METEOR_IGNORE;
+    } else {
+      process.env.METEOR_IGNORE = previous;
+    }
+  }
+};
+
+describe('createIgnoreMatcherSource', () => {
+  test('re-includes a file a later negation pattern rescues', () => {
+    const isIgnored = compileMatcher([
+      '*.tests.ts',
+      '!/imports/localization/LanguageSections.tests.ts',
+    ]);
+
+    expect(isIgnored('./imports/localization/LanguageSections.tests.ts')).toBe(
+      false,
+    );
+  });
+
+  test('still ignores files no negation pattern rescues', () => {
+    const isIgnored = compileMatcher([
+      '*.tests.ts',
+      '!/imports/localization/LanguageSections.tests.ts',
+    ]);
+
+    expect(isIgnored('./imports/localization/Other.tests.ts')).toBe(true);
+  });
+
+  test('lets the last matching pattern win when a positive follows a negation', () => {
+    const isIgnored = compileMatcher([
+      '*.tests.ts',
+      '!/imports/a/B.tests.ts',
+      '/imports/a/',
+    ]);
+
+    expect(isIgnored('./imports/a/B.tests.ts')).toBe(true);
+  });
+
+  test('ignores nothing when every pattern is a negation', () => {
+    const isIgnored = compileMatcher(['!/imports/a/B.tests.ts']);
+
+    expect(isIgnored('./imports/a/B.tests.ts')).toBe(false);
+  });
+
+  test('returns null when there are no patterns', () => {
+    expect(createIgnoreMatcherSource([])).toBeNull();
+  });
+
+  test('anchors a rooted pattern to the project root', () => {
+    const isIgnored = compileMatcher(['/imports/a.tests.ts']);
+
+    expect(isIgnored('./imports/a.tests.ts')).toBe(true);
+    expect(isIgnored('./packages/imports/a.tests.ts')).toBe(false);
+  });
+
+  test('supports character classes', () => {
+    const isIgnored = compileMatcher(['shard-[a-c].tests.ts']);
+
+    expect(isIgnored('./imports/shard-b.tests.ts')).toBe(true);
+    expect(isIgnored('./imports/shard-d.tests.ts')).toBe(false);
+  });
+
+  test('supports the single-character wildcard', () => {
+    const isIgnored = compileMatcher(['shard-?.tests.ts']);
+
+    expect(isIgnored('./imports/shard-1.tests.ts')).toBe(true);
+    expect(isIgnored('./imports/shard-12.tests.ts')).toBe(false);
+  });
+
+  test('matches a **/ pattern at the project root too', () => {
+    const isIgnored = compileMatcher(['**/legacy.tests.ts']);
+
+    expect(isIgnored('./legacy.tests.ts')).toBe(true);
+    expect(isIgnored('./imports/legacy.tests.ts')).toBe(true);
+  });
+
+  test('does not let a negation rescue a file under an excluded directory', () => {
+    const isIgnored = compileMatcher(['/imports/', '!/imports/a.tests.ts']);
+
+    expect(isIgnored('./imports/a.tests.ts')).toBe(true);
+  });
+});
+
+describe('createIgnoreRegex', () => {
+  test('matches paths covered by a positive pattern', () => {
+    const regex = createIgnoreRegex(createIgnoreGlobConfig(['node_modules/']));
+
+    expect(regex.test('./node_modules/foo/index.js')).toBe(true);
+    expect(regex.test('./imports/a.js')).toBe(false);
+  });
+});
+
+describe('getMeteorIgnoreEntries', () => {
+  let projectDir;
+
+  beforeEach(() => {
+    projectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'meteor-ignore-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  test('appends METEOR_IGNORE patterns after the .meteorignore ones', () => {
+    fs.writeFileSync(
+      path.join(projectDir, '.meteorignore'),
+      '# comment\n*.tests.ts\n\n',
+    );
+
+    const entries = withMeteorIgnoreEnv(
+      '!/imports/a/B.tests.ts  /imports/c',
+      () => getMeteorIgnoreEntries(projectDir),
+    );
+
+    expect(entries).toEqual([
+      '*.tests.ts',
+      '!/imports/a/B.tests.ts',
+      '/imports/c',
+    ]);
+  });
+
+  test('returns METEOR_IGNORE patterns when there is no .meteorignore file', () => {
+    const entries = withMeteorIgnoreEnv('*.tests.ts', () =>
+      getMeteorIgnoreEntries(projectDir),
+    );
+
+    expect(entries).toEqual(['*.tests.ts']);
+  });
+
+  test('returns an empty array when neither source has patterns', () => {
+    const entries = withMeteorIgnoreEnv(undefined, () =>
+      getMeteorIgnoreEntries(projectDir),
+    );
+
+    expect(entries).toEqual([]);
+  });
+});
+
+// The folder ignores generateEagerTestFile hands to Rspack as the context
+// `exclude`. Rspack tests that regex against absolute module paths built with
+// the platform separator, so on Windows they arrive with backslashes.
+const EAGER_TEST_IGNORES = [
+  '**/node_modules/**',
+  '**/.meteor/**',
+  '**/public/**',
+  '**/private/**',
+  '**/_build/**',
+  '**/client/**',
+];
+
+function excludeFor(rootPath) {
+  return createIgnoreRegex(createIgnoreGlobConfig(EAGER_TEST_IGNORES), rootPath);
+}
+
+describe('createIgnoreRegex', () => {
+  describe('POSIX absolute paths', () => {
+    const exclude = excludeFor('/Users/dev/app');
+
+    test('excludes ignored folders below the project root', () => {
+      expect(exclude.test('/Users/dev/app/node_modules/pkg/index.test.js')).toBe(true);
+      expect(exclude.test('/Users/dev/app/client/thing.test.js')).toBe(true);
+    });
+
+    test('keeps app test files', () => {
+      expect(exclude.test('/Users/dev/app/imports/api/thing.test.js')).toBe(false);
+    });
+
+    test('keeps app test files when a parent folder is named private (#14688)', () => {
+      const privateExclude = excludeFor('/private/tmp/app');
+      expect(privateExclude.test('/private/tmp/app/imports/thing.test.js')).toBe(false);
+      expect(privateExclude.test('/private/tmp/app/private/thing.test.js')).toBe(true);
+    });
+  });
+
+  describe('Windows absolute paths', () => {
+    const exclude = excludeFor('C:\\Users\\dev\\app');
+
+    test('excludes ignored folders joined with backslashes (#14513)', () => {
+      expect(exclude.test('C:\\Users\\dev\\app\\node_modules\\pkg\\index.test.js')).toBe(true);
+      expect(exclude.test('C:\\Users\\dev\\app\\client\\thing.test.js')).toBe(true);
+    });
+
+    test('keeps app test files', () => {
+      expect(exclude.test('C:\\Users\\dev\\app\\imports\\api\\thing.test.js')).toBe(false);
+    });
+
+    test('accepts a forward-slash root joined with backslashes', () => {
+      const mixedExclude = excludeFor('C:/Users/dev/app');
+      expect(mixedExclude.test('C:/Users/dev/app\\node_modules\\pkg\\index.test.js')).toBe(true);
+      expect(mixedExclude.test('C:/Users/dev/app\\imports\\thing.test.js')).toBe(false);
+    });
+
+    test('keeps app test files when a parent folder is named private', () => {
+      const privateExclude = excludeFor('C:\\Users\\dev\\private\\app');
+      expect(privateExclude.test('C:\\Users\\dev\\private\\app\\imports\\thing.test.js')).toBe(false);
+    });
+  });
+
+  describe('without a root path', () => {
+    test('matches relative context keys', () => {
+      const exclude = createIgnoreRegex(createIgnoreGlobConfig(['tests/fixtures/**']));
+      expect(exclude.test('./tests/fixtures/thing.test.js')).toBe(true);
+      expect(exclude.test('./imports/thing.test.js')).toBe(false);
+    });
+
+    test('keeps a single star within one path segment', () => {
+      const exclude = createIgnoreRegex(createIgnoreGlobConfig(['imports/*.test.js']));
+      expect(exclude.test('./imports/thing.test.js')).toBe(true);
+      expect(exclude.test('./imports/nested/thing.test.js')).toBe(false);
+    });
+
+    test('never matches when every pattern is a negation', () => {
+      const exclude = createIgnoreRegex(createIgnoreGlobConfig(['!imports/**']));
+      expect(exclude.test('./imports/thing.test.js')).toBe(false);
+    });
+  });
+
+  test('survives being embedded as a regex literal in generated code', () => {
+    const exclude = excludeFor('C:\\Users\\dev\\app');
+    const embedded = new Function(`return ${exclude.toString()};`)();
+    expect(embedded.test('C:\\Users\\dev\\app\\node_modules\\pkg\\index.test.js')).toBe(true);
+    expect(embedded.test('C:\\Users\\dev\\app\\imports\\thing.test.js')).toBe(false);
+  });
+});

package/lib/test.js

@@ -1,6 +1,10 @@
 const fs = require('fs');
 const path = require('path');
-const { createIgnoreRegex, createIgnoreGlobConfig } = require("./ignore.js");
+const {
+  createIgnoreGlobConfig,
+  createIgnoreMatcherSource,
+  createIgnoreRegex,
+} = require("./ignore.js");
 
 // Normalize a path to always use forward slashes (POSIX style).
 // Module identifiers in bundled JS must use '/' regardless of OS.
@@ -47,10 +51,11 @@ const generateEagerTestFile = ({
     createIgnoreGlobConfig(ignoreEntries),
     projectDir,
   );
-  // Create regex from meteor ignore entries
-  const excludeMeteorIgnoreRegex = inMeteorIgnoreEntries.length > 0
-    ? createIgnoreRegex(createIgnoreGlobConfig(inMeteorIgnoreEntries))
-    : null;
+  // Build the .meteorignore filter. It is `ignore`-backed rather than a regex
+  // because gitignore's last-match-wins rule cannot be expressed as one, and
+  // collapsing it into one used to drop every `!` pattern — silently loading
+  // zero test files for a sharded run.
+  const meteorIgnoreMatcher = createIgnoreMatcherSource(inMeteorIgnoreEntries);
 
   const prefix = (inPrefix && `${inPrefix}-`) || "";
   const filename = isAppTest
@@ -64,8 +69,9 @@ const generateEagerTestFile = ({
   const content = `${
     globalImportPath ? `import '${toPosix(globalImportPath)}';\n\n` : ""
   }${
-    excludeMeteorIgnoreRegex
-      ? `const MeteorIgnoreRegex = ${excludeMeteorIgnoreRegex.toString()};`
+    meteorIgnoreMatcher
+      ? `import MeteorIgnore from '${toPosix(meteorIgnoreMatcher.modulePath)}';\n\n` +
+        `const MeteorIgnoreMatcher = ${meteorIgnoreMatcher.source}(MeteorIgnore);`
       : ""
   }
 {
@@ -77,9 +83,9 @@ const generateEagerTestFile = ({
   });
   await Promise.all(ctx.keys().filter((k) => {
     ${
-      excludeMeteorIgnoreRegex
+      meteorIgnoreMatcher
         ? `// Only exclude based on *relative* path segments.
-    return !MeteorIgnoreRegex.test(k);`
+    return !MeteorIgnoreMatcher(k);`
         : "return true;"
     }
   }).map(ctx));

package/lib/test.test.js

@@ -0,0 +1,49 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const { createIgnoreMatcherSource } = require('./ignore.js');
+const { generateEagerTestFile } = require('./test.js');
+
+describe('generateEagerTestFile', () => {
+  let projectDir;
+
+  beforeEach(() => {
+    projectDir = fs.mkdtempSync(path.join(os.tmpdir(), 'meteor-eager-test-'));
+  });
+
+  afterEach(() => {
+    fs.rmSync(projectDir, { recursive: true, force: true });
+  });
+
+  const generate = meteorIgnoreEntries =>
+    fs.readFileSync(
+      generateEagerTestFile({
+        isAppTest: false,
+        projectDir,
+        buildContext: '_build',
+        meteorIgnoreEntries,
+      }),
+      'utf8',
+    );
+
+  test('filters test files through a matcher built from the ignore package', () => {
+    const entries = ['*.tests.ts', '!/imports/a/B.tests.ts'];
+    const { modulePath, source } = createIgnoreMatcherSource(entries);
+
+    const content = generate(entries);
+
+    expect(content).toContain(
+      `import MeteorIgnore from '${modulePath.replace(/\\/g, '/')}';`,
+    );
+    expect(content).toContain(source);
+    expect(content).toContain('!MeteorIgnoreMatcher(k)');
+  });
+
+  test('keeps every test file when there are no meteor ignore entries', () => {
+    const content = generate([]);
+
+    expect(content).not.toContain('MeteorIgnore');
+    expect(content).toContain('return true;');
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meteorjs/rspack",
-  "version": "3.0.0-beta.1",
+  "version": "3.0.0-beta.3",
   "description": "Configuration logic for using Rspack in Meteor projects",
   "main": "index.js",
   "type": "commonjs",
@@ -12,6 +12,7 @@
   },
   "dependencies": {
     "fast-deep-equal": "^3.1.3",
+    "ignore": "^7.0.5",
     "ignore-loader": "^0.1.2",
     "isomorphic-timers-promises": "^1.0.1",
     "rspack-merge": "^1.0.1"

package/plugins/RequireExtenalsPlugin.js

@@ -164,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();

package/rspack.config.js

@@ -123,6 +123,7 @@ function createSwcConfig({
   externalHelpers,
   isDevEnvironment,
   isClient,
+  isLegacy,
   isAngularEnabled,
 }) {
   const defaultConfig = {
@@ -133,7 +134,7 @@ function createSwcConfig({
         ...(isJsxEnabled && { jsx: true }),
         ...(isAngularEnabled && { decorators: true }),
       },
-      target: isClient ? 'es2015' : 'es2022',
+      target: isLegacy ? 'es5' : isClient ? 'es2015' : 'es2022',
       ...(isReactEnabled && {
         transform: {
           react: {
@@ -257,6 +258,10 @@ module.exports = async function (inMeteor = {}, argv = {}) {
     Meteor.chunksContext ||
     process.env.RSPACK_CHUNKS_CONTEXT ||
     `build-chunks${(meteorLocalDirName && `-${meteorLocalDirName}`) || ""}`;
+  const clientOutputContext = Meteor.clientOutputContext || '';
+  const clientOutputDir = path.resolve(projectDir, 'public', clientOutputContext);
+  const clientChunkPrefix = clientOutputContext ? '' : `${chunksContext}/`;
+  const clientAssetContext = path.posix.relative(clientOutputContext, assetsContext);
 
   // Compute build paths before loading user config (needed by Meteor helpers below)
   const outputPath = Meteor.outputPath;
@@ -267,6 +272,9 @@ module.exports = async function (inMeteor = {}, argv = {}) {
   const isTest = !!Meteor.isTest;
   const isClient = !!Meteor.isClient;
   const isServer = !!Meteor.isServer;
+  const isLegacy = !!Meteor.isLegacy;
+  Meteor.isLegacy = isLegacy;
+  const arch = Meteor.arch;
   const isRun = !!Meteor.isRun;
   const isBuild = !!Meteor.isBuild;
   const isReactEnabled = !!Meteor.isReactEnabled;
@@ -312,7 +320,7 @@ module.exports = async function (inMeteor = {}, argv = {}) {
   // reassigned after load once mode is fully resolved.
   let cacheStrategy = createCacheStrategy(
     initialMode,
-    (Meteor.isClient && "client") || "server",
+    arch || (Meteor.isClient && "client") || "server",
     { projectConfigPath, configPath, buildContext }
   );
   let swcConfigRule = createSwcConfig({
@@ -321,8 +329,9 @@ module.exports = async function (inMeteor = {}, argv = {}) {
     isJsxEnabled,
     isTsxEnabled,
     externalHelpers: enableSwcExternalHelpers,
-    isDevEnvironment: isRun && initialIsDev && !isTest && !isNative,
+    isDevEnvironment: isRun && initialIsDev && !isTest && !isNative && !arch,
     isClient,
+    isLegacy,
     isAngularEnabled,
   });
   Meteor.swcConfigOptions = swcConfigRule.options;
@@ -355,7 +364,8 @@ module.exports = async function (inMeteor = {}, argv = {}) {
     return new HtmlRspackPlugin({
       inject: false,
       cache: true,
-      filename: `../${buildContext}/${outputDir}/index.html`,
+      filename: path.relative(clientOutputDir,
+        path.resolve(projectDir, buildContext, outputDir, 'index.html')).replaceAll(path.sep, '/'),
       templateContent: `
           <head>
             <% for tag in htmlRspackPlugin.tags.headTags { %>
@@ -401,7 +411,7 @@ module.exports = async function (inMeteor = {}, argv = {}) {
 
   cacheStrategy = createCacheStrategy(
     mode,
-    (Meteor.isClient && "client") || "server",
+    arch || (Meteor.isClient && "client") || "server",
     // 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).
@@ -418,7 +428,6 @@ module.exports = async function (inMeteor = {}, argv = {}) {
   );
 
   // Determine output directories
-  const clientOutputDir = path.resolve(projectDir, "public");
   const serverOutputDir = path.resolve(projectDir, "private");
 
 
@@ -441,12 +450,12 @@ 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);
   }
 
-  const isDevEnvironment = isRun && isDev && !isTest && !isNative;
+  const isDevEnvironment = isRun && isDev && !isTest && !isNative && !arch;
   swcConfigRule = createSwcConfig({
     isTypescriptEnabled,
     isReactEnabled,
@@ -455,6 +464,7 @@ module.exports = async function (inMeteor = {}, argv = {}) {
     externalHelpers: enableSwcExternalHelpers,
     isDevEnvironment,
     isClient,
+    isLegacy,
     isAngularEnabled,
   });
   Meteor.swcConfigOptions = swcConfigRule.options;
@@ -492,7 +502,7 @@ module.exports = async function (inMeteor = {}, argv = {}) {
     ...(Meteor.isBlazeEnabled && {
       externals: /\.html$/,
       isEagerImport: (module) => module.endsWith(".html"),
-      ...((isProd || (isTest && isClient)) && {
+      ...((isProd || arch || (isTest && isClient)) && {
         lastImports: [`./${outputFilename}`],
       }),
     }),
@@ -505,7 +515,7 @@ module.exports = async function (inMeteor = {}, argv = {}) {
     const filename = _fileInfo.filename;
     const isPublic = filename.startsWith("/") || filename.startsWith("public");
     if (isPublic) return `[name][ext][query]`;
-    return `${assetsContext}/[hash][ext][query]`;
+    return `${isClient ? clientAssetContext : assetsContext}/[hash][ext][query]`;
   };
 
   const rsdoctorModule = isBundleVisualizerEnabled
@@ -537,6 +547,7 @@ module.exports = async function (inMeteor = {}, argv = {}) {
     : { stats: "errors-warnings", infrastructureLogging: { level: "warn" } };
 
   const clientEntry =
+    arch && !(isTest && isTestEager) ? path.resolve(projectDir, buildContext, entryPath) :
     isClient && isTest && isTestEager && isTestFullApp
       ? generateEagerTestFile({
           isAppTest: true,
@@ -544,7 +555,7 @@ module.exports = async function (inMeteor = {}, argv = {}) {
           buildContext,
           ignoreEntries: ["**/server/**"],
           meteorIgnoreEntries,
-          prefix: "client",
+          prefix: arch || "client",
           extraEntry: path.resolve(process.cwd(), Meteor.mainClientEntry),
           globalImportPath: path.resolve(projectDir, buildContext, entryPath),
         })
@@ -556,13 +567,13 @@ module.exports = async function (inMeteor = {}, argv = {}) {
           buildContext,
           ignoreEntries: ["**/server/**"],
           meteorIgnoreEntries,
-          prefix: "client",
+          prefix: arch || "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-") || ""}${arch || 'client'}-rspack]`;
 
   // Default onListening provided by meteor-rspack. Kept as a named
   // reference so we can detect a user-supplied override after merge
@@ -603,7 +614,7 @@ module.exports = async function (inMeteor = {}, argv = {}) {
   // Base client config
   let clientConfig = {
     name: clientNameConfig,
-    target: "web",
+    target: isLegacy ? ["web", "es5"] : "web",
     mode,
     entry: clientEntry,
     output: {
@@ -611,27 +622,28 @@ module.exports = async function (inMeteor = {}, argv = {}) {
       filename: (_module) => {
         const chunkName = _module.chunk?.name;
         const isMainChunk = !chunkName || chunkName === "main";
-        const chunkSuffix = `${chunksContext}/[id]${
+        const chunkSuffix = `${clientChunkPrefix}[id]${
           isProd ? ".[chunkhash]" : ""
         }.js`;
         if (isDevEnvironment) {
           if (isMainChunk) return outputFilename;
           return chunkSuffix;
         }
-        if (isMainChunk) return `../${buildContext}/${outputPath}`;
+        if (isMainChunk) return path.relative(clientOutputDir,
+          path.resolve(projectDir, buildContext, outputPath)).replaceAll(path.sep, '/');
         return chunkSuffix;
       },
       library: { type: "commonjs2" },
-      publicPath: "/",
-      chunkFilename: `${chunksContext}/[id]${isProd ? ".[chunkhash]" : ""}.js`,
+      publicPath: clientOutputContext ? `/${clientOutputContext}/` : "/",
+      chunkFilename: `${clientChunkPrefix}[id]${isProd ? ".[chunkhash]" : ""}.js`,
       assetModuleFilename,
-      cssFilename: `${chunksContext}/[name]${
+      cssFilename: `${clientChunkPrefix}[name]${
         isProd ? ".[contenthash]" : ""
       }.css`,
-      cssChunkFilename: `${chunksContext}/[id]${
+      cssChunkFilename: `${clientChunkPrefix}[id]${
         isProd ? ".[contenthash]" : ""
       }.css`,
-      ...(isProd && { clean: { keep: keepOutsideBuild() } }),
+      ...(isProd && { clean: clientOutputContext ? true : { keep: keepOutsideBuild() } }),
     },
     optimization: {
       usedExports: true,
@@ -932,8 +944,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
@@ -950,19 +962,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 || [])];