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

package/.claude/settings.local.json

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

package/README.md

@@ -0,0 +1,142 @@
+# @meteorjs/rspack
+
+The default [Rspack](https://rspack.dev) configuration for Meteor applications. This package provides everything you need to bundle your Meteor app with Rspack out of the box: client and server builds, SWC transpilation, React/Blaze/Angular support, hot module replacement, asset management, and all the Meteor-specific wiring so you don't have to.
+
+When Meteor runs with the Rspack bundler enabled, this package is what generates the underlying Rspack configuration. It detects your project setup (TypeScript, React, Blaze, Angular), sets up the right loaders and plugins, defines `Meteor.isClient`/`Meteor.isServer` and friends, configures caching, and exposes a set of helpers you can use in your own `rspack.config.js` to customize the build without breaking Meteor integration.
+
+## What it provides
+
+- **Dual client/server builds** with the correct targets, externals, and output paths
+- **SWC-based transpilation** for JS/TS/JSX/TSX with automatic framework detection
+- **React Fast Refresh** in development when React is enabled
+- **Blaze template handling** via ignore-loader when Blaze is enabled
+- **Persistent filesystem caching** for fast rebuilds
+- **Asset externals and HTML generation** through custom Rspack plugins
+- **A `defineConfig` helper** that accepts a factory function receiving Meteor environment flags and build utilities
+- **Customizable config** via `rspack.config.js` in your project root, with safe merging that warns if you try to override reserved settings
+- **Automatic CSS delegation** when rspack is configured with CSS, Less, or SCSS loaders, Meteor automatically detects the handled extensions after the first compilation and stops processing those files itself in the entry folder context. No `.meteorignore` entries needed.
+
+## Installation
+
+[Rspack integration](https://docs.meteor.com/about/modern-build-stack/rspack-bundler-integration.html) is automatically managed by the rspack Atmosphere package.
+
+```bash
+meteor add rspack
+```
+
+By doing this, your Meteor app will automatically serve `@meteorjs/rspack` and the required `@rspack/cli`, `@rspack/core`, among others.
+
+## Usage
+
+In your project's `rspack.config.js`, use the `defineConfig` helper to customize the build. The factory function receives a `env` object with Meteor environment flags and helper utilities:
+
+```js
+const { defineConfig } = require('@meteorjs/rspack');
+
+module.exports = defineConfig((env, argv) => {
+  // env.isClient, env.isServer, env.isDevelopment, env.isProduction
+  // env.isReactEnabled, env.isBlazeEnabled, etc.
+
+  return {
+    // Your custom Rspack configuration here.
+    // It gets safely merged with the Meteor defaults.
+  };
+});
+```
+
+More information is available in the official docs: [Rspack Bundler Integration](https://docs.meteor.com/about/modern-build-stack/rspack-bundler-integration.html#custom-rspack-config-js).
+
+## Development
+
+### Install dependencies
+
+```bash
+npm install
+```
+
+### Version bumping
+
+Use `npm run bump` to update the version in `package.json` before publishing.
+
+```bash
+npm run bump -- <major|minor|patch> [--beta]
+```
+
+**Standard bumps** increment the version and remove any prerelease suffix:
+
+```bash
+npm run bump -- patch   # 1.0.1 -> 1.0.2
+npm run bump -- minor   # 1.0.1 -> 1.1.0
+npm run bump -- major   # 1.0.1 -> 2.0.0
+```
+
+**Beta bumps** append or increment a `-beta.N` prerelease suffix:
+
+```bash
+npm run bump -- patch --beta   # 1.0.1 -> 1.0.2-beta.0
+npm run bump -- patch --beta   # 1.0.2-beta.0 -> 1.0.2-beta.1
+npm run bump -- patch --beta   # 1.0.2-beta.1 -> 1.0.2-beta.2
+```
+
+If you change the bump level while on a beta, the base version updates and the beta counter resets:
+
+```bash
+npm run bump -- minor --beta   # 1.0.2-beta.2 -> 1.1.0-beta.0
+npm run bump -- major --beta   # 1.1.0-beta.0 -> 2.0.0-beta.0
+```
+
+### Publishing a beta release
+
+After bumping to a beta version, publish to the `beta` dist-tag:
+
+```bash
+npm run bump -- patch --beta
+npm run publish:beta
+```
+
+Users can then install the beta with:
+
+```bash
+npm install @meteorjs/rspack@beta
+```
+
+You can pass extra flags to `npm publish` through the script:
+
+```bash
+npm run publish:beta -- --dry-run
+```
+
+### Publishing an official release
+
+After bumping to a stable version, publish with the default `latest` tag:
+
+```bash
+npm run bump -- patch
+npm publish
+```
+
+### Typical workflows
+
+**Beta iteration**: ship multiple beta builds for the same upcoming patch:
+
+```bash
+npm run bump -- patch --beta    # 1.0.1 -> 1.0.2-beta.0
+npm run publish:beta
+# ... fix issues ...
+npm run bump -- patch --beta    # 1.0.2-beta.0 -> 1.0.2-beta.1
+npm run publish:beta
+```
+
+**Promote beta to stable**: once the beta is ready, bump to the stable version and publish:
+
+```bash
+npm run bump -- patch           # 1.0.2-beta.1 -> 1.0.3
+npm publish
+```
+
+**Direct stable release**: skip the beta phase entirely:
+
+```bash
+npm run bump -- minor           # 1.0.1 -> 1.1.0
+npm publish
+```

package/index.d.ts

@@ -57,10 +57,21 @@ type MeteorEnv = Record<string, any> & {
    */
   splitVendorChunk: () => Record<string, object>;
   /**
-   * Extend Rspack SWC loader config.
+   * Extend the SWC loader config by smart-merging custom options on top of
+   * Meteor's defaults.  Only the properties you specify are overridden;
+   * everything else is preserved.
+   * @param swcConfig - SWC loader options to merge with defaults
    * @returns A config object with SWC loader config
    */
   extendSwcConfig: (swcConfig: SwcLoaderOptions) => Record<string, object>;
+  /**
+   * Replace the SWC loader config entirely, discarding Meteor's defaults.
+   * Use this when you need full control over SWC options and don't want any
+   * automatic merging with Meteor's built-in configuration.
+   * @param swcConfig - Complete SWC loader options (replaces defaults)
+   * @returns A config object with SWC loader config
+   */
+  replaceSwcConfig: (swcConfig: SwcLoaderOptions) => Record<string, object>;
   /**
    * Extend Rspack configs.
    * @returns A config object with merged configs
@@ -75,6 +86,12 @@ type MeteorEnv = Record<string, any> & {
   disablePlugins: (
     matchers: string | RegExp | ((plugin: any, index: number) => boolean) | Array<string | RegExp | ((plugin: any, index: number) => boolean)>
   ) => Record<string, any>;
+  /**
+   * Omit `Meteor.isDevelopment` and `Meteor.isProduction` from the DefinePlugin so
+   * the bundle is not tied to a specific Meteor environment (portable / isomorphic builds).
+   * @returns A config fragment with `meteor.enablePortableBuild: true`
+   */
+  enablePortableBuild: () => Record<string, any>;
 }
 
 export type ConfigFactory = (

package/lib/localDependenciesHelpers.js

@@ -0,0 +1,184 @@
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Extract local file dependencies from a config file by parsing require/import statements using AST
+ * @param {string} configFilePath - Path to the config file to parse
+ * @returns {string[]} - Array of absolute paths to local dependencies
+ */
+function extractLocalDependencies(configFilePath) {
+  if (!configFilePath || !fs.existsSync(configFilePath)) {
+    return [];
+  }
+
+  try {
+    const swc = require('@swc/core');
+    const content = fs.readFileSync(configFilePath, 'utf-8');
+    const configDir = path.dirname(configFilePath);
+    const projectDir = process.cwd();
+    const dependencies = [];
+
+    // Parse the file into an AST
+    const ast = swc.parseSync(content, {
+      syntax: 'ecmascript',
+      dynamicImport: true,
+      target: 'es2020',
+    });
+
+    // Visit all nodes to find import/require statements
+    visitNode(ast, (node) => {
+      let modulePath = null;
+
+      // Handle require() calls: require('./plugin')
+      if (node.type === 'CallExpression' && 
+          node.callee.type === 'Identifier' && 
+          node.callee.value === 'require' &&
+          node.arguments.length > 0) {
+        const arg = node.arguments[0];
+        if (arg.expression?.type === 'StringLiteral') {
+          modulePath = arg.expression.value;
+        }
+      }
+
+      // Handle dynamic import() calls: import('./plugin')
+      if (node.type === 'CallExpression' &&
+          node.callee.type === 'Import' &&
+          node.arguments.length > 0) {
+        const arg = node.arguments[0];
+        if (arg.expression?.type === 'StringLiteral') {
+          modulePath = arg.expression.value;
+        }
+      }
+
+      // Handle static imports: import x from './plugin'
+      if (node.type === 'ImportDeclaration' && node.source?.type === 'StringLiteral') {
+        modulePath = node.source.value;
+      }
+
+      // Handle export re-exports: export * from './plugin'
+      if (node.type === 'ExportAllDeclaration' && node.source?.type === 'StringLiteral') {
+        modulePath = node.source.value;
+      }
+
+      // Handle named export re-exports: export { x } from './plugin'
+      if (node.type === 'ExportNamedDeclaration' && node.source?.type === 'StringLiteral') {
+        modulePath = node.source.value;
+      }
+
+      // If we found a module path, try to resolve it
+      if (modulePath) {
+        const resolvedPath = resolveLocalModule(modulePath, configDir, projectDir);
+        if (resolvedPath) {
+          dependencies.push(resolvedPath);
+        }
+      }
+    });
+
+    // Remove duplicates
+    return [...new Set(dependencies)];
+  } catch (error) {
+    console.warn('[Rspack Cache] Failed to parse config dependencies:', error.message);
+    return [];
+  }
+}
+
+/**
+ * Recursively visit all nodes in an AST
+ * @param {Object} node - AST node
+ * @param {Function} callback - Function to call for each node
+ */
+function visitNode(node, callback) {
+  if (!node || typeof node !== 'object') {
+    return;
+  }
+
+  callback(node);
+
+  // Visit all properties of the node
+  for (const key in node) {
+    if (Object.prototype.hasOwnProperty.call(node, key)) {
+      const value = node[key];
+      if (Array.isArray(value)) {
+        value.forEach(child => visitNode(child, callback));
+      } else if (typeof value === 'object') {
+        visitNode(value, callback);
+      }
+    }
+  }
+}
+
+/**
+ * Resolve a module path to an absolute path if it's a local file
+ * @param {string} modulePath - Module path from require/import statement
+ * @param {string} configDir - Directory containing the config file
+ * @param {string} projectDir - Project root directory
+ * @returns {string|null} - Resolved absolute path or null
+ */
+function resolveLocalModule(modulePath, configDir, projectDir) {
+  // Only process relative paths (starts with . or ..)
+  if (!modulePath.startsWith('.')) {
+    return null;
+  }
+
+  try {
+    let resolvedPath = path.resolve(configDir, modulePath);
+    const extensions = ['.js', '.mjs', '.cjs', '.ts', '.json'];
+
+    // If the path exists as-is, check if it's a directory needing index resolution
+    if (fs.existsSync(resolvedPath)) {
+      if (fs.statSync(resolvedPath).isDirectory()) {
+        let found = false;
+        for (const ext of extensions) {
+          const indexPath = path.join(resolvedPath, `index${ext}`);
+          if (fs.existsSync(indexPath)) {
+            resolvedPath = indexPath;
+            found = true;
+            break;
+          }
+        }
+        if (!found) {
+          return null;
+        }
+      }
+    } else {
+      // Try common extensions if file doesn't exist as-is
+      let found = false;
+
+      for (const ext of extensions) {
+        const pathWithExt = resolvedPath + ext;
+        if (fs.existsSync(pathWithExt)) {
+          resolvedPath = pathWithExt;
+          found = true;
+          break;
+        }
+      }
+
+      // If still not found, return null
+      if (!found) {
+        return null;
+      }
+    }
+
+    // Verify file is within project (not node_modules)
+    const resolvedReal = fs.realpathSync(resolvedPath);
+    const projectReal = fs.realpathSync(projectDir);
+
+    const isWithinProject = 
+      resolvedReal === projectReal ||
+      resolvedReal.startsWith(projectReal + path.sep);
+    const hasNodeModulesSegment = resolvedReal.split(path.sep).includes('node_modules');
+
+    if (isWithinProject && !hasNodeModulesSegment) {
+      return resolvedPath;
+    }
+  } catch (error) {
+    // Silently ignore resolution errors
+  }
+
+  return null;
+}
+
+module.exports = {
+  extractLocalDependencies,
+  resolveLocalModule,
+};

package/lib/meteorRspackConfigHelpers.js

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

package/lib/meteorRspackHelpers.js

@@ -132,10 +132,14 @@ function splitVendorChunk() {
 }
 
 /**
- * Extend SWC loader config
- * Usage: extendSwcConfig()
+ * Extend SWC loader config by smart-merging custom options on top of Meteor's
+ * defaults (via `mergeSplitOverlap`).  Only the properties you specify are
+ * overridden; everything else is preserved.
  *
- * @returns {Record<string, object>} `{ meteorRspackConfigX: { optimization: { ... } } }`
+ * Usage: Meteor.extendSwcConfig({ jsc: { parser: { decorators: true } } })
+ *
+ * @param {object} swcConfig - SWC loader options to merge with defaults
+ * @returns {Record<string, object>} config fragment for spreading into rspack config
  */
 function extendSwcConfig(swcConfig) {
   return prepareMeteorRspackConfig({
@@ -152,6 +156,44 @@ function extendSwcConfig(swcConfig) {
   });
 }
 
+/**
+ * Replace the SWC loader config entirely, discarding Meteor's defaults.
+ * Use this when you need full control over SWC options and don't want any
+ * automatic merging with Meteor's built-in configuration.
+ *
+ * Usage: Meteor.replaceSwcConfig({ jsc: { parser: { syntax: 'typescript' }, target: 'es2020' } })
+ *
+ * @param {object} swcConfig - Complete SWC loader options (replaces defaults)
+ * @returns {Record<string, object>} config fragment for spreading into rspack config
+ */
+function replaceSwcConfig(swcConfig) {
+  return prepareMeteorRspackConfig({
+    module: {
+      rules: [
+        {
+          test: /\.(?:[mc]?js|jsx|[mc]?ts|tsx)$/i,
+          exclude: /node_modules|\.meteor\/local/,
+          loader: 'builtin:swc-loader',
+          options: swcConfig,
+        },
+      ],
+    },
+  });
+}
+
+/**
+ * Signal that `Meteor.isDevelopment` and `Meteor.isProduction` should be omitted
+ * from DefinePlugin, making the bundle portable across Meteor environments.
+ * Usage: return Meteor.enablePortableBuild() in your rspack.config.js
+ *
+ * @returns {Record<string, object>} config fragment with `meteor.enablePortableBuild: true`
+ */
+function enablePortableBuild() {
+  return prepareMeteorRspackConfig({
+    "meteor.enablePortableBuild": true,
+  });
+}
+
 /**
  * Remove plugins from a Rspack config by name, RegExp, predicate, or array of them.
  * When using a function predicate, it receives both the plugin and its index in the plugins array.
@@ -214,7 +256,9 @@ module.exports = {
   setCache,
   splitVendorChunk,
   extendSwcConfig,
+  replaceSwcConfig,
   makeWebNodeBuiltinsAlias,
   disablePlugins,
   outputMeteorRspack,
+  enablePortableBuild,
 };

package/lib/swc.js

@@ -9,11 +9,38 @@ const vm = require('vm');
 function getMeteorAppSwcrc(file = '.swcrc') {
   try {
     const filePath = `${process.cwd()}/${file}`;
-    if (file.endsWith('.js')) {
+    if (file.endsWith('.js') || file.endsWith('.ts')) {
       let content = fs.readFileSync(filePath, 'utf-8');
-      // Check if the content uses ES module syntax (export default)
+      
+      if (file.endsWith('.ts')) {
+        try {
+          const swc = require('@swc/core');
+          const result = swc.transformSync(content, {
+            jsc: {
+              parser: {
+                syntax: 'typescript',
+              },
+              target: 'es2015',
+            },
+          });
+          content = result.code;
+        } catch (swcError) {
+          content = content
+            .replace(/import\s+type\s+.*?from\s+['"][^'"]+['"];?/g, '')
+            .replace(/import\s+.*?from\s+['"][^'"]+['"];?/g, '')
+            .replace(/import\s+['"][^'"]+['"];?/g, '')
+            .replace(/export\s+default\s+/, 'module.exports = ')
+            .replace(/export\s+/g, '')
+            .replace(/:\s*\w+(\[\])?(\s*=)/g, '$2')
+            .replace(/\(([^)]*?):\s*\w+(\[\])?\)/g, '($1)')
+            .replace(/\):\s*\w+(\[\])?\s*\{/g, ') {')
+            .replace(/interface\s+\w+\s*\{[^}]*\}/g, '')
+            .replace(/type\s+\w+\s*=\s*[^;]+;/g, '')
+            .replace(/as\s+\w+(\[\])?/g, '');
+        }
+      }
+      
       if (content.includes('export default')) {
-        // Transform ES module syntax to CommonJS
         content = content.replace(/export\s+default\s+/, 'module.exports = ');
       }
       const script = new vm.Script(`
@@ -27,7 +54,9 @@ function getMeteorAppSwcrc(file = '.swcrc') {
         })()
       `);
       const context = vm.createContext({ process });
-      return script.runInContext(context);
+      const result = script.runInContext(context);
+      // Handle CJS interop wrapper (e.g. { __esModule: true, default: config })
+      return result && result.__esModule && result.default ? result.default : result;
     } else {
       // For .swcrc and other JSON files, parse as JSON
       return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
@@ -45,12 +74,13 @@ function getMeteorAppSwcrc(file = '.swcrc') {
 function getMeteorAppSwcConfig() {
   const hasSwcRc = fs.existsSync(`${process.cwd()}/.swcrc`);
   const hasSwcJs = !hasSwcRc && fs.existsSync(`${process.cwd()}/swc.config.js`);
+  const hasSwcTs = !hasSwcRc && !hasSwcJs && fs.existsSync(`${process.cwd()}/swc.config.ts`);
 
-  if (!hasSwcRc && !hasSwcJs) {
+  if (!hasSwcRc && !hasSwcJs && !hasSwcTs) {
     return undefined;
   }
 
-  const swcFile = hasSwcJs ? 'swc.config.js' : '.swcrc';
+  const swcFile = hasSwcTs ? 'swc.config.ts' : hasSwcJs ? 'swc.config.js' : '.swcrc';
   const config = getMeteorAppSwcrc(swcFile);
 
   // Set baseUrl to process.cwd() if it exists

package/lib/test.js

@@ -2,6 +2,10 @@ const fs = require('fs');
 const path = require('path');
 const { createIgnoreRegex, createIgnoreGlobConfig } = require("./ignore.js");
 
+// Normalize a path to always use forward slashes (POSIX style).
+// Module identifiers in bundled JS must use '/' regardless of OS.
+const toPosix = (p) => p.replace(/\\/g, '/');
+
 /**
  * Generates eager test files dynamically
  * @param {Object} options - Options for generating the test file
@@ -58,14 +62,14 @@ const generateEagerTestFile = ({
     : "/\\.(?:test|spec)s?\\.[^.]+$/";
 
   const content = `${
-    globalImportPath ? `import '${globalImportPath}';\n\n` : ""
+    globalImportPath ? `import '${toPosix(globalImportPath)}';\n\n` : ""
   }${
     excludeMeteorIgnoreRegex
       ? `const MeteorIgnoreRegex = ${excludeMeteorIgnoreRegex.toString()};`
       : ""
   }
 {
-  const ctx = import.meta.webpackContext('${projectDir}', {
+  const ctx = import.meta.webpackContext('${toPosix(projectDir)}', {
     recursive: true,
     regExp: ${regExp},
     exclude: ${excludeFoldersRegex.toString()},
@@ -81,9 +85,9 @@ const generateEagerTestFile = ({
   }).forEach(ctx);
   ${
     extraEntry
-      ? `const extra = import.meta.webpackContext('${path.dirname(
+      ? `const extra = import.meta.webpackContext('${toPosix(path.dirname(
           extraEntry
-        )}', {
+        ))}', {
     recursive: false,
     regExp: ${new RegExp(`${path.basename(extraEntry)}$`).toString()},
     mode: 'eager',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meteorjs/rspack",
-  "version": "1.1.0-beta.30",
+  "version": "1.1.0-beta.32",
   "description": "Configuration logic for using Rspack in Meteor projects",
   "main": "index.js",
   "type": "commonjs",
@@ -14,6 +14,7 @@
   },
   "peerDependencies": {
     "@rspack/cli": ">=1.3.0",
-    "@rspack/core": ">=1.3.0"
+    "@rspack/core": ">=1.3.0",
+    "@swc/core": ">=1.3.0"
   }
 }