diff --git a/lib/puppet/reference/metaparameter.rb b/lib/puppet/reference/metaparameter.rb
index 3c4c08701..9235d3d26 100644
--- a/lib/puppet/reference/metaparameter.rb
+++ b/lib/puppet/reference/metaparameter.rb
@@ -1,41 +1,43 @@
 metaparameter = Puppet::Util::Reference.newreference :metaparameter, :doc => "All Puppet metaparameters and all their details" do
   types = {}
   Puppet::Type.loadall
 
   Puppet::Type.eachtype { |type|
     next if type.name == :puppet
     next if type.name == :component
     types[type.name] = type
   }
 
   str = %{
 
 # Metaparameters
     
 Metaparameters are parameters that work with any resource type; they are part of the 
 Puppet framework itself rather than being part of the implementation of any
 given instance.  Thus, any defined metaparameter can be used with any instance
 in your manifest, including defined components.
 
 ## Available Metaparameters
 
 }
   begin
     params = []
     Puppet::Type.eachmetaparam { |param|
       params << param
     }
 
     params.sort { |a,b|
       a.to_s <=> b.to_s
     }.each { |param|
-      str += paramwrap(param.to_s, scrub(Puppet::Type.metaparamdoc(param)), :level => 3)
+      str << markdown_header(param.to_s, 3)
+      str << scrub(Puppet::Type.metaparamdoc(param))
+      str << "\n\n"
     }
   rescue => detail
     puts detail.backtrace
     puts "incorrect metaparams: #{detail}"
     exit(1)
   end
 
   str
 end
diff --git a/lib/puppet/reference/type.rb b/lib/puppet/reference/type.rb
index f620dfc64..f2841d49f 100644
--- a/lib/puppet/reference/type.rb
+++ b/lib/puppet/reference/type.rb
@@ -1,113 +1,117 @@
 type = Puppet::Util::Reference.newreference :type, :doc => "All Puppet resource types and all their details" do
   types = {}
   Puppet::Type.loadall
 
   Puppet::Type.eachtype { |type|
     next if type.name == :puppet
     next if type.name == :component
     next if type.name == :whit
     types[type.name] = type
   }
 
   str = %{
 
 ## Resource Types
 
 - The *namevar* is the parameter used to uniquely identify a type instance.
   This is the parameter that gets assigned when a string is provided before
   the colon in a type declaration.  In general, only developers will need to
   worry about which parameter is the `namevar`.
 
   In the following code:
 
       file { "/etc/passwd":
         owner => root,
         group => root,
         mode => 644
       }
 
   `/etc/passwd` is considered the title of the file object (used for things like
   dependency handling), and because `path` is the namevar for `file`, that
   string is assigned to the `path` parameter.
 
 - *Parameters* determine the specific configuration of the instance.  They either
   directly modify the system (internally, these are called properties) or they affect
   how the instance behaves (e.g., adding a search path for `exec` instances or determining recursion on `file` instances).
 
 - *Providers* provide low-level functionality for a given resource type.  This is
   usually in the form of calling out to external commands.
 
   When required binaries are specified for providers, fully qualifed paths
   indicate that the binary must exist at that specific path and unqualified
   binaries indicate that Puppet will search for the binary using the shell
   path.
 
 - *Features* are abilities that some providers might not support.  You can use the list
   of supported features to determine how a given provider can be used.
 
   Resource types define features they can use, and providers can be tested to see
   which features they provide.
 
     }
 
     types.sort { |a,b|
       a.to_s <=> b.to_s
     }.each { |name,type|
 
       str << "
 
 ----------------
 
 "
 
   str << markdown_header(name, 3)
   str << scrub(type.doc) + "\n\n"
 
   # Handle the feature docs.
   if featuredocs = type.featuredocs
     str << markdown_header("Features", 4)
     str << featuredocs
     end
 
     docs = {}
     type.validproperties.sort { |a,b|
       a.to_s <=> b.to_s
     }.reject { |sname|
       property = type.propertybyname(sname)
       property.nodoc
     }.each { |sname|
       property = type.propertybyname(sname)
 
       raise "Could not retrieve property #{sname} on type #{type.name}" unless property
 
       doc = nil
       unless doc = property.doc
         $stderr.puts "No docs for #{type}[#{sname}]"
         next
       end
       doc = doc.dup
       tmp = doc
       tmp = scrub(tmp)
 
       docs[sname]  = tmp
     }
 
     str << markdown_header("Parameters", 4) + "\n"
     type.parameters.sort { |a,b|
       a.to_s <=> b.to_s
     }.each { |name,param|
       #docs[name] = indent(scrub(type.paramdoc(name)), $tab)
       docs[name] = scrub(type.paramdoc(name))
     }
 
     additional_key_attributes = type.key_attributes - [:name]
     docs.sort { |a, b|
       a[0].to_s <=> b[0].to_s
     }.each { |name, doc|
-      str << paramwrap(name, doc, :namevar => additional_key_attributes.include?(name))
+      if additional_key_attributes.include?(name)
+        doc = "(**Namevar:** If omitted, this parameter's value defaults to the resource's title.)\n\n" + doc
+      end
+      str << markdown_header(name, 5)
+      str << doc
     }
     str << "\n"
   }
 
   str
 end
diff --git a/lib/puppet/util/reference.rb b/lib/puppet/util/reference.rb
index 597047002..1ec5880af 100644
--- a/lib/puppet/util/reference.rb
+++ b/lib/puppet/util/reference.rb
@@ -1,140 +1,129 @@
 require 'puppet/util/instance_loader'
 require 'fileutils'
 
 # Manage Reference Documentation.
 class Puppet::Util::Reference
   include Puppet::Util
   include Puppet::Util::Docs
 
   extend Puppet::Util::InstanceLoader
 
   instance_load(:reference, 'puppet/reference')
 
   def self.footer
     "\n\n----------------\n\n*This page autogenerated on #{Time.now}*\n"
   end
 
   def self.modes
     %w{pdf text}
   end
 
   def self.newreference(name, options = {}, &block)
     ref = self.new(name, options, &block)
     instance_hash(:reference)[symbolize(name)] = ref
 
     ref
   end
 
   def self.page(*sections)
     depth = 4
     # Use the minimum depth
     sections.each do |name|
       section = reference(name) or raise "Could not find section #{name}"
       depth = section.depth if section.depth < depth
     end
   end
 
   def self.pdf(text)
     puts "creating pdf"
     Puppet::Util.secure_open("/tmp/puppetdoc.txt", "w") do |f|
       f.puts text
     end
     rst2latex = which('rst2latex') || which('rst2latex.py') || raise("Could not find rst2latex")
     cmd = %{#{rst2latex} /tmp/puppetdoc.txt > /tmp/puppetdoc.tex}
     Puppet::Util.secure_open("/tmp/puppetdoc.tex","w") do |f|
       # If we get here without an error, /tmp/puppetdoc.tex isn't a tricky cracker's symlink
     end
     output = %x{#{cmd}}
     unless $CHILD_STATUS == 0
       $stderr.puts "rst2latex failed"
       $stderr.puts output
       exit(1)
     end
     $stderr.puts output
 
     # Now convert to pdf
     Dir.chdir("/tmp") do
       %x{texi2pdf puppetdoc.tex >/dev/null 2>/dev/null}
     end
 
   end
 
   def self.references
     instance_loader(:reference).loadall
     loaded_instances(:reference).sort { |a,b| a.to_s <=> b.to_s }
   end
 
   HEADER_LEVELS = [nil, "#", "##", "###", "####", "#####"]
 
   attr_accessor :page, :depth, :header, :title, :dynamic
   attr_writer :doc
 
   def doc
     if defined?(@doc)
       return "#{@name} - #{@doc}"
     else
       return @title
     end
   end
 
   def dynamic?
     self.dynamic
   end
 
   def markdown_header(name, level)
     "#{HEADER_LEVELS[level]} #{name}\n\n"
   end
 
   def initialize(name, options = {}, &block)
     @name = name
     options.each do |option, value|
       send(option.to_s + "=", value)
     end
 
     meta_def(:generate, &block)
 
     # Now handle the defaults
     @title ||= "#{@name.to_s.capitalize} Reference"
     @page ||= @title.gsub(/\s+/, '')
     @depth ||= 2
     @header ||= ""
   end
 
   # Indent every line in the chunk except those which begin with '..'.
   def indent(text, tab)
     text.gsub(/(^|\A)/, tab).gsub(/^ +\.\./, "..")
   end
 
   def option(name, value)
     ":#{name.to_s.capitalize}: #{value}\n"
   end
 
-  def paramwrap(name, text, options = {})
-    options[:level] ||= 5
-    #str = "#{name} : "
-    str = markdown_header(name, options[:level])
-    str += "- **namevar**\n\n" if options[:namevar]
-    str += text
-    #str += text.gsub(/\n/, "\n    ")
-
-    str += "\n\n"
-  end
-
   def text
     puts output
   end
 
   def to_markdown(withcontents = true)
     # First the header
     text = markdown_header(@title, 1)
     text << "\n\n**This page is autogenerated; any changes will get overwritten** *(last generated on #{Time.now.to_s})*\n\n"
 
     text << @header
 
     text << generate
 
     text << self.class.footer if withcontents
 
     text
   end
 end