Regenerate flatbuffer code

simongdavies · simongdavies · commit 54d6815a707b · 2025-09-11T16:25:47.000+01:00
Signed-off-by: Simon Davies &lt;simongdavies@users.noreply.github.com&gt;
diff --git a/src/hyperlight_common/src/flatbuffers/hyperlight/generated/error_code_generated.rs b/src/hyperlight_common/src/flatbuffers/hyperlight/generated/error_code_generated.rs
@@ -124,7 +124,7 @@ impl<'a> flatbuffers::Follow<'a> for ErrorCode {
     type Inner = Self;
     #[inline]
     unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-        let b = flatbuffers::read_scalar_at::<u64>(buf, loc);
+        let b = unsafe { flatbuffers::read_scalar_at::<u64>(buf, loc) };
         Self(b)
     }
 }
@@ -133,7 +133,9 @@ impl flatbuffers::Push for ErrorCode {
     type Output = ErrorCode;
     #[inline]
     unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
-        flatbuffers::emplace_scalar::<u64>(dst, self.0);
+        unsafe {
+            flatbuffers::emplace_scalar::<u64>(dst, self.0);
+        }
     }
 }
 
diff --git a/src/hyperlight_common/src/flatbuffers/hyperlight/generated/function_call_generated.rs b/src/hyperlight_common/src/flatbuffers/hyperlight/generated/function_call_generated.rs
@@ -22,7 +22,7 @@ impl<'a> flatbuffers::Follow<'a> for FunctionCall<'a> {
     #[inline]
     unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table::new(buf, loc),
+            _tab: unsafe { flatbuffers::Table::new(buf, loc) },
         }
     }
 }
@@ -290,14 +290,14 @@ pub fn size_prefixed_root_as_function_call_with_opts<'b, 'o>(
 /// # Safety
 /// Callers must trust the given bytes do indeed contain a valid `FunctionCall`.
 pub unsafe fn root_as_function_call_unchecked(buf: &[u8]) -> FunctionCall {
-    flatbuffers::root_unchecked::<FunctionCall>(buf)
+    unsafe { flatbuffers::root_unchecked::<FunctionCall>(buf) }
 }
 #[inline]
 /// Assumes, without verification, that a buffer of bytes contains a size prefixed FunctionCall and returns it.
 /// # Safety
 /// Callers must trust the given bytes do indeed contain a valid size prefixed `FunctionCall`.
 pub unsafe fn size_prefixed_root_as_function_call_unchecked(buf: &[u8]) -> FunctionCall {
-    flatbuffers::size_prefixed_root_unchecked::<FunctionCall>(buf)
+    unsafe { flatbuffers::size_prefixed_root_unchecked::<FunctionCall>(buf) }
 }
 #[inline]
 pub fn finish_function_call_buffer<'a, 'b, A: flatbuffers::Allocator + 'a>(
diff --git a/src/hyperlight_common/src/flatbuffers/hyperlight/generated/function_call_result_generated.rs b/src/hyperlight_common/src/flatbuffers/hyperlight/generated/function_call_result_generated.rs
@@ -22,7 +22,7 @@ impl<'a> flatbuffers::Follow<'a> for FunctionCallResult<'a> {
     #[inline]
     unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table::new(buf, loc),
+            _tab: unsafe { flatbuffers::Table::new(buf, loc) },
         }
     }
 }
@@ -513,7 +513,7 @@ pub fn size_prefixed_root_as_function_call_result_with_opts<'b, 'o>(
 /// # Safety
 /// Callers must trust the given bytes do indeed contain a valid `FunctionCallResult`.
 pub unsafe fn root_as_function_call_result_unchecked(buf: &[u8]) -> FunctionCallResult {
-    flatbuffers::root_unchecked::<FunctionCallResult>(buf)
+    unsafe { flatbuffers::root_unchecked::<FunctionCallResult>(buf) }
 }
 #[inline]
 /// Assumes, without verification, that a buffer of bytes contains a size prefixed FunctionCallResult and returns it.
@@ -522,7 +522,7 @@ pub unsafe fn root_as_function_call_result_unchecked(buf: &[u8]) -> FunctionCall
 pub unsafe fn size_prefixed_root_as_function_call_result_unchecked(
     buf: &[u8],
 ) -> FunctionCallResult {
-    flatbuffers::size_prefixed_root_unchecked::<FunctionCallResult>(buf)
+    unsafe { flatbuffers::size_prefixed_root_unchecked::<FunctionCallResult>(buf) }
 }
 #[inline]
 pub fn finish_function_call_result_buffer<'a, 'b, A: flatbuffers::Allocator + 'a>(
diff --git a/src/hyperlight_common/src/flatbuffers/hyperlight/generated/function_call_type_generated.rs b/src/hyperlight_common/src/flatbuffers/hyperlight/generated/function_call_type_generated.rs
@@ -66,7 +66,7 @@ impl<'a> flatbuffers::Follow<'a> for FunctionCallType {
     type Inner = Self;
     #[inline]
     unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-        let b = flatbuffers::read_scalar_at::<u8>(buf, loc);
+        let b = unsafe { flatbuffers::read_scalar_at::<u8>(buf, loc) };
         Self(b)
     }
 }
@@ -75,7 +75,9 @@ impl flatbuffers::Push for FunctionCallType {
     type Output = FunctionCallType;
     #[inline]
     unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
-        flatbuffers::emplace_scalar::<u8>(dst, self.0);
+        unsafe {
+            flatbuffers::emplace_scalar::<u8>(dst, self.0);
+        }
     }
 }
 
diff --git a/src/hyperlight_common/src/flatbuffers/hyperlight/generated/guest_error_generated.rs b/src/hyperlight_common/src/flatbuffers/hyperlight/generated/guest_error_generated.rs
@@ -22,7 +22,7 @@ impl<'a> flatbuffers::Follow<'a> for GuestError<'a> {
     #[inline]
     unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table::new(buf, loc),
+            _tab: unsafe { flatbuffers::Table::new(buf, loc) },
         }
     }
 }
@@ -192,14 +192,14 @@ pub fn size_prefixed_root_as_guest_error_with_opts<'b, 'o>(
 /// # Safety
 /// Callers must trust the given bytes do indeed contain a valid `GuestError`.
 pub unsafe fn root_as_guest_error_unchecked(buf: &[u8]) -> GuestError {
-    flatbuffers::root_unchecked::<GuestError>(buf)
+    unsafe { flatbuffers::root_unchecked::<GuestError>(buf) }
 }
 #[inline]
 /// Assumes, without verification, that a buffer of bytes contains a size prefixed GuestError and returns it.
 /// # Safety
 /// Callers must trust the given bytes do indeed contain a valid size prefixed `GuestError`.
 pub unsafe fn size_prefixed_root_as_guest_error_unchecked(buf: &[u8]) -> GuestError {
-    flatbuffers::size_prefixed_root_unchecked::<GuestError>(buf)
+    unsafe { flatbuffers::size_prefixed_root_unchecked::<GuestError>(buf) }
 }
 #[inline]
 pub fn finish_guest_error_buffer<'a, 'b, A: flatbuffers::Allocator + 'a>(
diff --git a/src/hyperlight_common/src/flatbuffers/hyperlight/generated/guest_log_data_generated.rs b/src/hyperlight_common/src/flatbuffers/hyperlight/generated/guest_log_data_generated.rs
@@ -22,7 +22,7 @@ impl<'a> flatbuffers::Follow<'a> for GuestLogData<'a> {
     #[inline]
     unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table::new(buf, loc),
+            _tab: unsafe { flatbuffers::Table::new(buf, loc) },
         }
     }
 }
@@ -288,14 +288,14 @@ pub fn size_prefixed_root_as_guest_log_data_with_opts<'b, 'o>(
 /// # Safety
 /// Callers must trust the given bytes do indeed contain a valid `GuestLogData`.
 pub unsafe fn root_as_guest_log_data_unchecked(buf: &[u8]) -> GuestLogData {
-    flatbuffers::root_unchecked::<GuestLogData>(buf)
+    unsafe { flatbuffers::root_unchecked::<GuestLogData>(buf) }
 }
 #[inline]
 /// Assumes, without verification, that a buffer of bytes contains a size prefixed GuestLogData and returns it.
 /// # Safety
 /// Callers must trust the given bytes do indeed contain a valid size prefixed `GuestLogData`.
 pub unsafe fn size_prefixed_root_as_guest_log_data_unchecked(buf: &[u8]) -> GuestLogData {
-    flatbuffers::size_prefixed_root_unchecked::<GuestLogData>(buf)
+    unsafe { flatbuffers::size_prefixed_root_unchecked::<GuestLogData>(buf) }
 }
 #[inline]
 pub fn finish_guest_log_data_buffer<'a, 'b, A: flatbuffers::Allocator + 'a>(
diff --git a/src/hyperlight_common/src/flatbuffers/hyperlight/generated/hlbool_generated.rs b/src/hyperlight_common/src/flatbuffers/hyperlight/generated/hlbool_generated.rs
@@ -22,7 +22,7 @@ impl<'a> flatbuffers::Follow<'a> for hlbool<'a> {
     #[inline]
     unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table::new(buf, loc),
+            _tab: unsafe { flatbuffers::Table::new(buf, loc) },
         }
     }
 }
diff --git a/src/hyperlight_common/src/flatbuffers/hyperlight/generated/hldouble_generated.rs b/src/hyperlight_common/src/flatbuffers/hyperlight/generated/hldouble_generated.rs
@@ -22,7 +22,7 @@ impl<'a> flatbuffers::Follow<'a> for hldouble<'a> {
     #[inline]
     unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table::new(buf, loc),
+            _tab: unsafe { flatbuffers::Table::new(buf, loc) },
         }
     }
 }
diff --git a/src/hyperlight_common/src/flatbuffers/hyperlight/generated/hlfloat_generated.rs b/src/hyperlight_common/src/flatbuffers/hyperlight/generated/hlfloat_generated.rs
@@ -22,7 +22,7 @@ impl<'a> flatbuffers::Follow<'a> for hlfloat<'a> {
     #[inline]
     unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table::new(buf, loc),
+            _tab: unsafe { flatbuffers::Table::new(buf, loc) },
         }
     }
 }
diff --git a/src/hyperlight_common/src/flatbuffers/hyperlight/generated/hlint_generated.rs b/src/hyperlight_common/src/flatbuffers/hyperlight/generated/hlint_generated.rs
@@ -22,7 +22,7 @@ impl<'a> flatbuffers::Follow<'a> for hlint<'a> {
     #[inline]
     unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table::new(buf, loc),
+            _tab: unsafe { flatbuffers::Table::new(buf, loc) },
         }
     }
 }
diff --git a/src/hyperlight_common/src/flatbuffers/hyperlight/generated/hllong_generated.rs b/src/hyperlight_common/src/flatbuffers/hyperlight/generated/hllong_generated.rs
@@ -22,7 +22,7 @@ impl<'a> flatbuffers::Follow<'a> for hllong<'a> {
     #[inline]
     unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table::new(buf, loc),
+            _tab: unsafe { flatbuffers::Table::new(buf, loc) },
         }
     }
 }
diff --git a/src/hyperlight_common/src/flatbuffers/hyperlight/generated/hlsizeprefixedbuffer_generated.rs b/src/hyperlight_common/src/flatbuffers/hyperlight/generated/hlsizeprefixedbuffer_generated.rs
@@ -22,7 +22,7 @@ impl<'a> flatbuffers::Follow<'a> for hlsizeprefixedbuffer<'a> {
     #[inline]
     unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table::new(buf, loc),
+            _tab: unsafe { flatbuffers::Table::new(buf, loc) },
         }
     }
 }
diff --git a/src/hyperlight_common/src/flatbuffers/hyperlight/generated/hlstring_generated.rs b/src/hyperlight_common/src/flatbuffers/hyperlight/generated/hlstring_generated.rs
@@ -22,7 +22,7 @@ impl<'a> flatbuffers::Follow<'a> for hlstring<'a> {
     #[inline]
     unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table::new(buf, loc),
+            _tab: unsafe { flatbuffers::Table::new(buf, loc) },
         }
     }
 }
diff --git a/src/hyperlight_common/src/flatbuffers/hyperlight/generated/hluint_generated.rs b/src/hyperlight_common/src/flatbuffers/hyperlight/generated/hluint_generated.rs
@@ -22,7 +22,7 @@ impl<'a> flatbuffers::Follow<'a> for hluint<'a> {
     #[inline]
     unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table::new(buf, loc),
+            _tab: unsafe { flatbuffers::Table::new(buf, loc) },
         }
     }
 }
diff --git a/src/hyperlight_common/src/flatbuffers/hyperlight/generated/hlulong_generated.rs b/src/hyperlight_common/src/flatbuffers/hyperlight/generated/hlulong_generated.rs
@@ -22,7 +22,7 @@ impl<'a> flatbuffers::Follow<'a> for hlulong<'a> {
     #[inline]
     unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table::new(buf, loc),
+            _tab: unsafe { flatbuffers::Table::new(buf, loc) },
         }
     }
 }
diff --git a/src/hyperlight_common/src/flatbuffers/hyperlight/generated/hlvecbytes_generated.rs b/src/hyperlight_common/src/flatbuffers/hyperlight/generated/hlvecbytes_generated.rs
@@ -22,7 +22,7 @@ impl<'a> flatbuffers::Follow<'a> for hlvecbytes<'a> {
     #[inline]
     unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table::new(buf, loc),
+            _tab: unsafe { flatbuffers::Table::new(buf, loc) },
         }
     }
 }
diff --git a/src/hyperlight_common/src/flatbuffers/hyperlight/generated/hlvoid_generated.rs b/src/hyperlight_common/src/flatbuffers/hyperlight/generated/hlvoid_generated.rs
@@ -22,7 +22,7 @@ impl<'a> flatbuffers::Follow<'a> for hlvoid<'a> {
     #[inline]
     unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table::new(buf, loc),
+            _tab: unsafe { flatbuffers::Table::new(buf, loc) },
         }
     }
 }
diff --git a/src/hyperlight_common/src/flatbuffers/hyperlight/generated/host_function_definition_generated.rs b/src/hyperlight_common/src/flatbuffers/hyperlight/generated/host_function_definition_generated.rs
@@ -22,7 +22,7 @@ impl<'a> flatbuffers::Follow<'a> for HostFunctionDefinition<'a> {
     #[inline]
     unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table::new(buf, loc),
+            _tab: unsafe { flatbuffers::Table::new(buf, loc) },
         }
     }
 }
@@ -202,3 +202,88 @@ impl core::fmt::Debug for HostFunctionDefinition<'_> {
         ds.finish()
     }
 }
+#[inline]
+/// Verifies that a buffer of bytes contains a `HostFunctionDefinition`
+/// and returns it.
+/// Note that verification is still experimental and may not
+/// catch every error, or be maximally performant. For the
+/// previous, unchecked, behavior use
+/// `root_as_host_function_definition_unchecked`.
+pub fn root_as_host_function_definition(
+    buf: &[u8],
+) -> Result<HostFunctionDefinition, flatbuffers::InvalidFlatbuffer> {
+    flatbuffers::root::<HostFunctionDefinition>(buf)
+}
+#[inline]
+/// Verifies that a buffer of bytes contains a size prefixed
+/// `HostFunctionDefinition` and returns it.
+/// Note that verification is still experimental and may not
+/// catch every error, or be maximally performant. For the
+/// previous, unchecked, behavior use
+/// `size_prefixed_root_as_host_function_definition_unchecked`.
+pub fn size_prefixed_root_as_host_function_definition(
+    buf: &[u8],
+) -> Result<HostFunctionDefinition, flatbuffers::InvalidFlatbuffer> {
+    flatbuffers::size_prefixed_root::<HostFunctionDefinition>(buf)
+}
+#[inline]
+/// Verifies, with the given options, that a buffer of bytes
+/// contains a `HostFunctionDefinition` and returns it.
+/// Note that verification is still experimental and may not
+/// catch every error, or be maximally performant. For the
+/// previous, unchecked, behavior use
+/// `root_as_host_function_definition_unchecked`.
+pub fn root_as_host_function_definition_with_opts<'b, 'o>(
+    opts: &'o flatbuffers::VerifierOptions,
+    buf: &'b [u8],
+) -> Result<HostFunctionDefinition<'b>, flatbuffers::InvalidFlatbuffer> {
+    flatbuffers::root_with_opts::<HostFunctionDefinition<'b>>(opts, buf)
+}
+#[inline]
+/// Verifies, with the given verifier options, that a buffer of
+/// bytes contains a size prefixed `HostFunctionDefinition` and returns
+/// it. Note that verification is still experimental and may not
+/// catch every error, or be maximally performant. For the
+/// previous, unchecked, behavior use
+/// `root_as_host_function_definition_unchecked`.
+pub fn size_prefixed_root_as_host_function_definition_with_opts<'b, 'o>(
+    opts: &'o flatbuffers::VerifierOptions,
+    buf: &'b [u8],
+) -> Result<HostFunctionDefinition<'b>, flatbuffers::InvalidFlatbuffer> {
+    flatbuffers::size_prefixed_root_with_opts::<HostFunctionDefinition<'b>>(opts, buf)
+}
+#[inline]
+/// Assumes, without verification, that a buffer of bytes contains a HostFunctionDefinition and returns it.
+/// # Safety
+/// Callers must trust the given bytes do indeed contain a valid `HostFunctionDefinition`.
+pub unsafe fn root_as_host_function_definition_unchecked(buf: &[u8]) -> HostFunctionDefinition {
+    unsafe { flatbuffers::root_unchecked::<HostFunctionDefinition>(buf) }
+}
+#[inline]
+/// Assumes, without verification, that a buffer of bytes contains a size prefixed HostFunctionDefinition and returns it.
+/// # Safety
+/// Callers must trust the given bytes do indeed contain a valid size prefixed `HostFunctionDefinition`.
+pub unsafe fn size_prefixed_root_as_host_function_definition_unchecked(
+    buf: &[u8],
+) -> HostFunctionDefinition {
+    unsafe { flatbuffers::size_prefixed_root_unchecked::<HostFunctionDefinition>(buf) }
+}
+#[inline]
+pub fn finish_host_function_definition_buffer<'a, 'b, A: flatbuffers::Allocator + 'a>(
+    fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+    root: flatbuffers::WIPOffset<HostFunctionDefinition<'a>>,
+) {
+    fbb.finish(root, None);
+}
+
+#[inline]
+pub fn finish_size_prefixed_host_function_definition_buffer<
+    'a,
+    'b,
+    A: flatbuffers::Allocator + 'a,
+>(
+    fbb: &'b mut flatbuffers::FlatBufferBuilder<'a, A>,
+    root: flatbuffers::WIPOffset<HostFunctionDefinition<'a>>,
+) {
+    fbb.finish_size_prefixed(root, None);
+}
diff --git a/src/hyperlight_common/src/flatbuffers/hyperlight/generated/host_function_details_generated.rs b/src/hyperlight_common/src/flatbuffers/hyperlight/generated/host_function_details_generated.rs
@@ -22,7 +22,7 @@ impl<'a> flatbuffers::Follow<'a> for HostFunctionDetails<'a> {
     #[inline]
     unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table::new(buf, loc),
+            _tab: unsafe { flatbuffers::Table::new(buf, loc) },
         }
     }
 }
@@ -187,7 +187,7 @@ pub fn size_prefixed_root_as_host_function_details_with_opts<'b, 'o>(
 /// # Safety
 /// Callers must trust the given bytes do indeed contain a valid `HostFunctionDetails`.
 pub unsafe fn root_as_host_function_details_unchecked(buf: &[u8]) -> HostFunctionDetails {
-    flatbuffers::root_unchecked::<HostFunctionDetails>(buf)
+    unsafe { flatbuffers::root_unchecked::<HostFunctionDetails>(buf) }
 }
 #[inline]
 /// Assumes, without verification, that a buffer of bytes contains a size prefixed HostFunctionDetails and returns it.
@@ -196,7 +196,7 @@ pub unsafe fn root_as_host_function_details_unchecked(buf: &[u8]) -> HostFunctio
 pub unsafe fn size_prefixed_root_as_host_function_details_unchecked(
     buf: &[u8],
 ) -> HostFunctionDetails {
-    flatbuffers::size_prefixed_root_unchecked::<HostFunctionDetails>(buf)
+    unsafe { flatbuffers::size_prefixed_root_unchecked::<HostFunctionDetails>(buf) }
 }
 #[inline]
 pub fn finish_host_function_details_buffer<'a, 'b, A: flatbuffers::Allocator + 'a>(
diff --git a/src/hyperlight_common/src/flatbuffers/hyperlight/generated/log_level_generated.rs b/src/hyperlight_common/src/flatbuffers/hyperlight/generated/log_level_generated.rs
@@ -86,7 +86,7 @@ impl<'a> flatbuffers::Follow<'a> for LogLevel {
     type Inner = Self;
     #[inline]
     unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-        let b = flatbuffers::read_scalar_at::<u8>(buf, loc);
+        let b = unsafe { flatbuffers::read_scalar_at::<u8>(buf, loc) };
         Self(b)
     }
 }
@@ -95,7 +95,9 @@ impl flatbuffers::Push for LogLevel {
     type Output = LogLevel;
     #[inline]
     unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
-        flatbuffers::emplace_scalar::<u8>(dst, self.0);
+        unsafe {
+            flatbuffers::emplace_scalar::<u8>(dst, self.0);
+        }
     }
 }
 
diff --git a/src/hyperlight_common/src/flatbuffers/hyperlight/generated/parameter_generated.rs b/src/hyperlight_common/src/flatbuffers/hyperlight/generated/parameter_generated.rs
@@ -22,7 +22,7 @@ impl<'a> flatbuffers::Follow<'a> for Parameter<'a> {
     #[inline]
     unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table::new(buf, loc),
+            _tab: unsafe { flatbuffers::Table::new(buf, loc) },
         }
     }
 }
diff --git a/src/hyperlight_common/src/flatbuffers/hyperlight/generated/parameter_type_generated.rs b/src/hyperlight_common/src/flatbuffers/hyperlight/generated/parameter_type_generated.rs
diff --git a/src/hyperlight_common/src/flatbuffers/hyperlight/generated/parameter_value_generated.rs b/src/hyperlight_common/src/flatbuffers/hyperlight/generated/parameter_value_generated.rs
diff --git a/src/hyperlight_common/src/flatbuffers/hyperlight/generated/return_type_generated.rs b/src/hyperlight_common/src/flatbuffers/hyperlight/generated/return_type_generated.rs
diff --git a/src/hyperlight_common/src/flatbuffers/hyperlight/generated/return_value_generated.rs b/src/hyperlight_common/src/flatbuffers/hyperlight/generated/return_value_generated.rs

Original file line number	Diff line number	Diff line change
`@@ -124,7 +124,7 @@ impl<'a> flatbuffers::Follow<'a> for ErrorCode {`
`124`	`124`	`type Inner = Self;`
`125`	`125`	`#[inline]`
`126`	`126`	`unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {`
`127`		`- let b = flatbuffers::read_scalar_at::<u64>(buf, loc);`
	`127`	`+ let b = unsafe { flatbuffers::read_scalar_at::<u64>(buf, loc) };`
`128`	`128`	`Self(b)`
`129`	`129`	`}`
`130`	`130`	`}`
`@@ -133,7 +133,9 @@ impl flatbuffers::Push for ErrorCode {`
`133`	`133`	`type Output = ErrorCode;`
`134`	`134`	`#[inline]`
`135`	`135`	`unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {`
`136`		`- flatbuffers::emplace_scalar::<u64>(dst, self.0);`
	`136`	`+ unsafe {`
	`137`	`+ flatbuffers::emplace_scalar::<u64>(dst, self.0);`
	`138`	`+ }`
`137`	`139`	`}`
`138`	`140`	`}`
`139`	`141`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,7 @@ impl<'a> flatbuffers::Follow<'a> for FunctionCall<'a> {`
`22`	`22`	`#[inline]`
`23`	`23`	`unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {`
`24`	`24`	`Self {`
`25`		`- _tab: flatbuffers::Table::new(buf, loc),`
	`25`	`+ _tab: unsafe { flatbuffers::Table::new(buf, loc) },`
`26`	`26`	`}`
`27`	`27`	`}`
`28`	`28`	`}`
`@@ -290,14 +290,14 @@ pub fn size_prefixed_root_as_function_call_with_opts<'b, 'o>(`
`290`	`290`	`/// # Safety`
`291`	`291`	/// Callers must trust the given bytes do indeed contain a valid `FunctionCall`.
`292`	`292`	`pub unsafe fn root_as_function_call_unchecked(buf: &[u8]) -> FunctionCall {`
`293`		`- flatbuffers::root_unchecked::<FunctionCall>(buf)`
	`293`	`+ unsafe { flatbuffers::root_unchecked::<FunctionCall>(buf) }`
`294`	`294`	`}`
`295`	`295`	`#[inline]`
`296`	`296`	`/// Assumes, without verification, that a buffer of bytes contains a size prefixed FunctionCall and returns it.`
`297`	`297`	`/// # Safety`
`298`	`298`	/// Callers must trust the given bytes do indeed contain a valid size prefixed `FunctionCall`.
`299`	`299`	`pub unsafe fn size_prefixed_root_as_function_call_unchecked(buf: &[u8]) -> FunctionCall {`
`300`		`- flatbuffers::size_prefixed_root_unchecked::<FunctionCall>(buf)`
	`300`	`+ unsafe { flatbuffers::size_prefixed_root_unchecked::<FunctionCall>(buf) }`
`301`	`301`	`}`
`302`	`302`	`#[inline]`
`303`	`303`	`pub fn finish_function_call_buffer<'a, 'b, A: flatbuffers::Allocator + 'a>(`
Original file line number	Diff line number	Diff line change
`@@ -66,7 +66,7 @@ impl<'a> flatbuffers::Follow<'a> for FunctionCallType {`
`66`	`66`	`type Inner = Self;`
`67`	`67`	`#[inline]`
`68`	`68`	`unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {`
`69`		`- let b = flatbuffers::read_scalar_at::<u8>(buf, loc);`
	`69`	`+ let b = unsafe { flatbuffers::read_scalar_at::<u8>(buf, loc) };`
`70`	`70`	`Self(b)`
`71`	`71`	`}`
`72`	`72`	`}`
`@@ -75,7 +75,9 @@ impl flatbuffers::Push for FunctionCallType {`
`75`	`75`	`type Output = FunctionCallType;`
`76`	`76`	`#[inline]`
`77`	`77`	`unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {`
`78`		`- flatbuffers::emplace_scalar::<u8>(dst, self.0);`
	`78`	`+ unsafe {`
	`79`	`+ flatbuffers::emplace_scalar::<u8>(dst, self.0);`
	`80`	`+ }`
`79`	`81`	`}`
`80`	`82`	`}`
`81`	`83`