feat(vm): add VM-owned PCG64 random and coverage headroom
Intrepid/Prometeu/Runtime/pipeline/pr-master This commit looks good

Implement GC-managed random generators, next/nextf intrinsics, bounded ranges and deterministic conformance coverage. Publish the runtime contract and producer guidance.

Give coverage domains at least five percentage points of measured headroom while preserving sufficient floors. Record local qualification: make ci-domains passes with 939 tests and all domain gates green.
This commit is contained in:
2026-10-09 12:51:05 +01:00
parent 9318cf7cd3
commit 3e39a90083
50 changed files with 2545 additions and 189 deletions
@@ -0,0 +1,94 @@
#![allow(dead_code)]
use prometeu_bytecode::{
assemble, load_limits::LoadBudget, registry::*, registry_codec::PbxModule,
};
use prometeu_vm::resource_budget::RuntimeLimits;
use prometeu_vm::{
HostContext, HostReturn, NativeInterface, ValidatedProgramImage, VirtualMachine, VmInitError,
};
use std::sync::Arc;
pub struct Native;
impl NativeInterface for Native {
fn syscall(
&mut self,
_: u32,
_: &[prometeu_bytecode::Value],
_: &mut HostReturn,
_: &mut HostContext,
) -> Result<(), prometeu_hal::vm_fault::VmFault> {
panic!("random must not invoke host syscalls")
}
}
pub fn sig(params: &[u32], results: &[u32]) -> Signature {
Signature {
parameters: params.iter().map(|&t| NamedType { type_id: TypeId(t), name: None }).collect(),
results: results.iter().map(|&t| TypeId(t)).collect(),
}
}
pub fn declarations() -> Vec<TypeDecl> {
let mut t: Vec<_> = [BuiltinId::INT64, BuiltinId::RANDOM, BuiltinId::FLOAT, BuiltinId::DYNAMIC]
.into_iter()
.map(|b| TypeDecl { name: None, kind: TypeKind::Builtin(b) })
.collect();
t.extend([
TypeDecl {
name: None,
kind: TypeKind::Struct(vec![NamedType { type_id: TypeId(1), name: None }]),
},
TypeDecl { name: None, kind: TypeKind::Array(TypeId(1)) },
TypeDecl { name: None, kind: TypeKind::Fn(sig(&[], &[0])) },
TypeDecl { name: None, kind: TypeKind::Struct(vec![]) },
TypeDecl { name: None, kind: TypeKind::Trait(vec![]) },
TypeDecl { name: None, kind: TypeKind::Fn(sig(&[1], &[1])) },
]);
t
}
pub type Body<'a> = (&'a str, Signature, Vec<TypeId>, u32);
pub fn bytes(bodies: &[Body<'_>]) -> Vec<u8> {
let mut code = Vec::new();
let mut functions = Vec::new();
for (text, signature, captures, locals) in bodies {
let body = assemble(text).unwrap();
functions.push(FunctionDecl {
signature: signature.clone(),
captures: captures.clone(),
local_slots: *locals,
max_stack_slots: 64,
code_offset: code.len() as u32,
code_len: body.len() as u32,
..Default::default()
});
code.extend(body);
}
let mut b = LoadBudget::new(Default::default());
let registry = Registry::resolve(
RegistryDeclarations { types: declarations(), functions, implementations: vec![] },
code.len(),
&mut b,
)
.unwrap();
PbxModule {
registry: &registry,
constants: &[],
code: &code,
debug: None,
exports: &[],
syscalls: &[],
}
.serialize(&mut b)
.unwrap()
}
pub fn image(bodies: &[Body<'_>]) -> Result<Arc<ValidatedProgramImage>, VmInitError> {
ValidatedProgramImage::load(&bytes(bodies), &mut LoadBudget::new(Default::default()), 0)
}
pub fn vm(bodies: &[Body<'_>]) -> VirtualMachine {
let mut v = VirtualMachine::from_image(image(bodies).unwrap(), RuntimeLimits::default());
v.prepare_boot_call().unwrap();
v
}
pub fn run(v: &mut VirtualMachine, budget: u64) -> prometeu_vm::BudgetReport {
v.run_budget(budget, &mut Native, &mut HostContext::new(None)).unwrap()
}
pub fn step(v: &mut VirtualMachine) {
v.step(&mut Native, &mut HostContext::new(None)).unwrap();
}