diff --git a/meteor b/meteor
index 756a5f9de5..d407eba907 100755
--- a/meteor
+++ b/meteor
@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 
-BUNDLE_VERSION=22.18.0.22
+BUNDLE_VERSION=22.18.0.36
 
 # OS Check. Put here because here is where we download the precompiled
 # bundles that are arch specific.
diff --git a/npm-packages/meteor-rspack/entries/eager-app-tests.js b/npm-packages/meteor-rspack/entries/eager-app-tests.js
deleted file mode 100644
index 50a1c7fa2c..0000000000
--- a/npm-packages/meteor-rspack/entries/eager-app-tests.js
+++ /dev/null
@@ -1,9 +0,0 @@
-{
-  const ctx = import.meta.webpackContext('/', {
-    recursive: true,
-    regExp: /\.app-(?:test|spec)s?\.[^.]+$/,
-    exclude: /(^|\/)(node_modules|\.meteor|_build)(\/|$)/,
-    mode: 'eager',
-  });
-  ctx.keys().forEach(ctx);
-}
diff --git a/npm-packages/meteor-rspack/entries/eager-tests.js b/npm-packages/meteor-rspack/entries/eager-tests.js
deleted file mode 100644
index d5044e443b..0000000000
--- a/npm-packages/meteor-rspack/entries/eager-tests.js
+++ /dev/null
@@ -1,9 +0,0 @@
-{
-  const ctx = import.meta.webpackContext('/', {
-    recursive: true,
-    regExp: /\.(?:test|spec)s?\.[^.]+$/,
-    exclude: /(^|\/)(node_modules|\.meteor|_build)(\/|$)/,
-    mode: 'eager',
-  });
-  ctx.keys().forEach(ctx);
-}
diff --git a/npm-packages/meteor-rspack/index.js b/npm-packages/meteor-rspack/index.js
index a18cdc07b6..696487151f 100644
--- a/npm-packages/meteor-rspack/index.js
+++ b/npm-packages/meteor-rspack/index.js
@@ -1,5 +1,5 @@
-import { defineConfig as rspackDefineConfig } from '@rspack/cli';
-import HtmlRspackPlugin from './plugins/HtmlRspackPlugin.js';
+const { defineConfig: rspackDefineConfig } = require('@rspack/cli');
+const HtmlRspackPlugin = require('./plugins/HtmlRspackPlugin.js');
 
 /**
  * @typedef {import('rspack').Configuration & {
@@ -16,12 +16,13 @@ import HtmlRspackPlugin from './plugins/HtmlRspackPlugin.js';
  * @param {ConfigFactory} factory
  * @returns {ReturnType<typeof rspackDefineConfig>}
  */
-export function defineConfig(factory) {
+function defineConfig(factory) {
   return rspackDefineConfig(factory);
 }
 
-// Export our helper plus passthrough
-export default defineConfig;
+// Export our helper plus passthrough as default export
+module.exports = defineConfig;
 
-// Export the HtmlRspackPlugin
-export { HtmlRspackPlugin };
+// Export the HtmlRspackPlugin and defineConfig as named exports
+module.exports.defineConfig = defineConfig;
+module.exports.HtmlRspackPlugin = HtmlRspackPlugin;
diff --git a/npm-packages/meteor-rspack/lib/ignore.js b/npm-packages/meteor-rspack/lib/ignore.js
new file mode 100644
index 0000000000..17058cce19
--- /dev/null
+++ b/npm-packages/meteor-rspack/lib/ignore.js
@@ -0,0 +1,139 @@
+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.
+ *
+ * @param {string} projectDir - The project directory path
+ * @returns {string[]} - Array of ignore patterns
+ */
+const getMeteorIgnoreEntries = function (projectDir) {
+  const meteorIgnorePath = path.join(projectDir, '.meteorignore');
+
+  // Check if .meteorignore file exists
+  try {
+    const fileContent = fs.readFileSync(meteorIgnorePath, 'utf8');
+
+    // Process each line in the file
+    const entries = 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 [];
+  }
+};
+
+/**
+ * Creates a glob config array for ignoring specified patterns.
+ * Transforms .gitignore-style entries into chokidar-compatible glob patterns.
+ * @param {string[]} entries - Array of .gitignore-style patterns
+ * @returns {string[]} - Array of glob patterns for chokidar
+ */
+function createIgnoreGlobConfig(entries = []) {
+  if (!Array.isArray(entries)) {
+    throw new Error('Entries must be an array');
+  }
+
+  const globPatterns = [];
+
+  entries.forEach(entry => {
+    // Skip empty entries
+    if (!entry.trim()) {
+      return;
+    }
+
+    // Handle comments
+    if (entry.startsWith('#')) {
+      return;
+    }
+
+    // Check if it's a negation pattern
+    const isNegation = entry.startsWith('!');
+    let pattern = isNegation ? entry.substring(1).trim() : entry.trim();
+
+    // Remove leading ./ or / if present
+    pattern = pattern.replace(/^(\.\/|\/)/g, '');
+
+    // If it ends with /, it's a directory pattern, add ** to match all contents
+    if (pattern.endsWith('/')) {
+      pattern = pattern.slice(0, -1) + '/**';
+    }
+
+    // If it doesn't include a /, it could match anywhere in the path
+    if (!pattern.includes('/')) {
+      pattern = '**/' + pattern;
+    } else if (!pattern.startsWith('**/') && !pattern.startsWith('/')) {
+      // If it has a / but doesn't start with **/, add **/ to match anywhere
+      pattern = '**/' + pattern;
+    }
+
+    // Add the negation back if it was present
+    if (isNegation) {
+      pattern = '!' + pattern;
+    }
+
+    globPatterns.push(pattern);
+  });
+
+  return globPatterns;
+}
+
+/**
+ * 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
+ * @returns {RegExp} - Regex pattern to match the specified patterns
+ */
+function createIgnoreRegex(globPatterns) {
+  if (!Array.isArray(globPatterns) || globPatterns.length === 0) {
+    throw new Error('globPatterns must be a non-empty array');
+  }
+
+  // Process each glob pattern and convert to regex
+  const regexPatterns = globPatterns.map(pattern => {
+    // Skip negation patterns for the regex
+    if (pattern.startsWith('!')) {
+      return null;
+    }
+
+    // Escape special regex characters, but not * and /
+    let regexPattern = pattern.replace(/[.+?^${}()|[\]\\]/g, '\\$&');
+
+    // 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 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 + '$';
+
+    return regexPattern;
+  }).filter(pattern => pattern !== null);
+
+  if (regexPatterns.length === 0) {
+    // If all patterns were negations, return a regex that matches nothing
+    return new RegExp('^$');
+  }
+
+  // Join all patterns with | to create a single regex
+  const combinedPattern = regexPatterns.join('|');
+  return new RegExp(combinedPattern);
+}
+
+module.exports = {
+  createIgnoreRegex,
+  getMeteorIgnoreEntries,
+  createIgnoreGlobConfig,
+};
diff --git a/npm-packages/meteor-rspack/lib/mergeRulesSplitOverlap.js b/npm-packages/meteor-rspack/lib/mergeRulesSplitOverlap.js
index 2b8e946939..c7a73234d2 100644
--- a/npm-packages/meteor-rspack/lib/mergeRulesSplitOverlap.js
+++ b/npm-packages/meteor-rspack/lib/mergeRulesSplitOverlap.js
@@ -3,12 +3,13 @@
  * overlapping file extensions in module rules.
  */
 
-import { mergeWithCustomize } from 'webpack-merge';
+const { mergeWithCustomize } = require('webpack-merge');
+const isEqual = require('fast-deep-equal');
 
 /**
  * File extensions to check when determining rule overlaps.
  */
-export const EXT_CATALOG = [
+const EXT_CATALOG = [
   '.tsx', '.ts', '.mts', '.cts',
   '.jsx', '.js', '.mjs', '.cjs',
 ];
@@ -87,6 +88,10 @@ function splitOverlapRulesMerge(aRules, bRules) {
     for (let i = 0; i < result.length; i++) {
       const aRule = result[i];
 
+
+      const isMergeableRule = isEqual(aRule?.include || [], bRule?.include || []);
+      if (!isMergeableRule) continue;
+
       // Determine which extensions each rule matches (within our catalog)
       const aExts = EXT_CATALOG.filter(ext => ruleMatchesExt(aRule, ext));
       const bExts = EXT_CATALOG.filter(ext => ruleMatchesExt(bRule, ext));
@@ -130,7 +135,7 @@ function splitOverlapRulesMerge(aRules, bRules) {
  * @param {Function} getter - Function to get the identifier from the plugin
  * @returns {Function} Customizer function
  */
-export function unique(key, pluginNames = [], getter = item => item.constructor && item.constructor.name) {
+function unique(key, pluginNames = [], getter = item => item.constructor && item.constructor.name) {
   return (a, b, k) => {
     if (k !== key) return undefined;
 
@@ -183,7 +188,7 @@ export function unique(key, pluginNames = [], getter = item => item.constructor
  * @param {Function} [options.warningFn] - Custom warning function that receives the path string
  * @returns {Object} The cleaned object with specified paths removed
  */
-export function cleanOmittedPaths(obj, options = {}) {
+function cleanOmittedPaths(obj, options = {}) {
   if (!obj || typeof obj !== 'object') {
     return obj;
   }
@@ -252,13 +257,35 @@ export function cleanOmittedPaths(obj, options = {}) {
   return result;
 }
 
+/**
+ * Normalizes externals configuration to ensure consistent handling.
+ * @param {Object} config - The configuration object
+ * @returns {Object} - The normalized configuration
+ */
+function normalizeExternals(config) {
+  if (!config || !config.externals) return config;
+
+  // Create a deep clone of the config to avoid modifying the original
+  const result = { ...config };
+
+  // If externals is not an array, convert it to an array
+  if (!Array.isArray(result.externals)) {
+    result.externals = [result.externals];
+  }
+
+  return result;
+}
+
 /**
  * Merges webpack/rspack configs with smart handling of overlapping rules.
  *
  * @param {...Object} configs - Configs to merge
  * @returns {Object} Merged config
  */
-export function mergeSplitOverlap(...configs) {
+function mergeSplitOverlap(...configs) {
+  // Normalize externals in all configs before merging
+  const normalizedConfigs = configs.map(normalizeExternals);
+
   return mergeWithCustomize({
     customizeArray(a, b, key) {
       if (key === 'module.rules') {
@@ -267,6 +294,14 @@ export function mergeSplitOverlap(...configs) {
         return splitOverlapRulesMerge(aRules, bRules);
       }
 
+      // Ensure custom extensions first
+      if (key === 'resolve.extensions') {
+        const aRules = Array.isArray(a) ? a : [];
+        const bRules = Array.isArray(b) ? b : [];
+        const merged = [...bRules, ...aRules];
+        return [...new Set(merged)];
+      }
+
       // Handle plugins uniqueness
       if (key === 'plugins') {
         return unique(
@@ -279,5 +314,12 @@ export function mergeSplitOverlap(...configs) {
       // fall through to default merging
       return undefined;
     }
-  })(...configs);
+  })(...normalizedConfigs);
 }
+
+module.exports = {
+  EXT_CATALOG,
+  unique,
+  cleanOmittedPaths,
+  mergeSplitOverlap
+};
diff --git a/npm-packages/meteor-rspack/lib/meteorRspackConfigFactory.js b/npm-packages/meteor-rspack/lib/meteorRspackConfigFactory.js
new file mode 100644
index 0000000000..3dbeaf04a5
--- /dev/null
+++ b/npm-packages/meteor-rspack/lib/meteorRspackConfigFactory.js
@@ -0,0 +1,99 @@
+// meteorRspackConfigFactory.js
+
+const { mergeSplitOverlap } = require("./mergeRulesSplitOverlap.js");
+
+const DEFAULT_PREFIX = "meteorRspackConfig";
+let counter = 0;
+
+/**
+ * Create a uniquely keyed Rspack config fragment.
+ * Example return: { meteorRspackConfig1: { ...customConfig } }
+ *
+ * @param {object} customConfig
+ * @param {{ key?: number|string, prefix?: string }} [opts]
+ * @returns {Record<string, object>}
+ */
+function prepareMeteorRspackConfig(customConfig, opts = {}) {
+  if (!customConfig || typeof customConfig !== "object") {
+    throw new TypeError("customConfig must be an object");
+  }
+  const prefix = opts.prefix || DEFAULT_PREFIX;
+
+  let name;
+  if (opts.key != null) {
+    const k = String(opts.key).trim();
+    if (/^\d+$/.test(k)) name = `${prefix}${k}`;
+    else if (k.startsWith(prefix) && /^\d+$/.test(k.slice(prefix.length)))
+      name = k;
+    else
+      throw new Error(`opts.key must be a positive integer or "${prefix}<n>"`);
+
+    const n = parseInt(name.slice(prefix.length), 10);
+    if (Number.isFinite(n) && n > counter) counter = n;
+  } else {
+    counter += 1;
+    name = `${prefix}${counter}`;
+  }
+
+  return { [name]: customConfig };
+}
+
+/**
+ * Merge all `{prefix}<n>` fragments into `config` using `mergeSplitOverlap`,
+ * then remove those temporary keys. Mutates `config`.
+ *
+ * Position-aware merge:
+ * Walk the config in insertion order and fold:
+ *   - for a fragment key:  out = mergeSplitOverlap(out, fragment)
+ *   - for a normal key:    out = mergeSplitOverlap(out, { [key]: value })
+ *
+ * Result: fragments behave like spreads at their exact position;
+ * later inline keys override earlier ones (including fragments).
+ *
+ * @param {object} config
+ * @param {{ prefix?: string }} [opts]
+ * @returns {object} same (mutated) config
+ */
+function mergeMeteorRspackFragments(config, opts = {}) {
+  if (!config || typeof config !== "object" || Array.isArray(config)) {
+    throw new TypeError("config must be a plain object");
+  }
+  const prefix = opts.prefix || DEFAULT_PREFIX;
+
+  let out = {};
+  for (const key of Object.keys(config)) {
+    const val = config[key];
+
+    const isFragment =
+      typeof key === "string" &&
+      key.startsWith(prefix) &&
+      /^\d+$/.test(key.slice(prefix.length));
+
+    if (isFragment) {
+      if (!val || typeof val !== "object" || Array.isArray(val)) {
+        throw new Error(`Fragment "${key}" must be a plain object`);
+      }
+      out = mergeSplitOverlap(out, val);
+    } else {
+      out = mergeSplitOverlap(out, { [key]: val });
+    }
+  }
+
+  // keep object identity; fragments disappear because `out` doesn't include them
+  replaceObject(config, out);
+  return config;
+}
+
+function replaceObject(target, source) {
+  for (const k of Object.keys(target)) {
+    if (!(k in source)) delete target[k];
+  }
+  for (const k of Object.keys(source)) {
+    target[k] = source[k];
+  }
+}
+
+module.exports = {
+  prepareMeteorRspackConfig,
+  mergeMeteorRspackFragments,
+};
diff --git a/npm-packages/meteor-rspack/lib/meteorRspackHelpers.js b/npm-packages/meteor-rspack/lib/meteorRspackHelpers.js
new file mode 100644
index 0000000000..cde87ba899
--- /dev/null
+++ b/npm-packages/meteor-rspack/lib/meteorRspackHelpers.js
@@ -0,0 +1,106 @@
+const path = require("path");
+const { prepareMeteorRspackConfig } = require("./meteorRspackConfigFactory");
+const { builtinModules } = require("module");
+
+/**
+ * Resolve a package directory from node resolution.
+ * @param {string} pkg
+ * @returns {string} absolute directory of the package
+ */
+function pkgDir(pkg) {
+  const resolved = require.resolve(`${pkg}/package.json`, {
+    paths: [process.cwd()],
+  });
+  return path.dirname(resolved);
+}
+
+/**
+ * Wrap externals for Meteor runtime (marks deps as externals).
+ * Usage: compileWithMeteor(["sharp", "vimeo", "fs"])
+ *
+ * @param {string[]} deps - package names or module IDs
+ * @returns {Record<string, object>} `{ meteorRspackConfigX: { externals: [...] } }`
+ */
+function compileWithMeteor(deps) {
+  const flat = deps.flat().filter(Boolean);
+  return prepareMeteorRspackConfig({
+    externals: flat,
+  });
+}
+
+/**
+ * Add SWC transpilation rules limited to specific deps (monorepo-friendly).
+ * Usage: compileWithRspack(["@org/lib-a", "zod"])
+ *
+ * Requires global `Meteor.swcConfigOptions` (as in your setup).
+ *
+ * @param {string[]} deps - package names to include in SWC loader
+ * @returns {Record<string, object>} `{ meteorRspackConfigX: { module: { rules: [...] } } }`
+ */
+function compileWithRspack(deps, { options = {} } = {}) {
+  const includeDirs = deps.flat().filter(Boolean).map(pkgDir);
+
+  return prepareMeteorRspackConfig({
+    module: {
+      rules: [
+        {
+          test: /\.(?:[mc]?js|jsx|[mc]?ts|tsx)$/i,
+          include: includeDirs,
+          loader: "builtin:swc-loader",
+          options,
+        },
+      ],
+    },
+  });
+}
+
+/**
+ * Enable or disable Rspack cache config
+ * Usage: setCache(false)
+ *
+ * @param {boolean} enabled
+ * @param {Record<string, object>} cacheConfig
+ * @returns {Record<string, object>} `{ meteorRspackConfigX: { cache: {} } }`
+ */
+function setCache(
+  enabled,
+  cacheConfig = { cache: true, experiments: { cache: true } },
+) {
+  return prepareMeteorRspackConfig(
+    enabled
+      ? cacheConfig
+      : {
+        cache: false, // disable cache
+        experiments: {
+          cache: false, // disable persistent cache (experimental flag)
+        },
+      },
+  );
+}
+
+/**
+ * Build an alias map that disables ALL Node core modules in a web build.
+ * - Includes both 'fs' and 'node:fs' keys
+ * - Optional extras let you block non-core modules too
+ */
+function makeWebNodeBuiltinsAlias(extras = []) {
+  // Strip potential 'node:' prefixes then add both forms
+  const core = new Set(builtinModules.map((m) => m.replace(/^node:/, "")));
+
+  const names = new Set();
+  for (const m of core) {
+    names.add(m);           // e.g. 'fs'
+    names.add(`node:${m}`); // e.g. 'node:fs'
+  }
+  for (const x of extras) names.add(x);
+
+  // Map every name to false (causes hard error if imported)
+  return Object.fromEntries([...names].map((m) => [m, false]));
+}
+
+module.exports = {
+  compileWithMeteor,
+  compileWithRspack,
+  setCache,
+  makeWebNodeBuiltinsAlias,
+};
diff --git a/npm-packages/meteor-rspack/lib/swc.js b/npm-packages/meteor-rspack/lib/swc.js
index c221739330..8b43703059 100644
--- a/npm-packages/meteor-rspack/lib/swc.js
+++ b/npm-packages/meteor-rspack/lib/swc.js
@@ -1,12 +1,12 @@
-import fs from 'fs';
-import vm from 'vm';
+const fs = require('fs');
+const vm = require('vm');
 
 /**
  * Reads and parses the SWC configuration file.
  * @param {string} file - The name of the SWC configuration file (default: '.swcrc')
  * @returns {Object|undefined} The parsed SWC configuration or undefined if an error occurs
  */
-export function getMeteorAppSwcrc(file = '.swcrc') {
+function getMeteorAppSwcrc(file = '.swcrc') {
   try {
     const filePath = `${process.cwd()}/${file}`;
     if (file.endsWith('.js')) {
@@ -42,7 +42,7 @@ export function getMeteorAppSwcrc(file = '.swcrc') {
  * If the configuration has a baseUrl property, it will be set to process.cwd().
  * @returns {Object|undefined} The SWC configuration or undefined if no configuration exists
  */
-export function getMeteorAppSwcConfig() {
+function getMeteorAppSwcConfig() {
   const hasSwcRc = fs.existsSync(`${process.cwd()}/.swcrc`);
   const hasSwcJs = !hasSwcRc && fs.existsSync(`${process.cwd()}/swc.config.js`);
 
@@ -60,3 +60,8 @@ export function getMeteorAppSwcConfig() {
 
   return config;
 }
+
+module.exports = {
+  getMeteorAppSwcrc,
+  getMeteorAppSwcConfig
+};
diff --git a/npm-packages/meteor-rspack/lib/test.js b/npm-packages/meteor-rspack/lib/test.js
new file mode 100644
index 0000000000..6301c73681
--- /dev/null
+++ b/npm-packages/meteor-rspack/lib/test.js
@@ -0,0 +1,62 @@
+const fs = require('fs');
+const path = require('path');
+const { createIgnoreRegex, createIgnoreGlobConfig } = require("./ignore.js");
+
+/**
+ * Generates eager test files dynamically
+ * @param {Object} options - Options for generating the test file
+ * @param {boolean} options.isAppTest - Whether this is an app test
+ * @param {string} options.projectDir - The project directory
+ * @param {string} options.buildContext - The build context
+ * @param {string[]} options.entries - Array of ignore patterns
+ * @returns {string} The path to the generated file
+ */
+const generateEagerTestFile = ({
+  isAppTest,
+  projectDir,
+  buildContext,
+  entries = [],
+}) => {
+  const distDir = path.resolve(projectDir, ".meteor/local/test");
+  if (!fs.existsSync(distDir)) {
+    fs.mkdirSync(distDir, { recursive: true });
+  }
+
+  // Combine all ignore entries
+  const ignoreEntries = [
+    "**/node_modules/**",
+    "**/.meteor/**",
+    "**/public/**",
+    "**/private/**",
+    `**/${buildContext}/**`,
+    ...entries,
+  ];
+
+  // Create regex from ignore entries
+  const excludeFoldersRegex = createIgnoreRegex(
+    createIgnoreGlobConfig(ignoreEntries)
+  );
+
+  const filename = isAppTest ? "eager-app-tests.mjs" : "eager-tests.mjs";
+  const filePath = path.resolve(distDir, filename);
+  const regExp = isAppTest
+    ? "/\\.app-(?:test|spec)s?\\.[^.]+$/"
+    : "/\\.(?:test|spec)s?\\.[^.]+$/";
+
+  const content = `{
+  const ctx = import.meta.webpackContext('/', {
+    recursive: true,
+    regExp: ${regExp},
+    exclude: ${excludeFoldersRegex.toString()},
+    mode: 'eager',
+  });
+  ctx.keys().forEach(ctx);
+}`;
+
+  fs.writeFileSync(filePath, content);
+  return filePath;
+};
+
+module.exports = {
+  generateEagerTestFile,
+};
diff --git a/npm-packages/meteor-rspack/package-lock.json b/npm-packages/meteor-rspack/package-lock.json
index 4212d497e0..f0f0dca61d 100644
--- a/npm-packages/meteor-rspack/package-lock.json
+++ b/npm-packages/meteor-rspack/package-lock.json
@@ -1,14 +1,15 @@
 {
   "name": "@meteorjs/rspack",
-  "version": "0.0.36",
+  "version": "0.0.60",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@meteorjs/rspack",
-      "version": "0.0.36",
+      "version": "0.0.60",
       "license": "ISC",
       "dependencies": {
+        "fast-deep-equal": "^3.1.3",
         "ignore-loader": "^0.1.2",
         "webpack-merge": "^6.0.1"
       },
@@ -1398,8 +1399,7 @@
       "version": "3.1.3",
       "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
       "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
-      "license": "MIT",
-      "peer": true
+      "license": "MIT"
     },
     "node_modules/fast-uri": {
       "version": "3.0.6",
diff --git a/npm-packages/meteor-rspack/package.json b/npm-packages/meteor-rspack/package.json
index ae82b79cbe..413fc02091 100644
--- a/npm-packages/meteor-rspack/package.json
+++ b/npm-packages/meteor-rspack/package.json
@@ -1,12 +1,13 @@
 {
   "name": "@meteorjs/rspack",
-  "version": "0.0.36",
+  "version": "0.0.60",
   "description": "Configuration logic for using Rspack in Meteor projects",
   "main": "index.js",
-  "type": "module",
+  "type": "commonjs",
   "author": "",
   "license": "ISC",
   "dependencies": {
+    "fast-deep-equal": "^3.1.3",
     "ignore-loader": "^0.1.2",
     "webpack-merge": "^6.0.1"
   },
diff --git a/npm-packages/meteor-rspack/plugins/HtmlRspackPlugin.js b/npm-packages/meteor-rspack/plugins/HtmlRspackPlugin.js
index 6e0b9a9511..5af36fc29e 100644
--- a/npm-packages/meteor-rspack/plugins/HtmlRspackPlugin.js
+++ b/npm-packages/meteor-rspack/plugins/HtmlRspackPlugin.js
@@ -1,10 +1,11 @@
-import RspackMeteorHtmlPlugin, { loadHtmlRspackPluginFromHost } from './RspackMeteorHtmlPlugin.js';
+const RspackMeteorHtmlPlugin = require('./RspackMeteorHtmlPlugin.js');
+const { loadHtmlRspackPluginFromHost } = RspackMeteorHtmlPlugin;
 
 /**
  * A plugin that composes the original HtmlRspackPlugin from @rspack/core
  * and RspackMeteorHtmlPlugin, in that order.
  */
-export default class HtmlRspackPlugin {
+class HtmlRspackPlugin {
   constructor(options = {}) {
     this.options = options;
   }
@@ -26,3 +27,5 @@ export default class HtmlRspackPlugin {
     meteorPlugin.apply(compiler);
   }
 }
+
+module.exports = HtmlRspackPlugin;
diff --git a/npm-packages/meteor-rspack/plugins/RequireExtenalsPlugin.js b/npm-packages/meteor-rspack/plugins/RequireExtenalsPlugin.js
index c121cff63b..205863dbad 100644
--- a/npm-packages/meteor-rspack/plugins/RequireExtenalsPlugin.js
+++ b/npm-packages/meteor-rspack/plugins/RequireExtenalsPlugin.js
@@ -7,10 +7,10 @@
 // the externalMap function if provided.
 // Used for Blaze to translate require of html files to require of js files bundled by Meteor.
 
-import fs from 'fs';
-import path from 'path';
+const fs = require('fs');
+const path = require('path');
 
-export class RequireExternalsPlugin {
+class RequireExternalsPlugin {
   constructor({
     filePath,
     // Externals can be:
@@ -487,3 +487,5 @@ export class RequireExternalsPlugin {
     return existing;
   }
 }
+
+module.exports = { RequireExternalsPlugin };
diff --git a/npm-packages/meteor-rspack/plugins/RspackMeteorHtmlPlugin.js b/npm-packages/meteor-rspack/plugins/RspackMeteorHtmlPlugin.js
index baa93a336f..0e1ec8dd59 100644
--- a/npm-packages/meteor-rspack/plugins/RspackMeteorHtmlPlugin.js
+++ b/npm-packages/meteor-rspack/plugins/RspackMeteorHtmlPlugin.js
@@ -1,7 +1,7 @@
-import path from 'node:path';
-import { createRequire } from 'node:module';
+const path = require('node:path');
+const { createRequire } = require('node:module');
 
-export function loadHtmlRspackPluginFromHost(compiler) {
+function loadHtmlRspackPluginFromHost(compiler) {
   // Prefer the compiler's context; fall back to process.cwd()
   const ctx = compiler.options?.context || compiler.context || process.cwd();
   const requireFromHost = createRequire(path.join(ctx, 'package.json'));
@@ -16,7 +16,7 @@ export function loadHtmlRspackPluginFromHost(compiler) {
  * 1. Remove the injected `*-rspack.js` script tags
  * 2. Strip <!doctype> and <html>…</html> wrappers from the final HTML
  */
-export default class RspackMeteorHtmlPlugin {
+class RspackMeteorHtmlPlugin {
   apply(compiler) {
     const HtmlRspackPlugin = loadHtmlRspackPluginFromHost(compiler);
     if (!HtmlRspackPlugin?.getCompilationHooks) {
@@ -45,3 +45,6 @@ export default class RspackMeteorHtmlPlugin {
     });
   }
 }
+
+module.exports = RspackMeteorHtmlPlugin;
+module.exports.loadHtmlRspackPluginFromHost = loadHtmlRspackPluginFromHost;
diff --git a/npm-packages/meteor-rspack/rspack.config.js b/npm-packages/meteor-rspack/rspack.config.js
index 6353ea1c74..39e948af87 100644
--- a/npm-packages/meteor-rspack/rspack.config.js
+++ b/npm-packages/meteor-rspack/rspack.config.js
@@ -1,16 +1,22 @@
-import { DefinePlugin, BannerPlugin } from '@rspack/core';
-import fs from 'fs';
-import { createRequire } from 'module';
-import { inspect } from 'node:util';
-import path from 'path';
-import { merge } from 'webpack-merge';
+const { DefinePlugin, BannerPlugin, NormalModuleReplacementPlugin } = require('@rspack/core');
+const fs = require('fs');
+const { inspect } = require('node:util');
+const path = require('path');
+const { merge } = require('webpack-merge');
 
-import { cleanOmittedPaths, mergeSplitOverlap } from "./lib/mergeRulesSplitOverlap.js";
-import { getMeteorAppSwcConfig } from './lib/swc.js';
-import HtmlRspackPlugin from './plugins/HtmlRspackPlugin.js';
-import { RequireExternalsPlugin } from './plugins/RequireExtenalsPlugin.js';
-
-const require = createRequire(import.meta.url);
+const { cleanOmittedPaths, mergeSplitOverlap } = require("./lib/mergeRulesSplitOverlap.js");
+const { getMeteorAppSwcConfig } = require('./lib/swc.js');
+const HtmlRspackPlugin = require('./plugins/HtmlRspackPlugin.js');
+const { RequireExternalsPlugin } = require('./plugins/RequireExtenalsPlugin.js');
+const { generateEagerTestFile } = require("./lib/test.js");
+const { getMeteorIgnoreEntries, createIgnoreGlobConfig } = require("./lib/ignore");
+const { mergeMeteorRspackFragments } = require("./lib/meteorRspackConfigFactory.js");
+const {
+  compileWithMeteor,
+  compileWithRspack,
+  setCache,
+  makeWebNodeBuiltinsAlias,
+} = require('./lib/meteorRspackHelpers.js');
 
 // Safe require that doesn't throw if the module isn't found
 function safeRequire(moduleName) {
@@ -28,17 +34,52 @@ function safeRequire(moduleName) {
 }
 
 // Persistent filesystem cache strategy
-function createCacheStrategy(mode) {
+function createCacheStrategy(mode, side, { projectConfigPath, configPath } = {}) {
+  // Check for configuration files
+  const tsconfigPath = path.join(process.cwd(), 'tsconfig.json');
+  const hasTsconfig = fs.existsSync(tsconfigPath);
+  const babelRcConfig = path.join(process.cwd(), '.babelrc');
+  const hasBabelRcConfig = fs.existsSync(babelRcConfig);
+  const babelJsConfig = path.join(process.cwd(), 'babel.config.js');
+  const hasBabelJsConfig = fs.existsSync(babelJsConfig);
+  const swcrcPath = path.join(process.cwd(), '.swcrc');
+  const hasSwcrcConfig = fs.existsSync(swcrcPath);
+  const swcJsPath = path.join(process.cwd(), 'swc.config.js');
+  const hasSwcJsConfig = fs.existsSync(swcJsPath);
+  const postcssConfigPath = path.join(process.cwd(), 'postcss.config.js');
+  const hasPostcssConfig = fs.existsSync(postcssConfigPath);
+  const packageLockPath = path.join(process.cwd(), 'package-lock.json');
+  const hasPackageLock = fs.existsSync(packageLockPath);
+  const yarnLockPath = path.join(process.cwd(), 'yarn.lock');
+  const hasYarnLock = fs.existsSync(yarnLockPath);
+
+  // Build dependencies array
+  const buildDependencies = [
+    ...(projectConfigPath ? [projectConfigPath] : []),
+    ...(configPath ? [configPath] : []),
+    ...(hasTsconfig ? [tsconfigPath] : []),
+    ...(hasBabelRcConfig ? [babelRcConfig] : []),
+    ...(hasBabelJsConfig ? [babelJsConfig] : []),
+    ...(hasSwcrcConfig ? [swcrcPath] : []),
+    ...(hasSwcJsConfig ? [swcJsPath] : []),
+    ...(hasPostcssConfig ? [postcssConfigPath] : []),
+    ...(hasPackageLock ? [packageLockPath] : []),
+    ...(hasYarnLock ? [yarnLockPath] : []),
+  ].filter(Boolean);
+
   return {
     cache: true,
     experiments: {
       cache: {
-        version: `swc-${mode}`,
-        type: 'persistent',
+        version: `cache-${mode}${(side && `-${side}`) || ""}`,
+        type: "persistent",
         storage: {
-          type: 'filesystem',
-          directory: 'node_modules/.cache/rspack',
+          type: "filesystem",
+          directory: `node_modules/.cache/rspack${(side && `/${side}`) || ""}`,
         },
+        ...(buildDependencies.length > 0 && {
+          buildDependencies: buildDependencies,
+        })
       },
     },
   };
@@ -47,32 +88,48 @@ function createCacheStrategy(mode) {
 // SWC loader rule (JSX/JS)
 function createSwcConfig({
   isTypescriptEnabled,
+  isReactEnabled,
   isJsxEnabled,
   isTsxEnabled,
   externalHelpers,
   isDevEnvironment,
+  isClient,
 }) {
   const defaultConfig = {
     jsc: {
       baseUrl: process.cwd(),
-      paths: { '/*': ['*'] },
+      paths: { '/*': ['*', '/*'] },
       parser: {
         syntax: isTypescriptEnabled ? 'typescript' : 'ecmascript',
         ...(isTsxEnabled && { tsx: true }),
         ...(isJsxEnabled && { jsx: true }),
       },
       target: 'es2015',
-      transform: {
-        react: {
-          development: isDevEnvironment,
-          refresh: isDevEnvironment,
+      ...(isReactEnabled && {
+        transform: {
+          react: {
+            development: isDevEnvironment,
+            ...(isClient && { refresh: isDevEnvironment }),
+          },
         },
-      },
+      }),
       externalHelpers,
     },
   };
+
+  // Swcrc config not customizable
+  const omitPaths = [
+    'jsc.target',
+  ];
+  // Define warning function
+  const warningFn = path => {
+    console.warn(
+      `[.swcrc] Ignored custom "${path}" — reserved for Meteor-Rspack integration.`,
+    );
+  };
   const customConfig = getMeteorAppSwcConfig() || {};
-  const swcConfig = merge(defaultConfig, customConfig);
+  const cleanedCustomConfig = cleanOmittedPaths(customConfig, { omitPaths, warningFn });
+  const swcConfig = merge(defaultConfig, cleanedCustomConfig);
   return {
     test: /\.(?:[mc]?js|jsx|[mc]?ts|tsx)$/i,
     exclude: /node_modules|\.meteor\/local/,
@@ -81,6 +138,43 @@ function createSwcConfig({
   };
 }
 
+function createRemoteDevServerConfig() {
+  const rootUrl = process.env.ROOT_URL;
+  let hostname;
+  let protocol;
+  let port;
+
+  if (rootUrl) {
+    try {
+      const url = new URL(rootUrl);
+      // Detect if it's remote (not localhost or 127.x)
+      const isLocal =
+        url.hostname.includes('localhost') ||
+        url.hostname.startsWith('127.') ||
+        url.hostname.endsWith('.local');
+      if (!isLocal) {
+        hostname = url.hostname;
+        protocol = url.protocol === 'https:' ? 'wss' : 'ws';
+        port = url.port ? Number(url.port) : (url.protocol === 'https:' ? 443 : 80);
+
+        return {
+          client: {
+            webSocketURL: {
+              hostname,
+              port,
+              protocol,
+            },
+          },
+        };
+      }
+    } catch (err) {
+      console.warn(`Invalid ROOT_URL "${rootUrl}", falling back to localhost`);
+    }
+  }
+
+  // If local doesn't provide any extra config
+  return {};
+}
 
 // Keep files outside of build folders
 function keepOutsideBuild() {
@@ -92,17 +186,12 @@ function keepOutsideBuild() {
   };
 }
 
-// Watch options shared across both builds
-const defaultWatchOptions = {
-  ignored: ['**/.meteor/local/**', '**/dist/**'],
-};
-
 /**
  * @param {{ isClient: boolean; isServer: boolean; isDevelopment?: boolean; isProduction?: boolean; isTest?: boolean }} Meteor
  * @param {{ mode?: string; clientEntry?: string; serverEntry?: string; clientOutputFolder?: string; serverOutputFolder?: string; chunksContext?: string; assetsContext?: string; serverAssetsContext?: string }} argv
- * @returns {import('@rspack/cli').Configuration[]}
+ * @returns {Promise<import('@rspack/cli').Configuration[]>}
  */
-export default function (inMeteor = {}, argv = {}) {
+module.exports = async function (inMeteor = {}, argv = {}) {
   // Transform Meteor env properties to proper boolean values
   const Meteor = { ...inMeteor };
   // Convert string boolean values to actual booleans
@@ -118,7 +207,9 @@ export default function (inMeteor = {}, argv = {}) {
   const isDev = !!Meteor.isDevelopment || !isProd;
   const isTest = !!Meteor.isTest;
   const isClient = !!Meteor.isClient;
+  const isServer = !!Meteor.isServer;
   const isRun = !!Meteor.isRun;
+  const isBuild = !!Meteor.isBuild;
   const isReactEnabled = !!Meteor.isReactEnabled;
   const isTestModule = !!Meteor.isTestModule;
   const isTestEager = !!Meteor.isTestEager;
@@ -126,6 +217,9 @@ export default function (inMeteor = {}, argv = {}) {
   const swcExternalHelpers = !!Meteor.swcExternalHelpers;
   const isNative = !!Meteor.isNative;
   const mode = isProd ? 'production' : 'development';
+  const projectDir = process.cwd();
+  const projectConfigPath = Meteor.projectConfigPath || path.resolve(projectDir, 'rspack.config.js');
+  const configPath = Meteor.configPath;
 
   const isTypescriptEnabled = Meteor.isTypescriptEnabled || false;
   const isJsxEnabled =
@@ -147,11 +241,11 @@ export default function (inMeteor = {}, argv = {}) {
   const runPath = Meteor.runPath;
 
   // Determine banner
-  const bannerOutput = JSON.parse(Meteor.bannerOutput || '');
+  const bannerOutput = JSON.parse(Meteor.bannerOutput || process.env.RSPACK_BANNER || '""');
 
   // Determine output directories
-  const clientOutputDir = path.resolve(process.cwd(), 'public');
-  const serverOutputDir = path.resolve(process.cwd(), 'private');
+  const clientOutputDir = path.resolve(projectDir, 'public');
+  const serverOutputDir = path.resolve(projectDir, 'private');
 
   // Determine context for bundles and assets
   const buildContext = Meteor.buildContext || '_build';
@@ -159,9 +253,27 @@ export default function (inMeteor = {}, argv = {}) {
   const chunksContext = Meteor.chunksContext || 'build-chunks';
 
   // Determine build output and pass to Meteor
-  const buildOutputDir = path.resolve(process.cwd(), buildContext, outputDir);
+  const buildOutputDir = path.resolve(projectDir, buildContext, outputDir);
   Meteor.buildOutputDir = buildOutputDir;
 
+  const cacheStrategy = createCacheStrategy(
+    mode,
+    (Meteor.isClient && 'client') || 'server',
+    { projectConfigPath, configPath }
+  );
+
+  // Expose Meteor's helpers to expand Rspack configs
+  Meteor.compileWithMeteor = deps => compileWithMeteor(deps);
+  Meteor.compileWithRspack = deps =>
+    compileWithRspack(deps, {
+      options: Meteor.swcConfigOptions,
+    });
+  Meteor.setCache = enabled =>
+    setCache(
+      !!enabled,
+      enabled === 'memory' ? undefined : cacheStrategy
+    );
+
   // Add HtmlRspackPlugin function to Meteor
   Meteor.HtmlRspackPlugin = (options = {}) => {
     return new HtmlRspackPlugin({
@@ -184,18 +296,26 @@ export default function (inMeteor = {}, argv = {}) {
     });
   };
 
-  // Set watch options
+  // Get Meteor ignore entries
+  const meteorIgnoreEntries = getMeteorIgnoreEntries(projectDir);
+
+  // Additional ignore entries
+  const additionalEntries = [
+    "**/.meteor/local/**",
+    "**/dist/**",
+    ...(isTest && isTestEager
+      ? [`**/${buildContext}/**`, "**/.meteor/local/**", "node_modules/**"]
+      : []),
+  ];
+
+  // Set default watch options
   const watchOptions = {
-    ...defaultWatchOptions,
-    ...(isTest &&
-      isTestEager && {
-        ignored: [
-          ...defaultWatchOptions.ignored,
-          '**/_build/**',
-          '**/.meteor/local/**',
-          '**/node_modules/**',
-        ],
-      }),
+    ignored: [
+      ...createIgnoreGlobConfig([
+        ...meteorIgnoreEntries,
+        ...additionalEntries,
+      ]),
+    ],
   };
 
   if (Meteor.isDebug || Meteor.isVerbose) {
@@ -203,13 +323,16 @@ export default function (inMeteor = {}, argv = {}) {
     console.log('[i] Meteor flags:', Meteor);
   }
 
+  const enableSwcExternalHelpers = !isServer && swcExternalHelpers;
   const isDevEnvironment = isRun && isDev && !isTest && !isNative;
   const swcConfigRule = createSwcConfig({
     isTypescriptEnabled,
+    isReactEnabled,
     isJsxEnabled,
     isTsxEnabled,
-    externalHelpers: swcExternalHelpers,
+    externalHelpers: enableSwcExternalHelpers,
     isDevEnvironment,
+    isClient,
   });
   // Expose swc config to use in custom configs
   Meteor.swcConfigOptions = swcConfigRule.options;
@@ -217,10 +340,14 @@ export default function (inMeteor = {}, argv = {}) {
   const externals = [
     /^meteor.*/,
     ...(isReactEnabled ? [/^react$/, /^react-dom$/] : []),
+    ...(isServer ? [/^bcrypt$/] : []),
   ];
   const alias = {
     '/': path.resolve(process.cwd()),
   };
+  const fallback = {
+    ...(isClient && makeWebNodeBuiltinsAlias()),
+  };
   const extensions = [
     '.ts',
     '.tsx',
@@ -248,16 +375,26 @@ export default function (inMeteor = {}, argv = {}) {
         lastImports: [`./${outputFilename}`],
       }),
     }),
-    enableGlobalPolyfill: isDevEnvironment,
+    enableGlobalPolyfill: isDevEnvironment && !isServer,
   });
 
   const rsdoctorModule = isBundleVisualizerEnabled
     ? safeRequire('@rsdoctor/rspack-plugin')
     : null;
-  const doctorPluginConfig = isBundleVisualizerEnabled && rsdoctorModule?.RsdoctorRspackPlugin
+  const doctorPluginConfig = isRun && isBundleVisualizerEnabled && rsdoctorModule?.RsdoctorRspackPlugin
     ? [
         new rsdoctorModule.RsdoctorRspackPlugin({
-          port: isClient ? 8081 : 8082,
+          port: isClient
+            ? (parseInt(Meteor.rsdoctorClientPort || '8888', 10))
+            : (parseInt(Meteor.rsdoctorServerPort || '8889', 10)),
+        }),
+      ]
+    : [];
+  const bannerPluginConfig = !isBuild
+    ? [
+        new BannerPlugin({
+          banner: bannerOutput,
+          entryOnly: true,
         }),
       ]
     : [];
@@ -269,13 +406,24 @@ export default function (inMeteor = {}, argv = {}) {
   let clientConfig = {
     name: clientNameConfig,
     target: 'web',
-    mode: 'development',
+    mode,
     entry: path.resolve(process.cwd(), buildContext, entryPath),
     output: {
       path: clientOutputDir,
-      filename: () =>
-        isDevEnvironment ? outputFilename : `../${buildContext}/${outputPath}`,
-      libraryTarget: 'commonjs',
+      filename: (_module) => {
+        const chunkName = _module.chunk?.name;
+        const isMainChunk = !chunkName || chunkName === "main";
+        const chunkSuffix = `${chunksContext}/[id]${
+          isProd ? '.[chunkhash]' : ''
+        }.js`;
+        if (isDevEnvironment) {
+          if (isMainChunk) return outputFilename;
+          return chunkSuffix;
+        }
+        if (isMainChunk) return `../${buildContext}/${outputPath}`;
+        return chunkSuffix;
+      },
+      libraryTarget: 'commonjs2',
       publicPath: '/',
       chunkFilename: `${chunksContext}/[id]${isProd ? '.[chunkhash]' : ''}.js`,
       assetModuleFilename: `${assetsContext}/[hash][ext][query]`,
@@ -305,7 +453,7 @@ export default function (inMeteor = {}, argv = {}) {
         ...extraRules,
       ],
     },
-    resolve: { extensions, alias },
+    resolve: { extensions, alias, fallback },
     externals,
     plugins: [
       ...[
@@ -322,17 +470,18 @@ export default function (inMeteor = {}, argv = {}) {
         'Meteor.isDevelopment': JSON.stringify(isDev),
         'Meteor.isProduction': JSON.stringify(isProd),
       }),
-      new BannerPlugin({
-        banner: bannerOutput,
-        entryOnly: true,
-      }),
+      ...bannerPluginConfig,
       Meteor.HtmlRspackPlugin(),
       ...doctorPluginConfig,
+      new NormalModuleReplacementPlugin(/^node:(.*)$/, (res) => {
+        res.request = res.request.replace(/^node:/, '');
+      }),
     ],
     watchOptions,
     devtool: isDevEnvironment || isNative || isTest ? 'source-map' : 'hidden-source-map',
     ...(isDevEnvironment && {
       devServer: {
+        ...createRemoteDevServerConfig(),
         static: { directory: clientOutputDir, publicPath: '/__rspack__/' },
         hot: true,
         liveReload: true,
@@ -344,15 +493,26 @@ export default function (inMeteor = {}, argv = {}) {
         },
       },
     }),
-    experiments: { css: true },
+    ...merge(cacheStrategy, { experiments: { css: true } })
   };
 
+
   const serverEntry =
     isTest && isTestEager && isTestFullApp
-      ? path.resolve(process.cwd(), 'node_modules/@meteorjs/rspack/entries/eager-app-tests.js')
+      ? generateEagerTestFile({
+          isAppTest: true,
+          projectDir,
+          buildContext,
+          entries: meteorIgnoreEntries,
+        })
       : isTest && isTestEager
-      ? path.resolve(process.cwd(), 'node_modules/@meteorjs/rspack/entries/eager-tests.js')
-      : path.resolve(process.cwd(), buildContext, entryPath);
+      ? generateEagerTestFile({
+          isAppTest: false,
+          projectDir,
+          buildContext,
+          entries: meteorIgnoreEntries,
+        })
+      : path.resolve(projectDir, buildContext, entryPath);
   const serverNameConfig = `[${(isTest && 'test-') || ''}${
     (isTestModule && 'module') || 'server'
   }-rspack]`;
@@ -365,12 +525,16 @@ export default function (inMeteor = {}, argv = {}) {
     output: {
       path: serverOutputDir,
       filename: () => `../${buildContext}/${outputPath}`,
-      libraryTarget: 'commonjs',
+      libraryTarget: 'commonjs2',
       chunkFilename: `${chunksContext}/[id]${isProd ? '.[chunkhash]' : ''}.js`,
       assetModuleFilename: `${assetsContext}/[hash][ext][query]`,
       ...(isProd && { clean: { keep: keepOutsideBuild() } }),
     },
-    optimization: { usedExports: true },
+    optimization: {
+      usedExports: true,
+      splitChunks: false,
+      runtimeChunk: false,
+    },
     module: {
       rules: [swcConfigRule, ...extraRules],
       parser: {
@@ -383,10 +547,11 @@ export default function (inMeteor = {}, argv = {}) {
     resolve: {
       extensions,
       alias,
-      modules: ['node_modules', path.resolve(process.cwd())],
+      modules: ['node_modules', path.resolve(projectDir)],
       conditionNames: ['import', 'require', 'node', 'default'],
     },
     externals,
+    externalsPresets: { node: true },
     plugins: [
       new DefinePlugin(
         isTest && (isTestModule || isTestEager)
@@ -404,27 +569,47 @@ export default function (inMeteor = {}, argv = {}) {
               'Meteor.isProduction': JSON.stringify(isProd),
             },
       ),
-      new BannerPlugin({
-        banner: bannerOutput,
-        entryOnly: true,
-      }),
-      isTestModule && requireExternalsPlugin,
+      ...bannerPluginConfig,
+      requireExternalsPlugin,
       ...doctorPluginConfig,
     ],
     watchOptions,
     devtool: isDevEnvironment || isNative || isTest ? 'source-map' : 'hidden-source-map',
     ...((isDevEnvironment || (isTest && !isTestEager) || isNative) &&
-      createCacheStrategy(mode)),
+      cacheStrategy),
   };
 
   // Load and apply project-level overrides for the selected build
-  const projectConfigPath = path.resolve(process.cwd(), 'rspack.config.js');
-
   // Check if we're in a Meteor package directory by looking at the path
-  const isMeteorPackageConfig = process.cwd().includes('/packages/rspack');
+  const isMeteorPackageConfig = projectDir.includes('/packages/rspack');
   if (fs.existsSync(projectConfigPath) && !isMeteorPackageConfig) {
-    const projectConfig =
-      require(projectConfigPath)?.default || require(projectConfigPath);
+    // 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 configPath = projectConfigPath;
+    if (fs.existsSync(mjsConfigPath)) {
+      configPath = mjsConfigPath;
+    } else if (fs.existsSync(cjsConfigPath)) {
+      configPath = cjsConfigPath;
+    }
+
+    // Use require for CommonJS modules and dynamic import for ES modules
+    let projectConfig;
+    try {
+      if (path.extname(configPath) === '.mjs') {
+        // For ESM modules, we need to use dynamic import
+        const fileUrl = `file://${configPath}`;
+        const module = await import(fileUrl);
+        projectConfig = module.default || module;
+      } else {
+        // For CommonJS modules, we can use require
+        projectConfig = require(configPath)?.default || require(configPath);
+      }
+    } catch (error) {
+      console.error(`Error loading rspack config from ${configPath}:`, error);
+      throw error;
+    }
 
     const userConfig =
       typeof projectConfig === 'function'
@@ -432,29 +617,38 @@ export default function (inMeteor = {}, argv = {}) {
         : projectConfig;
 
     const omitPaths = [
-      'name',
-      'target',
-      'entry',
-      'output.path',
-      'output.filename',
-      'output.publicPath',
-    ];
+      "name",
+      "target",
+      "entry",
+      "output.path",
+      "output.filename",
+      "output.publicPath",
+      ...(Meteor.isServer
+        ? ["optimization.splitChunks", "optimization.runtimeChunk"]
+        : []),
+    ].filter(Boolean);
     const warningFn = path => {
       console.warn(
         `[rspack.config.js] Ignored custom "${path}" — reserved for Meteor-Rspack integration.`,
       );
     };
 
+    let nextUserConfig = cleanOmittedPaths(userConfig, {
+      omitPaths,
+      warningFn,
+    });
+    nextUserConfig = mergeMeteorRspackFragments(nextUserConfig);
+
     if (Meteor.isClient) {
       clientConfig = mergeSplitOverlap(
         clientConfig,
-        cleanOmittedPaths(userConfig, { omitPaths, warningFn }),
+        nextUserConfig
       );
     }
     if (Meteor.isServer) {
       serverConfig = mergeSplitOverlap(
         serverConfig,
-        cleanOmittedPaths(userConfig, { omitPaths, warningFn }),
+        nextUserConfig
       );
     }
   }
diff --git a/package.json b/package.json
index 398337f89a..183ff91e63 100644
--- a/package.json
+++ b/package.json
@@ -11,10 +11,6 @@
     "url": "https://github.com/meteor/meteor/issues"
   },
   "homepage": "https://www.meteor.com/",
-  "scripts": {
-    "install:modern": "cd tools/modern-tests && npm install && npx playwright install && npx playwright install --with-deps",
-    "test:modern": "cd tools/modern-tests && npm test -- "
-  },
   "devDependencies": {
     "@babel/core": "^7.21.3",
     "@babel/eslint-parser": "^7.21.3",
@@ -39,7 +35,9 @@
     "typescript": "^5.4.5"
   },
   "scripts": {
-    "test:idle-bot": "node --test .github/scripts/__tests__/inactive-issues.test.js"
+    "install:modern": "cd tools/modern-tests && npm install && npx playwright install && npx playwright install --with-deps",
+    "test:idle-bot": "node --test .github/scripts/__tests__/inactive-issues.test.js",
+    "test:modern": "cd tools/modern-tests && npm test -- "
   },
   "jshintConfig": {
     "esversion": 11
diff --git a/packages/accounts-base/package.js b/packages/accounts-base/package.js
index 4190011694..ef6bbb1cb3 100644
--- a/packages/accounts-base/package.js
+++ b/packages/accounts-base/package.js
@@ -1,6 +1,6 @@
 Package.describe({
   summary: "A user account system",
-  version: "3.1.2",
+  version: "3.2.0-beta340.11",
 });
 
 Package.onUse((api) => {
diff --git a/packages/accounts-password/package.js b/packages/accounts-password/package.js
index f41e5b8127..e4c64f8d24 100644
--- a/packages/accounts-password/package.js
+++ b/packages/accounts-password/package.js
@@ -11,6 +11,7 @@ Package.describe({
 Npm.depends({
   bcrypt: "5.0.1",
   argon2: "0.41.1",
+  "node-gyp-build": "4.8.4",
 });
 
 Package.onUse((api) => {
diff --git a/packages/babel-compiler/babel-compiler.js b/packages/babel-compiler/babel-compiler.js
index 860061818a..fe72514001 100644
--- a/packages/babel-compiler/babel-compiler.js
+++ b/packages/babel-compiler/babel-compiler.js
@@ -246,7 +246,7 @@ BCp.processOneFileForTarget = function (inputFile, source) {
   // Check if the file is a Rspack output file
   // If it is, bypass SWC/Babel and just read the file and its map file
   // as the contents are already transpiled by Rspack.
-  if (Plugin?.rspackHelpers?.isRspackOutputFile(inputFilePath)) {
+if (Plugin?.rspackHelpers?.isRspackOutputFile(inputFilePath)) {
     try {
       // Get the full path to the file
       const fullPath = inputFile.getPathInPackage();
@@ -260,6 +260,17 @@ BCp.processOneFileForTarget = function (inputFile, source) {
         toBeAdded.sourceMap = JSON.parse(mapContent);
       }
 
+      if (this.isVerbose()) {
+        const arch = inputFile.getArch();
+        logTranspilation({
+          usedRspack: true,
+          inputFilePath,
+          packageName,
+          cacheHit: true,
+          arch,
+        });
+      }
+
       return toBeAdded;
     } catch (e) {
       // If there's an error reading the file or map, log it and continue with normal processing
@@ -281,7 +292,8 @@ BCp.processOneFileForTarget = function (inputFile, source) {
     const features = Object.assign({}, this.extraFeatures);
     const arch = inputFile.getArch();
 
-    if (arch.startsWith("os.")) {
+    const isNodeTarget = arch.startsWith("os.");
+    if (isNodeTarget) {
       // Start with a much simpler set of Babel presets and plugins if
       // we're compiling for Node 8.
       features.nodeMajorVersion = parseInt(process.versions.node, 10);
@@ -355,8 +367,11 @@ BCp.processOneFileForTarget = function (inputFile, source) {
             tsx: hasTSXSupport,
           },
           ...(hasSwcHelpersAvailable &&
+            !isNodeTarget &&
             (packageName == null ||
-              !['modules-runtime'].includes(packageName)) && {
+              !['core-runtime', 'modules', 'modules-runtime'].includes(
+                packageName,
+              )) && {
               externalHelpers: true,
             }),
         },
@@ -373,6 +388,7 @@ BCp.processOneFileForTarget = function (inputFile, source) {
       // Merge with app-level SWC config
       if (lastModifiedSwcConfig) {
         swcOptions = deepMerge(swcOptions, lastModifiedSwcConfig, [
+          'jsc.target',
           'env.targets',
           'module.type',
         ]);
@@ -1120,14 +1136,16 @@ function logTranspilation({
   packageName,
   inputFilePath,
   usedSwc,
+  usedRspack,
   cacheHit,
   isNodeModulesCode,
   arch,
   errorMessage = '',
   tip = '',
 }) {
-  const transpiler = usedSwc ? 'SWC' : 'Babel';
-  const transpilerColor = usedSwc ? 32 : 33;
+  let transpiler = usedSwc ? 'SWC' : 'Babel';
+  transpiler = usedRspack ? 'Rspack' : transpiler;
+  const transpilerColor = usedSwc || usedRspack ? 32 : 33;
   const label = color('[Transpiler]', 36);
   const transpilerPart = `${label} Used ${color(
     transpiler,
@@ -1150,7 +1168,7 @@ function logTranspilation({
     : color(originPaddedRaw, 35);
   const cacheStatus = errorMessage
     ? color('⚠️  Fallback', 33)
-    : usedSwc
+    : usedSwc || usedRspack
     ? cacheHit
       ? color('🟢 Cache hit', 32)
       : color('🔴 Cache miss', 31)
diff --git a/packages/babel-compiler/package.js b/packages/babel-compiler/package.js
index 2e69cdc028..d528724189 100644
--- a/packages/babel-compiler/package.js
+++ b/packages/babel-compiler/package.js
@@ -1,14 +1,14 @@
 Package.describe({
   name: "babel-compiler",
   summary: "Parser/transpiler for ECMAScript 2015+ syntax",
-  version: '7.12.2',
+  version: '7.13.0-beta340.11',
 });
 
 Npm.depends({
   '@meteorjs/babel': '7.20.1',
   'json5': '2.2.3',
   'semver': '7.6.3',
-  "@meteorjs/swc-core": "1.12.14",
+  "@meteorjs/swc-core": "1.13.5",
 });
 
 Package.onUse(function (api) {
diff --git a/packages/boilerplate-generator/package.js b/packages/boilerplate-generator/package.js
index de1d8f8e40..3fa23d1ec0 100644
--- a/packages/boilerplate-generator/package.js
+++ b/packages/boilerplate-generator/package.js
@@ -1,6 +1,6 @@
 Package.describe({
   summary: "Generates the boilerplate html from program's manifest",
-  version: '2.0.2',
+  version: '2.1.0-beta340.11',
 });
 
 Npm.depends({
diff --git a/packages/ecmascript/package.js b/packages/ecmascript/package.js
index dcc86c7f0b..35c78bd132 100644
--- a/packages/ecmascript/package.js
+++ b/packages/ecmascript/package.js
@@ -1,6 +1,6 @@
 Package.describe({
   name: 'ecmascript',
-  version: '0.16.13',
+  version: '0.17.0-beta340.11',
   summary: 'Compiler plugin that supports ES2015+ in all .js files',
   documentation: 'README.md',
 });
diff --git a/packages/meteor-tool/package.js b/packages/meteor-tool/package.js
index 00beae7bc0..856ba17cb7 100644
--- a/packages/meteor-tool/package.js
+++ b/packages/meteor-tool/package.js
@@ -1,6 +1,6 @@
 Package.describe({
   summary: "The Meteor command-line tool",
-  version: "3.3.1",
+  version: "3.4.0-beta.11",
 });
 
 Package.includeTool();
diff --git a/packages/minifier-js/package.js b/packages/minifier-js/package.js
index 788cf783b6..3533f9ba77 100644
--- a/packages/minifier-js/package.js
+++ b/packages/minifier-js/package.js
@@ -1,6 +1,6 @@
 Package.describe({
   summary: "JavaScript minifier",
-  version: '3.0.4',
+  version: '3.1.0-beta340.11',
 });
 
 Npm.depends({
diff --git a/packages/minimongo/local_collection.js b/packages/minimongo/local_collection.js
index 7d564ca564..a345d4938c 100644
--- a/packages/minimongo/local_collection.js
+++ b/packages/minimongo/local_collection.js
@@ -743,7 +743,7 @@ export default class LocalCollection {
       for (const id of specificIds) {
         const doc = this._docs.get(id);
 
-        if (doc && !fn(doc, id)) {
+        if (doc && fn(doc, id) === false) {
           break
         }
       }
diff --git a/packages/minimongo/minimongo_tests.js b/packages/minimongo/minimongo_tests.js
index 9801384815..65953b5f91 100644
--- a/packages/minimongo/minimongo_tests.js
+++ b/packages/minimongo/minimongo_tests.js
@@ -59,6 +59,36 @@ Tinytest.add('minimongo - wrapTransform', test => {
   handle.stop();
 });
 
+Tinytest.add('minimongo - bulk remove with $in operator removes all matching documents', function(test) {
+  const coll = new LocalCollection();
+  
+  // Insert multiple documents
+  const ids = ['id1', 'id2', 'id3', 'id4'];
+  ids.forEach(id => {
+    coll.insert({ _id: id, value: `item-${id}` });
+  });
+  
+  // Verify we have 4 documents
+  test.equal(coll.find().count(), 4);
+  
+  // Remove 2 documents using $in operator
+  const removedCount = coll.remove({ _id: { $in: ['id1', 'id2'] } });
+  
+  // This should remove 2 documents, not just 1
+  test.equal(removedCount, 2);
+  
+  // Verify only 2 documents remain
+  test.equal(coll.find().count(), 2);
+  
+  // Verify the correct documents were removed
+  test.isUndefined(coll.findOne('id1'));
+  test.isUndefined(coll.findOne('id2'));
+  
+  // Verify the other documents still exist
+  test.isNotUndefined(coll.findOne('id3'));
+  test.isNotUndefined(coll.findOne('id4'));
+});
+
 if (Meteor.isClient) {
   Tinytest.add('minimongo - $geoIntersects should throw error', function(test) {
     const collection = new LocalCollection();
diff --git a/packages/minimongo/minimongo_tests_client.js b/packages/minimongo/minimongo_tests_client.js
index 074705f33c..c1405552a5 100644
--- a/packages/minimongo/minimongo_tests_client.js
+++ b/packages/minimongo/minimongo_tests_client.js
@@ -4061,4 +4061,4 @@ Tinytest.addAsync('minimongo - operation result fields (async)', async test => {
   // Test remove
   const removeResult = await c.removeAsync({name: 'doc1'});
   test.equal(removeResult, 1, 'remove should return removed count');
-});
+});
\ No newline at end of file
diff --git a/packages/mongo/collection/collection.js b/packages/mongo/collection/collection.js
index f41f97a68c..23cb81f7f0 100644
--- a/packages/mongo/collection/collection.js
+++ b/packages/mongo/collection/collection.js
@@ -62,8 +62,15 @@ Mongo.Collection = function Collection(name, options) {
   setupAutopublish(this, name, options);
 
   Mongo._collections.set(name, this);
+  
+  // Apply collection extensions
+  CollectionExtensions._applyExtensions(this, name, options);
 };
 
+// Apply static methods to the Collection constructor
+CollectionExtensions._applyStaticMethods(Mongo.Collection);
+
+
 Object.assign(Mongo.Collection.prototype, {
   _getFindSelector(args) {
     if (args.length == 0) return {};
@@ -153,6 +160,118 @@ Object.assign(Mongo.Collection, {
 
     return selector;
   },
+
+  // Collection Extensions API - delegate to CollectionExtensions
+  /**
+   * @summary Add a constructor extension function that runs when collections are created.
+   * @locus Anywhere
+   * @memberof Mongo.Collection
+   * @static
+   * @param {Function} extension Extension function called with (name, options) and 'this' bound to collection instance
+   */
+  addExtension(extension) {
+    return CollectionExtensions.addExtension(extension);
+  },
+
+  /**
+   * @summary Add a prototype method to all collection instances.
+   * @locus Anywhere
+   * @memberof Mongo.Collection
+   * @static
+   * @param {String} name The name of the method to add
+   * @param {Function} method The method function, bound to the collection instance
+   */
+  addPrototypeMethod(name, method) {
+    return CollectionExtensions.addPrototypeMethod(name, method);
+  },
+
+  /**
+   * @summary Add a static method to the Mongo.Collection constructor.
+   * @locus Anywhere
+   * @memberof Mongo.Collection
+   * @static
+   * @param {String} name The name of the static method to add
+   * @param {Function} method The static method function
+   */
+  addStaticMethod(name, method) {
+    return CollectionExtensions.addStaticMethod(name, method);
+  },
+
+  /**
+   * @summary Remove a constructor extension (useful for testing).
+   * @locus Anywhere
+   * @memberof Mongo.Collection
+   * @static
+   * @param {Function} extension The extension function to remove
+   */
+  removeExtension(extension) {
+    return CollectionExtensions.removeExtension(extension);
+  },
+
+  /**
+   * @summary Remove a prototype method from all collection instances.
+   * @locus Anywhere
+   * @memberof Mongo.Collection
+   * @static
+   * @param {String} name The name of the method to remove
+   */
+  removePrototypeMethod(name) {
+    return CollectionExtensions.removePrototypeMethod(name);
+  },
+
+  /**
+   * @summary Remove a static method from the Mongo.Collection constructor.
+   * @locus Anywhere
+   * @memberof Mongo.Collection
+   * @static
+   * @param {String} name The name of the static method to remove
+   */
+  removeStaticMethod(name) {
+    return CollectionExtensions.removeStaticMethod(name);
+  },
+
+  /**
+   * @summary Clear all extensions, prototype methods, and static methods (useful for testing).
+   * @locus Anywhere
+   * @memberof Mongo.Collection
+   * @static
+   */
+  clearExtensions() {
+    return CollectionExtensions.clearExtensions();
+  },
+
+  /**
+   * @summary Get all registered constructor extensions (useful for debugging).
+   * @locus Anywhere
+   * @memberof Mongo.Collection
+   * @static
+   * @returns {Array<Function>} Array of registered extension functions
+   */
+  getExtensions() {
+    return CollectionExtensions.getExtensions();
+  },
+
+  /**
+   * @summary Get all registered prototype methods (useful for debugging).
+   * @locus Anywhere
+   * @memberof Mongo.Collection
+   * @static
+   * @returns {Map<String, Function>} Map of method names to functions
+   */
+  getPrototypeMethods() {
+    return CollectionExtensions.getPrototypeMethods();
+  },
+
+  /**
+   * @summary Get all registered static methods (useful for debugging).
+   * @locus Anywhere
+   * @memberof Mongo.Collection
+   * @static
+   * @returns {Map<String, Function>} Map of method names to functions
+   */
+  getStaticMethods() {
+    return CollectionExtensions.getStaticMethods();
+  }
 });
 
 Object.assign(Mongo.Collection.prototype, ReplicationMethods, SyncMethods, AsyncMethods, IndexMethods);
@@ -230,6 +349,13 @@ Object.assign(Mongo, {
    * @protected
    */
   _collections: new Map(),
+
+  /**
+   * @summary Collection Extensions API
+   * @memberof Mongo
+   * @static
+   */
+  CollectionExtensions: CollectionExtensions
 })
 
 
diff --git a/packages/mongo/collection/collection_extensions.js b/packages/mongo/collection/collection_extensions.js
new file mode 100644
index 0000000000..c259f9a4f2
--- /dev/null
+++ b/packages/mongo/collection/collection_extensions.js
@@ -0,0 +1,146 @@
+/**
+ * Collection Extensions System
+ * 
+ * Provides a clean way to extend Mongo.Collection functionality
+ * without monkey patching. Supports constructor extensions,
+ * prototype methods, and static methods.
+ */
+
+if (Package['lai:collection-extensions']) {
+  console.warn('lai:collection-extensions is not deprecated. Use Mongo.Collection.addExtension instead.');
+}
+
+CollectionExtensions = {
+  _extensions: [],
+  _prototypeMethods: new Map(),
+  _staticMethods: new Map(),
+  
+  /**
+   * Add a constructor extension function
+   * Extension function is called with (name, options) and 'this' bound to collection instance
+   */
+  addExtension(extension) {
+    if (typeof extension !== 'function') {
+      throw new Error('Extension must be a function');
+    }
+    this._extensions.push(extension);
+  },
+  
+  /**
+   * Add a prototype method to all collection instances
+   * Method is bound to the collection instance
+   */
+  addPrototypeMethod(name, method) {
+    if (typeof name !== 'string' || !name) {
+      throw new Error('Prototype method name must be a non-empty string');
+    }
+    if (typeof method !== 'function') {
+      throw new Error('Prototype method must be a function');
+    }
+    
+    this._prototypeMethods.set(name, method);
+  },
+  
+  /**
+   * Add a static method to the Mongo.Collection constructor
+   */
+  addStaticMethod(name, method) {
+    if (typeof name !== 'string' || !name) {
+      throw new Error('Static method name must be a non-empty string');
+    }
+    if (typeof method !== 'function') {
+      throw new Error('Static method must be a function');
+    }
+    
+    this._staticMethods.set(name, method);
+  },
+  
+  /**
+   * Remove an extension (useful for testing)
+   */
+  removeExtension(extension) {
+    const index = this._extensions.indexOf(extension);
+    if (index > -1) {
+      this._extensions.splice(index, 1);
+    }
+  },
+  
+  /**
+   * Remove a prototype method
+   */
+  removePrototypeMethod(name) {
+    this._prototypeMethods.delete(name);
+  },
+  
+  /**
+   * Remove a static method
+   */
+  removeStaticMethod(name) {
+    this._staticMethods.delete(name);
+  },
+  
+  /**
+   * Clear all extensions (useful for testing)
+   */
+  clearExtensions() {
+    this._extensions.length = 0;
+    this._prototypeMethods.clear();
+    this._staticMethods.clear();
+  },
+  
+  /**
+   * Get all registered extensions (useful for debugging)
+   */
+  getExtensions() {
+    return [...this._extensions];
+  },
+  
+  /**
+   * Get all registered prototype methods (useful for debugging)
+   */
+  getPrototypeMethods() {
+    return new Map(this._prototypeMethods);
+  },
+  
+  /**
+   * Get all registered static methods (useful for debugging)
+   */
+  getStaticMethods() {
+    return new Map(this._staticMethods);
+  },
+  
+
+  
+  /**
+   * Apply all extensions to a collection instance
+   * Called during collection construction
+   */
+  _applyExtensions(instance, name, options) {
+    // Apply constructor extensions
+    for (const extension of this._extensions) {
+      try {
+        extension.call(instance, name, options);
+      } catch (error) {
+        // Provide helpful error context
+        throw new Error(`Extension failed for collection '${name}': ${error.message}`);
+      }
+    }
+    
+    // Apply prototype methods
+    for (const [methodName, method] of this._prototypeMethods) {
+      instance[methodName] = method.bind(instance);
+    }
+  },
+  
+  /**
+   * Apply static methods to the Mongo.Collection constructor
+   * Called during package initialization
+   */
+  _applyStaticMethods(CollectionConstructor) {
+    for (const [methodName, method] of this._staticMethods) {
+      CollectionConstructor[methodName] = method;
+    }
+  },
+  
+
+}; 
\ No newline at end of file
diff --git a/packages/mongo/mongo.d.ts b/packages/mongo/mongo.d.ts
index 2f3c941732..0d499ee588 100644
--- a/packages/mongo/mongo.d.ts
+++ b/packages/mongo/mongo.d.ts
@@ -53,6 +53,50 @@ export namespace Mongo {
     ? T
     : U;
 
+  /**
+   * Configuration options for Mongo Collection constructor
+   */
+  interface CollectionOptions<T = any, U = T> {
+    /**
+     * The server connection that will manage this collection. Uses the default connection if not specified. 
+     * Pass the return value of calling `DDP.connect` to specify a different server. Pass `null` to specify 
+     * no connection. Unmanaged (`name` is null) collections cannot specify a connection.
+     */
+    connection?: DDP.DDPStatic | null | undefined;
+    
+    /** 
+     * The method of generating the `_id` fields of new documents in this collection. Possible values:
+     * - **`'STRING'`**: random strings
+     * - **`'MONGO'`**: random [`Mongo.ObjectID`](#mongo_object_id) values
+     * 
+     * The default id generation technique is `'STRING'`.
+     */
+    idGeneration?: string | undefined;
+    
+    /**
+     * An optional transformation function. Documents will be passed through this function before being 
+     * returned from `fetch` or `findOne`, and before being passed to callbacks of `observe`, `map`, 
+     * `forEach`, `allow`, and `deny`. Transforms are *not* applied for the callbacks of `observeChanges` 
+     * or to cursors returned from publish functions.
+     */
+    transform?: (doc: T) => U;
+    
+    /** 
+     * Set to `false` to skip setting up the mutation methods that enable insert/update/remove from client code. 
+     * Default `true`. 
+     */
+    defineMutationMethods?: boolean | undefined;
+    
+    // Internal options (from normalizeOptions function)
+    /** @internal */
+    _driver?: any;
+    /** @internal */
+    _preventAutopublish?: boolean;
+    
+    // Allow additional properties for extensibility
+    [key: string]: any;
+  }
+
   var Collection: CollectionStatic;
   interface CollectionStatic {
     /**
@@ -61,27 +105,7 @@ export namespace Mongo {
      */
     new <T extends NpmModuleMongodb.Document, U = T>(
       name: string | null,
-      options?: {
-        /**
-         * The server connection that will manage this collection. Uses the default connection if not specified. Pass the return value of calling `DDP.connect` to specify a different
-         * server. Pass `null` to specify no connection. Unmanaged (`name` is null) collections cannot specify a connection.
-         */
-        connection?: DDP.DDPStatic | null | undefined;
-        /** The method of generating the `_id` fields of new documents in this collection.  Possible values:
-         * - **`'STRING'`**: random strings
-         * - **`'MONGO'`**:  random [`Mongo.ObjectID`](#mongo_object_id) values
-         *
-         * The default id generation technique is `'STRING'`.
-         */
-        idGeneration?: string | undefined;
-        /**
-         * An optional transformation function. Documents will be passed through this function before being returned from `fetch` or `findOne`, and before being passed to callbacks of
-         * `observe`, `map`, `forEach`, `allow`, and `deny`. Transforms are *not* applied for the callbacks of `observeChanges` or to cursors returned from publish functions.
-         */
-        transform?: (doc: T) => U;
-        /** Set to `false` to skip setting up the mutation methods that enable insert/update/remove from client code. Default `true`. */
-        defineMutationMethods?: boolean | undefined;
-      }
+      options?: CollectionOptions<T, U>
     ): Collection<T, U>;
 
     /**
@@ -92,6 +116,68 @@ export namespace Mongo {
     getCollection<
         TCollection extends Collection<any, any> | undefined = Collection<NpmModuleMongodb.Document> | undefined
     >(name: string): TCollection;
+
+    // Collection Extensions API
+    /**
+     * Add a constructor extension function that runs when collections are created.
+     * @param extension Extension function called with (name, options) and 'this' bound to collection instance
+     */
+    addExtension<T = any, U = T>(extension: (this: Collection<T, U>, name: string | null, options?: CollectionOptions<T, U>) => void): void;
+
+    /**
+     * Add a prototype method to all collection instances.
+     * @param name The name of the method to add
+     * @param method The method function, bound to the collection instance
+     */
+    addPrototypeMethod<T = any, U = T>(name: string, method: (this: Collection<T, U>, ...args: any[]) => any): void;
+
+    /**
+     * Add a static method to the Mongo.Collection constructor.
+     * @param name The name of the static method to add
+     * @param method The static method function
+     */
+    addStaticMethod(name: string, method: Function): void;
+
+    /**
+     * Remove a constructor extension (useful for testing).
+     * @param extension The extension function to remove
+     */
+    removeExtension(extension: Function): void;
+
+    /**
+     * Remove a prototype method from all collection instances.
+     * @param name The name of the method to remove
+     */
+    removePrototypeMethod(name: string): void;
+
+    /**
+     * Remove a static method from the Mongo.Collection constructor.
+     * @param name The name of the static method to remove
+     */
+    removeStaticMethod(name: string): void;
+
+    /**
+     * Clear all extensions, prototype methods, and static methods (useful for testing).
+     */
+    clearExtensions(): void;
+
+    /**
+     * Get all registered constructor extensions (useful for debugging).
+     * @returns Array of registered extension functions
+     */
+    getExtensions(): Array<Function>;
+
+    /**
+     * Get all registered prototype methods (useful for debugging).
+     * @returns Map of method names to functions
+     */
+    getPrototypeMethods(): Map<string, Function>;
+
+    /**
+     * Get all registered static methods (useful for debugging).
+     * @returns Map of method names to functions
+     */
+    getStaticMethods(): Map<string, Function>;
   }
   interface Collection<T extends NpmModuleMongodb.Document, U = T> {
     allow<Fn extends Transform<T> = undefined>(options: {
@@ -479,6 +565,87 @@ export namespace Mongo {
     equals(otherID: ObjectID): boolean;
   }
 
+  /**
+   * Collection Extensions API
+   */
+  interface CollectionExtensions {
+    /**
+     * Add a constructor extension function that runs when collections are created.
+     * @param extension Extension function called with (name, options) and 'this' bound to collection instance
+     */
+    addExtension<T = any, U = T>(extension: (this: Collection<T, U>, name: string | null, options?: CollectionOptions<T, U>) => void): void;
+    
+    /**
+     * Add a prototype method to all collection instances.
+     * @param name The name of the method to add
+     * @param method The method function, bound to the collection instance
+     */
+    addPrototypeMethod<T = any, U = T>(name: string, method: (this: Collection<T, U>, ...args: any[]) => any): void;
+
+    /**
+     * Add a static method to the Mongo.Collection constructor.
+     * @param name The name of the static method to add
+     * @param method The static method function
+     */
+    addStaticMethod(name: string, method: Function): void;
+
+    /**
+     * Remove a constructor extension (useful for testing).
+     * @param extension The extension function to remove
+     */
+    removeExtension(extension: Function): void;
+
+    /**
+     * Remove a prototype method from all collection instances.
+     * @param name The name of the method to remove
+     */
+    removePrototypeMethod(name: string): void;
+
+    /**
+     * Remove a static method from the Mongo.Collection constructor.
+     * @param name The name of the static method to remove
+     */
+    removeStaticMethod(name: string): void;
+
+    /**
+     * Clear all extensions, prototype methods, and static methods (useful for testing).
+     */
+    clearExtensions(): void;
+
+    /**
+     * Get all registered constructor extensions (useful for debugging).
+     * @returns Array of registered extension functions
+     */
+    getExtensions(): Array<Function>;
+
+    /**
+     * Get all registered prototype methods (useful for debugging).
+     * @returns Map of method names to functions
+     */
+    getPrototypeMethods(): Map<string, Function>;
+
+    /**
+     * Get all registered static methods (useful for debugging).
+     * @returns Map of method names to functions
+     */
+    getStaticMethods(): Map<string, Function>;
+  }
+
+  var CollectionExtensions: CollectionExtensions;
+
+  /**
+   * Retrieve a Meteor collection instance by name. Only collections defined with `new Mongo.Collection(...)` are available with this method.
+   * @param name Name of your collection as it was defined with `new Mongo.Collection()`.
+   * @returns The collection instance or undefined if not found
+   */
+  function getCollection<T extends Collection<any, any> | undefined = Collection<NpmModuleMongodb.Document> | undefined>(name: string): T;
+
+  /**
+   * A record of all defined Mongo.Collection instances, indexed by collection name.
+   * @internal
+   */
+  var _collections: Map<string, Collection<any, any>>;
+
   function setConnectionOptions(options: any): void;
 }
 
diff --git a/packages/mongo/oplog_tailing.ts b/packages/mongo/oplog_tailing.ts
index 2df4bf7aaa..1a84fd2c16 100644
--- a/packages/mongo/oplog_tailing.ts
+++ b/packages/mongo/oplog_tailing.ts
@@ -41,6 +41,8 @@ export class OplogHandle {
     excludeCollections?: string[];
     includeCollections?: string[];
   };
+  private _includeNSRegex?: RegExp;
+  private _excludeNSRegex?: RegExp;
   private _stopped: boolean;
   private _tailHandle: any;
   private _readyPromiseResolver: (() => void) | null;
@@ -82,6 +84,18 @@ export class OplogHandle {
     }
     this._oplogOptions = { includeCollections, excludeCollections };
 
+    if (includeCollections?.length) {
+      const incAlt = includeCollections.map((c) => Meteor._escapeRegExp(c)).join('|');
+
+      this._includeNSRegex = new RegExp(`^${Meteor._escapeRegExp(this._dbName)}\\.(?:${incAlt})$`);
+    }
+
+    if (excludeCollections?.length) {
+      const excAlt = excludeCollections.map((c) => Meteor._escapeRegExp(c)).join('|');
+
+      this._excludeNSRegex = new RegExp(`^${Meteor._escapeRegExp(this._dbName)}\\.(?:${excAlt})$`);
+    }
+
     this._catchingUpResolvers = [];
     this._lastProcessedTS = null;
 
@@ -92,6 +106,15 @@ export class OplogHandle {
     this._startTrailingPromise = this._startTailing();
   }
 
+    private _nsAllowed(ns: string | undefined): boolean {
+    if (!ns) return false;
+    if (ns === 'admin.$cmd') return true;
+    if (this._includeNSRegex && !this._includeNSRegex.test(ns)) return false;
+    if (this._excludeNSRegex && this._excludeNSRegex.test(ns)) return false;
+
+    return true;
+  }
+
   private _getOplogSelector(lastProcessedTS?: any): any {
     const oplogCriteria: any = [
       {
@@ -104,40 +127,55 @@ export class OplogHandle {
       },
     ];
 
-    const nsRegex = new RegExp(
-      "^(?:" +
-        [
-          // @ts-ignore
-          Meteor._escapeRegExp(this._dbName + "."),
-          // @ts-ignore
-          Meteor._escapeRegExp("admin.$cmd"),
-        ].join("|") +
-        ")"
-    );
-
     if (this._oplogOptions.excludeCollections?.length) {
-      oplogCriteria.push({
-        ns: {
-          $regex: nsRegex,
-          $nin: this._oplogOptions.excludeCollections.map(
-            (collName: string) => `${this._dbName}.${collName}`
-          ),
-        },
-      });
-    } else if (this._oplogOptions.includeCollections?.length) {
+      const nsRegex = new RegExp(
+        '^(?:' +
+          [
+            // @ts-ignore
+            Meteor._escapeRegExp(this._dbName + '.'),
+          ].join('|') +
+          ')'
+      );
+      const excludeNs = {
+        $regex: nsRegex,
+        $nin: this._oplogOptions.excludeCollections.map(
+          (collName: string) => `${this._dbName}.${collName}`
+        ),
+      };
       oplogCriteria.push({
         $or: [
-          { ns: /^admin\.\$cmd/ },
+          { ns: excludeNs },
           {
-            ns: {
-              $in: this._oplogOptions.includeCollections.map(
-                (collName: string) => `${this._dbName}.${collName}`
-              ),
-            },
+            ns: /^admin\.\$cmd/,
+            'o.applyOps': { $elemMatch: { ns: excludeNs } },
           },
         ],
       });
+    } else if (this._oplogOptions.includeCollections?.length) {
+      const includeNs = {
+        $in: this._oplogOptions.includeCollections.map(
+          (collName: string) => `${this._dbName}.${collName}`
+        ),
+      };
+      oplogCriteria.push({
+        $or: [
+          {
+            ns: includeNs,
+          },
+          { ns: /^admin\.\$cmd/, 'o.applyOps.ns': includeNs },
+        ],
+      });
     } else {
+      const nsRegex = new RegExp(
+        "^(?:" +
+          [
+            // @ts-ignore
+            Meteor._escapeRegExp(this._dbName + "."),
+            // @ts-ignore
+            Meteor._escapeRegExp("admin.$cmd"),
+          ].join("|") +
+          ")"
+      );
       oplogCriteria.push({
         ns: nsRegex,
       });
@@ -411,6 +449,11 @@ async function handleDoc(handle: OplogHandle, doc: OplogEntry): Promise<void> {
           op.ts = nextTimestamp;
           nextTimestamp = nextTimestamp.add(Long.ONE);
         }
+        // Only forward sub-ops whose ns is allowed
+        // See https://github.com/meteor/meteor/issues/13945
+        if (!handle['_nsAllowed'](op.ns)) {
+          continue;
+        }
         await handleDoc(handle, op);
       }
       return;
diff --git a/packages/mongo/package.js b/packages/mongo/package.js
index c0ff30242f..749fa259e1 100644
--- a/packages/mongo/package.js
+++ b/packages/mongo/package.js
@@ -79,6 +79,7 @@ Package.onUse(function (api) {
   api.export("MongoInternals", "server");
 
   api.export("Mongo");
+  api.export("CollectionExtensions");
   api.export("ObserveMultiplexer", "server", { testOnly: true });
 
   api.addFiles(
@@ -100,6 +101,7 @@ Package.onUse(function (api) {
   );
   api.addFiles("local_collection_driver.js", ["client", "server"]);
   api.addFiles("remote_collection_driver.ts", "server");
+  api.addFiles("collection/collection_extensions.js", ["client", "server"]);
   api.addFiles("collection/collection.js", ["client", "server"]);
   api.addFiles("connection_options.ts", "server");
   // For zodern:types to pick up our published types.
@@ -130,6 +132,7 @@ Package.onTest(function (api) {
   api.addFiles("tests/collection_tests.js", ["client", "server"]);
   api.addFiles("tests/collection_async_tests.js", ["client", "server"]);
   api.addFiles("tests/observe_changes_tests.js", ["client", "server"]);
+  api.addFiles("tests/collection_extensions_tests.js", ["client", "server"]);
   api.addFiles("tests/oplog_tests.js", "server");
   api.addFiles("tests/oplog_v2_converter_tests.js", "server");
   api.addFiles("tests/doc_fetcher_tests.js", "server");
diff --git a/packages/mongo/tests/collection_extensions_tests.js b/packages/mongo/tests/collection_extensions_tests.js
new file mode 100644
index 0000000000..0a6e9dc3c5
--- /dev/null
+++ b/packages/mongo/tests/collection_extensions_tests.js
@@ -0,0 +1,233 @@
+import { Tinytest } from "meteor/tinytest";
+import { Mongo } from "meteor/mongo";
+import { CollectionExtensions } from "meteor/mongo";
+import { Random } from "meteor/random";
+
+// Test setup and teardown
+function setupTest() {
+  CollectionExtensions.clearExtensions();
+}
+
+function teardownTest() {
+  CollectionExtensions.clearExtensions();
+}
+
+Tinytest.add("CollectionExtensions - constructor extension", function (test) {
+  setupTest();
+  
+  let extensionCallCount = 0;
+  let extensionData = null;
+  
+  CollectionExtensions.addExtension(function(name, options) {
+    extensionCallCount++;
+    extensionData = { name, options, instance: this };
+  });
+  
+  const testCollection = new Mongo.Collection(Random.id());
+  
+  test.equal(extensionCallCount, 1);
+  test.equal(extensionData.name, testCollection._name);
+  test.equal(extensionData.instance, testCollection);
+  test.isTrue(extensionData.options && typeof extensionData.options === 'object');
+  
+  teardownTest();
+});
+
+Tinytest.add("CollectionExtensions - multiple extensions", function (test) {
+  setupTest();
+  
+  let callOrder = [];
+  
+  CollectionExtensions.addExtension(function(name, options) {
+    callOrder.push('extension1');
+  });
+  
+  CollectionExtensions.addExtension(function(name, options) {
+    callOrder.push('extension2');
+  });
+  
+  CollectionExtensions.addExtension(function(name, options) {
+    callOrder.push('extension3');
+  });
+  
+  const testCollection = new Mongo.Collection(Random.id());
+  
+  test.equal(callOrder, ['extension1', 'extension2', 'extension3']);
+  
+  teardownTest();
+});
+
+Tinytest.add("CollectionExtensions - prototype methods", function (test) {
+  setupTest();
+  
+  CollectionExtensions.addPrototypeMethod('testMethod', function() {
+    return 'testResult';
+  });
+  
+  const testCollection = new Mongo.Collection(Random.id());
+  
+  test.isTrue(typeof testCollection.testMethod === 'function');
+  test.equal(testCollection.testMethod(), 'testResult');
+  
+  teardownTest();
+});
+
+// Test prototype method with collection context
+Tinytest.add("CollectionExtensions - prototype method context", function (test) {
+  setupTest();
+  
+  // Add prototype method that uses collection context
+  CollectionExtensions.addPrototypeMethod('getCollectionName', function() {
+    return this._name;
+  });
+  
+  // Create collection
+  const testCollection = new Mongo.Collection(Random.id());
+  
+  // Verify method has correct context
+  test.equal(testCollection.getCollectionName(), testCollection._name);
+  
+  teardownTest();
+});
+
+// Test static methods
+Tinytest.add("CollectionExtensions - static methods", function (test) {
+  setupTest();
+  
+  // Add static method
+  CollectionExtensions.addStaticMethod('testStaticMethod', function() {
+    return 'staticResult';
+  });
+  
+  // Apply static methods (this happens automatically in real usage)
+  CollectionExtensions._applyStaticMethods(Mongo.Collection);
+  
+  // Verify static method was added
+  test.isTrue(typeof Mongo.Collection.testStaticMethod === 'function');
+  test.equal(Mongo.Collection.testStaticMethod(), 'staticResult');
+  
+  // Clean up
+  delete Mongo.Collection.testStaticMethod;
+  teardownTest();
+});
+
+// Test error handling in extensions
+Tinytest.add("CollectionExtensions - extension error handling", function (test) {
+  setupTest();
+  
+  // Add extension that throws error
+  CollectionExtensions.addExtension(function(name, options) {
+    throw new Error('Test extension error');
+  });
+  
+  // Creating collection should throw with helpful error message
+  test.throws(() => {
+    new Mongo.Collection(Random.id());
+  }, /Extension failed for collection/);
+  
+  teardownTest();
+});
+
+// Test extension removal
+Tinytest.add("CollectionExtensions - extension removal", function (test) {
+  setupTest();
+  
+  let callCount = 0;
+  
+  const extension = function(name, options) {
+    callCount++;
+  };
+  
+  CollectionExtensions.addExtension(extension);
+  
+  const testCollection1 = new Mongo.Collection(Random.id());
+  test.equal(callCount, 1);
+  
+  CollectionExtensions.removeExtension(extension);
+  
+  // Create another collection - should not call extension
+  const testCollection2 = new Mongo.Collection(Random.id());
+  test.equal(callCount, 1); // Still 1, not 2
+  
+  teardownTest();
+});
+
+Tinytest.add("CollectionExtensions - prototype method removal", function (test) {
+  setupTest();
+  
+  CollectionExtensions.addPrototypeMethod('testMethod', function() {
+    return 'test';
+  });
+  
+  const testCollection1 = new Mongo.Collection(Random.id());
+  test.isTrue(typeof testCollection1.testMethod === 'function');
+  
+  CollectionExtensions.removePrototypeMethod('testMethod');
+  
+  const testCollection2 = new Mongo.Collection(Random.id());
+  test.isUndefined(testCollection2.testMethod);
+  
+  teardownTest();
+});
+
+Tinytest.add("CollectionExtensions - input validation", function (test) {
+  setupTest();
+  
+  test.throws(() => {
+    CollectionExtensions.addExtension("not a function");
+  }, /Extension must be a function/);
+  
+  test.throws(() => {
+    CollectionExtensions.addPrototypeMethod("", function() {});
+  }, /Prototype method name must be a non-empty string/);
+  
+  test.throws(() => {
+    CollectionExtensions.addPrototypeMethod(123, function() {});
+  }, /Prototype method name must be a non-empty string/);
+  
+  test.throws(() => {
+    CollectionExtensions.addPrototypeMethod("test", "not a function");
+  }, /Prototype method must be a function/);
+  
+  test.throws(() => {
+    CollectionExtensions.addStaticMethod("", function() {});
+  }, /Static method name must be a non-empty string/);
+  
+  test.throws(() => {
+    CollectionExtensions.addStaticMethod("test", "not a function");
+  }, /Static method must be a function/);
+  
+  teardownTest();
+});
+
+Tinytest.add("CollectionExtensions - introspection", function (test) {
+  setupTest();
+  
+  const extension1 = function() {};
+  const extension2 = function() {};
+  
+  test.equal(CollectionExtensions.getExtensions(), []);
+  test.equal(CollectionExtensions.getPrototypeMethods().size, 0);
+  test.equal(CollectionExtensions.getStaticMethods().size, 0);
+  
+  CollectionExtensions.addExtension(extension1);
+  CollectionExtensions.addExtension(extension2);
+  CollectionExtensions.addPrototypeMethod('test1', function() {});
+  CollectionExtensions.addStaticMethod('test2', function() {});
+  
+  // Test introspection
+  const extensions = CollectionExtensions.getExtensions();
+  test.equal(extensions.length, 2);
+  test.equal(extensions[0], extension1);
+  test.equal(extensions[1], extension2);
+  
+  const prototypeMethods = CollectionExtensions.getPrototypeMethods();
+  test.equal(prototypeMethods.size, 1);
+  test.isTrue(prototypeMethods.has('test1'));
+  
+  const staticMethods = CollectionExtensions.getStaticMethods();
+  test.equal(staticMethods.size, 1);
+  test.isTrue(staticMethods.has('test2'));
+  
+  teardownTest();
+});
\ No newline at end of file
diff --git a/packages/mongo/tests/mongo_livedata_tests.js b/packages/mongo/tests/mongo_livedata_tests.js
index af69aee7b4..f3e32106a5 100644
--- a/packages/mongo/tests/mongo_livedata_tests.js
+++ b/packages/mongo/tests/mongo_livedata_tests.js
@@ -2776,6 +2776,53 @@ const setsEqual = function (a, b) {
     });
   });
 
+  // Test operation result fields with allow/deny rules (similar to issue #12159)
+  if (Meteor.isServer) {
+    testAsyncMulti('mongo-livedata - operation result fields with allow/deny, ' + idGeneration, [
+      async function(test, expect) {
+        var collectionName = 'test_operation_results_' + Random.id();
+        var coll = new Mongo.Collection(collectionName, { idGeneration: idGeneration });
+        
+        // Set up allow rules for all operations
+        coll.allow({
+          insert: function() { return true; },
+          update: function() { return true; },
+          remove: function() { return true; }
+        });
+        
+        // Test insert
+        var insertedId = await coll.insertAsync({name: 'doc1'});
+        test.isTrue(insertedId !== undefined, 'insert should return an ID');
+        
+        // Test update
+        var updateResult = await coll.updateAsync({name: 'doc1'}, {$set: {value: 1}});
+        test.equal(updateResult, 1, 'update should return affected count');
+        
+        // Test upsert (update case)
+        var upsertUpdateResult = await coll.upsertAsync({name: 'doc1'}, {$set: {value: 2}});
+        test.equal(upsertUpdateResult.numberAffected, 1);
+        test.isFalse(upsertUpdateResult.hasOwnProperty('insertedId'));
+        
+        // Test upsert (insert case)
+        var upsertInsertResult = await coll.upsertAsync({name: 'doc2'}, {$set: {value: 3}});
+        test.equal(upsertInsertResult.numberAffected, 1);
+        test.isTrue(upsertInsertResult.hasOwnProperty('insertedId'));
+        
+        // Test remove
+        var removeResult = await coll.removeAsync({name: 'doc1'});
+        test.equal(removeResult, 1, 'remove should return removed count');
+        
+        // Test insert with explicit ID
+        var explicitId = idGeneration === 'MONGO' ? new Mongo.ObjectID() : 'explicit-test-id';
+        var insertExplicitResult = await coll.insertAsync({_id: explicitId, name: 'explicit-doc'});
+        test.equal(insertExplicitResult, explicitId, 'insert with explicit ID should return that ID');
+        
+        // Clean up
+        await coll.dropCollectionAsync();
+      }
+    ]);
+  }
+
 });  // end idGeneration parametrization
 
 Tinytest.add('mongo-livedata - rewrite selector', function(test) {
diff --git a/packages/mongo/tests/oplog_tests.js b/packages/mongo/tests/oplog_tests.js
index 2ffb0c32eb..0ef4bf8089 100644
--- a/packages/mongo/tests/oplog_tests.js
+++ b/packages/mongo/tests/oplog_tests.js
@@ -181,11 +181,46 @@ process.env.MONGO_OPLOG_URL &&
 const defaultOplogHandle = MongoInternals.defaultRemoteCollectionDriver().mongo._oplogHandle;
 let previousMongoPackageSettings = {};
 
+async function oplogSimpleInsertion(IncludeCollection, ExcludeCollection) {
+  await IncludeCollection.rawCollection().insertOne({ include: 'yes', foo: 'bar' });
+  await ExcludeCollection.rawCollection().insertOne({ include: 'no', foo: 'bar' });
+}
+
+async function oplogInsertionTransaction(IncludeCollection, ExcludeCollection) {
+  const client = MongoInternals.defaultRemoteCollectionDriver().mongo.client;
+  const session = client.startSession();
+
+  try {
+    await session.withTransaction(async () => {
+      await IncludeCollection.rawCollection().insertOne({ include: 'yes', foo: 'bar' }, { session });
+      await ExcludeCollection.rawCollection().insertOne({ include: 'no', foo: 'bar' }, { session });
+    });
+  } finally {
+    await session.endSession();
+  }
+}
+
+async function oplogMassiveInsertion(IncludeCollection, ExcludeCollection) {
+  const totalDocuments = 10000;
+  const documentInclude = Array.from(
+    { length: totalDocuments },
+    (_, index) => ({ include: "yes", foo: "bar" + index })
+  );
+  const documentExclude = Array.from(
+    { length: totalDocuments },
+    (_, index) => ({ include: "no", foo: "bar" + index })
+  );
+
+  await IncludeCollection.rawCollection().insertMany(documentInclude);
+  await ExcludeCollection.rawCollection().insertMany(documentExclude);
+}
+
 async function oplogOptionsTest({
   test,
   includeCollectionName,
   excludeCollectionName,
-  mongoPackageSettings = {}
+  mongoPackageSettings = {},
+  functionToRun
 }) {
   try {
     previousMongoPackageSettings = { ...(Meteor.settings?.packages?.mongo || {}) };
@@ -199,9 +234,11 @@ async function oplogOptionsTest({
     const IncludeCollection = new Mongo.Collection(includeCollectionName);
     const ExcludeCollection = new Mongo.Collection(excludeCollectionName);
 
-    const shouldBeTracked = new Promise((resolve) => {
-      IncludeCollection.find({ include: 'yes' }).observeChanges({
-        added(id, fields) { resolve(true) }
+    const shouldBeTracked = new Promise((resolve, reject) => {
+      IncludeCollection.find({ include: "yes" }).observeChanges({
+        added(id, fields) {
+          resolve(true);
+        },
       });
     });
     const shouldBeIgnored = new Promise((resolve, reject) => {
@@ -218,8 +255,7 @@ async function oplogOptionsTest({
     });
 
     // do the inserts:
-    await IncludeCollection.rawCollection().insertOne({ include: 'yes', foo: 'bar' });
-    await ExcludeCollection.rawCollection().insertOne({ include: 'no', foo: 'bar' });
+    await functionToRun(IncludeCollection, ExcludeCollection);
 
     test.equal(await shouldBeTracked, true);
     test.equal(await shouldBeIgnored, true);
@@ -229,6 +265,73 @@ async function oplogOptionsTest({
     MongoInternals.defaultRemoteCollectionDriver().mongo._setOplogHandle(defaultOplogHandle);
   }
 }
+async function oplogTailingOptionsTest({
+  test,
+  includeCollectionName,
+  excludeCollectionName,
+  mongoPackageSettings = {},
+  functionToRun
+}) {
+  let stopRaw;
+  try {
+    previousMongoPackageSettings = { ...(Meteor.settings?.packages?.mongo || {}) };
+    if (!Meteor.settings.packages) Meteor.settings.packages = {};
+    Meteor.settings.packages.mongo = mongoPackageSettings;
+
+    const myOplogHandle = new MongoInternals.OplogHandle(process.env.MONGO_OPLOG_URL, 'meteor');
+    await myOplogHandle._startTrailingPromise;
+
+    const IncludeCollection = new Mongo.Collection(includeCollectionName);
+    const ExcludeCollection = new Mongo.Collection(excludeCollectionName);
+
+    // Listen for INCLUDE collection oplog entries
+    const includeSeen = new Promise(async (resolve, reject) => {
+      const includeStop = await myOplogHandle.onOplogEntry(
+        { dropCollection: false, dropDatabase: false, collection: includeCollectionName },
+        ({ op, collection, id }) => {
+          try {
+            // Only accept actual inserts for the include collection
+            if (op?.op === 'i' && collection === includeCollectionName && op?.o?.include === 'yes') {
+              includeStop.stop();
+              resolve(true);
+            }
+          } catch (e) {
+            includeStop.stop();
+            reject(e);
+          }
+        }
+      );
+    });
+
+    // Ensure EXCLUDE collection does NOT get processed
+    const excludeNotSeen = new Promise(async (resolve, reject) => {
+      const excludeStop = await myOplogHandle.onOplogEntry(
+        { dropCollection: false, dropDatabase: false, collection: excludeCollectionName },
+        ({ op, collection, id }) => {
+          // If anything for excluded collection arrives, fail
+          excludeStop.stop();
+          reject("Recieved a document in a excluded collection");
+        }
+      );
+      // Resolve after 2s if nothing arrived
+      setTimeout(() => {
+        excludeStop.stop();
+        resolve(true);
+      }, 2000);
+    });
+
+    // Do the inserts (e.g., oplogInsertionTransaction or your chosen function)
+    await functionToRun(IncludeCollection, ExcludeCollection);
+
+    // Await raw-oplog assertions
+    test.equal(await includeSeen, true);
+    test.equal(await excludeNotSeen, true);
+  } finally {
+    if (stopRaw?.stop) await stopRaw.stop();
+    // Reset:
+    Meteor.settings.packages.mongo = { ...previousMongoPackageSettings };
+  }
+}
 
 process.env.MONGO_OPLOG_URL && Tinytest.addAsync(
   'mongo-livedata - oplog - oplogSettings - oplogExcludeCollections',
@@ -242,7 +345,8 @@ process.env.MONGO_OPLOG_URL && Tinytest.addAsync(
       test,
       includeCollectionName: collectionNameA,
       excludeCollectionName: collectionNameB,
-      mongoPackageSettings
+      mongoPackageSettings,
+      functionToRun: oplogSimpleInsertion
     });
   }
 );
@@ -259,7 +363,8 @@ process.env.MONGO_OPLOG_URL && Tinytest.addAsync(
       test,
       includeCollectionName: collectionNameB,
       excludeCollectionName: collectionNameA,
-      mongoPackageSettings
+      mongoPackageSettings,
+      functionToRun: oplogSimpleInsertion
     });
   }
 );
@@ -279,7 +384,8 @@ process.env.MONGO_OPLOG_URL && Tinytest.addAsync(
         test,
         includeCollectionName: collectionNameA,
         excludeCollectionName: collectionNameB,
-        mongoPackageSettings
+        mongoPackageSettings,
+        functionToRun: oplogSimpleInsertion
       });
       test.fail();
     } catch (err) {
@@ -350,6 +456,78 @@ process.env.MONGO_OPLOG_URL &&
     }
   );
 
+process.env.MONGO_OPLOG_URL && Tinytest.addAsync(
+  'mongo-livedata - oplog - oplogSettings - massiveInsertion - oplogIncludeCollections',
+  async test => {
+    const collectionNameA = "oplog-a-massive-" + Random.id();
+    const collectionNameB = "oplog-b-massive-" + Random.id();
+    const mongoPackageSettings = {
+      oplogIncludeCollections: [collectionNameA]
+    };
+    await oplogTailingOptionsTest({
+      test,
+      includeCollectionName: collectionNameA,
+      excludeCollectionName: collectionNameB,
+      mongoPackageSettings,
+      functionToRun: oplogMassiveInsertion
+    });
+  }
+);
+
+process.env.MONGO_OPLOG_URL && Tinytest.addAsync(
+  'mongo-livedata - oplog - oplogSettings - massiveInsertion - oplogExcludeCollections',
+  async test => {
+    const collectionNameA = "oplog-a-massive-" + Random.id();
+    const collectionNameB = "oplog-b-massive-" + Random.id();
+    const mongoPackageSettings = {
+      oplogExcludeCollections: [collectionNameA]
+    };
+    await oplogTailingOptionsTest({
+      test,
+      includeCollectionName: collectionNameB,
+      excludeCollectionName: collectionNameA,
+      mongoPackageSettings,
+      functionToRun: oplogMassiveInsertion
+    });
+  }
+);
+
+process.env.MONGO_OPLOG_URL && Tinytest.addAsync(
+  'mongo-livedata - oplog - oplogSettings - transaction - oplogExcludeCollections',
+  async test => {
+    const collectionNameA = "oplog-a-transaction-" + Random.id();
+    const collectionNameB = "oplog-b-transaction-" + Random.id();
+    const mongoPackageSettings = {
+      oplogExcludeCollections: [collectionNameA]
+    };
+    await oplogTailingOptionsTest({
+      test,
+      includeCollectionName: collectionNameB,
+      excludeCollectionName: collectionNameA,
+      mongoPackageSettings,
+      functionToRun: oplogInsertionTransaction
+    });
+  }
+);
+
+process.env.MONGO_OPLOG_URL && Tinytest.addAsync(
+  'mongo-livedata - oplog - oplogSettings - transaction - oplogIncludeCollections',
+  async test => {
+    const collectionNameA = "oplog-a-transaction-" + Random.id();
+    const collectionNameB = "oplog-b-transaction-" + Random.id();
+    const mongoPackageSettings = {
+      oplogIncludeCollections: [collectionNameA]
+    };
+    await oplogTailingOptionsTest({
+      test,
+      includeCollectionName: collectionNameA,
+      excludeCollectionName: collectionNameB,
+      mongoPackageSettings,
+      functionToRun: oplogInsertionTransaction
+    });
+  }
+);
+  
 // TODO this is commented for now, but we need to find out the cause
 // PR: https://github.com/meteor/meteor/pull/12057
 // Meteor.isServer && Tinytest.addAsync(
diff --git a/packages/rspack/lib/build-context.js b/packages/rspack/lib/build-context.js
index 03b13c444b..76365b0f34 100644
--- a/packages/rspack/lib/build-context.js
+++ b/packages/rspack/lib/build-context.js
@@ -7,6 +7,8 @@ import { RSPACK_DOCTOR_CONTEXT } from "./constants";
 const fs = require('fs');
 const path = require('path');
 
+const { getCustomConfigFilePath } = require('./processes');
+
 const { logError } = require('meteor/tools-core/lib/log');
 
 const { capitalizeFirstLetter } = require('meteor/tools-core/lib/string');
@@ -577,13 +579,22 @@ export function cleanBuildContextFiles() {
 /**
  * Ensures the rspack.config.js file exists at the project level
  * Creates the file if it doesn't exist with the required template
- * @returns {string} Path to the rspack.config.js file
+ * Will not create a new file if rspack.config.mjs or rspack.config.cjs exists
+ * @returns {string} Path to the rspack.config file (.js, .mjs, or .cjs)
  */
 export function ensureRspackConfigExists() {
   const appDir = getMeteorAppDir();
-  const configPath = path.join(appDir, 'rspack.config.js');
 
-  const configTemplate = `import { defineConfig } from '@meteorjs/rspack';
+  // Check if any config file already exists using the helper function
+  const existingConfigPath = getCustomConfigFilePath(appDir);
+  if (existingConfigPath) {
+    return existingConfigPath;
+  }
+
+  // If no config file exists, we'll create a .js one
+  const jsConfigPath = path.join(appDir, 'rspack.config.js');
+
+  const configTemplate = `const { defineConfig } = require('@meteorjs/rspack');
 
 /**
  * Rspack configuration for Meteor projects.
@@ -595,19 +606,19 @@ export function ensureRspackConfigExists() {
  *
  * Use these flags to adjust your build settings based on environment.
  */
-export default defineConfig(Meteor => {
+module.exports = defineConfig(Meteor => {
   return {};
 });
 `;
 
-  if (!fs.existsSync(configPath)) {
+  if (!fs.existsSync(jsConfigPath)) {
     try {
-      fs.writeFileSync(configPath, configTemplate, 'utf8');
+      fs.writeFileSync(jsConfigPath, configTemplate, 'utf8');
     } catch (error) {
       logError(`Failed to create rspack.config.js file: ${error.message}`);
       throw error;
     }
   }
 
-  return configPath;
+  return jsConfigPath;
 }
diff --git a/packages/rspack/lib/config.js b/packages/rspack/lib/config.js
index 24fc73a6d9..6d65da243c 100644
--- a/packages/rspack/lib/config.js
+++ b/packages/rspack/lib/config.js
@@ -4,6 +4,7 @@
  */
 import { glob } from 'glob';
 import path from 'path';
+import fs from 'fs';
 
 const { logInfo } = require('meteor/tools-core/lib/log');
 const {
@@ -21,13 +22,63 @@ const {
   isMeteorLessProject,
   isMeteorScssProject,
   getMeteorEnvPackageDirs,
+  getMeteorAppConfig,
+  getMeteorAppDir,
 } = require('meteor/tools-core/lib/meteor');
+const { buildUnignorePatterns } = require('meteor/tools-core/lib/ignore');
 
 import { getInitialEntrypoints } from './build-context';
 
 const { ensureModuleFilesExist, getBuildFilePath } = require('./build-context');
 const { RSPACK_BUILD_CONTEXT, FILE_ROLE } = require('./constants');
 
+/**
+ * Checks if entries exist in .meteorignore file
+ * @param {string[]} entries - Entries to check
+ * @returns {Object} Results with entry keys and boolean values
+ */
+function checkMeteorIgnoreExactEntries(entries) {
+  const meteorIgnorePath = path.join(getMeteorAppDir(), '.meteorignore');
+  const results = {};
+
+  // Initialize results object with false for each entry
+  entries.forEach(entry => {
+    results[entry] = false;
+  });
+
+  // Check if .meteorignore file exists
+  if (!fs.existsSync(meteorIgnorePath)) {
+    return results;
+  }
+
+  // Read the .meteorignore file
+  try {
+    const content = fs.readFileSync(meteorIgnorePath, 'utf8');
+    const lines = content.split('\n');
+
+    // Check each line against all entries
+    lines.forEach(line => {
+      // Skip empty lines and comments
+      if (!line.trim() || line.trim().startsWith('#')) {
+        return;
+      }
+
+      const trimmedLine = line.trim();
+
+      // Check for exact matches
+      entries.forEach(entry => {
+        if (trimmedLine === entry) {
+          results[entry] = true;
+        }
+      });
+    });
+  } catch (error) {
+    // If there's an error reading the file, return the initialized results
+  }
+
+  return results;
+}
+
 /**
  * Gets the list of file extensions to ignore based on project type
  * For Blaze projects, it excludes .html as used by Blaze
@@ -92,6 +143,7 @@ function getFileExtensionsToIgnore() {
  * @returns {void}
  */
 export function configureMeteorForRspack() {
+  const meteorAppConfig = getMeteorAppConfig();
   const initialEntrypoints = getInitialEntrypoints();
 
   // Ignore node_modules to prevent Meteor from processing them
@@ -138,13 +190,59 @@ export function configureMeteorForRspack() {
     extraFoldersToIgnore = [];
   }
 
-  // Skip immediate html and css children from intial entrypoint contexts
+  // Skip CSS/HTML files in entrypoint contexts
   extraFilesToIgnore = [
     ...extraFilesToIgnore,
-    ...initialEntrypointContexts.flatMap(entrypoint => [
-      `!${entrypoint}/*.html`,
-      `!${entrypoint}/*.css`,
-    ]),
+    ...initialEntrypointContexts.flatMap(entrypoint => {
+      const cssPattern = `${entrypoint}/*.css`;
+      const htmlPattern = `${entrypoint}/*.html`;
+
+      const cssFiles = glob.sync(cssPattern);
+      const htmlFiles = glob.sync(htmlPattern);
+
+      const entriesToCheck = [
+        cssPattern,
+        htmlPattern,
+        ...cssFiles,
+        ...htmlFiles
+      ];
+
+      const entryResults = checkMeteorIgnoreExactEntries(entriesToCheck);
+      const hasMatchingCssPattern = entryResults[cssPattern];
+      const hasMatchingHtmlPattern = entryResults[htmlPattern];
+      const hasAnyCssFileInMeteorIgnore = cssFiles.some(file => entryResults[file]);
+      const hasAnyHtmlFileInMeteorIgnore = htmlFiles.some(file => entryResults[file]);
+
+      const result = [];
+
+      // Handle HTML files
+      if (hasAnyHtmlFileInMeteorIgnore) {
+        // Add individual HTML files that are not in meteorignore
+        htmlFiles.forEach(file => {
+          if (!entryResults[file]) {
+            result.push(`!${file}`);
+          }
+        });
+      } else if (!hasMatchingHtmlPattern) {
+        // Skip HTML pattern if not in meteorignore
+        result.push(`!${htmlPattern}`);
+      }
+
+      // Handle CSS files
+      if (hasAnyCssFileInMeteorIgnore) {
+        // Add individual CSS files that are not in meteorignore
+        cssFiles.forEach(file => {
+          if (!entryResults[file]) {
+            result.push(`!${file}`);
+          }
+        });
+      } else if (!hasMatchingCssPattern) {
+        // Skip CSS pattern if not in meteorignore
+        result.push(`!${cssPattern}`);
+      }
+
+      return result;
+    }),
   ];
 
   const testIgnorePath = `${RSPACK_BUILD_CONTEXT}/${path.dirname(
@@ -176,13 +274,24 @@ export function configureMeteorForRspack() {
   ].filter(Boolean);
   const rootFilesToIgnore = [
     ...projectRootFilesAndFolders.files.filter(
-      file => !['package.json', '.meteorignore', 'tsconfig.json'].includes(file),
+      file =>
+        ![
+          'package.json',
+          '.meteorignore',
+          'tsconfig.json',
+          'postcss.config.js',
+          'scss-config.json',
+        ].includes(file),
     ),
   ];
   const filesToIgnore = [...rootFilesToIgnore, ...extraFilesToIgnore];
+  const unignoredFilesAndFolders = buildUnignorePatterns(
+    meteorAppConfig?.modules || [],
+    { skipLevel: 1 },
+  );
   const meteorAppIgnores = `${foldersToIgnore.join(' ')} ${filesToIgnore.join(
     ' ',
-  )}`;
+  )} ${unignoredFilesAndFolders.join(' ')}`.trim();
   setMeteorAppIgnore(meteorAppIgnores);
 
   if (isMeteorAppDebug() || isMeteorAppConfigModernVerbose()) {
diff --git a/packages/rspack/lib/constants.js b/packages/rspack/lib/constants.js
index be6612be89..dbc252014b 100644
--- a/packages/rspack/lib/constants.js
+++ b/packages/rspack/lib/constants.js
@@ -3,9 +3,9 @@
  * @description Constants and global state keys for Rspack plugin
  */
 
-export const DEFAULT_RSPACK_VERSION = '1.5.0';
+export const DEFAULT_RSPACK_VERSION = '1.5.3';
 
-export const DEFAULT_METEOR_RSPACK_VERSION = '0.0.36';
+export const DEFAULT_METEOR_RSPACK_VERSION = '0.0.60';
 
 export const DEFAULT_METEOR_RSPACK_REACT_HMR_VERSION = '1.4.3';
 
@@ -36,38 +36,50 @@ export const GLOBAL_STATE_KEYS = {
   RSPACK_REACT_INSTALLATION_CHECKED: 'rspack.rspackReactInstallationChecked',
   RSPACK_DOCTOR_INSTALLATION_CHECKED: 'rspack.rspackDoctorInstallationChecked',
   REACT_CHECKED: 'rspack.reactChecked',
+  TYPESCRIPT_CHECKED: 'rspack.typescriptChecked',
   INITIAL_ENTRYPONTS: 'meteor.initialEntrypoints',
   CLIENT_FIRST_COMPILE: 'rspack.clientFirstCompile',
   SERVER_FIRST_COMPILE: 'rspack.serverFirstCompile',
   BUILD_CONTEXT_FILES_CLEANED: 'rspack.buildContextFilesCleaned',
 };
 
-/**
- * Default port for Rspack dev server
- * @type {string|any|number}
- */
-export const RSPACK_DEVSERVER_PORT = process.env.RSPACK_DEVSERVER_PORT || 8080;
+const meteorConfig = typeof Plugin !== 'undefined' ? Plugin?.getMeteorConfig() : null;
 
 /**
  * Directory name for Rspack build context
  * Can be overridden with RSPACK_BUILD_CONTEXT environment variable
  * @constant {string}
  */
-export const RSPACK_BUILD_CONTEXT = process.env.RSPACK_BUILD_CONTEXT || '_build';
+export const RSPACK_BUILD_CONTEXT =
+  meteorConfig?.buildContext ||
+  process.env.RSPACK_BUILD_CONTEXT ||
+  '_build';
+
+process.env.RSPACK_BUILD_CONTEXT = RSPACK_BUILD_CONTEXT;
 
 /**
  * Directory name for Rspack assets context
  * Can be overridden with RSPACK_ASSETS_CONTEXT environment variable
  * @constant {string}
  */
-export const RSPACK_ASSETS_CONTEXT = process.env.RSPACK_ASSETS_CONTEXT || 'build-assets';
+export const RSPACK_ASSETS_CONTEXT =
+  meteorConfig?.assetsContext ||
+  process.env.RSPACK_ASSETS_CONTEXT ||
+  'build-assets';
+
+process.env.RSPACK_ASSETS_CONTEXT = RSPACK_ASSETS_CONTEXT;
 
 /**
  * Directory name for Rspack bundles context
  * Can be overridden with RSPACK_ASSETS_CONTEXT environment variable
  * @constant {string}
  */
-export const RSPACK_CHUNKS_CONTEXT = process.env.RSPACK_CHUNKS_CONTEXT || 'build-chunks';
+export const RSPACK_CHUNKS_CONTEXT =
+  meteorConfig?.chunksContext ||
+  process.env.RSPACK_CHUNKS_CONTEXT ||
+  'build-chunks';
+
+process.env.RSPACK_CHUNKS_CONTEXT = RSPACK_CHUNKS_CONTEXT;
 
 /**
  * Directory name for Rspack doctor context
@@ -81,18 +93,6 @@ export const RSPACK_DOCTOR_CONTEXT = '.rsdoctor';
  */
 export const RSPACK_HOT_UPDATE_REGEX = /^\/(.+\.hot-update\.(?:json|js))$/;
 
-/**
- * Regex pattern for rspack bundles
- * @constant {RegExp}
- */
-export const RSPACK_BUNDLES_REGEX = new RegExp(`^\/${RSPACK_CHUNKS_CONTEXT}\/(.+)$`);
-
-/**
- * Regex pattern for rspack assets
- * @constant {RegExp}
- */
-export const RSPACK_ASSETS_REGEX = new RegExp(`^\/${RSPACK_ASSETS_CONTEXT}\/(.+)$`);
-
 export const FILE_ROLE = {
   build: 'build',
   entry: 'entry',
diff --git a/packages/rspack/lib/dependencies.js b/packages/rspack/lib/dependencies.js
index f458457a5c..814f002bf3 100644
--- a/packages/rspack/lib/dependencies.js
+++ b/packages/rspack/lib/dependencies.js
@@ -81,13 +81,25 @@ async function ensureDependenciesInstalled(dependencies, globalStateKey, package
       logInfo(`  • ${dep}`);
     });
 
+    // Check if this is a Yarn project
+    const isYarnProj = process.env.YARN_ENABLED === 'true';
+
     // Install dev dependencies
     const devDepsToInstall = allDepsToInstall.filter(dep => dep.dev === true || dep.dev == null);
     if (devDepsToInstall.length > 0) {
       const devDepsStrings = devDepsToInstall.map(dep => `${dep.name}@${dep.version}`);
+
+      // Log progress for dev dependencies
+      logProgress(
+        `🔧 Installing ${devDepsToInstall.length} dev dependenc${
+          devDepsToInstall.length === 1 ? "y" : "ies"
+        }...`
+      );
+
       success = await installNpmDependency(devDepsStrings, {
         cwd: appDir,
         dev: true,
+        yarn: isYarnProj,
       });
     }
 
@@ -95,22 +107,37 @@ async function ensureDependenciesInstalled(dependencies, globalStateKey, package
     const depsToInstall = allDepsToInstall.filter(dep => dep.dev === false);
     if (depsToInstall.length > 0) {
       const depsStrings = depsToInstall.map(dep => `${dep.name}@${dep.version}`);
-      const depsSuccess = await installNpmDependency(depsStrings, {
+
+      // Log progress for regular dependencies
+      logProgress(
+        `🔧 Installing ${depsToInstall.length} dependenc${
+          devDepsToInstall.length === 1 ? "y" : "ies"
+        }...`
+      );
+
+      let depsSuccess;
+      depsSuccess = await installNpmDependency(depsStrings, {
         cwd: appDir,
         dev: false,
+        yarn: isYarnProj,
       });
 
       success = success && depsSuccess;
     }
 
     if (!success) {
+      const isYarnProj = process.env.YARN_ENABLED === 'true';
+      const installCommand = isYarnProj 
+        ? `yarn add --dev ${dependencyStrings.join(' ').trim()}`
+        : `meteor npm install -D ${dependencyStrings.join(' ').trim()}`;
+
       logError(`\n┌─────────────────────────────────────────────────`);
       logError(`│ ❌ ${packageName} Installation Failed`);
       logError(`└─────────────────────────────────────────────────`);
-      logError(`Run: meteor npm install -D ${joinWithAnd(dependencyStrings)}`);
+      logError(`Run: ${installCommand}`);
 
       throw new Error(
-        `Failed to install ${packageName} dependencies. Please install them manually with: meteor npm install -D ${joinWithAnd(dependencyStrings)}`
+        `Failed to install ${packageName} dependencies. Please install them manually with: ${installCommand}`
       );
     }
 
@@ -199,3 +226,31 @@ export async function ensureRspackDoctorInstalled() {
     'Rspack Doctor'
   );
 }
+
+/**
+ * Checks if TypeScript is installed and sets global state accordingly
+ * Sets global state and environment variables based on TypeScript detection
+ * @returns {boolean} Whether TypeScript is installed
+ */
+export function checkTypescriptInstalled() {
+  // Skip if already checked
+  if (getGlobalState(GLOBAL_STATE_KEYS.TYPESCRIPT_CHECKED, false)) {
+    return;
+  }
+
+  const appDir = getMeteorAppDir();
+  // Check if TypeScript is a dependency in the project
+  const isTypescriptInstalled = checkNpmDependencyExists('typescript', { cwd: appDir });
+
+  if (isTypescriptInstalled) {
+    // Set environment variable to indicate TypeScript is enabled
+    process.env.METEOR_TYPESCRIPT_ENABLED = 'true';
+  } else {
+    process.env.METEOR_TYPESCRIPT_ENABLED = 'false';
+  }
+
+  // Mark as checked
+  setGlobalState(GLOBAL_STATE_KEYS.TYPESCRIPT_CHECKED, true);
+
+  return isTypescriptInstalled;
+}
diff --git a/packages/rspack/lib/processes.js b/packages/rspack/lib/processes.js
index 8e3d3c3e25..ed35e57fb4 100644
--- a/packages/rspack/lib/processes.js
+++ b/packages/rspack/lib/processes.js
@@ -2,8 +2,9 @@
  * @module processes
  * @description Functions for managing Rspack processes
  */
-import { checkNpmDependencyExists, getNpxCommand } from 'meteor/tools-core/lib/npm';
-import { RSPACK_DEVSERVER_PORT } from "./constants";
+
+import fs from 'fs';
+import path from 'path';
 
 const {
   spawnProcess,
@@ -31,8 +32,15 @@ const {
   getMeteorInitialAppEntrypoints,
   isMeteorAppConfigModernVerbose,
   isMeteorBundleVisualizerProject,
+  getMeteorAppPort,
 } = require('meteor/tools-core/lib/meteor');
 
+const {
+  checkNpmDependencyExists,
+  getNpxCommand,
+  getMonorepoPath,
+} = require('meteor/tools-core/lib/npm');
+
 const {
   getGlobalState,
   setGlobalState
@@ -51,19 +59,114 @@ const {
 } = require('./build-context');
 
 /**
- * Gets the appropriate config file name based on environment
- * @returns {string} The name of the Rspack config file
+ * Calculates the devServerPort based on process.env.PORT
+ * Base port is 8077, and we add the sum of the digits of process.env.PORT
+ * @returns {number} The calculated devServerPort
  */
-export function getConfigFileName() {
-  return `${process.cwd()}/node_modules/@meteorjs/rspack/rspack.config.js`;
+export function calculateDevServerPort() {
+  const port = getMeteorAppPort();
+  const basePort = 8077;
+
+  // Sum the digits of the port
+  const digitSum = port.split('').reduce((sum, digit) => sum + parseInt(digit, 10), 0);
+
+  return basePort + digitSum;
 }
 
 /**
- * Gets the appropriate Rspack environment variables
+ * Calculates the Rsdoctor client port based on process.env.PORT
+ * Base port is 8885, and we add the sum of the digits of process.env.PORT
+ * @returns {number} The calculated Rsdoctor client port
+ */
+export function calculateRsdoctorClientPort() {
+  const port = getMeteorAppPort();
+  const basePort = 8885;
+
+  // Sum the digits of the port
+  const digitSum = port.split('').reduce((sum, digit) => sum + parseInt(digit, 10), 0);
+
+  return basePort + digitSum;
+}
+
+/**
+ * Calculates the Rsdoctor server port based on process.env.PORT
+ * Base port is 8885, and we add the sum of the digits of process.env.PORT + 1
+ * @returns {number} The calculated Rsdoctor server port
+ */
+export function calculateRsdoctorServerPort() {
+  const port = getMeteorAppPort();
+  const basePort = 8885;
+
+  // Sum the digits of the port
+  const digitSum = port.split('').reduce((sum, digit) => sum + parseInt(digit, 10), 0);
+
+  // Add 1 to differentiate from client port
+  return basePort + digitSum + 1;
+}
+
+/**
+ * Helper function to check for a file with different extensions in order of priority
+ * @param {string} basePath - The base directory path (without 'rspack.config' and extension)
+ * @returns {string|null} The full path with extension if found, null otherwise
+ */
+export function getCustomConfigFilePath(basePath = getMeteorAppDir()) {
+  const configBasePath = path.join(basePath, 'rspack.config');
+
+  // Check for .js extension first (highest priority)
+  const jsPath = `${configBasePath}.js`;
+  if (fs.existsSync(jsPath)) {
+    return jsPath;
+  }
+
+  // Check for .mjs extension next
+  const mjsPath = `${configBasePath}.mjs`;
+  if (fs.existsSync(mjsPath)) {
+    return mjsPath;
+  }
+
+  // Check for .cjs extension last
+  const cjsPath = `${configBasePath}.cjs`;
+  if (fs.existsSync(cjsPath)) {
+    return cjsPath;
+  }
+
+  // No valid config file found with any extension
+  return null;
+}
+
+/**
+ * Gets the appropriate config file name based on environment
+ * @returns {string} The name of the Rspack config file
+ * @throws {Error} If no valid config file is found
+ */
+export function getConfigFilePath() {
+  // Check if the config file exists at the current path with any of the supported extensions
+  const defaultConfigBasePath = path.join(process.cwd(), 'node_modules/@meteorjs/rspack');
+  const defaultConfigPath = getCustomConfigFilePath(defaultConfigBasePath);
+  if (defaultConfigPath) {
+    return defaultConfigPath;
+  }
+
+  // If not found, check if we're in a monorepo and look for alternative config
+  const monorepoPath = getMonorepoPath();
+  if (monorepoPath) {
+    const alternativeConfigBasePath = path.join(monorepoPath, 'node_modules/@meteorjs/rspack');
+    const alternativeConfigPath = getCustomConfigFilePath(alternativeConfigBasePath);
+    if (alternativeConfigPath) {
+      return alternativeConfigPath;
+    }
+  }
+
+  // If no config file is found, throw an error
+  throw new Error('Could not find rspack.config.js, rspack.config.mjs, or rspack.config.cjs. Make sure @meteorjs/rspack is installed correctly.');
+}
+
+/**
+ * Gets the appropriate Rspack environment variables and command line arguments
  * @param {Object} options - Options for environment variables
  * @param {boolean} options.isClient - Whether this is for client-side build
  * @param {boolean} options.isServer - Whether this is for server-side build
- * @returns {string[]} Array of command line arguments for Rspack
+ * @returns {Object} Object containing params (command line arguments) and envs (environment variables)
  */
 export function getRspackEnv({ isClient, isServer, isTest: inIsTest }) {
   const RSPACK_BUILD_CONTEXT = require('./constants').RSPACK_BUILD_CONTEXT;
@@ -90,17 +193,23 @@ export function getRspackEnv({ isClient, isServer, isTest: inIsTest }) {
 
   const entryKey = `${isTest && isTestModule ? 'test' : 'main'}${isClient ? 'Client' : 'Server'}`;
   const inputFilePath = isTest && isTestModule ? initialEntrypoints.testModule : initialEntrypoints[entryKey];
-  const isTypescriptEnabled = inputFilePath?.endsWith('.ts') || inputFilePath?.endsWith('.tsx');
-  const isTsxEnabled = inputFilePath?.endsWith('.tsx');
-  const isJsxEnabled = inputFilePath?.endsWith('.jsx');
+  const isTypescriptEnabled = process.env.METEOR_TYPESCRIPT_ENABLED === 'true' ||
+    inputFilePath?.endsWith('.ts') ||
+    inputFilePath?.endsWith('.tsx');
+
+  const isReactEnabled = process.env.METEOR_REACT_ENABLED === 'true';
+  const isTsxEnabled = isTypescriptEnabled && (inputFilePath?.endsWith('.tsx') || isReactEnabled);
+  const isJsxEnabled = !isTypescriptEnabled && (inputFilePath?.endsWith('.jsx') || isReactEnabled);
 
-  const isReactEnabled = !!process.env.METEOR_REACT_ENABLED;
   const isBlazeEnabled = isMeteorBlazeProject();
   const isBlazeHotEnabled = isMeteorBlazeHotProject();
   const isBundleVisualizerEnabled = isMeteorBundleVisualizerProject();
 
   const swcExternalHelpers = checkNpmDependencyExists('@swc/helpers');
 
+  const configPath = getConfigFilePath();
+  const projectConfigPath = getCustomConfigFilePath();
+
   const pairs = [
     ['isDevelopment', isMeteorAppDevelopment()],
     ['isProduction', isMeteorAppProduction()],
@@ -127,11 +236,12 @@ export function getRspackEnv({ isClient, isServer, isTest: inIsTest }) {
       }),
     ],
     ['runPath', getBuildFilePath({ ...module, ...env, ...side, ...commandRole }) ],
-    ['bannerOutput', JSON.stringify(getBuildFileContent({ ...module, ...env, ...side, role: FILE_ROLE.output }))],
     ['buildContext', RSPACK_BUILD_CONTEXT],
     ['chunksContext', RSPACK_CHUNKS_CONTEXT],
     ['assetsContext', RSPACK_ASSETS_CONTEXT],
-    ['devServerPort', RSPACK_DEVSERVER_PORT],
+    ['devServerPort', process.env.RSPACK_DEVSERVER_PORT],
+    ['projectConfigPath', projectConfigPath],
+    ['configPath', configPath],
     ...(swcExternalHelpers &&  [['swcExternalHelpers', swcExternalHelpers]] || []),
     ...(isReactEnabled &&  [['isReactEnabled', isReactEnabled]] || []),
     ...(isBlazeEnabled &&  [['isBlazeEnabled', isBlazeEnabled]] || []),
@@ -139,13 +249,26 @@ export function getRspackEnv({ isClient, isServer, isTest: inIsTest }) {
     ...(isTypescriptEnabled &&  [['isTypescriptEnabled', isTypescriptEnabled]] || []),
     ...(isTsxEnabled &&  [['isTsxEnabled', isTsxEnabled]] || []),
     ...(isJsxEnabled &&  [['isJsxEnabled', isJsxEnabled]] || []),
-    ...(isBundleVisualizerEnabled &&  [['isBundleVisualizerEnabled', isBundleVisualizerEnabled]] || []),
+    ...(isBundleVisualizerEnabled &&  [
+      ['isBundleVisualizerEnabled', isBundleVisualizerEnabled],
+      ['rsdoctorClientPort', process.env.RSDOCTOR_CLIENT_PORT],
+      ['rsdoctorServerPort', process.env.RSDOCTOR_SERVER_PORT],
+    ] || []),
 
   ].filter(Boolean);
-  return pairs.flatMap(([key, val]) => [
+
+  // Create environment variables object with bannerOutput
+  const envs = {
+    RSPACK_BANNER: JSON.stringify(getBuildFileContent({ ...module, ...env, ...side, role: FILE_ROLE.output }))
+  };
+
+  // Create params from pairs
+  const params = pairs.flatMap(([key, val]) => [
     '--env',
     `${key}=${val}`
   ]);
+
+  return { params, envs };
 }
 
 /**
@@ -165,12 +288,14 @@ export function startRspackClientServe(options = {}) {
   }
 
   const appDir = getMeteorAppDir();
-  const configFile = getConfigFileName();
-  const { command, args } = getNpxCommand(['rspack', 'serve', '--config', configFile, ...getRspackEnv({ isClient: true, isServer: false })]);
+  const configFile = getConfigFilePath();
+  const { params, envs } = getRspackEnv({ isClient: true, isServer: false });
+  const { command, args } = getNpxCommand(['rspack', 'serve', '--config', configFile, ...params]);
   const newClientProcess = spawnProcess(
     command,
     args, {
       cwd: appDir,
+      env: { ...process.env, ...envs },
       onStdout: (data) => {
         logInfo(`[Rspack Client] ${data}`);
         if (onCompile && data.trim().includes("compiled")) {
@@ -187,11 +312,19 @@ export function startRspackClientServe(options = {}) {
         if (data.includes('Loopback:') || data.includes('Project is running at:')) {
           logInfo(`[Rspack Client] ${data}`);
         } else {
+          // Check if this is the "npm error could not determine executable to run" error
+          if (data.includes('npm error could not determine executable to run')) {
+            const errorMsg = '[Rspack Client Error] Try running "meteor npm install" to ensure rspack is available';
+            logError(errorMsg);
+            throw new Error(errorMsg);
+          }
           logError(`[Rspack Client Error] ${data}`);
         }
       },
       onError: (err) => {
-        logError(`Rspack Error: ${err.message}`);
+        const errorMsg = `Rspack Error: ${err.message}`;
+        logError(errorMsg);
+        throw new Error(errorMsg);
       }
     });
 
@@ -218,12 +351,14 @@ export function startRspackServerWatch(options = {}) {
   }
 
   const appDir = getMeteorAppDir();
-  const configFile = getConfigFileName();
-  const { command, args } = getNpxCommand(['rspack', 'build', '--watch', '--config', configFile, ...getRspackEnv({ isClient: false, isServer: true })]);
+  const configFile = getConfigFilePath();
+  const { params, envs } = getRspackEnv({ isClient: false, isServer: true });
+  const { command, args } = getNpxCommand(['rspack', 'build', '--watch', '--config', configFile, ...params]);
   const newServerProcess = spawnProcess(
     command,
     args, {
     cwd: appDir,
+    env: { ...process.env, ...envs },
     onStdout: (data) => {
       logInfo(`[Rspack Server] ${data}`);
       if (onCompile && data.trim().includes("compiled")) {
@@ -235,11 +370,19 @@ export function startRspackServerWatch(options = {}) {
       if (data.includes('Project is running at:')) {
         logInfo(`[Rspack Server] ${data}`);
       } else {
+        // Check if this is the "npm error could not determine executable to run" error
+        if (data.includes('npm error could not determine executable to run')) {
+          const errorMsg = '[Rspack Server Error] Try running "meteor npm install" to ensure rspack is available';
+          logError(errorMsg);
+          throw new Error(errorMsg);
+        }
         logError(`[Rspack Server Error] ${data}`);
       }
     },
     onError: (err) => {
-      logError(`Rspack Error: ${err.message}`);
+      const errorMsg = `Rspack Error: ${err.message}`;
+      logError(errorMsg);
+      throw new Error(errorMsg);
     }
   });
 
@@ -262,18 +405,19 @@ export function startRspackServerWatch(options = {}) {
  */
 export async function runRspackBuild({ isClient, isServer, isTest, isTestModule, onCompile, watch, label = 'Build' } = {}) {
   const appDir = getMeteorAppDir();
-  const configFile = getConfigFileName();
+  const configFile = getConfigFilePath();
 
   const endpoint = isTestModule ? 'Module' : isClient ? 'Client' : 'Server';
   // Use a promise to ensure Meteor waits until Rspack finishes
   return new Promise((resolve, reject) => {
+    const { params, envs } = getRspackEnv({ isClient, isServer, isTest, isTestModule });
     const rspackArgs = [
       'rspack',
       'build',
       '--config',
       configFile,
       ...(watch && ['--watch']) || [],
-      ...getRspackEnv({ isClient, isServer, isTest, isTestModule }),
+      ...params,
     ].filter(Boolean);
     const { command, args } = getNpxCommand(rspackArgs);
     spawnProcess(
@@ -281,6 +425,7 @@ export async function runRspackBuild({ isClient, isServer, isTest, isTestModule,
       args,
       {
       cwd: appDir,
+      env: { ...process.env, ...envs },
       onStdout: (data) => {
         logInfo(`[Rspack ${label} ${endpoint}] ${data}`);
         if (onCompile && data.trim().includes("compiled")) {
@@ -292,6 +437,12 @@ export async function runRspackBuild({ isClient, isServer, isTest, isTestModule,
         if (data.includes('Project is running at:')) {
           logInfo(`[Rspack ${label} ${endpoint}] ${data}`);
         } else {
+          // Check if this is the "npm error could not determine executable to run" error
+          if (data.includes('npm error could not determine executable to run')) {
+            const errorMsg = `[Rspack ${label} Error ${endpoint}] Try running "meteor npm install" to ensure rspack is available`;
+            logError(errorMsg);
+            throw new Error(errorMsg);
+          }
           logError(`[Rspack ${label} Error ${endpoint}] ${data}`);
         }
       },
diff --git a/packages/rspack/package.js b/packages/rspack/package.js
index 0638a7c4d6..52765a5880 100644
--- a/packages/rspack/package.js
+++ b/packages/rspack/package.js
@@ -1,6 +1,6 @@
 Package.describe({
   summary: "Integrate rspack into the Meteor lifecycle to run the bundler independently",
-  version: '1.0.0-beta340.0',
+  version: '1.0.0-beta340.11',
 });
 
 Package.registerBuildPlugin({
diff --git a/packages/rspack/rspack_plugin.js b/packages/rspack/rspack_plugin.js
index 4d961ed24a..6962ce900b 100644
--- a/packages/rspack/rspack_plugin.js
+++ b/packages/rspack/rspack_plugin.js
@@ -22,8 +22,8 @@ const {
 const {
   ensureRspackInstalled,
   checkReactInstalled,
+  checkTypescriptInstalled,
   ensureRspackReactInstalled,
-  ensureRspackDoctorInstalled,
 } = require('./lib/dependencies');
 
 const {
@@ -37,6 +37,11 @@ const {
   startRspackServerWatch,
   runRspackBuild,
   cleanup,
+  calculateDevServerPort,
+  calculateRsdoctorClientPort,
+  calculateRsdoctorServerPort,
+  getConfigFilePath,
+  getCustomConfigFilePath,
 } = require('./lib/processes');
 
 const {
@@ -66,6 +71,7 @@ const {
   isMeteorAppDebug,
   isMeteorAppConfigModernVerbose,
   isMeteorAppNative,
+  isMeteorBundleVisualizerProject,
 } = require('meteor/tools-core/lib/meteor');
 
 const {
@@ -76,17 +82,29 @@ const {
 const {
   getNpxCommand,
   getNpmCommand,
+  getYarnCommand,
+  isYarnProject,
 } = require('meteor/tools-core/lib/npm');
+const { getMeteorAppConfig, hasMeteorAppConfigAutoInstallDeps } = require("../tools-core/lib/meteor");
 
 if (isMeteorAppRun() || isMeteorAppBuild() || isMeteorAppTest()) {
   // Get entry points from Meteor configuration
   setGlobalState(GLOBAL_STATE_KEYS.INITIAL_ENTRYPONTS, getMeteorAppEntrypoints());
 
+  let isYarnProj = process.env.YARN_ENABLED === 'true';
   // Main entry point - using top-level await
   try {
+    // Check if the project is a Yarn project and store the result in environment variable if not already set
+    if (process.env.YARN_ENABLED === undefined) {
+      isYarnProj = isYarnProject();
+      process.env.YARN_ENABLED = isYarnProj ? 'true' : 'false';
+    }
     if (isMeteorAppDebug() || isMeteorAppConfigModernVerbose()) {
       logInfo(`[i] Meteor Npx prefix: ${getNpxCommand([])?.prefix}`);
       logInfo(`[i] Meteor Npm prefix: ${getNpmCommand([])?.prefix}`);
+      if (isYarnProj) {
+        logInfo(`[i] Meteor Yarn prefix: ${getYarnCommand([])?.prefix}`);
+      }
     }
 
     // Clean build context files only if they haven't been cleaned yet
@@ -95,14 +113,23 @@ if (isMeteorAppRun() || isMeteorAppBuild() || isMeteorAppTest()) {
       setGlobalState(GLOBAL_STATE_KEYS.BUILD_CONTEXT_FILES_CLEANED, true);
     }
 
-    // Ensure Rspack is installed
-    await ensureRspackInstalled();
+    // Auto install deps (by default enabled)
+    if (hasMeteorAppConfigAutoInstallDeps()) {
+      // Ensure Rspack is installed
+      await ensureRspackInstalled();
+    }
 
     // Check if Rspack React is installed
     if (checkReactInstalled()) {
-      await ensureRspackReactInstalled();
+      // Auto install deps (by default enabled)
+      if (hasMeteorAppConfigAutoInstallDeps()) {
+        await ensureRspackReactInstalled();
+      }
     }
 
+    // Check if TypeScript is installed
+    checkTypescriptInstalled();
+
     // Ensure the Rspack build context directory exists
     ensureRspackBuildContextExists();
 
@@ -112,6 +139,38 @@ if (isMeteorAppRun() || isMeteorAppBuild() || isMeteorAppTest()) {
     // Configure Meteor settings for Rspack
     configureMeteorForRspack();
 
+    // Calculate and set the devServerPort at boot
+    if (!process.env.RSPACK_DEVSERVER_PORT) {
+      process.env.RSPACK_DEVSERVER_PORT = calculateDevServerPort();
+      if (isMeteorAppDebug() || isMeteorAppConfigModernVerbose()) {
+        logInfo(`[i] Rspack DevServer Port: ${process.env.RSPACK_DEVSERVER_PORT}`);
+      }
+    }
+
+    if (isMeteorAppDebug() || isMeteorAppConfigModernVerbose()) {
+      const configFile = getConfigFilePath();
+      logInfo(`[i] Rspack default config: ${configFile}`);
+      const projectConfigFile = getCustomConfigFilePath();
+      logInfo(`[i] Rspack custom config: ${projectConfigFile}`);
+    }
+
+    // Calculate and set the Rsdoctor client and server ports at boot only if bundle visualizer is enabled
+    if (isMeteorBundleVisualizerProject()) {
+      if (!process.env.RSDOCTOR_CLIENT_PORT) {
+        process.env.RSDOCTOR_CLIENT_PORT = calculateRsdoctorClientPort();
+        if (isMeteorAppDebug() || isMeteorAppConfigModernVerbose()) {
+          logInfo(`[i] Rsdoctor Client Port: ${process.env.RSDOCTOR_CLIENT_PORT}`);
+        }
+      }
+
+      if (!process.env.RSDOCTOR_SERVER_PORT) {
+        process.env.RSDOCTOR_SERVER_PORT = calculateRsdoctorServerPort();
+        if (isMeteorAppDebug() || isMeteorAppConfigModernVerbose()) {
+          logInfo(`[i] Rsdoctor Server Port: ${process.env.RSDOCTOR_SERVER_PORT}`);
+        }
+      }
+    }
+
     // Register cleanup handler
     process.on('exit', cleanup);
     process.on('SIGINT', () => {
diff --git a/packages/rspack/rspack_server.js b/packages/rspack/rspack_server.js
index 1dc9829777..477ecfbcc3 100644
--- a/packages/rspack/rspack_server.js
+++ b/packages/rspack/rspack_server.js
@@ -1,19 +1,38 @@
 import { Meteor } from 'meteor/meteor';
-import { WebApp } from 'meteor/webapp';
+import { WebApp, WebAppInternals } from 'meteor/webapp';
 import { shuffleString } from 'meteor/tools-core/lib/string';
 import { createProxyMiddleware } from 'http-proxy-middleware';
+import path from 'path';
+import { parse as parseUrl } from 'url';
 import {
   RSPACK_CHUNKS_CONTEXT,
   RSPACK_ASSETS_CONTEXT,
   RSPACK_HOT_UPDATE_REGEX,
-  RSPACK_BUNDLES_REGEX,
-  RSPACK_ASSETS_REGEX,
-  RSPACK_DEVSERVER_PORT,
 } from "./lib/constants";
 
+// Define constants for both development and production
+const rspackChunksContext = process.env.RSPACK_CHUNKS_CONTEXT || RSPACK_CHUNKS_CONTEXT;
+const rspackAssetsContext = process.env.RSPACK_ASSETS_CONTEXT || RSPACK_ASSETS_CONTEXT;
+
+/**
+ * Regex pattern for rspack bundles
+ * @constant {RegExp}
+ */
+const RSPACK_CHUNKS_REGEX = new RegExp(
+  `^\/${rspackChunksContext}\/(.+)$`,
+);
+
+/**
+ * Regex pattern for rspack assets
+ * @constant {RegExp}
+ */
+const RSPACK_ASSETS_REGEX = new RegExp(
+  `^\/${rspackAssetsContext}\/(.+)$`,
+);
+
 if (Meteor.isDevelopment) {
   // Target URL for the Rspack dev server
-  const target = `http://localhost:${RSPACK_DEVSERVER_PORT}`;
+  const target = `http://localhost:${process.env.RSPACK_DEVSERVER_PORT}`;
 
   // Proxy HMR websocket upgrade requests
   WebApp.connectHandlers.use('/ws',
@@ -53,10 +72,10 @@ if (Meteor.isDevelopment) {
     }
 
     // 2) match "/build-chunks/<anything>"
-    const bundlesMatch = req.url.match(RSPACK_BUNDLES_REGEX);
+    const bundlesMatch = req.url.match(RSPACK_CHUNKS_REGEX);
     if (bundlesMatch) {
       // Redirect "/bundles/foo.js" → "/__rspack__/build-chunks/foo.js"
-      const target = `/__rspack__/${RSPACK_CHUNKS_CONTEXT}/${bundlesMatch[1]}`;
+      const target = `/__rspack__/${rspackChunksContext}/${bundlesMatch[1]}`;
       res.writeHead(307, { Location: target });
       return res.end();
     }
@@ -65,7 +84,7 @@ if (Meteor.isDevelopment) {
     const assetsMatch = req.url.match(RSPACK_ASSETS_REGEX);
     if (assetsMatch) {
       // Redirect "/build-assets/foo.js" → "/__rspack__/build-assets/foo.js"
-      const target = `/__rspack__/${RSPACK_ASSETS_CONTEXT}/${assetsMatch[1]}`;
+      const target = `/__rspack__/${rspackAssetsContext}/${assetsMatch[1]}`;
       res.writeHead(307, { Location: target });
       return res.end();
     }
@@ -105,3 +124,80 @@ if (Meteor.isDevelopment) {
   // Enable client reload on server startup
   enableClientReloadOnServerStart();
 }
+
+/**
+ * Register a single rspack static asset with WebAppInternals.staticFilesByArch
+ * @param {string} arch - The architecture to register the asset for
+ * @param {string} pathname - The pathname of the asset
+ * @param {string} filePath - The absolute path to the asset on disk
+ * @returns {Object} The static file info object
+ */
+function registerRspackStaticAsset(arch, pathname, filePath) {
+  // Ensure the architecture exists in staticFilesByArch
+  if (!WebAppInternals.staticFilesByArch[arch]) {
+    WebAppInternals.staticFilesByArch[arch] = Object.create(null);
+  }
+
+  // Get the static files object for this architecture
+  const staticFiles = WebAppInternals.staticFilesByArch[arch];
+
+  // Skip if already registered
+  if (staticFiles[pathname]) {
+    // Ensure the entry is marked as cacheable
+    staticFiles[pathname].cacheable = true;
+    return staticFiles[pathname];
+  }
+
+  // Determine file type based on extension
+  const type = pathname.endsWith(".js") ? "js" :
+    pathname.endsWith(".css") ? "css" :
+      pathname.endsWith(".json") ? "json" : undefined;
+
+  // Extract hash from filename (assuming it's the second part after splitting by '.')
+  const filename = pathname.split("/").pop();
+  const hash = filename.split(".")[1];
+
+  // Register the asset
+  staticFiles[pathname] = {
+    absolutePath: filePath,
+    cacheable: true, // Most rspack assets are cacheable
+    hash,
+    type
+  };
+
+  return staticFiles[pathname];
+}
+
+// Store the original staticFilesMiddleware
+const originalStaticFilesMiddleware = WebAppInternals.staticFilesMiddleware;
+
+// Handle rspack assets on-demand to add Meteor's static files headers
+WebAppInternals.staticFilesMiddleware = async function(staticFilesByArch, req, res, next) {
+  const pathname = parseUrl(req.url).pathname;
+
+  try {
+    // Check if this is a rspack asset request
+    const chunksMatch = pathname.match(RSPACK_CHUNKS_REGEX);
+    const assetsMatch = pathname.match(RSPACK_ASSETS_REGEX);
+
+    if (chunksMatch || assetsMatch) {
+      const cwd = process.cwd();
+      const architectures = ["web.browser", "web.browser.legacy", "web.cordova"];
+      WebApp.categorizeRequest(req);
+
+      // Try to find the file on disk
+      const context = chunksMatch ? rspackChunksContext : rspackAssetsContext;
+      const filename = (chunksMatch ? chunksMatch[1] : assetsMatch[1]);
+      const filePath = path.join(cwd, context, filename);
+
+      architectures.forEach(archName => {
+        registerRspackStaticAsset(archName, pathname, filePath);
+      });
+    }
+  } catch (e) {
+    console.error(`Error handling rspack asset: ${e.message}`);
+  }
+
+  // Call the original middleware
+  return originalStaticFilesMiddleware(staticFilesByArch, req, res, next);
+};
diff --git a/packages/shell-server/package.js b/packages/shell-server/package.js
index 1dd7551714..69987dd4d9 100644
--- a/packages/shell-server/package.js
+++ b/packages/shell-server/package.js
@@ -1,6 +1,6 @@
 Package.describe({
   name: "shell-server",
-  version: '0.6.2',
+  version: '0.7.0-beta340.11',
   summary: "Server-side component of the `meteor shell` command.",
   documentation: "README.md"
 });
diff --git a/packages/standard-minifier-js/package.js b/packages/standard-minifier-js/package.js
index 6f23b6e939..384cad5770 100644
--- a/packages/standard-minifier-js/package.js
+++ b/packages/standard-minifier-js/package.js
@@ -12,7 +12,7 @@ Package.registerBuildPlugin({
     'ecmascript'
   ],
   npmDependencies: {
-    '@meteorjs/swc-core': '1.12.14',
+    '@meteorjs/swc-core': '1.13.5',
     'acorn': '8.10.0',
     "@babel/runtime": "7.18.9",
     '@babel/parser': '7.22.7',
diff --git a/packages/test-in-browser/diff_match_patch_uncompressed.js b/packages/test-in-browser/diff_match_patch_uncompressed.js
deleted file mode 100644
index 4d5542c1d3..0000000000
--- a/packages/test-in-browser/diff_match_patch_uncompressed.js
+++ /dev/null
@@ -1,2218 +0,0 @@
-/**
- * Diff Match and Patch
- * Copyright 2018 The diff-match-patch Authors.
- * https://github.com/google/diff-match-patch
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/**
- * @fileoverview Computes the difference between two texts to create a patch.
- * Applies the patch onto another text, allowing for errors.
- * @author fraser@google.com (Neil Fraser)
- */
-
-/**
- * Class containing the diff, match and patch methods.
- * @constructor
- */
-var diff_match_patch = function() {
-
-  // Defaults.
-  // Redefine these in your program to override the defaults.
-
-  // Number of seconds to map a diff before giving up (0 for infinity).
-  this.Diff_Timeout = 1.0;
-  // Cost of an empty edit operation in terms of edit characters.
-  this.Diff_EditCost = 4;
-  // At what point is no match declared (0.0 = perfection, 1.0 = very loose).
-  this.Match_Threshold = 0.5;
-  // How far to search for a match (0 = exact location, 1000+ = broad match).
-  // A match this many characters away from the expected location will add
-  // 1.0 to the score (0.0 is a perfect match).
-  this.Match_Distance = 1000;
-  // When deleting a large block of text (over ~64 characters), how close do
-  // the contents have to be to match the expected contents. (0.0 = perfection,
-  // 1.0 = very loose).  Note that Match_Threshold controls how closely the
-  // end points of a delete need to match.
-  this.Patch_DeleteThreshold = 0.5;
-  // Chunk size for context length.
-  this.Patch_Margin = 4;
-
-  // The number of bits in an int.
-  this.Match_MaxBits = 32;
-};
-
-
-//  DIFF FUNCTIONS
-
-
-/**
- * The data structure representing a diff is an array of tuples:
- * [[DIFF_DELETE, 'Hello'], [DIFF_INSERT, 'Goodbye'], [DIFF_EQUAL, ' world.']]
- * which means: delete 'Hello', add 'Goodbye' and keep ' world.'
- */
-var DIFF_DELETE = -1;
-var DIFF_INSERT = 1;
-var DIFF_EQUAL = 0;
-
-/**
- * Class representing one diff tuple.
- * ~Attempts to look like a two-element array (which is what this used to be).~
- * Constructor returns an actual two-element array, to allow destructing @JackuB
- * See https://github.com/JackuB/diff-match-patch/issues/14 for details
- * @param {number} op Operation, one of: DIFF_DELETE, DIFF_INSERT, DIFF_EQUAL.
- * @param {string} text Text to be deleted, inserted, or retained.
- * @constructor
- */
-diff_match_patch.Diff = function(op, text) {
-  return [op, text];
-};
-
-/**
- * Find the differences between two texts.  Simplifies the problem by stripping
- * any common prefix or suffix off the texts before diffing.
- * @param {string} text1 Old string to be diffed.
- * @param {string} text2 New string to be diffed.
- * @param {boolean=} opt_checklines Optional speedup flag. If present and false,
- *     then don't run a line-level diff first to identify the changed areas.
- *     Defaults to true, which does a faster, slightly less optimal diff.
- * @param {number=} opt_deadline Optional time when the diff should be complete
- *     by.  Used internally for recursive calls.  Users should set DiffTimeout
- *     instead.
- * @return {!Array.<!diff_match_patch.Diff>} Array of diff tuples.
- */
-diff_match_patch.prototype.diff_main = function(text1, text2, opt_checklines,
-    opt_deadline) {
-  // Set a deadline by which time the diff must be complete.
-  if (typeof opt_deadline == 'undefined') {
-    if (this.Diff_Timeout <= 0) {
-      opt_deadline = Number.MAX_VALUE;
-    } else {
-      opt_deadline = (new Date).getTime() + this.Diff_Timeout * 1000;
-    }
-  }
-  var deadline = opt_deadline;
-
-  // Check for null inputs.
-  if (text1 == null || text2 == null) {
-    throw new Error('Null input. (diff_main)');
-  }
-
-  // Check for equality (speedup).
-  if (text1 == text2) {
-    if (text1) {
-      return [new diff_match_patch.Diff(DIFF_EQUAL, text1)];
-    }
-    return [];
-  }
-
-  if (typeof opt_checklines == 'undefined') {
-    opt_checklines = true;
-  }
-  var checklines = opt_checklines;
-
-  // Trim off common prefix (speedup).
-  var commonlength = this.diff_commonPrefix(text1, text2);
-  var commonprefix = text1.substring(0, commonlength);
-  text1 = text1.substring(commonlength);
-  text2 = text2.substring(commonlength);
-
-  // Trim off common suffix (speedup).
-  commonlength = this.diff_commonSuffix(text1, text2);
-  var commonsuffix = text1.substring(text1.length - commonlength);
-  text1 = text1.substring(0, text1.length - commonlength);
-  text2 = text2.substring(0, text2.length - commonlength);
-
-  // Compute the diff on the middle block.
-  var diffs = this.diff_compute_(text1, text2, checklines, deadline);
-
-  // Restore the prefix and suffix.
-  if (commonprefix) {
-    diffs.unshift(new diff_match_patch.Diff(DIFF_EQUAL, commonprefix));
-  }
-  if (commonsuffix) {
-    diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, commonsuffix));
-  }
-  this.diff_cleanupMerge(diffs);
-  return diffs;
-};
-
-
-/**
- * Find the differences between two texts.  Assumes that the texts do not
- * have any common prefix or suffix.
- * @param {string} text1 Old string to be diffed.
- * @param {string} text2 New string to be diffed.
- * @param {boolean} checklines Speedup flag.  If false, then don't run a
- *     line-level diff first to identify the changed areas.
- *     If true, then run a faster, slightly less optimal diff.
- * @param {number} deadline Time when the diff should be complete by.
- * @return {!Array.<!diff_match_patch.Diff>} Array of diff tuples.
- * @private
- */
-diff_match_patch.prototype.diff_compute_ = function(text1, text2, checklines,
-    deadline) {
-  var diffs;
-
-  if (!text1) {
-    // Just add some text (speedup).
-    return [new diff_match_patch.Diff(DIFF_INSERT, text2)];
-  }
-
-  if (!text2) {
-    // Just delete some text (speedup).
-    return [new diff_match_patch.Diff(DIFF_DELETE, text1)];
-  }
-
-  var longtext = text1.length > text2.length ? text1 : text2;
-  var shorttext = text1.length > text2.length ? text2 : text1;
-  var i = longtext.indexOf(shorttext);
-  if (i != -1) {
-    // Shorter text is inside the longer text (speedup).
-    diffs = [new diff_match_patch.Diff(DIFF_INSERT, longtext.substring(0, i)),
-             new diff_match_patch.Diff(DIFF_EQUAL, shorttext),
-             new diff_match_patch.Diff(DIFF_INSERT,
-                 longtext.substring(i + shorttext.length))];
-    // Swap insertions for deletions if diff is reversed.
-    if (text1.length > text2.length) {
-      diffs[0][0] = diffs[2][0] = DIFF_DELETE;
-    }
-    return diffs;
-  }
-
-  if (shorttext.length == 1) {
-    // Single character string.
-    // After the previous speedup, the character can't be an equality.
-    return [new diff_match_patch.Diff(DIFF_DELETE, text1),
-            new diff_match_patch.Diff(DIFF_INSERT, text2)];
-  }
-
-  // Check to see if the problem can be split in two.
-  var hm = this.diff_halfMatch_(text1, text2);
-  if (hm) {
-    // A half-match was found, sort out the return data.
-    var text1_a = hm[0];
-    var text1_b = hm[1];
-    var text2_a = hm[2];
-    var text2_b = hm[3];
-    var mid_common = hm[4];
-    // Send both pairs off for separate processing.
-    var diffs_a = this.diff_main(text1_a, text2_a, checklines, deadline);
-    var diffs_b = this.diff_main(text1_b, text2_b, checklines, deadline);
-    // Merge the results.
-    return diffs_a.concat([new diff_match_patch.Diff(DIFF_EQUAL, mid_common)],
-                          diffs_b);
-  }
-
-  if (checklines && text1.length > 100 && text2.length > 100) {
-    return this.diff_lineMode_(text1, text2, deadline);
-  }
-
-  return this.diff_bisect_(text1, text2, deadline);
-};
-
-
-/**
- * Do a quick line-level diff on both strings, then rediff the parts for
- * greater accuracy.
- * This speedup can produce non-minimal diffs.
- * @param {string} text1 Old string to be diffed.
- * @param {string} text2 New string to be diffed.
- * @param {number} deadline Time when the diff should be complete by.
- * @return {!Array.<!diff_match_patch.Diff>} Array of diff tuples.
- * @private
- */
-diff_match_patch.prototype.diff_lineMode_ = function(text1, text2, deadline) {
-  // Scan the text on a line-by-line basis first.
-  var a = this.diff_linesToChars_(text1, text2);
-  text1 = a.chars1;
-  text2 = a.chars2;
-  var linearray = a.lineArray;
-
-  var diffs = this.diff_main(text1, text2, false, deadline);
-
-  // Convert the diff back to original text.
-  this.diff_charsToLines_(diffs, linearray);
-  // Eliminate freak matches (e.g. blank lines)
-  this.diff_cleanupSemantic(diffs);
-
-  // Rediff any replacement blocks, this time character-by-character.
-  // Add a dummy entry at the end.
-  diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, ''));
-  var pointer = 0;
-  var count_delete = 0;
-  var count_insert = 0;
-  var text_delete = '';
-  var text_insert = '';
-  while (pointer < diffs.length) {
-    switch (diffs[pointer][0]) {
-      case DIFF_INSERT:
-        count_insert++;
-        text_insert += diffs[pointer][1];
-        break;
-      case DIFF_DELETE:
-        count_delete++;
-        text_delete += diffs[pointer][1];
-        break;
-      case DIFF_EQUAL:
-        // Upon reaching an equality, check for prior redundancies.
-        if (count_delete >= 1 && count_insert >= 1) {
-          // Delete the offending records and add the merged ones.
-          diffs.splice(pointer - count_delete - count_insert,
-                       count_delete + count_insert);
-          pointer = pointer - count_delete - count_insert;
-          var subDiff =
-              this.diff_main(text_delete, text_insert, false, deadline);
-          for (var j = subDiff.length - 1; j >= 0; j--) {
-            diffs.splice(pointer, 0, subDiff[j]);
-          }
-          pointer = pointer + subDiff.length;
-        }
-        count_insert = 0;
-        count_delete = 0;
-        text_delete = '';
-        text_insert = '';
-        break;
-    }
-    pointer++;
-  }
-  diffs.pop();  // Remove the dummy entry at the end.
-
-  return diffs;
-};
-
-
-/**
- * Find the 'middle snake' of a diff, split the problem in two
- * and return the recursively constructed diff.
- * See Myers 1986 paper: An O(ND) Difference Algorithm and Its Variations.
- * @param {string} text1 Old string to be diffed.
- * @param {string} text2 New string to be diffed.
- * @param {number} deadline Time at which to bail if not yet complete.
- * @return {!Array.<!diff_match_patch.Diff>} Array of diff tuples.
- * @private
- */
-diff_match_patch.prototype.diff_bisect_ = function(text1, text2, deadline) {
-  // Cache the text lengths to prevent multiple calls.
-  var text1_length = text1.length;
-  var text2_length = text2.length;
-  var max_d = Math.ceil((text1_length + text2_length) / 2);
-  var v_offset = max_d;
-  var v_length = 2 * max_d;
-  var v1 = new Array(v_length);
-  var v2 = new Array(v_length);
-  // Setting all elements to -1 is faster in Chrome & Firefox than mixing
-  // integers and undefined.
-  for (var x = 0; x < v_length; x++) {
-    v1[x] = -1;
-    v2[x] = -1;
-  }
-  v1[v_offset + 1] = 0;
-  v2[v_offset + 1] = 0;
-  var delta = text1_length - text2_length;
-  // If the total number of characters is odd, then the front path will collide
-  // with the reverse path.
-  var front = (delta % 2 != 0);
-  // Offsets for start and end of k loop.
-  // Prevents mapping of space beyond the grid.
-  var k1start = 0;
-  var k1end = 0;
-  var k2start = 0;
-  var k2end = 0;
-  for (var d = 0; d < max_d; d++) {
-    // Bail out if deadline is reached.
-    if ((new Date()).getTime() > deadline) {
-      break;
-    }
-
-    // Walk the front path one step.
-    for (var k1 = -d + k1start; k1 <= d - k1end; k1 += 2) {
-      var k1_offset = v_offset + k1;
-      var x1;
-      if (k1 == -d || (k1 != d && v1[k1_offset - 1] < v1[k1_offset + 1])) {
-        x1 = v1[k1_offset + 1];
-      } else {
-        x1 = v1[k1_offset - 1] + 1;
-      }
-      var y1 = x1 - k1;
-      while (x1 < text1_length && y1 < text2_length &&
-             text1.charAt(x1) == text2.charAt(y1)) {
-        x1++;
-        y1++;
-      }
-      v1[k1_offset] = x1;
-      if (x1 > text1_length) {
-        // Ran off the right of the graph.
-        k1end += 2;
-      } else if (y1 > text2_length) {
-        // Ran off the bottom of the graph.
-        k1start += 2;
-      } else if (front) {
-        var k2_offset = v_offset + delta - k1;
-        if (k2_offset >= 0 && k2_offset < v_length && v2[k2_offset] != -1) {
-          // Mirror x2 onto top-left coordinate system.
-          var x2 = text1_length - v2[k2_offset];
-          if (x1 >= x2) {
-            // Overlap detected.
-            return this.diff_bisectSplit_(text1, text2, x1, y1, deadline);
-          }
-        }
-      }
-    }
-
-    // Walk the reverse path one step.
-    for (var k2 = -d + k2start; k2 <= d - k2end; k2 += 2) {
-      var k2_offset = v_offset + k2;
-      var x2;
-      if (k2 == -d || (k2 != d && v2[k2_offset - 1] < v2[k2_offset + 1])) {
-        x2 = v2[k2_offset + 1];
-      } else {
-        x2 = v2[k2_offset - 1] + 1;
-      }
-      var y2 = x2 - k2;
-      while (x2 < text1_length && y2 < text2_length &&
-             text1.charAt(text1_length - x2 - 1) ==
-             text2.charAt(text2_length - y2 - 1)) {
-        x2++;
-        y2++;
-      }
-      v2[k2_offset] = x2;
-      if (x2 > text1_length) {
-        // Ran off the left of the graph.
-        k2end += 2;
-      } else if (y2 > text2_length) {
-        // Ran off the top of the graph.
-        k2start += 2;
-      } else if (!front) {
-        var k1_offset = v_offset + delta - k2;
-        if (k1_offset >= 0 && k1_offset < v_length && v1[k1_offset] != -1) {
-          var x1 = v1[k1_offset];
-          var y1 = v_offset + x1 - k1_offset;
-          // Mirror x2 onto top-left coordinate system.
-          x2 = text1_length - x2;
-          if (x1 >= x2) {
-            // Overlap detected.
-            return this.diff_bisectSplit_(text1, text2, x1, y1, deadline);
-          }
-        }
-      }
-    }
-  }
-  // Diff took too long and hit the deadline or
-  // number of diffs equals number of characters, no commonality at all.
-  return [new diff_match_patch.Diff(DIFF_DELETE, text1),
-          new diff_match_patch.Diff(DIFF_INSERT, text2)];
-};
-
-
-/**
- * Given the location of the 'middle snake', split the diff in two parts
- * and recurse.
- * @param {string} text1 Old string to be diffed.
- * @param {string} text2 New string to be diffed.
- * @param {number} x Index of split point in text1.
- * @param {number} y Index of split point in text2.
- * @param {number} deadline Time at which to bail if not yet complete.
- * @return {!Array.<!diff_match_patch.Diff>} Array of diff tuples.
- * @private
- */
-diff_match_patch.prototype.diff_bisectSplit_ = function(text1, text2, x, y,
-    deadline) {
-  var text1a = text1.substring(0, x);
-  var text2a = text2.substring(0, y);
-  var text1b = text1.substring(x);
-  var text2b = text2.substring(y);
-
-  // Compute both diffs serially.
-  var diffs = this.diff_main(text1a, text2a, false, deadline);
-  var diffsb = this.diff_main(text1b, text2b, false, deadline);
-
-  return diffs.concat(diffsb);
-};
-
-
-/**
- * Split two texts into an array of strings.  Reduce the texts to a string of
- * hashes where each Unicode character represents one line.
- * @param {string} text1 First string.
- * @param {string} text2 Second string.
- * @return {{chars1: string, chars2: string, lineArray: !Array.<string>}}
- *     An object containing the encoded text1, the encoded text2 and
- *     the array of unique strings.
- *     The zeroth element of the array of unique strings is intentionally blank.
- * @private
- */
-diff_match_patch.prototype.diff_linesToChars_ = function(text1, text2) {
-  var lineArray = [];  // e.g. lineArray[4] == 'Hello\n'
-  var lineHash = {};   // e.g. lineHash['Hello\n'] == 4
-
-  // '\x00' is a valid character, but various debuggers don't like it.
-  // So we'll insert a junk entry to avoid generating a null character.
-  lineArray[0] = '';
-
-  /**
-   * Split a text into an array of strings.  Reduce the texts to a string of
-   * hashes where each Unicode character represents one line.
-   * Modifies linearray and linehash through being a closure.
-   * @param {string} text String to encode.
-   * @return {string} Encoded string.
-   * @private
-   */
-  function diff_linesToCharsMunge_(text) {
-    var chars = '';
-    // Walk the text, pulling out a substring for each line.
-    // text.split('\n') would would temporarily double our memory footprint.
-    // Modifying text would create many large strings to garbage collect.
-    var lineStart = 0;
-    var lineEnd = -1;
-    // Keeping our own length variable is faster than looking it up.
-    var lineArrayLength = lineArray.length;
-    while (lineEnd < text.length - 1) {
-      lineEnd = text.indexOf('\n', lineStart);
-      if (lineEnd == -1) {
-        lineEnd = text.length - 1;
-      }
-      var line = text.substring(lineStart, lineEnd + 1);
-
-      if (lineHash.hasOwnProperty ? lineHash.hasOwnProperty(line) :
-          (lineHash[line] !== undefined)) {
-        chars += String.fromCharCode(lineHash[line]);
-      } else {
-        if (lineArrayLength == maxLines) {
-          // Bail out at 65535 because
-          // String.fromCharCode(65536) == String.fromCharCode(0)
-          line = text.substring(lineStart);
-          lineEnd = text.length;
-        }
-        chars += String.fromCharCode(lineArrayLength);
-        lineHash[line] = lineArrayLength;
-        lineArray[lineArrayLength++] = line;
-      }
-      lineStart = lineEnd + 1;
-    }
-    return chars;
-  }
-  // Allocate 2/3rds of the space for text1, the rest for text2.
-  var maxLines = 40000;
-  var chars1 = diff_linesToCharsMunge_(text1);
-  maxLines = 65535;
-  var chars2 = diff_linesToCharsMunge_(text2);
-  return {chars1: chars1, chars2: chars2, lineArray: lineArray};
-};
-
-
-/**
- * Rehydrate the text in a diff from a string of line hashes to real lines of
- * text.
- * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.
- * @param {!Array.<string>} lineArray Array of unique strings.
- * @private
- */
-diff_match_patch.prototype.diff_charsToLines_ = function(diffs, lineArray) {
-  for (var i = 0; i < diffs.length; i++) {
-    var chars = diffs[i][1];
-    var text = [];
-    for (var j = 0; j < chars.length; j++) {
-      text[j] = lineArray[chars.charCodeAt(j)];
-    }
-    diffs[i][1] = text.join('');
-  }
-};
-
-
-/**
- * Determine the common prefix of two strings.
- * @param {string} text1 First string.
- * @param {string} text2 Second string.
- * @return {number} The number of characters common to the start of each
- *     string.
- */
-diff_match_patch.prototype.diff_commonPrefix = function(text1, text2) {
-  // Quick check for common null cases.
-  if (!text1 || !text2 || text1.charAt(0) != text2.charAt(0)) {
-    return 0;
-  }
-  // Binary search.
-  // Performance analysis: https://neil.fraser.name/news/2007/10/09/
-  var pointermin = 0;
-  var pointermax = Math.min(text1.length, text2.length);
-  var pointermid = pointermax;
-  var pointerstart = 0;
-  while (pointermin < pointermid) {
-    if (text1.substring(pointerstart, pointermid) ==
-        text2.substring(pointerstart, pointermid)) {
-      pointermin = pointermid;
-      pointerstart = pointermin;
-    } else {
-      pointermax = pointermid;
-    }
-    pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin);
-  }
-  return pointermid;
-};
-
-
-/**
- * Determine the common suffix of two strings.
- * @param {string} text1 First string.
- * @param {string} text2 Second string.
- * @return {number} The number of characters common to the end of each string.
- */
-diff_match_patch.prototype.diff_commonSuffix = function(text1, text2) {
-  // Quick check for common null cases.
-  if (!text1 || !text2 ||
-      text1.charAt(text1.length - 1) != text2.charAt(text2.length - 1)) {
-    return 0;
-  }
-  // Binary search.
-  // Performance analysis: https://neil.fraser.name/news/2007/10/09/
-  var pointermin = 0;
-  var pointermax = Math.min(text1.length, text2.length);
-  var pointermid = pointermax;
-  var pointerend = 0;
-  while (pointermin < pointermid) {
-    if (text1.substring(text1.length - pointermid, text1.length - pointerend) ==
-        text2.substring(text2.length - pointermid, text2.length - pointerend)) {
-      pointermin = pointermid;
-      pointerend = pointermin;
-    } else {
-      pointermax = pointermid;
-    }
-    pointermid = Math.floor((pointermax - pointermin) / 2 + pointermin);
-  }
-  return pointermid;
-};
-
-
-/**
- * Determine if the suffix of one string is the prefix of another.
- * @param {string} text1 First string.
- * @param {string} text2 Second string.
- * @return {number} The number of characters common to the end of the first
- *     string and the start of the second string.
- * @private
- */
-diff_match_patch.prototype.diff_commonOverlap_ = function(text1, text2) {
-  // Cache the text lengths to prevent multiple calls.
-  var text1_length = text1.length;
-  var text2_length = text2.length;
-  // Eliminate the null case.
-  if (text1_length == 0 || text2_length == 0) {
-    return 0;
-  }
-  // Truncate the longer string.
-  if (text1_length > text2_length) {
-    text1 = text1.substring(text1_length - text2_length);
-  } else if (text1_length < text2_length) {
-    text2 = text2.substring(0, text1_length);
-  }
-  var text_length = Math.min(text1_length, text2_length);
-  // Quick check for the worst case.
-  if (text1 == text2) {
-    return text_length;
-  }
-
-  // Start by looking for a single character match
-  // and increase length until no match is found.
-  // Performance analysis: https://neil.fraser.name/news/2010/11/04/
-  var best = 0;
-  var length = 1;
-  while (true) {
-    var pattern = text1.substring(text_length - length);
-    var found = text2.indexOf(pattern);
-    if (found == -1) {
-      return best;
-    }
-    length += found;
-    if (found == 0 || text1.substring(text_length - length) ==
-        text2.substring(0, length)) {
-      best = length;
-      length++;
-    }
-  }
-};
-
-
-/**
- * Do the two texts share a substring which is at least half the length of the
- * longer text?
- * This speedup can produce non-minimal diffs.
- * @param {string} text1 First string.
- * @param {string} text2 Second string.
- * @return {Array.<string>} Five element Array, containing the prefix of
- *     text1, the suffix of text1, the prefix of text2, the suffix of
- *     text2 and the common middle.  Or null if there was no match.
- * @private
- */
-diff_match_patch.prototype.diff_halfMatch_ = function(text1, text2) {
-  if (this.Diff_Timeout <= 0) {
-    // Don't risk returning a non-optimal diff if we have unlimited time.
-    return null;
-  }
-  var longtext = text1.length > text2.length ? text1 : text2;
-  var shorttext = text1.length > text2.length ? text2 : text1;
-  if (longtext.length < 4 || shorttext.length * 2 < longtext.length) {
-    return null;  // Pointless.
-  }
-  var dmp = this;  // 'this' becomes 'window' in a closure.
-
-  /**
-   * Does a substring of shorttext exist within longtext such that the substring
-   * is at least half the length of longtext?
-   * Closure, but does not reference any external variables.
-   * @param {string} longtext Longer string.
-   * @param {string} shorttext Shorter string.
-   * @param {number} i Start index of quarter length substring within longtext.
-   * @return {Array.<string>} Five element Array, containing the prefix of
-   *     longtext, the suffix of longtext, the prefix of shorttext, the suffix
-   *     of shorttext and the common middle.  Or null if there was no match.
-   * @private
-   */
-  function diff_halfMatchI_(longtext, shorttext, i) {
-    // Start with a 1/4 length substring at position i as a seed.
-    var seed = longtext.substring(i, i + Math.floor(longtext.length / 4));
-    var j = -1;
-    var best_common = '';
-    var best_longtext_a, best_longtext_b, best_shorttext_a, best_shorttext_b;
-    while ((j = shorttext.indexOf(seed, j + 1)) != -1) {
-      var prefixLength = dmp.diff_commonPrefix(longtext.substring(i),
-                                               shorttext.substring(j));
-      var suffixLength = dmp.diff_commonSuffix(longtext.substring(0, i),
-                                               shorttext.substring(0, j));
-      if (best_common.length < suffixLength + prefixLength) {
-        best_common = shorttext.substring(j - suffixLength, j) +
-            shorttext.substring(j, j + prefixLength);
-        best_longtext_a = longtext.substring(0, i - suffixLength);
-        best_longtext_b = longtext.substring(i + prefixLength);
-        best_shorttext_a = shorttext.substring(0, j - suffixLength);
-        best_shorttext_b = shorttext.substring(j + prefixLength);
-      }
-    }
-    if (best_common.length * 2 >= longtext.length) {
-      return [best_longtext_a, best_longtext_b,
-              best_shorttext_a, best_shorttext_b, best_common];
-    } else {
-      return null;
-    }
-  }
-
-  // First check if the second quarter is the seed for a half-match.
-  var hm1 = diff_halfMatchI_(longtext, shorttext,
-                             Math.ceil(longtext.length / 4));
-  // Check again based on the third quarter.
-  var hm2 = diff_halfMatchI_(longtext, shorttext,
-                             Math.ceil(longtext.length / 2));
-  var hm;
-  if (!hm1 && !hm2) {
-    return null;
-  } else if (!hm2) {
-    hm = hm1;
-  } else if (!hm1) {
-    hm = hm2;
-  } else {
-    // Both matched.  Select the longest.
-    hm = hm1[4].length > hm2[4].length ? hm1 : hm2;
-  }
-
-  // A half-match was found, sort out the return data.
-  var text1_a, text1_b, text2_a, text2_b;
-  if (text1.length > text2.length) {
-    text1_a = hm[0];
-    text1_b = hm[1];
-    text2_a = hm[2];
-    text2_b = hm[3];
-  } else {
-    text2_a = hm[0];
-    text2_b = hm[1];
-    text1_a = hm[2];
-    text1_b = hm[3];
-  }
-  var mid_common = hm[4];
-  return [text1_a, text1_b, text2_a, text2_b, mid_common];
-};
-
-
-/**
- * Reduce the number of edits by eliminating semantically trivial equalities.
- * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.
- */
-diff_match_patch.prototype.diff_cleanupSemantic = function(diffs) {
-  var changes = false;
-  var equalities = [];  // Stack of indices where equalities are found.
-  var equalitiesLength = 0;  // Keeping our own length var is faster in JS.
-  /** @type {?string} */
-  var lastEquality = null;
-  // Always equal to diffs[equalities[equalitiesLength - 1]][1]
-  var pointer = 0;  // Index of current position.
-  // Number of characters that changed prior to the equality.
-  var length_insertions1 = 0;
-  var length_deletions1 = 0;
-  // Number of characters that changed after the equality.
-  var length_insertions2 = 0;
-  var length_deletions2 = 0;
-  while (pointer < diffs.length) {
-    if (diffs[pointer][0] == DIFF_EQUAL) {  // Equality found.
-      equalities[equalitiesLength++] = pointer;
-      length_insertions1 = length_insertions2;
-      length_deletions1 = length_deletions2;
-      length_insertions2 = 0;
-      length_deletions2 = 0;
-      lastEquality = diffs[pointer][1];
-    } else {  // An insertion or deletion.
-      if (diffs[pointer][0] == DIFF_INSERT) {
-        length_insertions2 += diffs[pointer][1].length;
-      } else {
-        length_deletions2 += diffs[pointer][1].length;
-      }
-      // Eliminate an equality that is smaller or equal to the edits on both
-      // sides of it.
-      if (lastEquality && (lastEquality.length <=
-          Math.max(length_insertions1, length_deletions1)) &&
-          (lastEquality.length <= Math.max(length_insertions2,
-                                           length_deletions2))) {
-        // Duplicate record.
-        diffs.splice(equalities[equalitiesLength - 1], 0,
-                     new diff_match_patch.Diff(DIFF_DELETE, lastEquality));
-        // Change second copy to insert.
-        diffs[equalities[equalitiesLength - 1] + 1][0] = DIFF_INSERT;
-        // Throw away the equality we just deleted.
-        equalitiesLength--;
-        // Throw away the previous equality (it needs to be reevaluated).
-        equalitiesLength--;
-        pointer = equalitiesLength > 0 ? equalities[equalitiesLength - 1] : -1;
-        length_insertions1 = 0;  // Reset the counters.
-        length_deletions1 = 0;
-        length_insertions2 = 0;
-        length_deletions2 = 0;
-        lastEquality = null;
-        changes = true;
-      }
-    }
-    pointer++;
-  }
-
-  // Normalize the diff.
-  if (changes) {
-    this.diff_cleanupMerge(diffs);
-  }
-  this.diff_cleanupSemanticLossless(diffs);
-
-  // Find any overlaps between deletions and insertions.
-  // e.g: <del>abcxxx</del><ins>xxxdef</ins>
-  //   -> <del>abc</del>xxx<ins>def</ins>
-  // e.g: <del>xxxabc</del><ins>defxxx</ins>
-  //   -> <ins>def</ins>xxx<del>abc</del>
-  // Only extract an overlap if it is as big as the edit ahead or behind it.
-  pointer = 1;
-  while (pointer < diffs.length) {
-    if (diffs[pointer - 1][0] == DIFF_DELETE &&
-        diffs[pointer][0] == DIFF_INSERT) {
-      var deletion = diffs[pointer - 1][1];
-      var insertion = diffs[pointer][1];
-      var overlap_length1 = this.diff_commonOverlap_(deletion, insertion);
-      var overlap_length2 = this.diff_commonOverlap_(insertion, deletion);
-      if (overlap_length1 >= overlap_length2) {
-        if (overlap_length1 >= deletion.length / 2 ||
-            overlap_length1 >= insertion.length / 2) {
-          // Overlap found.  Insert an equality and trim the surrounding edits.
-          diffs.splice(pointer, 0, new diff_match_patch.Diff(DIFF_EQUAL,
-              insertion.substring(0, overlap_length1)));
-          diffs[pointer - 1][1] =
-              deletion.substring(0, deletion.length - overlap_length1);
-          diffs[pointer + 1][1] = insertion.substring(overlap_length1);
-          pointer++;
-        }
-      } else {
-        if (overlap_length2 >= deletion.length / 2 ||
-            overlap_length2 >= insertion.length / 2) {
-          // Reverse overlap found.
-          // Insert an equality and swap and trim the surrounding edits.
-          diffs.splice(pointer, 0, new diff_match_patch.Diff(DIFF_EQUAL,
-              deletion.substring(0, overlap_length2)));
-          diffs[pointer - 1][0] = DIFF_INSERT;
-          diffs[pointer - 1][1] =
-              insertion.substring(0, insertion.length - overlap_length2);
-          diffs[pointer + 1][0] = DIFF_DELETE;
-          diffs[pointer + 1][1] =
-              deletion.substring(overlap_length2);
-          pointer++;
-        }
-      }
-      pointer++;
-    }
-    pointer++;
-  }
-};
-
-
-/**
- * Look for single edits surrounded on both sides by equalities
- * which can be shifted sideways to align the edit to a word boundary.
- * e.g: The c<ins>at c</ins>ame. -> The <ins>cat </ins>came.
- * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.
- */
-diff_match_patch.prototype.diff_cleanupSemanticLossless = function(diffs) {
-  /**
-   * Given two strings, compute a score representing whether the internal
-   * boundary falls on logical boundaries.
-   * Scores range from 6 (best) to 0 (worst).
-   * Closure, but does not reference any external variables.
-   * @param {string} one First string.
-   * @param {string} two Second string.
-   * @return {number} The score.
-   * @private
-   */
-  function diff_cleanupSemanticScore_(one, two) {
-    if (!one || !two) {
-      // Edges are the best.
-      return 6;
-    }
-
-    // Each port of this function behaves slightly differently due to
-    // subtle differences in each language's definition of things like
-    // 'whitespace'.  Since this function's purpose is largely cosmetic,
-    // the choice has been made to use each language's native features
-    // rather than force total conformity.
-    var char1 = one.charAt(one.length - 1);
-    var char2 = two.charAt(0);
-    var nonAlphaNumeric1 = char1.match(diff_match_patch.nonAlphaNumericRegex_);
-    var nonAlphaNumeric2 = char2.match(diff_match_patch.nonAlphaNumericRegex_);
-    var whitespace1 = nonAlphaNumeric1 &&
-        char1.match(diff_match_patch.whitespaceRegex_);
-    var whitespace2 = nonAlphaNumeric2 &&
-        char2.match(diff_match_patch.whitespaceRegex_);
-    var lineBreak1 = whitespace1 &&
-        char1.match(diff_match_patch.linebreakRegex_);
-    var lineBreak2 = whitespace2 &&
-        char2.match(diff_match_patch.linebreakRegex_);
-    var blankLine1 = lineBreak1 &&
-        one.match(diff_match_patch.blanklineEndRegex_);
-    var blankLine2 = lineBreak2 &&
-        two.match(diff_match_patch.blanklineStartRegex_);
-
-    if (blankLine1 || blankLine2) {
-      // Five points for blank lines.
-      return 5;
-    } else if (lineBreak1 || lineBreak2) {
-      // Four points for line breaks.
-      return 4;
-    } else if (nonAlphaNumeric1 && !whitespace1 && whitespace2) {
-      // Three points for end of sentences.
-      return 3;
-    } else if (whitespace1 || whitespace2) {
-      // Two points for whitespace.
-      return 2;
-    } else if (nonAlphaNumeric1 || nonAlphaNumeric2) {
-      // One point for non-alphanumeric.
-      return 1;
-    }
-    return 0;
-  }
-
-  var pointer = 1;
-  // Intentionally ignore the first and last element (don't need checking).
-  while (pointer < diffs.length - 1) {
-    if (diffs[pointer - 1][0] == DIFF_EQUAL &&
-        diffs[pointer + 1][0] == DIFF_EQUAL) {
-      // This is a single edit surrounded by equalities.
-      var equality1 = diffs[pointer - 1][1];
-      var edit = diffs[pointer][1];
-      var equality2 = diffs[pointer + 1][1];
-
-      // First, shift the edit as far left as possible.
-      var commonOffset = this.diff_commonSuffix(equality1, edit);
-      if (commonOffset) {
-        var commonString = edit.substring(edit.length - commonOffset);
-        equality1 = equality1.substring(0, equality1.length - commonOffset);
-        edit = commonString + edit.substring(0, edit.length - commonOffset);
-        equality2 = commonString + equality2;
-      }
-
-      // Second, step character by character right, looking for the best fit.
-      var bestEquality1 = equality1;
-      var bestEdit = edit;
-      var bestEquality2 = equality2;
-      var bestScore = diff_cleanupSemanticScore_(equality1, edit) +
-          diff_cleanupSemanticScore_(edit, equality2);
-      while (edit.charAt(0) === equality2.charAt(0)) {
-        equality1 += edit.charAt(0);
-        edit = edit.substring(1) + equality2.charAt(0);
-        equality2 = equality2.substring(1);
-        var score = diff_cleanupSemanticScore_(equality1, edit) +
-            diff_cleanupSemanticScore_(edit, equality2);
-        // The >= encourages trailing rather than leading whitespace on edits.
-        if (score >= bestScore) {
-          bestScore = score;
-          bestEquality1 = equality1;
-          bestEdit = edit;
-          bestEquality2 = equality2;
-        }
-      }
-
-      if (diffs[pointer - 1][1] != bestEquality1) {
-        // We have an improvement, save it back to the diff.
-        if (bestEquality1) {
-          diffs[pointer - 1][1] = bestEquality1;
-        } else {
-          diffs.splice(pointer - 1, 1);
-          pointer--;
-        }
-        diffs[pointer][1] = bestEdit;
-        if (bestEquality2) {
-          diffs[pointer + 1][1] = bestEquality2;
-        } else {
-          diffs.splice(pointer + 1, 1);
-          pointer--;
-        }
-      }
-    }
-    pointer++;
-  }
-};
-
-// Define some regex patterns for matching boundaries.
-diff_match_patch.nonAlphaNumericRegex_ = /[^a-zA-Z0-9]/;
-diff_match_patch.whitespaceRegex_ = /\s/;
-diff_match_patch.linebreakRegex_ = /[\r\n]/;
-diff_match_patch.blanklineEndRegex_ = /\n\r?\n$/;
-diff_match_patch.blanklineStartRegex_ = /^\r?\n\r?\n/;
-
-/**
- * Reduce the number of edits by eliminating operationally trivial equalities.
- * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.
- */
-diff_match_patch.prototype.diff_cleanupEfficiency = function(diffs) {
-  var changes = false;
-  var equalities = [];  // Stack of indices where equalities are found.
-  var equalitiesLength = 0;  // Keeping our own length var is faster in JS.
-  /** @type {?string} */
-  var lastEquality = null;
-  // Always equal to diffs[equalities[equalitiesLength - 1]][1]
-  var pointer = 0;  // Index of current position.
-  // Is there an insertion operation before the last equality.
-  var pre_ins = false;
-  // Is there a deletion operation before the last equality.
-  var pre_del = false;
-  // Is there an insertion operation after the last equality.
-  var post_ins = false;
-  // Is there a deletion operation after the last equality.
-  var post_del = false;
-  while (pointer < diffs.length) {
-    if (diffs[pointer][0] == DIFF_EQUAL) {  // Equality found.
-      if (diffs[pointer][1].length < this.Diff_EditCost &&
-          (post_ins || post_del)) {
-        // Candidate found.
-        equalities[equalitiesLength++] = pointer;
-        pre_ins = post_ins;
-        pre_del = post_del;
-        lastEquality = diffs[pointer][1];
-      } else {
-        // Not a candidate, and can never become one.
-        equalitiesLength = 0;
-        lastEquality = null;
-      }
-      post_ins = post_del = false;
-    } else {  // An insertion or deletion.
-      if (diffs[pointer][0] == DIFF_DELETE) {
-        post_del = true;
-      } else {
-        post_ins = true;
-      }
-      /*
-       * Five types to be split:
-       * <ins>A</ins><del>B</del>XY<ins>C</ins><del>D</del>
-       * <ins>A</ins>X<ins>C</ins><del>D</del>
-       * <ins>A</ins><del>B</del>X<ins>C</ins>
-       * <ins>A</del>X<ins>C</ins><del>D</del>
-       * <ins>A</ins><del>B</del>X<del>C</del>
-       */
-      if (lastEquality && ((pre_ins && pre_del && post_ins && post_del) ||
-                           ((lastEquality.length < this.Diff_EditCost / 2) &&
-                            (pre_ins + pre_del + post_ins + post_del) == 3))) {
-        // Duplicate record.
-        diffs.splice(equalities[equalitiesLength - 1], 0,
-                     new diff_match_patch.Diff(DIFF_DELETE, lastEquality));
-        // Change second copy to insert.
-        diffs[equalities[equalitiesLength - 1] + 1][0] = DIFF_INSERT;
-        equalitiesLength--;  // Throw away the equality we just deleted;
-        lastEquality = null;
-        if (pre_ins && pre_del) {
-          // No changes made which could affect previous entry, keep going.
-          post_ins = post_del = true;
-          equalitiesLength = 0;
-        } else {
-          equalitiesLength--;  // Throw away the previous equality.
-          pointer = equalitiesLength > 0 ?
-              equalities[equalitiesLength - 1] : -1;
-          post_ins = post_del = false;
-        }
-        changes = true;
-      }
-    }
-    pointer++;
-  }
-
-  if (changes) {
-    this.diff_cleanupMerge(diffs);
-  }
-};
-
-
-/**
- * Reorder and merge like edit sections.  Merge equalities.
- * Any edit section can move as long as it doesn't cross an equality.
- * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.
- */
-diff_match_patch.prototype.diff_cleanupMerge = function(diffs) {
-  // Add a dummy entry at the end.
-  diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, ''));
-  var pointer = 0;
-  var count_delete = 0;
-  var count_insert = 0;
-  var text_delete = '';
-  var text_insert = '';
-  var commonlength;
-  while (pointer < diffs.length) {
-    switch (diffs[pointer][0]) {
-      case DIFF_INSERT:
-        count_insert++;
-        text_insert += diffs[pointer][1];
-        pointer++;
-        break;
-      case DIFF_DELETE:
-        count_delete++;
-        text_delete += diffs[pointer][1];
-        pointer++;
-        break;
-      case DIFF_EQUAL:
-        // Upon reaching an equality, check for prior redundancies.
-        if (count_delete + count_insert > 1) {
-          if (count_delete !== 0 && count_insert !== 0) {
-            // Factor out any common prefixies.
-            commonlength = this.diff_commonPrefix(text_insert, text_delete);
-            if (commonlength !== 0) {
-              if ((pointer - count_delete - count_insert) > 0 &&
-                  diffs[pointer - count_delete - count_insert - 1][0] ==
-                  DIFF_EQUAL) {
-                diffs[pointer - count_delete - count_insert - 1][1] +=
-                    text_insert.substring(0, commonlength);
-              } else {
-                diffs.splice(0, 0, new diff_match_patch.Diff(DIFF_EQUAL,
-                    text_insert.substring(0, commonlength)));
-                pointer++;
-              }
-              text_insert = text_insert.substring(commonlength);
-              text_delete = text_delete.substring(commonlength);
-            }
-            // Factor out any common suffixies.
-            commonlength = this.diff_commonSuffix(text_insert, text_delete);
-            if (commonlength !== 0) {
-              diffs[pointer][1] = text_insert.substring(text_insert.length -
-                  commonlength) + diffs[pointer][1];
-              text_insert = text_insert.substring(0, text_insert.length -
-                  commonlength);
-              text_delete = text_delete.substring(0, text_delete.length -
-                  commonlength);
-            }
-          }
-          // Delete the offending records and add the merged ones.
-          pointer -= count_delete + count_insert;
-          diffs.splice(pointer, count_delete + count_insert);
-          if (text_delete.length) {
-            diffs.splice(pointer, 0,
-                new diff_match_patch.Diff(DIFF_DELETE, text_delete));
-            pointer++;
-          }
-          if (text_insert.length) {
-            diffs.splice(pointer, 0,
-                new diff_match_patch.Diff(DIFF_INSERT, text_insert));
-            pointer++;
-          }
-          pointer++;
-        } else if (pointer !== 0 && diffs[pointer - 1][0] == DIFF_EQUAL) {
-          // Merge this equality with the previous one.
-          diffs[pointer - 1][1] += diffs[pointer][1];
-          diffs.splice(pointer, 1);
-        } else {
-          pointer++;
-        }
-        count_insert = 0;
-        count_delete = 0;
-        text_delete = '';
-        text_insert = '';
-        break;
-    }
-  }
-  if (diffs[diffs.length - 1][1] === '') {
-    diffs.pop();  // Remove the dummy entry at the end.
-  }
-
-  // Second pass: look for single edits surrounded on both sides by equalities
-  // which can be shifted sideways to eliminate an equality.
-  // e.g: A<ins>BA</ins>C -> <ins>AB</ins>AC
-  var changes = false;
-  pointer = 1;
-  // Intentionally ignore the first and last element (don't need checking).
-  while (pointer < diffs.length - 1) {
-    if (diffs[pointer - 1][0] == DIFF_EQUAL &&
-        diffs[pointer + 1][0] == DIFF_EQUAL) {
-      // This is a single edit surrounded by equalities.
-      if (diffs[pointer][1].substring(diffs[pointer][1].length -
-          diffs[pointer - 1][1].length) == diffs[pointer - 1][1]) {
-        // Shift the edit over the previous equality.
-        diffs[pointer][1] = diffs[pointer - 1][1] +
-            diffs[pointer][1].substring(0, diffs[pointer][1].length -
-                                        diffs[pointer - 1][1].length);
-        diffs[pointer + 1][1] = diffs[pointer - 1][1] + diffs[pointer + 1][1];
-        diffs.splice(pointer - 1, 1);
-        changes = true;
-      } else if (diffs[pointer][1].substring(0, diffs[pointer + 1][1].length) ==
-          diffs[pointer + 1][1]) {
-        // Shift the edit over the next equality.
-        diffs[pointer - 1][1] += diffs[pointer + 1][1];
-        diffs[pointer][1] =
-            diffs[pointer][1].substring(diffs[pointer + 1][1].length) +
-            diffs[pointer + 1][1];
-        diffs.splice(pointer + 1, 1);
-        changes = true;
-      }
-    }
-    pointer++;
-  }
-  // If shifts were made, the diff needs reordering and another shift sweep.
-  if (changes) {
-    this.diff_cleanupMerge(diffs);
-  }
-};
-
-
-/**
- * loc is a location in text1, compute and return the equivalent location in
- * text2.
- * e.g. 'The cat' vs 'The big cat', 1->1, 5->8
- * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.
- * @param {number} loc Location within text1.
- * @return {number} Location within text2.
- */
-diff_match_patch.prototype.diff_xIndex = function(diffs, loc) {
-  var chars1 = 0;
-  var chars2 = 0;
-  var last_chars1 = 0;
-  var last_chars2 = 0;
-  var x;
-  for (x = 0; x < diffs.length; x++) {
-    if (diffs[x][0] !== DIFF_INSERT) {  // Equality or deletion.
-      chars1 += diffs[x][1].length;
-    }
-    if (diffs[x][0] !== DIFF_DELETE) {  // Equality or insertion.
-      chars2 += diffs[x][1].length;
-    }
-    if (chars1 > loc) {  // Overshot the location.
-      break;
-    }
-    last_chars1 = chars1;
-    last_chars2 = chars2;
-  }
-  // Was the location was deleted?
-  if (diffs.length != x && diffs[x][0] === DIFF_DELETE) {
-    return last_chars2;
-  }
-  // Add the remaining character length.
-  return last_chars2 + (loc - last_chars1);
-};
-
-
-/**
- * Convert a diff array into a pretty HTML report.
- * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.
- * @return {string} HTML representation.
- */
-diff_match_patch.prototype.diff_prettyHtml = function(diffs) {
-  var html = [];
-  var pattern_amp = /&/g;
-  var pattern_lt = /</g;
-  var pattern_gt = />/g;
-  var pattern_para = /\n/g;
-  for (var x = 0; x < diffs.length; x++) {
-    var op = diffs[x][0];    // Operation (insert, delete, equal)
-    var data = diffs[x][1];  // Text of change.
-    var text = data.replace(pattern_amp, '&amp;').replace(pattern_lt, '&lt;')
-        .replace(pattern_gt, '&gt;').replace(pattern_para, '&para;<br>');
-    switch (op) {
-      case DIFF_INSERT:
-        html[x] = '<ins style="background:#e6ffe6;">' + text + '</ins>';
-        break;
-      case DIFF_DELETE:
-        html[x] = '<del style="background:#ffe6e6;">' + text + '</del>';
-        break;
-      case DIFF_EQUAL:
-        html[x] = '<span>' + text + '</span>';
-        break;
-    }
-  }
-  return html.join('');
-};
-
-
-/**
- * Compute and return the source text (all equalities and deletions).
- * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.
- * @return {string} Source text.
- */
-diff_match_patch.prototype.diff_text1 = function(diffs) {
-  var text = [];
-  for (var x = 0; x < diffs.length; x++) {
-    if (diffs[x][0] !== DIFF_INSERT) {
-      text[x] = diffs[x][1];
-    }
-  }
-  return text.join('');
-};
-
-
-/**
- * Compute and return the destination text (all equalities and insertions).
- * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.
- * @return {string} Destination text.
- */
-diff_match_patch.prototype.diff_text2 = function(diffs) {
-  var text = [];
-  for (var x = 0; x < diffs.length; x++) {
-    if (diffs[x][0] !== DIFF_DELETE) {
-      text[x] = diffs[x][1];
-    }
-  }
-  return text.join('');
-};
-
-
-/**
- * Compute the Levenshtein distance; the number of inserted, deleted or
- * substituted characters.
- * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.
- * @return {number} Number of changes.
- */
-diff_match_patch.prototype.diff_levenshtein = function(diffs) {
-  var levenshtein = 0;
-  var insertions = 0;
-  var deletions = 0;
-  for (var x = 0; x < diffs.length; x++) {
-    var op = diffs[x][0];
-    var data = diffs[x][1];
-    switch (op) {
-      case DIFF_INSERT:
-        insertions += data.length;
-        break;
-      case DIFF_DELETE:
-        deletions += data.length;
-        break;
-      case DIFF_EQUAL:
-        // A deletion and an insertion is one substitution.
-        levenshtein += Math.max(insertions, deletions);
-        insertions = 0;
-        deletions = 0;
-        break;
-    }
-  }
-  levenshtein += Math.max(insertions, deletions);
-  return levenshtein;
-};
-
-
-/**
- * Crush the diff into an encoded string which describes the operations
- * required to transform text1 into text2.
- * E.g. =3\t-2\t+ing  -> Keep 3 chars, delete 2 chars, insert 'ing'.
- * Operations are tab-separated.  Inserted text is escaped using %xx notation.
- * @param {!Array.<!diff_match_patch.Diff>} diffs Array of diff tuples.
- * @return {string} Delta text.
- */
-diff_match_patch.prototype.diff_toDelta = function(diffs) {
-  var text = [];
-  for (var x = 0; x < diffs.length; x++) {
-    switch (diffs[x][0]) {
-      case DIFF_INSERT:
-        text[x] = '+' + encodeURI(diffs[x][1]);
-        break;
-      case DIFF_DELETE:
-        text[x] = '-' + diffs[x][1].length;
-        break;
-      case DIFF_EQUAL:
-        text[x] = '=' + diffs[x][1].length;
-        break;
-    }
-  }
-  return text.join('\t').replace(/%20/g, ' ');
-};
-
-
-/**
- * Given the original text1, and an encoded string which describes the
- * operations required to transform text1 into text2, compute the full diff.
- * @param {string} text1 Source string for the diff.
- * @param {string} delta Delta text.
- * @return {!Array.<!diff_match_patch.Diff>} Array of diff tuples.
- * @throws {!Error} If invalid input.
- */
-diff_match_patch.prototype.diff_fromDelta = function(text1, delta) {
-  var diffs = [];
-  var diffsLength = 0;  // Keeping our own length var is faster in JS.
-  var pointer = 0;  // Cursor in text1
-  var tokens = delta.split(/\t/g);
-  for (var x = 0; x < tokens.length; x++) {
-    // Each token begins with a one character parameter which specifies the
-    // operation of this token (delete, insert, equality).
-    var param = tokens[x].substring(1);
-    switch (tokens[x].charAt(0)) {
-      case '+':
-        try {
-          diffs[diffsLength++] =
-              new diff_match_patch.Diff(DIFF_INSERT, decodeURI(param));
-        } catch (ex) {
-          // Malformed URI sequence.
-          throw new Error('Illegal escape in diff_fromDelta: ' + param);
-        }
-        break;
-      case '-':
-        // Fall through.
-      case '=':
-        var n = parseInt(param, 10);
-        if (isNaN(n) || n < 0) {
-          throw new Error('Invalid number in diff_fromDelta: ' + param);
-        }
-        var text = text1.substring(pointer, pointer += n);
-        if (tokens[x].charAt(0) == '=') {
-          diffs[diffsLength++] = new diff_match_patch.Diff(DIFF_EQUAL, text);
-        } else {
-          diffs[diffsLength++] = new diff_match_patch.Diff(DIFF_DELETE, text);
-        }
-        break;
-      default:
-        // Blank tokens are ok (from a trailing \t).
-        // Anything else is an error.
-        if (tokens[x]) {
-          throw new Error('Invalid diff operation in diff_fromDelta: ' +
-                          tokens[x]);
-        }
-    }
-  }
-  if (pointer != text1.length) {
-    throw new Error('Delta length (' + pointer +
-        ') does not equal source text length (' + text1.length + ').');
-  }
-  return diffs;
-};
-
-
-//  MATCH FUNCTIONS
-
-
-/**
- * Locate the best instance of 'pattern' in 'text' near 'loc'.
- * @param {string} text The text to search.
- * @param {string} pattern The pattern to search for.
- * @param {number} loc The location to search around.
- * @return {number} Best match index or -1.
- */
-diff_match_patch.prototype.match_main = function(text, pattern, loc) {
-  // Check for null inputs.
-  if (text == null || pattern == null || loc == null) {
-    throw new Error('Null input. (match_main)');
-  }
-
-  loc = Math.max(0, Math.min(loc, text.length));
-  if (text == pattern) {
-    // Shortcut (potentially not guaranteed by the algorithm)
-    return 0;
-  } else if (!text.length) {
-    // Nothing to match.
-    return -1;
-  } else if (text.substring(loc, loc + pattern.length) == pattern) {
-    // Perfect match at the perfect spot!  (Includes case of null pattern)
-    return loc;
-  } else {
-    // Do a fuzzy compare.
-    return this.match_bitap_(text, pattern, loc);
-  }
-};
-
-
-/**
- * Locate the best instance of 'pattern' in 'text' near 'loc' using the
- * Bitap algorithm.
- * @param {string} text The text to search.
- * @param {string} pattern The pattern to search for.
- * @param {number} loc The location to search around.
- * @return {number} Best match index or -1.
- * @private
- */
-diff_match_patch.prototype.match_bitap_ = function(text, pattern, loc) {
-  if (pattern.length > this.Match_MaxBits) {
-    throw new Error('Pattern too long for this browser.');
-  }
-
-  // Initialise the alphabet.
-  var s = this.match_alphabet_(pattern);
-
-  var dmp = this;  // 'this' becomes 'window' in a closure.
-
-  /**
-   * Compute and return the score for a match with e errors and x location.
-   * Accesses loc and pattern through being a closure.
-   * @param {number} e Number of errors in match.
-   * @param {number} x Location of match.
-   * @return {number} Overall score for match (0.0 = good, 1.0 = bad).
-   * @private
-   */
-  function match_bitapScore_(e, x) {
-    var accuracy = e / pattern.length;
-    var proximity = Math.abs(loc - x);
-    if (!dmp.Match_Distance) {
-      // Dodge divide by zero error.
-      return proximity ? 1.0 : accuracy;
-    }
-    return accuracy + (proximity / dmp.Match_Distance);
-  }
-
-  // Highest score beyond which we give up.
-  var score_threshold = this.Match_Threshold;
-  // Is there a nearby exact match? (speedup)
-  var best_loc = text.indexOf(pattern, loc);
-  if (best_loc != -1) {
-    score_threshold = Math.min(match_bitapScore_(0, best_loc), score_threshold);
-    // What about in the other direction? (speedup)
-    best_loc = text.lastIndexOf(pattern, loc + pattern.length);
-    if (best_loc != -1) {
-      score_threshold =
-          Math.min(match_bitapScore_(0, best_loc), score_threshold);
-    }
-  }
-
-  // Initialise the bit arrays.
-  var matchmask = 1 << (pattern.length - 1);
-  best_loc = -1;
-
-  var bin_min, bin_mid;
-  var bin_max = pattern.length + text.length;
-  var last_rd;
-  for (var d = 0; d < pattern.length; d++) {
-    // Scan for the best match; each iteration allows for one more error.
-    // Run a binary search to determine how far from 'loc' we can stray at this
-    // error level.
-    bin_min = 0;
-    bin_mid = bin_max;
-    while (bin_min < bin_mid) {
-      if (match_bitapScore_(d, loc + bin_mid) <= score_threshold) {
-        bin_min = bin_mid;
-      } else {
-        bin_max = bin_mid;
-      }
-      bin_mid = Math.floor((bin_max - bin_min) / 2 + bin_min);
-    }
-    // Use the result from this iteration as the maximum for the next.
-    bin_max = bin_mid;
-    var start = Math.max(1, loc - bin_mid + 1);
-    var finish = Math.min(loc + bin_mid, text.length) + pattern.length;
-
-    var rd = Array(finish + 2);
-    rd[finish + 1] = (1 << d) - 1;
-    for (var j = finish; j >= start; j--) {
-      // The alphabet (s) is a sparse hash, so the following line generates
-      // warnings.
-      var charMatch = s[text.charAt(j - 1)];
-      if (d === 0) {  // First pass: exact match.
-        rd[j] = ((rd[j + 1] << 1) | 1) & charMatch;
-      } else {  // Subsequent passes: fuzzy match.
-        rd[j] = (((rd[j + 1] << 1) | 1) & charMatch) |
-                (((last_rd[j + 1] | last_rd[j]) << 1) | 1) |
-                last_rd[j + 1];
-      }
-      if (rd[j] & matchmask) {
-        var score = match_bitapScore_(d, j - 1);
-        // This match will almost certainly be better than any existing match.
-        // But check anyway.
-        if (score <= score_threshold) {
-          // Told you so.
-          score_threshold = score;
-          best_loc = j - 1;
-          if (best_loc > loc) {
-            // When passing loc, don't exceed our current distance from loc.
-            start = Math.max(1, 2 * loc - best_loc);
-          } else {
-            // Already passed loc, downhill from here on in.
-            break;
-          }
-        }
-      }
-    }
-    // No hope for a (better) match at greater error levels.
-    if (match_bitapScore_(d + 1, loc) > score_threshold) {
-      break;
-    }
-    last_rd = rd;
-  }
-  return best_loc;
-};
-
-
-/**
- * Initialise the alphabet for the Bitap algorithm.
- * @param {string} pattern The text to encode.
- * @return {!Object} Hash of character locations.
- * @private
- */
-diff_match_patch.prototype.match_alphabet_ = function(pattern) {
-  var s = {};
-  for (var i = 0; i < pattern.length; i++) {
-    s[pattern.charAt(i)] = 0;
-  }
-  for (var i = 0; i < pattern.length; i++) {
-    s[pattern.charAt(i)] |= 1 << (pattern.length - i - 1);
-  }
-  return s;
-};
-
-
-//  PATCH FUNCTIONS
-
-
-/**
- * Increase the context until it is unique,
- * but don't let the pattern expand beyond Match_MaxBits.
- * @param {!diff_match_patch.patch_obj} patch The patch to grow.
- * @param {string} text Source text.
- * @private
- */
-diff_match_patch.prototype.patch_addContext_ = function(patch, text) {
-  if (text.length == 0) {
-    return;
-  }
-  if (patch.start2 === null) {
-    throw Error('patch not initialized');
-  }
-  var pattern = text.substring(patch.start2, patch.start2 + patch.length1);
-  var padding = 0;
-
-  // Look for the first and last matches of pattern in text.  If two different
-  // matches are found, increase the pattern length.
-  while (text.indexOf(pattern) != text.lastIndexOf(pattern) &&
-         pattern.length < this.Match_MaxBits - this.Patch_Margin -
-         this.Patch_Margin) {
-    padding += this.Patch_Margin;
-    pattern = text.substring(patch.start2 - padding,
-                             patch.start2 + patch.length1 + padding);
-  }
-  // Add one chunk for good luck.
-  padding += this.Patch_Margin;
-
-  // Add the prefix.
-  var prefix = text.substring(patch.start2 - padding, patch.start2);
-  if (prefix) {
-    patch.diffs.unshift(new diff_match_patch.Diff(DIFF_EQUAL, prefix));
-  }
-  // Add the suffix.
-  var suffix = text.substring(patch.start2 + patch.length1,
-                              patch.start2 + patch.length1 + padding);
-  if (suffix) {
-    patch.diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, suffix));
-  }
-
-  // Roll back the start points.
-  patch.start1 -= prefix.length;
-  patch.start2 -= prefix.length;
-  // Extend the lengths.
-  patch.length1 += prefix.length + suffix.length;
-  patch.length2 += prefix.length + suffix.length;
-};
-
-
-/**
- * Compute a list of patches to turn text1 into text2.
- * Use diffs if provided, otherwise compute it ourselves.
- * There are four ways to call this function, depending on what data is
- * available to the caller:
- * Method 1:
- * a = text1, b = text2
- * Method 2:
- * a = diffs
- * Method 3 (optimal):
- * a = text1, b = diffs
- * Method 4 (deprecated, use method 3):
- * a = text1, b = text2, c = diffs
- *
- * @param {string|!Array.<!diff_match_patch.Diff>} a text1 (methods 1,3,4) or
- * Array of diff tuples for text1 to text2 (method 2).
- * @param {string|!Array.<!diff_match_patch.Diff>=} opt_b text2 (methods 1,4) or
- * Array of diff tuples for text1 to text2 (method 3) or undefined (method 2).
- * @param {string|!Array.<!diff_match_patch.Diff>=} opt_c Array of diff tuples
- * for text1 to text2 (method 4) or undefined (methods 1,2,3).
- * @return {!Array.<!diff_match_patch.patch_obj>} Array of Patch objects.
- */
-diff_match_patch.prototype.patch_make = function(a, opt_b, opt_c) {
-  var text1, diffs;
-  if (typeof a == 'string' && typeof opt_b == 'string' &&
-      typeof opt_c == 'undefined') {
-    // Method 1: text1, text2
-    // Compute diffs from text1 and text2.
-    text1 = /** @type {string} */(a);
-    diffs = this.diff_main(text1, /** @type {string} */(opt_b), true);
-    if (diffs.length > 2) {
-      this.diff_cleanupSemantic(diffs);
-      this.diff_cleanupEfficiency(diffs);
-    }
-  } else if (a && typeof a == 'object' && typeof opt_b == 'undefined' &&
-      typeof opt_c == 'undefined') {
-    // Method 2: diffs
-    // Compute text1 from diffs.
-    diffs = /** @type {!Array.<!diff_match_patch.Diff>} */(a);
-    text1 = this.diff_text1(diffs);
-  } else if (typeof a == 'string' && opt_b && typeof opt_b == 'object' &&
-      typeof opt_c == 'undefined') {
-    // Method 3: text1, diffs
-    text1 = /** @type {string} */(a);
-    diffs = /** @type {!Array.<!diff_match_patch.Diff>} */(opt_b);
-  } else if (typeof a == 'string' && typeof opt_b == 'string' &&
-      opt_c && typeof opt_c == 'object') {
-    // Method 4: text1, text2, diffs
-    // text2 is not used.
-    text1 = /** @type {string} */(a);
-    diffs = /** @type {!Array.<!diff_match_patch.Diff>} */(opt_c);
-  } else {
-    throw new Error('Unknown call format to patch_make.');
-  }
-
-  if (diffs.length === 0) {
-    return [];  // Get rid of the null case.
-  }
-  var patches = [];
-  var patch = new diff_match_patch.patch_obj();
-  var patchDiffLength = 0;  // Keeping our own length var is faster in JS.
-  var char_count1 = 0;  // Number of characters into the text1 string.
-  var char_count2 = 0;  // Number of characters into the text2 string.
-  // Start with text1 (prepatch_text) and apply the diffs until we arrive at
-  // text2 (postpatch_text).  We recreate the patches one by one to determine
-  // context info.
-  var prepatch_text = text1;
-  var postpatch_text = text1;
-  for (var x = 0; x < diffs.length; x++) {
-    var diff_type = diffs[x][0];
-    var diff_text = diffs[x][1];
-
-    if (!patchDiffLength && diff_type !== DIFF_EQUAL) {
-      // A new patch starts here.
-      patch.start1 = char_count1;
-      patch.start2 = char_count2;
-    }
-
-    switch (diff_type) {
-      case DIFF_INSERT:
-        patch.diffs[patchDiffLength++] = diffs[x];
-        patch.length2 += diff_text.length;
-        postpatch_text = postpatch_text.substring(0, char_count2) + diff_text +
-                         postpatch_text.substring(char_count2);
-        break;
-      case DIFF_DELETE:
-        patch.length1 += diff_text.length;
-        patch.diffs[patchDiffLength++] = diffs[x];
-        postpatch_text = postpatch_text.substring(0, char_count2) +
-                         postpatch_text.substring(char_count2 +
-                             diff_text.length);
-        break;
-      case DIFF_EQUAL:
-        if (diff_text.length <= 2 * this.Patch_Margin &&
-            patchDiffLength && diffs.length != x + 1) {
-          // Small equality inside a patch.
-          patch.diffs[patchDiffLength++] = diffs[x];
-          patch.length1 += diff_text.length;
-          patch.length2 += diff_text.length;
-        } else if (diff_text.length >= 2 * this.Patch_Margin) {
-          // Time for a new patch.
-          if (patchDiffLength) {
-            this.patch_addContext_(patch, prepatch_text);
-            patches.push(patch);
-            patch = new diff_match_patch.patch_obj();
-            patchDiffLength = 0;
-            // Unlike Unidiff, our patch lists have a rolling context.
-            // https://github.com/google/diff-match-patch/wiki/Unidiff
-            // Update prepatch text & pos to reflect the application of the
-            // just completed patch.
-            prepatch_text = postpatch_text;
-            char_count1 = char_count2;
-          }
-        }
-        break;
-    }
-
-    // Update the current character count.
-    if (diff_type !== DIFF_INSERT) {
-      char_count1 += diff_text.length;
-    }
-    if (diff_type !== DIFF_DELETE) {
-      char_count2 += diff_text.length;
-    }
-  }
-  // Pick up the leftover patch if not empty.
-  if (patchDiffLength) {
-    this.patch_addContext_(patch, prepatch_text);
-    patches.push(patch);
-  }
-
-  return patches;
-};
-
-
-/**
- * Given an array of patches, return another array that is identical.
- * @param {!Array.<!diff_match_patch.patch_obj>} patches Array of Patch objects.
- * @return {!Array.<!diff_match_patch.patch_obj>} Array of Patch objects.
- */
-diff_match_patch.prototype.patch_deepCopy = function(patches) {
-  // Making deep copies is hard in JavaScript.
-  var patchesCopy = [];
-  for (var x = 0; x < patches.length; x++) {
-    var patch = patches[x];
-    var patchCopy = new diff_match_patch.patch_obj();
-    patchCopy.diffs = [];
-    for (var y = 0; y < patch.diffs.length; y++) {
-      patchCopy.diffs[y] =
-          new diff_match_patch.Diff(patch.diffs[y][0], patch.diffs[y][1]);
-    }
-    patchCopy.start1 = patch.start1;
-    patchCopy.start2 = patch.start2;
-    patchCopy.length1 = patch.length1;
-    patchCopy.length2 = patch.length2;
-    patchesCopy[x] = patchCopy;
-  }
-  return patchesCopy;
-};
-
-
-/**
- * Merge a set of patches onto the text.  Return a patched text, as well
- * as a list of true/false values indicating which patches were applied.
- * @param {!Array.<!diff_match_patch.patch_obj>} patches Array of Patch objects.
- * @param {string} text Old text.
- * @return {!Array.<string|!Array.<boolean>>} Two element Array, containing the
- *      new text and an array of boolean values.
- */
-diff_match_patch.prototype.patch_apply = function(patches, text) {
-  if (patches.length == 0) {
-    return [text, []];
-  }
-
-  // Deep copy the patches so that no changes are made to originals.
-  patches = this.patch_deepCopy(patches);
-
-  var nullPadding = this.patch_addPadding(patches);
-  text = nullPadding + text + nullPadding;
-
-  this.patch_splitMax(patches);
-  // delta keeps track of the offset between the expected and actual location
-  // of the previous patch.  If there are patches expected at positions 10 and
-  // 20, but the first patch was found at 12, delta is 2 and the second patch
-  // has an effective expected position of 22.
-  var delta = 0;
-  var results = [];
-  for (var x = 0; x < patches.length; x++) {
-    var expected_loc = patches[x].start2 + delta;
-    var text1 = this.diff_text1(patches[x].diffs);
-    var start_loc;
-    var end_loc = -1;
-    if (text1.length > this.Match_MaxBits) {
-      // patch_splitMax will only provide an oversized pattern in the case of
-      // a monster delete.
-      start_loc = this.match_main(text, text1.substring(0, this.Match_MaxBits),
-                                  expected_loc);
-      if (start_loc != -1) {
-        end_loc = this.match_main(text,
-            text1.substring(text1.length - this.Match_MaxBits),
-            expected_loc + text1.length - this.Match_MaxBits);
-        if (end_loc == -1 || start_loc >= end_loc) {
-          // Can't find valid trailing context.  Drop this patch.
-          start_loc = -1;
-        }
-      }
-    } else {
-      start_loc = this.match_main(text, text1, expected_loc);
-    }
-    if (start_loc == -1) {
-      // No match found.  :(
-      results[x] = false;
-      // Subtract the delta for this failed patch from subsequent patches.
-      delta -= patches[x].length2 - patches[x].length1;
-    } else {
-      // Found a match.  :)
-      results[x] = true;
-      delta = start_loc - expected_loc;
-      var text2;
-      if (end_loc == -1) {
-        text2 = text.substring(start_loc, start_loc + text1.length);
-      } else {
-        text2 = text.substring(start_loc, end_loc + this.Match_MaxBits);
-      }
-      if (text1 == text2) {
-        // Perfect match, just shove the replacement text in.
-        text = text.substring(0, start_loc) +
-               this.diff_text2(patches[x].diffs) +
-               text.substring(start_loc + text1.length);
-      } else {
-        // Imperfect match.  Run a diff to get a framework of equivalent
-        // indices.
-        var diffs = this.diff_main(text1, text2, false);
-        if (text1.length > this.Match_MaxBits &&
-            this.diff_levenshtein(diffs) / text1.length >
-            this.Patch_DeleteThreshold) {
-          // The end points match, but the content is unacceptably bad.
-          results[x] = false;
-        } else {
-          this.diff_cleanupSemanticLossless(diffs);
-          var index1 = 0;
-          var index2;
-          for (var y = 0; y < patches[x].diffs.length; y++) {
-            var mod = patches[x].diffs[y];
-            if (mod[0] !== DIFF_EQUAL) {
-              index2 = this.diff_xIndex(diffs, index1);
-            }
-            if (mod[0] === DIFF_INSERT) {  // Insertion
-              text = text.substring(0, start_loc + index2) + mod[1] +
-                     text.substring(start_loc + index2);
-            } else if (mod[0] === DIFF_DELETE) {  // Deletion
-              text = text.substring(0, start_loc + index2) +
-                     text.substring(start_loc + this.diff_xIndex(diffs,
-                         index1 + mod[1].length));
-            }
-            if (mod[0] !== DIFF_DELETE) {
-              index1 += mod[1].length;
-            }
-          }
-        }
-      }
-    }
-  }
-  // Strip the padding off.
-  text = text.substring(nullPadding.length, text.length - nullPadding.length);
-  return [text, results];
-};
-
-
-/**
- * Add some padding on text start and end so that edges can match something.
- * Intended to be called only from within patch_apply.
- * @param {!Array.<!diff_match_patch.patch_obj>} patches Array of Patch objects.
- * @return {string} The padding string added to each side.
- */
-diff_match_patch.prototype.patch_addPadding = function(patches) {
-  var paddingLength = this.Patch_Margin;
-  var nullPadding = '';
-  for (var x = 1; x <= paddingLength; x++) {
-    nullPadding += String.fromCharCode(x);
-  }
-
-  // Bump all the patches forward.
-  for (var x = 0; x < patches.length; x++) {
-    patches[x].start1 += paddingLength;
-    patches[x].start2 += paddingLength;
-  }
-
-  // Add some padding on start of first diff.
-  var patch = patches[0];
-  var diffs = patch.diffs;
-  if (diffs.length == 0 || diffs[0][0] != DIFF_EQUAL) {
-    // Add nullPadding equality.
-    diffs.unshift(new diff_match_patch.Diff(DIFF_EQUAL, nullPadding));
-    patch.start1 -= paddingLength;  // Should be 0.
-    patch.start2 -= paddingLength;  // Should be 0.
-    patch.length1 += paddingLength;
-    patch.length2 += paddingLength;
-  } else if (paddingLength > diffs[0][1].length) {
-    // Grow first equality.
-    var extraLength = paddingLength - diffs[0][1].length;
-    diffs[0][1] = nullPadding.substring(diffs[0][1].length) + diffs[0][1];
-    patch.start1 -= extraLength;
-    patch.start2 -= extraLength;
-    patch.length1 += extraLength;
-    patch.length2 += extraLength;
-  }
-
-  // Add some padding on end of last diff.
-  patch = patches[patches.length - 1];
-  diffs = patch.diffs;
-  if (diffs.length == 0 || diffs[diffs.length - 1][0] != DIFF_EQUAL) {
-    // Add nullPadding equality.
-    diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, nullPadding));
-    patch.length1 += paddingLength;
-    patch.length2 += paddingLength;
-  } else if (paddingLength > diffs[diffs.length - 1][1].length) {
-    // Grow last equality.
-    var extraLength = paddingLength - diffs[diffs.length - 1][1].length;
-    diffs[diffs.length - 1][1] += nullPadding.substring(0, extraLength);
-    patch.length1 += extraLength;
-    patch.length2 += extraLength;
-  }
-
-  return nullPadding;
-};
-
-
-/**
- * Look through the patches and break up any which are longer than the maximum
- * limit of the match algorithm.
- * Intended to be called only from within patch_apply.
- * @param {!Array.<!diff_match_patch.patch_obj>} patches Array of Patch objects.
- */
-diff_match_patch.prototype.patch_splitMax = function(patches) {
-  var patch_size = this.Match_MaxBits;
-  for (var x = 0; x < patches.length; x++) {
-    if (patches[x].length1 <= patch_size) {
-      continue;
-    }
-    var bigpatch = patches[x];
-    // Remove the big old patch.
-    patches.splice(x--, 1);
-    var start1 = bigpatch.start1;
-    var start2 = bigpatch.start2;
-    var precontext = '';
-    while (bigpatch.diffs.length !== 0) {
-      // Create one of several smaller patches.
-      var patch = new diff_match_patch.patch_obj();
-      var empty = true;
-      patch.start1 = start1 - precontext.length;
-      patch.start2 = start2 - precontext.length;
-      if (precontext !== '') {
-        patch.length1 = patch.length2 = precontext.length;
-        patch.diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, precontext));
-      }
-      while (bigpatch.diffs.length !== 0 &&
-             patch.length1 < patch_size - this.Patch_Margin) {
-        var diff_type = bigpatch.diffs[0][0];
-        var diff_text = bigpatch.diffs[0][1];
-        if (diff_type === DIFF_INSERT) {
-          // Insertions are harmless.
-          patch.length2 += diff_text.length;
-          start2 += diff_text.length;
-          patch.diffs.push(bigpatch.diffs.shift());
-          empty = false;
-        } else if (diff_type === DIFF_DELETE && patch.diffs.length == 1 &&
-                   patch.diffs[0][0] == DIFF_EQUAL &&
-                   diff_text.length > 2 * patch_size) {
-          // This is a large deletion.  Let it pass in one chunk.
-          patch.length1 += diff_text.length;
-          start1 += diff_text.length;
-          empty = false;
-          patch.diffs.push(new diff_match_patch.Diff(diff_type, diff_text));
-          bigpatch.diffs.shift();
-        } else {
-          // Deletion or equality.  Only take as much as we can stomach.
-          diff_text = diff_text.substring(0,
-              patch_size - patch.length1 - this.Patch_Margin);
-          patch.length1 += diff_text.length;
-          start1 += diff_text.length;
-          if (diff_type === DIFF_EQUAL) {
-            patch.length2 += diff_text.length;
-            start2 += diff_text.length;
-          } else {
-            empty = false;
-          }
-          patch.diffs.push(new diff_match_patch.Diff(diff_type, diff_text));
-          if (diff_text == bigpatch.diffs[0][1]) {
-            bigpatch.diffs.shift();
-          } else {
-            bigpatch.diffs[0][1] =
-                bigpatch.diffs[0][1].substring(diff_text.length);
-          }
-        }
-      }
-      // Compute the head context for the next patch.
-      precontext = this.diff_text2(patch.diffs);
-      precontext =
-          precontext.substring(precontext.length - this.Patch_Margin);
-      // Append the end context for this patch.
-      var postcontext = this.diff_text1(bigpatch.diffs)
-                            .substring(0, this.Patch_Margin);
-      if (postcontext !== '') {
-        patch.length1 += postcontext.length;
-        patch.length2 += postcontext.length;
-        if (patch.diffs.length !== 0 &&
-            patch.diffs[patch.diffs.length - 1][0] === DIFF_EQUAL) {
-          patch.diffs[patch.diffs.length - 1][1] += postcontext;
-        } else {
-          patch.diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, postcontext));
-        }
-      }
-      if (!empty) {
-        patches.splice(++x, 0, patch);
-      }
-    }
-  }
-};
-
-
-/**
- * Take a list of patches and return a textual representation.
- * @param {!Array.<!diff_match_patch.patch_obj>} patches Array of Patch objects.
- * @return {string} Text representation of patches.
- */
-diff_match_patch.prototype.patch_toText = function(patches) {
-  var text = [];
-  for (var x = 0; x < patches.length; x++) {
-    text[x] = patches[x];
-  }
-  return text.join('');
-};
-
-
-/**
- * Parse a textual representation of patches and return a list of Patch objects.
- * @param {string} textline Text representation of patches.
- * @return {!Array.<!diff_match_patch.patch_obj>} Array of Patch objects.
- * @throws {!Error} If invalid input.
- */
-diff_match_patch.prototype.patch_fromText = function(textline) {
-  var patches = [];
-  if (!textline) {
-    return patches;
-  }
-  var text = textline.split('\n');
-  var textPointer = 0;
-  var patchHeader = /^@@ -(\d+),?(\d*) \+(\d+),?(\d*) @@$/;
-  while (textPointer < text.length) {
-    var m = text[textPointer].match(patchHeader);
-    if (!m) {
-      throw new Error('Invalid patch string: ' + text[textPointer]);
-    }
-    var patch = new diff_match_patch.patch_obj();
-    patches.push(patch);
-    patch.start1 = parseInt(m[1], 10);
-    if (m[2] === '') {
-      patch.start1--;
-      patch.length1 = 1;
-    } else if (m[2] == '0') {
-      patch.length1 = 0;
-    } else {
-      patch.start1--;
-      patch.length1 = parseInt(m[2], 10);
-    }
-
-    patch.start2 = parseInt(m[3], 10);
-    if (m[4] === '') {
-      patch.start2--;
-      patch.length2 = 1;
-    } else if (m[4] == '0') {
-      patch.length2 = 0;
-    } else {
-      patch.start2--;
-      patch.length2 = parseInt(m[4], 10);
-    }
-    textPointer++;
-
-    while (textPointer < text.length) {
-      var sign = text[textPointer].charAt(0);
-      try {
-        var line = decodeURI(text[textPointer].substring(1));
-      } catch (ex) {
-        // Malformed URI sequence.
-        throw new Error('Illegal escape in patch_fromText: ' + line);
-      }
-      if (sign == '-') {
-        // Deletion.
-        patch.diffs.push(new diff_match_patch.Diff(DIFF_DELETE, line));
-      } else if (sign == '+') {
-        // Insertion.
-        patch.diffs.push(new diff_match_patch.Diff(DIFF_INSERT, line));
-      } else if (sign == ' ') {
-        // Minor equality.
-        patch.diffs.push(new diff_match_patch.Diff(DIFF_EQUAL, line));
-      } else if (sign == '@') {
-        // Start of next patch.
-        break;
-      } else if (sign === '') {
-        // Blank line?  Whatever.
-      } else {
-        // WTF?
-        throw new Error('Invalid patch mode "' + sign + '" in: ' + line);
-      }
-      textPointer++;
-    }
-  }
-  return patches;
-};
-
-
-/**
- * Class representing one patch operation.
- * @constructor
- */
-diff_match_patch.patch_obj = function() {
-  /** @type {!Array.<!diff_match_patch.Diff>} */
-  this.diffs = [];
-  /** @type {?number} */
-  this.start1 = null;
-  /** @type {?number} */
-  this.start2 = null;
-  /** @type {number} */
-  this.length1 = 0;
-  /** @type {number} */
-  this.length2 = 0;
-};
-
-
-/**
- * Emulate GNU diff's format.
- * Header: @@ -382,8 +481,9 @@
- * Indices are printed as 1-based, not 0-based.
- * @return {string} The GNU diff string.
- */
-diff_match_patch.patch_obj.prototype.toString = function() {
-  var coords1, coords2;
-  if (this.length1 === 0) {
-    coords1 = this.start1 + ',0';
-  } else if (this.length1 == 1) {
-    coords1 = this.start1 + 1;
-  } else {
-    coords1 = (this.start1 + 1) + ',' + this.length1;
-  }
-  if (this.length2 === 0) {
-    coords2 = this.start2 + ',0';
-  } else if (this.length2 == 1) {
-    coords2 = this.start2 + 1;
-  } else {
-    coords2 = (this.start2 + 1) + ',' + this.length2;
-  }
-  var text = ['@@ -' + coords1 + ' +' + coords2 + ' @@\n'];
-  var op;
-  // Escape the body of the patch with %xx notation.
-  for (var x = 0; x < this.diffs.length; x++) {
-    switch (this.diffs[x][0]) {
-      case DIFF_INSERT:
-        op = '+';
-        break;
-      case DIFF_DELETE:
-        op = '-';
-        break;
-      case DIFF_EQUAL:
-        op = ' ';
-        break;
-    }
-    text[x + 1] = op + encodeURI(this.diffs[x][1]) + '\n';
-  }
-  return text.join('').replace(/%20/g, ' ');
-};
-
-
-// The following export code was added by @ForbesLindesay
-module.exports = diff_match_patch;
-module.exports['diff_match_patch'] = diff_match_patch;
-module.exports['DIFF_DELETE'] = DIFF_DELETE;
-module.exports['DIFF_INSERT'] = DIFF_INSERT;
-module.exports['DIFF_EQUAL'] = DIFF_EQUAL;
\ No newline at end of file
diff --git a/packages/test-in-browser/driver.html b/packages/test-in-browser/driver.html
index 52bd3b8aad..a8f976998b 100644
--- a/packages/test-in-browser/driver.html
+++ b/packages/test-in-browser/driver.html
@@ -44,12 +44,15 @@
     <ul class="navbar-nav mr-auto">
       {{#each groupPaths}}
         <li class="nav-item"><span class="nav-link">&nbsp;-&nbsp;</span></li>
-        <li class="nav-item"><a class="nav-link" href="#">{{name}}</a></li>
+        <li class="nav-item"><a class="nav-link group" href="#">{{name}}</a></li>
       {{/each}}
     </ul>
 
     <form class="navbar-form pull-right">
       <span id="current-client-test"></span>
+      {{#if isFiltered}}
+        <button class="btn btn-secondary run-all">Run All Tests</button>
+      {{/if}}
       <button class="btn btn-primary rerun">
         {{#if rerunScheduled}}
         Rerun scheduled...
diff --git a/packages/test-in-browser/driver.js b/packages/test-in-browser/driver.js
index d14a6fecde..e469fa7fa5 100644
--- a/packages/test-in-browser/driver.js
+++ b/packages/test-in-browser/driver.js
@@ -1,9 +1,13 @@
 ////
 //// Setup
 ////
-import { diff_match_patch } from './diff_match_patch_uncompressed'
+import { diffChars } from 'diff'
 import 'bootstrap/dist/css/bootstrap.min.css';
 
+const arraysEqual = (a, b) => {
+  return a.length === b.length && a.every((v, i) => v === b[i]);
+}
+
 // dependency for the count of tests running/passed/failed, etc. drives
 // the navbar and the like.
 var countDep = new Tracker.Dependency;
@@ -43,12 +47,118 @@ window.onerror = (message, source, line) => {
   Session.set("uncaughtErrors", Array.from(uncaughtErrors));
 };
 
-Session.setDefault("groupPath", ["tinytest"]);
+var getGroupPathFromURL = function() {
+  var pathname = window.location.pathname;
+  var match = pathname.match(/^\/group\/(.+)$/);
+  if (match) {
+    try {
+      return JSON.parse(decodeURIComponent(match[1]));
+    } catch (e) {
+      console.warn('Invalid group path in URL:', match[1]);
+    }
+  }
+  return ["tinytest"];
+};
+
+var setGroupPathInURL = function(groupPath, pushState = true) {
+  var newURL = '/';
+
+  if (!arraysEqual(groupPath, ['tinytest'])) {
+    newURL = '/group/' + encodeURIComponent(JSON.stringify(groupPath));
+  }
+  
+  var historyState = { groupPath: groupPath };
+  
+  if (pushState) {
+    window.history.pushState(historyState, '', newURL);
+  } else {
+    window.history.replaceState(historyState, '', newURL);
+  }
+};
+
+// Initialize group path from URL, fallback to default
+var initialGroupPath = getGroupPathFromURL();
+Session.setDefault("groupPath", initialGroupPath);
 Session.set("rerunScheduled", false);
 
+// Safeguards for rapid navigation
+var isNavigating = false;
+var lastNavigationTime = 0;
+var navigationDebounceMs = 200; // Minimum time between navigations
+
+// Handle browser back/forward navigation
+window.addEventListener('popstate', function(event) {
+  var now = Date.now();
+  
+  // Safeguard 1: Prevent overlapping navigations
+  if (isNavigating) {
+    console.log('Navigation already in progress, ignoring');
+    return;
+  }
+  
+  // Safeguard 2: Debounce rapid successive calls
+  if (now - lastNavigationTime < navigationDebounceMs) {
+    console.log('Navigation too rapid, ignoring');
+    return;
+  }
+  
+  var newGroupPath = getGroupPathFromURL();
+  var currentGroupPath = Session.get("groupPath");
+  
+  if (!arraysEqual(newGroupPath, currentGroupPath)) {
+    // Set navigation flag
+    isNavigating = true;
+    lastNavigationTime = now;
+    
+    // Emulate the EXACT same sequence as changeToPath
+    
+    // 1. URL is already changed by browser, but ensure it's correct
+    setGroupPathInURL(newGroupPath, false); // replaceState, don't create new entry
+    
+    // 2. Update session state (SAME as changeToPath)
+    Session.set("groupPath", newGroupPath);
+    Session.set("rerunScheduled", true);
+    
+    // 3. Clean reload (SAME as changeToPath)
+    Reload._reload();
+  }
+});
+
 // This function is exported. It's called on client startup by the
 // bundle generated by `meteor test` or `meteor test-packages`.
 runTests = function () {
+  // Reset navigation safeguards when app starts
+  isNavigating = false;
+  
+  // Reset all test state before starting
+  running = true;
+  totalCount = 0;
+  passedCount = 0;
+  failedCount = 0;
+  failedTests = [];
+  resultTree = [];
+  
+  // Reset dependencies to trigger UI updates
+  countDep.changed();
+  topLevelGroupsDep.changed();
+  
+  // Get current group path from URL (in case of refresh)
+  var currentGroupPath = getGroupPathFromURL();
+  Session.set("groupPath", currentGroupPath);
+  
+  // Only update URL if it's actually different from what we expect
+  var expectedURL;
+  if (currentGroupPath && currentGroupPath.length > 0 && JSON.stringify(currentGroupPath) !== JSON.stringify(["tinytest"])) {
+    expectedURL = '/group/' + encodeURIComponent(JSON.stringify(currentGroupPath));
+  } else {
+    expectedURL = '/';
+  }
+  
+  // Only do replaceState if the URL doesn't match what we expect
+  if (window.location.pathname !== expectedURL) {
+    setGroupPathInURL(currentGroupPath, false);
+  }
+  
   document.body.innerHTML = "";
   document.head.title = "Tests";
 
@@ -62,7 +172,7 @@ runTests = function () {
     Tracker.flush();
 
     Meteor.connection._unsubscribeAll();
-  }, Session.get("groupPath"));
+  }, currentGroupPath);
 
 };
 
@@ -322,6 +432,10 @@ Template.progressBar.helpers({
 //// Template - groupNav
 
 var changeToPath = function (path) {
+  // Update URL with new group path (pushState creates new history entry)
+  setGroupPathInURL(path, true);
+  
+  // Update session to trigger UI updates
   Session.set("groupPath", path);
   Session.set("rerunScheduled", true);
   // pretend there's just been a hot code push
@@ -340,6 +454,10 @@ Template.groupNav.helpers({
   },
   rerunScheduled: function () {
     return Session.get("rerunScheduled");
+  },
+  isFiltered: function () {
+    var groupPath = Session.get("groupPath");
+    return groupPath.length > 1 || groupPath[0] !== "tinytest";
   }
 });
 
@@ -350,6 +468,9 @@ Template.groupNav.events({
   'click .rerun': function () {
     Session.set("rerunScheduled", true);
     Reload._reload();
+  },
+  'click .run-all': function () {
+    changeToPath(["tinytest"]);
   }
 });
 
@@ -507,10 +628,13 @@ Template.event.events({
 
 // e.g. doDiff('abc', 'bcd') => [[-1, 'a'], [0, 'bc'], [1, 'd']]
 var doDiff = function (str1, str2) {
-  var D = new diff_match_patch();
-  var pieces = D.diff_main(str1, str2, false);
-  D.diff_cleanupSemantic(pieces);
-  return pieces;
+  const diff = diffChars(str1, str2);
+  
+  return diff.map(part => {
+    if (part.added) return [1, part.value];
+    if (part.removed) return [-1, part.value];
+    return [0, part.value];
+  });
 };
 
 Template.event.helpers({
diff --git a/packages/test-in-browser/package.js b/packages/test-in-browser/package.js
index 2f721e5b1e..24c8e389e8 100644
--- a/packages/test-in-browser/package.js
+++ b/packages/test-in-browser/package.js
@@ -1,11 +1,12 @@
 Package.describe({
   summary: "Run tests interactively in the browser",
-  version: '1.4.0',
+  version: '1.5.0-beta340.11',
   documentation: null
 });
 
 Npm.depends({
   'bootstrap': '4.3.1',
+  'diff': '8.0.2'
 });
 
 Package.onUse(function (api) {
diff --git a/packages/tools-core/lib/ignore.js b/packages/tools-core/lib/ignore.js
new file mode 100644
index 0000000000..611cb3344b
--- /dev/null
+++ b/packages/tools-core/lib/ignore.js
@@ -0,0 +1,87 @@
+/**
+ * Build gitignore-style "unignore" patterns for specific files/folders.
+ *
+ * Rules:
+ *  - Files:  !a/  !a/b/  !a/b/c.txt
+ *  - Folders (must end with '/'):
+ *            !a/  !a/b/  !a/b/c/  !a/b/c/**
+ *
+ * @param {string[]} inputPaths  Paths to keep. Use '/' for dirs (e.g. 'assets/public/').
+ * @param {Object} [options]
+ * @param {boolean} [options.includeAllAncestors=true]  If false, only include the immediate parent dir.
+ * @param {boolean} [options.includeGlobForDirs=true]   Emit '**' for directories.
+ * @param {number} [options.skipLevel=0]               Skip this many levels from the beginning.
+ * @returns {string[]} Negation patterns, in correct order.
+ */
+export function buildUnignorePatterns(inputPaths, {
+  includeAllAncestors = true,
+  includeGlobForDirs = true,
+  skipLevel = 0,
+} = {}) {
+  const out = [];
+  const seen = new Set();
+
+  const push = (p) => {
+    if (!seen.has(p)) {
+      seen.add(p);
+      out.push(p);
+    }
+  };
+
+  for (let raw of inputPaths) {
+    if (!raw || typeof raw !== 'string') continue;
+
+    // Normalize: forward slashes, drop leading './', collapse double slashes
+    let anchored = raw.startsWith('/');
+    let p = raw.replace(/\\/g, '/')
+      .replace(/^\.\/+/, '')
+      .replace(/\/{2,}/g, '/');
+
+    // detect dir by trailing slash
+    const isDir = p.endsWith('/');
+    // strip leading + trailing slashes for splitting, but remember anchoring
+    const core = p.replace(/^\/+/, '').replace(/\/+$/, '');
+    if (!core) continue;
+
+    const parts = core.split('/');
+
+    // Process based on skipLevel
+    if (skipLevel >= parts.length) {
+      // Skip everything if skipLevel is greater than or equal to the number of parts
+      continue;
+    }
+
+    // Ancestors (top-down)
+    if (includeAllAncestors) {
+      // Start from skipLevel + 1 to skip the specified number of levels
+      const startLevel = Math.max(1, skipLevel + 1);
+      for (let i = startLevel; i <= parts.length - 1; i++) {
+        const anc = (anchored ? '/' : '') + parts.slice(0, i).join('/') + '/';
+        push('!' + anc);
+      }
+    } else if (parts.length > 1) {
+      // Only immediate parent
+      // For minimal mode with skipLevel, we need to check if the parent is at a level we should skip
+      if (skipLevel < parts.length - 1) {
+        // Check if the parent's level is greater than skipLevel
+        const parentLevel = parts.length - 1;
+        if (parentLevel > skipLevel) {
+          const parent = (anchored ? '/' : '') + parts.slice(0, parts.length - 1).join('/') + '/';
+          push('!' + parent);
+        }
+      }
+    }
+
+    // Add the file/directory pattern
+    if (isDir) {
+      const dir = (anchored ? '/' : '') + parts.join('/') + '/';
+      push('!' + dir);
+      if (includeGlobForDirs) push('!' + dir + '**');
+    } else {
+      const file = (anchored ? '/' : '') + parts.join('/');
+      push('!' + file);
+    }
+  }
+
+  return out;
+}
diff --git a/packages/tools-core/lib/meteor.js b/packages/tools-core/lib/meteor.js
index 5dec528f61..0d69ba2283 100644
--- a/packages/tools-core/lib/meteor.js
+++ b/packages/tools-core/lib/meteor.js
@@ -29,6 +29,14 @@ export function getMeteorAppConfig() {
     : getMeteorAppPackageJson()?.meteor;
 }
 
+/**
+ * Get Meteor's app port
+ * @returns {false|*}
+ */
+export function getMeteorAppPort() {
+  return Package?.meteor?.global?.currentCommand?.options?.['port'] || process.env.PORT || '3000';
+}
+
 /**
  * Retrieves the modern configuration from the application's package.json.
  * @returns {Object|undefined} The modern configuration object or undefined if not found.
@@ -46,6 +54,15 @@ export function isMeteorAppConfigModernVerbose() {
     getMeteorAppConfigModern()?.transpiler?.verbose || false;
 }
 
+/**
+ * Retrieves the auto install deps flag from the app's package.json.
+ * @returns {Boolean|*}
+ */
+export function hasMeteorAppConfigAutoInstallDeps() {
+  const { autoInstallDeps = true } = getMeteorAppConfig() || {};
+  return !!autoInstallDeps;
+}
+
 /**
  * Retrieves the entry points for the Meteor application from the configuration.
  * Uses Plugin.getMeteorConfig() if available, otherwise falls back to getMeteorAppConfig().
@@ -404,6 +421,14 @@ export function isMeteorBundleVisualizerProject() {
   return getMeteorAppPackages().includes('bundle-visualizer');
 }
 
+/**
+ * Checks if the Meteor application is a Typescript project.
+ * @returns {boolean} True if the application is a Typescript project, false otherwise.
+ */
+export function isMeteorTypescriptProject() {
+  return getMeteorAppPackages().includes('typescript');
+}
+
 /**
  * Checks if the current Meteor command is 'test-packages'.
  * @returns {boolean} True if the current command is 'test-packages', false otherwise.
diff --git a/packages/tools-core/lib/npm.js b/packages/tools-core/lib/npm.js
index a07bad0b1a..66462675f3 100644
--- a/packages/tools-core/lib/npm.js
+++ b/packages/tools-core/lib/npm.js
@@ -136,6 +136,37 @@ function buildNpmInstallArgs(dependencies, options = {}) {
   return args;
 }
 
+/**
+ * Builds yarn install arguments based on options and dependencies
+ * 
+ * @param {string|string[]} dependencies - The npm dependency or dependencies to install
+ * @param {Object} [options] - Options for the installation
+ * @param {boolean} [options.dev=false] - If true, install as a dev dependency
+ * @param {boolean} [options.exact=false] - If true, install with exact version
+ * @returns {string[]} Array of arguments for the yarn add command
+ */
+function buildYarnInstallArgs(dependencies, options = {}) {
+  const args = ['add'];
+
+  // Add flags based on options
+  if (options.dev) {
+    args.push('--dev');
+  }
+
+  if (options.exact) {
+    args.push('--exact');
+  }
+
+  // Add dependencies to the command
+  if (Array.isArray(dependencies)) {
+    args.push(...dependencies);
+  } else {
+    args.push(dependencies);
+  }
+
+  return args;
+}
+
 /**
  * Executes a command and returns a promise that resolves to true if successful
  * 
@@ -161,17 +192,26 @@ function executeCommand(command, args, options) {
 
 /**
  * Installs a npm dependency using direct npm binary if available, otherwise falls back to `meteor npm install`.
+ * If yarn option is true, uses yarn instead.
  * 
  * @param {string|string[]} dependencies - The npm dependency or dependencies to install
  * @param {Object} [options] - Options for the installation
  * @param {string} [options.cwd] - Current working directory (defaults to process.cwd())
  * @param {boolean} [options.dev=false] - If true, install as a dev dependency
  * @param {boolean} [options.exact=false] - If true, install with exact version
+ * @param {boolean} [options.yarn=false] - If true, use yarn instead of npm
  * @returns {Promise<boolean>} A promise that resolves to true if installation succeeded, false otherwise
  */
 export function installNpmDependency(dependencies, options = {}) {
   const cwd = options.cwd || process.cwd();
 
+  // If yarn option is true, use yarn
+  if (options.yarn) {
+    const { command, args: baseArgs } = getYarnCommand([]);
+    const args = buildYarnInstallArgs(dependencies, options);
+    return executeCommand(command, [...baseArgs, ...args], { cwd });
+  }
+
   // Try to get the npm binary path
   const npmBinaryPath = getNodeBinaryPath('npm');
 
@@ -319,3 +359,129 @@ export function getNpxCommand(args) {
     prefix: `meteor npx`,
   };
 }
+
+/**
+ * Checks if the current project is a Yarn project.
+ * Looks for yarn.lock file in the current working directory and checks packageManager in package.json.
+ * 
+ * @param {Object} [options] - Options for the check
+ * @param {string} [options.cwd] - Current working directory (defaults to process.cwd())
+ * @returns {boolean} True if it's a Yarn project, false otherwise
+ */
+export function isYarnProject(options = {}) {
+  const cwd = options.cwd || process.cwd();
+
+  // Check if yarn.lock exists
+  const yarnLockPath = path.join(cwd, 'yarn.lock');
+  if (fs.existsSync(yarnLockPath)) {
+    return true;
+  }
+
+  // Check packageManager field in package.json
+  try {
+    const packageJsonPath = path.join(cwd, 'package.json');
+    if (fs.existsSync(packageJsonPath)) {
+      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+
+      // Check if packageManager contains "yarn"
+      if (packageJson.packageManager && packageJson.packageManager.includes('yarn')) {
+        return true;
+      }
+    }
+  } catch (error) {
+    // If there's an error reading or parsing package.json, continue
+  }
+
+  return false;
+}
+
+/**
+ * Gets the yarn command and arguments
+ * @param {string[]} args - The arguments to pass to yarn
+ * @returns {Object} An object with command, args, and base properties
+ */
+export function getYarnCommand(args) {
+  // Try to get the yarn binary path
+  const yarnBinaryPath = getNodeBinaryPath('yarn');
+
+  // If we have a direct path to yarn, use it
+  if (yarnBinaryPath && fs.existsSync(yarnBinaryPath)) {
+    return {
+      command: yarnBinaryPath,
+      args,
+      prefix: `${yarnBinaryPath}`,
+    };
+  }
+
+  // Fall back to using 'yarn' directly
+  return {
+    command: 'yarn',
+    args,
+    prefix: `yarn`,
+  };
+}
+
+/**
+ * Gets the path to the monorepo root by checking for common monorepo indicators.
+ * Traverses up the directory tree until it finds a monorepo indicator or reaches the root.
+ * 
+ * @param {Object} [options] - Options for the detection
+ * @param {string} [options.cwd] - Current working directory (defaults to process.cwd())
+ * @returns {string|null} Path to the monorepo root if found, null otherwise
+ */
+export function getMonorepoPath(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  let currentDir = cwd;
+
+  // Function to check if directory has monorepo indicators
+  const hasMonorepoIndicators = (dir) => {
+    try {
+      // Check for npm/yarn workspaces in package.json
+      const packageJsonPath = path.join(dir, 'package.json');
+      if (fs.existsSync(packageJsonPath)) {
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        if (packageJson.workspaces) {
+          return true;
+        }
+      }
+
+      // Check for Lerna
+      const lernaJsonPath = path.join(dir, 'lerna.json');
+      if (fs.existsSync(lernaJsonPath)) {
+        return true;
+      }
+
+      // Check for pnpm workspaces
+      const pnpmWorkspacePath = path.join(dir, 'pnpm-workspace.yaml');
+      if (fs.existsSync(pnpmWorkspacePath)) {
+        return true;
+      }
+
+      return false;
+    } catch (error) {
+      return false;
+    }
+  };
+
+  // Traverse up the directory tree
+  while (currentDir !== path.dirname(currentDir)) { // Stop when we reach the root directory
+    if (hasMonorepoIndicators(currentDir)) {
+      return currentDir;
+    }
+    currentDir = path.dirname(currentDir);
+  }
+
+  // Check the root directory as well
+  return hasMonorepoIndicators(currentDir) ? currentDir : null;
+}
+
+/**
+ * Detects if a directory is within a monorepo by checking for common monorepo indicators.
+ *
+ * @param {Object} [options] - Options for the detection
+ * @param {string} [options.cwd] - Current working directory (defaults to process.cwd())
+ * @returns {boolean} True if the directory is within a monorepo, false otherwise
+ */
+export function isMonorepo(options = {}) {
+  return getMonorepoPath(options) !== null;
+}
diff --git a/packages/tools-core/lib/process.js b/packages/tools-core/lib/process.js
index 52017d7a86..88db5b7cc6 100644
--- a/packages/tools-core/lib/process.js
+++ b/packages/tools-core/lib/process.js
@@ -25,6 +25,7 @@ export function spawnProcess(command, args, options = {}) {
     cwd: options.cwd || process.cwd(),
     stdio: ['pipe', 'pipe', 'pipe'],
     detached: options.detached || false,
+    ...(process.platform === 'win32' && { shell: true }),
   });
 
   // Add a reference to track if the process is running
diff --git a/packages/tools-core/package.js b/packages/tools-core/package.js
index a13b6977e2..6f0ca3ceb5 100644
--- a/packages/tools-core/package.js
+++ b/packages/tools-core/package.js
@@ -1,6 +1,6 @@
 Package.describe({
   summary: "Helpers for managing modern tools in Meteor",
-  version: '1.0.0-beta340.0',
+  version: '1.0.0-beta340.11',
 });
 
 Package.onUse(function (api) {
diff --git a/packages/tools-core/tools-core_server.js b/packages/tools-core/tools-core_server.js
index 313cc1674c..108d4e35c5 100644
--- a/packages/tools-core/tools-core_server.js
+++ b/packages/tools-core/tools-core_server.js
@@ -5,3 +5,4 @@ export * from './lib/process';
 export * from './lib/global-state';
 export * from './lib/git';
 export * from './lib/string';
+export * from './lib/ignore';
diff --git a/packages/typescript/package.js b/packages/typescript/package.js
index 2a4372edf4..2ce664d572 100644
--- a/packages/typescript/package.js
+++ b/packages/typescript/package.js
@@ -1,6 +1,6 @@
 Package.describe({
   name: 'typescript',
-  version: '5.6.6',
+  version: '5.7.0-beta340.11',
   summary:
     'Compiler plugin that compiles TypeScript and ECMAScript in .ts and .tsx files',
   documentation: 'README.md',
diff --git a/scripts/admin/meteor-release-experimental.json b/scripts/admin/meteor-release-experimental.json
index 2432e8857d..c020238c39 100644
--- a/scripts/admin/meteor-release-experimental.json
+++ b/scripts/admin/meteor-release-experimental.json
@@ -1,6 +1,6 @@
 {
   "track": "METEOR",
-  "version": "3.3.1-rc.2",
+  "version": "3.4-beta.11",
   "recommended": false,
   "official": false,
   "description": "Meteor experimental release"
diff --git a/scripts/dev-bundle-tool-package.js b/scripts/dev-bundle-tool-package.js
index bea9a12aec..fd5b488573 100644
--- a/scripts/dev-bundle-tool-package.js
+++ b/scripts/dev-bundle-tool-package.js
@@ -12,6 +12,7 @@ var packageJson = {
     // and we want to make sure there are no dependencies on a higher version
     npm: "10.9.3",
     "node-gyp": "10.2.0",
+    "node-gyp-build": "4.8.4",
     "@mapbox/node-pre-gyp": "1.0.11",
     typescript: "5.6.3",
     "@meteorjs/babel": "7.20.0",
diff --git a/tools/cli/commands.js b/tools/cli/commands.js
index 14966d1176..244796733b 100644
--- a/tools/cli/commands.js
+++ b/tools/cli/commands.js
@@ -690,6 +690,7 @@ function getExamplesJSON(){
 const DEFAULT_SKELETON = "react";
 export const AVAILABLE_SKELETONS = [
   "apollo",
+  "babel",
   "bare",
   "blaze",
   "full",
@@ -702,6 +703,7 @@ export const AVAILABLE_SKELETONS = [
   "chakra-ui",
   "solid",
   "legacy",
+  "coffeescript"
 ];
 
 const SKELETON_INFO = {
@@ -716,8 +718,10 @@ const SKELETON_INFO = {
   "svelte": "To create a basic Svelte app",
   "tailwind": "To create an app using React and Tailwind",
   "chakra-ui": "To create an app Chakra UI and React",
-  "solid": "To create a basic Solid app"
-}
+  "solid": "To create a basic Solid app",
+  "coffeescript": "To create a basic CoffeeScript app",
+  "babel": "To create a React app with Babel support",
+};
 
 main.registerCommand({
   name: 'create',
@@ -727,6 +731,7 @@ main.registerCommand({
     list: { type: Boolean },
     example: { type: String },
     package: { type: Boolean },
+    babel: { type: Boolean },
     bare: { type: Boolean },
     minimal: { type: Boolean },
     full: { type: Boolean },
@@ -738,6 +743,7 @@ main.registerCommand({
     svelte: { type: Boolean },
     tailwind: { type: Boolean },
     'chakra-ui': { type: Boolean },
+    coffeescript: { type: Boolean },
     solid: { type: Boolean },
     legacy: { type: Boolean },
     prototype: { type: Boolean },
@@ -842,7 +848,7 @@ main.registerCommand({
             return transform(f);
           },
           transformContents: async function (contents, f) {
-            if (/(\.html|\.[jt]sx?|\.css)/.test(f)) {
+            if (/(\.html|\.[jt]sx?|\.css|\.coffee)/.test(f)) {
               return Buffer.from(await transform(contents.toString()));
             } else {
               return contents;
@@ -1227,7 +1233,7 @@ main.registerCommand({
               return Buffer.from(contents.toString().replace(/~prototype~/g, ""));
             }
           }
-          if (/(\.html|\.[jt]sx?|\.css)/.test(f)) {
+          if (/(\.html|\.[jt]sx?|\.css|\.coffee)/.test(f)) {
             return Buffer.from(transform(contents.toString()));
           } else {
             return contents;
diff --git a/tools/cli/help.txt b/tools/cli/help.txt
index 96e611feca..e560cd2716 100644
--- a/tools/cli/help.txt
+++ b/tools/cli/help.txt
@@ -153,7 +153,7 @@ Options:
 
 >>> create
 Create a new project.
-Usage: meteor create [--release <release>] [--bare|--minimal|--full|--react|--vue|--apollo|--svelte|--blaze|--tailwind|--chakra-ui|--solid] <path>
+Usage: meteor create [--release <release>] [--bare|--minimal|--full|--react|--vue|--apollo|--svelte|--blaze|--tailwind|--chakra-ui|--solid|--babel|--coffeescript] <path>
        meteor create [--release <release>] --example <example_name> [<path>]
        meteor create [--release <release>] --from <git_url> [<path>]
        meteor create --list
@@ -195,6 +195,8 @@ Options:
   --blaze       Create a basic blaze-based app.
   --tailwind    Create a basic react-based app, with tailwind configured.
   --chakra-ui   Create a basic react-based app, with chakra-ui configured.
+  --coffeescript Create a basic coffescript app, with react.
+  --babel       Create a React app with Babel support.
   --solid       Create a basic solid-based app.
   --prototype Create a prototype app with the insecure & autopublish packages. Can be used along with other app commands
 
diff --git a/tools/cli/main.js b/tools/cli/main.js
index b73e2b7868..d72744a72f 100644
--- a/tools/cli/main.js
+++ b/tools/cli/main.js
@@ -2,6 +2,10 @@ var showRequireProfile = ('METEOR_PROFILE_REQUIRE' in process.env);
 if (showRequireProfile) {
   require('../tool-env/profile-require.js').start();
 }
+const { initMeteorConfig } = require('../tool-env/meteor-config');
+
+// Initialize meteorConfig globally
+initMeteorConfig();
 
 var assert = require("assert");
 var _ = require('underscore');
@@ -287,16 +291,12 @@ main.captureAndExit = async function (header, title, f) {
 
 // NB: files required up to this point may not define commands
 
-const { initMeteorConfig } = require('../tool-env/meteor-config');
 require('./commands.js');
 require('./commands-packages.js');
 require('./commands-packages-query.js');
 require('./commands-cordova.js');
 require('./commands-aliases.js');
 
-// Initialize meteorConfig globally
-initMeteorConfig();
-
 ///////////////////////////////////////////////////////////////////////////////
 // Record all the top-level commands as JSON
 ///////////////////////////////////////////////////////////////////////////////
diff --git a/tools/modern-tests/apps/babel/rspack.config.js b/tools/modern-tests/apps/babel/rspack.config.mjs
similarity index 100%
rename from tools/modern-tests/apps/babel/rspack.config.js
rename to tools/modern-tests/apps/babel/rspack.config.mjs
diff --git a/tools/modern-tests/apps/coffeescript/rspack.config.js b/tools/modern-tests/apps/coffeescript/rspack.config.js
index bb1757b415..ca59f202e2 100644
--- a/tools/modern-tests/apps/coffeescript/rspack.config.js
+++ b/tools/modern-tests/apps/coffeescript/rspack.config.js
@@ -1,4 +1,4 @@
-import { defineConfig } from '@meteorjs/rspack';
+const { defineConfig } = require('@meteorjs/rspack');
 
 /**
  * Rspack configuration for Meteor projects.
@@ -10,7 +10,7 @@ import { defineConfig } from '@meteorjs/rspack';
  *
  * Use these flags to adjust your build settings based on environment.
  */
-export default defineConfig(Meteor => {
+module.exports = defineConfig(Meteor => {
   return {
     module: {
       rules: [
diff --git a/tools/modern-tests/apps/monorepo/.npmrc b/tools/modern-tests/apps/monorepo/.npmrc
new file mode 100644
index 0000000000..217a694955
--- /dev/null
+++ b/tools/modern-tests/apps/monorepo/.npmrc
@@ -0,0 +1 @@
+install-strategy=nested
diff --git a/tools/modern-tests/apps/monorepo/app/.meteor/packages b/tools/modern-tests/apps/monorepo/app/.meteor/packages
new file mode 100644
index 0000000000..80b136d881
--- /dev/null
+++ b/tools/modern-tests/apps/monorepo/app/.meteor/packages
@@ -0,0 +1,22 @@
+# Meteor packages used by this project, one per line.
+# Check this file (and the other files in this directory) into your repository.
+#
+# 'meteor add' and 'meteor remove' will edit this file for you,
+# but you can also edit it by hand.
+
+meteor-base             # Packages every Meteor app needs to have
+mobile-experience       # Packages for a great mobile UX
+mongo                   # The database Meteor supports right now
+reactive-var            # Reactive variable for tracker
+
+standard-minifier-css   # CSS minifier run for production mode
+standard-minifier-js    # JS minifier run for production mode
+es5-shim                # ECMAScript 5 compatibility for older browsers
+ecmascript              # Enable ECMAScript2015+ syntax in app code
+typescript              # Enable TypeScript syntax in .ts and .tsx modules
+shell-server            # Server-side component of the `meteor shell` command
+hot-module-replacement  # Update client in development without reloading the page
+
+
+static-html             # Define static page content in .html files
+react-meteor-data       # React higher-order component for reactively tracking Meteor data
diff --git a/tools/modern-tests/apps/monorepo/app/.meteor/platforms b/tools/modern-tests/apps/monorepo/app/.meteor/platforms
new file mode 100644
index 0000000000..efeba1b50c
--- /dev/null
+++ b/tools/modern-tests/apps/monorepo/app/.meteor/platforms
@@ -0,0 +1,2 @@
+server
+browser
diff --git a/tools/modern-tests/apps/monorepo/app/.meteor/release b/tools/modern-tests/apps/monorepo/app/.meteor/release
new file mode 100644
index 0000000000..621e94f0ec
--- /dev/null
+++ b/tools/modern-tests/apps/monorepo/app/.meteor/release
@@ -0,0 +1 @@
+none
diff --git a/tools/modern-tests/apps/monorepo/app/.meteorignore b/tools/modern-tests/apps/monorepo/app/.meteorignore
new file mode 100644
index 0000000000..b8463671b0
--- /dev/null
+++ b/tools/modern-tests/apps/monorepo/app/.meteorignore
@@ -0,0 +1 @@
+**/ignore*
diff --git a/tools/modern-tests/apps/monorepo/app/.swcrc b/tools/modern-tests/apps/monorepo/app/.swcrc
new file mode 100644
index 0000000000..68b72e1154
--- /dev/null
+++ b/tools/modern-tests/apps/monorepo/app/.swcrc
@@ -0,0 +1,8 @@
+{
+  "jsc": {
+    "parser": {
+      "syntax": "typescript",
+      "tsx": true
+    }
+  }
+}
diff --git a/tools/modern-tests/apps/typescript/client/main.css b/tools/modern-tests/apps/monorepo/app/client/main.css
similarity index 100%
rename from tools/modern-tests/apps/typescript/client/main.css
rename to tools/modern-tests/apps/monorepo/app/client/main.css
diff --git a/tools/modern-tests/apps/monorepo/app/client/main.html b/tools/modern-tests/apps/monorepo/app/client/main.html
new file mode 100644
index 0000000000..0d1a6cada5
--- /dev/null
+++ b/tools/modern-tests/apps/monorepo/app/client/main.html
@@ -0,0 +1,8 @@
+<head>
+  <title>monorepo</title>
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+</head>
+
+<body>
+  <div id="react-target"></div>
+</body>
diff --git a/tools/modern-tests/apps/monorepo/app/client/main.jsx b/tools/modern-tests/apps/monorepo/app/client/main.jsx
new file mode 100644
index 0000000000..d2e380f93c
--- /dev/null
+++ b/tools/modern-tests/apps/monorepo/app/client/main.jsx
@@ -0,0 +1,10 @@
+import React from 'react';
+import { createRoot } from 'react-dom/client';
+import { Meteor } from 'meteor/meteor';
+import { App } from '/imports/ui/App';
+
+Meteor.startup(() => {
+  const container = document.getElementById('react-target');
+  const root = createRoot(container);
+  root.render(<App />);
+});
diff --git a/tools/modern-tests/apps/monorepo/app/ignored/ignore.test.js b/tools/modern-tests/apps/monorepo/app/ignored/ignore.test.js
new file mode 100644
index 0000000000..6e10e42476
--- /dev/null
+++ b/tools/modern-tests/apps/monorepo/app/ignored/ignore.test.js
@@ -0,0 +1 @@
+throw new Error("This file should be ignored");
diff --git a/tools/modern-tests/apps/monorepo/app/imports/api/links.js b/tools/modern-tests/apps/monorepo/app/imports/api/links.js
new file mode 100644
index 0000000000..a3e3364a2e
--- /dev/null
+++ b/tools/modern-tests/apps/monorepo/app/imports/api/links.js
@@ -0,0 +1,8 @@
+import { Mongo } from 'meteor/mongo';
+import { Buffer } from "node:buffer";
+
+// Don't trigger an error on using node modules
+//  as ignored to enable shared client/server code
+console.log("Buffer loaded: ", !!Buffer);
+
+export const LinksCollection = new Mongo.Collection('links');
diff --git a/tools/modern-tests/apps/monorepo/app/imports/emails/TestEmail.jsx b/tools/modern-tests/apps/monorepo/app/imports/emails/TestEmail.jsx
new file mode 100644
index 0000000000..4d2a6c491c
--- /dev/null
+++ b/tools/modern-tests/apps/monorepo/app/imports/emails/TestEmail.jsx
@@ -0,0 +1,15 @@
+import { Button, Html } from '@react-email/components';
+import * as React from 'react';
+
+export default function TestEmail() {
+  return (
+    <Html>
+      <Button
+        href='https://example.com'
+        style={{ background: '#000', color: '#fff', padding: '12px 20px' }}
+      >
+        Click me
+      </Button>
+    </Html>
+  );
+}
diff --git a/tools/modern-tests/apps/monorepo/app/imports/ui/App.jsx b/tools/modern-tests/apps/monorepo/app/imports/ui/App.jsx
new file mode 100644
index 0000000000..6f7340caf9
--- /dev/null
+++ b/tools/modern-tests/apps/monorepo/app/imports/ui/App.jsx
@@ -0,0 +1,11 @@
+import React from 'react';
+import { Hello } from './Hello.jsx';
+import { Info } from './Info.jsx';
+
+export const App = () => (
+  <div>
+    <h1>Welcome to Meteor!</h1>
+    <Hello/>
+    <Info/>
+  </div>
+);
diff --git a/tools/modern-tests/apps/monorepo/app/imports/ui/Hello.jsx b/tools/modern-tests/apps/monorepo/app/imports/ui/Hello.jsx
new file mode 100644
index 0000000000..15e0f185ac
--- /dev/null
+++ b/tools/modern-tests/apps/monorepo/app/imports/ui/Hello.jsx
@@ -0,0 +1,16 @@
+import React, { useState } from 'react';
+
+export const Hello = () => {
+  const [counter, setCounter] = useState(0);
+
+  const increment = () => {
+    setCounter(counter + 1);
+  };
+
+  return (
+    <div>
+      <button onClick={increment}>Click Me</button>
+      <p>You've pressed the button {counter} times.</p>
+    </div>
+  );
+};
diff --git a/tools/modern-tests/apps/monorepo/app/imports/ui/Info.jsx b/tools/modern-tests/apps/monorepo/app/imports/ui/Info.jsx
new file mode 100644
index 0000000000..a9a7a45cfe
--- /dev/null
+++ b/tools/modern-tests/apps/monorepo/app/imports/ui/Info.jsx
@@ -0,0 +1,23 @@
+import React from 'react';
+import { useFind, useSubscribe } from 'meteor/react-meteor-data';
+import { LinksCollection } from '../api/links';
+
+export const Info = () => {
+  const isLoading = useSubscribe('links');
+  const links = useFind(() => LinksCollection.find());
+
+  if(isLoading()) {
+    return <div>Loading...</div>;
+  }
+
+  return (
+    <div>
+      <h2>Learn Meteor!</h2>
+      <ul>{links.map(
+        link => <li key={link._id}>
+          <a href={link.url} target="_blank">{link.title}</a>
+        </li>
+      )}</ul>
+    </div>
+  );
+};
diff --git a/tools/modern-tests/apps/monorepo/app/package.json b/tools/modern-tests/apps/monorepo/app/package.json
new file mode 100644
index 0000000000..c5e73767e0
--- /dev/null
+++ b/tools/modern-tests/apps/monorepo/app/package.json
@@ -0,0 +1,33 @@
+{
+  "name": "app",
+  "private": true,
+  "scripts": {
+    "start": "meteor run",
+    "test": "meteor test --once --driver-package meteortesting:mocha",
+    "test-app": "TEST_WATCH=1 meteor test --full-app --driver-package meteortesting:mocha",
+    "visualize": "meteor --production --extra-packages bundle-visualizer"
+  },
+  "dependencies": {
+    "@babel/runtime": "^7.23.5",
+    "@react-email/components": "0.5.3",
+    "@swc/helpers": "^0.5.17",
+    "grubba-rpc": "^0.12.8",
+    "meteor-node-stubs": "^1.2.12",
+    "pino": "^9.6.0",
+    "pino-pretty": "^13.0.0",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0",
+    "thread-stream": "^3.1.0",
+    "zod": "^3.24.4"
+  },
+  "devDependencies": {
+    "playwright": "^1.54.2"
+  },
+  "meteor": {
+    "mainModule": {
+      "client": "client/main.jsx",
+      "server": "server/main.js"
+    },
+    "modern": true
+  }
+}
diff --git a/tools/modern-tests/apps/typescript/rspack.config.js b/tools/modern-tests/apps/monorepo/app/rspack.config.js
similarity index 62%
rename from tools/modern-tests/apps/typescript/rspack.config.js
rename to tools/modern-tests/apps/monorepo/app/rspack.config.js
index 64e8db0052..b2e81958db 100644
--- a/tools/modern-tests/apps/typescript/rspack.config.js
+++ b/tools/modern-tests/apps/monorepo/app/rspack.config.js
@@ -1,5 +1,4 @@
-import { defineConfig } from '@meteorjs/rspack';
-import { TsCheckerRspackPlugin } from 'ts-checker-rspack-plugin';
+const { defineConfig } = require('@meteorjs/rspack');
 
 /**
  * Rspack configuration for Meteor projects.
@@ -11,8 +10,9 @@ import { TsCheckerRspackPlugin } from 'ts-checker-rspack-plugin';
  *
  * Use these flags to adjust your build settings based on environment.
  */
-export default defineConfig(Meteor => {
+module.exports = defineConfig(Meteor => {
   return {
-    plugins: [new TsCheckerRspackPlugin()],
+    ...Meteor.compileWithMeteor(["thread-stream"]),
+    ...Meteor.compileWithRspack(["grubba-rpc"]),
   };
 });
diff --git a/tools/modern-tests/apps/monorepo/app/server/main.js b/tools/modern-tests/apps/monorepo/app/server/main.js
new file mode 100644
index 0000000000..00d7d58f57
--- /dev/null
+++ b/tools/modern-tests/apps/monorepo/app/server/main.js
@@ -0,0 +1,64 @@
+import { Meteor } from 'meteor/meteor';
+import pino from 'pino';
+import { createClient } from 'grubba-rpc';
+
+import { LinksCollection } from '/imports/api/links';
+import { TestEmail } from '/imports/emails/TestEmail';
+
+console.log('-> TestEmail loaded', !!TestEmail);
+
+const logger = pino({
+  transport: {
+    target: "pino-pretty",
+    options: {
+      colorize: true,
+      levelFirst: true,
+      translateTime: "UTC:yyyy-mm-dd HH:MM:ss.l o",
+      ignore: "pid,hostname"
+    }
+  },
+  browser: { asObject: true }
+});
+
+// Issue with thread-stream "Cannot find module '/_build/main-dev/lib/worker.js'"
+// Ensure `Meteor.compileWithMeteor(["thread-stream"])` works
+console.log("logger loaded", !!logger);
+
+// Issue with npm deps that require compilation as not transpiled
+// Ensure `Meteor.compileWithRspack(["grubba-rpc"])` works
+console.log("grubba-rpc's createClient", !!createClient);
+
+async function insertLink({ title, url }) {
+  await LinksCollection.insertAsync({ title, url, createdAt: new Date() });
+}
+
+Meteor.startup(async () => {
+  // If the Links collection is empty, add some data.
+  if (await LinksCollection.find().countAsync() === 0) {
+    await insertLink({
+      title: 'Do the Tutorial',
+      url: 'https://react-tutorial.meteor.com/simple-todos/01-creating-app.html',
+    });
+
+    await insertLink({
+      title: 'Follow the Guide',
+      url: 'https://guide.meteor.com',
+    });
+
+    await insertLink({
+      title: 'Read the Docs',
+      url: 'https://docs.meteor.com',
+    });
+
+    await insertLink({
+      title: 'Discussions',
+      url: 'https://forums.meteor.com',
+    });
+  }
+
+  // We publish the entire Links collection to all clients.
+  // In order to be fetched in real-time to the clients
+  Meteor.publish("links", function () {
+    return LinksCollection.find();
+  });
+});
diff --git a/tools/modern-tests/apps/monorepo/app/tests/ignore-test.test.js b/tools/modern-tests/apps/monorepo/app/tests/ignore-test.test.js
new file mode 100644
index 0000000000..6e10e42476
--- /dev/null
+++ b/tools/modern-tests/apps/monorepo/app/tests/ignore-test.test.js
@@ -0,0 +1 @@
+throw new Error("This file should be ignored");
diff --git a/tools/modern-tests/apps/monorepo/app/tests/ignored/ignore-nested.test.js b/tools/modern-tests/apps/monorepo/app/tests/ignored/ignore-nested.test.js
new file mode 100644
index 0000000000..6e10e42476
--- /dev/null
+++ b/tools/modern-tests/apps/monorepo/app/tests/ignored/ignore-nested.test.js
@@ -0,0 +1 @@
+throw new Error("This file should be ignored");
diff --git a/tools/modern-tests/apps/monorepo/app/tests/main.test.js b/tools/modern-tests/apps/monorepo/app/tests/main.test.js
new file mode 100644
index 0000000000..685c69de3f
--- /dev/null
+++ b/tools/modern-tests/apps/monorepo/app/tests/main.test.js
@@ -0,0 +1,25 @@
+import assert from "assert";
+
+describe("monorepo", function () {
+  it("package.json has correct name", async function () {
+    const { name } = await import("../package.json");
+    assert.strictEqual(name, "app");
+  });
+
+  if (Meteor.isClient) {
+    it("client is not server", function () {
+      assert.strictEqual(Meteor.isServer, false);
+    });
+  }
+
+  if (Meteor.isServer) {
+    it("server is not client", function () {
+      assert.strictEqual(Meteor.isClient, false);
+    });
+  }
+
+  it("is test", function () {
+    assert.strictEqual(Meteor.isTest, true);
+    assert.strictEqual(Meteor.isAppTest, false);
+  });
+});
diff --git a/tools/modern-tests/apps/monorepo/package.json b/tools/modern-tests/apps/monorepo/package.json
new file mode 100644
index 0000000000..f2422900c5
--- /dev/null
+++ b/tools/modern-tests/apps/monorepo/package.json
@@ -0,0 +1,10 @@
+{
+  "name": "monorepo",
+  "private": true,
+  "workspaces": [
+    "app"
+  ],
+  "engines": {
+    "node": ">=22.0.0"
+  }
+}
diff --git a/tools/modern-tests/apps/react-router/imports/ui/App.jsx b/tools/modern-tests/apps/react-router/imports/ui/App.jsx
index c317515faa..d5cb7c95e6 100644
--- a/tools/modern-tests/apps/react-router/imports/ui/App.jsx
+++ b/tools/modern-tests/apps/react-router/imports/ui/App.jsx
@@ -9,7 +9,7 @@ import "./Global.less";
 
 // Dynamically import components
 const Home = lazy(() =>
-  import("./Home.jsx").then((module) => ({ default: module.Home }))
+  import(/* webpackPrefetch: true */ "./Home.jsx").then((module) => ({ default: module.Home }))
 );
 const NotFound = lazy(() =>
   import("./NotFound.jsx").then((module) => ({ default: module.NotFound }))
diff --git a/tools/modern-tests/apps/react-router/package.json b/tools/modern-tests/apps/react-router/package.json
index dbbf46f446..966f93a251 100644
--- a/tools/modern-tests/apps/react-router/package.json
+++ b/tools/modern-tests/apps/react-router/package.json
@@ -11,6 +11,7 @@
     "@babel/runtime": "^7.23.5",
     "@modelcontextprotocol/sdk": "^1.17.3",
     "@swc/helpers": "^0.5.17",
+    "bcrypt": "^6.0.0",
     "meteor-node-stubs": "^1.2.12",
     "react": "^18.3.1",
     "react-compiler-runtime": "^19.1.0-rc.2",
@@ -26,13 +27,15 @@
     "babel-loader": "^9.1.3",
     "less": "^4.4.0",
     "less-loader": "^12.3.0",
-    "playwright": "^1.54.2"
+    "playwright": "^1.54.2",
+    "typescript": "^5.9.2"
   },
   "meteor": {
     "mainModule": {
       "client": "client/main.jsx",
       "server": "server/main.js"
     },
+    "modules": ["styles/module.css"],
     "modern": true
   }
 }
diff --git a/tools/modern-tests/apps/react-router/rspack.config.js b/tools/modern-tests/apps/react-router/rspack.config.js
index 330dc69908..45f50b6250 100644
--- a/tools/modern-tests/apps/react-router/rspack.config.js
+++ b/tools/modern-tests/apps/react-router/rspack.config.js
@@ -1,4 +1,4 @@
-import { defineConfig } from '@meteorjs/rspack';
+const { defineConfig } = require('@meteorjs/rspack');
 
 /**
  * Rspack configuration for Meteor projects.
@@ -10,13 +10,14 @@ import { defineConfig } from '@meteorjs/rspack';
  *
  * Use these flags to adjust your build settings based on environment.
  */
-export default defineConfig(Meteor => {
+module.exports = defineConfig(Meteor => {
   return {
     resolve: {
       alias: {
         '@helper/alias': '/imports/helpers/alias.js',
         '@react/alias': '/node_modules/react',
       },
+      extensions: ['.jsx'],
     },
     module: {
       rules: [
@@ -42,6 +43,22 @@ export default defineConfig(Meteor => {
         },
       ],
     },
+    ...(Meteor.isClient && {
+      optimization: {
+        splitChunks: {
+          chunks: 'all',
+          cacheGroups: {
+            reactRouter: {
+              test: /[\\/]node_modules[\\/](react-router|react-router-dom)[\\/]/,
+              name: 'react-router',
+              priority: 40,
+              enforce: true,
+            },
+            vendor: { test: /node_modules/, name: 'vendors' },
+          },
+        },
+      },
+    }),
     plugins: [
       Meteor.HtmlRspackPlugin({
         title: 'react-router',
diff --git a/tools/modern-tests/apps/react-router/server/main.js b/tools/modern-tests/apps/react-router/server/main.js
index 6beb7c30b7..f0ea8e46e8 100644
--- a/tools/modern-tests/apps/react-router/server/main.js
+++ b/tools/modern-tests/apps/react-router/server/main.js
@@ -4,8 +4,13 @@ import { LinksCollection } from '/imports/api/links';
 import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
 import '@helper/alias';
 import ReactAlias from '@react/alias';
+import './resolve-extensions/first';
+import { TypescriptEnabled } from './ts/helpers';
+import bcrypt from "bcrypt";
 
 console.log('@react/alias loaded', ReactAlias.version);
+console.log('TypescriptEnabled', TypescriptEnabled);
+console.log("bcrypt loaded", !!bcrypt);
 
 async function insertLink({ title, url }) {
   await LinksCollection.insertAsync({ title, url, createdAt: new Date() });
diff --git a/tools/modern-tests/apps/react-router/server/resolve-extensions/first.jsx b/tools/modern-tests/apps/react-router/server/resolve-extensions/first.jsx
new file mode 100644
index 0000000000..f4a34cd479
--- /dev/null
+++ b/tools/modern-tests/apps/react-router/server/resolve-extensions/first.jsx
@@ -0,0 +1 @@
+console.log('first.jsx loaded');
diff --git a/tools/modern-tests/apps/react-router/server/resolve-extensions/first.tsx b/tools/modern-tests/apps/react-router/server/resolve-extensions/first.tsx
new file mode 100644
index 0000000000..fafcfe4cf4
--- /dev/null
+++ b/tools/modern-tests/apps/react-router/server/resolve-extensions/first.tsx
@@ -0,0 +1 @@
+console.log('first.tsx loaded');
diff --git a/tools/modern-tests/apps/react-router/server/ts/helpers.ts b/tools/modern-tests/apps/react-router/server/ts/helpers.ts
new file mode 100644
index 0000000000..67a82d6f6c
--- /dev/null
+++ b/tools/modern-tests/apps/react-router/server/ts/helpers.ts
@@ -0,0 +1 @@
+export const TypescriptEnabled: boolean = true;
diff --git a/tools/modern-tests/apps/react-router/styles/module.css b/tools/modern-tests/apps/react-router/styles/module.css
new file mode 100644
index 0000000000..2b1f0dafba
--- /dev/null
+++ b/tools/modern-tests/apps/react-router/styles/module.css
@@ -0,0 +1,3 @@
+body {
+  align-content: center;
+}
diff --git a/tools/modern-tests/apps/solid/.meteor/versions b/tools/modern-tests/apps/solid/.meteor/versions
index 568a832e00..1d4dd2a26c 100644
--- a/tools/modern-tests/apps/solid/.meteor/versions
+++ b/tools/modern-tests/apps/solid/.meteor/versions
@@ -54,14 +54,14 @@ reactive-var@1.0.13
 reload@1.3.2
 retry@1.1.1
 routepolicy@1.1.2
-rspack@1.0.0-beta340.0
+rspack@1.0.0-beta340.11
 shell-server@0.6.1
 socket-stream-client@0.6.1
 standard-minifier-css@1.9.3
 standard-minifier-js@3.1.1
 static-html@1.4.0
 static-html-tools@1.0.0
-tools-core@1.0.0-beta340.0
+tools-core@1.0.0-beta340.11
 tracker@1.3.4
 typescript@5.6.5
 webapp@2.0.7
diff --git a/tools/modern-tests/apps/solid/rspack.config.js b/tools/modern-tests/apps/solid/rspack.config.js
index 4b7ef941e5..2a399ac99c 100644
--- a/tools/modern-tests/apps/solid/rspack.config.js
+++ b/tools/modern-tests/apps/solid/rspack.config.js
@@ -1,4 +1,4 @@
-import { defineConfig } from '@meteorjs/rspack';
+const { defineConfig } = require('@meteorjs/rspack');
 
 /**
  * Rspack configuration for Meteor projects.
@@ -10,7 +10,7 @@ import { defineConfig } from '@meteorjs/rspack';
  *
  * Use these flags to adjust your build settings based on environment.
  */
-export default defineConfig(Meteor => {
+module.exports = defineConfig(Meteor => {
   return {
     ...Meteor.isClient && {
       module: {
diff --git a/tools/modern-tests/apps/svelte/.meteor/versions b/tools/modern-tests/apps/svelte/.meteor/versions
index a017451e5c..9f2afd5734 100644
--- a/tools/modern-tests/apps/svelte/.meteor/versions
+++ b/tools/modern-tests/apps/svelte/.meteor/versions
@@ -53,14 +53,14 @@ react-fast-refresh@0.2.9
 reload@1.3.2
 retry@1.1.1
 routepolicy@1.1.2
-rspack@1.0.0-beta340.0
+rspack@1.0.0-beta340.11
 shell-server@0.6.1
 socket-stream-client@0.6.1
 standard-minifier-css@1.9.3
 standard-minifier-js@3.1.1
 static-html@1.4.0
 static-html-tools@1.0.0
-tools-core@1.0.0-beta340.0
+tools-core@1.0.0-beta340.11
 tracker@1.3.4
 typescript@5.6.5
 webapp@2.0.7
diff --git a/tools/modern-tests/apps/svelte/rspack.config.js b/tools/modern-tests/apps/svelte/rspack.config.js
index 8674c37f4d..3161c3db9c 100644
--- a/tools/modern-tests/apps/svelte/rspack.config.js
+++ b/tools/modern-tests/apps/svelte/rspack.config.js
@@ -1,9 +1,6 @@
-import { defineConfig } from '@meteorjs/rspack';
-import path from 'path';
-import sveltePreprocess from 'svelte-preprocess';
-import { createRequire } from 'node:module';
-
-const require = createRequire(import.meta.url);
+const { defineConfig } = require('@meteorjs/rspack');
+const path = require('path');
+const sveltePreprocess = require('svelte-preprocess');
 
 /**
  * Rspack configuration for Meteor projects.
@@ -15,7 +12,7 @@ const require = createRequire(import.meta.url);
  *
  * Use these flags to adjust your build settings based on environment.
  */
-export default defineConfig(Meteor => {
+module.exports = defineConfig(Meteor => {
   return {
     ...Meteor.isClient && {
       resolve: {
diff --git a/tools/modern-tests/apps/typescript/.meteor/packages b/tools/modern-tests/apps/typescript/.meteor/packages
index 993162a9f0..da38d886c4 100644
--- a/tools/modern-tests/apps/typescript/.meteor/packages
+++ b/tools/modern-tests/apps/typescript/.meteor/packages
@@ -17,7 +17,7 @@ typescript              # Enable TypeScript syntax in .ts and .tsx modules
 shell-server            # Server-side component of the `meteor shell` command
 hot-module-replacement  # Update client in development without reloading the page
 
-
+fourseven:scss@5.0.0-rc.1 # Enable SCSS syntax in .scss using Meteor
 static-html             # Define static page content in .html files
 react-meteor-data       # React higher-order component for reactively tracking Meteor data
 zodern:types            # Pull in type declarations from other Meteor packages
diff --git a/tools/modern-tests/apps/typescript/client/main.scss b/tools/modern-tests/apps/typescript/client/main.scss
new file mode 100644
index 0000000000..7f354f0fa7
--- /dev/null
+++ b/tools/modern-tests/apps/typescript/client/main.scss
@@ -0,0 +1,4 @@
+body {
+  padding: 10px;
+  font-family: sans-serif;
+}
diff --git a/tools/modern-tests/apps/typescript/imports/ui/App.tsx b/tools/modern-tests/apps/typescript/imports/ui/App.tsx
index d354e1b352..52f71448cc 100644
--- a/tools/modern-tests/apps/typescript/imports/ui/App.tsx
+++ b/tools/modern-tests/apps/typescript/imports/ui/App.tsx
@@ -1,4 +1,5 @@
 import React from 'react';
+import './Global.scss';
 import { Hello } from './Hello';
 import { Info } from './Info';
 
diff --git a/tools/modern-tests/apps/typescript/imports/ui/Global.scss b/tools/modern-tests/apps/typescript/imports/ui/Global.scss
new file mode 100644
index 0000000000..2c0c9d93e3
--- /dev/null
+++ b/tools/modern-tests/apps/typescript/imports/ui/Global.scss
@@ -0,0 +1,3 @@
+body {
+    white-space: break-spaces;
+}
diff --git a/tools/modern-tests/apps/typescript/package.json b/tools/modern-tests/apps/typescript/package.json
index d831ddf726..bd5d960dc2 100644
--- a/tools/modern-tests/apps/typescript/package.json
+++ b/tools/modern-tests/apps/typescript/package.json
@@ -22,6 +22,9 @@
     "@types/react-dom": "^18.2.4",
     "assert": "^2.1.0",
     "playwright": "^1.54.2",
+    "sass": "^1.92.1",
+    "sass-embedded": "^1.92.1",
+    "sass-loader": "^16.0.5",
     "ts-checker-rspack-plugin": "^1.1.5",
     "typescript": "^5.4.5"
   },
@@ -34,6 +37,9 @@
       "client": "tests/client.ts",
       "server": "tests/server.ts"
     },
-    "modern": true
+    "modern": true,
+    "buildContext": "build",
+    "assetsContext": "assets",
+    "chunksContext": "chunks"
   }
 }
diff --git a/tools/modern-tests/apps/typescript/rspack.config.cjs b/tools/modern-tests/apps/typescript/rspack.config.cjs
new file mode 100644
index 0000000000..5c209dc30e
--- /dev/null
+++ b/tools/modern-tests/apps/typescript/rspack.config.cjs
@@ -0,0 +1,35 @@
+const { defineConfig } = require('@meteorjs/rspack');
+const { TsCheckerRspackPlugin } = require('ts-checker-rspack-plugin');
+
+/**
+ * Rspack configuration for Meteor projects.
+ *
+ * Provides typed flags on the `Meteor` object, such as:
+ * - `Meteor.isClient` / `Meteor.isServer`
+ * - `Meteor.isDevelopment` / `Meteor.isProduction`
+ * - …and other flags available
+ *
+ * Use these flags to adjust your build settings based on environment.
+ */
+module.exports = defineConfig(Meteor => {
+  return {
+    module: {
+      rules: [
+        {
+          test: /\.scss$/i,
+          use: [
+            {
+              loader: 'sass-loader',
+              options: {
+                api: 'modern-compiler',
+                implementation: require.resolve('sass-embedded'),
+              },
+            },
+          ],
+          type: 'css/auto',
+        },
+      ],
+    },
+    plugins: [new TsCheckerRspackPlugin()],
+  };
+});
diff --git a/tools/modern-tests/apps/typescript/tsconfig.json b/tools/modern-tests/apps/typescript/tsconfig.json
index 98ed85aae8..051daf943e 100644
--- a/tools/modern-tests/apps/typescript/tsconfig.json
+++ b/tools/modern-tests/apps/typescript/tsconfig.json
@@ -44,9 +44,9 @@
   "exclude": [
     "./.meteor/**",
     "./packages/**",
-    "./_build/**",
-    "./public/build-chunks/**",
-    "./public/build-assets/**",
-    "./private/build-assets/**"
+    "./build/**",
+    "./public/chunks/**",
+    "./public/assets/**",
+    "./private/assets/**"
   ]
 }
diff --git a/tools/modern-tests/apps/vue/.meteor/versions b/tools/modern-tests/apps/vue/.meteor/versions
index 568a832e00..1d4dd2a26c 100644
--- a/tools/modern-tests/apps/vue/.meteor/versions
+++ b/tools/modern-tests/apps/vue/.meteor/versions
@@ -54,14 +54,14 @@ reactive-var@1.0.13
 reload@1.3.2
 retry@1.1.1
 routepolicy@1.1.2
-rspack@1.0.0-beta340.0
+rspack@1.0.0-beta340.11
 shell-server@0.6.1
 socket-stream-client@0.6.1
 standard-minifier-css@1.9.3
 standard-minifier-js@3.1.1
 static-html@1.4.0
 static-html-tools@1.0.0
-tools-core@1.0.0-beta340.0
+tools-core@1.0.0-beta340.11
 tracker@1.3.4
 typescript@5.6.5
 webapp@2.0.7
diff --git a/tools/modern-tests/apps/vue/.meteorignore b/tools/modern-tests/apps/vue/.meteorignore
new file mode 100644
index 0000000000..21d63e9485
--- /dev/null
+++ b/tools/modern-tests/apps/vue/.meteorignore
@@ -0,0 +1,2 @@
+# Ignore client/main.css file so that is processed by Rspack import
+client/main.css
diff --git a/tools/modern-tests/apps/vue/client/main.css b/tools/modern-tests/apps/vue/client/main.css
new file mode 100644
index 0000000000..d61a8dd67c
--- /dev/null
+++ b/tools/modern-tests/apps/vue/client/main.css
@@ -0,0 +1,3 @@
+body {
+    padding: 10px;
+}
diff --git a/tools/modern-tests/apps/vue/client/main.js b/tools/modern-tests/apps/vue/client/main.js
index 403d8a2d2a..64512a8d55 100644
--- a/tools/modern-tests/apps/vue/client/main.js
+++ b/tools/modern-tests/apps/vue/client/main.js
@@ -1 +1,2 @@
-import '../imports/ui/main'
\ No newline at end of file
+import './main.css';
+import '../imports/ui/main';
diff --git a/tools/modern-tests/apps/vue/client/meteor.css b/tools/modern-tests/apps/vue/client/meteor.css
new file mode 100644
index 0000000000..853ac29a7c
--- /dev/null
+++ b/tools/modern-tests/apps/vue/client/meteor.css
@@ -0,0 +1,3 @@
+body {
+    font-family: sans-serif;
+}
diff --git a/tools/modern-tests/apps/vue/imports/ui/main.css b/tools/modern-tests/apps/vue/imports/ui/main.css
index 6ea2603dca..f1d8c73cdc 100644
--- a/tools/modern-tests/apps/vue/imports/ui/main.css
+++ b/tools/modern-tests/apps/vue/imports/ui/main.css
@@ -1,6 +1 @@
 @import "tailwindcss";
-
-body {
-    padding: 10px;
-    font-family: sans-serif;
-}
diff --git a/tools/modern-tests/apps/vue/package.json b/tools/modern-tests/apps/vue/package.json
index 8bc5421981..77ccaa1380 100644
--- a/tools/modern-tests/apps/vue/package.json
+++ b/tools/modern-tests/apps/vue/package.json
@@ -17,7 +17,7 @@
     "vue-router": "^4.2.5"
   },
   "devDependencies": {
-    "@meteorjs/rspack": "^0.0.36",
+    "@meteorjs/rspack": "^0.0.60",
     "@rspack/cli": "^1.4.8",
     "@rspack/core": "^1.4.8",
     "@tailwindcss/postcss": "^4.1.12",
diff --git a/tools/modern-tests/apps/vue/rspack.config.js b/tools/modern-tests/apps/vue/rspack.config.js
index 1f99e6320a..9f7fb1cd8f 100644
--- a/tools/modern-tests/apps/vue/rspack.config.js
+++ b/tools/modern-tests/apps/vue/rspack.config.js
@@ -1,5 +1,5 @@
-import { defineConfig } from '@meteorjs/rspack';
-import { VueLoaderPlugin } from 'vue-loader';
+const { defineConfig } = require('@meteorjs/rspack');
+const { VueLoaderPlugin } = require('vue-loader');
 
 /**
  * Rspack configuration for Meteor projects.
@@ -11,7 +11,7 @@ import { VueLoaderPlugin } from 'vue-loader';
  *
  * Use these flags to adjust your build settings based on environment.
  */
-export default defineConfig(Meteor => {
+module.exports = defineConfig(Meteor => {
   return {
     ...Meteor.isClient && {
       plugins: [new VueLoaderPlugin()],
diff --git a/tools/modern-tests/assertions.js b/tools/modern-tests/assertions.js
index cf31f15aaa..4b873f6d9e 100644
--- a/tools/modern-tests/assertions.js
+++ b/tools/modern-tests/assertions.js
@@ -215,18 +215,40 @@ export async function assertConsoleEval(code, expectedResult, options = {}) {
 }
 
 /**
- * Helper function to assert that the body element has the expected CSS styles
+ * Helper function to assert that an element has the expected CSS styles
+ * @param {string} selector - CSS selector string (e.g., 'body', '.my-class') or a string representing a DOM element (e.g., 'document.body')
  * @param {Object} expectedStyles - Expected CSS styles as key-value pairs
  * @param {Object} options - Additional options for assertConsoleEval
  * @returns {Promise<Object>} - A promise that resolves with the computed styles
  */
-export async function assertBodyStyles(expectedStyles, options = {}) {
-  console.log(`Asserting body styles: ${JSON.stringify(expectedStyles)}`);
+export async function assertStyles(selector, expectedStyles, options = {}) {
+  // Determine if the selector is a CSS selector or a DOM element reference
+  const isCssSelector = selector.startsWith('.') || 
+    selector.startsWith('#') ||
+    selector.startsWith('[') ||
+    selector === 'body' ||
+    selector.includes(' ');
+
+  console.log(`Asserting styles for ${selector}: ${JSON.stringify(expectedStyles)}`);
 
   // Create a JavaScript code string that evaluates the computed styles
   const code = `
     (() => {
-      const computedStyle = getComputedStyle(document.body);
+      let element;
+
+      // Handle the selector based on its type
+      ${isCssSelector 
+        ? `element = document.querySelector('${selector}');
+           if (!element) {
+             throw new Error('Element not found with selector: ${selector}');
+           }`
+        : `element = ${selector};
+           if (!element) {
+             throw new Error('Element not found: ${selector}');
+           }`
+      }
+
+      const computedStyle = getComputedStyle(element);
       const result = {};
       ${Object.keys(expectedStyles).map(prop => 
         `result['${prop}'] = computedStyle.getPropertyValue('${prop}');`
@@ -236,12 +258,23 @@ export async function assertBodyStyles(expectedStyles, options = {}) {
   `;
 
   // Use assertConsoleEval to evaluate the code and check the result
-  return await assertConsoleEval(code, expectedStyles, { 
+  return assertConsoleEval(code, expectedStyles, {
     exactMatch: false,
     ...options
   });
 }
 
+/**
+ * Helper function to assert that the body element has the expected CSS styles
+ * @param {Object} expectedStyles - Expected CSS styles as key-value pairs
+ * @param {Object} options - Additional options for assertConsoleEval
+ * @returns {Promise<Object>} - A promise that resolves with the computed styles
+ */
+export async function assertBodyStyles(expectedStyles, options = {}) {
+  // Use assertStyles with document.body as the selector
+  return assertStyles('document.body', expectedStyles, options);
+}
+
 /**
  * Helper function to assert that meta tags have the expected content
  * @param {Object} expectedMetaTags - Expected meta tag properties and values as key-value pairs
diff --git a/tools/modern-tests/babel.test.js b/tools/modern-tests/babel.test.js
index 218a16a4c9..a414d7bbb0 100644
--- a/tools/modern-tests/babel.test.js
+++ b/tools/modern-tests/babel.test.js
@@ -12,6 +12,7 @@ describe('Babel App Bundling /', () => {
       server: 'server/main.js',
       test: 'tests/main.js'
     },
+    configFile: 'rspack.config.mjs',
     customAssertions: {
       afterRun: async ({ result }) => {
         await assertFileExtensionModuleRules(result.outputLines);
diff --git a/tools/modern-tests/helpers.js b/tools/modern-tests/helpers.js
index d29c5d8ee7..40acba09bd 100644
--- a/tools/modern-tests/helpers.js
+++ b/tools/modern-tests/helpers.js
@@ -13,9 +13,13 @@ const METEOR_EXECUTABLE = path.join(REPO_ROOT, 'meteor');
  * Helper function to set up a Meteor app in a temporary directory
  * Copies the app and runs npm install
  * @param {string} appName - Name of the app in the apps directory
+ * @param {Object} options - Additional options
+ * @param {boolean} options.isMonorepo - Whether the app is a monorepo
  * @returns {string} - Path to the temporary directory containing the app
  */
-export async function setupMeteorApp(appName) {
+export async function setupMeteorApp(appName, options = {}) {
+  const { isMonorepo = false } = options;
+
   // Create a unique temporary directory
   const randomSuffix = Math.random().toString(36).substring(2, 10);
   const tempDir = path.join(os.tmpdir(), `meteortest-${appName}-${randomSuffix}`);
@@ -42,13 +46,30 @@ export async function setupMeteorApp(appName) {
     console.error('Error during copy:', err);
   }
 
-  // Run npm install in the temporary directory
-  console.log('Running npm install...');
-  await execa.command('npm install', {
-    cwd: tempDir,
-    stdio: 'inherit',
-    shell: true,
-  });
+  if (isMonorepo) {
+    // For monorepo, install dependencies at both root and app level
+    console.log('Running npm install at root level...');
+    await execa.command('npm install', {
+      cwd: tempDir,
+      stdio: 'inherit',
+      shell: true,
+    });
+
+    console.log('Running npm install at app level...');
+    await execa.command('npm install', {
+      cwd: path.join(tempDir, 'app'),
+      stdio: 'inherit',
+      shell: true,
+    });
+  } else {
+    // For regular apps, just install at the root
+    console.log('Running npm install...');
+    await execa.command('npm install', {
+      cwd: tempDir,
+      stdio: 'inherit',
+      shell: true,
+    });
+  }
 
   return { tempDir };
 }
@@ -61,9 +82,12 @@ export async function setupMeteorApp(appName) {
  * @param {string|RegExp} options.waitForOutput - Output pattern to wait for
  * @param {Object} options.waitOptions - Options for waitForMeteorOutput
  * @param {string[]} options.commandOptions - Additional command line options for the run command (e.g. ['--production'])
+ * @param {boolean} options.isMonorepo - Whether the app is a monorepo
  * @returns {Object} - The meteor process and output lines
  */
 export async function runMeteorApp(tempDir, port, options = {}) {
+  const { isMonorepo = false } = options;
+
   // Start Meteor CLI in dev mode
   console.log(`Starting Meteor app on port ${port}...`);
 
@@ -76,11 +100,14 @@ export async function runMeteorApp(tempDir, port, options = {}) {
     args.push(...options.commandOptions);
   }
 
+  // For monorepo, run the meteor command from the app subdirectory
+  const appDir = isMonorepo ? path.join(tempDir, 'app') : tempDir;
+
   // Run the meteor command
   const { meteorProcess, outputLines } = await runMeteorCommand(
     'run', 
     args, 
-    tempDir,
+    appDir,
     {
       captureOutput
     }
@@ -476,9 +503,12 @@ export async function appendFileContent(tempDir, filePath, options = {}) {
  * @param {Object} options.waitOptions - Options for waitForMeteorOutput
  * @param {string[]} options.commandOptions - Additional command line options for the test command
  * @param {boolean} options.checkTestResults - Whether to check test results and propagate failures to Jest
+ * @param {boolean} options.isMonorepo - Whether the app is a monorepo
  * @returns {Object} - The meteor process and output lines
  */
 export async function runMeteorTests(tempDir, port, options = {}) {
+  const { isMonorepo = false } = options;
+
   // Start Meteor tests
   console.log(`Starting Meteor tests on port ${port}...`);
 
@@ -491,11 +521,14 @@ export async function runMeteorTests(tempDir, port, options = {}) {
     args.push(...options.commandOptions);
   }
 
+  // For monorepo, run the meteor command from the app subdirectory
+  const appDir = isMonorepo ? path.join(tempDir, 'app') : tempDir;
+
   // Run the meteor test command
   const { meteorProcess, outputLines, processResult } = await runMeteorCommand(
     'test', 
     args, 
-    tempDir,
+    appDir,
     {
       execaOptions: {
         env: {
@@ -647,9 +680,12 @@ export async function waitForPlaywrightConsole(pattern, options = {}) {
  * @param {Object} options - Additional options
  * @param {string[]} options.commandOptions - Additional command line options for the build command
  * @param {boolean} options.captureOutput - Whether to capture the command's output
+ * @param {boolean} options.isMonorepo - Whether the app is a monorepo
  * @returns {Object} - The build output directory and the meteor process result
  */
 export async function buildMeteorApp(tempDir, options = {}) {
+  const { isMonorepo = false } = options;
+
   // Create a unique temporary directory for the build output
   const randomSuffix = Math.random().toString(36).substring(2, 10);
   const buildOutputDir = path.join(os.tmpdir(), `meteor-build-${randomSuffix}`);
@@ -667,11 +703,14 @@ export async function buildMeteorApp(tempDir, options = {}) {
     args.push(...options.commandOptions);
   }
 
+  // For monorepo, run the meteor command from the app subdirectory
+  const appDir = isMonorepo ? path.join(tempDir, 'app') : tempDir;
+
   // Run the meteor build command with automatic exit code checking
   const result = await runMeteorCommand(
     'build', 
     args, 
-    tempDir,
+    appDir,
     {
       execaOptions: options.execaOptions || {},
       captureOutput: options.captureOutput !== undefined ? options.captureOutput : true,
diff --git a/tools/modern-tests/jest.config.js b/tools/modern-tests/jest.config.js
index e89d17b797..160d7af6cf 100644
--- a/tools/modern-tests/jest.config.js
+++ b/tools/modern-tests/jest.config.js
@@ -2,6 +2,7 @@ module.exports = {
   preset: 'jest-playwright-preset',
   rootDir: __dirname,
   testMatch: ["**/*.test.js"],
+  testPathIgnorePatterns: ["<rootDir>/apps/"],
   setupFilesAfterEnv: ['<rootDir>/jest.setup.js'],
   verbose: true,
   // Increase timeout for CLI operations
diff --git a/tools/modern-tests/jest.setup.js b/tools/modern-tests/jest.setup.js
index 83590326d1..6b950af3a3 100644
--- a/tools/modern-tests/jest.setup.js
+++ b/tools/modern-tests/jest.setup.js
@@ -1,6 +1,11 @@
 // jest.setup.js
 import chalk from 'chalk';
 
+// Set fixed ports for all tests
+process.env.RSPACK_DEVSERVER_PORT = '8080';
+process.env.RSDOCTOR_CLIENT_PORT = '8888';
+process.env.RSDOCTOR_SERVER_PORT = '8889';
+
 // This runs before each test
 beforeEach(() => {
   const name = expect.getState().currentTestName;
diff --git a/tools/modern-tests/monorepo.test.js b/tools/modern-tests/monorepo.test.js
new file mode 100644
index 0000000000..d40c77a544
--- /dev/null
+++ b/tools/modern-tests/monorepo.test.js
@@ -0,0 +1,27 @@
+import {
+  waitForMeteorOutput,
+} from "./helpers";
+import { testMeteorRspackBundler } from './test-helpers';
+
+describe('Monorepo App Bundling /', () => {
+  describe('Meteor+Rspack Bundler /', testMeteorRspackBundler({
+    appName: 'monorepo',
+    port: 3133,
+    isMonorepo: true,
+    filePaths: { 
+      client: 'app/client/main.jsx', 
+      server: 'app/server/main.js',
+      test: 'app/tests/main.test.js'
+    },
+    customAssertions: {
+      afterRunRebuildClient: async ({ allConsoleLogs }) => {
+        // Check for HMR output as enabled by default
+        await waitForMeteorOutput(allConsoleLogs, /.*HMR.*Updated modules:.*/);
+      },
+      afterRunProductionRebuildClient: async ({ allConsoleLogs }) => {
+        // Check for HMR to not be enabled in production-like mode
+        await waitForMeteorOutput(allConsoleLogs, /.*HMR.*Updated modules:*/, { negate: true });
+      },
+    }
+  }));
+});
diff --git a/tools/modern-tests/react-router.test.js b/tools/modern-tests/react-router.test.js
index 47c42fcf08..9e7d7c0349 100644
--- a/tools/modern-tests/react-router.test.js
+++ b/tools/modern-tests/react-router.test.js
@@ -19,14 +19,22 @@ describe('ReactRouter App Bundling /', () => {
       process.env.METEOR_PACKAGE_DIRS = '';
     },
     customAssertions: {
-      afterRun: async ({ result, port }) => {
-        await waitForReactEnvs(result.outputLines, { isJsxEnabled: true });
+      afterInit: async ({ result }) => {
         await waitForMeteorOutput(result.outputLines, /.*babel-plugin-react-compiler.*/);
+      },
+      afterRun: async ({ result, port }) => {
+        await waitForReactEnvs(result.outputLines, { isTsxEnabled: true });
+        // negated as cached output (babel.config.js)
+        await waitForMeteorOutput(result.outputLines, /.*babel-plugin-react-compiler.*/, { negate: true });
         await assert404Page(port);
         // Less styles support
         await assertBodyStyles({
           'white-space': 'break-spaces',
         });
+        // Meteor modules config
+        await assertBodyStyles({
+          'align-content': 'center',
+        });
         // Custom html rspack plugin options
         await assertMetaTags({
           'theme-color': '#4285f4',
@@ -35,19 +43,25 @@ describe('ReactRouter App Bundling /', () => {
         await waitForMeteorOutput(result.outputLines, /.*default-package loaded.*/);
         // custom-package loading
         await waitForMeteorOutput(result.outputLines, /.*custom-package loaded.*/);
+        // resolve.extensions loading
+        await waitForMeteorOutput(result.outputLines, /.*first\.jsx loaded.*/);
       },
       afterRunRebuildClient: async ({ allConsoleLogs }) => {
         // Check for HMR output as enabled by default
         await waitForMeteorOutput(allConsoleLogs, /.*HMR.*Updated modules:.*/);
       },
       afterRunProduction: async ({ result, port }) => {
-        await waitForReactEnvs(result.outputLines, { isJsxEnabled: true });
+        await waitForReactEnvs(result.outputLines, { isTsxEnabled: true });
         await waitForMeteorOutput(result.outputLines, /.*babel-plugin-react-compiler.*/);
         await assert404Page(port, { isProductionMode: true });
         // Less styles support
         await assertBodyStyles({
           'white-space': 'break-spaces',
         });
+        // Meteor modules config
+        await assertBodyStyles({
+          'align-content': 'center',
+        });
         // Custom html rspack plugin options
         await assertMetaTags({
           'theme-color': '#4285f4',
@@ -64,7 +78,7 @@ describe('ReactRouter App Bundling /', () => {
         await waitForReactEnvs(result.outputLines);
       },
       afterBuild: async ({ result }) => {
-        await waitForReactEnvs(result.outputLines, { isJsxEnabled: true });
+        await waitForReactEnvs(result.outputLines, { isTsxEnabled: true });
         await waitForMeteorOutput(result.outputLines, /.*babel-plugin-react-compiler.*/);
       },
     }
@@ -85,10 +99,10 @@ export async function waitForReactEnvs(outputLines, options = {}) {
     /.*isReactEnabled:.*true.*/,
     options
   );
-  if (options.isJsxEnabled) {
+  if (options.isTsxEnabled) {
     await waitForMeteorOutput(
       outputLines,
-      /.*isJsxEnabled:.*true.*/,
+      /.*isTsxEnabled:.*true.*/,
       options
     );
   }
diff --git a/tools/modern-tests/skeleton.test.js b/tools/modern-tests/skeleton.test.js
index e8adb6c15c..f0670a7451 100644
--- a/tools/modern-tests/skeleton.test.js
+++ b/tools/modern-tests/skeleton.test.js
@@ -6,6 +6,7 @@
 
 
 import { testMeteorSkeleton } from "./test-helpers";
+import { assertStyles } from "./assertions";
 
 describe('Meteor Skeletons /', () => {
   describe('Apollo Skeleton /', testMeteorSkeleton({
@@ -18,6 +19,16 @@ describe('Meteor Skeletons /', () => {
     },
   }));
 
+  describe('Babel Skeleton /', testMeteorSkeleton({
+    skeletonName: 'babel',
+    port: 3212,
+    filePaths: {
+      client: 'client/main.jsx',
+      server: 'server/main.js',
+      test: 'tests/main.js'
+    },
+  }));
+
   describe('Blaze Skeleton /', testMeteorSkeleton({
     skeletonName: 'blaze',
     port: 3202,
@@ -39,6 +50,16 @@ describe('Meteor Skeletons /', () => {
     checkBodyStyles: false,
   }));
 
+  describe('Coffeescript Skeleton /', testMeteorSkeleton({
+    skeletonName: 'coffeescript',
+    port: 3211,
+    filePaths: {
+      client: 'client/main.coffee',
+      server: 'server/main.coffee',
+      test: 'tests/main.coffee',
+    },
+  }));
+
   describe('Full Skeleton /', testMeteorSkeleton({
     skeletonName: 'full',
     port: 3204,
@@ -87,6 +108,20 @@ describe('Meteor Skeletons /', () => {
       server: 'server/main.ts',
       test: 'tests/main.ts',
     },
+    customAssertions: {
+      afterRun: async () => {
+        // Verify Tailwind styles for ".bg-gray-100" element
+        await assertStyles('.bg-gray-100', {
+          ['background-color']: 'oklch(0.967 0.003 264.542)',
+        });
+      },
+      afterRunProduction: async () => {
+        // Verify Tailwind styles for ".bg-gray-100" element
+        await assertStyles('.bg-gray-100', {
+          ['background-color']: 'lab(96.1596 -0.0823438 -1.13575)',
+        });
+      }
+    }
   }));
 
   describe('Typescript Skeleton /', testMeteorSkeleton({
diff --git a/tools/modern-tests/test-helpers.js b/tools/modern-tests/test-helpers.js
index 6277d0383e..430077681a 100644
--- a/tools/modern-tests/test-helpers.js
+++ b/tools/modern-tests/test-helpers.js
@@ -115,10 +115,11 @@ export function testMeteorBundler(options) {
  * @returns {Function} - Jest test function
  */
 export function testMeteorRspackBundler(options) {
-  const { 
-    appName, 
-    port, 
-    filePaths = { 
+  const {
+    appName,
+    port,
+    isMonorepo = false,
+    filePaths = {
       client: 'client/main.jsx',
       server: 'server/main.js',
       test: 'tests/main.js',
@@ -151,11 +152,16 @@ export function testMeteorRspackBundler(options) {
     // Additional behavior for beforeAll and afterAll
     beforeAllBehavior,
     afterAllBehavior,
+    // Build directory (default: '_build')
+    buildDir = '_build',
+    // Rspack config file (default: 'rspack.config.js')
+    configFile = 'rspack.config.js',
   } = options;
 
   return () => {
     let meteorProcess;
     let tempDir;
+    let appDir;
 
     beforeAll(async () => {
       // Run additional beforeAll behavior
@@ -168,20 +174,22 @@ export function testMeteorRspackBundler(options) {
       await killProcessByPort('8080');
 
       // Setup the Meteor app
-      tempDir = (await setupMeteorApp(appName))?.tempDir;
+      tempDir = (await setupMeteorApp(appName, { isMonorepo }))?.tempDir;
 
       // Add Rspack package
-      await runMeteorCommand('add', ['rspack'], tempDir, { checkExitCode: true });
+      appDir = isMonorepo ? path.join(tempDir, 'app') : tempDir;
+      await runMeteorCommand('add', ['rspack'], appDir, { checkExitCode: true });
 
       // Set meteor.modern.verbose to true
       if (verbose) {
-        await execa('npm', ['pkg', 'delete', 'meteor.modern'], { cwd: tempDir });
-        await execa('npm', ['pkg', 'set', 'meteor.modern.verbose=true'], { cwd: tempDir });
+        await execa('npm', ['pkg', 'delete', 'meteor.modern'], { cwd: appDir });
+        await execa('npm', ['pkg', 'set', 'meteor.modern.verbose=true'], { cwd: appDir });
       }
 
       // Run the Meteor app to install Rspack
       const result = await runMeteorApp(tempDir, port, {
         waitForOutput: "=> App running at:",
+        isMonorepo
       });
       meteorProcess = result.meteorProcess;
 
@@ -189,8 +197,13 @@ export function testMeteorRspackBundler(options) {
       await wait(1000);
 
       // Assert that the config files exists
-      await assertFileExist(tempDir, '.gitignore', { content: '_build' });
-      await assertFileExist(tempDir, 'rspack.config.js', { content: '@meteorjs/rspack' });
+      await assertFileExist(appDir, '.gitignore', { content: buildDir });
+      await assertFileExist(appDir, configFile, { content: '@meteorjs/rspack' });
+
+      // Run custom assertions if provided
+      if (customAssertions && customAssertions.afterInit) {
+        await customAssertions.afterInit({ tempDir, port, meteorProcess, result });
+      }
 
       // Kill the meteor process
       await killMeteorProcess(meteorProcess);
@@ -214,6 +227,7 @@ export function testMeteorRspackBundler(options) {
       // Run the Meteor app and wait for "restarted at" output
       const result = await runMeteorApp(tempDir, port, {
         waitForOutput: "=> App running at:",
+        isMonorepo
       });
       meteorProcess = result.meteorProcess;
 
@@ -221,12 +235,12 @@ export function testMeteorRspackBundler(options) {
       await wait(500);
 
       // Assert that the app files exists
-      await assertFileExist(tempDir, '_build/main-dev/client-entry.js');
-      await assertFileExist(tempDir, '_build/main-dev/client-rspack.js');
-      await assertFileExist(tempDir, '_build/main-dev/client-meteor.js');
-      await assertFileExist(tempDir, '_build/main-dev/server-entry.js');
-      await assertFileExist(tempDir, '_build/main-dev/server-rspack.js');
-      await assertFileExist(tempDir, '_build/main-dev/server-meteor.js');
+      await assertFileExist(appDir, `${buildDir}/main-dev/client-entry.js`);
+      await assertFileExist(appDir, `${buildDir}/main-dev/client-rspack.js`);
+      await assertFileExist(appDir, `${buildDir}/main-dev/client-meteor.js`);
+      await assertFileExist(appDir, `${buildDir}/main-dev/server-entry.js`);
+      await assertFileExist(appDir, `${buildDir}/main-dev/server-rspack.js`);
+      await assertFileExist(appDir, `${buildDir}/main-dev/server-meteor.js`);
 
       // Assert that the Meteor app is running correctly
       await assertMeteorReactApp(port, { title: appName });
@@ -253,11 +267,11 @@ export function testMeteorRspackBundler(options) {
 
       // Run custom assertions if provided
       if (customAssertions && customAssertions.afterRunRebuildClient) {
-        await customAssertions.afterRunRebuildClient({ 
-          tempDir, 
-          port, 
-          meteorProcess, 
-          result, 
+        await customAssertions.afterRunRebuildClient({
+          tempDir,
+          port,
+          meteorProcess,
+          result,
           allConsoleLogs: consoleLogs.allLogs
         });
       }
@@ -303,6 +317,7 @@ export function testMeteorRspackBundler(options) {
       const result = await runMeteorApp(tempDir, port, {
         waitForOutput: "=> App running at:",
         commandOptions: ['--production'],
+        isMonorepo
       });
       meteorProcess = result.meteorProcess;
 
@@ -310,13 +325,13 @@ export function testMeteorRspackBundler(options) {
       await wait(500);
 
       // Assert that the app files exists
-      await assertFileExist(tempDir, '_build/main-prod/client-entry.js');
-      await assertFileExist(tempDir, '_build/main-prod/client-rspack.js');
-      await assertFileExist(tempDir, '_build/main-prod/client-meteor.js');
-      await assertFileExist(tempDir, '_build/main-prod/server-entry.js');
-      await assertFileExist(tempDir, '_build/main-prod/server-rspack.js');
-      await assertFileExist(tempDir, '_build/main-prod/server-meteor.js');
-      await assertFileExist(tempDir, '_build/main-prod/index.html');
+      await assertFileExist(appDir, `${buildDir}/main-prod/client-entry.js`);
+      await assertFileExist(appDir, `${buildDir}/main-prod/client-rspack.js`);
+      await assertFileExist(appDir, `${buildDir}/main-prod/client-meteor.js`);
+      await assertFileExist(appDir, `${buildDir}/main-prod/server-entry.js`);
+      await assertFileExist(appDir, `${buildDir}/main-prod/server-rspack.js`);
+      await assertFileExist(appDir, `${buildDir}/main-prod/server-meteor.js`);
+      await assertFileExist(appDir, `${buildDir}/main-prod/index.html`);
 
       await assertFileExist(tempDir, filePaths.server);
 
@@ -345,10 +360,10 @@ export function testMeteorRspackBundler(options) {
 
       // Run custom assertions if provided
       if (customAssertions && customAssertions.afterRunProductionRebuildClient) {
-        await customAssertions.afterRunProductionRebuildClient({ 
-          tempDir, 
-          port, 
-          meteorProcess, 
+        await customAssertions.afterRunProductionRebuildClient({
+          tempDir,
+          port,
+          meteorProcess,
           result,
           allConsoleLogs: consoleLogs.allLogs
         });
@@ -397,6 +412,7 @@ export function testMeteorRspackBundler(options) {
         const result = await runMeteorApp(tempDir, port, {
           waitForOutput: "=> App running at:",
           commandOptions: ['--extra-packages', 'bundle-visualizer', '--production'],
+          isMonorepo
         });
         meteorProcess = result.meteorProcess;
 
@@ -404,13 +420,13 @@ export function testMeteorRspackBundler(options) {
         await wait(500);
 
         // Assert that the app files exists
-        await assertFileExist(tempDir, '_build/main-prod/client-entry.js');
-        await assertFileExist(tempDir, '_build/main-prod/client-rspack.js');
-        await assertFileExist(tempDir, '_build/main-prod/client-meteor.js');
-        await assertFileExist(tempDir, '_build/main-prod/server-entry.js');
-        await assertFileExist(tempDir, '_build/main-prod/server-rspack.js');
-        await assertFileExist(tempDir, '_build/main-prod/server-meteor.js');
-        await assertFileExist(tempDir, '_build/main-prod/index.html');
+        await assertFileExist(appDir, `${buildDir}/main-prod/client-entry.js`);
+        await assertFileExist(appDir, `${buildDir}/main-prod/client-rspack.js`);
+        await assertFileExist(appDir, `${buildDir}/main-prod/client-meteor.js`);
+        await assertFileExist(appDir, `${buildDir}/main-prod/server-entry.js`);
+        await assertFileExist(appDir, `${buildDir}/main-prod/server-rspack.js`);
+        await assertFileExist(appDir, `${buildDir}/main-prod/server-meteor.js`);
+        await assertFileExist(appDir, `${buildDir}/main-prod/index.html`);
 
         // Assert that the Meteor app is running correctly
         await assertMeteorReactApp(port, { title: appName });
@@ -455,6 +471,7 @@ export function testMeteorRspackBundler(options) {
         waitForOutput: "=> App running at:",
         commandOptions: testFullApp ? ['--full-app'] : [],
         checkTestResults: false,
+        isMonorepo
       });
       meteorProcess = result.meteorProcess;
 
@@ -465,16 +482,16 @@ export function testMeteorRspackBundler(options) {
 
       // Assert that the app files exists
       if (isTestModule) {
-        await assertFileExist(tempDir, '_build/test/test-entry.js');
-        await assertFileExist(tempDir, '_build/test/test-rspack.js');
-        await assertFileExist(tempDir, '_build/test/test-meteor.js');
+        await assertFileExist(appDir, `${buildDir}/test/test-entry.js`);
+        await assertFileExist(appDir, `${buildDir}/test/test-rspack.js`);
+        await assertFileExist(appDir, `${buildDir}/test/test-meteor.js`);
       } else {
-        await assertFileExist(tempDir, '_build/test/client-entry.js');
-        await assertFileExist(tempDir, '_build/test/client-rspack.js');
-        await assertFileExist(tempDir, '_build/test/client-meteor.js');
-        await assertFileExist(tempDir, '_build/test/server-entry.js');
-        await assertFileExist(tempDir, '_build/test/server-rspack.js');
-        await assertFileExist(tempDir, '_build/test/server-meteor.js');
+        await assertFileExist(appDir, `${buildDir}/test/client-entry.js`);
+        await assertFileExist(appDir, `${buildDir}/test/client-rspack.js`);
+        await assertFileExist(appDir, `${buildDir}/test/client-meteor.js`);
+        await assertFileExist(appDir, `${buildDir}/test/server-entry.js`);
+        await assertFileExist(appDir, `${buildDir}/test/server-rspack.js`);
+        await assertFileExist(appDir, `${buildDir}/test/server-meteor.js`);
       }
 
       // Run custom assertions if provided
@@ -538,6 +555,7 @@ export function testMeteorRspackBundler(options) {
         waitForOutput: "=> App running at:",
         commandOptions: testFullApp ? ['--full-app', '--once'] : ['--once'],
         checkTestResults: true,
+        isMonorepo
       });
 
       // Wait for a margin
@@ -547,16 +565,16 @@ export function testMeteorRspackBundler(options) {
 
       // Assert that the app files exists
       if (isTestModule) {
-        await assertFileExist(tempDir, '_build/test/test-entry.js');
-        await assertFileExist(tempDir, '_build/test/test-rspack.js');
-        await assertFileExist(tempDir, '_build/test/test-meteor.js');
+        await assertFileExist(appDir, `${buildDir}/test/test-entry.js`);
+        await assertFileExist(appDir, `${buildDir}/test/test-rspack.js`);
+        await assertFileExist(appDir, `${buildDir}/test/test-meteor.js`);
       } else {
-        await assertFileExist(tempDir, '_build/test/client-entry.js');
-        await assertFileExist(tempDir, '_build/test/client-rspack.js');
-        await assertFileExist(tempDir, '_build/test/client-meteor.js');
-        await assertFileExist(tempDir, '_build/test/server-entry.js');
-        await assertFileExist(tempDir, '_build/test/server-rspack.js');
-        await assertFileExist(tempDir, '_build/test/server-meteor.js');
+        await assertFileExist(appDir, `${buildDir}/test/client-entry.js`);
+        await assertFileExist(appDir, `${buildDir}/test/client-rspack.js`);
+        await assertFileExist(appDir, `${buildDir}/test/client-meteor.js`);
+        await assertFileExist(appDir, `${buildDir}/test/server-entry.js`);
+        await assertFileExist(appDir, `${buildDir}/test/server-rspack.js`);
+        await assertFileExist(appDir, `${buildDir}/test/server-meteor.js`);
       }
 
       if (verbose) {
@@ -583,7 +601,8 @@ export function testMeteorRspackBundler(options) {
       // Build the app with Rspack
       const { buildOutputDir, processResult: result } = await buildMeteorApp(tempDir, {
         commandOptions: ['--directory'],
-        captureOutput: true
+        captureOutput: true,
+        isMonorepo
       });
 
       // Wait for a margin
diff --git a/tools/modern-tests/typescript.test.js b/tools/modern-tests/typescript.test.js
index 8981aa50be..fff1a329ec 100644
--- a/tools/modern-tests/typescript.test.js
+++ b/tools/modern-tests/typescript.test.js
@@ -2,7 +2,7 @@ import {
   waitForMeteorOutput,
 } from "./helpers";
 import { testMeteorRspackBundler } from './test-helpers';
-import { assertFileExist } from "./assertions";
+import { assertBodyStyles, assertFileExist } from "./assertions";
 
 describe('TypeScript App Bundling /', () => {
   describe('Meteor+Rspack Bundler /', testMeteorRspackBundler({
@@ -14,8 +14,14 @@ describe('TypeScript App Bundling /', () => {
       testClient: 'tests/client.ts',
       testServer: 'tests/server.ts',
     },
+    buildDir: 'build',
+    configFile: 'rspack.config.cjs',
     customAssertions: {
       afterRun: async ({ result, tempDir }) => {
+        // SCSS styles support
+        await assertBodyStyles({
+          'white-space': 'break-spaces',
+        });
         await waitForTypeScriptEnvs(result.outputLines, { isTsxEnabled: true });
         await waitForTypeScriptErrorFree(result.outputLines);
         await assertFileExist(tempDir, '.meteor/local/types');
@@ -25,6 +31,10 @@ describe('TypeScript App Bundling /', () => {
         await waitForMeteorOutput(allConsoleLogs, /.*HMR.*Updated modules:.*/);
       },
       afterRunProduction: async ({ result }) => {
+        // SCSS styles support
+        await assertBodyStyles({
+          'white-space': 'break-spaces',
+        });
         await waitForTypeScriptEnvs(result.outputLines, { isTsxEnabled: true });
       },
       afterRunProductionRebuildClient: async ({ allConsoleLogs }) => {
diff --git a/tools/modern-tests/vue.test.js b/tools/modern-tests/vue.test.js
index 82eec04a0c..db298b2b14 100644
--- a/tools/modern-tests/vue.test.js
+++ b/tools/modern-tests/vue.test.js
@@ -2,6 +2,7 @@ import {
   waitForMeteorOutput,
 } from "./helpers";
 import { testMeteorRspackBundler } from './test-helpers';
+import { assertStyles } from "./assertions";
 
 describe('Vue App Bundling /', () => {
   describe('Meteor+Rspack Bundler /', testMeteorRspackBundler({
@@ -13,10 +14,22 @@ describe('Vue App Bundling /', () => {
       test: 'tests/main.js'
     },
     customAssertions: {
+      afterRun: async () => {
+        // Verify Tailwind styles for ".p-8" element
+        await assertStyles('.p-8', {
+          ['padding']: '32px',
+        });
+      },
       afterRunRebuildClient: async ({ allConsoleLogs }) => {
         // Check for HMR output as enabled by default
         await waitForMeteorOutput(allConsoleLogs, /.*HMR.*Updated modules:.*/);
       },
+      afterRunProduction: async () => {
+        // Verify Tailwind styles for ".p-8" element
+        await assertStyles('.p-8', {
+          ['padding']: '32px',
+        });
+      },
       afterRunProductionRebuildClient: async ({ allConsoleLogs }) => {
         // Check for HMR to not be enabled in production-like mode
         await waitForMeteorOutput(allConsoleLogs, /.*HMR.*Updated modules:*/, { negate: true });
diff --git a/tools/runners/run-mongo.js b/tools/runners/run-mongo.js
index c9a7de7334..c15feffbed 100644
--- a/tools/runners/run-mongo.js
+++ b/tools/runners/run-mongo.js
@@ -1024,6 +1024,12 @@ Object.assign(MRp, {
         'https://github.com/meteor/meteor/issues/4019 for more details.';
     }
 
+    if (signal === "SIGILL"){
+      message +=
+        '\n\n' +
+        "MongoDB crashed with SIGILL, you may be running a build of Meteor not compatible with your architecture. If this persists, try re-installing Meteor.";
+    }
+
     runLog.log(message);
     self._fail();
   },
diff --git a/tools/static-assets/skel-apollo/package.json b/tools/static-assets/skel-apollo/package.json
index 8b34c505a0..c2b9d79260 100644
--- a/tools/static-assets/skel-apollo/package.json
+++ b/tools/static-assets/skel-apollo/package.json
@@ -20,9 +20,9 @@
   "devDependencies": {
     "@graphql-tools/webpack-loader": "^7.0.0",
     "@rsdoctor/rspack-plugin": "^1.2.3",
-    "@meteorjs/rspack": "^0.0.36",
-    "@rspack/cli": "^1.5.0",
-    "@rspack/core": "^1.5.0",
+    "@meteorjs/rspack": "^0.0.60",
+    "@rspack/cli": "^1.5.3",
+    "@rspack/core": "^1.5.3",
     "@rspack/plugin-react-refresh": "^1.4.3",
     "react-refresh": "^0.17.0"
   },
diff --git a/tools/static-assets/skel-apollo/rspack.config.js b/tools/static-assets/skel-apollo/rspack.config.js
index 9bfbac437f..48cbbabc56 100644
--- a/tools/static-assets/skel-apollo/rspack.config.js
+++ b/tools/static-assets/skel-apollo/rspack.config.js
@@ -1,4 +1,4 @@
-import { defineConfig } from '@meteorjs/rspack';
+const { defineConfig } = require('@meteorjs/rspack');
 
 /**
  * Rspack configuration for Meteor projects.
@@ -10,7 +10,7 @@ import { defineConfig } from '@meteorjs/rspack';
  *
  * Use these flags to adjust your build settings based on environment.
  */
-export default defineConfig(Meteor => {
+module.exports = defineConfig(Meteor => {
   return {
     module: {
       rules: [
diff --git a/tools/static-assets/skel-babel/.babelrc b/tools/static-assets/skel-babel/.babelrc
new file mode 100644
index 0000000000..283dab1090
--- /dev/null
+++ b/tools/static-assets/skel-babel/.babelrc
@@ -0,0 +1,14 @@
+{
+  "presets": [
+    "@babel/preset-env",
+    "@babel/preset-react"
+  ],
+  "plugins": [
+    ["module-resolver", {
+      "alias": {
+        "@ui": "./imports/ui",
+        "@api": "./imports/api"
+      }
+    }]
+  ]
+}
diff --git a/tools/static-assets/skel-babel/.meteor/.gitignore b/tools/static-assets/skel-babel/.meteor/.gitignore
new file mode 100644
index 0000000000..4083037423
--- /dev/null
+++ b/tools/static-assets/skel-babel/.meteor/.gitignore
@@ -0,0 +1 @@
+local
diff --git a/tools/static-assets/skel-babel/.meteor/packages b/tools/static-assets/skel-babel/.meteor/packages
new file mode 100644
index 0000000000..e3c4adc2ff
--- /dev/null
+++ b/tools/static-assets/skel-babel/.meteor/packages
@@ -0,0 +1,23 @@
+# Meteor packages used by this project, one per line.
+# Check this file (and the other files in this directory) into your repository.
+#
+# 'meteor add' and 'meteor remove' will edit this file for you,
+# but you can also edit it by hand.
+
+meteor-base             # Packages every Meteor app needs to have
+mobile-experience       # Packages for a great mobile UX
+mongo                   # The database Meteor supports right now
+reactive-var            # Reactive variable for tracker
+
+standard-minifier-css   # CSS minifier run for production mode
+standard-minifier-js    # JS minifier run for production mode
+es5-shim                # ECMAScript 5 compatibility for older browsers
+ecmascript              # Enable ECMAScript2015+ syntax in app code
+typescript              # Enable TypeScript syntax in .ts and .tsx modules
+shell-server            # Server-side component of the `meteor shell` command
+hot-module-replacement  # Update client in development without reloading the page
+
+~prototype~
+static-html             # Define static page content in .html files
+react-meteor-data       # React higher-order component for reactively tracking Meteor data
+rspack
diff --git a/tools/static-assets/skel-babel/.meteor/platforms b/tools/static-assets/skel-babel/.meteor/platforms
new file mode 100644
index 0000000000..efeba1b50c
--- /dev/null
+++ b/tools/static-assets/skel-babel/.meteor/platforms
@@ -0,0 +1,2 @@
+server
+browser
diff --git a/tools/static-assets/skel-babel/client/main.css b/tools/static-assets/skel-babel/client/main.css
new file mode 100644
index 0000000000..7f354f0fa7
--- /dev/null
+++ b/tools/static-assets/skel-babel/client/main.css
@@ -0,0 +1,4 @@
+body {
+  padding: 10px;
+  font-family: sans-serif;
+}
diff --git a/tools/static-assets/skel-babel/client/main.html b/tools/static-assets/skel-babel/client/main.html
new file mode 100644
index 0000000000..7c3d674342
--- /dev/null
+++ b/tools/static-assets/skel-babel/client/main.html
@@ -0,0 +1,8 @@
+<head>
+  <title>~name~</title>
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+</head>
+
+<body>
+  <div id="react-target"></div>
+</body>
diff --git a/tools/static-assets/skel-babel/client/main.jsx b/tools/static-assets/skel-babel/client/main.jsx
new file mode 100644
index 0000000000..d2e380f93c
--- /dev/null
+++ b/tools/static-assets/skel-babel/client/main.jsx
@@ -0,0 +1,10 @@
+import React from 'react';
+import { createRoot } from 'react-dom/client';
+import { Meteor } from 'meteor/meteor';
+import { App } from '/imports/ui/App';
+
+Meteor.startup(() => {
+  const container = document.getElementById('react-target');
+  const root = createRoot(container);
+  root.render(<App />);
+});
diff --git a/tools/static-assets/skel-babel/imports/api/links.js b/tools/static-assets/skel-babel/imports/api/links.js
new file mode 100644
index 0000000000..050c508eae
--- /dev/null
+++ b/tools/static-assets/skel-babel/imports/api/links.js
@@ -0,0 +1,3 @@
+import { Mongo } from 'meteor/mongo';
+
+export const LinksCollection = new Mongo.Collection('links');
diff --git a/tools/static-assets/skel-babel/imports/ui/App.jsx b/tools/static-assets/skel-babel/imports/ui/App.jsx
new file mode 100644
index 0000000000..6f7340caf9
--- /dev/null
+++ b/tools/static-assets/skel-babel/imports/ui/App.jsx
@@ -0,0 +1,11 @@
+import React from 'react';
+import { Hello } from './Hello.jsx';
+import { Info } from './Info.jsx';
+
+export const App = () => (
+  <div>
+    <h1>Welcome to Meteor!</h1>
+    <Hello/>
+    <Info/>
+  </div>
+);
diff --git a/tools/static-assets/skel-babel/imports/ui/Hello.jsx b/tools/static-assets/skel-babel/imports/ui/Hello.jsx
new file mode 100644
index 0000000000..15e0f185ac
--- /dev/null
+++ b/tools/static-assets/skel-babel/imports/ui/Hello.jsx
@@ -0,0 +1,16 @@
+import React, { useState } from 'react';
+
+export const Hello = () => {
+  const [counter, setCounter] = useState(0);
+
+  const increment = () => {
+    setCounter(counter + 1);
+  };
+
+  return (
+    <div>
+      <button onClick={increment}>Click Me</button>
+      <p>You've pressed the button {counter} times.</p>
+    </div>
+  );
+};
diff --git a/tools/static-assets/skel-babel/imports/ui/Info.jsx b/tools/static-assets/skel-babel/imports/ui/Info.jsx
new file mode 100644
index 0000000000..a9a7a45cfe
--- /dev/null
+++ b/tools/static-assets/skel-babel/imports/ui/Info.jsx
@@ -0,0 +1,23 @@
+import React from 'react';
+import { useFind, useSubscribe } from 'meteor/react-meteor-data';
+import { LinksCollection } from '../api/links';
+
+export const Info = () => {
+  const isLoading = useSubscribe('links');
+  const links = useFind(() => LinksCollection.find());
+
+  if(isLoading()) {
+    return <div>Loading...</div>;
+  }
+
+  return (
+    <div>
+      <h2>Learn Meteor!</h2>
+      <ul>{links.map(
+        link => <li key={link._id}>
+          <a href={link.url} target="_blank">{link.title}</a>
+        </li>
+      )}</ul>
+    </div>
+  );
+};
diff --git a/tools/static-assets/skel-babel/package.json b/tools/static-assets/skel-babel/package.json
new file mode 100644
index 0000000000..7051fbf29f
--- /dev/null
+++ b/tools/static-assets/skel-babel/package.json
@@ -0,0 +1,37 @@
+{
+  "name": "~name~",
+  "private": true,
+  "scripts": {
+    "start": "meteor run",
+    "test": "meteor test --once --driver-package meteortesting:mocha",
+    "test-app": "TEST_WATCH=1 meteor test --full-app --driver-package meteortesting:mocha",
+    "visualize": "meteor --production --extra-packages bundle-visualizer"
+  },
+  "dependencies": {
+    "@babel/runtime": "^7.23.5",
+    "@swc/helpers": "^0.5.17",
+    "meteor-node-stubs": "^1.2.12",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0"
+  },
+  "devDependencies": {
+    "@babel/preset-env": "^7.28.3",
+    "@babel/preset-react": "^7.23.3",
+    "@meteorjs/rspack": "^0.0.60",
+    "@rsdoctor/rspack-plugin": "^1.2.3",
+    "@rspack/cli": "^1.5.3",
+    "@rspack/core": "^1.5.3",
+    "@rspack/plugin-react-refresh": "^1.4.3",
+    "babel-loader": "^9.1.3",
+    "babel-plugin-module-resolver": "^5.0.0",
+    "react-refresh": "^0.17.0"
+  },
+  "meteor": {
+    "mainModule": {
+      "client": "client/main.jsx",
+      "server": "server/main.js"
+    },
+    "testModule": "tests/main.js",
+    "modern": true
+  }
+}
diff --git a/tools/static-assets/skel-babel/rspack.config.js b/tools/static-assets/skel-babel/rspack.config.js
new file mode 100644
index 0000000000..9316881419
--- /dev/null
+++ b/tools/static-assets/skel-babel/rspack.config.js
@@ -0,0 +1,27 @@
+const { defineConfig } = require('@meteorjs/rspack');
+
+/**
+ * Rspack configuration for Meteor projects.
+ *
+ * Provides typed flags on the `Meteor` object, such as:
+ * - `Meteor.isClient` / `Meteor.isServer`
+ * - `Meteor.isDevelopment` / `Meteor.isProduction`
+ * - …and other flags available
+ *
+ * Use these flags to adjust your build settings based on environment.
+ */
+module.exports = defineConfig(Meteor => {
+  return {
+    module: {
+      rules: [
+        {
+          test: /\.(js|jsx)$/i,
+          exclude: /node_modules|\.meteor\/local/,
+          use: {
+            loader: 'babel-loader',
+          },
+        },
+      ],
+    },
+  };
+});
diff --git a/tools/static-assets/skel-babel/server/main.js b/tools/static-assets/skel-babel/server/main.js
new file mode 100644
index 0000000000..49452ad352
--- /dev/null
+++ b/tools/static-assets/skel-babel/server/main.js
@@ -0,0 +1,37 @@
+import { Meteor } from 'meteor/meteor';
+import { LinksCollection } from '/imports/api/links';
+
+async function insertLink({ title, url }) {
+  await LinksCollection.insertAsync({ title, url, createdAt: new Date() });
+}
+
+Meteor.startup(async () => {
+  // If the Links collection is empty, add some data.
+  if (await LinksCollection.find().countAsync() === 0) {
+    await insertLink({
+      title: 'Do the Tutorial',
+      url: 'https://react-tutorial.meteor.com/simple-todos/01-creating-app.html',
+    });
+
+    await insertLink({
+      title: 'Follow the Guide',
+      url: 'https://guide.meteor.com',
+    });
+
+    await insertLink({
+      title: 'Read the Docs',
+      url: 'https://docs.meteor.com',
+    });
+
+    await insertLink({
+      title: 'Discussions',
+      url: 'https://forums.meteor.com',
+    });
+  }
+
+  // We publish the entire Links collection to all clients.
+  // In order to be fetched in real-time to the clients
+  Meteor.publish("links", function () {
+    return LinksCollection.find();
+  });
+});
diff --git a/tools/static-assets/skel-babel/tests/main.js b/tools/static-assets/skel-babel/tests/main.js
new file mode 100644
index 0000000000..ea7a8da1e1
--- /dev/null
+++ b/tools/static-assets/skel-babel/tests/main.js
@@ -0,0 +1,20 @@
+import assert from "assert";
+
+describe("~name~", function () {
+  it("package.json has correct name", async function () {
+    const { name } = await import("../package.json");
+    assert.strictEqual(name, "~name~");
+  });
+
+  if (Meteor.isClient) {
+    it("client is not server", function () {
+      assert.strictEqual(Meteor.isServer, false);
+    });
+  }
+
+  if (Meteor.isServer) {
+    it("server is not client", function () {
+      assert.strictEqual(Meteor.isClient, false);
+    });
+  }
+});
diff --git a/tools/static-assets/skel-blaze/package.json b/tools/static-assets/skel-blaze/package.json
index 7ea28f6ab9..1e48bee29d 100644
--- a/tools/static-assets/skel-blaze/package.json
+++ b/tools/static-assets/skel-blaze/package.json
@@ -14,10 +14,10 @@
     "meteor-node-stubs": "^1.2.12"
   },
   "devDependencies": {
-    "@meteorjs/rspack": "^0.0.36",
+    "@meteorjs/rspack": "^0.0.60",
     "@rsdoctor/rspack-plugin": "^1.2.3",
-    "@rspack/cli": "^1.5.0",
-    "@rspack/core": "^1.5.0",
+    "@rspack/cli": "^1.5.3",
+    "@rspack/core": "^1.5.3",
     "@rspack/plugin-react-refresh": "^1.4.3"
   },
   "meteor": {
diff --git a/tools/static-assets/skel-blaze/rspack.config.js b/tools/static-assets/skel-blaze/rspack.config.js
index 1d1e902def..33f02e3bbe 100644
--- a/tools/static-assets/skel-blaze/rspack.config.js
+++ b/tools/static-assets/skel-blaze/rspack.config.js
@@ -1,4 +1,4 @@
-import { defineConfig } from '@meteorjs/rspack';
+const { defineConfig } = require('@meteorjs/rspack');
 
 /**
  * Rspack configuration for Meteor projects.
@@ -10,6 +10,6 @@ import { defineConfig } from '@meteorjs/rspack';
  *
  * Use these flags to adjust your build settings based on environment.
  */
-export default defineConfig(Meteor => {
+module.exports = defineConfig(Meteor => {
   return {};
 });
diff --git a/tools/static-assets/skel-chakra-ui/package.json b/tools/static-assets/skel-chakra-ui/package.json
index d0fd93c897..8b760014f6 100644
--- a/tools/static-assets/skel-chakra-ui/package.json
+++ b/tools/static-assets/skel-chakra-ui/package.json
@@ -21,10 +21,10 @@
     "react-dom": "^18.2.0"
   },
   "devDependencies": {
-    "@meteorjs/rspack": "^0.0.36",
+    "@meteorjs/rspack": "^0.0.60",
     "@rsdoctor/rspack-plugin": "^1.2.3",
-    "@rspack/cli": "^1.5.0",
-    "@rspack/core": "^1.5.0",
+    "@rspack/cli": "^1.5.3",
+    "@rspack/core": "^1.5.3",
     "@rspack/plugin-react-refresh": "^1.4.3",
     "react-refresh": "^0.17.0"
   },
diff --git a/tools/static-assets/skel-chakra-ui/rspack.config.js b/tools/static-assets/skel-chakra-ui/rspack.config.js
index 1d1e902def..33f02e3bbe 100644
--- a/tools/static-assets/skel-chakra-ui/rspack.config.js
+++ b/tools/static-assets/skel-chakra-ui/rspack.config.js
@@ -1,4 +1,4 @@
-import { defineConfig } from '@meteorjs/rspack';
+const { defineConfig } = require('@meteorjs/rspack');
 
 /**
  * Rspack configuration for Meteor projects.
@@ -10,6 +10,6 @@ import { defineConfig } from '@meteorjs/rspack';
  *
  * Use these flags to adjust your build settings based on environment.
  */
-export default defineConfig(Meteor => {
+module.exports = defineConfig(Meteor => {
   return {};
 });
diff --git a/tools/static-assets/skel-coffeescript/.gitignore b/tools/static-assets/skel-coffeescript/.gitignore
new file mode 100644
index 0000000000..3e954aa73f
--- /dev/null
+++ b/tools/static-assets/skel-coffeescript/.gitignore
@@ -0,0 +1,7 @@
+node_modules/
+
+# Meteor Modern-Tools build context directories
+_build
+*/build-assets
+*/build-chunks
+.rsdoctor
diff --git a/tools/static-assets/skel-coffeescript/.meteor/.gitignore b/tools/static-assets/skel-coffeescript/.meteor/.gitignore
new file mode 100644
index 0000000000..4083037423
--- /dev/null
+++ b/tools/static-assets/skel-coffeescript/.meteor/.gitignore
@@ -0,0 +1 @@
+local
diff --git a/tools/static-assets/skel-coffeescript/.meteor/packages b/tools/static-assets/skel-coffeescript/.meteor/packages
new file mode 100644
index 0000000000..76496e58da
--- /dev/null
+++ b/tools/static-assets/skel-coffeescript/.meteor/packages
@@ -0,0 +1,24 @@
+# Meteor packages used by this project, one per line.
+# Check this file (and the other files in this directory) into your repository.
+#
+# 'meteor add' and 'meteor remove' will edit this file for you,
+# but you can also edit it by hand.
+
+meteor-base             # Packages every Meteor app needs to have
+mobile-experience       # Packages for a great mobile UX
+mongo                   # The database Meteor supports right now
+reactive-var            # Reactive variable for tracker
+
+standard-minifier-css   # CSS minifier run for production mode
+standard-minifier-js    # JS minifier run for production mode
+es5-shim                # ECMAScript 5 compatibility for older browsers
+ecmascript              # Enable ECMAScript2015+ syntax in app code
+typescript              # Enable TypeScript syntax in .ts and .tsx modules
+shell-server            # Server-side component of the `meteor shell` command
+hot-module-replacement  # Update client in development without reloading the page
+
+~prototype~
+static-html             # Define static page content in .html files
+react-meteor-data       # React higher-order component for reactively tracking Meteor data
+rspack
+coffeescript            # CoffeeScript support
diff --git a/tools/static-assets/skel-coffeescript/.meteor/platforms b/tools/static-assets/skel-coffeescript/.meteor/platforms
new file mode 100644
index 0000000000..efeba1b50c
--- /dev/null
+++ b/tools/static-assets/skel-coffeescript/.meteor/platforms
@@ -0,0 +1,2 @@
+server
+browser
diff --git a/tools/static-assets/skel-coffeescript/client/main.coffee b/tools/static-assets/skel-coffeescript/client/main.coffee
new file mode 100644
index 0000000000..406b81b26c
--- /dev/null
+++ b/tools/static-assets/skel-coffeescript/client/main.coffee
@@ -0,0 +1,9 @@
+import React from 'react'
+import { createRoot } from 'react-dom/client'
+import { Meteor } from 'meteor/meteor'
+import { App } from '/imports/ui/App.coffee'
+
+Meteor.startup ->
+  container = document.getElementById('react-target')
+  root = createRoot(container)
+  root.render(<App />)
diff --git a/tools/static-assets/skel-coffeescript/client/main.css b/tools/static-assets/skel-coffeescript/client/main.css
new file mode 100644
index 0000000000..7f354f0fa7
--- /dev/null
+++ b/tools/static-assets/skel-coffeescript/client/main.css
@@ -0,0 +1,4 @@
+body {
+  padding: 10px;
+  font-family: sans-serif;
+}
diff --git a/tools/static-assets/skel-coffeescript/client/main.html b/tools/static-assets/skel-coffeescript/client/main.html
new file mode 100644
index 0000000000..7c3d674342
--- /dev/null
+++ b/tools/static-assets/skel-coffeescript/client/main.html
@@ -0,0 +1,8 @@
+<head>
+  <title>~name~</title>
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+</head>
+
+<body>
+  <div id="react-target"></div>
+</body>
diff --git a/tools/static-assets/skel-coffeescript/imports/api/links.coffee b/tools/static-assets/skel-coffeescript/imports/api/links.coffee
new file mode 100644
index 0000000000..95c5ed8cfc
--- /dev/null
+++ b/tools/static-assets/skel-coffeescript/imports/api/links.coffee
@@ -0,0 +1,3 @@
+import { Mongo } from 'meteor/mongo'
+
+export LinksCollection = new Mongo.Collection('links')
diff --git a/tools/static-assets/skel-coffeescript/imports/ui/App.coffee b/tools/static-assets/skel-coffeescript/imports/ui/App.coffee
new file mode 100644
index 0000000000..f6cf0f2b01
--- /dev/null
+++ b/tools/static-assets/skel-coffeescript/imports/ui/App.coffee
@@ -0,0 +1,10 @@
+import React from 'react'
+import { Hello } from './Hello.coffee'
+import { Info } from './Info.coffee'
+
+export App = ->
+  <div>
+    <h1>Welcome to Meteor!</h1>
+    <Hello/>
+    <Info/>
+  </div>
diff --git a/tools/static-assets/skel-coffeescript/imports/ui/Hello.coffee b/tools/static-assets/skel-coffeescript/imports/ui/Hello.coffee
new file mode 100644
index 0000000000..ab48a1e4f2
--- /dev/null
+++ b/tools/static-assets/skel-coffeescript/imports/ui/Hello.coffee
@@ -0,0 +1,12 @@
+import React, { useState } from 'react'
+
+export Hello = ->
+  [counter, setCounter] = useState(0)
+
+  increment = ->
+    setCounter(counter + 1)
+
+  <div>
+    <button onClick={increment}>Click Me</button>
+    <p>You've pressed the button {counter} times.</p>
+  </div>
diff --git a/tools/static-assets/skel-coffeescript/imports/ui/Info.coffee b/tools/static-assets/skel-coffeescript/imports/ui/Info.coffee
new file mode 100644
index 0000000000..062d35eee2
--- /dev/null
+++ b/tools/static-assets/skel-coffeescript/imports/ui/Info.coffee
@@ -0,0 +1,19 @@
+import React from 'react'
+import { useFind, useSubscribe } from 'meteor/react-meteor-data'
+import { LinksCollection } from '../api/links.coffee'
+
+export Info = ->
+  isLoading = useSubscribe('links')
+  links = useFind(-> LinksCollection.find())
+
+  if isLoading()
+    return <div>Loading...</div>
+
+  <div>
+    <h2>Learn Meteor!</h2>
+    <ul>{links.map (link) ->
+      <li key={link._id}>
+        <a href={link.url} target="_blank">{link.title}</a>
+      </li>
+    }</ul>
+  </div>
diff --git a/tools/static-assets/skel-coffeescript/package.json b/tools/static-assets/skel-coffeescript/package.json
new file mode 100644
index 0000000000..8ffabbbc87
--- /dev/null
+++ b/tools/static-assets/skel-coffeescript/package.json
@@ -0,0 +1,36 @@
+{
+  "name": "~name~",
+  "private": true,
+  "scripts": {
+    "start": "meteor run",
+    "test": "meteor test --once --driver-package meteortesting:mocha",
+    "test-app": "TEST_WATCH=1 meteor test --full-app --driver-package meteortesting:mocha",
+    "visualize": "meteor --production --extra-packages bundle-visualizer"
+  },
+  "dependencies": {
+    "@babel/runtime": "^7.23.5",
+    "@swc/helpers": "^0.5.17",
+    "meteor-node-stubs": "^1.2.12",
+    "react": "^18.2.0",
+    "react-dom": "^18.2.0"
+  },
+  "devDependencies": {
+    "@meteorjs/rspack": "^0.0.60",
+    "@rsdoctor/rspack-plugin": "^1.2.3",
+    "@rspack/cli": "^1.5.3",
+    "@rspack/core": "^1.5.3",
+    "@rspack/plugin-react-refresh": "^1.4.3",
+    "coffee-loader": "^5.0.0",
+    "coffeescript": "^2.7.0",
+    "react-refresh": "^0.17.0",
+    "swc-loader": "^0.2.6"
+  },
+  "meteor": {
+    "mainModule": {
+      "client": "client/main.coffee",
+      "server": "server/main.coffee"
+    },
+    "testModule": "tests/main.coffee",
+    "modern": true
+  }
+}
diff --git a/tools/static-assets/skel-coffeescript/rspack.config.js b/tools/static-assets/skel-coffeescript/rspack.config.js
new file mode 100644
index 0000000000..00811e5840
--- /dev/null
+++ b/tools/static-assets/skel-coffeescript/rspack.config.js
@@ -0,0 +1,36 @@
+const { defineConfig } = require('@meteorjs/rspack');
+
+/**
+ * Rspack configuration for Meteor projects.
+ *
+ * Provides typed flags on the `Meteor` object, such as:
+ * - `Meteor.isClient` / `Meteor.isServer`
+ * - `Meteor.isDevelopment` / `Meteor.isProduction`
+ * - …and other flags available
+ *
+ * Use these flags to adjust your build settings based on environment.
+ */
+module.exports = defineConfig(Meteor => {
+  return {
+    module: {
+      rules: [
+        {
+          test: /\.coffee$/i,
+          use: [
+            {
+              loader: 'swc-loader',
+              // preserve SWC config in the Meteor project level
+              options: Meteor.swcConfigOptions,
+            },
+            {
+              loader: 'coffee-loader',
+            },
+          ],
+        },
+      ],
+    },
+    resolve: {
+      extensions: ['.coffee'],
+    },
+  };
+});
diff --git a/tools/static-assets/skel-coffeescript/server/main.coffee b/tools/static-assets/skel-coffeescript/server/main.coffee
new file mode 100644
index 0000000000..35d653b1a7
--- /dev/null
+++ b/tools/static-assets/skel-coffeescript/server/main.coffee
@@ -0,0 +1,29 @@
+import { Meteor } from 'meteor/meteor'
+import { LinksCollection } from '/imports/api/links.coffee'
+
+insertLink = ({ title, url }) ->
+  await LinksCollection.insertAsync({ title, url, createdAt: new Date() })
+
+Meteor.startup ->
+  # If the Links collection is empty, add some data.
+  if await LinksCollection.find().countAsync() is 0
+    await insertLink
+      title: 'Do the Tutorial'
+      url: 'https://react-tutorial.meteor.com/simple-todos/01-creating-app.html'
+
+    await insertLink
+      title: 'Follow the Guide'
+      url: 'https://guide.meteor.com'
+
+    await insertLink
+      title: 'Read the Docs'
+      url: 'https://docs.meteor.com'
+
+    await insertLink
+      title: 'Discussions'
+      url: 'https://forums.meteor.com'
+
+  # We publish the entire Links collection to all clients.
+  # In order to be fetched in real-time to the clients
+  Meteor.publish "links", ->
+    LinksCollection.find()
diff --git a/tools/static-assets/skel-coffeescript/tests/main.coffee b/tools/static-assets/skel-coffeescript/tests/main.coffee
new file mode 100644
index 0000000000..5adec09774
--- /dev/null
+++ b/tools/static-assets/skel-coffeescript/tests/main.coffee
@@ -0,0 +1,15 @@
+import { Meteor } from 'meteor/meteor'
+import assert from 'assert'
+
+describe '~name~', ->
+  it 'package.json has correct name', ->
+    packageJson = require('../package.json')
+    assert.strictEqual(packageJson.name, '~name~')
+
+  if Meteor.isClient
+    it 'client is not server', ->
+      assert.strictEqual(Meteor.isServer, false)
+
+  if Meteor.isServer
+    it 'server is not client', ->
+      assert.strictEqual(Meteor.isClient, false)
diff --git a/tools/static-assets/skel-full/package.json b/tools/static-assets/skel-full/package.json
index 99b2e31efa..80b10f6e56 100644
--- a/tools/static-assets/skel-full/package.json
+++ b/tools/static-assets/skel-full/package.json
@@ -12,10 +12,10 @@
     "meteor-node-stubs": "^1.2.12"
   },
   "devDependencies": {
-    "@meteorjs/rspack": "^0.0.36",
+    "@meteorjs/rspack": "^0.0.60",
     "@rsdoctor/rspack-plugin": "^1.2.3",
-    "@rspack/cli": "^1.5.0",
-    "@rspack/core": "^1.5.0",
+    "@rspack/cli": "^1.5.3",
+    "@rspack/core": "^1.5.3",
     "chai": "^4.2.0"
   },
   "meteor": {
diff --git a/tools/static-assets/skel-full/rspack.config.js b/tools/static-assets/skel-full/rspack.config.js
index 1d1e902def..33f02e3bbe 100644
--- a/tools/static-assets/skel-full/rspack.config.js
+++ b/tools/static-assets/skel-full/rspack.config.js
@@ -1,4 +1,4 @@
-import { defineConfig } from '@meteorjs/rspack';
+const { defineConfig } = require('@meteorjs/rspack');
 
 /**
  * Rspack configuration for Meteor projects.
@@ -10,6 +10,6 @@ import { defineConfig } from '@meteorjs/rspack';
  *
  * Use these flags to adjust your build settings based on environment.
  */
-export default defineConfig(Meteor => {
+module.exports = defineConfig(Meteor => {
   return {};
 });
diff --git a/tools/static-assets/skel-react/package.json b/tools/static-assets/skel-react/package.json
index faa5d657c6..19bd2eb741 100644
--- a/tools/static-assets/skel-react/package.json
+++ b/tools/static-assets/skel-react/package.json
@@ -15,10 +15,10 @@
     "react-dom": "^18.2.0"
   },
   "devDependencies": {
-    "@meteorjs/rspack": "^0.0.36",
+    "@meteorjs/rspack": "^0.0.60",
     "@rsdoctor/rspack-plugin": "^1.2.3",
-    "@rspack/cli": "^1.5.0",
-    "@rspack/core": "^1.5.0",
+    "@rspack/cli": "^1.5.3",
+    "@rspack/core": "^1.5.3",
     "@rspack/plugin-react-refresh": "^1.4.3",
     "react-refresh": "^0.17.0"
   },
diff --git a/tools/static-assets/skel-react/rspack.config.js b/tools/static-assets/skel-react/rspack.config.js
index 1d1e902def..33f02e3bbe 100644
--- a/tools/static-assets/skel-react/rspack.config.js
+++ b/tools/static-assets/skel-react/rspack.config.js
@@ -1,4 +1,4 @@
-import { defineConfig } from '@meteorjs/rspack';
+const { defineConfig } = require('@meteorjs/rspack');
 
 /**
  * Rspack configuration for Meteor projects.
@@ -10,6 +10,6 @@ import { defineConfig } from '@meteorjs/rspack';
  *
  * Use these flags to adjust your build settings based on environment.
  */
-export default defineConfig(Meteor => {
+module.exports = defineConfig(Meteor => {
   return {};
 });
diff --git a/tools/static-assets/skel-solid/package.json b/tools/static-assets/skel-solid/package.json
index a71f81a14d..1456b397c3 100644
--- a/tools/static-assets/skel-solid/package.json
+++ b/tools/static-assets/skel-solid/package.json
@@ -14,10 +14,10 @@
     "picocolors": "^1.1.1"
   },
   "devDependencies": {
-    "@meteorjs/rspack": "^0.0.36",
+    "@meteorjs/rspack": "^0.0.60",
     "@rsdoctor/rspack-plugin": "^1.2.3",
-    "@rspack/cli": "^1.5.0",
-    "@rspack/core": "^1.5.0",
+    "@rspack/cli": "^1.5.3",
+    "@rspack/core": "^1.5.3",
     "babel-loader": "10.0.0",
     "babel-preset-solid": "^1.8.15",
     "solid-js": "^1.9.4",
diff --git a/tools/static-assets/skel-solid/rspack.config.js b/tools/static-assets/skel-solid/rspack.config.js
index 4b7ef941e5..2a399ac99c 100644
--- a/tools/static-assets/skel-solid/rspack.config.js
+++ b/tools/static-assets/skel-solid/rspack.config.js
@@ -1,4 +1,4 @@
-import { defineConfig } from '@meteorjs/rspack';
+const { defineConfig } = require('@meteorjs/rspack');
 
 /**
  * Rspack configuration for Meteor projects.
@@ -10,7 +10,7 @@ import { defineConfig } from '@meteorjs/rspack';
  *
  * Use these flags to adjust your build settings based on environment.
  */
-export default defineConfig(Meteor => {
+module.exports = defineConfig(Meteor => {
   return {
     ...Meteor.isClient && {
       module: {
diff --git a/tools/static-assets/skel-svelte/package.json b/tools/static-assets/skel-svelte/package.json
index ac079c09c7..0e203f9424 100644
--- a/tools/static-assets/skel-svelte/package.json
+++ b/tools/static-assets/skel-svelte/package.json
@@ -13,10 +13,10 @@
     "meteor-node-stubs": "^1.2.12"
   },
   "devDependencies": {
-    "@meteorjs/rspack": "^0.0.36",
+    "@meteorjs/rspack": "^0.0.60",
     "@rsdoctor/rspack-plugin": "^1.2.3",
-    "@rspack/cli": "^1.5.0",
-    "@rspack/core": "^1.5.0",
+    "@rspack/cli": "^1.5.3",
+    "@rspack/core": "^1.5.3",
     "postcss-load-config": "^5.1.0",
     "svelte": "^5.38.2",
     "svelte-check": "^4.3.1",
diff --git a/tools/static-assets/skel-svelte/rspack.config.js b/tools/static-assets/skel-svelte/rspack.config.js
index 530ed86a7a..05275dfece 100644
--- a/tools/static-assets/skel-svelte/rspack.config.js
+++ b/tools/static-assets/skel-svelte/rspack.config.js
@@ -1,5 +1,5 @@
-import { defineConfig } from "@meteorjs/rspack";
-import sveltePreprocess from "svelte-preprocess";
+const { defineConfig } = require("@meteorjs/rspack");
+const sveltePreprocess = require("svelte-preprocess");
 
 /**
  * Rspack configuration for Meteor projects.
@@ -11,7 +11,7 @@ import sveltePreprocess from "svelte-preprocess";
  *
  * Use these flags to adjust your build settings based on environment.
  */
-export default defineConfig((Meteor) => {
+module.exports = defineConfig((Meteor) => {
   return {
     ...(Meteor.isClient && {
       resolve: {
diff --git a/tools/static-assets/skel-tailwind/.meteorignore b/tools/static-assets/skel-tailwind/.meteorignore
new file mode 100644
index 0000000000..4568c54a7d
--- /dev/null
+++ b/tools/static-assets/skel-tailwind/.meteorignore
@@ -0,0 +1,2 @@
+# Ignore Meteor CSS handling; let Rspack resolve Tailwind styles
+client/main.css
diff --git a/tools/static-assets/skel-tailwind/client/main.css b/tools/static-assets/skel-tailwind/client/main.css
index e059394a6d..6ea2603dca 100644
--- a/tools/static-assets/skel-tailwind/client/main.css
+++ b/tools/static-assets/skel-tailwind/client/main.css
@@ -1,6 +1,4 @@
-@tailwind base;
-@tailwind components;
-@tailwind utilities;
+@import "tailwindcss";
 
 body {
     padding: 10px;
diff --git a/tools/static-assets/skel-tailwind/client/main.jsx b/tools/static-assets/skel-tailwind/client/main.jsx
index a42cee8ff3..ea3a779300 100644
--- a/tools/static-assets/skel-tailwind/client/main.jsx
+++ b/tools/static-assets/skel-tailwind/client/main.jsx
@@ -2,6 +2,7 @@ import React from 'react';
 import { Meteor } from 'meteor/meteor';
 import { render } from 'react-dom';
 import { App } from '/imports/ui/App';
+import './main.css';
 
 Meteor.startup(() => {
   render(<App/>, document.getElementById('react-target'));
diff --git a/tools/static-assets/skel-tailwind/imports/ui/App.jsx b/tools/static-assets/skel-tailwind/imports/ui/App.jsx
index b74141276d..6cc8298b0e 100644
--- a/tools/static-assets/skel-tailwind/imports/ui/App.jsx
+++ b/tools/static-assets/skel-tailwind/imports/ui/App.jsx
@@ -4,7 +4,6 @@ import { Info } from './Info.jsx';
 
 export const App = () => (
   <div className="max-w-3xl min-h-screen mx-auto sm:pt-10">
-    <h1>Welcome to Meteor!</h1>
     <Hello/>
     <Info/>
   </div>
diff --git a/tools/static-assets/skel-tailwind/imports/ui/Hello.jsx b/tools/static-assets/skel-tailwind/imports/ui/Hello.jsx
index ca51ed5233..ad3ae3c053 100644
--- a/tools/static-assets/skel-tailwind/imports/ui/Hello.jsx
+++ b/tools/static-assets/skel-tailwind/imports/ui/Hello.jsx
@@ -13,9 +13,9 @@ export const Hello = () => {
         <div className="sm:flex sm:items-start sm:justify-between">
           <div>
             <div className="flex items-center">
-              <h3 className="text-3xl text-gray-900 font-bold">
+              <h1 className="text-3xl text-gray-900 font-bold">
                 Welcome to Meteor!
-              </h3>
+              </h1>
               <div>
                 <svg xmlns="http://www.w3.org/2000/svg" width="50" height="50" viewBox="0 0 400 400"><g fill="#DE4F4F"><path d="M286.575 306.886L44.755 49.922l256.962 241.82c4.312 4.056 4.518 10.837.46 15.146-4.053 4.31-10.832 4.518-15.144.46-.15-.14-.318-.31-.458-.462M251.032 325.01L68.692 127.528 266.177 309.87c4.35 4.013 4.618 10.794.604 15.144-4.018 4.35-10.794 4.617-15.146.604-.2-.19-.413-.406-.602-.607M214.083 325.542L92.907 194.272 224.18 315.446c2.898 2.676 3.077 7.197.402 10.098-2.677 2.896-7.195 3.082-10.097.402-.136-.125-.277-.272-.402-.405M315.612 234.685L189.102 98.078 325.71 224.585c2.896 2.684 3.067 7.203.387 10.1-2.682 2.895-7.2 3.066-10.098.387-.13-.123-.268-.258-.388-.387M304.697 272.93L121.567 74.655l198.274 183.13c4.35 4.017 4.62 10.796.605 15.144-4.017 4.352-10.797 4.617-15.146.604-.205-.19-.418-.404-.603-.605M176.31 314.783l-57.647-62.695 62.692 57.65c1.453 1.334 1.547 3.596.215 5.045-1.338 1.453-3.598 1.55-5.05.215-.072-.07-.144-.143-.21-.215M311.093 189.297l-57.65-62.694 62.696 57.646c1.45 1.335 1.546 3.597.21 5.048-1.335 1.45-3.595 1.547-5.05.21-.07-.065-.143-.143-.207-.21"/></g></svg>
               </div>
diff --git a/tools/static-assets/skel-tailwind/package.json b/tools/static-assets/skel-tailwind/package.json
index 10b1b30628..8b6b881901 100644
--- a/tools/static-assets/skel-tailwind/package.json
+++ b/tools/static-assets/skel-tailwind/package.json
@@ -16,10 +16,10 @@
     "react-dom": "^17.0.2"
   },
   "devDependencies": {
-    "@meteorjs/rspack": "^0.0.36",
+    "@meteorjs/rspack": "^0.0.60",
     "@rsdoctor/rspack-plugin": "^1.2.3",
-    "@rspack/cli": "^1.5.0",
-    "@rspack/core": "^1.5.0",
+    "@rspack/cli": "^1.5.3",
+    "@rspack/core": "^1.5.3",
     "@rspack/plugin-react-refresh": "^1.4.3",
     "@tailwindcss/postcss": "^4.1.12",
     "@types/meteor": "^2.9.7",
diff --git a/tools/static-assets/skel-tailwind/rspack.config.js b/tools/static-assets/skel-tailwind/rspack.config.js
index 95f7e659b6..b5de81b007 100644
--- a/tools/static-assets/skel-tailwind/rspack.config.js
+++ b/tools/static-assets/skel-tailwind/rspack.config.js
@@ -1,4 +1,4 @@
-import { defineConfig } from '@meteorjs/rspack';
+const { defineConfig } = require('@meteorjs/rspack');
 
 /**
  * Rspack configuration for Meteor projects.
@@ -10,7 +10,7 @@ import { defineConfig } from '@meteorjs/rspack';
  *
  * Use these flags to adjust your build settings based on environment.
  */
-export default defineConfig(Meteor => {
+module.exports = defineConfig(Meteor => {
   return {
     ...Meteor.isClient && {
       module: {
diff --git a/tools/static-assets/skel-typescript/package.json b/tools/static-assets/skel-typescript/package.json
index b765302749..c4f8aaf629 100644
--- a/tools/static-assets/skel-typescript/package.json
+++ b/tools/static-assets/skel-typescript/package.json
@@ -15,10 +15,10 @@
     "react-dom": "^18.2.0"
   },
   "devDependencies": {
-    "@meteorjs/rspack": "^0.0.36",
+    "@meteorjs/rspack": "^0.0.60",
     "@rsdoctor/rspack-plugin": "^1.2.3",
-    "@rspack/cli": "^1.5.0",
-    "@rspack/core": "^1.5.0",
+    "@rspack/cli": "^1.5.3",
+    "@rspack/core": "^1.5.3",
     "@rspack/plugin-react-refresh": "^1.4.3",
     "@types/meteor": "^2.9.9",
     "@types/mocha": "^8.2.3",
diff --git a/tools/static-assets/skel-typescript/rspack.config.js b/tools/static-assets/skel-typescript/rspack.config.js
index ba70ffc324..7537cbfff6 100644
--- a/tools/static-assets/skel-typescript/rspack.config.js
+++ b/tools/static-assets/skel-typescript/rspack.config.js
@@ -1,5 +1,5 @@
-import { defineConfig } from '@meteorjs/rspack';
-import { TsCheckerRspackPlugin } from 'ts-checker-rspack-plugin';
+const { defineConfig } = require('@meteorjs/rspack');
+const { TsCheckerRspackPlugin } = require('ts-checker-rspack-plugin');
 
 /**
  * Rspack configuration for Meteor projects.
@@ -11,7 +11,7 @@ import { TsCheckerRspackPlugin } from 'ts-checker-rspack-plugin';
  *
  * Use these flags to adjust your build settings based on environment.
  */
-export default defineConfig(Meteor => {
+module.exports = defineConfig(Meteor => {
   return {
     plugins: [
       new TsCheckerRspackPlugin(),
diff --git a/tools/static-assets/skel-vue/package.json b/tools/static-assets/skel-vue/package.json
index b1a8dd36ad..b79fc48ce0 100644
--- a/tools/static-assets/skel-vue/package.json
+++ b/tools/static-assets/skel-vue/package.json
@@ -17,10 +17,10 @@
     "vue-router": "^4.2.5"
   },
   "devDependencies": {
-    "@meteorjs/rspack": "^0.0.36",
+    "@meteorjs/rspack": "^0.0.60",
     "@rsdoctor/rspack-plugin": "^1.2.3",
-    "@rspack/cli": "^1.5.0",
-    "@rspack/core": "^1.5.0",
+    "@rspack/cli": "^1.5.3",
+    "@rspack/core": "^1.5.3",
     "@tailwindcss/postcss": "^4.1.12",
     "@types/meteor": "^2.9.7",
     "postcss": "^8.5.6",
diff --git a/tools/static-assets/skel-vue/rspack.config.js b/tools/static-assets/skel-vue/rspack.config.js
index 1f99e6320a..9f7fb1cd8f 100644
--- a/tools/static-assets/skel-vue/rspack.config.js
+++ b/tools/static-assets/skel-vue/rspack.config.js
@@ -1,5 +1,5 @@
-import { defineConfig } from '@meteorjs/rspack';
-import { VueLoaderPlugin } from 'vue-loader';
+const { defineConfig } = require('@meteorjs/rspack');
+const { VueLoaderPlugin } = require('vue-loader');
 
 /**
  * Rspack configuration for Meteor projects.
@@ -11,7 +11,7 @@ import { VueLoaderPlugin } from 'vue-loader';
  *
  * Use these flags to adjust your build settings based on environment.
  */
-export default defineConfig(Meteor => {
+module.exports = defineConfig(Meteor => {
   return {
     ...Meteor.isClient && {
       plugins: [new VueLoaderPlugin()],
diff --git a/tools/tool-env/meteor-config.js b/tools/tool-env/meteor-config.js
index 9b06234bb8..d3cd59eef7 100644
--- a/tools/tool-env/meteor-config.js
+++ b/tools/tool-env/meteor-config.js
@@ -47,7 +47,7 @@ export const normalizeModernConfig = (r = false) => Object.fromEntries(
  * @param {string|null} appDir - The application directory path. If null, only environment variables are used.
  * @returns {Object} - The initialized Meteor configuration object.
  */
-export function initMeteorConfig(appDir) {
+export function initMeteorConfig(appDir = process.cwd()) {
   const modernForced = JSON.parse(process.env.METEOR_MODERN || "false");
   let packageJson;
   if (appDir) {
diff --git a/tools/tool-env/rspack.js b/tools/tool-env/rspack.js
index 38ac49f537..766ed44ec0 100644
--- a/tools/tool-env/rspack.js
+++ b/tools/tool-env/rspack.js
@@ -1,14 +1,17 @@
 // Helper functions for Rspack integration
 const files = require('../fs/files');
+const { getMeteorConfig } = require("./meteor-config");
+
+const config = getMeteorConfig();
 
 // Get the build context from environment variable or use default "_build"
-const rspackBuildContext = process.env.RSPACK_BUILD_CONTEXT || "_build";
+const rspackBuildContext = config?.buildContext || process.env.RSPACK_BUILD_CONTEXT || "_build";
 
 // Get the assets context from environment variable or use default "build-assets"
-const rspackAssetsContext = process.env.RSPACK_ASSETS_CONTEXT || "build-assets";
+const rspackAssetsContext = config?.assetsContext || process.env.RSPACK_ASSETS_CONTEXT || "build-assets";
 
 // Get the bundles context from environment variable or use default "build-chunks"
-const rspackChunksContext = process.env.RSPACK_CHUNKS_CONTEXT || "build-chunks";
+const rspackChunksContext = config?.chunksContext || process.env.RSPACK_CHUNKS_CONTEXT || "build-chunks";
 
 // Cache the regex pattern for performance
 const rspackFilePattern = new RegExp(`^${rspackBuildContext}\\/.*\\/[^\\/]*-rspack\\.js$`);
diff --git a/v3-docs/docs/about/modern-build-stack.md b/v3-docs/docs/about/modern-build-stack.md
index b77f85934d..2a16caffce 100644
--- a/v3-docs/docs/about/modern-build-stack.md
+++ b/v3-docs/docs/about/modern-build-stack.md
@@ -46,7 +46,7 @@ Starting with Meteor 3.4
 Add this Atmosphere package to your app:
 
 ``` bash
-meteor add rspack
+meteor add rspack@1.0.0-beta340.11
 ```
 
 On first run, the package installs the required Rspack setup at the project level. It compiles your app code with Rspack to get the full benefit of this integration.
diff --git a/v3-docs/docs/about/modern-build-stack/rspack-bundler-integration.md b/v3-docs/docs/about/modern-build-stack/rspack-bundler-integration.md
index 7cf2f2d8a3..d68b4f2696 100644
--- a/v3-docs/docs/about/modern-build-stack/rspack-bundler-integration.md
+++ b/v3-docs/docs/about/modern-build-stack/rspack-bundler-integration.md
@@ -18,7 +18,7 @@ Starting with Meteor 3.4
 Add this Atmosphere package to your app:
 
 ``` bash
-meteor add rspack
+meteor add rspack@1.0.0-beta340.11
 ```
 
 On first run, the package installs the required Rspack setup at the project level. It compiles your app code with Rspack to get the full benefit of this integration.
@@ -67,7 +67,19 @@ A Meteor-Rspack project reserves the folders `_build`, `{public,private}/build-a
 
 The folders are prepared and cleared automatically and should not be modified directly, as they are autogenerated. They are added to `.gitignore` when using Git, and it’s recommended to exclude them from IDE analysis.
 
-You don’t need to migrate your project for this, just ensure these folders are reserved for Meteor-Rspack. If you already use them for something else, move that content elsewhere. Currently, folder names cannot be customized, but this may be supported in the future.
+You don’t need to migrate your project for this, just ensure these folders are reserved for Meteor-Rspack. If you already use them for something else, move that content elsewhere.
+
+If you want to customize the folder names, set these options in `package.json`:
+
+``` json
+{
+  "meteor": {
+    "buildContext": "build",
+    "assetsContext": "assets",
+    "chunksContext": "chunks"
+  }
+}
+```
 
 :::warning
 Attempts were made to reuse the existing `.meteor/local` cache context instead of creating new build contexts, but this was not possible.
@@ -75,17 +87,35 @@ Attempts were made to reuse the existing `.meteor/local` cache context instead o
 Use `.meteor/local` or folders that suggest internals or hidden content (e.g., starting with a dot). These affect debug visibility, file watching, final compilation, and inclusion in the Cordova bundle.
 :::
 
+### Replace build plugins
+
+Meteor build plugins extend the Meteor bundler by letting you handle new file types and process them for the final app bundle. They’ve commonly handled HTML templating, style files for Less or SCSS, CoffeeScript, and more, since the system allows third-party customization.
+
+However, Meteor’s build system solves the same problems as other bundlers, including Rspack. Build plugins are largely deprecated in favor of Rspack alternatives. Some plugins may still be useful if they don’t act directly on app files and do something Meteor-specific that can be preserved.
+
+Among the compatible plugins:
+- [`zodern:types`](https://packosphere.com/zodern/types). Still compatible, automatically providing Meteor types for core and community packages.
+
+For others, please refer to the migration topics.
+- [CSS, Less, and SCSS](#css-less-and-scss) (when using [`less`](https://packosphere.com/meteor/less), [`fourseven:scss`](https://packosphere.com/fourseven/scss))
+- [Coffeescript](#coffeescript) (when using [`coffeescript`](https://packosphere.com/meteor/coffeescript))
+- [Svelte](#svelte) (when using [`zodern:melte`](https://packosphere.com/zodern/melte))
+
+You can still use these plugins to handle files inside Meteor atmosphere packages. You only need consider Rspack alternative when it’s required for your app code, which will usually be the case. An exception applies to HTML and CSS files: you can still use Meteor plugins touching these files if they are in the entry folder (e.g. `client/*.[html|css]` in most apps), or when using `modules` config as explained in the [Entry Points migration guide](#entry-points).
+
+Please report your plugin usage as [GitHub issues](https://github.com/meteor/meteor/issues?q=sort%3Aupdated-desc+is%3Aissue+is%3Aopen) or [forum posts](https://forums.meteor.com/), so we can suggest an Rspack alternative or assess compatibility.
+
 ## Custom `rspack.config.js`
 
-Meteor-Rspack projects can be customized using the `rspack.config.js` file, which is automatically available when installing the `rspack` package.
+Meteor-Rspack projects can be customized using the `rspack.config.js` file, which is automatically available when installing the `rspack` package. You can also use `rspack.config.mjs` or `rspack.config.cjs` if you prefer strict ESM or CommonJS formats.
 
 This file defines dynamic configurations, so you return the config from a resolved function.
 
 ```javascript
-import { defineConfig } from '@meteorjs/rspack';
-import { rspack } from '@rspack/core';
-import HtmlRspackPlugin from 'html-rspack-plugin';
-import NodePolyfillPlugin from 'node-polyfill-webpack-plugin';
+const { defineConfig } = require('@meteorjs/rspack');
+const { rspack } = require('@rspack/core');
+const HtmlRspackPlugin = require('html-rspack-plugin');
+const NodePolyfillPlugin = require('node-polyfill-webpack-plugin');
 
 /**
  * Example: Using different plugins for client and server builds
@@ -94,29 +124,34 @@ import NodePolyfillPlugin from 'node-polyfill-webpack-plugin';
  * - For server: Add Node.js polyfills with NodePolyfillPlugin
  * - For both: Add progress plugin
  */
-export default defineConfig(Meteor => {
+module.exports = defineConfig(Meteor => {
   return {
     plugins: [
       Meteor.isClient && new rspack.ProvidePlugin({ _: 'lodash' }),
       Meteor.isServer && new NodePolyfillPlugin(),
       new rspack.ProgressPlugin()
-    ].filter(Boolean)
+    ].filter(Boolean),
   };
 });
 ```
 
 You can use flags to control the final configuration based on the environment. The available flags are passed in the `Meteor` parameter.
 
-| Flag            | Type    | Description                                        |
-| --------------- | ------- | -------------------------------------------------- |
-| `isDevelopment` | boolean | True when running in development mode              |
-| `isProduction`  | boolean | True when running in production mode               |
-| `isClient`      | boolean | True when building or running client code          |
-| `isServer`      | boolean | True when building or running server code          |
-| `isTest`        | boolean | True when running in test mode                     |
-| `isDebug`       | boolean | True when debug mode is enabled                    |
-| `isRun`         | boolean | True when running the project with `meteor run`    |
-| `isBuild`       | boolean | True when building the project with `meteor build` |
+| Flag                | Type     | Description                                                                 |
+|---------------------| -------- |-----------------------------------------------------------------------------|
+| `isDevelopment`     | boolean  | True when running in development mode                                       |
+| `isProduction`      | boolean  | True when running in production mode                                        |
+| `isClient`          | boolean  | True when building or running client code                                   |
+| `isServer`          | boolean  | True when building or running server code                                   |
+| `isTest`            | boolean  | True when running in test mode                                              |
+| `isDebug`           | boolean  | True when debug mode is enabled                                             |
+| `isRun`             | boolean  | True when running the project with `meteor run`                             |
+| `isBuild`           | boolean  | True when building the project with `meteor build`                          |
+| `swcConfigOptions`  | object   | Project-level SWC config available for reusing                              |
+| `HtmlRspackPlugin`  | function | Custom HtmlRspackPlugin function for extending the config                   |
+| `compileWithMeteor` | function | Forces given npm deps (string[]) to be compiled by Meteor                   |
+| `compileWithRspack` | function | Forces given npm deps (string[]) to be compiled by Rspack                   |
+| `setCache`          | function | Enables or disables cache. Accepts true (persistent, default), false, or 'memory' |
 
 Some configurations in the Rspack config are reserved for the Meteor-Rspack setup to work, such as Rspack options inside the `entry` and `output` objects. These will trigger warnings if modified. All other settings can be overridden, giving you the flexibility to make any setup compatible with the modern bundler.
 
@@ -154,6 +189,22 @@ Ensure your app defines these entry files with the correct paths where each modu
 
 Defining entry points improves performance even with the Meteor bundler, as Meteor stops scanning and eagerly loading unnecessary files. For Meteor-Rspack integration, this is required, since it does not support automatic code discovery for efficiency.
 
+In Meteor-Rspack integration, all app code is ignored by Meteor and handled by Rspack. By default, Meteor still processes eagerly CSS and HTML files in the entry folder (e.g. `client/*.[html|css]` in most apps).
+
+If you need Meteor to handle CSS or HTML files outside the main entry folder, add them to the `modules` field. This field accepts an array of strings, each pointing to a file or folder.
+
+``` json
+{
+  "meteor": {
+    "modules": ["styles/main.css"]
+  }
+}
+```
+
+With this, Meteor will process these files, merge stylesheets, generate the final HTML, and support files a Meteor plugin may use, except for JS or script code now handled by Rspack. You can also process CSS and HTML files directly with Rspack using loaders from imports in your app code, as mentioned in ["CSS, Less and SCSS"](#css-less-and-scss) or ["HtmlRspackPlugin"](#htmlrspackplugin). If you prefer Meteor's loading approach, you can still rely on it.
+
+Keep in mind: compiling styles with the Meteor compilers triggers Meteor HMR, which is slower than Rspack HMR. Migrating to compile styles with Rspack as part of the app code ensures the fastest HMR for style changes in development.
+
 ### Nested Imports
 
 Nested imports are a feature of Meteor’s bundler, not supported in standard bundlers. Meteor introduced them during a time when bundling standards were still evolving and experimented with its own approach. This feature comes from the [`reify` module](https://github.com/benjamn/reify/tree/main) and works with Babel transpilation. SWC doesn't support them since they were never standardized.
@@ -286,6 +337,49 @@ Previous official support in the Meteor bundler was through [jorgenvatle:vite](h
 With Meteor-Rspack integration, you no longer need vite-related packages, so you should remove them from your project.
 :::
 
+### Coffeescript
+
+Meteor-Rspack supports CoffeeScript projects out of the box. To enable it, install the needed dependencies and add the configuration to Meteor’s rspack.config.js.
+
+[See the official Webpack and CoffeeScript integration guide](https://webpack.js.org/loaders/coffee-loader/#getting-started). Since Rspack is based on Webpack, the same setup applies.
+
+If you want to use SWC with CoffeeScript, combine `swc-loader` with `coffee-loader`.
+
+```bash
+npm install --save-dev coffeescript swc-loader coffee-loader
+```
+
+In your `rspack.config.js` you would add something like:
+
+``` javascript
+export default defineConfig(Meteor => {
+  return {
+    module: {
+      rules: [
+        {
+          test: /\.coffee$/i,
+          use: [
+            {
+              loader: 'swc-loader',
+              // perserve SWC config in the Meteor project level
+              options: Meteor.swcConfigOptions,
+            },
+            {
+              loader: 'coffee-loader',
+            },
+          ],
+        },
+      ],
+    },
+    resolve: {
+      extensions: ['.coffee'],
+    },
+  };
+});
+```
+
+> Use `meteor create --coffeescript` to start with a preconfigured Rspack Coffeescript app.
+
 ### Svelte
 
 Meteor-Rspack supports Svelte projects out of the box. To enable it, install the required dependencies and add the new configuration to Meteor’s `rspack.config.js` file.
@@ -302,10 +396,92 @@ With the Meteor–Rspack integration, `zodern:melte` no longer works. Use the of
 
 ### Tailwind
 
-Meteor-Rspack supports Tailwind projects out of the box. For details, check [the official Rspack and Tailwind guide](https://rspack.rs/guide/tech/css#tailwind-css).
+Meteor-Rspack supports Tailwind projects out of the box. For details, check [the official Rspack and Tailwind guide](https://tailwindcss.com/docs/installation/framework-guides/rspack/react).
 
 > Use `meteor create --tailwind` to start with a preconfigured Rspack Tailwind app.
 
+### Babel
+
+Meteor-Rspack supports Babel projects as an alternative to default SWC.
+
+> Use `meteor create --babel` to start with a preconfigured Rspack Babel app.
+
+Using Babel will increase build times. Prefer SWC. If you need Babel for specific files, limit Babel to those files, or use a hybrid with SWC and Babel. For example, [enabling React Compiler is available only via Babel using module rules](https://rspack.rs/guide/tech/react#react-compiler).
+
+### HtmlRspackPlugin
+
+Meteor-Rspack includes its own HtmlRspackPlugin, enabled by default to attach chunks and assets to the HTML skeleton. Meteor then uses this HTML to generate the final index file.
+
+If you want to customize HtmlRspackPlugin, add it to your `rspack.config.js` file:
+
+```javascript
+export default defineConfig(Meteor => {
+  return {
+    plugins: [
+      Meteor.HtmlRspackPlugin({
+        meta: {
+          // Will generate: <meta name="viewport" content="width=device-width, initial-scale=1, shrink-to-fit=no">
+          viewport: 'width=device-width, initial-scale=1, shrink-to-fit=no',
+          // Will generate: <meta name="theme-color" content="#4285f4">
+          'theme-color': '#4285f4',
+          // Will generate:  <meta http-equiv="Content-Security-Policy" content="default-src https:">
+          'Content-Security-Policy': {
+            'http-equiv': 'Content-Security-Policy',
+            content: 'default-src https:',
+          },
+        },
+      }),
+    ],
+  };
+});
+```
+
+This example adds meta tags to the HTML. For more options, see the [official Rspack and HTML integration guide](https://rspack.rs/plugins/rspack/html-rspack-plugin).
+
+:::warning
+You can still use HTML files near your Meteor client entry point to define customizations (for example, `./client/main.html` will generate correctly and apply the contents you add).
+:::
+
+### `compileWithRspack` and `compileWithMeteor`
+
+Meteor provides two helpers to control how specific npm dependencies are handled by Rspack during the build.
+
+They let you force or skip compilation for selected packages, which is useful in monorepos or when dealing with untranspiled or native modules.
+
+Available helpers in your `rspack.config.js`:
+
+🔹 **Meteor.compileWithRspack(deps: string[])**
+Forces Rspack (via SWC) to parse and transpile the listed npm packages.
+
+Use this when a dependency:
+
+* Uses modern syntax (ESM, TypeScript, etc.) not compatible with your target,
+* Lives inside a monorepo and isn’t precompiled,
+* Needs to be reprocessed according to your SWC config.
+
+🔹 **Meteor.compileWithMeteor(deps: string[])**
+Marks the listed npm packages as externals, so they are skipped by Rspack and handled by Meteor/Node during build and runtime.
+
+Use this when facing issues and for:
+
+* Native or binary modules (e.g. `sharp`),
+* npm dependencies used inside Meteor atmosphere packages that keep internal state,
+* Large or precompiled modules you prefer to offload to Meteor’s cache.
+
+``` json
+const { defineConfig } = require('@meteorjs/rspack');
+const { rspack } = require('@rspack/core');
+const NodePolyfillPlugin = require('node-polyfill-webpack-plugin');
+
+module.exports = defineConfig(Meteor => ({
+  // Exclude native modules from the bundle (use Meteor runtime)
+  ...(Meteor.isServer ? Meteor.compileWithMeteor(['sharp']) : {}),
+
+  // Force-compile modern or local packages via SWC
+  ...Meteor.compileWithRspack(['grubba-rpc']),
+}));
+```
+
 ## Benefits
 
 Meteor–Rspack integration sends your app code to Rspack to use modern bundler features. Meteor then uses Rspack’s output to handle Meteor-specific tasks (like Atmosphere package compilation) and create the final bundle.
diff --git a/v3-docs/docs/api/collections.md b/v3-docs/docs/api/collections.md
index 15e17dcd6d..b403eb9fdd 100644
--- a/v3-docs/docs/api/collections.md
+++ b/v3-docs/docs/api/collections.md
@@ -669,6 +669,89 @@ The methods (like `update` or `insert`) you call on the resulting _raw_ collecti
 
 <ApiBox name="Mongo.Collection#rawDatabase" instanceName="Collection"/>
 
+## Collection Extensions
+
+Meteor provides a powerful Collection Extensions API that allows you to extend the functionality of all collection instances. These static methods on `Mongo.Collection` let you add constructor extensions, prototype methods, and static methods to customize collection behavior. These very same APIs are exported under `CollectionExtensions` for backwards compatibility with [lai:collection-extensions](https://github.com/Meteor-Community-Packages/meteor-collection-extensions). 
+
+<ApiBox name="Mongo.Collection.addExtension" />
+
+Add a constructor extension function that runs when collections are created. The extension function is called with `(name, options)` and `this` bound to the collection instance.
+
+Example:
+```js
+Mongo.Collection.addExtension(function(name, options) {
+  this._customProperty = 'value';
+  console.log(`Collection ${name} was created`);
+});
+```
+
+<ApiBox name="Mongo.Collection.addPrototypeMethod" />
+
+Add a prototype method to all collection instances. The method is bound to the collection instance and available on all collections.
+
+Example:
+```js
+Mongo.Collection.addPrototypeMethod('customMethod', function() {
+  return `${this._name} is awesome`;
+});
+
+// Now available on all collections
+const Users = new Mongo.Collection('users');
+console.log(Users.customMethod()); // "users is awesome"
+```
+
+<ApiBox name="Mongo.Collection.addStaticMethod" />
+
+Add a static method to the `Mongo.Collection` constructor itself.
+
+Example:
+```js
+Mongo.Collection.addStaticMethod('getAllCollections', function() {
+  return Array.from(Mongo._collections.values());
+});
+
+// Now available as static method
+const allCollections = Mongo.Collection.getAllCollections();
+```
+
+<ApiBox name="Mongo.Collection.removeExtension" />
+
+Remove a constructor extension (useful for testing).
+
+<ApiBox name="Mongo.Collection.removePrototypeMethod" />
+
+Remove a prototype method from all collection instances.
+
+<ApiBox name="Mongo.Collection.removeStaticMethod" />
+
+Remove a static method from the `Mongo.Collection` constructor.
+
+<ApiBox name="Mongo.Collection.clearExtensions" />
+
+Clear all extensions, prototype methods, and static methods. This is useful for testing to ensure a clean state.
+
+<ApiBox name="Mongo.Collection.getExtensions" />
+
+Get all registered constructor extensions. Returns an array of extension functions. Useful for debugging.
+
+<ApiBox name="Mongo.Collection.getPrototypeMethods" />
+
+Get all registered prototype methods. Returns a Map of method names to functions. Useful for debugging.
+
+<ApiBox name="Mongo.Collection.getStaticMethods" />
+
+Get all registered static methods. Returns a Map of method names to functions. Useful for debugging.
+
+### Legacy Aliases
+
+<ApiBox name="Mongo.Collection.addPrototype" />
+
+Backwards compatibility alias for `addPrototypeMethod`. **Deprecated** - use `addPrototypeMethod` instead.
+
+<ApiBox name="Mongo.Collection.removePrototype" />
+
+Backwards compatibility alias for `removePrototypeMethod`. **Deprecated** - use `removePrototypeMethod` instead.
+
 
 ## Cursors {#mongo_cursor}
 
diff --git a/v3-docs/docs/cli/index.md b/v3-docs/docs/cli/index.md
index 00bdfa2916..626742b91f 100644
--- a/v3-docs/docs/cli/index.md
+++ b/v3-docs/docs/cli/index.md
@@ -279,6 +279,8 @@ If you run `meteor create` without arguments, Meteor will launch an interactive
 | `--typescript` | React + TypeScript | [TypeScript Guide](https://guide.meteor.com/build-tool.html#typescript) |
 | `--tailwind` | React + Tailwind CSS | - |
 | `--chakra-ui` | React + Chakra UI | [Simple Tasks Example](https://github.com/fredmaiaarantes/simpletasks) |
+ | `--coffeescript` | CoffeeScript | - |
+ | `--babel` | React with Babel support | - |
 
 ### Project Structure Options
 
diff --git a/v3-docs/docs/generators/changelog/versions/3.4.0.md b/v3-docs/docs/generators/changelog/versions/3.4.0.md
new file mode 100644
index 0000000000..0c7f03e214
--- /dev/null
+++ b/v3-docs/docs/generators/changelog/versions/3.4.0.md
@@ -0,0 +1,107 @@
+## v3.4.0, not yet
+
+### Highlights
+
+- **Meteor-Rspack Integration**
+
+  - ⚡ New `rspack` package
+  
+  Orchestrates the full Rspack setup, including the development server and production builds.
+
+  - 📦 New `@meteorjs/rspack` npm package
+
+  Provides a default rspack.config.js. Applications can extend or override this configuration with their own.
+
+  - 🛠️ New `tools-core` package
+
+  Supplies runtime utilities for Meteor, designed to support this integration and future tool integrations.
+
+  - 🔑 Core updates
+
+  Enhanced Meteor’s core to support the Rspack integration.
+
+  - ✅ Test suite additions
+
+  Introduced tests for app skeletons and Meteor-Rspack features to ensure quality and reliability.
+
+  - Adopting Rspack gives you a faster build experience
+
+  - Adopting Rspack produces smaller bundle sizes through advanced tree shaking
+
+  - Adopting Rspack lets you extend your app with modern setups and tooling
+
+All Merged PRs@[GitHub PRs 3.4](https://github.com/meteor/meteor/pulls?q=is%3Apr+is%3Amerged+base%3Arelease-3.4)
+
+#### Breaking Changes
+
+N/A
+
+####  Internal API changes
+
+N/A
+
+#### Migration Steps
+
+Please run the following command to update your project:
+
+```bash
+meteor update --release 3.4-beta.2
+```
+
+---
+
+**Add this to your `package.json` to enable the new modern build stack:**
+
+```json
+"meteor": {
+  "modern": true
+}
+```
+
+Check out [the requirements for Meteor Bundler optimizations](https://deploy-preview-13910.docs.meteor.com/about/modern-build-stack/meteor-bundler-optimizations.html#requirements) on existing apps.
+
+**Add `rspack` package to enable the Rspack Bundler integration:**
+
+```bash
+meteor add rspack-beta340.11
+```
+
+> This package is added by default for new apps.
+
+Check out [the requirements for Rspack Bundler integration](https://deploy-preview-13910.docs.meteor.com/about/modern-build-stack/rspack-bundler-integration.html#requirements) on existing apps.
+
+### [📃 Modern Build Stack docs](https://deploy-preview-13910.docs.meteor.com/about/modern-build-stack.html)
+
+### [☄️ Meteor Bundler optimizations docs](https://deploy-preview-13910.docs.meteor.com/about/modern-build-stack/meteor-bundler-optimizations.html)
+
+### [⚡ Rspack Bundler integration docs](https://deploy-preview-13910.docs.meteor.com/about/modern-build-stack/rspack-bundler-integration.html)
+
+If you find any issues, please report them to the [Meteor issues tracker](https://github.com/meteor/meteor).
+
+#### Bumped Meteor Packages
+
+- accounts-base@3.2.0-beta340.11
+- babel-compiler@7.13.0-beta340.11
+- ecmascript@0.17.0-beta340.11
+- boilerplate-generator@2.1.0-beta340.11
+- meteor-tool@3.4.0-beta.0
+- minifier-js@3.1.0-beta340.11
+- rspack@1.0.0-beta340.11
+- shell-server@0.7.0-beta340.11
+- test-in-browser@1.5.0-beta340.11
+- tools-core@1.0.0-beta340.11
+- typescript@5.7.0-beta340.11
+
+#### Bumped NPM Packages
+
+- @meteorjs/rspack@0.0.36
+
+#### Special thanks to
+
+✨✨✨
+
+- [@nachocodoner](https://github.com/nachocodoner)
+- [@italojs](https://github.com/italojs)
+- [@Grubba27](https://github.com/Grubba27)
+
+✨✨✨