diff --git a/lib/puppet/resource.rb b/lib/puppet/resource.rb
index 7dea270e8..4f0d50750 100644
--- a/lib/puppet/resource.rb
+++ b/lib/puppet/resource.rb
@@ -1,404 +1,416 @@
 require 'puppet'
 require 'puppet/util/tagging'
 require 'puppet/util/pson'
 
 # The simplest resource class.  Eventually it will function as the
 # base class for all resource-like behaviour.
 class Puppet::Resource
   include Puppet::Util::Tagging
 
   require 'puppet/resource/type_collection_helper'
   include Puppet::Resource::TypeCollectionHelper
 
   extend Puppet::Util::Pson
   include Enumerable
   attr_accessor :file, :line, :catalog, :exported, :virtual, :validate_parameters, :strict
   attr_reader :type, :title
 
   require 'puppet/indirector'
   extend Puppet::Indirector
   indirects :resource, :terminus_class => :ral
 
   ATTRIBUTES = [:file, :line, :exported]
 
   def self.from_pson(pson)
     raise ArgumentError, "No resource type provided in pson data" unless type = pson['type']
     raise ArgumentError, "No resource title provided in pson data" unless title = pson['title']
 
     resource = new(type, title)
 
     if params = pson['parameters']
       params.each { |param, value| resource[param] = value }
     end
 
     if tags = pson['tags']
       tags.each { |tag| resource.tag(tag) }
     end
 
     ATTRIBUTES.each do |a|
       if value = pson[a.to_s]
         resource.send(a.to_s + "=", value)
       end
     end
 
     resource.exported ||= false
 
     resource
   end
 
   def to_pson_data_hash
     data = ([:type, :title, :tags] + ATTRIBUTES).inject({}) do |hash, param|
       next hash unless value = self.send(param)
       hash[param.to_s] = value
       hash
     end
 
     data["exported"] ||= false
 
     params = self.to_hash.inject({}) do |hash, ary|
       param, value = ary
 
       # Don't duplicate the title as the namevar
       next hash if param == namevar and value == title
 
       hash[param] = Puppet::Resource.value_to_pson_data(value)
       hash
     end
 
     data["parameters"] = params unless params.empty?
 
     data
   end
 
   def self.value_to_pson_data(value)
     if value.is_a? Array
       value.map{|v| value_to_pson_data(v) }
     elsif value.is_a? Puppet::Resource
       value.to_s
     else
       value
     end
   end
 
+  def yaml_property_munge(x)
+    case x
+    when Hash
+      x.inject({}) { |h,kv| 
+        k,v = kv
+        h[k] = self.class.value_to_pson_data(v)
+        h
+      }
+    else self.class.value_to_pson_data(x)
+    end
+  end
+
   def to_pson(*args)
     to_pson_data_hash.to_pson(*args)
   end
 
   # Proxy these methods to the parameters hash.  It's likely they'll
   # be overridden at some point, but this works for now.
   %w{has_key? keys length delete empty? <<}.each do |method|
     define_method(method) do |*args|
       @parameters.send(method, *args)
     end
   end
 
   # Set a given parameter.  Converts all passed names
   # to lower-case symbols.
   def []=(param, value)
     validate_parameter(param) if validate_parameters
     @parameters[parameter_name(param)] = value
   end
 
   # Return a given parameter's value.  Converts all passed names
   # to lower-case symbols.
   def [](param)
     @parameters[parameter_name(param)]
   end
 
   def ==(other)
     return false unless other.respond_to?(:title) and self.type == other.type and self.title == other.title
 
     return false unless to_hash == other.to_hash
     true
   end
 
   # Compatibility method.
   def builtin?
     builtin_type?
   end
 
   # Is this a builtin resource type?
   def builtin_type?
     resource_type.is_a?(Class)
   end
 
   # Iterate over each param/value pair, as required for Enumerable.
   def each
     @parameters.each { |p,v| yield p, v }
   end
 
   def include?(parameter)
     super || @parameters.keys.include?( parameter_name(parameter) )
   end
 
   # These two methods are extracted into a Helper
   # module, but file load order prevents me
   # from including them in the class, and I had weird
   # behaviour (i.e., sometimes it didn't work) when
   # I directly extended each resource with the helper.
   def environment
     Puppet::Node::Environment.new(@environment)
   end
 
   def environment=(env)
     if env.is_a?(String) or env.is_a?(Symbol)
       @environment = env
     else
       @environment = env.name
     end
   end
 
   %w{exported virtual strict}.each do |m|
     define_method(m+"?") do
       self.send(m)
     end
   end
 
   # This stub class is only needed for serialization compatibility with 0.25.x
   class Reference
     attr_accessor :type,:title
     def initialize(type,title)
       @type,@title = type,title
     end
   end
 
   # Create our resource.
   def initialize(type, title = nil, attributes = {})
     @parameters = {}
 
     # Set things like strictness first.
     attributes.each do |attr, value|
       next if attr == :parameters
       send(attr.to_s + "=", value)
     end
 
     @type, @title = extract_type_and_title(type, title)
 
     @type = munge_type_name(@type)
 
     if @type == "Class"
       @title = :main if @title == ""
       @title = munge_type_name(@title)
     end
 
     if params = attributes[:parameters]
       extract_parameters(params)
     end
 
     tag(self.type)
     tag(self.title) if valid_tag?(self.title)
 
     @reference = Reference.new(@type,@title) # for serialization compatibility with 0.25.x
 
     raise ArgumentError, "Invalid resource type #{type}" if strict? and ! resource_type
   end
 
   def ref
     to_s
   end
 
   # Find our resource.
   def resolve
     return(catalog ? catalog.resource(to_s) : nil)
   end
 
   def resource_type
     case type
     when "Class"; known_resource_types.hostclass(title == :main ? "" : title)
     when "Node"; known_resource_types.node(title)
     else
       Puppet::Type.type(type.to_s.downcase.to_sym) || known_resource_types.definition(type)
     end
   end
 
   # Produce a simple hash of our parameters.
   def to_hash
     parse_title.merge @parameters
   end
 
   def to_s
     "#{type}[#{title}]"
   end
 
   def uniqueness_key
     # Temporary kludge to deal with inconsistant use patters
     h = self.to_hash
     h[namevar] ||= h[:name]
     h[:name]   ||= h[namevar]
     h.values_at(*key_attributes.sort_by { |k| k.to_s })
   end
 
   def key_attributes
     return(resource_type.respond_to? :key_attributes) ? resource_type.key_attributes : [:name]
   end
 
   # Convert our resource to Puppet code.
   def to_manifest
     "%s { '%s':\n%s\n}" % [self.type.to_s.downcase, self.title,
       @parameters.collect { |p, v|
         if v.is_a? Array
           "    #{p} => [\'#{v.join("','")}\']"
         else
           "    #{p} => \'#{v}\'"
         end
       }.join(",\n")
       ]
   end
 
   def to_ref
     ref
   end
 
   # Convert our resource to a RAL resource instance.  Creates component
   # instances for resource types that don't exist.
   def to_ral
     if typeklass = Puppet::Type.type(self.type)
       return typeklass.new(self)
     else
       return Puppet::Type::Component.new(self)
     end
   end
 
   # Translate our object to a backward-compatible transportable object.
   def to_trans
     if builtin_type? and type.downcase.to_s != "stage"
       result = to_transobject
     else
       result = to_transbucket
     end
 
     result.file = self.file
     result.line = self.line
 
     result
   end
 
   def to_trans_ref
     [type.to_s, title.to_s]
   end
 
   # Create an old-style TransObject instance, for builtin resource types.
   def to_transobject
     # Now convert to a transobject
     result = Puppet::TransObject.new(title, type)
     to_hash.each do |p, v|
       if v.is_a?(Puppet::Resource)
         v = v.to_trans_ref
       elsif v.is_a?(Array)
         v = v.collect { |av|
           av = av.to_trans_ref if av.is_a?(Puppet::Resource)
           av
         }
       end
 
       # If the value is an array with only one value, then
       # convert it to a single value.  This is largely so that
       # the database interaction doesn't have to worry about
       # whether it returns an array or a string.
       result[p.to_s] = if v.is_a?(Array) and v.length == 1
         v[0]
           else
             v
               end
     end
 
     result.tags = self.tags
 
     result
   end
 
   def name
     # this is potential namespace conflict
     # between the notion of an "indirector name"
     # and a "resource name"
     [ type, title ].join('/')
   end
 
   def to_resource
     self
   end
 
   def valid_parameter?(name)
     resource_type.valid_parameter?(name)
   end
 
   def validate_parameter(name)
     raise ArgumentError, "Invalid parameter #{name}" unless valid_parameter?(name)
   end
 
   private
 
   # Produce a canonical method name.
   def parameter_name(param)
     param = param.to_s.downcase.to_sym
     if param == :name and n = namevar
       param = namevar
     end
     param
   end
 
   # The namevar for our resource type. If the type doesn't exist,
   # always use :name.
   def namevar
     if builtin_type? and t = resource_type and t.key_attributes.length == 1
       t.key_attributes.first
     else
       :name
     end
   end
 
   # Create an old-style TransBucket instance, for non-builtin resource types.
   def to_transbucket
     bucket = Puppet::TransBucket.new([])
 
     bucket.type = self.type
     bucket.name = self.title
 
     # TransBuckets don't support parameters, which is why they're being deprecated.
     bucket
   end
 
   def extract_parameters(params)
     params.each do |param, value|
       validate_parameter(param) if strict?
       self[param] = value
     end
   end
 
   def extract_type_and_title(argtype, argtitle)
     if    (argtitle || argtype) =~ /^([^\[\]]+)\[(.+)\]$/m then [ $1,                 $2            ]
     elsif argtitle                                         then [ argtype,            argtitle      ]
     elsif argtype.is_a?(Puppet::Type)                      then [ argtype.class.name, argtype.title ]
     elsif argtype.is_a?(Hash)                              then
       raise ArgumentError, "Puppet::Resource.new does not take a hash as the first argument. "+
         "Did you mean (#{(argtype[:type] || argtype["type"]).inspect}, #{(argtype[:title] || argtype["title"]).inspect }) ?"
     else raise ArgumentError, "No title provided and #{argtype.inspect} is not a valid resource reference"
     end
   end
 
   def munge_type_name(value)
     return :main if value == :main
     return "Class" if value == "" or value.nil? or value.to_s.downcase == "component"
 
     value.to_s.split("::").collect { |s| s.capitalize }.join("::")
   end
 
   def parse_title
     h = {}
     type = resource_type
     if type.respond_to? :title_patterns
       type.title_patterns.each { |regexp, symbols_and_lambdas|
         if captures = regexp.match(title.to_s)
           symbols_and_lambdas.zip(captures[1..-1]).each { |symbol_and_lambda,capture|
             sym, lam = symbol_and_lambda
             #self[sym] = lam.call(capture)
             h[sym] = lam.call(capture)
           }
           return h
         end
       }
     else
       return { :name => title.to_s }
     end
   end
 end
diff --git a/lib/puppet/util/zaml.rb b/lib/puppet/util/zaml.rb
index 64c58f9a3..9fda5ae3b 100644
--- a/lib/puppet/util/zaml.rb
+++ b/lib/puppet/util/zaml.rb
@@ -1,318 +1,321 @@
 #
 # ZAML -- A partial replacement for YAML, writen with speed and code clarity
 #         in mind.  ZAML fixes one YAML bug (loading Exceptions) and provides
 #         a replacement for YAML.dump unimaginatively called ZAML.dump,
 #         which is faster on all known cases and an order of magnitude faster
 #         with complex structures.
 #
 # http://github.com/hallettj/zaml
 #
 # Authors: Markus Roberts, Jesse Hallett, Ian McIntosh, Igal Koshevoy, Simon Chiang
 #
 
 require 'yaml'
 
 class ZAML
   VERSION = "0.1.1"
   #
   # Class Methods
   #
   def self.dump(stuff, where='')
     z = new
     stuff.to_zaml(z)
     where << z.to_s
   end
   #
   # Instance Methods
   #
   def initialize
     @result = []
     @indent = nil
     @structured_key_prefix = nil
     Label.counter_reset
     emit('--- ')
   end
   def nested(tail='  ')
     old_indent = @indent
     @indent = "#{@indent || "\n"}#{tail}"
     yield
     @indent = old_indent
   end
   class Label
     #
     # YAML only wants objects in the datastream once; if the same object
     #    occurs more than once, we need to emit a label ("&idxxx") on the
     #    first occurrence and then emit a back reference (*idxxx") on any
     #    subsequent occurrence(s).
     #
     # To accomplish this we keeps a hash (by object id) of the labels of
     #    the things we serialize as we begin to serialize them.  The labels
     #    initially serialize as an empty string (since most objects are only
     #    going to be be encountered once), but can be changed to a valid
     #    (by assigning it a number) the first time it is subsequently used,
     #    if it ever is.  Note that we need to do the label setup BEFORE we
     #    start to serialize the object so that circular structures (in
     #    which we will encounter a reference to the object as we serialize
     #    it can be handled).
     #
     def self.counter_reset
       @@previously_emitted_object = {}
       @@next_free_label_number = 0
     end
     def initialize(obj,indent)
       @indent = indent
       @this_label_number = nil
       @@previously_emitted_object[obj.object_id] = self
     end
     def to_s
       @this_label_number ? ('&id%03d%s' % [@this_label_number, @indent]) : ''
     end
     def reference
       @this_label_number ||= (@@next_free_label_number += 1)
       @reference         ||= '*id%03d' % @this_label_number
     end
     def self.for(obj)
       @@previously_emitted_object[obj.object_id]
     end
   end
   def new_label_for(obj)
     Label.new(obj,(Hash === obj || Array === obj) ? "#{@indent || "\n"}  " : ' ')
   end
   def first_time_only(obj)
     if label = Label.for(obj)
       emit(label.reference)
     else
       if @structured_key_prefix and not obj.is_a? String
         emit(@structured_key_prefix)
         @structured_key_prefix = nil
       end
       emit(new_label_for(obj))
       yield
     end
   end
   def emit(s)
     @result << s
     @recent_nl = false unless s.kind_of?(Label)
   end
   def nl(s='')
     emit(@indent || "\n") unless @recent_nl
     emit(s)
     @recent_nl = true
   end
   def to_s
     @result.join
   end
   def prefix_structured_keys(x)
     @structured_key_prefix = x
     yield
     nl unless @structured_key_prefix
     @structured_key_prefix = nil
   end
 end
 
 ################################################################
 #
 #   Behavior for custom classes
 #
 ################################################################
 
 class Object
   def to_yaml_properties
     instance_variables.sort        # Default YAML behavior
   end
+  def yaml_property_munge(x)
+    x
+  end
   def zamlized_class_name(root)
     cls = self.class
     "!ruby/#{root.name.downcase}#{cls == root ? '' : ":#{cls.respond_to?(:name) ? cls.name : cls}"}"
   end
   def to_zaml(z)
     z.first_time_only(self) {
       z.emit(zamlized_class_name(Object))
       z.nested {
         instance_variables = to_yaml_properties
         if instance_variables.empty?
           z.emit(" {}")
         else
           instance_variables.each { |v|
             z.nl
             v[1..-1].to_zaml(z)       # Remove leading '@'
             z.emit(': ')
-            instance_variable_get(v).to_zaml(z)
+            yaml_property_munge(instance_variable_get(v)).to_zaml(z)
           }
         end
       }
     }
   end
 end
 
 ################################################################
 #
 #   Behavior for built-in classes
 #
 ################################################################
 
 class NilClass
   def to_zaml(z)
     z.emit('')        # NOTE: blank turns into nil in YAML.load
   end
 end
 
 class Symbol
   def to_zaml(z)
     z.emit(self.inspect)
   end
 end
 
 class TrueClass
   def to_zaml(z)
     z.emit('true')
   end
 end
 
 class FalseClass
   def to_zaml(z)
     z.emit('false')
   end
 end
 
 class Numeric
   def to_zaml(z)
     z.emit(self)
   end
 end
 
 class Regexp
   def to_zaml(z)
     z.first_time_only(self) { z.emit("#{zamlized_class_name(Regexp)} #{inspect}") }
   end
 end
 
 class Exception
   def to_zaml(z)
     z.emit(zamlized_class_name(Exception))
     z.nested {
       z.nl("message: ")
       message.to_zaml(z)
     }
   end
   #
   # Monkey patch for buggy Exception restore in YAML
   #
   #     This makes it work for now but is not very future-proof; if things
   #     change we'll most likely want to remove this.  To mitigate the risks
   #     as much as possible, we test for the bug before appling the patch.
   #
   if respond_to? :yaml_new and yaml_new(self, :tag, "message" => "blurp").message != "blurp"
     def self.yaml_new( klass, tag, val )
       o = YAML.object_maker( klass, {} ).exception(val.delete( 'message'))
       val.each_pair do |k,v|
         o.instance_variable_set("@#{k}", v)
       end
       o
     end
   end
 end
 
 class String
   ZAML_ESCAPES = %w{\x00 \x01 \x02 \x03 \x04 \x05 \x06 \a \x08 \t \n \v \f \r \x0e \x0f \x10 \x11 \x12 \x13 \x14 \x15 \x16 \x17 \x18 \x19 \x1a \e \x1c \x1d \x1e \x1f }
   def escaped_for_zaml
     gsub( /\x5C/, "\\\\\\" ).  # Demi-kludge for Maglev/rubinius; the regexp should be /\\/ but parsetree chokes on that.
     gsub( /"/, "\\\"" ).
     gsub( /([\x00-\x1F])/ ) { |x| ZAML_ESCAPES[ x.unpack("C")[0] ] }.
     gsub( /([\x80-\xFF])/ ) { |x| "\\x#{x.unpack("C")[0].to_s(16)}" }
   end
   def to_zaml(z)
     z.first_time_only(self) {
       num = '[-+]?(0x)?\d+\.?\d*'
       case
         when self == ''
           z.emit('""')
         # when self =~ /[\x00-\x08\x0B\x0C\x0E-\x1F\x80-\xFF]/
         #   z.emit("!binary |\n")
         #   z.emit([self].pack("m*"))
         when (
           (self =~ /\A(true|false|yes|no|on|null|off|#{num}(:#{num})*|!|=|~)$/i) or
           (self =~ /\A\n* /) or
           (self =~ /[\s:]$/) or
           (self =~ /^[>|][-+\d]*\s/i) or
           (self[-1..-1] =~ /\s/) or
           (self =~ /[\x00-\x08\x0B\x0C\x0E-\x1F\x80-\xFF]/) or
           (self =~ /[,\[\]\{\}\r\t]|:\s|\s#/) or
           (self =~ /\A([-:?!#&*'"]|<<|%.+:.)/)
           )
           z.emit("\"#{escaped_for_zaml}\"")
         when self =~ /\n/
           if self[-1..-1] == "\n" then z.emit('|+') else z.emit('|-') end
           z.nested { split("\n",-1).each { |line| z.nl; z.emit(line.chomp("\n")) } }
         else
           z.emit(self)
       end
     }
   end
 end
 
 class Hash
   def to_zaml(z)
     z.first_time_only(self) {
       z.nested {
         if empty?
           z.emit('{}')
         else
           each_pair { |k, v|
             z.nl
             z.prefix_structured_keys('? ') { k.to_zaml(z) }
             z.emit(': ')
             v.to_zaml(z)
           }
         end
       }
     }
   end
 end
 
 class Array
   def to_zaml(z)
     z.first_time_only(self) {
       z.nested {
         if empty?
           z.emit('[]')
         else
           each { |v| z.nl('- '); v.to_zaml(z) }
         end
       }
     }
   end
 end
 
 class Time
   def to_zaml(z)
     # 2008-12-06 10:06:51.373758 -07:00
     ms = ("%0.6f" % (usec * 1e-6)).sub(/^\d+\./,'')
     offset = "%+0.2i:%0.2i" % [utc_offset / 3600, (utc_offset / 60) % 60]
     z.emit(self.strftime("%Y-%m-%d %H:%M:%S.#{ms} #{offset}"))
   end
 end
 
 class Date
   def to_zaml(z)
     z.emit(strftime('%Y-%m-%d'))
   end
 end
 
 class Range
   def to_zaml(z)
     z.first_time_only(self) {
       z.emit(zamlized_class_name(Range))
       z.nested {
         z.nl
         z.emit('begin: ')
         z.emit(first)
         z.nl
         z.emit('end: ')
         z.emit(last)
         z.nl
         z.emit('excl: ')
         z.emit(exclude_end?)
       }
     }
   end
 end