     args = ['in'] unless args.length
     res = []
     for port in args
+      if @nodeInstance.isForwardingInport port
+        ip = @__getForForwarding port
+        res.push ip
+        continue
       ip = @ports[port].get @scope
       res.push ip
 
     if args.length is 1 then res[0] else res
+
+  __getForForwarding: (port) ->
+    # Ensure we have a bracket context for the current scope
+    @nodeInstance.bracketContext[@scope] = [] unless @nodeInstance.bracketContext[@scope]
+    prefix = []
+    dataIp = null
+    # Read IPs until we hit data
+    loop
+      # Read next packet
+      ip = @ports[port].get @scope
+      # Stop at the end of the buffer
+      break unless ip
+      if ip.type is 'data'
+        # Hit the data IP, stop here
+        dataIp = ip
+        break
+      # Keep track of bracket closings and openings before
+      prefix.push ip
+
+    # Forwarding brackets that came before data packet need to manipulate context
+    # and be added to result so they can be forwarded correctly to ports that
+    # need them
+    for ip in prefix
+      if ip.type is 'closeBracket'
+        # Bracket closings before data should remove bracket context
+        @result.__bracketClosingBefore = [] unless @result.__bracketClosingBefore
+        context = @nodeInstance.bracketContext[@scope].pop()
+        context.closeIp = ip
+        @result.__bracketClosingBefore.push context
+        continue
+      if ip.type is 'openBracket'
+        # Bracket openings need to go to bracket context
+        @nodeInstance.bracketContext[@scope].push
+          ip: ip
+          ports: []
+          source: port
+        continue
+
+    # Add current bracket context to the result so that when we send
+    # to ports we can also add the surrounding brackets
+    @result.__bracketContext = @nodeInstance.bracketContext[@scope].slice 0
+    # Bracket closings that were in buffer after the data packet need to
+    # be added to result for done() to read them from
+    return dataIp
 
   # Fetches `data` property of IP object(s) for given port(s)
   getData: (args...) ->

  done: (error) ->
    @error error if error

    debug "#{@nodeInstance.nodeId} finished processing #{@nodeInstance.load}"
    @nodeInstance.load--


      # If port is non-triggering, we can skip the process function call
      return

    if ip.type is 'openBracket' and @autoOrdering is null
      # Switch component to ordered mode when receiving a stream unless
      # auto-ordering is disabled
      debug "#{@nodeId} port #{port.name} entered auto-ordering mode"
      @autoOrdering = true

    # Initialize the result object for situations where output needs
    # to be queued to be kept in order
    result = {}

    if @isForwardingInport port
      # For bracket-forwarding inports we need to initialize a bracket context
      # so that brackets can be sent as part of the output, and closed after.
      if ip.type is 'openBracket'
        # For forwarding ports openBrackets don't fire
        return

      if ip.type is 'closeBracket'
        # For forwarding ports closeBrackets don't fire
        # However, we need to handle several different scenarios:
        # A. There are closeBrackets in queue before current packet
        # B. There are closeBrackets in queue after current packet
        # C. We're no longer processing anything and closeBracket arrives
        if @load is 0 and @outputQ.length is 0
          buf = port.getBuffer ip.scope
          return unless buf[0] is ip
          # Remove from buffer
          port.get ip.scope
          context = @bracketContext[ip.scope].pop()
          context.closeIp = ip
          return unless context.ports.length
          debug "#{@nodeId} closeBracket-C #{ip.data} #{context.ports}"
          result =
            __resolved: true
          for outport in context.ports
            result[outport] = [ip.clone()]
          @outputQ.push result
          do @processOutputQueue
        return

    # Prepare the input/output pair
    input = new ProcessInput @inPorts, ip, @, port, result
    output = new ProcessOutput @outPorts, ip, @, result
