diff --git a/src/protocol/eval/executor.rs b/src/protocol/eval/executor.rs
index 2a77a1ebb0dcb357eb413cd626ea2b65a7abb639..51fd02d09163c89b2881c71691a6931795858990 100644
--- a/src/protocol/eval/executor.rs
+++ b/src/protocol/eval/executor.rs
@@ -135,7 +135,7 @@ impl Frame {
                 // Here we only care about literals that have subexpressions
                 match &expr.value {
                     Literal::Null | Literal::True | Literal::False |
-                    Literal::Character(_) | Literal::String(_) |
+                    Literal::Character(_) | Literal::Bytestring(_) | Literal::String(_) |
                     Literal::Integer(_) | Literal::Enum(_) => {
                         // No subexpressions
                     },
@@ -514,6 +514,16 @@ impl Prompt {
                                 Literal::True => Value::Bool(true),
                                 Literal::False => Value::Bool(false),
                                 Literal::Character(lit_value) => Value::Char(*lit_value),
+                                Literal::Bytestring(lit_value) => {
+                                    let heap_pos = self.store.alloc_heap();
+                                    let values = &mut self.store.heap_regions[heap_pos as usize].values;
+                                    debug_assert!(values.is_empty());
+                                    values.reserve(lit_value.len());
+                                    for byte in lit_value {
+                                        values.push(Value::UInt8(*byte));
+                                    }
+                                    Value::Array(heap_pos)
+                                }
                                 Literal::String(lit_value) => {
                                     let heap_pos = self.store.alloc_heap();
                                     let values = &mut self.store.heap_regions[heap_pos as usize].values;
@@ -718,6 +728,8 @@ impl Prompt {
                                     // Convert the runtime-variant of a string
                                     // into an actual string.
                                     let value = cur_frame.expr_values.pop_front().unwrap();
+                                    let mut is_literal_string = value.get_heap_pos().is_some();
+                                    let value = self.store.maybe_read_ref(&value);
                                     let value_heap_pos = value.as_string();
                                     let elements = &self.store.heap_regions[value_heap_pos as usize].values;
 
@@ -728,7 +740,10 @@ impl Prompt {
 
                                     // Drop the heap-allocated value from the
                                     // store
-                                    self.store.drop_heap_pos(value_heap_pos);
+                                    if is_literal_string {
+                                        self.store.drop_heap_pos(value_heap_pos);
+                                    }
+
                                     println!("{}", message);
                                 },
                                 Method::SelectStart => {
@@ -755,11 +770,15 @@ impl Prompt {
                                         },
                                     }
                                 },
+                                Method::ComponentRandomU32 | Method::ComponentTcpClient => {
+                                    debug_assert_eq!(heap[expr.procedure].parameters.len(), cur_frame.expr_values.len());
+                                    debug_assert_eq!(heap[cur_frame.position].as_new().expression, expr.this);
+                                },
                                 Method::UserComponent => {
                                     // This is actually handled by the evaluation
                                     // of the statement.
                                     debug_assert_eq!(heap[expr.procedure].parameters.len(), cur_frame.expr_values.len());
-                                    debug_assert_eq!(heap[cur_frame.position].as_new().expression, expr.this)
+                                    debug_assert_eq!(heap[cur_frame.position].as_new().expression, expr.this);
                                 },
                                 Method::UserFunction => {
                                     // Push a new frame. Note that all expressions have