//! Studio-produced PBS images through the production VM and foreground firmware. use prometeu_bytecode::{Value, registry::LifecycleRole}; use prometeu_drivers::TestPlatform; use prometeu_firmware::firmware::{Firmware, FirmwareState}; use prometeu_hal::{InputSignals, app_mode::AppMode, cartridge::{Cartridge, AssetsPayloadSource}}; use prometeu_system::task::{TaskId, TaskState}; use prometeu_vm::{HostContext, LogicalFrameEndingReason as Reason, ValidatedProgramImage, VirtualMachine}; use std::path::Path; fn bytes(root: &Path, name: &str) -> Vec { std::fs::read(root.join(format!("{name}.pbx"))).unwrap_or_else(|e| panic!("{name}: {e}")) } fn load(root: &Path, name: &str) -> VirtualMachine { let image = ValidatedProgramImage::load(&bytes(root, name), &mut super::LoadBudget::new(Default::default()), super::caps::NONE).unwrap(); for role in [LifecycleRole::BeforePause, LifecycleRole::BeforeResume] { if let Some(id) = image.registry().lifecycle_hook(role) { assert_ne!(id.0, 0); } } let mut vm = VirtualMachine::from_image(image, Default::default()); vm.prepare_boot_call().unwrap(); let report = vm.run_budget(100_000, &mut super::NoNative, &mut HostContext::new(None)).unwrap(); assert!(matches!(report.reason, Reason::EndOfRom | Reason::Halted), "{name}: {report:?}"); vm } fn query(root: &Path, name: &str, vm: &mut VirtualMachine) -> i32 { let id = std::fs::read_to_string(root.join(format!("{name}.probe"))).unwrap(); vm.prepare_call(id.trim()).unwrap(); let report = vm.run_budget(100_000, &mut super::NoNative, &mut HostContext::new(None)).unwrap(); assert!(matches!(report.reason, Reason::EndOfRom | Reason::Halted), "{name}: {report:?}"); match vm.operand_stack_top(1)[0] { Value::Int32(value) => value, ref other => panic!("{other:?}") } } fn finish_hook(vm: &mut VirtualMachine, expected: Reason) -> usize { let mut previous = vm.lifecycle_remaining_cycles().unwrap(); let mut slices = 0; loop { slices += 1; assert!(slices < 16); let report = vm.run_budget(u64::MAX, &mut super::NoNative, &mut HostContext::new(None)).unwrap(); // Includes the specified whole-instruction overshoot; this corpus uses scalar instructions. assert!(report.cycles_used <= VirtualMachine::LIFECYCLE_SLICE + 100); if report.reason != Reason::BudgetExhausted { assert_eq!(report.reason, expected); break; } let remaining = vm.lifecycle_remaining_cycles().unwrap(); assert!(remaining < previous); assert_eq!(previous.saturating_sub(report.cycles_used), remaining); previous = remaining; } slices } fn snapshot(fw: &mut Firmware, task: TaskId) -> (usize, u64, u64) { // The active foreground facade switches to the crash UI after failure. // Observe the retained game session so a foreground change cannot reset the oracle. let sessions = fw.os.sessions(); let session = sessions.vm_session_for_task(task).unwrap(); (session.vm.pc(), session.runtime.tick_index, session.runtime.atomic_telemetry.completed_logical_frames.load(std::sync::atomic::Ordering::Relaxed) as u64) } fn firmware(root: &Path, name: &str) -> (Firmware, TestPlatform, TaskId) { let mut fw = Firmware::new(None); let mut platform = TestPlatform::new(); fw.load_cartridge(Cartridge { app_id: 86, title: "Studio PBS lifecycle".into(), app_version: "1.0.0".into(), app_mode: AppMode::Game, capabilities: super::caps::NONE, memcard_slots: None, program: bytes(root, name), assets: AssetsPayloadSource::empty(), asset_table: vec![], preload: vec![], }); fw.tick(&InputSignals::default(), &mut platform); let task = fw.os.lifecycle().resident_game_task().unwrap(); fw.tick(&InputSignals::default(), &mut platform); assert!(fw.os.vm().last_crash_report().is_none()); (fw, platform, task) } fn foreground_case(root: &Path, name: &str, expected: i32, resume: bool) { let (mut fw, mut platform, task) = firmware(root, name); let signals = InputSignals::default(); fw.request_home_from_host(); fw.tick(&signals, &mut platform); // Existing Home handoff, including its gameplay reaction. let suspended = snapshot(&mut fw, task); fw.tick(&signals, &mut platform); // Hook only, or already-suspended case without a hook. assert_eq!(fw.os.lifecycle().task_state(task), Some(TaskState::Suspended), "{name}"); assert_eq!(snapshot(&mut fw, task), suspended, "pause changed gameplay state: {name}"); assert!(fw.resume_resident_game_from_home()); if resume { fw.tick(&signals, &mut platform); // BeforeResume only. assert_eq!(snapshot(&mut fw, task), suspended, "resume changed gameplay state: {name}"); } fw.tick(&signals, &mut platform); // First eligible gameplay frame validates guest stage/init/heap. assert!(fw.os.vm().last_crash_report().is_none(), "{name}"); assert_eq!(snapshot(&mut fw, task).1, suspended.1 + 1); let actual = { let mut sessions = fw.os.sessions(); let session = sessions.vm_session_for_task_mut(task).unwrap(); // Terminal observation only, after all continuation/frame assertions; no later host tick. query(root, name, &mut session.vm) }; assert_eq!(actual, expected, "ordered guest effects/init/heap: {name}"); println!("FIRMWARE HOME/RESUME PASS {name}: pc={}, gameplayTicks={}, frames={}, guest={actual}", suspended.0, suspended.1, suspended.2); } fn other_foreground_paths(root: &Path, name: &str) { for shell in [false, true] { let (mut fw, mut platform, task) = firmware(root, name); let before = snapshot(&mut fw, task); if shell { fw.os.sessions().try_create_native_shell_task(99, "Tools").unwrap(); } else { fw.os.lifecycle().suspend_task(task).unwrap(); } fw.tick(&InputSignals::default(), &mut platform); assert_eq!(fw.os.lifecycle().task_state(task), Some(TaskState::Suspended)); assert_eq!(snapshot(&mut fw, task), before); println!("DIRECT/SHELL SUSPEND PASS {name}: shell={shell}, no reaction tick"); } let mut vm = load(root, name); vm.prepare_boot_call().unwrap(); let partial = vm.run_budget(1, &mut super::NoNative, &mut HostContext::new(None)).unwrap(); assert_eq!(partial.reason, Reason::BudgetExhausted); assert!(!vm.call_stack_is_empty()); let pc = vm.pc(); let stack = vm.operand_stack_top(1000).to_vec(); assert!(!stack.is_empty(), "suspended wrapper must retain an operand"); for role in [LifecycleRole::BeforePause, LifecycleRole::BeforeResume] { assert!(vm.begin_lifecycle(role).unwrap()); finish_hook(&mut vm, Reason::LifecycleComplete); assert_eq!(vm.pc(), pc); assert_eq!(vm.operand_stack_top(1000).to_vec(), stack); assert!(!vm.call_stack_is_empty()); } let resumed = vm.run_budget(100_000, &mut super::NoNative, &mut HostContext::new(None)).unwrap(); assert!(matches!(resumed.reason, Reason::EndOfRom | Reason::Halted)); assert_eq!(query(root, name, &mut vm), 230112); println!("SUSPENDED STACK/CONTINUATION PASS {name}: retained operand, frame and heap"); } pub fn verify(root: &Path) { for suffix in ["", "-optimized"] { for (case, expected, resume) in [("both", 230112, true), ("pause", 20109, false), ("resume", 30110, true), ("none", 107, false)] { let name = format!("pbs-lifecycle-{case}{suffix}"); let mut vm = load(root, &name); for (role, present) in [(LifecycleRole::BeforePause, case == "both" || case == "pause"), (LifecycleRole::BeforeResume, resume)] { let pc = vm.pc(); let stack = vm.operand_stack_top(1000).to_vec(); assert_eq!(vm.begin_lifecycle(role).unwrap(), present); if present { assert!(vm.begin_lifecycle(role).is_err(), "controlled calls cannot reenter"); finish_hook(&mut vm, Reason::LifecycleComplete); } assert_eq!(vm.pc(), pc); assert_eq!(vm.operand_stack_top(1000).to_vec(), stack); } vm.prepare_boot_call().unwrap(); let next = vm.run_budget(100_000, &mut super::NoNative, &mut HostContext::new(None)).unwrap(); assert!(matches!(next.reason, Reason::Halted | Reason::EndOfRom)); assert_eq!(query(root, &name, &mut vm), expected); foreground_case(root, &name, expected, resume); } other_foreground_paths(root, &format!("pbs-lifecycle-both{suffix}")); let name = format!("pbs-lifecycle-direct{suffix}"); let mut vm = load(root, &name); assert!(!vm.lifecycle_active()); assert_eq!(query(root, &name, &mut vm), 230112); println!("ORDINARY CALL PASS {name}: no controlled invocation"); let name = format!("pbs-lifecycle-slices{suffix}"); let mut vm = load(root, &name); vm.begin_lifecycle(LifecycleRole::BeforePause).unwrap(); let hook_pc = vm.pc(); vm.insert_breakpoint(hook_pc); let remaining = vm.lifecycle_remaining_cycles(); let stopped = vm.run_budget(250_000, &mut super::NoNative, &mut HostContext::new(None)).unwrap(); assert_eq!(stopped.reason, Reason::Breakpoint); assert_eq!(stopped.cycles_used, 0); assert_eq!(vm.lifecycle_remaining_cycles(), remaining); vm.remove_breakpoint(hook_pc); vm.step(&mut super::NoNative, &mut HostContext::new(None)).unwrap(); assert!(vm.lifecycle_remaining_cycles().unwrap() < remaining.unwrap()); assert!(finish_hook(&mut vm, Reason::LifecycleComplete) > 1); println!("SLICES + DEBUGGER PASS {name}: one retained total fuel budget"); for case in ["trap", "fuel"] { let name = format!("pbs-lifecycle-{case}{suffix}"); let mut vm = load(root, &name); vm.begin_lifecycle(LifecycleRole::BeforePause).unwrap(); let mut slices = 0; let terminal = loop { slices += 1; assert!(slices < 16); let report = vm.run_budget(u64::MAX, &mut super::NoNative, &mut HostContext::new(None)).unwrap(); if report.reason != Reason::BudgetExhausted { break report.reason; } }; if case == "trap" { assert!(matches!(terminal, Reason::Trap(_))); } else { assert!(matches!(&terminal, Reason::Panic(text) if text.contains("lifecycle total cycle budget exhausted"))); assert!(slices > 1); } let blocked = vm.run_budget(1000, &mut super::NoNative, &mut HostContext::new(None)).unwrap(); assert_eq!(blocked.reason, terminal); assert_eq!(blocked.steps_executed, 0); assert!(vm.prepare_boot_call().is_err()); let (mut fw, mut platform, task) = firmware(root, &name); fw.request_home_from_host(); fw.tick(&InputSignals::default(), &mut platform); let before = snapshot(&mut fw, task); for _ in 0..16 { fw.tick(&InputSignals::default(), &mut platform); if matches!(fw.state, FirmwareState::AppCrashes(_)) { break; } } assert!(matches!(fw.state, FirmwareState::AppCrashes(_)), "{name}"); assert_eq!(snapshot(&mut fw, task).1, before.1); assert_eq!(snapshot(&mut fw, task).2, before.2); println!("FATAL + GAMEPLAY BLOCK PASS {name}: {terminal:?}, slices={slices}"); } } // These binaries are explicitly synthetic; no PBS sync surface is claimed. for case in ["direct", "transitive"] { let name = format!("synthetic-lifecycle-sync-{case}"); let mut vm = load(root, &name); vm.begin_lifecycle(LifecycleRole::BeforePause).unwrap(); let report = vm.run_budget(100_000, &mut super::NoNative, &mut HostContext::new(None)).unwrap(); assert!(matches!(report.reason, Reason::Trap(_)), "{report:?}"); let again = vm.run_budget(1000, &mut super::NoNative, &mut HostContext::new(None)).unwrap(); assert_eq!(again.steps_executed, 0); assert_eq!(again.reason, report.reason); let (mut fw, mut platform, task) = firmware(root, &name); fw.request_home_from_host(); fw.tick(&InputSignals::default(), &mut platform); let before = snapshot(&mut fw, task); fw.tick(&InputSignals::default(), &mut platform); assert!(matches!(fw.state, FirmwareState::AppCrashes(_))); assert_eq!(snapshot(&mut fw, task).1, before.1); assert_eq!(snapshot(&mut fw, task).2, before.2); println!("SYNTHETIC SYNC REJECTION PASS {case}: no gameplay/frame publication"); } let name = "pbs-lifecycle-imports"; let mut vm = load(root, name); assert!(vm.begin_lifecycle(LifecycleRole::BeforePause).unwrap()); finish_hook(&mut vm, Reason::LifecycleComplete); assert!(!vm.has_lifecycle_hook(LifecycleRole::BeforeResume)); println!("PRODUCTION PIPELINE IMPORTS PASS: alias/reexport selected one original hook"); }