fix: address code review feedback

Signed-off-by: Tomasz Andrzejak <andreiltd@gmail.com>

Author: andreiltd

src/hyperlight_common/src/flatbuffer_wrappers/codec.rs

@@ -15,11 +15,14 @@ pub trait ExternalValueSink<'a> {
     /// Receive one contiguous byte value.
     fn push_bytes(&mut self, value: &'a [u8]) -> Result<()>;
 
-    /// Receive one chunk-preserving byte value.
+    /// Receive one logical byte sequence represented as chunks.
     fn push_chunks(&mut self, value: &'a [Bytes]) -> Result<()>;
 }
 
 /// Supplies complete external byte values while a FlatBuffer is decoded.
+///
+/// Implementations must validate `length` against available input and the
+/// resource budget before allocating.
 pub trait ExternalValueSource {
     /// Take the next external value as contiguous bytes.
     fn take_bytes(&mut self, length: usize) -> Result<Vec<u8>>;

src/hyperlight_common/src/flatbuffer_wrappers/function_types.rs

@@ -305,10 +305,10 @@ pub enum ParameterValue {
     Bool(bool),
     /// `Vec<u8>`
     VecBytes(Vec<u8>),
-    /// One complete chunk-preserving byte value.
+    /// One logical byte sequence represented as chunks.
     ///
-    /// Chunk boundaries are not framing and are not guaranteed to survive
-    /// transport.
+    /// Chunk boundaries are a storage detail and may change during transport.
+    /// They do not delimit messages or values.
     ByteChunks(
         #[cfg_attr(feature = "fuzzing", arbitrary(with = arbitrary_byte_chunks))] Vec<Bytes>,
     ),
@@ -336,7 +336,7 @@ pub enum ParameterType {
     Bool,
     /// `Vec<u8>`
     VecBytes,
-    /// One complete chunk-preserving byte value.
+    /// One logical byte sequence represented as chunks.
     ByteChunks,
 }
 
@@ -363,10 +363,10 @@ pub enum ReturnValue {
     Void(()),
     /// `Vec<u8>`
     VecBytes(Vec<u8>),
-    /// One complete chunk-preserving byte value.
+    /// One logical byte sequence represented as chunks.
     ///
-    /// Chunk boundaries are not framing and are not guaranteed to survive
-    /// transport.
+    /// Chunk boundaries are a storage detail and may change during transport.
+    /// They do not delimit messages or values.
     ByteChunks(Vec<Bytes>),
 }
 
@@ -396,7 +396,7 @@ pub enum ReturnType {
     Void,
     /// `Vec<u8>`
     VecBytes,
-    /// One complete chunk-preserving byte value.
+    /// One logical byte sequence represented as chunks.
     ByteChunks,
 }
 

src/hyperlight_common/src/func/ret_type.rs

@@ -9,9 +9,11 @@ use crate::flatbuffer_wrappers::function_types::{ReturnType, ReturnValue};
 
 /// This is a marker trait that is used to indicate that a type is a valid Hyperlight return type.
 ///
-/// `Vec<u8>` and `Vec<Bytes>` are distinct logical return types. `Vec<u8>`
-/// carries contiguous bytes, while `Vec<Bytes>` preserves local chunk
-/// ownership. Chunk boundaries are not application framing.
+/// `Vec<u8>` and `Vec<Bytes>` both represent one logical byte sequence.
+/// `Vec<u8>` stores it contiguously. `Vec<Bytes>` represents it as chunks and
+/// may avoid flattening them into one allocation. Chunk boundaries are a
+/// storage detail and may change during transport. They do not delimit messages
+/// or values.
 pub trait SupportedReturnType: Sized + Clone + Send + Sync + 'static {
     /// The return type of the supported return value
     const TYPE: ReturnType;

src/hyperlight_guest_capi/src/types/parameter.rs

@@ -97,20 +97,12 @@ impl OwnedFfiParameter {
                     FfiParameterOwner::String { _value: value },
                 )
             }
-            ParameterValue::VecBytes(v) => {
-    ParameterValue::VecBytes(mut v) => {
-        let view = FfiVec::from_mut_slice(&mut v);
-        (
-            ParameterType::VecBytes,
-            FfiParameterValue { VecBytes: view },
-            FfiParameterOwner::VecBytes { _value: v },
-        )
-    }
-                let view = FfiVec::from_mut_slice(&mut value);
+            ParameterValue::VecBytes(mut v) => {
+                let view = FfiVec::from_mut_slice(&mut v);
                 (
                     ParameterType::VecBytes,
                     FfiParameterValue { VecBytes: view },
-                    FfiParameterOwner::VecBytes { _value: value },
+                    FfiParameterOwner::VecBytes { _value: v },
                 )
             }
             ParameterValue::ByteChunks(v) => {

src/hyperlight_guest_capi/src/types/vec.rs

@@ -16,6 +16,10 @@ pub struct FfiVec {
 }
 
 impl FfiVec {
+    /// Creates a non-owning FFI view over `value` without copying.
+    ///
+    /// The caller must keep `value` alive and at a stable address while the
+    /// view is used. The view must not be passed to [`Self::into_vec`].
     pub(crate) fn from_mut_slice(value: &mut [u8]) -> Self {
         Self {
             data: value.as_mut_ptr(),

src/schema/function_types.fbs

@@ -57,15 +57,16 @@ table hlvecbytes {
     value:[ubyte];
 }
 
-// hlbytechunks is the embedded compatibility representation of a chunked byte
-// value. Embedded transport does not preserve chunk boundaries.
+// hlbytechunks is the embedded compatibility representation of one logical
+// byte sequence. It stores the bytes contiguously, so original chunk boundaries
+// are not preserved.
 
 table hlbytechunks {
     value:[ubyte];
 }
 
 // hlexternalbytes declares a logical byte value stored outside the FlatBuffer.
-// chunked distinguishes ByteChunks from the default VecBytes logical type.
+// chunked requests the ByteChunks representation rather than VecBytes.
 
 table hlexternalbytes {
     length:ulong;