feat(vm): enforce typed CALL RET and native entry boundaries for PLN-0176 step 26

This commit is contained in:
2026-10-07 20:32:09 +01:00
parent a9d91be39e
commit ba603ce64a
9 changed files with 477 additions and 24 deletions
@@ -199,8 +199,7 @@ fn late_work_refusal_releases_all_new_owners() {
let bytes = fixture(&[1, 0], 0, &[K::String("abc".into())], None, &[]);
let mut full = budget();
ValidatedProgramImage::load(&bytes, &mut full, caps::NONE).unwrap();
let mut b =
LoadBudget::new(LoadLimits { work: full.used(Q::Work) - 1, ..Default::default() });
let mut b = LoadBudget::new(LoadLimits { work: full.used(Q::Work) - 1, ..Default::default() });
b.charge(Q::TemporaryBytes, 7).unwrap();
b.charge(Q::RegistryBytes, 3).unwrap();
let VmInitError::RegistryLoadFailed(error) =
@@ -3,6 +3,9 @@ mod gc;
mod loader;
mod runtime;
mod stack;
mod typed;
#[cfg(test)]
mod typed_tests;
use crate::call_frame::CallFrame;
use crate::heap::{CoroutineState, Heap};
@@ -81,6 +84,7 @@ pub struct VirtualMachine {
globals: BudgetVec<Value>,
/// The loaded executable (Bytecode + Constant Pool), that is the ROM translated.
program: ProgramImage,
validated_image: Option<std::sync::Arc<crate::ValidatedProgramImage>>,
/// Heap Memory: Dynamic allocation pool.
heap: Heap,
/// Total virtual cycles consumed since the VM started.
@@ -197,6 +201,7 @@ impl VirtualMachine {
None,
std::collections::HashMap::new(),
),
validated_image: None,
heap: Heap::with_budget(&budget),
cycles: 0,
halted: false,
@@ -213,6 +218,20 @@ impl VirtualMachine {
}
}
/// Sessions share validated code, constants, debug and Registry ownership.
/// Entry setup validates supplied groups before publishing an active frame.
pub fn from_image(
image: std::sync::Arc<crate::ValidatedProgramImage>,
limits: RuntimeLimits,
) -> Self {
let mut vm = Self::with_runtime_limits(Vec::new(), Vec::new(), limits);
vm.program = image.execution.clone();
vm.capabilities = image.capabilities();
vm.validated_image = Some(image);
vm.halted = true;
vm
}
/// Executes a single instruction at the current Program Counter (PC).
///
/// This follows the classic CPU cycle:
@@ -1056,7 +1075,7 @@ impl VirtualMachine {
)
})?;
if self.operand_stack.len() < callee.param_slots as usize {
if self.temporary_slots() < callee.param_slots as usize {
return Err(self.trap(
TRAP_STACK_UNDERFLOW,
opcode as u16,
@@ -1072,14 +1091,21 @@ impl VirtualMachine {
let stack_base = self.operand_stack.len() - callee.param_slots as usize;
self.check_signature_group(func_id, false, &self.operand_stack[stack_base..])
.map_err(|(_, error)| self.value_trap(error, opcode, start_pc as u32))?;
let callee_local_slots = callee.local_slots;
let callee_offset = callee.code_offset;
self.operand_stack
.reserve(callee_local_slots as usize)
let stack_growth = self
.operand_stack
.prepare_growth(callee_local_slots as usize)
.map_err(|e| self.resource_trap(e, opcode, start_pc as u32))?;
self.call_stack
.reserve(1)
let frame_growth = self
.call_stack
.prepare_growth(1)
.map_err(|e| self.resource_trap(e, opcode, start_pc as u32))?;
self.operand_stack.commit_growth(stack_growth);
self.call_stack.commit_growth(frame_growth);
// Allocate and zero-init local_slots
for _ in 0..callee_local_slots {
self.operand_stack
@@ -1093,7 +1119,7 @@ impl VirtualMachine {
self.pc = callee_offset as usize;
}
OpCode::Ret => {
let frame = self.call_stack.pop().ok_or_else(|| {
let frame = self.call_stack.last().cloned().ok_or_else(|| {
self.trap(
TRAP_STACK_UNDERFLOW,
opcode as u16,
@@ -1117,6 +1143,13 @@ impl VirtualMachine {
), start_pc as u32));
}
self.check_signature_group(
frame.func_idx,
true,
&self.operand_stack[current_height - return_slots..],
)
.map_err(|(_, error)| self.value_trap(error, opcode, start_pc as u32))?;
// Copy return values (preserving order: pop return_slots values, then reverse to push back)
let mut return_vals = BudgetVec::new(&self.budget, RuntimeResource::TemporaryBytes);
return_vals
@@ -1129,6 +1162,7 @@ impl VirtualMachine {
}
return_vals.reverse();
self.call_stack.pop();
self.operand_stack.truncate(frame.stack_base);
for val in return_vals.drain(..) {
self.push_trap(val, opcode, start_pc as u32)?;
@@ -4897,6 +4931,7 @@ mod tests {
let limits = RuntimeLimits::default().lowered(RuntimeResource::CallDepth, 0).unwrap();
let mut vm = VirtualMachine::with_runtime_limits(assemble("HALT").unwrap(), vec![], limits);
let error = vm.prepare_boot_call().unwrap_err();
let VmInitError::RuntimeResourceLimit(error) = error else { panic!("{error:?}") };
assert_eq!(
(error.resource, error.requested, error.limit),
(RuntimeResource::CallDepth, 1, 0)
@@ -5056,7 +5091,9 @@ mod tests {
fn guest_quota_failure_does_not_publish_an_entry_context() {
let limits = RuntimeLimits::default().lowered(RuntimeResource::GuestBytes, 0).unwrap();
let mut vm = VirtualMachine::with_runtime_limits(assemble("HALT").unwrap(), vec![], limits);
assert_eq!(vm.prepare_boot_call().unwrap_err().resource, RuntimeResource::GuestBytes);
assert!(
matches!(vm.prepare_boot_call().unwrap_err(), VmInitError::RuntimeResourceLimit(error) if error.resource == RuntimeResource::GuestBytes)
);
assert!(vm.current_coro.is_none());
assert!(vm.call_stack.is_empty());
assert_eq!(vm.heap.len(), 0);
@@ -70,6 +70,7 @@ fn patch_module_hostcalls(
impl VirtualMachine {
pub fn initialize(&mut self, program_bytes: Vec<u8>) -> Result<(), VmInitError> {
self.program = ProgramImage::default();
self.validated_image = None;
self.pc = 0;
self.operand_stack.clear();
self.call_stack.clear();
@@ -128,26 +129,61 @@ impl VirtualMachine {
self.capabilities = caps;
}
pub fn prepare_boot_call(&mut self) -> Result<(), ResourceFailure> {
self.prepare_call_by_index(0)
pub fn prepare_boot_call(&mut self) -> Result<(), VmInitError> {
self.prepare_call_by_index(0, &[])
}
pub fn prepare_call(&mut self, entrypoint: &str) -> Result<(), ResourceFailure> {
pub fn prepare_call(&mut self, entrypoint: &str) -> Result<(), VmInitError> {
self.prepare_call_with_args(entrypoint, &[])
}
pub fn prepare_call_with_args(
&mut self,
entrypoint: &str,
arguments: &[Value],
) -> Result<(), VmInitError> {
let func_idx = if let Ok(idx) = entrypoint.parse::<usize>() {
idx
} else if let Some(image) = &self.validated_image {
image
.exports()
.iter()
.rfind(|export| export.symbol == entrypoint)
.map(|export| export.func_idx as usize)
.ok_or(VmInitError::EntrypointNotFound)?
} else {
self.program.exports.get(entrypoint).map(|&idx| idx as usize).ok_or(()).unwrap_or(0)
};
self.prepare_call_by_index(func_idx)
self.prepare_call_by_index(func_idx, arguments)
}
fn prepare_call_by_index(&mut self, func_idx: usize) -> Result<(), ResourceFailure> {
fn prepare_call_by_index(
&mut self,
func_idx: usize,
arguments: &[Value],
) -> Result<(), VmInitError> {
if self.validated_image.is_some() {
self.check_signature_group(func_idx, false, arguments).map_err(|(slot, error)| {
if self.program.functions.get(func_idx).is_none() {
VmInitError::EntrypointNotFound
} else {
VmInitError::EntrypointArgumentsInvalid {
function: func_idx as u32,
slot: slot as u32,
trap_code: Self::value_error_code(error),
}
}
})?;
}
self.budget.check(RuntimeResource::CallDepth, 1)?;
let callee = self.program.functions.get(func_idx).cloned().unwrap_or_default();
let total_slots = callee.param_slots as usize + callee.local_slots as usize;
self.operand_stack.reserve(total_slots.saturating_sub(self.operand_stack.len()))?;
self.call_stack.reserve(1usize.saturating_sub(self.call_stack.len()))?;
let stack_growth = self
.operand_stack
.prepare_growth(total_slots.saturating_sub(self.operand_stack.len()))?;
let frame_growth =
self.call_stack.prepare_growth(1usize.saturating_sub(self.call_stack.len()))?;
let main_href = self.heap.allocate_coroutine(
callee.code_offset as usize,
CoroutineState::Running,
@@ -155,6 +191,8 @@ impl VirtualMachine {
BudgetVec::new(&self.budget, RuntimeResource::AuxiliaryBytes),
BudgetVec::new(&self.budget, RuntimeResource::AuxiliaryBytes),
)?;
self.operand_stack.commit_growth(stack_growth);
self.call_stack.commit_growth(frame_growth);
self.pc = callee.code_offset as usize;
self.halted = false;
@@ -162,8 +200,13 @@ impl VirtualMachine {
self.call_stack.clear();
if let Some(func) = self.program.functions.get(func_idx) {
let total_slots = func.param_slots as u32 + func.local_slots as u32;
for _ in 0..total_slots {
let typed = self.validated_image.is_some();
if typed {
self.operand_stack.extend_from_slice(arguments)?;
}
let null_slots =
func.local_slots as usize + if typed { 0 } else { func.param_slots as usize };
for _ in 0..null_slots {
self.operand_stack.push(Value::Null)?;
}
}
@@ -45,6 +45,9 @@ impl VirtualMachine {
}
pub fn pop(&mut self) -> Result<Value, String> {
if self.temporary_slots() == 0 {
return Err("Stack underflow".into());
}
self.operand_stack.pop().ok_or("Stack underflow".into())
}
@@ -62,6 +65,9 @@ impl VirtualMachine {
}
pub fn peek(&self) -> Result<&Value, String> {
if self.temporary_slots() == 0 {
return Err("Stack underflow".into());
}
self.operand_stack.last().ok_or("Stack underflow".into())
}
@@ -0,0 +1,79 @@
use super::*;
use crate::value_contract::{self, ValueError};
impl VirtualMachine {
pub(super) fn temporary_slots(&self) -> usize {
if self.validated_image.is_none() {
return self.operand_stack.len();
}
let floor = self
.call_stack
.last()
.map(|frame| {
let function = &self.program.functions[frame.func_idx];
frame.stack_base + function.param_slots as usize + function.local_slots as usize
})
.unwrap_or(0);
self.operand_stack.len().saturating_sub(floor)
}
pub(super) fn value_error_code(error: ValueError) -> u32 {
match error {
ValueError::Type => TRAP_TYPE,
ValueError::InvalidHandle => TRAP_INVALID_HANDLE,
ValueError::NullReference => TRAP_NULL_REFERENCE,
ValueError::Bounds => TRAP_OOB,
ValueError::Resource(_) => TRAP_RESOURCE_LIMIT,
}
}
pub(super) fn value_trap(
&self,
error: ValueError,
opcode: OpCode,
pc: u32,
) -> LogicalFrameEndingReason {
if let ValueError::Resource(resource) = error {
return self.resource_trap(resource, opcode, pc);
}
self.trap(
Self::value_error_code(error),
opcode as u16,
format!("Invalid typed value: {error:?}"),
pc,
)
}
pub(super) fn check_signature_group(
&self,
function: usize,
results: bool,
values: &[Value],
) -> Result<(), (usize, ValueError)> {
let Some(image) = &self.validated_image else {
return Ok(());
};
let declaration =
image.registry().declarations().functions.get(function).ok_or((0, ValueError::Type))?;
let signature = &declaration.signature;
let count = if results { signature.results.len() } else { signature.parameters.len() };
let mut slot = 0;
for index in 0..count {
let ty = if results {
signature.results[index]
} else {
signature.parameters[index].type_id
};
let width = image.registry().type_layout(ty).unwrap().storage.slots as usize;
let end = slot + width;
let values = values.get(slot..end).ok_or((slot, ValueError::Type))?;
value_contract::validate(image.registry(), &self.heap, ty, values)
.map_err(|e| (slot, e))?;
slot = end;
}
if values.len() != slot {
return Err((slot, ValueError::Type));
}
Ok(())
}
}
@@ -0,0 +1,284 @@
use super::*;
use crate::{HostReturn, ValidatedProgramImage};
use prometeu_bytecode::load_limits::LoadBudget;
use prometeu_bytecode::registry::{
BuiltinId as B, FunctionDecl, ImplementationDecl, NamedType, Registry, RegistryDeclarations,
Signature, TypeDecl, TypeId, TypeKind,
};
use prometeu_bytecode::registry_codec::PbxModule;
use std::sync::Arc;
struct Native;
impl NativeInterface for Native {
fn syscall(
&mut self,
_id: u32,
_args: &[Value],
_ret: &mut HostReturn,
_ctx: &mut HostContext,
) -> Result<(), VmFault> {
Ok(())
}
}
fn op(code: &mut Vec<u8>, opcode: OpCode) {
code.extend_from_slice(&(opcode as u16).to_le_bytes());
}
fn arg(code: &mut Vec<u8>, opcode: OpCode, argument: u32) {
op(code, opcode);
code.extend_from_slice(&argument.to_le_bytes());
}
fn function(
offset: usize,
len: usize,
parameters: &[u32],
results: &[u32],
locals: u32,
max: u32,
) -> FunctionDecl {
FunctionDecl {
name: Some(format!("f{offset}")),
code_offset: offset as u32,
code_len: len as u32,
local_slots: locals,
max_stack_slots: max,
signature: Signature {
parameters: parameters
.iter()
.map(|&id| NamedType { type_id: TypeId(id), name: None })
.collect(),
results: results.iter().copied().map(TypeId).collect(),
},
}
}
fn image(code: &[u8], functions: Vec<FunctionDecl>) -> Arc<ValidatedProgramImage> {
let kind = |kind| TypeDecl { name: None, kind };
let mut types: Vec<_> =
[B::INT32, B::INT64, B::FLOAT, B::BOOL, B::STRING, B::VEC2, B::COLOR, B::PIXEL, B::DYNAMIC]
.into_iter()
.map(|id| kind(TypeKind::Builtin(id)))
.collect();
types.extend([
kind(TypeKind::Struct(vec![])),
kind(TypeKind::Struct(vec![])),
kind(TypeKind::Trait(vec![])),
kind(TypeKind::Trait(vec![])),
kind(TypeKind::Array(TypeId(0))),
kind(TypeKind::Array(TypeId(3))),
]);
let registry = Registry::resolve(
RegistryDeclarations {
types,
functions,
implementations: vec![
ImplementationDecl { owner: TypeId(9), trait_id: TypeId(11), methods: vec![] },
ImplementationDecl { owner: TypeId(9), trait_id: TypeId(12), methods: vec![] },
],
},
code.len(),
&mut LoadBudget::new(Default::default()),
)
.unwrap();
let bytes = PbxModule {
registry: &registry,
code,
constants: &[],
debug: None,
exports: &[],
syscalls: &[],
}
.serialize(&mut LoadBudget::new(Default::default()))
.unwrap();
ValidatedProgramImage::load(&bytes, &mut LoadBudget::new(Default::default()), NONE).unwrap()
}
fn run(vm: &mut VirtualMachine) -> LogicalFrameEndingReason {
vm.run_budget(1000, &mut Native, &mut HostContext::new(None)).unwrap().reason
}
#[test]
fn typed_sessions_share_image_but_have_independent_execution_and_heap() {
let image = image(&[1, 0], vec![function(0, 2, &[], &[], 0, 0)]);
let mut first = VirtualMachine::from_image(image.clone(), RuntimeLimits::default());
let mut second = VirtualMachine::from_image(image.clone(), RuntimeLimits::default());
assert!(Arc::ptr_eq(&first.program.rom, &second.program.rom));
assert!(Arc::ptr_eq(&first.program.constant_pool, &second.program.constant_pool));
first.prepare_boot_call().unwrap();
second.prepare_boot_call().unwrap();
assert_eq!(run(&mut first), LogicalFrameEndingReason::Halted);
assert!(!second.halted);
assert_eq!(second.pc, 0);
drop(first);
drop(image);
assert_eq!(run(&mut second), LogicalFrameEndingReason::Halted);
}
#[test]
fn entry_rejects_bad_complete_groups_before_frame_or_heap_publication() {
let image = image(&[1, 0], vec![function(0, 2, &[5, 8], &[], 2, 0)]);
let mut vm = VirtualMachine::from_image(image, RuntimeLimits::default());
for args in [
vec![],
vec![Value::Float(1.), Value::Int32(2), Value::Null, Value::Null],
vec![Value::Float(1.), Value::Float(2.), Value::Int64(0), Value::Boolean(true)],
] {
assert!(matches!(
vm.prepare_call_with_args("0", &args),
Err(VmInitError::EntrypointArgumentsInvalid { trap_code: TRAP_TYPE, .. })
));
assert_eq!(vm.heap.len(), 0);
assert!(vm.call_stack.is_empty());
assert!(vm.operand_stack.is_empty());
assert_eq!(vm.budget.used(RuntimeResource::AuxiliaryBytes), 0);
}
vm.prepare_call_with_args("0", &[Value::Float(1.), Value::Float(2.), Value::Null, Value::Null])
.unwrap();
assert_eq!(&vm.operand_stack[4..], &[Value::Null, Value::Null]);
assert!(vm.pop().is_err()); // A generic pop cannot consume parameters/locals.
}
#[test]
fn unknown_at_call_is_checked_after_branch_merge_without_publishing_bad_frame() {
let mut code = vec![];
arg(&mut code, OpCode::GetLocal, 0);
let branch = code.len();
arg(&mut code, OpCode::JmpIfTrue, 0);
arg(&mut code, OpCode::PushI32, 17);
let jump = code.len();
arg(&mut code, OpCode::Jmp, 0);
let right = code.len();
op(&mut code, OpCode::PushBool);
code.push(1);
let join = code.len();
arg(&mut code, OpCode::Call, 1);
op(&mut code, OpCode::Halt);
let end = code.len();
op(&mut code, OpCode::Ret);
code[branch + 2..branch + 6].copy_from_slice(&(right as u32).to_le_bytes());
code[jump + 2..jump + 6].copy_from_slice(&(join as u32).to_le_bytes());
let image =
image(&code, vec![function(0, end, &[3], &[], 0, 1), function(end, 2, &[0], &[], 0, 0)]);
for (condition, success) in [(false, true), (true, false)] {
let mut vm = VirtualMachine::from_image(image.clone(), RuntimeLimits::default());
vm.prepare_call_with_args("0", &[Value::Boolean(condition)]).unwrap();
let result = run(&mut vm);
if success {
assert_eq!(result, LogicalFrameEndingReason::Halted);
} else {
assert!(
matches!(result,LogicalFrameEndingReason::Trap(info) if info.code==TRAP_TYPE && info.pc==join as u32 && info.opcode==OpCode::Call as u16)
);
assert_eq!(vm.call_stack.len(), 1);
assert_eq!(vm.operand_stack.last(), Some(&Value::Boolean(true)));
}
}
}
#[test]
fn ordered_multi_group_return_preserves_native_owners_and_receiver_identity() {
let mut code = vec![];
// vec2, trait, Dynamic and string occupy seven slots together.
for slot in 0..7 {
arg(&mut code, OpCode::GetLocal, slot);
}
op(&mut code, OpCode::Ret);
let image = image(&code, vec![function(0, code.len(), &[5, 11, 8, 4], &[5, 11, 8, 4], 2, 7)]);
let registry = image.registry().clone();
let mut vm = VirtualMachine::from_image(image, RuntimeLimits::default());
let receiver = vm.heap.allocate_typed_struct(registry, TypeId(9)).unwrap();
let text: Arc<str> = Arc::from("retained");
let args = [
Value::Float(1.),
Value::Float(2.),
Value::HeapRef(receiver),
Value::Int64(0),
Value::Int64(0),
Value::Int32(17),
Value::String(text.clone()),
];
vm.prepare_call_with_args("0", &args).unwrap();
assert_eq!(run(&mut vm), LogicalFrameEndingReason::EndOfRom);
assert_eq!(vm.operand_stack.as_slice(), &args);
assert!(vm.call_stack.is_empty());
let Value::String(returned) = &vm.operand_stack[6] else { panic!() };
assert!(Arc::ptr_eq(returned, &text));
}
#[test]
fn unknown_return_and_late_return_resource_failures_keep_current_frame_and_operands() {
let mut code = vec![];
arg(&mut code, OpCode::GetGlobal, 0);
op(&mut code, OpCode::Ret);
let image = image(&code, vec![function(0, code.len(), &[], &[0], 0, 1)]);
for (value, limits, expected) in [
(Value::Boolean(true), RuntimeLimits::default(), TRAP_TYPE),
(
Value::Int32(3),
RuntimeLimits::default().lowered(RuntimeResource::TemporaryBytes, 0).unwrap(),
TRAP_RESOURCE_LIMIT,
),
] {
let mut vm = VirtualMachine::from_image(image.clone(), limits);
vm.prepare_boot_call().unwrap();
vm.globals.push(value.clone()).unwrap();
let result = run(&mut vm);
assert!(
matches!(result,LogicalFrameEndingReason::Trap(info) if info.code==expected && info.pc==6)
);
assert_eq!(vm.call_stack.len(), 1);
assert_eq!(vm.operand_stack.as_slice(), &[value]);
}
}
#[test]
fn direct_call_returns_zero_or_one_result_and_initializes_generic_locals() {
for results in [&[][..], &[0][..]] {
let mut code = vec![];
arg(&mut code, OpCode::Call, 1);
op(&mut code, OpCode::Halt);
let end = code.len();
if !results.is_empty() {
arg(&mut code, OpCode::PushI32, 42);
}
op(&mut code, OpCode::Ret);
let image = image(
&code,
vec![
function(0, end, &[], &[], 0, 1),
function(end, code.len() - end, &[], results, 3, results.len() as u32),
],
);
let mut vm = VirtualMachine::from_image(image, RuntimeLimits::default());
vm.prepare_boot_call().unwrap();
vm.step(&mut Native, &mut HostContext::new(None)).unwrap();
assert_eq!(vm.call_stack.len(), 2);
assert_eq!(vm.operand_stack.as_slice(), &[Value::Null, Value::Null, Value::Null]);
assert_eq!(run(&mut vm), LogicalFrameEndingReason::Halted);
assert_eq!(vm.operand_stack.len(), results.len());
if !results.is_empty() {
assert_eq!(vm.operand_stack[0], Value::Int32(42));
}
}
}
#[test]
fn call_growth_refusal_does_not_publish_frame_or_keep_provisional_capacity() {
let mut code = vec![];
arg(&mut code, OpCode::Call, 1);
op(&mut code, OpCode::Halt);
let end = code.len();
op(&mut code, OpCode::Ret);
let image =
image(&code, vec![function(0, end, &[], &[], 0, 0), function(end, 2, &[], &[], 100, 0)]);
let mut vm = VirtualMachine::from_image(
image,
RuntimeLimits::default().lowered(RuntimeResource::AuxiliaryBytes, 2048).unwrap(),
);
vm.prepare_boot_call().unwrap();
let before = vm.budget.used(RuntimeResource::AuxiliaryBytes);
assert!(
matches!(run(&mut vm),LogicalFrameEndingReason::Trap(info) if info.code==TRAP_RESOURCE_LIMIT && info.pc==0)
);
assert_eq!(vm.call_stack.len(), 1);
assert!(vm.operand_stack.is_empty());
assert_eq!(vm.budget.used(RuntimeResource::AuxiliaryBytes), before);
assert_eq!(vm.budget.used(RuntimeResource::TemporaryBytes), 0);
}
@@ -17,9 +17,16 @@ pub enum VmInitError {
ImageLoadFailed(prometeu_bytecode::LoadError),
LoaderPatchFailed(LoaderPatchError),
EntrypointNotFound,
EntrypointArgumentsInvalid { function: u32, slot: u32, trap_code: u32 },
VerificationFailed(crate::verifier::VerifierError),
}
impl From<crate::resource_budget::ResourceFailure> for VmInitError {
fn from(value: crate::resource_budget::ResourceFailure) -> Self {
Self::RuntimeResourceLimit(value)
}
}
impl From<prometeu_bytecode::load_limits::LoadFailure> for VmInitError {
fn from(value: prometeu_bytecode::load_limits::LoadFailure) -> Self {
Self::RegistryLoadFailed(value)