diff --git a/lib/puppet/application/apply.rb b/lib/puppet/application/apply.rb
index 8909939dc..1814858b0 100644
--- a/lib/puppet/application/apply.rb
+++ b/lib/puppet/application/apply.rb
@@ -1,173 +1,173 @@
 require 'puppet/application'
 
 class Puppet::Application::Apply < Puppet::Application
 
     should_parse_config
 
     option("--debug","-d")
     option("--execute EXECUTE","-e") do |arg|
         options[:code] = arg
     end
     option("--loadclasses","-L")
     option("--verbose","-v")
     option("--use-nodes")
     option("--detailed-exitcodes")
 
     option("--apply catalog",  "-a catalog") do |arg|
         options[:catalog] = arg
     end
 
     option("--logdest LOGDEST", "-l") do |arg|
         begin
             Puppet::Util::Log.newdestination(arg)
             options[:logset] = true
         rescue => detail
             $stderr.puts detail.to_s
         end
     end
 
     def run_command
         if options[:catalog]
             apply
         elsif Puppet[:parseonly]
             parseonly
         else
             main
         end
     end
 
     def apply
         if options[:catalog] == "-"
             text = $stdin.read
         else
             text = File.read(options[:catalog])
         end
 
         begin
             catalog = Puppet::Resource::Catalog.convert_from(Puppet::Resource::Catalog.default_format,text)
             unless catalog.is_a?(Puppet::Resource::Catalog)
                 catalog = Puppet::Resource::Catalog.pson_create(catalog)
             end
         rescue => detail
             raise Puppet::Error, "Could not deserialize catalog from pson: %s" % detail
         end
 
         catalog = catalog.to_ral
 
         require 'puppet/configurer'
         configurer = Puppet::Configurer.new
         configurer.run :catalog => catalog
     end
 
     def parseonly
         # Set our code or file to use.
         if options[:code] or command_line.args.length == 0
             Puppet[:code] = options[:code] || STDIN.read
         else
             Puppet[:manifest] = command_line.args.shift
         end
         begin
-            Puppet::Resource::TypeCollection.new(Puppet[:environment]).perform_initial_import
+            Puppet::Node::Environment.new(Puppet[:environment]).known_resource_types
         rescue => detail
             Puppet.err detail
             exit 1
         end
         exit 0
     end
 
     def main
         # Set our code or file to use.
         if options[:code] or command_line.args.length == 0
             Puppet[:code] = options[:code] || STDIN.read
         else
             Puppet[:manifest] = command_line.args.shift
         end
 
         # Collect our facts.
         unless facts = Puppet::Node::Facts.find(Puppet[:certname])
             raise "Could not find facts for %s" % Puppet[:certname]
         end
 
         # Find our Node
         unless node = Puppet::Node.find(Puppet[:certname])
             raise "Could not find node %s" % Puppet[:certname]
         end
 
         # Merge in the facts.
         node.merge(facts.values)
 
         # Allow users to load the classes that puppet agent creates.
         if options[:loadclasses]
             file = Puppet[:classfile]
             if FileTest.exists?(file)
                 unless FileTest.readable?(file)
                     $stderr.puts "%s is not readable" % file
                     exit(63)
                 end
                 node.classes = File.read(file).split(/[\s\n]+/)
             end
         end
 
         begin
             # Compile our catalog
             starttime = Time.now
             catalog = Puppet::Resource::Catalog.find(node.name, :use_node => node)
 
             # Translate it to a RAL catalog
             catalog = catalog.to_ral
 
             catalog.finalize
 
             catalog.retrieval_duration = Time.now - starttime
 
             require 'puppet/configurer'
             configurer = Puppet::Configurer.new
             configurer.execute_prerun_command
 
             # And apply it
             transaction = catalog.apply
 
             configurer.execute_postrun_command
 
             status = 0
             if not Puppet[:noop] and options[:detailed_exitcodes] then
                 transaction.generate_report
                 exit(transaction.report.exit_status)
             else
                 exit(0)
             end
         rescue => detail
             puts detail.backtrace if Puppet[:trace]
             $stderr.puts detail.message
             exit(1)
         end
     end
 
     def setup
         if Puppet.settings.print_configs?
             exit(Puppet.settings.print_configs ? 0 : 1)
         end
 
         # If noop is set, then also enable diffs
         if Puppet[:noop]
             Puppet[:show_diff] = true
         end
 
         unless options[:logset]
             Puppet::Util::Log.newdestination(:console)
         end
         client = nil
         server = nil
 
         trap(:INT) do
             $stderr.puts "Exiting"
             exit(1)
         end
 
         if options[:debug]
             Puppet::Util::Log.level = :debug
         elsif options[:verbose]
             Puppet::Util::Log.level = :info
         end
     end
 end
diff --git a/lib/puppet/application/master.rb b/lib/puppet/application/master.rb
index fdcd7d34f..484ec08ca 100644
--- a/lib/puppet/application/master.rb
+++ b/lib/puppet/application/master.rb
@@ -1,166 +1,166 @@
 require 'puppet/application'
 
 class Puppet::Application::Master < Puppet::Application
 
     should_parse_config
     run_mode :master
 
     option("--debug", "-d")
     option("--verbose", "-v")
 
     # internal option, only to be used by ext/rack/config.ru
     option("--rack")
 
     option("--compile host",  "-c host") do |arg|
         options[:node] = arg
     end
 
     option("--logdest DEST",  "-l DEST") do |arg|
         begin
             Puppet::Util::Log.newdestination(arg)
             options[:setdest] = true
         rescue => detail
             if Puppet[:debug]
                 puts detail.backtrace
             end
             $stderr.puts detail.to_s
         end
     end
 
     def preinit
         trap(:INT) do
             $stderr.puts "Cancelling startup"
             exit(0)
         end
 
         # Create this first-off, so we have ARGV
         require 'puppet/daemon'
         @daemon = Puppet::Daemon.new
         @daemon.argv = ARGV.dup
     end
 
     def run_command
         if options[:node]
             compile
         elsif Puppet[:parseonly]
             parseonly
         else
             main
         end
     end
 
     def compile
         Puppet::Util::Log.newdestination :console
         raise ArgumentError, "Cannot render compiled catalogs without pson support" unless Puppet.features.pson?
         begin
             unless catalog = Puppet::Resource::Catalog.find(options[:node])
                 raise "Could not compile catalog for %s" % options[:node] 
             end
 
             jj catalog.to_resource
         rescue => detail
             $stderr.puts detail
             exit(30)
         end
         exit(0)
     end
 
     def parseonly
         begin
-            Puppet::Resource::TypeCollection.new(Puppet[:environment]).perform_initial_import
+            Puppet::Node::Environment.new(Puppet[:environment]).known_resource_types
         rescue => detail
             Puppet.err detail
             exit 1
         end
         exit(0)
     end
 
     def main
         require 'etc'
         require 'puppet/file_serving/content'
         require 'puppet/file_serving/metadata'
 
         xmlrpc_handlers = [:Status, :FileServer, :Master, :Report, :Filebucket]
 
         if Puppet[:ca]
             xmlrpc_handlers << :CA
         end
 
         # Make sure we've got a localhost ssl cert
         Puppet::SSL::Host.localhost
 
         # And now configure our server to *only* hit the CA for data, because that's
         # all it will have write access to.
         if Puppet::SSL::CertificateAuthority.ca?
             Puppet::SSL::Host.ca_location = :only
         end
 
         if Puppet.features.root?
             begin
                 Puppet::Util.chuser
             rescue => detail
                 puts detail.backtrace if Puppet[:trace]
                 $stderr.puts "Could not change user to %s: %s" % [Puppet[:user], detail]
                 exit(39)
             end
         end
 
         unless options[:rack]
             require 'puppet/network/server'
             @daemon.server = Puppet::Network::Server.new(:xmlrpc_handlers => xmlrpc_handlers)
             @daemon.daemonize if Puppet[:daemonize]
         else
             require 'puppet/network/http/rack'
             @app = Puppet::Network::HTTP::Rack.new(:xmlrpc_handlers => xmlrpc_handlers, :protocols => [:rest, :xmlrpc])
         end
 
         Puppet.notice "Starting Puppet master version %s" % [Puppet.version]
 
         unless options[:rack]
             @daemon.start
         else
             return @app
         end
     end
 
     def setup
         # Handle the logging settings.
         if options[:debug] or options[:verbose]
             if options[:debug]
                 Puppet::Util::Log.level = :debug
             else
                 Puppet::Util::Log.level = :info
             end
 
             unless Puppet[:daemonize] or options[:rack]
                 Puppet::Util::Log.newdestination(:console)
                 options[:setdest] = true
             end
         end
 
         unless options[:setdest]
             Puppet::Util::Log.newdestination(:syslog)
         end
 
         if Puppet.settings.print_configs?
             exit(Puppet.settings.print_configs ? 0 : 1)
         end
 
         Puppet.settings.use :main, :master, :ssl
 
         # A temporary solution, to at least make the master work for now.
         Puppet::Node::Facts.terminus_class = :yaml
 
         # Cache our nodes in yaml.  Currently not configurable.
         Puppet::Node.cache_class = :yaml
 
         # Configure all of the SSL stuff.
         if Puppet::SSL::CertificateAuthority.ca?
             Puppet::SSL::Host.ca_location = :local
             Puppet.settings.use :ca
             Puppet::SSL::CertificateAuthority.instance
         else
             Puppet::SSL::Host.ca_location = :none
         end
     end
 end