feat(pbs): add Set and reusable identity hashing

This commit is contained in:
2026-10-25 12:15:13 +00:00
parent 632ba6d0d6
commit 8105604f92
59 changed files with 4190 additions and 34 deletions
+323 -3
View File
@@ -41,6 +41,8 @@ fn main() {
for resource in [Q::GuestBytes,Q::HandleSlots,Q::AuxiliaryBytes,Q::TemporaryBytes,Q::StringBytes,Q::StringAllocations,Q::IndividualStringBytes,Q::CallDepth] {
println!("DEFAULT VM LIMIT {resource:?}={}",limits.get(resource));
}
if std::env::args().any(|arg| arg == "--set-only") { verify_pbs_set_fixtures(&root); return; }
if std::env::args().any(|arg| arg == "--identity-hashing-only") { verify_identity_hashing_fixtures(&root); return; }
if std::env::args().any(|arg| arg == "--linked-only") { verify_common_storage_fixtures(&root); verify_pbs_linked_fixtures(&root); return; }
if std::env::args().any(|arg| arg == "--list-cursor-only") { verify_common_storage_fixtures(&root); verify_pbs_list_cursor_fixtures(&root); return; }
if std::env::args().any(|arg| arg == "--generic-contracts-only") { verify_pbs_generic_contract_fixtures(&root); return; }
@@ -49,6 +51,7 @@ fn main() {
verify_pbs_math_fixtures(&root);
if std::env::args().any(|arg| arg == "--math-only") { return; }
verify_pbs_random_fixtures(&root);
verify_identity_hashing_fixtures(&root);
verify_catalog_fixtures(&root);
verify_pbs_fixtures(&root);
verify_pbs_structured_fixtures(&root);
@@ -57,6 +60,7 @@ fn main() {
verify_common_storage_fixtures(&root);
verify_pbs_list_cursor_fixtures(&root);
verify_pbs_linked_fixtures(&root);
verify_pbs_set_fixtures(&root);
verify_pbs_resource_refusals(&root);
verify_pbs_closure_frames(&root);
for name in [
@@ -497,7 +501,7 @@ fn verify_pbs_fixtures(root: &std::path::Path) {
for entry in std::fs::read_dir(root).unwrap() {
let path = entry.unwrap().path();
let name = path.file_stem().unwrap().to_str().unwrap();
if name.starts_with("pbs-random-") || name.starts_with("pbs-math-") || name.starts_with("pbs-structured-") || name.starts_with("pbs-generic-contract-") || name.starts_with("pbs-generic-struct-") || name.starts_with("pbs-list-") || name.starts_with("pbs-linked-") || !name.starts_with("pbs-") || path.extension().and_then(|v| v.to_str()) != Some("pbx") { continue; }
if name.starts_with("pbs-random-") || name.starts_with("pbs-math-") || name.starts_with("pbs-structured-") || name.starts_with("pbs-generic-contract-") || name.starts_with("pbs-generic-struct-") || name.starts_with("pbs-list-") || name.starts_with("pbs-linked-") || name.starts_with("pbs-hash-") || name.starts_with("pbs-set-") || !name.starts_with("pbs-") || path.extension().and_then(|v| v.to_str()) != Some("pbx") { continue; }
count += 1;
let bytes = std::fs::read(&path).unwrap();
let image = ValidatedProgramImage::load(&bytes, &mut LoadBudget::new(LoadLimits::default()), caps::NONE)
@@ -1236,8 +1240,9 @@ fn verify_collection_cursor_gc(root:&std::path::Path,collection:&str) {
let named=|name:&str|objects.iter().filter(|o|image.registry().declarations().types[o.type_id.0 as usize].name.as_deref()==Some(name)).collect::<Vec<_>>();
assert_eq!(named("_SnapshotNode<Item>").len(),nodes,"prefix nodes round {round}");
if collection=="linked" {assert!(named("_LinkedNode<Item>").is_empty(),"snapshot does not retain original Linked nodes");}
if collection=="set" {assert!(named("_SetNode<Item>").is_empty(),"snapshot does not retain original Set nodes");}
let values=named("Item");assert_eq!(values.len(),items,"captured object roots round {round}");
if items==1 {assert_eq!(values[0].groups[0],[V::Int32(1199)],"sticky last payload remains live");}
if items==1 && collection!="set" {assert_eq!(values[0].groups[0],[V::Int32(1199)],"sticky last payload remains live");}
println!("PBS {} CURSOR GC PASS round={round} nodes={nodes} items={items} collected={}",collection.to_uppercase(),snapshot.gc.reclaimed);
}
let report=vm.run_budget(100_000,&mut NoNative,&mut HostContext::new(None)).unwrap();
@@ -1355,7 +1360,9 @@ fn verify_collection_distribution(root:&std::path::Path,collection:&str,last:i32
}
retained.sort_unstable();
let expected=if collection=="linked"&&name=="installed" {vec![20,22]} else {vec![last]};
assert_eq!(retained,expected,"{collection} {name}: complete traversal retains each final value");
if collection=="set" {
assert_eq!(retained.len(),1);assert!([20,22].contains(&retained[0]),"Set has no order guarantee");
}else{assert_eq!(retained,expected,"{collection} {name}: complete traversal retains each final value");}
println!("PBS {} DISTRIBUTION LOAD/EXEC PASS {name}",collection.to_uppercase());
}
}
@@ -1509,3 +1516,316 @@ fn verify_linked_collection_gc(root:&std::path::Path) {
let report=vm.run_budget(100_000,&mut NoNative,&mut HostContext::new(None)).unwrap();
assert!(matches!(report.reason,End::Halted|End::EndOfRom));assert_eq!(vm.operand_stack_top(1),vec![Value::Int32(42)]);
}
fn verify_identity_hashing_fixtures(root: &std::path::Path) {
use prometeu_vm::LogicalFrameEndingReason as End;
use prometeu_bytecode::{isa::core::CoreOpCode as Op,registry::TypeId};
let corpus=std::fs::read_to_string(root.join("hash-vectors.tsv")).expect("mandatory hashing oracle manifest");
let mut originals=std::collections::BTreeMap::new();let mut count=0;
for row in corpus.lines() {
let parts:Vec<_>=row.split_whitespace().collect();let name=parts[0];
let expected=u64::from_str_radix(parts[1],16).unwrap() as i64;
let id:u32=parts[2].parse().unwrap();let cost:u64=parts[3].parse().unwrap();
let bytes=std::fs::read(root.join(format!("{name}.pbx"))).unwrap();
let image=ValidatedProgramImage::load(&bytes,&mut LoadBudget::new(LoadLimits::default()),caps::NONE).unwrap();
let code=image.code().to_vec();let mut vm=VirtualMachine::from_image(image,Default::default());
vm.prepare_boot_call().unwrap();let mut total=0;let mut calls=0;
loop {
let pc=vm.pc();let op=Op::try_from(u16::from_le_bytes(code[pc..pc+2].try_into().unwrap())).unwrap();
let charge=if op==Op::Intrinsic {
assert_eq!(u32::from_le_bytes(code[pc+2..pc+6].try_into().unwrap()),id,"{name}");
let before=vm.operand_stack_top(1).to_vec();let zero=vm.run_budget(0,&mut NoNative,&mut HostContext::new(None)).unwrap();
assert_eq!((vm.pc(),zero.cycles_used,zero.steps_executed),(pc,0,0));
assert_eq!(vm.operand_stack_top(1),before);calls+=1;cost
}else{op.cycles()};
let report=vm.run_budget(1,&mut NoNative,&mut HostContext::new(None)).unwrap();
assert_eq!(report.cycles_used,charge,"{name} at {pc}");total+=charge;
if matches!(report.reason,End::EndOfRom|End::Halted){break;}
assert!(matches!(report.reason,End::BudgetExhausted),"{name}: {report:?}");
assert!(total<100_000);
}
assert_eq!(calls,1,"{name}");assert_eq!(vm.operand_stack_top(1),vec![Value::Int64(expected)],"{name}");
if let Some(base)=name.strip_suffix("-optimized") {assert_eq!(originals.get(base),Some(&total),"{name}: optimizer charging");}
else{originals.insert(name.to_string(),total);}
println!("HASH ORACLE/COST/FUEL PASS {name} result={expected} cycles={total}");count+=1;
}
assert_eq!(count,60,"all 30 source scalar/String vectors in both optimizer paths");
for prefix in ["common-identity","pbs-hash-object","pbs-hash-contract","pbs-hash-array","pbs-hash-function","pbs-hash-random","pbs-hash-discard","pbs-hash-discard-reference"] {
for suffix in ["","-optimized"] {
let name=format!("{prefix}{suffix}");let bytes=std::fs::read(root.join(format!("{name}.pbx"))).expect("mandatory identity fixture");
let image=ValidatedProgramImage::load(&bytes,&mut LoadBudget::new(LoadLimits::default()),caps::NONE).unwrap_or_else(|e|panic!("{name}: {e:?}"));
let code=image.code().to_vec();let registry=image.registry().clone();
let mut vm=VirtualMachine::from_image(image,Default::default());let observer=vm.resource_observer();
vm.prepare_boot_call().unwrap();let mut steps=0;let mut queries=0;
loop {
let pc=vm.pc();let op=Op::try_from(u16::from_le_bytes(code[pc..pc+2].try_into().unwrap())).unwrap();
let width=|at:usize|registry.type_layout(TypeId(u32::from_le_bytes(code[at..at+4].try_into().unwrap()))).unwrap().storage.slots as u64;
let charge=match op {Op::RefIdentityHash=>Some(8+width(pc+2)),Op::RefIdentityEq=>Some(4+width(pc+2)+width(pc+6)),_=>None};
let report=vm.run_budget(1,&mut NoNative,&mut HostContext::new(None)).unwrap();
if let Some(charge)=charge {queries+=1;assert_eq!(report.cycles_used,charge,"{name}: typed query charge");}
if matches!(report.reason,End::EndOfRom|End::Halted){break;}
assert!(matches!(report.reason,End::BudgetExhausted),"{name}: {report:?}");steps+=1;assert!(steps<100_000);
}
if prefix=="pbs-hash-discard-reference"{assert_eq!(queries,2,"unused reference queries retain charged work");}
let expected=if prefix=="common-identity"{Value::Boolean(true)}else{Value::Int32(42)};
assert_eq!(vm.operand_stack_top(1),vec![expected],"{name}");drop(vm);
for resource in [prometeu_vm::resource_budget::RuntimeResource::GuestBytes,prometeu_vm::resource_budget::RuntimeResource::HandleSlots,prometeu_vm::resource_budget::RuntimeResource::StringBytes] {
assert_eq!(observer.used(resource),0,"{name}: owner release");
}
println!("IDENTITY COMPLETE GROUP/ALIAS/COST PASS {name}");
}
}
verify_identity_negative_fixtures(root);
}
fn verify_pbs_set_fixtures(root:&std::path::Path) {
use prometeu_vm::{LogicalFrameEndingReason as End,resource_budget::RuntimeResource as Q};
let successes=["basic","construction","arithmetic","scalars","objects","collisions","content","tuple",
"cursor-empty","cursor-single","snapshot","callback-reads","references","random","vec2","pixel","evaluation","contract-snapshot","string-snapshot","false-snapshot"];
let faults=[("fault-callback-1",prometeu_bytecode::TRAP_EXPLICIT),("fault-callback-2",prometeu_bytecode::TRAP_EXPLICIT),
("fault-callback-3",prometeu_bytecode::TRAP_EXPLICIT),("fault-callback-4",prometeu_bytecode::TRAP_EXPLICIT),
("fault-callback-5",prometeu_bytecode::TRAP_DIV_ZERO),("fault-overflow",prometeu_bytecode::TRAP_EXPLICIT)];
for (base,fault) in successes.into_iter().map(|n|(n,None)).chain(faults.into_iter().map(|(n,f)|(n,Some(f)))) {
for suffix in ["","-optimized"] {
let name=format!("{base}{suffix}");let bytes=std::fs::read(root.join(format!("pbs-set-{name}.pbx"))).unwrap_or_else(|e|panic!("mandatory Set {name}: {e}"));
let image=ValidatedProgramImage::load(&bytes,&mut LoadBudget::new(LoadLimits::default()),caps::NONE).unwrap_or_else(|e|panic!("Set {name}: {e:?}"));
let registry=image.registry().clone();let mut vm=VirtualMachine::from_image(image,Default::default());let observer=vm.resource_observer();
vm.prepare_boot_call().unwrap();let report=vm.run_budget(10_000_000,&mut NoNative,&mut HostContext::new(None)).unwrap();
if let Some(code)=fault {
let End::Trap(info)=report.reason else{panic!("{name}: {report:?}")};assert_eq!(info.code,code,"{name}: {info:?}");
if base.starts_with("fault-callback") {
use prometeu_vm::resource_diagnostics::StorageValue as V;
let objects=vm.heap().diagnostic_typed_storage();
let set=objects.iter().find(|o|registry.declarations().types[o.type_id.0 as usize].name.as_deref()==Some("set<int>")).expect("faulted Set retained");
assert_eq!(set.groups[0],vec![V::Null],"{name}: unpublished buckets");
assert_eq!(set.groups[1],vec![V::Int64(0)],"{name}: old size");
assert_eq!(set.groups[3],vec![V::Boolean(true)],"{name}: guard is not cleaned after fault");
}
}else {
assert!(matches!(report.reason,End::Halted|End::EndOfRom),"{name}: {report:?}");
assert_eq!(vm.operand_stack_top(1),vec![Value::Int32(42)],"{name}");
}
drop(vm);
for resource in [Q::GuestBytes,Q::HandleSlots,Q::AuxiliaryBytes,Q::TemporaryBytes,Q::StringBytes,Q::StringAllocations] {
assert_eq!(observer.used(resource),0,"{name}: final resource release {resource:?}");
}
println!("SET SOURCE/LOAD/EXEC/GUARD PASS {name}");
}
}
verify_set_refusals(root);
verify_set_postpublication_injection(root);
verify_collection_cursor_gc(root,"set");
verify_set_collection_gc(root);
verify_collection_distribution(root,"set",0);
verify_installed_hash(root);
}
fn set_state(vm:&VirtualMachine,image:&ValidatedProgramImage)->ObservedStorage {
use prometeu_vm::resource_diagnostics::StorageValue as V;
let objects=vm.heap().diagnostic_typed_storage();
let owner=objects.iter().find(|o|image.registry().declarations().types[o.type_id.0 as usize].name.as_deref()==Some("set<int>")).expect("source Set");
let mut pending=vec![owner.reference];let mut state:ObservedStorage=Vec::new();
while let Some(reference)=pending.pop() {
if state.iter().any(|o|o.reference==reference){continue;}
let object=objects.iter().find(|o|o.reference==reference).expect("live complete Set group");
for value in object.groups.iter().flatten(){if let V::Reference(reference)=value{pending.push(*reference);}}
state.push(object.clone());
}
state.sort_by_key(|o|(o.reference.index,o.reference.generation));state
}
fn set_without_guard(mut state:ObservedStorage,image:&ValidatedProgramImage)->ObservedStorage {
for object in &mut state {
if image.registry().declarations().types[object.type_id.0 as usize].name.as_deref()==Some("set<int>") {
object.groups[3]=vec![prometeu_vm::resource_diagnostics::StorageValue::Boolean(false)];
}
}
state
}
fn validate_set(vm:&VirtualMachine,image:&ValidatedProgramImage,expected:i64)->usize {
use prometeu_vm::resource_diagnostics::StorageValue as V;
let state=set_state(vm,image);
let owner=state.iter().find(|o|image.registry().declarations().types[o.type_id.0 as usize].name.as_deref()==Some("set<int>")).unwrap();
assert_eq!(owner.groups[1],vec![V::Int64(expected)]);assert_eq!(owner.groups[3],vec![V::Boolean(false)]);
let get=|reference|state.iter().find(|o|o.reference==reference).expect("reachable object");
let V::Reference(carrier)=owner.groups[0][0] else{assert_eq!(expected,0);return 0;};
let V::Reference(table)=get(carrier).groups[0][0] else{panic!("bucket carrier")};
let buckets=get(table);let capacity=buckets.groups.len();let mut nodes=std::collections::HashSet::new();
for (bucket,group) in buckets.groups.iter().enumerate() {
if *group==vec![V::Null,V::Null]{continue;}
let [V::Int64(tag),V::Reference(first)]=group.as_slice() else{panic!("complete bucket group")};
assert_eq!(image.registry().declarations().types[*tag as usize].name.as_deref(),Some("_SetNode<int>"));
let mut next=Some(*first);
while let Some(reference)=next {
assert!(nodes.insert(reference),"each node appears once, no cycles");let node=get(reference);
let V::Int64(hash)=node.groups[0][0] else{panic!("cached complete hash")};
assert_eq!(hash.rem_euclid(capacity as i64) as usize,bucket);
next=match node.groups[2][0]{V::Null=>None,V::Reference(carrier)=>{let V::Reference(value)=get(carrier).groups[0][0] else{panic!("next node carrier")};Some(value)},_=>panic!("next group")};
}
}
assert_eq!(nodes.len(),expected as usize);capacity
}
fn verify_set_refusals(root:&std::path::Path) {
use prometeu_vm::{LogicalFrameEndingReason as End,resource_budget::{RuntimeLimits,RuntimeResource as Q}};
use prometeu_bytecode::{decode_next,isa::core::CoreOpCode as Op,TRAP_RESOURCE_LIMIT};
let mut node_refusal=false;let mut snapshot_refusal=false;let mut table_refusal=false;let mut guard_effect=false;
for name in ["growth","add","duplicate","remove","clear","cursor"] {
for suffix in ["","-optimized"] {
let bytes=std::fs::read(root.join(format!("pbs-set-refusal-{name}{suffix}.pbx"))).expect("mandatory Set resource fixture");
let image=ValidatedProgramImage::load(&bytes,&mut LoadBudget::new(LoadLimits::default()),caps::NONE).unwrap();
let marker=|value:i32|{let mut pc=0;let mut found=Vec::new();while pc<image.code().len(){let i=decode_next(pc,image.code()).unwrap();if i.opcode==Op::PushI32&&i.imm_i32().unwrap()==value{found.push(pc);}pc=i.next_pc;}assert_eq!(found.len(),1);found[0]};
let before_pc=marker(314160);let after_pc=marker(314161);
let prepare=|limits|{let mut vm=VirtualMachine::from_image(image.clone(),limits);vm.prepare_boot_call().unwrap();vm.insert_breakpoint(before_pc);vm.insert_breakpoint(after_pc);vm};
let mut baseline=prepare(RuntimeLimits::default());assert!(matches!(baseline.run_budget(20_000_000,&mut NoNative,&mut HostContext::new(None)).unwrap().reason,End::Breakpoint));
let before=baseline.resource_snapshot();let old=set_state(&baseline,&image);let size=if name=="growth"{6}else{5};
assert_eq!(validate_set(&baseline,&image,size),8);baseline.remove_breakpoint(before_pc);
let mut successful=Vec::new();let mut max_nodes=0;let mut max_tables=0;
loop {
let objects=baseline.heap().diagnostic_typed_storage();
max_nodes=max_nodes.max(objects.iter().filter(|o|image.registry().declarations().types[o.type_id.0 as usize].name.as_deref()==Some("_SetNode<int>")).count());
max_tables=max_tables.max(objects.iter().filter(|o|matches!(image.registry().declarations().types[o.type_id.0 as usize].kind,prometeu_bytecode::registry::TypeKind::Array(_))).count());
successful.push((baseline.pc(),observe_originals(&baseline,&old)));
let report=baseline.run_budget(1,&mut NoNative,&mut HostContext::new(None)).unwrap();
if baseline.pc()==after_pc{break;}
assert!(matches!(report.reason,End::BudgetExhausted),"Set {name}: {report:?}");assert!(successful.len()<200_000);
}
let after=baseline.resource_snapshot();let expected=match name{"growth"|"add"=>size+1,"remove"=>size-1,"clear"=>0,_=>size};
let capacity=validate_set(&baseline,&image,expected);
assert_eq!(capacity,if name=="growth"{16}else if name=="clear"{0}else{8});
if name=="growth"{assert!(max_nodes>=13,"six old + six copied + inserted");assert!(max_tables>=2);}
if name=="duplicate"||name=="cursor"{assert_eq!(set_state(&baseline,&image),old);}
println!("SET PEAK {name}{suffix} nodes={max_nodes} tables={max_tables} before={:?} after={:?}",before.budget.peaks,after.budget.peaks);
let mut refusals=0;let mut structural_refusals=0;
for resource in [Q::GuestBytes,Q::HandleSlots,Q::AuxiliaryBytes,Q::TemporaryBytes,Q::CallDepth] {
let lower=before.budget.peaks[resource as usize];let upper=after.budget.peaks[resource as usize];if lower>=upper{continue;}
let mut limits=vec![lower,lower+(upper-lower)/4,lower+(upper-lower)/2,upper-1];
if resource==Q::HandleSlots{limits.extend(lower..upper.min(lower+24));}limits.sort_unstable();limits.dedup();
for limit in limits {
let mut vm=prepare(RuntimeLimits::default().lowered(resource,limit).unwrap());let observer=vm.resource_observer();
assert!(matches!(vm.run_budget(20_000_000,&mut NoNative,&mut HostContext::new(None)).unwrap().reason,End::Breakpoint),"Set setup {name} {resource:?}={limit}");
let original=set_state(&vm,&image);vm.remove_breakpoint(before_pc);
let (report,prefix,_)=trace_collection_attempt(&mut vm,&original,after_pc);assert_mutation_prefix(&prefix,&successful);
if let End::Trap(info)=report.reason {
assert_eq!(info.code,TRAP_RESOURCE_LIMIT,"Set {name} {resource:?}={limit}: {info:?}");
let touched=prefix.iter().any(|(_,state)|set_without_guard(state.clone(),&image)!=set_without_guard(original.clone(),&image));
if !touched {assert_eq!(set_without_guard(observe_originals(&vm,&original),&image),set_without_guard(original.clone(),&image));}
if name=="cursor"{assert_eq!(set_state(&vm,&image),original);}
let now=observe_originals(&vm,&original);guard_effect|=!touched&&now!=original;
structural_refusals+=usize::from(touched);
let instruction=decode_next(info.pc as usize,image.code()).unwrap();table_refusal|=name=="growth"&&instruction.opcode==Op::ArrayNew;
if instruction.opcode==Op::StructNew {
let named=image.registry().declarations().types[instruction.imm_u32().unwrap() as usize].name.as_deref();
node_refusal|=named==Some("_SetNode<int>");snapshot_refusal|=named==Some("_SnapshotNode<int>");
}
refusals+=1;println!("SET PHASE REFUSAL {name}{suffix} structural={touched} resource={resource:?} limit={limit} opcode={:?}",instruction.opcode);
}else{assert!(matches!(report.reason,End::BudgetExhausted|End::Breakpoint)&&vm.pc()==after_pc);}
drop(vm);for q in [Q::GuestBytes,Q::HandleSlots,Q::AuxiliaryBytes,Q::TemporaryBytes]{assert_eq!(observer.used(q),0);}
}
}
assert!(refusals>0,"Set {name}: resource refusal evidence");
println!("SET PHASE SUMMARY {name}{suffix} refusals={refusals} after_structural_write={structural_refusals}");
}
}
assert!(node_refusal&&snapshot_refusal&&table_refusal&&guard_effect,"nodes/snapshot/table/guard refusal evidence required");
}
fn verify_set_collection_gc(root:&std::path::Path) {
use prometeu_vm::LogicalFrameEndingReason as End;
let bytes=std::fs::read(root.join("pbs-set-gc-collection.pbx")).expect("mandatory Set collection GC fixture");
let image=ValidatedProgramImage::load(&bytes,&mut LoadBudget::new(LoadLimits::default()),caps::NONE).unwrap();
let mut vm=VirtualMachine::from_image(image.clone(),Default::default());vm.prepare_boot_call().unwrap();let mut previous=0;
for (round,count) in [64,61,0,0].into_iter().enumerate() {
let report=vm.run_budget(30_000_000,&mut NoNative,&mut HostContext::new(None)).unwrap();assert!(matches!(report.reason,End::FrameSync),"Set GC {round}: {report:?}");
let collections=vm.resource_snapshot().gc.collections;assert!(collections>previous);previous=collections;
let objects=vm.heap().diagnostic_typed_storage();
for name in ["_SetNode<Item>","Item"] {
let actual=objects.iter().filter(|o|image.registry().declarations().types[o.type_id.0 as usize].name.as_deref()==Some(name)).count();assert_eq!(actual,count,"Set GC {round}: {name}");
}
println!("SET COLLECTION/OLD-CANDIDATE GC PASS round={round} live_nodes={count}");
}
let report=vm.run_budget(100_000,&mut NoNative,&mut HostContext::new(None)).unwrap();assert!(matches!(report.reason,End::Halted|End::EndOfRom));assert_eq!(vm.operand_stack_top(1),vec![Value::Int32(42)]);
}
// Controlled test-only source instrumentation, never a production SDK algorithm.
// A quota probe is inserted after the real candidate-table store and before size.
// Natural production-quota coverage and its refusal frequencies remain separate.
fn verify_set_postpublication_injection(root:&std::path::Path) {
use prometeu_vm::{LogicalFrameEndingReason as End,resource_budget::{RuntimeLimits,RuntimeResource as Q},resource_diagnostics::StorageValue as V};
use prometeu_bytecode::{decode_next,isa::core::CoreOpCode as Op,TRAP_RESOURCE_LIMIT};
for suffix in ["","-optimized"] {
let bytes=std::fs::read(root.join(format!("pbs-set-injected-refusal-growth{suffix}.pbx"))).expect("explicit test-only post-publication injection");
let image=ValidatedProgramImage::load(&bytes,&mut LoadBudget::new(LoadLimits::default()),caps::NONE).unwrap();
let limits=RuntimeLimits::default().lowered(Q::GuestBytes,500_000).unwrap();
let mut vm=VirtualMachine::from_image(image.clone(),limits);let observer=vm.resource_observer();vm.prepare_boot_call().unwrap();
let mut found=false;
for _ in 0..200_000 {
let instruction=decode_next(vm.pc(),image.code()).unwrap();
if instruction.opcode==Op::ArrayNew&&vm.operand_stack_top(1)==vec![Value::Int64(1_000_000)] {
let original=vm.heap().diagnostic_typed_storage();let state=set_state(&vm,&image);
let owner=state.iter().find(|o|image.registry().declarations().types[o.type_id.0 as usize].name.as_deref()==Some("set<int>")).unwrap();
assert_eq!(owner.groups[1],vec![V::Int64(6)]);assert_eq!(owner.groups[3],vec![V::Boolean(true)]);
assert_eq!(state.iter().filter(|o|image.registry().declarations().types[o.type_id.0 as usize].name.as_deref()==Some("_SetNode<int>")).count(),7);
assert!(state.iter().any(|o|matches!(image.registry().declarations().types[o.type_id.0 as usize].kind,prometeu_bytecode::registry::TypeKind::Array(_))&&o.groups.len()==16));
let input=vm.operand_stack_top(1).to_vec();let report=vm.run_budget(1,&mut NoNative,&mut HostContext::new(None)).unwrap();
let End::Trap(info)=report.reason else{panic!("post-publication injection: {report:?}")};assert_eq!(info.code,TRAP_RESOURCE_LIMIT);
assert_eq!(vm.heap().diagnostic_typed_storage(),original,"refused probe preserves its entry state, retaining earlier table publication");
assert_eq!(vm.operand_stack_top(1),input);
println!("SET TEST-ONLY POST-PUBLICATION QUOTA INJECTION PASS {suffix}: new table=16 nodes=7 old size=6 guard=true");found=true;break;
}
let report=vm.run_budget(1,&mut NoNative,&mut HostContext::new(None)).unwrap();assert!(matches!(report.reason,End::BudgetExhausted),"before injection: {report:?}");
}
assert!(found);drop(vm);for q in [Q::GuestBytes,Q::HandleSlots,Q::AuxiliaryBytes,Q::TemporaryBytes]{assert_eq!(observer.used(q),0);}
}
}
fn verify_identity_negative_fixtures(root:&std::path::Path) {
use prometeu_vm::LogicalFrameEndingReason as End;
use prometeu_bytecode::{decode_next,isa::core::CoreOpCode as Op};
for base in ["bad-category","bad-right","dead-bad-category","bad-typeid"] {
for suffix in ["","-optimized"] {
let name=format!("common-identity-{base}{suffix}");let bytes=std::fs::read(root.join(format!("{name}.pbx"))).unwrap();
assert!(ValidatedProgramImage::load(&bytes,&mut LoadBudget::new(LoadLimits::default()),caps::NONE).is_err(),"{name}");
println!("IDENTITY NEUTRAL ADMISSION REJECT PASS {name}");
}
}
for base in ["partial","truncated"] {
let bytes=std::fs::read(root.join(format!("common-identity-{base}.pbx"))).unwrap();
assert!(ValidatedProgramImage::load(&bytes,&mut LoadBudget::new(LoadLimits::default()),caps::NONE).is_err());
println!("IDENTITY PARTIAL/TRUNCATED ADMISSION REJECT PASS {base}");
}
for base in ["null-views","right-after-null","right-after-distinct"] {
let bytes=std::fs::read(root.join(format!("common-identity-{base}.pbx"))).unwrap();
let image=ValidatedProgramImage::load(&bytes,&mut LoadBudget::new(LoadLimits::default()),caps::NONE).unwrap_or_else(|e|panic!("{base}: {e:?}"));
let mut vm=VirtualMachine::from_image(image.clone(),Default::default());vm.prepare_boot_call().unwrap();
loop {
let instruction=decode_next(vm.pc(),image.code()).unwrap();
if instruction.opcode==Op::RefIdentityEq {
let operands=vm.operand_stack_top(3).to_vec();
let zero=vm.run_budget(0,&mut NoNative,&mut HostContext::new(None)).unwrap();assert_eq!((zero.cycles_used,zero.steps_executed),(0,0));
let report=vm.run_budget(1,&mut NoNative,&mut HostContext::new(None)).unwrap();assert_eq!(report.cycles_used,7);
if base=="null-views" {
assert!(matches!(report.reason,End::BudgetExhausted));assert_eq!(vm.operand_stack_top(1),vec![Value::Boolean(true)]);
}else {
let End::Trap(info)=report.reason else{panic!("{base}: right validation was skipped: {report:?}")};
assert_eq!(info.code,prometeu_bytecode::TRAP_TYPE);assert_eq!(report.steps_executed,0);assert_eq!(vm.operand_stack_top(3),operands);
}
println!("IDENTITY COMPLETE RIGHT/NULL/FUEL/COST PASS {base}");break;
}
let report=vm.run_budget(1,&mut NoNative,&mut HostContext::new(None)).unwrap();assert!(matches!(report.reason,End::BudgetExhausted));
}
}
}
fn verify_installed_hash(root:&std::path::Path) {
use prometeu_vm::LogicalFrameEndingReason as End;
let bytes=std::fs::read(root.join("pbs-hash-installed.pbx")).expect("mandatory installed hashing example");
let image=ValidatedProgramImage::load(&bytes,&mut LoadBudget::new(LoadLimits::default()),caps::NONE).unwrap();
let mut vm=VirtualMachine::from_image(image,Default::default());vm.prepare_boot_call().unwrap();
let report=vm.run_budget(1_000_000,&mut NoNative,&mut HostContext::new(None)).unwrap();
assert!(matches!(report.reason,End::FrameSync|End::Halted|End::EndOfRom),"installed hashing: {report:?}");
println!("HASH INSTALLED JAR/SDK/EXAMPLE LOAD/EXEC PASS");
}