Replacement for Atmosphere Packages using NPM+SWC/Rspack #14089

awatson1978 · 2026-01-20T20:31:08Z

awatson1978
Jan 20, 2026

Following this discussion on Meteor forums, I asked Claude the following prompt:

❯ Claude, please scan this local copy of meteor/meteor, the github repo for the Meteor.js filesystem. We have been having
a conversation with the Meteor devs, on whether we want to upgrade the Atmosphere.js compile chain to use Speedy Web
Compiler (SWC) and Rspack.
https://forums.meteor.com/t/atmosphere-packages-swc-rspack/64379/4
There has been a recommendation to use NPM as much as possible, and we would appreciate your help in drafting a plan and
estimating complexity, for the following new meteor commands:

# need a way to compile the npm package                                                                                       
$ meteor rollup packages/my-npm-pkg                                                                                           
                                                                                                                              
# and then to (optionally) publish it                                                                                         
$ meteor npm-publish packages/my-npm-pkg                                                                                      
                                                                                                                              
# just-in-time addition of packages has been one of the best things about Atmosphere                                          
$ meteor run —extra-npm-package my-npm-pkg                                                                                    
                                                                                                                              
# just-in-time addition on deploy,ent has been a long-requested feature                                                       
$ meteor deploy —extra-npm-package my-npm-pkg

Results are below:

Plan: NPM-Focused Commands for Meteor (SWC + Rspack)

Purpose: Implementation plan for adding npm compilation and publishing capabilities using SWC and Rspack.

Executive Summary

Four new commands to enable Meteor packages to be compiled to npm-compatible format using SWC + Rspack:

Build Stack:

SWC - Rust-based transpiler (TypeScript/JSX → JavaScript)
Rspack - Rust-based bundler with SWC integration (Webpack-compatible)

Estimated Total: 2000-2900 lines of code

Why SWC + Rspack?

Current Architecture (For Context)

CLI Command System

Commands registered via main.registerCommand() in tools/cli/main.js
Package commands in tools/cli/commands-packages.js
Existing meteor publish publishes to Atmosphere, not npm

Build System (Isobuild)

Custom build system in tools/isobuild/
No existing Rspack/SWC integration
Would need new integration layer

NPM Integration

meteor npm is pass-through to bundled npm
Packages declare deps via Npm.depends() in package.js
Stored in .npm/package/node_modules/

Proposed File Structure

 tools/                                                                                                                         
   cli/                                                                                                                         
     commands-npm-build.js          # NEW: npm-build + npm-publish commands                                                     
   npm-build/                       # NEW directory                                                                             
     rspack-compiler.js             # Rspack compilation pipeline                                                               
     swc-config.js                  # SWC configuration generator                                                               
     npm-package-generator.js       # package.json generation                                                                   
     meteor-shim-generator.js       # Shims for Meteor globals                                                                  
     meteor-plugin.js               # Rspack plugin for Meteor transforms                                                       
   isobuild/                                                                                                                    
     extra-npm-resolver.js          # JIT npm package resolution

Files to Modify

ools/cli/main.js - Load new command file
tools/cli/commands.js - Add --extra-npm-package flags
tools/project-context.js - Support extra npm packages
tools/isobuild/bundler.js - Include extra packages in bundle

New Dependencies

 {                                                                                                                              
   "@rspack/core": "^1.x",                                                                                                      
   "@rspack/cli": "^1.x",                                                                                                       
   "@swc/core": "^1.x"                                                                                                          
 }

Command 1: meteor npm-build packages/my-npm-pkg

Purpose

Compile a Meteor package to npm-compatible ES modules using Rspack + SWC.

CLI Interface

 # Basic usage                                                                                                                  
 meteor npm-build packages/my-npm-pkg                                                                                           
                                                                                                                                
 # With options                                                                                                                 
 meteor npm-build packages/my-npm-pkg --output ./dist --format esm,cjs --minify                                                 
                                                                                                                                
 # Using config file                                                                                                            
 meteor npm-build packages/my-npm-pkg --config rspack.config.js                                                                 
                                                                                                                                
 # Build for specific target                                                                                                    
 meteor npm-build packages/my-npm-pkg --browser                                                                                 
 meteor npm-build packages/my-npm-pkg --server

Options

Output Structure

 dist/                                                                                                                          
   esm/                                                                                                                         
     index.js          # ES modules entry                                                                                       
     index.js.map                                                                                                               
   cjs/                                                                                                                         
     index.js          # CommonJS entry                                                                                         
     index.js.map                                                                                                               
   package.json        # npm package.json with exports field                                                                    
   README.md           # Copied from package root

Implementation Steps

Parse Package Source

 // Use existing PackageSource class                                                                                            
 const packageSource = new PackageSource();                                                                                     
 await packageSource.initFromPackageDir(packagePath);                                                                           
                                                                                                                                
 // Extract metadata                                                                                                            
 const exports = packageSource.getExports();      // api.export()                                                               
 const deps = packageSource.getNpmDependencies(); // Npm.depends()                                                              
 const mainModule = packageSource.getMainModule(); // api.mainModule()

Generate Rspack Configuration

 // rspack-compiler.js                                                                                                          
 const rspack = require('@rspack/core');                                                                                        
                                                                                                                                
 function createRspackConfig(packageSource, options) {                                                                          
   return {                                                                                                                     
     entry: packageSource.getMainModule() || './index.js',                                                                      
     output: {                                                                                                                  
       path: options.output,                                                                                                    
       filename: '[name].js',                                                                                                   
       library: { type: options.format },                                                                                       
     },                                                                                                                         
     module: {                                                                                                                  
       rules: [{                                                                                                                
         test: /\.[jt]sx?$/,                                                                                                    
         use: {                                                                                                                 
           loader: 'builtin:swc-loader',                                                                                        
           options: {                                                                                                           
             jsc: {                                                                                                             
               parser: { syntax: 'typescript', tsx: true },                                                                     
               transform: { react: { runtime: 'automatic' } },                                                                  
             },                                                                                                                 
           },                                                                                                                   
         },                                                                                                                     
       }],                                                                                                                      
     },                                                                                                                         
     plugins: [                                                                                                                 
       new MeteorTransformPlugin(options),                                                                                      
     ],                                                                                                                         
     optimization: {                                                                                                            
       minimize: options.minify,                                                                                                
       minimizer: [new rspack.SwcJsMinimizerRspackPlugin()],                                                                    
     },                                                                                                                         
   };                                                                                                                           
 }

Meteor Transform Plugin

 // meteor-plugin.js                                                                                                            
 class MeteorTransformPlugin {                                                                                                  
   apply(compiler) {                                                                                                            
     compiler.hooks.compilation.tap('MeteorTransform', (compilation) => {                                                       
       // Transform Meteor.isClient/isServer to constants                                                                       
       // Transform 'meteor/package' imports to shims or externals                                                              
     });                                                                                                                        
   }                                                                                                                            
 }

Run Compilation

 async function compile(packagePath, options) {                                                                                 
   const config = createRspackConfig(packageSource, options);                                                                   
   const compiler = rspack(config);                                                                                             
                                                                                                                                
   return new Promise((resolve, reject) => {                                                                                    
     compiler.run((err, stats) => {                                                                                             
       if (err || stats.hasErrors()) {                                                                                          
         reject(err || stats.toJson().errors);                                                                                  
       } else {                                                                                                                 
         resolve(stats);                                                                                                        
       }                                                                                                                        
     });                                                                                                                        
   });                                                                                                                          
 }

Command 2: meteor npm-publish packages/my-npm-pkg

Purpose

Publish compiled Meteor package to npm registry.

CLI Interface

 # Basic usage (auto-runs npm-build first)                                                                                      
 meteor npm-publish packages/my-npm-pkg                                                                                         
                                                                                                                                
 # Skip build step                                                                                                              
 meteor npm-publish packages/my-npm-pkg --no-build                                                                              
                                                                                                                                
 # Dry run                                                                                                                      
 meteor npm-publish packages/my-npm-pkg --dry-run                                                                               
                                                                                                                                
 # With 2FA                                                                                                                     
 meteor npm-publish packages/my-npm-pkg --otp 123456

Options

Implementation Steps

Validate Package

 async function validatePackage(packagePath) {                                                                                  
   const distPath = path.join(packagePath, 'dist');                                                                             
   if (!fs.existsSync(distPath)) {                                                                                              
     throw new Error('dist/ not found. Run meteor npm-build first.');                                                           
   }                                                                                                                            
                                                                                                                                
   const pkgJson = path.join(distPath, 'package.json');                                                                         
   if (!fs.existsSync(pkgJson)) {                                                                                               
     throw new Error('dist/package.json not found.');                                                                           
   }                                                                                                                            
 }

Generate npm package.json

 // npm-package-generator.js                                                                                                    
 function generateNpmPackageJson(meteorPackage) {                                                                               
   const npmDeps = meteorPackage.getNpmDependencies();                                                                          
                                                                                                                                
   return {                                                                                                                     
     name: meteorPackage.name,                                                                                                  
     version: meteorPackage.version,                                                                                            
     description: meteorPackage.summary,                                                                                        
     main: './cjs/index.js',                                                                                                    
     module: './esm/index.js',                                                                                                  
     types: './types/index.d.ts',  // if TypeScript                                                                             
     exports: {                                                                                                                 
       '.': {                                                                                                                   
         import: './esm/index.js',                                                                                              
         require: './cjs/index.js',                                                                                             
         types: './types/index.d.ts',                                                                                           
       },                                                                                                                       
     },                                                                                                                         
     dependencies: npmDeps,                                                                                                     
     peerDependencies: {                                                                                                        
       // Meteor shims if needed                                                                                                
     },                                                                                                                         
     sideEffects: false,                                                                                                        
     keywords: ['meteor', ...meteorPackage.keywords],                                                                           
     repository: meteorPackage.git,                                                                                             
     license: meteorPackage.license || 'MIT',                                                                                   
   };                                                                                                                           
 }

Execute npm publish

 async function publishToNpm(distPath, options) {                                                                               
   const args = ['publish'];                                                                                                    
                                                                                                                                
   if (options.tag) args.push('--tag', options.tag);                                                                            
   if (options.access) args.push('--access', options.access);                                                                   
   if (options.dryRun) args.push('--dry-run');                                                                                  
   if (options.otp) args.push('--otp', options.otp);                                                                            
   if (options.registry) args.push('--registry', options.registry);                                                             
                                                                                                                                
   // Use bundled npm via dev-bundle pattern                                                                                    
   const npmPath = files.pathJoin(                                                                                              
     files.getDevBundle(),                                                                                                      
     'bin',                                                                                                                     
     process.platform === 'win32' ? 'npm.cmd' : 'npm'                                                                           
   );                                                                                                                           
                                                                                                                                
   return execFileAsync(npmPath, args, { cwd: distPath });                                                                      
 }

Command 3: meteor run --extra-npm-package

Purpose

JIT addition of npm packages during development without modifying package.json.

CLI Interface

 # Single package                                                                                                               
 meteor run --extra-npm-package lodash                                                                                          
                                                                                                                                
 # Multiple packages                                                                                                            
 meteor run --extra-npm-package lodash,axios,date-fns                                                                           
                                                                                                                                
 # With versions                                                                                                                
 meteor run --extra-npm-package lodash@4.17.21,axios@^1.0.0                                                                     
                                                                                                                                
 # Combined with other flags                                                                                                    
 meteor run --port 4000 --extra-npm-package lodash

Use Cases

Quick testing/debugging - Try a package without committing
Optional feature flags - Conditionally include packages per environment
Custom workflows - Add packages to base templates dynamically

Implementation Steps

Add Option to runCommandOptions (in commands.js)

 var runCommandOptions = {                                                                                                      
   // ... existing options ...                                                                                                  
   'extra-npm-package': { type: String },                                                                                       
 };

Parse Package Specs

 // extra-npm-resolver.js                                                                                                       
 function parseExtraNpmPackages(packageString) {                                                                                
   if (!packageString) return [];                                                                                               
                                                                                                                                
   return packageString.split(',').map(spec => {                                                                                
     const match = spec.trim().match(/^(@?[^@]+)(?:@(.+))?$/);                                                                  
     return {                                                                                                                   
       name: match[1],                                                                                                          
       version: match[2] || 'latest',                                                                                           
     };                                                                                                                         
   });                                                                                                                          
 }

Install to Isolated Directory

async function installExtraNpmPackages(packages, projectDir) {                                                                 
   const extraDir = path.join(projectDir, '.meteor', 'local', 'extra-npm');                                                     
                                                                                                                                
   // Create temporary package.json                                                                                             
   const pkgJson = {                                                                                                            
     name: 'meteor-extra-npm',                                                                                                  
     private: true,                                                                                                             
     dependencies: Object.fromEntries(                                                                                          
       packages.map(p => [p.name, p.version])                                                                                   
     ),                                                                                                                         
   };                                                                                                                           
                                                                                                                                
   await fs.writeFile(                                                                                                          
     path.join(extraDir, 'package.json'),                                                                                       
     JSON.stringify(pkgJson, null, 2)                                                                                           
   );                                                                                                                           
                                                                                                                                
   // Run npm install                                                                                                           
   await execFileAsync(npmPath, ['install'], { cwd: extraDir });                                                                
                                                                                                                                
   return path.join(extraDir, 'node_modules');                                                                                  
 }

Add to Module Resolution (in bundler.js)

 // Extend NodeModulesDirectory to include extra packages                                                                       
 if (buildOptions.extraNpmPackages) {                                                                                           
   const extraNodeModules = await installExtraNpmPackages(                                                                      
     buildOptions.extraNpmPackages,                                                                                             
     projectContext.projectDir                                                                                                  
   );                                                                                                                           
                                                                                                                                
   nodeModulesDirectories.push(                                                                                                 
     new NodeModulesDirectory({                                                                                                 
       sourcePath: extraNodeModules,                                                                                            
       local: false,                                                                                                            
     })                                                                                                                         
   );                                                                                                                           
 }

Comparison with Existing Approaches

Command 4: meteor deploy --extra-npm-package

Purpose

JIT addition of npm packages during deployment.

CLI Interface

 # Deploy with extra packages                                                                                                   
 meteor deploy myapp.meteorapp.com --extra-npm-package lodash                                                                   
                                                                                                                                
 # Multiple packages                                                                                                            
 meteor deploy myapp.meteorapp.com --extra-npm-package lodash,axios

Implementation Steps

Add Option to Deploy Command (in commands.js)

// Find deploy command registration and add:                                                                                   
 'extra-npm-package': { type: String },

Install Before Bundle Creation

 // In deploy handler, before calling bundler.bundle()                                                                          
 if (options['extra-npm-package']) {                                                                                            
   const extraPkgs = parseExtraNpmPackages(options['extra-npm-package']);                                                       
   buildOptions.extraNpmPackages = extraPkgs;                                                                                   
 }

Include in Deployment Tarball

Packages installed to programs/server/npm/node_modules/
Included in bundle via existing NodeModulesDirectory mechanism
No changes needed to Galaxy deployment process

Handling Meteor-Specific Code

Meteor.isClient / Meteor.isServer

Strategy: Build-time constants via Rspack DefinePlugin

 // In rspack config                                                                                                            
 plugins: [                                                                                                                     
   new rspack.DefinePlugin({                                                                                                    
     'Meteor.isClient': options.browser ? 'true' : 'false',                                                                     
     'Meteor.isServer': options.server ? 'true' : 'false',                                                                      
     'Meteor.isProduction': JSON.stringify(process.env.NODE_ENV === 'production'),                                              
   }),                                                                                                                          
 ],

This enables dead code elimination - code in if (Meteor.isServer) blocks gets removed from browser builds.

Meteor Package Imports

For import { X } from 'meteor/package-name':

Recommended: Mark as External + Peer Dependencies

 // rspack config                                                                                                               
 externals: {                                                                                                                   
   'meteor/meteor': 'meteor/meteor',                                                                                            
   'meteor/check': 'meteor/check',                                                                                              
   // ... other meteor packages                                                                                                 
 },                                                                                                                             
                                                                                                                                
 // Generated package.json                                                                                                      
 {                                                                                                                              
   "peerDependencies": {                                                                                                        
     "@meteor-community/meteor-shim": "^1.0.0"                                                                                  
   },                                                                                                                           
   "peerDependenciesMeta": {                                                                                                    
     "@meteor-community/meteor-shim": {                                                                                         
       "optional": true                                                                                                         
     }                                                                                                                          
   }                                                                                                                            
 }

Alternative: Bundled Minimal Shims

For packages that want to work outside Meteor:

 // meteor-shim-generator.js                                                                                                    
 const METEOR_SHIMS = {                                                                                                         
   'meteor/meteor': `                                                                                                           
     export const Meteor = {                                                                                                    
       isClient: typeof window !== 'undefined',                                                                                 
       isServer: typeof window === 'undefined',                                                                                 
       isProduction: process.env.NODE_ENV === 'production',                                                                     
     };                                                                                                                         
   `,                                                                                                                           
   'meteor/check': `                                                                                                            
     export function check(value, pattern) { /* validation */ }                                                                 
     export const Match = { /* matchers */ };                                                                                   
   `,                                                                                                                           
 };

Architectural Decisions

Decision 1: SWC + Rspack Installation

Recommendation: Auto-Install on First Use

 async function ensureRspackInstalled() {                                                                                       
   const rspackDir = path.join(                                                                                                 
     files.getDevBundle(),                                                                                                      
     'lib',                                                                                                                     
     'node_modules',                                                                                                            
     '@rspack'                                                                                                                  
   );                                                                                                                           
                                                                                                                                
   if (!fs.existsSync(rspackDir)) {                                                                                             
     Console.info('Installing Rspack (first-time setup)...');                                                                   
     await npmInstall(['@rspack/core', '@swc/core'], rspackDir);                                                                
   }                                                                                                                            
                                                                                                                                
   return require(path.join(rspackDir, 'core'));                                                                                
 }

Benefits:

No increase in base Meteor install size
Lazy loading - only installed when meteor npm-build is used
Can update Rspack independently of Meteor releases

Decision 2: Meteor Import Handling

Recommendation: Configurable via package.json

 {                                                                                                                              
   "meteor": {                                                                                                                  
     "npmBuild": {                                                                                                              
       "meteorImports": "external"  // or "shim" or "inline"                                                                    
     }                                                                                                                          
   }                                                                                                                            
 }

external (default): Mark as external, document peer deps
shim: Generate minimal shims for common APIs
inline: Bundle shim code directly (largest output)

Decision 3: Configuration Format

Support both rspack.config.js AND package.json meteor section

// Check for rspack.config.js first                                                                                            
const configPath = path.join(packageDir, 'rspack.config.js');                                                                  
if (fs.existsSync(configPath)) {                                                                                               
  return require(configPath);                                                                                                  
}                                                                                                                              
                                                                                                                               
// Fall back to package.json meteor section                                                                                    
const pkgJson = require(path.join(packageDir, 'package.json'));                                                                
return pkgJson.meteor?.npmBuild || {};

Complexity Assessment

Implementation Phases

Phase 1: Foundation

├── Set up tools/npm-build/ directory structure
├── Implement Rspack configuration generator
├── Create basic meteor npm-build command
└── Handle simple packages (no Meteor imports)

Phase 2: Meteor Integration

├── Implement MeteorTransformPlugin for Rspack
├── Handle Meteor.isClient/isServer transforms
├── Add Meteor import handling (external/shim)
└── Generate proper npm package.json

Phase 3: npm-publish

├── Implement meteor npm-publish command
├── Integrate with npm authentication
├── Add dry-run and validation
└── Documentation for publishing workflow

Phase 4: JIT Features

├── Implement --extra-npm-package for meteor run
├── Extend to meteor deploy
├── Add caching for extra packages
└── Integration tests

Phase 5: Polish

├── Error handling and messages
├── Documentation
├── Example packages
└── Community testing

Questions for Community Discussion

Command naming: meteor npm-build vs meteor pack vs meteor compile?
Meteor imports: External-only, or provide bundled shims for common packages?
Shim packages: Should we maintain @meteor-community/* npm shims?
Atmosphere integration: Add --npm to meteor publish, or keep separate command?
Rspack for Isobuild: Should Meteor's internal build system also migrate to Rspack?

Verification Plan

Unit Tests

Rspack config generation
Package.json transformation
Meteor import handling

Integration Tests

End-to-end meteor npm-build execution
meteor npm-publish --dry-run validation
--extra-npm-package module resolution

Manual Testing Checklist

Create sample Meteor package with client/server code
Run meteor npm-build, verify dist/ structure
Verify Meteor.isClient/isServer transforms correctly
Run meteor npm-publish --dry-run
Test --extra-npm-package with lodash, axios
Deploy with --extra-npm-package to test Galaxy
Consume published package from non-Meteor project

Navigation Menu

Replacement for Atmosphere Packages using NPM+SWC/Rspack #14089

Uh oh!

{{title}}

Uh oh!

Replies: 0 comments

Select a reply

Uh oh!

Replacement for Atmosphere Packages using NPM+SWC/Rspack #14089

Uh oh!

awatson1978 Jan 20, 2026

Plan: NPM-Focused Commands for Meteor (SWC + Rspack)

Executive Summary

Build Stack:

Why SWC + Rspack?

Current Architecture (For Context)

CLI Command System

Build System (Isobuild)

NPM Integration

Proposed File Structure

Files to Modify

New Dependencies

Command 1: meteor npm-build packages/my-npm-pkg

Purpose

CLI Interface

Options

Output Structure

Implementation Steps

Command 2: meteor npm-publish packages/my-npm-pkg

Purpose

CLI Interface

Options

Implementation Steps

Command 3: meteor run --extra-npm-package

Purpose

CLI Interface

Use Cases

Implementation Steps

Comparison with Existing Approaches

Command 4: meteor deploy --extra-npm-package

Purpose

CLI Interface

Implementation Steps

Handling Meteor-Specific Code

Strategy: Build-time constants via Rspack DefinePlugin

Alternative: Bundled Minimal Shims

Architectural Decisions

Decision 1: SWC + Rspack Installation

Decision 2: Meteor Import Handling

Decision 3: Configuration Format

Complexity Assessment

Implementation Phases

Phase 1: Foundation

Phase 2: Meteor Integration

Phase 3: npm-publish

Phase 4: JIT Features

Phase 5: Polish

Questions for Community Discussion

Verification Plan

Replies: 0 comments

awatson1978
Jan 20, 2026