diff --git a/src/runtime2/inbox.rs b/src/runtime2/inbox.rs
index b07d021190240a8c06e000f0bc4398e19bddb273..b14bbafdc12a4c6d71d73634fd83bd1bcecad9f9 100644
--- a/src/runtime2/inbox.rs
+++ b/src/runtime2/inbox.rs
@@ -238,11 +238,11 @@ impl PublicInbox {
     }
 }
 
-pub struct PrivateInbox {
+pub(crate) struct PrivateInbox {
     // "Normal" messages, intended for a PDL protocol. These need to stick
     // around during an entire sync-block (to handle `put`s for which the
     // corresponding `get`s have not yet been reached).
-    messages: Vec<DataMessage>,
+    messages: Vec<(PortIdLocal, DataMessage)>,
     len_read: usize,
 }
 
@@ -257,17 +257,17 @@ impl PrivateInbox {
     /// Will insert the message into the inbox. Only exception is when the tuple
     /// (prev_branch_id, cur_branch_id, receiving_port_id) already exists, then
     /// nothing is inserted..
-    pub fn insert_message(&mut self, message: DataMessage) {
-        for existing in self.messages.iter() {
+    pub(crate) fn insert_message(&mut self, target_port: PortIdLocal, message: DataMessage) {
+        for (existing_target_port, existing) in self.messages.iter() {
             if existing.sender_prev_branch_id == message.sender_prev_branch_id &&
                     existing.sender_cur_branch_id == message.sender_cur_branch_id &&
-                    existing.sending_port == message.sending_port {
+                    *existing_target_port == target_port {
                 // Message was already received
                 return;
             }
         }
 
-        self.messages.push(message);
+        self.messages.push((target_port, message));
     }
 
     /// Retrieves all previously read messages that satisfy the provided
@@ -278,7 +278,7 @@ impl PrivateInbox {
     /// This function should only be used to check if already-received messages
     /// could be received by a newly encountered `get` call in a connector's
     /// PDL code.
-    pub fn get_messages(&self, port_id: PortIdLocal, prev_branch_id: BranchId) -> InboxMessageIter {
+    pub(crate) fn get_messages(&self, port_id: PortIdLocal, prev_branch_id: BranchId) -> InboxMessageIter {
         return InboxMessageIter{
             messages: &self.messages,
             next_index: 0,
@@ -290,26 +290,26 @@ impl PrivateInbox {
 
     /// Retrieves the next unread message. Should only be called by the
     /// inbox-reader.
-    pub fn next_message(&mut self) -> Option<&DataMessage> {
+    pub(crate) fn next_message(&mut self) -> Option<&DataMessage> {
         if self.len_read == self.messages.len() {
             return None;
         }
 
-        let to_return = &self.messages[self.len_read];
+        let (_, to_return) = &self.messages[self.len_read];
         self.len_read += 1;
         return Some(to_return);
     }
 
     /// Simply empties the inbox
-    pub fn clear(&mut self) {
+    pub(crate) fn clear(&mut self) {
         self.messages.clear();
         self.len_read = 0;
     }
 }
 
 /// Iterator over previously received messages in the inbox.
-pub struct InboxMessageIter<'i> {
-    messages: &'i Vec<DataMessage>,
+pub(crate) struct InboxMessageIter<'i> {
+    messages: &'i Vec<(PortIdLocal, DataMessage)>,
     next_index: usize,
     max_index: usize,
     match_port_id: PortIdLocal,
@@ -322,8 +322,8 @@ impl<'i> Iterator for InboxMessageIter<'i> {
     fn next(&mut self) -> Option<Self::Item> {
         // Loop until match is found or at end of messages
         while self.next_index < self.max_index {
-            let cur_message = &self.messages[self.next_index];
-            if cur_message.receiving_port == self.match_port_id && cur_message.sender_prev_branch_id == self.match_prev_branch_id {
+            let (target_port, cur_message) = &self.messages[self.next_index];
+            if *target_port == self.match_port_id && cur_message.sender_prev_branch_id == self.match_prev_branch_id {
                 // Found a match
                 break;
             }
@@ -335,7 +335,7 @@ impl<'i> Iterator for InboxMessageIter<'i> {
             return None;
         }
 
-        let message = &self.messages[self.next_index];
+        let (_, message) = &self.messages[self.next_index];
         self.next_index += 1;
         return Some(message);
     }