       callback = shiftable.pop()
 
     nameOrPattern = shiftable.shift()
-    packet        = @packets[nameOrPattern] or {}
+    packet        = @_packets[nameOrPattern] or {}
     pattern       = packet.pattern or parsePattern(nameOrPattern)
     callback    or= packet.callback or noop
 

class Packet extends stream.Stream
  # Construct a packet that sends events using the given `self` as `this`.
  constructor: (@self) ->
    @packets = {}
    @reset()
    @fields = []
    @transforms = Object.create(transforms)

  # Create a copy that will adopt the packets defined in this object, through
  # prototype inheritence. This is used to efficently create parsers and
  # serializers that can run concurrently, from a pre-configured prototype,
  # following classic GoF prototype creational pattern.
  clone: ->
    copy            = new (this.constructor)()
    copy.packets    = Object.create(packets)
    copy

  # Map a named packet with the given `name` to the given `pattern`. 
  packet: (name, pattern, callback) ->
    callback      or= noop
    pattern         = parsePattern(pattern)
    @packets[name]  = {pattern, callback}

  # Resets the bytes read, bytes written and the current pattern. Used to
  # recover from exceptional conditions and generally a good idea to call this

        # If we are filling an array field the current fields is an array,
        # otherwise current field is the value we've just read.
        if @pattern[@patternIndex].arrayed
          @_fields[@_fields.length - 1].push(field) if field?
        else
          @_fields.push(field)


      # If we've not yet hit our terminator, check for the terminator. If we've
