Files
bquarkz bf31184d4d feat(pbs): add sprite animation and shared Studio authoring
Implement DEC-0084 with factory-only Sprite/Animator structs, complete result
lowering, validated animation sidecars, generated PBS factories and JavaFX/MCP
authoring through shared services.

Qualify native dev/release with ordinary and optimized producers, zero-allocation
playback, private-cycle reclamation, canonical Composer pixels, installed JARs
and JavaFX lifecycle. Preserve the runtime checkout and existing host ABI.
2026-11-05 15:16:07 +00:00

119 lines
8.8 KiB
Rust

//! Real core playback and executed allocation evidence, including error paths.
use super::*;
use prometeu_vm::LogicalFrameEndingReason as End;
use prometeu_bytecode::{decode_next, isa::core::CoreOpCode as Op};
pub fn verify(root: &std::path::Path) {
let manifest = std::fs::read_to_string(root.join("pbs-animation-manifest.txt")).expect("mandatory animation manifest");
let names: Vec<_> = manifest.lines().collect();
assert_eq!(names, ["basic", "loop", "once", "negative", "overflow", "draft", "limits", "matrix", "errors"]);
for name in names { for suffix in ["", "-optimized"] {
let bytes = std::fs::read(root.join(format!("pbs-animation-{name}{suffix}.pbx"))).expect("mandatory animation fixture");
let image = ValidatedProgramImage::load(&bytes, &mut LoadBudget::new(LoadLimits::default()), caps::NONE)
.unwrap_or_else(|e| panic!("animation/{name}{suffix}: load {e:?}"));
let mut vm = VirtualMachine::from_image(image.clone(), Default::default());
vm.prepare_boot_call().unwrap();
let mut watching = false; let mut started = 0; let mut ended = 0; let mut allocations = 0; let mut measured_steps=0;
for step in 0..2_000_000 {
let instruction = decode_next(vm.pc(), image.code()).unwrap();
if instruction.opcode == Op::PushI32 {
if instruction.imm_i32().unwrap() == 162000001 { watching = true; started += 1; }
if instruction.imm_i32().unwrap() == 162000002 { watching = false; ended += 1; }
}
if watching { measured_steps+=1; }
if watching && matches!(instruction.opcode, Op::StructNew | Op::ArrayNew | Op::MakeClosure) { allocations += 1; }
let report = vm.run_budget(1, &mut NoNative, &mut HostContext::new(None))
.unwrap_or_else(|e| panic!("animation/{name}{suffix}: run {e:?}"));
if matches!(report.reason, End::Halted | End::EndOfRom) { break; }
assert!(matches!(report.reason, End::BudgetExhausted), "animation/{name}{suffix}: {report:?}");
assert!(step < 1_999_999, "animation failed to terminate");
}
assert_eq!(vm.operand_stack_top(2), vec![Value::Int32(42), Value::Int32(0)], "animation/{name}{suffix}");
if !matches!(name, "basic" | "draft" | "limits" | "matrix") { assert_eq!((started, ended), (1, 1)); }
assert!(measured_steps<50000,"bounded frame traversal: {measured_steps}");
assert_eq!(allocations, 0, "animation/{name}{suffix}: executed advance/sprite heap allocations");
if name=="basic" {
use prometeu_vm::resource_budget::{RuntimeLimits,RuntimeResource};
for resource in [RuntimeResource::GuestBytes,RuntimeResource::HandleSlots] {
let mut refused=VirtualMachine::from_image(image.clone(),RuntimeLimits::default().lowered(resource,0).unwrap());
refused.prepare_boot_call().unwrap();let report=refused.run_budget(100_000,&mut NoNative,&mut HostContext::new(None)).unwrap();
assert!(matches!(report.reason,End::Trap(ref fault) if fault.code==prometeu_bytecode::TRAP_RESOURCE_LIMIT));
assert_eq!(refused.heap().len(),0);println!("ANIMATION QUOTA TRAP PASS {suffix} {resource:?}");
}
}
println!("ANIMATION PASS {name}{suffix} watched={started} executed_allocations={allocations}");
} }
verify_gc(root);
verify_installed(root);
verify_composer(root);
}
fn verify_gc(root: &std::path::Path) {
for suffix in ["", "-optimized"] {
let bytes=std::fs::read(root.join(format!("pbs-animation-gc{suffix}.pbx"))).unwrap();
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();
for round in 0..2 {
let report=vm.run_budget(30_000_000,&mut NoNative,&mut HostContext::new(None)).unwrap();
assert!(matches!(report.reason,End::FrameSync),"animation GC: {report:?}");
let objects=vm.heap().diagnostic_typed_storage();
for name in ["Animator","_AnimationClip","_AnimationFrame"] {
let count=objects.iter().filter(|o|image.registry().declarations().types[o.type_id.0 as usize].name.as_deref()==Some(name)).count();
if round==0 {assert!(count>0,"live animation root {name}");} else {assert_eq!(count,0,"unowned cycle {name}");}
}
assert!(vm.resource_snapshot().gc.reclaimed>1000);
println!("ANIMATION GC PASS {suffix} round={round} collections={} reclaimed={}",vm.resource_snapshot().gc.collections,vm.resource_snapshot().gc.reclaimed);
}
}
}
fn verify_installed(root: &std::path::Path) {
use prometeu_drivers::TestPlatform;
use prometeu_firmware::firmware::Firmware;
use prometeu_hal::{InputSignals,app_mode::AppMode,cartridge::{Cartridge,AssetsPayloadSource}};
for suffix in ["", "-optimized"] {
let name=format!("pbs-animation-installed{suffix}");
let mut fw=Firmware::new(None);let mut platform=TestPlatform::new();
fw.load_cartridge(Cartridge{app_id:84,title:"Studio animation".into(),app_version:"1.0.0".into(),app_mode:AppMode::Game,capabilities:caps::NONE,memcard_slots:None,program:std::fs::read(root.join(format!("{name}.pbx"))).unwrap(),assets:AssetsPayloadSource::empty(),asset_table:vec![],preload:vec![]});
for _ in 0..5 {fw.tick(&InputSignals::default(),&mut platform);assert!(fw.os.vm().last_crash_report().is_none());}
let task=fw.os.lifecycle().resident_game_task().unwrap();let mut sessions=fw.os.sessions();let session=sessions.vm_session_for_task_mut(task).unwrap();
let id=std::fs::read_to_string(root.join(format!("{name}.probe"))).unwrap();session.vm.prepare_call(id.trim()).unwrap();
let report=session.vm.run_budget(100_000,&mut NoNative,&mut HostContext::new(None)).unwrap();assert!(matches!(report.reason,End::Halted|End::EndOfRom));assert_eq!(session.vm.operand_stack_top(1),vec![Value::Int32(42)]);
println!("ANIMATION INSTALLED GENERATED/FIRMWARE PASS {suffix}");
}
}
fn verify_composer(root: &std::path::Path) {
use prometeu_drivers::TestPlatform;
use prometeu_firmware::firmware::Firmware;
use prometeu_hal::{InputSignals,app_mode::AppMode,cartridge::{Cartridge,AssetsPayloadSource,AssetsPackPrelude}};
for suffix in ["", "-optimized"] {
let prefix=format!("pbs-animation-composer{suffix}");
let manifest:serde_json::Value=serde_json::from_slice(&std::fs::read(root.join(format!("{prefix}.manifest.json"))).unwrap()).unwrap();
let oracle:serde_json::Value=serde_json::from_slice(&std::fs::read(root.join(format!("{prefix}.oracle.json"))).unwrap()).unwrap();
let packed=std::fs::read(root.join(format!("{prefix}.assets.pa"))).unwrap();let prelude=AssetsPackPrelude::from_bytes(&packed).unwrap();
let mut fw=Firmware::new(None);let mut platform=TestPlatform::new();
fw.load_cartridge(Cartridge{app_id:84,title:"Studio animation Composer".into(),app_version:"1.0.0".into(),app_mode:AppMode::Game,
capabilities:caps::COMPOSER,memcard_slots:None,
program:std::fs::read(root.join(format!("{prefix}.pbx"))).unwrap(),assets:AssetsPayloadSource::from_bytes(packed[prelude.payload_offset as usize..].to_vec()),
asset_table:serde_json::from_value(manifest["asset_table"].clone()).unwrap(),preload:serde_json::from_value(manifest["preload"].clone()).unwrap()});
let mut observed=0;
for _ in 0..50000 {
fw.tick(&InputSignals::default(),&mut platform);
assert!(fw.os.vm().last_crash_report().is_none(),"Composer {suffix}: {:?}",fw.os.vm().last_crash_report());
if let Some(task)=fw.os.lifecycle().resident_game_task() {
let completed={let sessions=fw.os.sessions();sessions.vm_session_for_task(task).map(|s|s.runtime.atomic_telemetry.completed_logical_frames.load(std::sync::atomic::Ordering::Relaxed)).unwrap_or(0)};
if completed>observed {
assert_eq!(completed,observed+1,"one native frame per observation");
let sample=&oracle[observed as usize];let pixels=sample["rgba"].as_array().unwrap();let front=platform.local_hardware().gfx.front_buffer();let width=platform.local_hardware().gfx.size().0;
for x in [32,64] {for y in 0..16 {for dx in 0..16 {assert_eq!(front[(32+y)*width+x+dx],pixels[y*16+dx].as_u64().unwrap() as u32,"{prefix} tick={observed} x={x} pixel={dx},{y}");}}}
println!("ANIMATION COMPOSER PIXELS PASS {suffix} tick={observed} glyph={} palette={}",sample["glyph"],sample["palette"]);
observed=completed;if observed==8 {break;}
}
}
std::thread::yield_now();
}
assert_eq!(observed,8,"native Composer did not produce all frames");
}
}