diff --git a/crates/console/prometeu-drivers/src/memcard.rs b/crates/console/prometeu-drivers/src/memcard.rs index 07effa9..9a0994b 100644 --- a/crates/console/prometeu-drivers/src/memcard.rs +++ b/crates/console/prometeu-drivers/src/memcard.rs @@ -13,7 +13,8 @@ fn io_error(e: std::io::Error) -> Error { use std::io::ErrorKind as K; match e.kind() { K::NotFound => Error::Unavailable, - K::PermissionDenied => Error::ReadOnly, + K::PermissionDenied => Error::AccessDenied, + K::AlreadyExists => Error::AlreadyExists, K::StorageFull => Error::NoSpace, K::InvalidInput | K::UnexpectedEof => Error::InvalidRange, K::Unsupported => Error::Unsupported, @@ -21,8 +22,15 @@ fn io_error(e: std::io::Error) -> Error { } } impl FileMemcard { + fn lock(file: &File) -> Result<(), Error> { + file.try_lock().map_err(|error| match error { + std::fs::TryLockError::WouldBlock => Error::Busy, + std::fs::TryLockError::Error(error) => io_error(error), + }) + } pub fn open(path: &Path, read_only: bool) -> Result { let file = OpenOptions::new().read(true).write(!read_only).open(path).map_err(io_error)?; + Self::lock(&file)?; let length = file.metadata().map_err(io_error)?.len(); Ok(Self { file, length, read_only }) } @@ -47,7 +55,9 @@ impl FileMemcard { .create_new(true) .open(&temporary) .map_err(io_error)?; + let mut published = false; let result = (|| { + Self::lock(&file)?; let mut card = Self { file, length, read_only: false }; let zeros = [0u8; 65_536]; let mut offset = 0; @@ -64,6 +74,7 @@ impl FileMemcard { card.sync()?; // hard_link publishes without replacing a user file; parent sync makes the name durable. std::fs::hard_link(&temporary, path).map_err(io_error)?; + published = true; File::open(parent).and_then(|f| f.sync_all()).map_err(io_error)?; Ok(card) })(); @@ -71,10 +82,10 @@ impl FileMemcard { std::fs::remove_file(&temporary).and_then(|()| File::open(parent)?.sync_all()); match result { Ok(card) => { - cleanup.map_err(io_error)?; + cleanup.map_err(|_| Error::Indeterminate)?; Ok(card) } - Err(e) => Err(e), + Err(e) => Err(if published { Error::Indeterminate } else { e }), } } #[cfg(not(unix))] diff --git a/crates/console/prometeu-firmware/src/firmware/firmware_step_load_cartridge.rs b/crates/console/prometeu-firmware/src/firmware/firmware_step_load_cartridge.rs index 4f100da..bace34c 100644 --- a/crates/console/prometeu-firmware/src/firmware/firmware_step_load_cartridge.rs +++ b/crates/console/prometeu-firmware/src/firmware/firmware_step_load_cartridge.rs @@ -48,6 +48,25 @@ impl LoadCartridgeStep { pub fn needs_memcard_choice(&self) -> bool { self.awaiting_memcard && !self.preparing_memcard } + /// Typed host and UI admission share this single policy boundary. + pub fn choose_memcard( + &mut self, + os: &mut prometeu_system::SystemOS, + choice: prometeu_system::memcard::admission::Choice, + created_at: u64, + ) -> prometeu_system::memcard::image::Result<()> { + if !self.needs_memcard_choice() { + return Err(prometeu_system::memcard::image::Error::InvalidState); + } + os.memcard().choose_for_game( + self.cartridge.app_id, + self.cartridge.memcard_slots.unwrap() as usize, + choice, + created_at, + )?; + self.preparing_memcard = true; + Ok(()) + } pub fn new_game_switch(cartridge: Cartridge) -> Self { Self { failure_recovery: LoadCartridgeFailureRecovery::ReturnToHub, ..Self::new(cartridge) } @@ -128,13 +147,8 @@ impl LoadCartridgeStep { Choice::MemoryExisting }; let created_at = ctx.platform.wall_clock().utc_unix_seconds(); - match ctx.os.memcard().choose_for_game( - self.cartridge.app_id, - self.cartridge.memcard_slots.unwrap() as usize, - choice, - created_at, - ) { - Ok(()) => self.preparing_memcard = true, + match self.choose_memcard(ctx.os, choice, created_at) { + Ok(()) => {} Err(error) => self.memcard_message = Self::preparation_message(error), } } diff --git a/crates/console/prometeu-hal/src/memcard.rs b/crates/console/prometeu-hal/src/memcard.rs index 829a945..7de98e2 100644 --- a/crates/console/prometeu-hal/src/memcard.rs +++ b/crates/console/prometeu-hal/src/memcard.rs @@ -6,6 +6,10 @@ pub enum MemcardIoError { InvalidRange, NoSpace, Unsupported, + Busy, + AccessDenied, + AlreadyExists, + Indeterminate, IoError, } diff --git a/crates/console/prometeu-system/src/os/system_os.rs b/crates/console/prometeu-system/src/os/system_os.rs index c3ef6db..d1ac08a 100644 --- a/crates/console/prometeu-system/src/os/system_os.rs +++ b/crates/console/prometeu-system/src/os/system_os.rs @@ -64,6 +64,14 @@ impl SystemOS { pub fn memcard(&mut self) -> &mut MemcardService { &mut self.memcard } + /// A successful return confirms the shared worker has stopped and joined. + pub fn stop_background_io(&mut self) -> Result<(), crate::AsyncWorkLaneError> { + if let Some(controller) = &mut self.io_controller { + controller.stop()?; + } + self.io_controller = None; + Ok(()) + } /// Host/player operations are admitted only while gameplay is suspended. pub fn replace_memcard( diff --git a/crates/console/prometeu-system/src/services/memcard.rs b/crates/console/prometeu-system/src/services/memcard.rs index 3f9c49e..a58a6ba 100644 --- a/crates/console/prometeu-system/src/services/memcard.rs +++ b/crates/console/prometeu-system/src/services/memcard.rs @@ -2,6 +2,7 @@ //! shared IO worker owns storage during a publication. Legacy per-slot files are //! intentionally neither read nor migrated by this service. pub mod admission; +pub mod diagnostics; pub mod guest; pub mod image; pub mod session; diff --git a/crates/console/prometeu-system/src/services/memcard/admission.rs b/crates/console/prometeu-system/src/services/memcard/admission.rs index a21b433..9220b90 100644 --- a/crates/console/prometeu-system/src/services/memcard/admission.rs +++ b/crates/console/prometeu-system/src/services/memcard/admission.rs @@ -37,6 +37,7 @@ pub struct Admission { pub state: PreparationState, pub snapshot_budget: usize, faulted: bool, + replacement_observation: Option, } impl Default for Admission { fn default() -> Self { @@ -48,10 +49,26 @@ impl Default for Admission { state: PreparationState::Idle, snapshot_budget: DEFAULT_SNAPSHOT_BUDGET, faulted: false, + replacement_observation: None, } } } impl MemcardService { + pub fn session_diagnostics(&self) -> super::diagnostics::SessionDiagnostics { + self.admission.replacement_observation.clone().unwrap_or_else(|| self.session.diagnostics()) + } + pub fn preparation_active(&self) -> bool { + self.admission.receiver.is_some() + } + pub fn installed_card_id(&self) -> Option<[u8; 16]> { + self.admission.installed.as_ref().map(|c| c.current().card_id) + } + pub fn cancel_pending(&mut self) { + self.session.cancel_pending(); + if let Some(control) = &self.admission.control { + control.cancel(); + } + } pub fn host_faulted(&self) -> bool { self.admission.faulted || self.session.host_faulted() } @@ -60,7 +77,11 @@ impl MemcardService { } pub fn installed_health(&self) -> Option<(bool, bool, bool)> { self.admission.installed.as_ref().map(|card| { - (card.recovered, card.degraded, card.write_blocked || card.storage_read_only()) + ( + card.recovered, + card.degraded, + card.write_blocked || card.storage_read_only() || card.uncertain, + ) }) } pub fn card_has_game(&self, app_id: u32) -> bool { @@ -135,6 +156,9 @@ impl MemcardService { let owned = card.catalog.games.iter().find(|g| g.app_id == app_id).map_or(0, |g| g.slots.len()); if choice == Choice::Persistent { + if card.uncertain { + return Err(Error::Indeterminate); + } if card.storage_read_only() || card.write_blocked { return Err(Error::ReadOnly); } @@ -171,6 +195,10 @@ impl MemcardService { } Choice::Persistent => { let mut card = card.take().unwrap(); + if card.uncertain { + session.retain_idle_card(card); + return Err(Error::Indeterminate); + } if card.storage_read_only() || card.write_blocked { session.retain_idle_card(card); return Err(Error::ReadOnly); @@ -256,9 +284,24 @@ impl MemcardService { &mut self, storage: Box, load_existing: bool, + ) -> Result<()> { + self.replace_card_job(move |session, control| { + session.replace_storage(storage, load_existing, control) + }) + } + pub fn reconcile_card_with( + &mut self, + open: impl FnOnce() -> Result> + Send + 'static, + ) -> Result<()> { + self.replace_card_job(move |session, control| session.reconcile_storage_with(open, control)) + } + fn replace_card_job( + &mut self, + operation: impl FnOnce(&mut Session, &PublicationControl) -> Result<()> + Send + 'static, ) -> Result<()> { if self.admission.receiver.is_some() - || self.session.has_in_flight() + || self.session.io_active() + || self.session.has_deferred_write() || self.session.is_boot_active() { return Err(Error::Busy); @@ -266,6 +309,7 @@ impl MemcardService { if self.admission.faulted { return Err(Error::ReadOnly); } + self.admission.replacement_observation = Some(self.session.diagnostics()); let handoff = Arc::new(Mutex::new(Some(std::mem::take(&mut self.session)))); let worker = handoff.clone(); let control = Arc::new(PublicationControl::default()); @@ -275,13 +319,14 @@ impl MemcardService { .lane .submit_memcard_commit_write(move |_| { let mut session = worker.lock().unwrap().take().unwrap(); - let result = session.replace_storage(storage, load_existing, &worker_control); + let result = operation(&mut session, &worker_control); let _ = tx.send(Prepared::Replacement(session, result)); crate::AsyncWorkJobOutcome::Completed }) .is_err() { self.session = handoff.lock().unwrap().take().unwrap(); + self.admission.replacement_observation = None; return Err(Error::InvalidState); } self.admission.control = Some(control); @@ -331,6 +376,7 @@ impl MemcardService { } self.admission.receiver = None; self.admission.control = None; + self.admission.replacement_observation = None; } Err(mpsc::TryRecvError::Disconnected) => { self.admission.state = PreparationState::Failed(Error::InvalidState); @@ -361,3 +407,37 @@ impl MemcardService { } } } + +#[cfg(all(test, unix))] +mod tests { + use super::*; + use prometeu_drivers::memcard::FileMemcard; + use prometeu_hal::memcard::MemcardIoError; + + #[test] + fn idle_uncertain_media_remains_blocked_before_another_persistent_admission() { + let path = std::env::temp_dir().join(format!( + "memcard-uncertain-idle-{}-{}", + std::process::id(), + std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos() + )); + let io = FileMemcard::create(&path, IMAGE_BYTES, |io, id| { + Card::format(io, id).map_err(|_| MemcardIoError::IoError) + }) + .unwrap(); + let mut card = Card::mount(Box::new(io)).unwrap(); + card.uncertain = true; + let mut service = MemcardService::new(); + // An ended session returns its backend to the same installed-card state. + service.admission.installed = Some(card); + assert_eq!(service.installed_health(), Some((false, false, true))); + assert_eq!( + service.choose_for_game(42, 1, Choice::Persistent, 0), + Err(Error::Indeterminate) + ); + assert!(service.card_installed()); + assert_eq!(service.lane.pending_depth(), 0); + service.uninstall_card().unwrap(); + std::fs::remove_file(path).unwrap(); + } +} diff --git a/crates/console/prometeu-system/src/services/memcard/diagnostics.rs b/crates/console/prometeu-system/src/services/memcard/diagnostics.rs new file mode 100644 index 0000000..3bfcd3a --- /dev/null +++ b/crates/console/prometeu-system/src/services/memcard/diagnostics.rs @@ -0,0 +1,31 @@ +//! Read-only native observations. These do not consume the guest request entry. +use super::{ + image::Error, + session::{Mode, RequestResult}, +}; + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct RequestDiagnostics { + pub result: RequestResult, + pub storage_error: Option, + pub slot: Option, + pub operation: &'static str, + pub retained: bool, + pub io_active: bool, + pub deferred: bool, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct SessionDiagnostics { + pub app_id: Option, + pub card_id: Option<[u8; 16]>, + pub epoch: u64, + pub mode: Option, + pub health: (bool, bool, bool), + pub dirty_slots: Vec, + pub request: Option, + pub io_active: bool, + pub removal_pending: bool, + pub reconciliation_required: bool, + pub restart_required: bool, +} diff --git a/crates/console/prometeu-system/src/services/memcard/guest.rs b/crates/console/prometeu-system/src/services/memcard/guest.rs index 470b5a4..de37880 100644 --- a/crates/console/prometeu-system/src/services/memcard/guest.rs +++ b/crates/console/prometeu-system/src/services/memcard/guest.rs @@ -31,12 +31,14 @@ pub fn status(e: Error) -> i64 { use prometeu_hal::memcard::MemcardIoError as I; match e { Error::NoSpace | Error::Io(I::NoSpace) => 3, - Error::AccessDenied => 4, + Error::AccessDenied + | Error::IdentityMismatch + | Error::Io(I::AccessDenied | I::AlreadyExists) => 4, Error::Corrupt => 5, - Error::Indeterminate => 6, + Error::Indeterminate | Error::Io(I::Indeterminate) => 6, Error::Io(I::Unavailable) => 7, Error::InvalidState | Error::Canceled => 8, - Error::Busy => 9, + Error::Busy | Error::Io(I::Busy) => 9, Error::ReadOnly | Error::CounterExhausted | Error::Io(I::ReadOnly) => 10, Error::InvalidRange | Error::Io(I::InvalidRange) => 11, Error::Unsupported | Error::Io(I::Unsupported) => 12, diff --git a/crates/console/prometeu-system/src/services/memcard/image.rs b/crates/console/prometeu-system/src/services/memcard/image.rs index e27780f..449735a 100644 --- a/crates/console/prometeu-system/src/services/memcard/image.rs +++ b/crates/console/prometeu-system/src/services/memcard/image.rs @@ -29,6 +29,7 @@ pub enum Error { OutOfMemory, AccessDenied, InvalidState, + IdentityMismatch, } impl From for Error { fn from(e: MemcardIoError) -> Self { diff --git a/crates/console/prometeu-system/src/services/memcard/session.rs b/crates/console/prometeu-system/src/services/memcard/session.rs index 9b65eef..4f8834a 100644 --- a/crates/console/prometeu-system/src/services/memcard/session.rs +++ b/crates/console/prometeu-system/src/services/memcard/session.rs @@ -71,12 +71,14 @@ struct Request { job: AsyncWorkJobId, released: bool, saves_payload: bool, + worker_returned: bool, } /// Main-lane control; the Card moves into the single worker while its source is protected. #[derive(Default)] pub struct Session { card_id: Option<[u8; 16]>, uncertain_target: Option, + known_card_exclusions: Option<([u8; 16], [bool; BLOCK_COUNT])>, health: (bool, bool, bool), context: u64, epoch: u64, @@ -100,6 +102,82 @@ pub struct Session { deferred: Option<(u64, usize, u64, Instant)>, } impl Session { + /// IO ownership, independent of a completed result retained for guest release. + pub fn io_active(&self) -> bool { + self.request.as_ref().is_some_and(|r| !r.worker_returned) + } + pub fn has_deferred_write(&self) -> bool { + self.deferred.is_some() + } + pub fn cancel_pending(&mut self) { + if let Some(r) = &self.request { + r.control.cancel(); + } + if let Some((id, local, ..)) = self.deferred.take() { + self.slots[local].protected = false; + self.memory_result = Some(RequestResult { + id, + state: RequestState::Failure, + reason: RequestReason::Storage(Error::Canceled), + }); + } + } + pub fn diagnostics(&self) -> super::diagnostics::SessionDiagnostics { + use super::diagnostics::{RequestDiagnostics, SessionDiagnostics}; + let request = if let Some((id, local, ..)) = self.deferred { + Some(RequestDiagnostics { + result: RequestResult { + id, + state: RequestState::Pending, + reason: RequestReason::None, + }, + storage_error: None, + slot: Some(local), + operation: "commit", + retained: true, + io_active: false, + deferred: true, + }) + } else if let Some(r) = &self.request { + Some(RequestDiagnostics { + result: r.result, + storage_error: r.worker_error, + slot: r.saves_payload.then_some(r.local), + operation: if r.saves_payload { "commit" } else { "presentation" }, + retained: !r.released, + io_active: self.io_active(), + deferred: false, + }) + } else { + self.memory_result.map(|result| RequestDiagnostics { + result, + storage_error: None, + slot: None, + operation: "commit", + retained: true, + io_active: false, + deferred: false, + }) + }; + SessionDiagnostics { + app_id: self.mode.map(|_| self.app_id), + card_id: self.card_id, + epoch: self.epoch, + mode: self.mode, + health: self.health(), + dirty_slots: self + .slots + .iter() + .enumerate() + .filter_map(|(i, s)| s.data.read().ok().filter(|s| s.dirty).map(|_| i)) + .collect(), + request, + io_active: self.io_active(), + removal_pending: self.removal_pending, + reconciliation_required: self.reconcile_blocked, + restart_required: self.faulted, + } + } pub fn context(&self) -> u64 { self.context } @@ -531,6 +609,7 @@ impl Session { job, released: !saves_payload, saves_payload, + worker_returned: false, }); Ok(()) } @@ -674,6 +753,7 @@ impl Session { job, released: false, saves_payload: true, + worker_returned: false, }); Ok(id) } @@ -692,6 +772,7 @@ impl Session { let Some(r) = &mut self.request else { return }; match r.receiver.try_recv() { Ok(completion) => { + r.worker_returned = true; r.worker_error = completion.result.error; let current = self.mode.is_some() && r.session == self.context && r.epoch == self.epoch; @@ -819,7 +900,7 @@ impl Session { return Err(Error::Busy); } r.released = true; - if self.card.is_some() { + if r.worker_returned { self.request = None; } Ok(()) @@ -833,7 +914,7 @@ impl Session { r.control.cancel(); r.released = true; } - if self.card.is_some() { + if !self.io_active() { self.request = None; } self.removal_pending = false; @@ -869,7 +950,23 @@ impl Session { load_existing: bool, control: &PublicationControl, ) -> Result<()> { - if self.has_in_flight() || self.boot_active || self.mode.is_none() { + self.replace_storage_with(move || Ok(storage), load_existing, false, control) + } + pub(super) fn reconcile_storage_with( + &mut self, + open: impl FnOnce() -> Result>, + control: &PublicationControl, + ) -> Result<()> { + self.replace_storage_with(open, false, true, control) + } + fn replace_storage_with( + &mut self, + open: impl FnOnce() -> Result>, + load_existing: bool, + same_only: bool, + control: &PublicationControl, + ) -> Result<()> { + if self.io_active() || self.deferred.is_some() || self.boot_active || self.mode.is_none() { return Err(Error::Busy); } if self.icon.is_empty() @@ -882,11 +979,18 @@ impl Session { { self.uncertain_target = card.attempted_publication.clone(); } - let known = self.card.as_ref().map(|c| (c.current().card_id, c.known_exclusions())); + if let Some(card) = &self.card { + self.known_card_exclusions = Some((card.current().card_id, card.known_exclusions())); + } + let known = self.known_card_exclusions; self.card.take(); // Release the old scratch before mounting another image. self.scratch = None; self.reconcile_blocked = true; - self.card = Some(Card::mount(storage)?); + let candidate = Card::mount(open()?)?; + if same_only && self.card_id != Some(candidate.current().card_id) { + return Err(Error::IdentityMismatch); + } + self.card = Some(candidate); let card = self.card.as_mut().unwrap(); let same = self.card_id == Some(card.current().card_id); if let Some((id, known)) = known @@ -973,14 +1077,15 @@ impl Session { Ok(()) } pub fn detach(&mut self) -> Result<()> { - if self.deferred.is_some() - || self - .request - .as_ref() - .is_some_and(|r| r.result.state == RequestState::Pending || self.card.is_none()) - { + if self.deferred.is_some() || self.io_active() { return Err(Error::Busy); } + if self.card.is_none() && self.scratch.is_none() { + let mut scratch = Vec::new(); + scratch.try_reserve_exact(SLOT_BYTES).map_err(|_| Error::OutOfMemory)?; + scratch.resize(SLOT_BYTES, 0); + self.scratch = Some(scratch); + } self.mode = Some(Mode::MemoryOnly); self.removal_pending = false; self.reconcile_blocked = false; diff --git a/crates/dev/prometeu-test-support/src/lib.rs b/crates/dev/prometeu-test-support/src/lib.rs index cecb7a2..5adbe0e 100644 --- a/crates/dev/prometeu-test-support/src/lib.rs +++ b/crates/dev/prometeu-test-support/src/lib.rs @@ -107,4 +107,5 @@ mod tests { } } +pub mod memcard_fixture; pub mod program; diff --git a/crates/dev/prometeu-test-support/src/memcard_fixture.rs b/crates/dev/prometeu-test-support/src/memcard_fixture.rs new file mode 100644 index 0000000..af88c27 --- /dev/null +++ b/crates/dev/prometeu-test-support/src/memcard_fixture.rs @@ -0,0 +1,141 @@ +//! Neutral PBX/ABI fixture. No source-language frontend or compiler is involved. +use crate::program::{TestProgram, scalar_catalog}; +use prometeu_bytecode::{ + assembler::assemble, + model::{ConstantPoolEntry, SyscallDecl}, + registry::*, +}; +use std::collections::BTreeMap; + +#[derive(Clone, Copy)] +pub enum MemcardFixture { + Write, + Read, + Dirty, +} +#[derive(Default)] +struct Code { + bytes: Vec, + labels: BTreeMap<&'static str, u32>, + fixups: Vec<(usize, &'static str)>, +} +impl Code { + fn emit(&mut self, text: &str) { + self.bytes.extend(assemble(text).expect("fixture assembly")); + } + fn mark(&mut self, name: &'static str) { + self.labels.insert(name, self.bytes.len() as u32); + } + fn jump(&mut self, op: &str, name: &'static str) { + self.fixups.push((self.bytes.len() + 2, name)); + self.emit(&format!("{op} 0")); + } + fn check(&mut self, value: i64, int32: bool) { + self.emit(&format!("PUSH_{} {value}\nEQ", if int32 { "I32" } else { "I64" })); + let resume = self.bytes.len() + 8; // conditional jump followed by a terminal trap + self.emit(&format!("JMP_IF_TRUE {resume}\nTRAP")); + } + fn finish(mut self) -> Vec { + for (offset, label) in self.fixups { + self.bytes[offset..offset + 4].copy_from_slice(&self.labels[label].to_le_bytes()); + } + self.bytes + } +} + +/// Stack oracle at a completed frame: 100 pending, 101 durable SUCCESS, +/// 104 MEMORY_ONLY, 201 exact existing readback, 301 dirty/uncommitted RAM. +/// Read never writes or submits a commit; a missing/wrong payload traps. +pub fn memcard_program(kind: MemcardFixture) -> Vec { + let mut main = Code::default(); + main.emit("HOSTCALL 0"); + main.check(0, true); + main.emit("PUSH_I64 4\nARRAY_NEW 9\nSET_GLOBAL 1"); + if matches!(kind, MemcardFixture::Read) { + main.emit("GET_GLOBAL 0\nPUSH_I32 0\nPUSH_I32 0\nGET_GLOBAL 1\nPUSH_I32 0\nPUSH_I32 4\nHOSTCALL 1"); + main.check(4, false); + main.check(0, false); + for (i, value) in [0, 127, 128, 255].into_iter().enumerate() { + main.emit(&format!("GET_GLOBAL 1\nPUSH_I64 {i}\nARRAY_GET 9")); + main.check(value, true); + } + main.mark("done"); + main.emit("PUSH_I64 201\nFRAME_SYNC\nPOP_N 1"); + main.jump("JMP", "done"); + } else { + for (i, value) in [0, 127, 128, 255].into_iter().enumerate() { + main.emit(&format!("GET_GLOBAL 1\nPUSH_I64 {i}\nPUSH_I32 {value}\nARRAY_SET 9")); + } + main.emit("GET_GLOBAL 0\nPUSH_I32 0\nPUSH_I32 0\nGET_GLOBAL 1\nPUSH_I32 0\nPUSH_I32 4\nHOSTCALL 2"); + main.check(4, false); + main.check(0, false); + if matches!(kind, MemcardFixture::Dirty) { + main.mark("done"); + main.emit("PUSH_I64 301\nFRAME_SYNC\nPOP_N 1"); + main.jump("JMP", "done"); + } else { + main.emit("GET_GLOBAL 0\nPUSH_I32 0\nHOSTCALL 3\nSET_GLOBAL 2"); + main.check(0, false); + main.mark("query"); + main.emit("GET_GLOBAL 0\nGET_GLOBAL 2\nHOSTCALL 4\nPOP_N 1\nSET_GLOBAL 3"); + main.check(0, false); + main.emit("GET_GLOBAL 3\nPUSH_I64 100\nADD\nFRAME_SYNC\nPOP_N 1"); + main.jump("JMP", "query"); + } + } + main.mark("error"); + main.emit("TRAP"); + let mut code = main.finish(); + let main_len = code.len() as u32; + let hook = if matches!(kind, MemcardFixture::Read) { + assemble("GET_LOCAL 0\nSET_GLOBAL 0\nPUSH_I32 0\nRET").unwrap() + } else { + assemble("GET_LOCAL 0\nSET_GLOBAL 0\nPUSH_I64 560\nARRAY_NEW 9\nSET_GLOBAL 1\nGET_LOCAL 0\nPUSH_CONST 0\nPUSH_I64 1\nPUSH_I32 1\nPUSH_I32 1\nGET_GLOBAL 1\nPUSH_I32 0\nPUSH_I32 560\nHOSTCALL 1\nPOP_N 1\nPUSH_I32 0\nRET").unwrap() + }; + let hook_len = hook.len() as u32; + code.extend(hook); + let mut types = scalar_catalog(); + types.push(TypeDecl { name: None, kind: TypeKind::Array(TypeId(1)) }); + let mut imports = vec![("bootstrap", 0, 1)]; + if !matches!(kind, MemcardFixture::Read) { + imports.push(("presentation", 8, 1)); + } + match kind { + MemcardFixture::Read => imports.push(("slot_read", 6, 2)), + MemcardFixture::Dirty => imports.push(("slot_write", 6, 2)), + MemcardFixture::Write => { + imports.extend([("slot_write", 6, 2), ("slot_commit", 2, 2), ("query", 2, 3)]) + } + } + let syscalls = imports + .into_iter() + .map(|(name, arg_slots, ret_slots)| SyscallDecl { + module: "mem".into(), + name: name.into(), + version: 1, + arg_slots, + ret_slots, + }) + .collect(); + TestProgram { + const_pool: vec![ConstantPoolEntry::String("Neutral persistence fixture".into())], + code, + functions: vec![ + FunctionDecl { code_len: main_len, max_stack_slots: 32, ..Default::default() }, + FunctionDecl { + lifecycle_role: LifecycleRole::MemcardBoot, + code_offset: main_len, + code_len: hook_len, + max_stack_slots: 32, + signature: Signature { + parameters: vec![NamedType { type_id: TypeId(0), name: None }], + results: vec![TypeId(1)], + }, + ..Default::default() + }, + ], + syscalls, + ..Default::default() + } + .serialize_with_types(types) +} diff --git a/crates/dev/prometeu-test-support/src/program.rs b/crates/dev/prometeu-test-support/src/program.rs index 7861acd..31b6adb 100644 --- a/crates/dev/prometeu-test-support/src/program.rs +++ b/crates/dev/prometeu-test-support/src/program.rs @@ -63,10 +63,13 @@ impl TestProgram { } } pub fn serialize(&self) -> Vec { + self.serialize_with_types(scalar_catalog()) + } + pub fn serialize_with_types(&self, types: Vec) -> Vec { let mut budget = LoadBudget::new(Default::default()); let registry = Registry::resolve( RegistryDeclarations { - types: scalar_catalog(), + types, functions: self.functions.clone(), implementations: vec![], }, diff --git a/crates/host/prometeu-host-headless/src/automation/mod.rs b/crates/host/prometeu-host-headless/src/automation/mod.rs index b6e234e..4b74d2b 100644 --- a/crates/host/prometeu-host-headless/src/automation/mod.rs +++ b/crates/host/prometeu-host-headless/src/automation/mod.rs @@ -2,7 +2,7 @@ mod wire; pub use wire::Limits; -use crate::{AdvanceFrameOutcome, HeadlessHost}; +use crate::{AdvanceFrameOutcome, HeadlessHost, PendingWrites, TeardownPolicy}; use serde_json::{Value, json}; use std::io::{self, BufRead, Write}; use std::sync::{Arc, Mutex, mpsc}; @@ -16,7 +16,8 @@ struct Control { } enum Job { - Work(String, Command), + Work(String, Command, bool), + Shutdown(String, TeardownPolicy, bool, mpsc::Sender), Stop(Option), ReadError(io::Error), } @@ -104,6 +105,7 @@ fn read_commands( limits: &Limits, ) -> io::Result<()> { let mut initialized = false; + let mut memcard = false; loop { let bytes = match read_line(&mut input, limits.max_command_bytes)? { Line::Eof => break, @@ -142,11 +144,26 @@ fn read_commands( continue; } }; - if let Command::Shutdown = command { - let mut c = control.lock().unwrap(); - c.canceled = true; - sender.send(Job::Stop(Some(id))).map_err(|_| io::Error::other("execution stopped"))?; - return Ok(()); + if command.needs_memcard() && !memcard { + output.reply( + Some(&id), + Err(WireError::new( + "unsupported_capability", + "negotiate minor 1.1 and require memcard first", + )), + )?; + continue; + } + if let Command::Shutdown(params) = command { + control.lock().unwrap().canceled = true; + let (tx, rx) = mpsc::channel(); + sender + .send(Job::Shutdown(id, params.policy(), memcard, tx)) + .map_err(|_| io::Error::other("execution stopped"))?; + if rx.recv().map_err(|_| io::Error::other("execution stopped"))? { + return Ok(()); + } + continue; } if let Command::Initialize(params) = command { let result = if initialized { @@ -159,9 +176,17 @@ fn read_commands( .any(|c| !CAPABILITIES.contains(&c.as_str())) { Err(WireError::new("unsupported_capability", "required capability unavailable")) + } else if params.protocol_version.minor == 0 + && params.required_capabilities.iter().any(|c| c == "memcard") + { + Err(WireError::new("incompatible_version", "memcard requires protocol minor >= 1")) } else { initialized = true; - Ok(json!({"protocolVersion":{"major":1,"minor":0},"capabilities":CAPABILITIES})) + memcard = params.protocol_version.minor >= 1 + && params.required_capabilities.iter().any(|c| c == "memcard"); + Ok( + json!({"protocolVersion":{"major":1,"minor":params.protocol_version.minor.min(1)},"capabilities":CAPABILITIES}), + ) }; output.reply(Some(&id), result)?; continue; @@ -197,7 +222,9 @@ fn read_commands( c.active = Some(id.clone()); c.advancing = matches!(command, Command::Advance(_)); c.canceled = false; - sender.send(Job::Work(id, command)).map_err(|_| io::Error::other("execution stopped"))?; + sender + .send(Job::Work(id, command, memcard)) + .map_err(|_| io::Error::other("execution stopped"))?; } let mut c = control.lock().unwrap(); c.canceled = true; @@ -210,14 +237,39 @@ fn execute( id: &str, output: &Output, control: &Mutex, + memcard: bool, ) -> io::Result> { Ok(match command { Command::Boot(p) => { - host.boot(p.path).map(|()| wire::state(host.get_state())).map_err(wire::host_error) + let result = if let Some(choice) = p.memcard_choice { + host.boot_with_memcard_choice(p.path, choice.into()) + } else { + host.boot(p.path) + }; + result.map(|()| wire::state(host.get_state())).map_err(wire::host_error) } - Command::Reset => { - host.reset(); - Ok(wire::state(host.get_state())) + Command::Reset(params) => host + .reset_with_policy(params.policy()) + .map(|snapshot| { + let mut state = wire::state(host.get_state()); + if memcard { + state["memcard"] = json!(snapshot); + } + state + }) + .map_err(wire::host_error), + Command::MemcardMount(p) => { + host.mount_memcard(p).map(|s| json!(s)).map_err(wire::host_error) + } + Command::MemcardUnmount => { + host.unmount_memcard().map(|s| json!(s)).map_err(wire::host_error) + } + Command::GetMemcardState => Ok(json!(host.get_memcard_state())), + Command::MemcardReconcile => { + host.reconcile_memcard().map(|s| json!(s)).map_err(wire::host_error) + } + Command::MemcardContinueInMemory => { + host.continue_memcard_in_memory().map(|s| json!(s)).map_err(wire::host_error) } Command::SetInput(p) => { host.set_input(p.into()); @@ -254,6 +306,10 @@ fn execute( result["stop"] = json!("terminated"); break; } + Ok(AdvanceFrameOutcome::ActionRequired) => { + result["stop"] = json!("action_required"); + break; + } Err(error) => { result["stop"] = json!("host_error"); result["error"] = serde_json::to_value(wire::host_error(error))?; @@ -283,7 +339,7 @@ pub fn serve( let output = Arc::new(Output { writer: Mutex::new(writer), session, limit: limits.max_response_bytes }); output.send( - json!({"type":"hello","sessionId":output.session,"protocolVersion":{"major":1,"minor":0}, + json!({"type":"hello","sessionId":output.session,"protocolVersion":{"major":1,"minor":1}, "runtimeVersion":runtime_version,"capabilities":CAPABILITIES,"limits":limits}), )?; let control = Arc::new(Mutex::new(Control::default())); @@ -298,18 +354,58 @@ pub fn serve( } }); let mut host = HeadlessHost::new(); - while let Ok(job) = receiver.recv() { + loop { + host.poll_memcard(); + let job = match receiver.recv_timeout(std::time::Duration::from_millis(5)) { + Ok(job) => job, + Err(mpsc::RecvTimeoutError::Timeout) => continue, + Err(mpsc::RecvTimeoutError::Disconnected) => break, + }; match job { - Job::Work(id, command) => { - let result = execute(&mut host, command, &id, &output, &control)?; + Job::Work(id, command, memcard) => { + let result = match execute(&mut host, command, &id, &output, &control, memcard) { + Ok(result) => result, + Err(error) => { + cleanup_after_loss(&mut host); + return Err(error); + } + }; // Release authority under the same lock as response publication: // a client reacting to this reply cannot race a stale busy flag. let mut c = control.lock().unwrap(); - output.reply(Some(&id), result)?; + if let Err(error) = output.reply(Some(&id), result) { + drop(c); + cleanup_after_loss(&mut host); + return Err(error); + } c.active = None; c.advancing = false; } + Job::Shutdown(id, policy, memcard, ack) => match host.shutdown(policy) { + Ok(snapshot) => { + drop(host); + let mut value = json!({"closed":true}); + if memcard { + value["memcard"] = json!(snapshot); + } + output.reply(Some(&id), Ok(value))?; + let _ = ack.send(true); + reader.join().map_err(|_| io::Error::other("input reader panicked"))?; + return Ok(()); + } + Err(error) => { + if let Err(error) = output.reply(Some(&id), Err(wire::host_error(error))) { + cleanup_after_loss(&mut host); + return Err(error); + } + let _ = ack.send(false); + } + }, Job::Stop(id) => { + let _ = host.shutdown(TeardownPolicy { + discard_unsaved: true, + pending_writes: PendingWrites::Cancel, + }); drop(host); if let Some(id) = id { output.reply(Some(&id), Ok(json!({"closed":true})))?; @@ -317,13 +413,24 @@ pub fn serve( reader.join().map_err(|_| io::Error::other("input reader panicked"))?; return Ok(()); } - Job::ReadError(error) => return Err(error), + Job::ReadError(error) => { + let _ = host.shutdown(TeardownPolicy { + discard_unsaved: true, + pending_writes: PendingWrites::Cancel, + }); + return Err(error); + } } } reader.join().map_err(|_| io::Error::other("input reader panicked"))?; Ok(()) } +fn cleanup_after_loss(host: &mut HeadlessHost) { + let _ = host + .shutdown(TeardownPolicy { discard_unsaved: true, pending_writes: PendingWrites::Cancel }); +} + #[cfg(test)] mod tests { use super::*; @@ -369,7 +476,7 @@ mod tests { "../../../../../devtools/headless-protocol/requests.json" )) .unwrap(); - assert_eq!(requests.len(), 11); + assert_eq!(requests.len(), 21); for request in requests { wire::parse(serde_json::from_value(request).unwrap()).unwrap(); } diff --git a/crates/host/prometeu-host-headless/src/automation/wire.rs b/crates/host/prometeu-host-headless/src/automation/wire.rs index 14873f1..1a0a4eb 100644 --- a/crates/host/prometeu-host-headless/src/automation/wire.rs +++ b/crates/host/prometeu-host-headless/src/automation/wire.rs @@ -8,7 +8,10 @@ use std::io; #[cfg(test)] mod fault_tests; -use crate::{CapturedFrame, HostError, HostExecutionStatus, HostState}; +use crate::{ + CapturedFrame, HostError, HostExecutionStatus, HostState, MediaAccess, MediaAction, + MemcardChoice, MemcardMount, PendingWrites, TeardownPolicy, +}; pub const CAPABILITIES: &[&str] = &[ "boot", @@ -21,6 +24,12 @@ pub const CAPABILITIES: &[&str] = &[ "get_fault", "cancel", "shutdown", + "memcard", + "memcard_mount", + "memcard_unmount", + "get_memcard_state", + "memcard_reconcile", + "memcard_continue_in_memory", ]; #[derive(Clone, Debug, Serialize)] @@ -95,6 +104,33 @@ pub(super) struct Initialize { #[serde(deny_unknown_fields)] pub(super) struct Boot { pub path: String, + #[serde(default, rename = "memcardChoice", deserialize_with = "present")] + pub memcard_choice: Option, +} + +fn present<'de, D: serde::Deserializer<'de>, T: Deserialize<'de>>( + d: D, +) -> Result, D::Error> { + T::deserialize(d).map(Some) +} +#[derive(Debug, Default, Deserialize)] +#[serde(default, deny_unknown_fields, rename_all = "camelCase")] +pub(super) struct Teardown { + #[serde(deserialize_with = "present")] + pub discard_unsaved: Option, + #[serde(deserialize_with = "present")] + pub pending_writes: Option, +} +impl Teardown { + pub fn explicit(&self) -> bool { + self.discard_unsaved.is_some() || self.pending_writes.is_some() + } + pub fn policy(&self) -> TeardownPolicy { + TeardownPolicy { + discard_unsaved: self.discard_unsaved.unwrap_or(false), + pending_writes: self.pending_writes.unwrap_or_default(), + } + } } #[derive(Debug, Deserialize)] @@ -155,7 +191,12 @@ impl From for InputSignals { pub(super) enum Command { Initialize(Initialize), Boot(Boot), - Reset, + Reset(Teardown), + MemcardMount(MemcardMount), + MemcardUnmount, + GetMemcardState, + MemcardReconcile, + MemcardContinueInMemory, SetInput(Input), ClearInput, Advance(Advance), @@ -163,7 +204,21 @@ pub(super) enum Command { GetState, GetFault, Cancel(Cancel), - Shutdown, + Shutdown(Teardown), +} +impl Command { + pub fn needs_memcard(&self) -> bool { + match self { + Self::MemcardMount(_) + | Self::MemcardUnmount + | Self::GetMemcardState + | Self::MemcardReconcile + | Self::MemcardContinueInMemory => true, + Self::Boot(p) => p.memcard_choice.is_some(), + Self::Reset(p) | Self::Shutdown(p) => p.explicit(), + _ => false, + } + } } fn params(value: Value) -> Result { @@ -192,6 +247,17 @@ pub(super) fn parse(req: Request) -> Result<(String, Command), WireError> { Command::Boot(p) } "advance" => Command::Advance(params(req.params)?), + "reset" => Command::Reset(params(req.params)?), + "shutdown" => Command::Shutdown(params(req.params)?), + "memcard_mount" => { + let p: MemcardMount = params(req.params)?; + if p.path.trim().is_empty() + || matches!((p.action, p.access), (MediaAction::Create, MediaAccess::ReadOnly)) + { + return Err(WireError::new("invalid_params", "invalid media path/action/access")); + } + Command::MemcardMount(p) + } "set_input" => Command::SetInput(params(req.params)?), "cancel" => { let p: Cancel = params(req.params)?; @@ -200,15 +266,25 @@ pub(super) fn parse(req: Request) -> Result<(String, Command), WireError> { } Command::Cancel(p) } - "reset" | "clear_input" | "capture" | "get_state" | "get_fault" | "shutdown" => { + "clear_input" + | "capture" + | "get_state" + | "get_fault" + | "memcard_unmount" + | "get_memcard_state" + | "memcard_reconcile" + | "memcard_continue_in_memory" => { empty(&req.params)?; match req.command.as_str() { - "reset" => Command::Reset, + "memcard_unmount" => Command::MemcardUnmount, + "get_memcard_state" => Command::GetMemcardState, + "memcard_reconcile" => Command::MemcardReconcile, + "memcard_continue_in_memory" => Command::MemcardContinueInMemory, "clear_input" => Command::ClearInput, "capture" => Command::Capture, "get_state" => Command::GetState, "get_fault" => Command::GetFault, - _ => Command::Shutdown, + _ => unreachable!(), } } _ => return Err(WireError::new("unknown_command", "unknown command")), @@ -231,6 +307,9 @@ impl WireError { pub(super) fn host_error(error: HostError) -> WireError { let (code, details) = match &error { + HostError::Memcard(e) => { + ("memcard_error", json!({"operation":e.operation,"reason":e.reason,"state":e.state})) + } HostError::AlreadyBooted => ("already_booted", json!({})), HostError::BootFailed { reason, report } => { ("boot_failed", json!({"reason":reason,"fault":report.as_deref().map(fault)})) diff --git a/crates/host/prometeu-host-headless/src/host.rs b/crates/host/prometeu-host-headless/src/host.rs index b2ebef8..f2674b1 100644 --- a/crates/host/prometeu-host-headless/src/host.rs +++ b/crates/host/prometeu-host-headless/src/host.rs @@ -11,6 +11,12 @@ use prometeu_hal::{ RuntimePlatform, TelemetryPlatform, WallClock, }; use prometeu_system::{CrashReport, LatestRenderFrameStore}; +#[path = "memcard.rs"] +mod memcard; +pub use memcard::{ + MediaAccess, MediaAction, MemcardChoice, MemcardFailure, MemcardMount, MemcardState, + PendingWrites, TeardownPolicy, +}; const BOOT_TICK_LIMIT: usize = 5000; const HOST_FRAME_ADVANCE_TICK_LIMIT: usize = 100_000; @@ -46,6 +52,7 @@ pub enum AdvanceFrameOutcome { FrameCompleted { logical_frame_index: u64, frame_id: FrameId }, Faulted(CrashReport), Terminated, + ActionRequired, } #[derive(Debug, Clone, PartialEq, Eq)] @@ -53,6 +60,7 @@ pub enum AdvanceFramesStop { Completed, Faulted(CrashReport), Terminated, + ActionRequired, } #[derive(Debug, Clone, PartialEq, Eq)] @@ -64,6 +72,7 @@ pub struct AdvanceFramesOutcome { #[derive(Debug, Clone, PartialEq, Eq)] pub enum HostError { + Memcard(Box), AlreadyBooted, BootFailed { reason: String, report: Option> }, InvalidState { operation: &'static str, status: HostExecutionStatus }, @@ -75,6 +84,7 @@ pub enum HostError { impl fmt::Display for HostError { fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { match self { + Self::Memcard(error) => write!(f, "{}: {}", error.operation, error.reason), Self::AlreadyBooted => write!(f, "boot requires reset before another attempt"), Self::BootFailed { reason, .. } => write!(f, "boot failed: {reason}"), Self::InvalidState { operation, status } => { @@ -104,6 +114,7 @@ pub struct HeadlessHost { boot_attempted: bool, last_completed_frame: Option, controlled_wall_clock: Option>, + media: memcard::MediaSelection, } #[derive(Debug, Clone, Copy)] @@ -153,6 +164,7 @@ impl HeadlessHost { boot_attempted: false, last_completed_frame: None, controlled_wall_clock, + media: Default::default(), } } @@ -189,15 +201,20 @@ impl HeadlessHost { return Err(HostError::AlreadyBooted); } self.boot_attempted = true; + self.media.choice = choice; + self.media.boot_phase = "loading"; let path = path.into(); self.firmware.boot_target = BootTarget::Cartridge { path, debug: false, debug_port: 7777 }; let boot_deadline = std::time::Instant::now() + std::time::Duration::from_secs(5); + let mut choice_submitted = false; for _ in 0..BOOT_TICK_LIMIT { if matches!(self.firmware.state, FirmwareState::GameRunning(_)) { + self.media.boot_phase = "running"; return Ok(()); } if matches!(self.firmware.state, FirmwareState::AppCrashes(_)) { + self.media.boot_phase = "failed"; let report = self.get_fault(); let reason = report .as_ref() @@ -206,33 +223,55 @@ impl HeadlessHost { return Err(HostError::BootFailed { reason, report: report.map(Box::new) }); } if matches!(self.firmware.state, FirmwareState::HubHome(_)) { + self.media.boot_phase = "failed"; return Err(HostError::BootFailed { reason: "cartridge did not load".to_string(), report: None, }); } let progress = self.firmware.os.memcard().lane.progress_stamp(); + if let FirmwareState::LoadCartridge(step) = &self.firmware.state + && step.cartridge.memcard_slots.is_none() + && choice.is_some() + { + self.media.boot_phase = "failed"; + return Err(self.memcard_error("boot", "invalid_state")); + } + if choice_submitted + && let prometeu_system::memcard::admission::PreparationState::Failed(error) = + self.firmware.os.memcard().admission.state + { + self.media.boot_phase = "failed"; + return Err(self.memcard_error("boot", memcard::error_name(error))); + } let waiting = matches!(&self.firmware.state,FirmwareState::LoadCartridge(step) if step.needs_memcard_choice()); if waiting { let Some(choice) = choice else { - return Err(HostError::BootFailed { - reason: "Memory-card choice required; use boot_with_memcard_choice".into(), - report: None, - }); + self.media.boot_phase = "choice_required"; + return Err(self.memcard_error("boot", "choice_required")); }; - self.signals = InputSignals::default(); - self.tick_once(); - self.signals = match choice { - prometeu_system::memcard::admission::Choice::Persistent => { - InputSignals { a_signal: true, ..Default::default() } - } - prometeu_system::memcard::admission::Choice::MemoryFresh => { - InputSignals { x_signal: true, ..Default::default() } - } - prometeu_system::memcard::admission::Choice::MemoryExisting => { - InputSignals { y_signal: true, ..Default::default() } + if self.firmware.os.memcard().preparation_active() { + self.poll_memcard(); + self.firmware + .os + .memcard() + .lane + .wait_for_progress(progress, std::time::Duration::from_millis(5)); + continue; + } + let created_at = self.platform.wall_clock().utc_unix_seconds(); + let result = match &mut self.firmware.state { + FirmwareState::LoadCartridge(step) => { + step.choose_memcard(&mut self.firmware.os, choice, created_at) } + _ => unreachable!(), }; + if let Err(error) = result { + self.media.boot_phase = "failed"; + return Err(self.memcard_error("boot", memcard::error_name(error))); + } + choice_submitted = true; + self.media.boot_phase = "preparing"; } self.tick_once(); self.signals = InputSignals::default(); @@ -251,6 +290,7 @@ impl HeadlessHost { if matches!(self.firmware.state, FirmwareState::GameRunning(_)) { Ok(()) } else { + self.media.boot_phase = "failed"; Err(HostError::BootFailed { reason: "boot did not reach the game".to_string(), report: self.get_fault().map(Box::new), @@ -258,7 +298,10 @@ impl HeadlessHost { } } - pub fn reset(&mut self) { + pub fn reset(&mut self) -> Result<(), HostError> { + self.reset_with_policy(TeardownPolicy::default()).map(|_| ()) + } + fn reset_inner(&mut self) { self.signals = InputSignals::default(); self.firmware.change_state( FirmwareState::Reset(ResetStep), @@ -296,7 +339,11 @@ impl HeadlessHost { return Ok(AdvanceFrameOutcome::Faulted(report)); } if !matches!(self.firmware.state, FirmwareState::GameRunning(_)) { - return Ok(AdvanceFrameOutcome::Terminated); + return Ok(if self.host_action_required() { + AdvanceFrameOutcome::ActionRequired + } else { + AdvanceFrameOutcome::Terminated + }); } let start = self.firmware.os.vm().logical_frame_index(); @@ -305,6 +352,11 @@ impl HeadlessHost { self.firmware.os.vm().request_debug_step(); for _ in 0..HOST_FRAME_ADVANCE_TICK_LIMIT { + // A controlled lifecycle slice can consume the runtime step marker + // without closing a logical frame. This operation still owns the + // request until its first frame or an explicit stop boundary. + self.firmware.os.vm().set_paused(false); + self.firmware.os.vm().request_debug_step(); self.tick_once(); if let Some(report) = self.get_fault() { self.finish_frame_advance(); @@ -312,7 +364,11 @@ impl HeadlessHost { } if !matches!(self.firmware.state, FirmwareState::GameRunning(_)) { self.finish_frame_advance(); - return Ok(AdvanceFrameOutcome::Terminated); + return Ok(if self.host_action_required() { + AdvanceFrameOutcome::ActionRequired + } else { + AdvanceFrameOutcome::Terminated + }); } let logical_frame_index = self.firmware.os.vm().logical_frame_index(); @@ -360,6 +416,13 @@ impl HeadlessHost { stop: AdvanceFramesStop::Terminated, }); } + AdvanceFrameOutcome::ActionRequired => { + return Ok(AdvanceFramesOutcome { + requested: count, + completed, + stop: AdvanceFramesStop::ActionRequired, + }); + } } } Ok(AdvanceFramesOutcome { requested: count, completed, stop: AdvanceFramesStop::Completed }) @@ -416,6 +479,8 @@ impl HeadlessHost { fn execution_status(&mut self) -> HostExecutionStatus { if self.fault_is_visible() { HostExecutionStatus::Faulted + } else if self.host_action_required() { + HostExecutionStatus::Paused } else if !matches!(self.firmware.state, FirmwareState::GameRunning(_)) { HostExecutionStatus::Terminated } else if self.firmware.os.vm().paused() { @@ -432,7 +497,9 @@ impl HeadlessHost { fn require_active(&mut self, operation: &'static str) -> Result<(), HostError> { let status = self.execution_status(); - if matches!(status, HostExecutionStatus::Running | HostExecutionStatus::Paused) { + if matches!(status, HostExecutionStatus::Running | HostExecutionStatus::Paused) + && !self.host_action_required() + { Ok(()) } else { Err(HostError::InvalidState { operation, status }) @@ -463,6 +530,11 @@ impl RenderSubmissionSink for HeadlessPlatform { let frame_id = submission.frame_id; let ownership = submission.ownership; self.hardware.submit_render_submission(submission)?; + // Host dialogs use their own producer and may reuse FrameId::ZERO. + // Capture/advance observe only canonical game publications. + if ownership.app_mode != prometeu_hal::app_mode::AppMode::Game { + return Ok(()); + } let (width, height) = self.hardware.gfx.size(); let pixels = self.hardware.gfx.front_buffer().to_vec(); let frame = OwnedRgba8888Frame::packed(frame_id, ownership, width, height, pixels) diff --git a/crates/host/prometeu-host-headless/src/lib.rs b/crates/host/prometeu-host-headless/src/lib.rs index 48e7fdb..0abb9da 100644 --- a/crates/host/prometeu-host-headless/src/lib.rs +++ b/crates/host/prometeu-host-headless/src/lib.rs @@ -11,5 +11,6 @@ mod host; pub use host::{ AdvanceFrameOutcome, AdvanceFramesOutcome, AdvanceFramesStop, CapturedFrame, HeadlessHost, - HostError, HostExecutionStatus, HostState, + HostError, HostExecutionStatus, HostState, MediaAccess, MediaAction, MemcardChoice, + MemcardFailure, MemcardMount, MemcardState, PendingWrites, TeardownPolicy, }; diff --git a/crates/host/prometeu-host-headless/src/memcard.rs b/crates/host/prometeu-host-headless/src/memcard.rs new file mode 100644 index 0000000..7660e59 --- /dev/null +++ b/crates/host/prometeu-host-headless/src/memcard.rs @@ -0,0 +1,480 @@ +//! Public native host controls; all image policy stays in the shared system service. +use super::{HeadlessHost, HostError}; +use prometeu_drivers::memcard::FileMemcard; +use prometeu_firmware::FirmwareState; +use prometeu_hal::memcard::{MemcardIoError, MemcardStorage}; +use prometeu_system::memcard::{ + admission::{Choice, PreparationState}, + image::{Error, IMAGE_BYTES}, + session::{Mode, RequestReason, RequestState}, + transaction::Card, +}; +use serde::{Deserialize, Serialize}; +use std::{ + path::PathBuf, + time::{Duration, Instant}, +}; + +#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, Serialize)] +#[serde(rename_all = "snake_case")] +pub enum MediaAction { + Open, + Create, +} +#[derive(Debug, Clone, Copy, PartialEq, Eq, Deserialize, Serialize)] +#[serde(rename_all = "snake_case")] +pub enum MediaAccess { + ReadWrite, + ReadOnly, +} +#[derive(Debug, Clone, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct MemcardMount { + pub path: String, + pub action: MediaAction, + pub access: MediaAccess, +} +#[derive(Debug, Clone, Copy, Default, Deserialize, Serialize)] +#[serde(rename_all = "snake_case")] +pub enum PendingWrites { + #[default] + Wait, + Cancel, +} +#[derive(Debug, Clone, Copy, Default, Deserialize)] +#[serde(default, deny_unknown_fields, rename_all = "camelCase")] +pub struct TeardownPolicy { + pub discard_unsaved: bool, + pub pending_writes: PendingWrites, +} +#[derive(Debug, Clone, Copy, Deserialize)] +#[serde(rename_all = "snake_case")] +pub enum MemcardChoice { + Persistent, + MemoryFresh, + MemoryExisting, +} +impl From for Choice { + fn from(c: MemcardChoice) -> Self { + match c { + MemcardChoice::Persistent => Self::Persistent, + MemcardChoice::MemoryFresh => Self::MemoryFresh, + MemcardChoice::MemoryExisting => Self::MemoryExisting, + } + } +} +pub(super) fn choice_name(c: Choice) -> &'static str { + match c { + Choice::Persistent => "persistent", + Choice::MemoryFresh => "memory_fresh", + Choice::MemoryExisting => "memory_existing", + } +} +pub(super) fn error_name(e: Error) -> &'static str { + match e { + Error::Io(e) => match e { + MemcardIoError::Unavailable => "unavailable", + MemcardIoError::ReadOnly => "read_only", + MemcardIoError::InvalidRange => "invalid_range", + MemcardIoError::NoSpace => "no_space", + MemcardIoError::Unsupported => "unsupported", + MemcardIoError::Busy => "busy", + MemcardIoError::AccessDenied => "access_denied", + MemcardIoError::AlreadyExists => "already_exists", + MemcardIoError::Indeterminate => "indeterminate", + MemcardIoError::IoError => "io_error", + }, + Error::Corrupt => "corrupt", + Error::Unsupported => "unsupported", + Error::NoSpace => "no_space", + Error::InvalidRange => "invalid_range", + Error::CounterExhausted => "counter_exhausted", + Error::ReadOnly => "read_only", + Error::Indeterminate => "indeterminate", + Error::Busy => "busy", + Error::Canceled => "canceled", + Error::OutOfMemory => "out_of_memory", + Error::AccessDenied => "access_denied", + Error::InvalidState => "invalid_state", + Error::IdentityMismatch => "identity_mismatch", + } +} + +#[derive(Debug, Clone, PartialEq, Eq, Serialize)] +#[serde(rename_all = "camelCase")] +pub struct MemcardState { + pub media: MediaState, + pub session: SessionState, + pub dirty: bool, + pub dirty_slots: Vec, + pub request: Option, + pub io: IoState, + pub recovery: RecoveryState, +} +#[derive(Debug, Clone, PartialEq, Eq, Serialize)] +#[serde(rename_all = "camelCase")] +pub struct MediaState { + pub path: Option, + pub card_id: Option, + pub access: Option, + pub mount_epoch: String, + pub preparation: &'static str, + pub error: Option<&'static str>, + pub recovered: bool, + pub degraded: bool, + pub write_blocked: bool, +} +#[derive(Debug, Clone, PartialEq, Eq, Serialize)] +#[serde(rename_all = "camelCase")] +pub struct SessionState { + pub app_id: Option, + pub choice: Option<&'static str>, + pub mode: Option<&'static str>, + pub boot_attempted: bool, + pub boot_phase: &'static str, + pub resident: bool, + pub action_required: bool, +} +#[derive(Debug, Clone, PartialEq, Eq, Serialize)] +#[serde(rename_all = "camelCase")] +pub struct RequestObservation { + pub id: String, + pub state: &'static str, + pub reason: &'static str, + pub storage_error: Option<&'static str>, + pub operation: &'static str, + pub slot: Option, + pub retained: bool, +} +#[derive(Debug, Clone, PartialEq, Eq, Serialize)] +pub struct IoState { + pub active: bool, + pub deferred: bool, + pub phase: &'static str, +} +#[derive(Debug, Clone, PartialEq, Eq, Serialize)] +#[serde(rename_all = "camelCase")] +pub struct RecoveryState { + pub removal_pending: bool, + pub reconciliation_required: bool, + pub restart_required: bool, +} +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct MemcardFailure { + pub operation: &'static str, + pub reason: &'static str, + pub state: MemcardState, +} +#[derive(Default)] +pub(super) struct MediaSelection { + path: Option, + access: Option, + card_id: Option<[u8; 16]>, + error: Option<&'static str>, + pub choice: Option, + pub boot_phase: &'static str, + shutdown_failed: bool, +} + +impl HeadlessHost { + /// Poll only native work. This does not tick firmware or execute guest code. + pub fn poll_memcard(&mut self) { + self.firmware.os.poll_background_io(&mut self.platform); + } + pub(super) fn memcard_error( + &mut self, + operation: &'static str, + reason: &'static str, + ) -> HostError { + HostError::Memcard(Box::new(MemcardFailure { + operation, + reason, + state: self.get_memcard_state(), + })) + } + pub fn get_memcard_state(&mut self) -> MemcardState { + let resident = self.firmware.os.lifecycle().resident_game_task().is_some(); + let service = self.firmware.os.memcard(); + let d = service.session_diagnostics(); + let preparation = service.preparation_active(); + let host_faulted = service.host_faulted() || self.media.shutdown_failed; + let (state, error) = match service.admission.state { + PreparationState::Idle => ("idle", None), + PreparationState::Pending => ("pending", None), + PreparationState::Ready => ("ready", None), + PreparationState::Failed(e) => ("failed", Some(error_name(e))), + }; + let id = d.card_id.or(service.installed_card_id()).or(self.media.card_id); + let health = if d.mode.is_some() { + d.health + } else { + service.installed_health().unwrap_or((false, false, false)) + }; + let phase = if preparation { + "preparing" + } else if d.request.as_ref().is_some_and(|r| r.deferred) { + "deferred" + } else if d.io_active { + if service.lane.telemetry().active_job_id == service.session.pending_job() { + "running" + } else { + "queued" + } + } else if d.request.is_some() { + "returned" + } else { + "idle" + }; + MemcardState { + media: MediaState { + path: self.media.path.clone(), + access: self.media.access, + card_id: id.map(|id| id.iter().map(|v| format!("{v:02x}")).collect()), + mount_epoch: d.epoch.to_string(), + preparation: state, + error: error.or(self.media.error), + recovered: health.0, + degraded: health.1, + write_blocked: health.2, + }, + session: SessionState { + app_id: d.app_id, + choice: self.media.choice.map(choice_name), + mode: d.mode.map(|m| match m { + Mode::Persistent => "persistent", + Mode::MemoryOnly => "memory_only", + }), + boot_attempted: self.boot_attempted, + boot_phase: if self.media.boot_phase.is_empty() { + "idle" + } else { + self.media.boot_phase + }, + resident, + action_required: d.mode.is_some() + && resident + && (d.removal_pending + || host_faulted + || !matches!(self.firmware.state, FirmwareState::GameRunning(_))), + }, + dirty: !d.dirty_slots.is_empty(), + dirty_slots: d.dirty_slots, + request: d.request.map(|r| RequestObservation { + id: r.result.id.to_string(), + state: match r.result.state { + RequestState::Pending => "pending", + RequestState::Success => "success", + RequestState::Failure => "failure", + RequestState::Indeterminate => "indeterminate", + RequestState::MemoryOnly => "memory_only", + }, + reason: match r.result.reason { + RequestReason::None => "none", + RequestReason::Timeout => "timeout", + RequestReason::RestartRequired => "restart_required", + RequestReason::Storage(e) => error_name(e), + }, + storage_error: r.storage_error.map(error_name), + operation: r.operation, + slot: r.slot, + retained: r.retained, + }), + io: IoState { + active: preparation || d.io_active, + deferred: phase == "deferred", + phase, + }, + recovery: RecoveryState { + removal_pending: d.removal_pending, + reconciliation_required: d.reconciliation_required, + restart_required: host_faulted, + }, + } + } + pub fn mount_memcard(&mut self, options: MemcardMount) -> Result { + self.poll_memcard(); + if self.firmware.os.lifecycle().resident_game_task().is_some() { + return Err(self.memcard_error("memcard_mount", "invalid_state")); + } + if options.path.trim().is_empty() + || matches!( + (options.action, options.access), + (MediaAction::Create, MediaAccess::ReadOnly) + ) + { + return Err(self.memcard_error("memcard_mount", "invalid_state")); + } + let path = std::path::absolute(&options.path) + .map_err(|_| self.memcard_error("memcard_mount", "unavailable"))?; + // Do not change selection when admission is refused as busy. + let open_path = path.clone(); + let result = self.firmware.os.memcard().mount_card_with(move || { + let io = match options.action { + MediaAction::Open => { + FileMemcard::open(&open_path, options.access == MediaAccess::ReadOnly)? + } + MediaAction::Create => FileMemcard::create(&open_path, IMAGE_BYTES, |io, id| { + Card::format(io, id).map_err(|_| MemcardIoError::IoError) + })?, + }; + Ok(Box::new(io) as Box) + }); + result.map_err(|e| self.memcard_error("memcard_mount", error_name(e)))?; + self.media.path = Some(path); + self.media.access = Some(options.access); + self.media.error = None; + self.media.card_id = None; + if let Err(error) = self.wait_preparation("memcard_mount") { + if let HostError::Memcard(e) = &error { + self.media.error = Some(e.reason); + } + return Err(error); + } + self.media.card_id = self.firmware.os.memcard().installed_card_id(); + Ok(self.get_memcard_state()) + } + pub fn unmount_memcard(&mut self) -> Result { + self.poll_memcard(); + if self.firmware.os.lifecycle().resident_game_task().is_some() { + return Err(self.memcard_error("memcard_unmount", "invalid_state")); + } + self.firmware + .os + .memcard() + .uninstall_card() + .map_err(|e| self.memcard_error("memcard_unmount", error_name(e)))?; + self.media = MediaSelection { boot_phase: self.media.boot_phase, ..Default::default() }; + Ok(self.get_memcard_state()) + } + fn wait_preparation(&mut self, operation: &'static str) -> Result<(), HostError> { + let deadline = Instant::now() + Duration::from_secs(2); + loop { + self.poll_memcard(); + match self.firmware.os.memcard().admission.state { + PreparationState::Ready => return Ok(()), + PreparationState::Failed(e) => { + let reason = if self.firmware.os.memcard().host_faulted() { + "restart_required" + } else { + error_name(e) + }; + return Err(self.memcard_error(operation, reason)); + } + _ => {} + } + if Instant::now() >= deadline { + return Err(self.memcard_error(operation, "restart_required")); + } + let lane = self.firmware.os.memcard().lane.clone(); + lane.wait_for_progress(lane.progress_stamp(), Duration::from_millis(5)); + } + } + pub fn prepare_teardown( + &mut self, + policy: TeardownPolicy, + operation: &'static str, + ) -> Result { + self.poll_memcard(); + if matches!(policy.pending_writes, PendingWrites::Cancel) { + self.firmware.os.memcard().cancel_pending(); + } + let deadline = Instant::now() + Duration::from_secs(2); + loop { + self.poll_memcard(); + let state = self.get_memcard_state(); + if !state.io.active && !state.io.deferred { + break; + } + if state.recovery.restart_required || Instant::now() >= deadline { + return Err(self.memcard_error(operation, "restart_required")); + } + let lane = self.firmware.os.memcard().lane.clone(); + lane.wait_for_progress(lane.progress_stamp(), Duration::from_millis(5)); + } + if self.get_memcard_state().dirty && !policy.discard_unsaved { + return Err(self.memcard_error(operation, "unsaved_changes")); + } + Ok(self.get_memcard_state()) + } + pub fn reset_with_policy(&mut self, policy: TeardownPolicy) -> Result { + self.prepare_teardown(policy, "reset")?; + self.reset_inner(); + self.media.choice = None; + self.media.boot_phase = "idle"; + self.poll_memcard(); + Ok(self.get_memcard_state()) + } + pub fn shutdown(&mut self, policy: TeardownPolicy) -> Result { + let state = self.prepare_teardown(policy, "shutdown")?; + if self.firmware.os.stop_background_io().is_err() { + self.media.shutdown_failed = true; + return Err(self.memcard_error("shutdown", "restart_required")); + } + self.firmware.os.memcard().session.end_session(); + self.firmware.os.memcard().poll(Instant::now()); + self.firmware + .os + .memcard() + .uninstall_card() + .map_err(|e| self.memcard_error("shutdown", error_name(e)))?; + Ok(state) + } + pub fn reconcile_memcard(&mut self) -> Result { + self.poll_memcard(); + if !self.suspended_for_memcard() { + return Err(self.memcard_error("memcard_reconcile", "invalid_state")); + } + let path = self + .media + .path + .clone() + .ok_or_else(|| self.memcard_error("memcard_reconcile", "invalid_state"))?; + let read_only = self.media.access == Some(MediaAccess::ReadOnly); + self.firmware + .os + .memcard() + .reconcile_card_with(move || { + Ok(Box::new(FileMemcard::open(&path, read_only)?) as Box) + }) + .map_err(|e| self.memcard_error("memcard_reconcile", error_name(e)))?; + self.wait_preparation("memcard_reconcile")?; + self.media.error = None; + if !self.firmware.resume_resident_game_from_home() { + return Err(self.memcard_error("memcard_reconcile", "invalid_state")); + } + Ok(self.get_memcard_state()) + } + pub fn continue_memcard_in_memory(&mut self) -> Result { + self.poll_memcard(); + if !self.suspended_for_memcard() { + return Err(self.memcard_error("memcard_continue_in_memory", "invalid_state")); + } + self.firmware + .os + .detach_memcard() + .map_err(|e| self.memcard_error("memcard_continue_in_memory", error_name(e)))?; + if !self.firmware.resume_resident_game_from_home() { + return Err(self.memcard_error("memcard_continue_in_memory", "invalid_state")); + } + Ok(self.get_memcard_state()) + } + fn suspended_for_memcard(&mut self) -> bool { + let Some(task) = self.firmware.os.lifecycle().resident_game_task() else { return false }; + self.firmware.os.lifecycle().task_state(task) + == Some(prometeu_system::task::TaskState::Suspended) + && (self.firmware.os.memcard().session.removal_pending() + || self.firmware.os.memcard().session.diagnostics().reconciliation_required + || self.firmware.os.memcard().session.host_faulted()) + } + pub(super) fn host_action_required(&mut self) -> bool { + self.firmware.os.memcard().session.mode().is_some() + && self.firmware.os.lifecycle().resident_game_task().is_some() + && (self.firmware.os.memcard().session.removal_pending() + || self.firmware.os.memcard().host_faulted() + || !matches!(self.firmware.state, FirmwareState::GameRunning(_))) + } +} + +#[cfg(test)] +#[path = "memcard_tests.rs"] +mod tests; diff --git a/crates/host/prometeu-host-headless/src/memcard_tests.rs b/crates/host/prometeu-host-headless/src/memcard_tests.rs new file mode 100644 index 0000000..4056e40 --- /dev/null +++ b/crates/host/prometeu-host-headless/src/memcard_tests.rs @@ -0,0 +1,209 @@ +use super::*; +use crate::{AdvanceFrameOutcome, HostExecutionStatus}; +use prometeu_test_support::memcard_fixture::{MemcardFixture, memcard_program}; +use std::{fs, sync::mpsc}; + +struct Fixture { + root: PathBuf, + image: PathBuf, + cart: PathBuf, +} +impl Fixture { + fn new(kind: MemcardFixture) -> Self { + let root = std::env::temp_dir().join(format!( + "native-memcard-{}-{}", + std::process::id(), + std::time::SystemTime::now().duration_since(std::time::UNIX_EPOCH).unwrap().as_nanos() + )); + let cart = root.join("cart"); + fs::create_dir_all(&cart).unwrap(); + fs::write(cart.join("program.pbx"), memcard_program(kind)).unwrap(); + fs::write(cart.join("manifest.json"),r#"{"magic":"PMTU","cartridge_version":1,"app_id":42,"title":"Native memcard","app_version":"1","app_mode":"Game","capabilities":["memcard"],"memcard_slots":1}"#).unwrap(); + let image = root.join("save.pmc"); + Self { root, image, cart } + } + fn mount(&self, host: &mut HeadlessHost) { + host.mount_memcard(MemcardMount { + path: self.image.to_string_lossy().into_owned(), + action: MediaAction::Create, + access: MediaAccess::ReadWrite, + }) + .unwrap(); + host.boot_with_memcard_choice(self.cart.to_string_lossy(), Choice::Persistent).unwrap(); + } +} +impl Drop for Fixture { + fn drop(&mut self) { + let _ = fs::remove_dir_all(&self.root); + } +} +fn settle(host: &mut HeadlessHost) { + let deadline = Instant::now() + Duration::from_secs(3); + loop { + host.poll_memcard(); + if !host.get_memcard_state().io.active { + break; + } + assert!(Instant::now() < deadline, "IO did not cease"); + let lane = host.firmware.os.memcard().lane.clone(); + lane.wait_for_progress(lane.progress_stamp(), Duration::from_millis(5)); + } +} +fn pause_for_media(host: &mut HeadlessHost) { + let task = host.firmware.os.lifecycle().resident_game_task().unwrap(); + host.firmware.os.lifecycle().suspend_task(task).unwrap(); + assert_eq!( + host.firmware.os.lifecycle().task_state(task), + Some(prometeu_system::task::TaskState::Suspended) + ); +} + +#[test] +fn same_media_recovery_rejects_replacement_and_preserves_ram_continuation() { + let f = Fixture::new(MemcardFixture::Dirty); + let mut host = HeadlessHost::new(); + f.mount(&mut host); + assert!(matches!(host.advance_frame().unwrap(), AdvanceFrameOutcome::FrameCompleted { .. })); + settle(&mut host); + let context = host.firmware.os.memcard().session.context(); + host.firmware.os.memcard().session.notify_removal(); + pause_for_media(&mut host); + assert_eq!(host.get_state().status, HostExecutionStatus::Paused); + assert_eq!(host.advance_frame().unwrap(), AdvanceFrameOutcome::ActionRequired); + let old = f.root.join("old.pmc"); + fs::rename(&f.image, &old).unwrap(); + let replacement = FileMemcard::create(&f.image, IMAGE_BYTES, |io, id| { + Card::format(io, id).map_err(|_| MemcardIoError::IoError) + }) + .unwrap(); + drop(replacement); + let error = host.reconcile_memcard().unwrap_err(); + assert!(matches!(error,HostError::Memcard(e) if e.reason=="identity_mismatch")); + let mut bytes = [0; 4]; + host.firmware.os.memcard().session.read(context, 0, 0, &mut bytes).unwrap(); + assert_eq!(bytes, [0, 127, 128, 255]); + fs::rename(&f.image, f.root.join("other.pmc")).unwrap(); + fs::rename(&old, &f.image).unwrap(); + let restored = host.reconcile_memcard().unwrap(); + assert!(restored.dirty); + assert!(!restored.recovery.reconciliation_required); + assert_eq!(host.firmware.os.memcard().session.context(), context); + assert!(matches!(host.advance_frame().unwrap(), AdvanceFrameOutcome::FrameCompleted { .. })); + assert_eq!(host.get_state().stack_top.last(), Some(&prometeu_bytecode::Value::Int64(301))); + host.shutdown(TeardownPolicy { discard_unsaved: true, ..Default::default() }).unwrap(); +} + +#[test] +fn explicit_continue_in_ram_preserves_dirty_snapshot_and_uses_no_new_boot() { + let f = Fixture::new(MemcardFixture::Dirty); + let mut host = HeadlessHost::new(); + f.mount(&mut host); + host.advance_frame().unwrap(); + settle(&mut host); + let context = host.firmware.os.memcard().session.context(); + host.firmware.os.memcard().session.notify_removal(); + pause_for_media(&mut host); + let ram = host.continue_memcard_in_memory().unwrap(); + assert_eq!(ram.session.mode, Some("memory_only")); + assert!(ram.dirty); + assert_eq!(host.firmware.os.memcard().session.context(), context); + host.advance_frame().unwrap(); + host.shutdown(TeardownPolicy { discard_unsaved: true, ..Default::default() }).unwrap(); +} + +struct GateStore { + file: FileMemcard, + inside_publication: bool, + payload_seen: bool, + fired: bool, + entered: mpsc::Sender<()>, + continue_io: mpsc::Receiver<()>, +} +impl MemcardStorage for GateStore { + fn len(&self) -> Result { + self.file.len() + } + fn read_only(&self) -> bool { + false + } + fn read_at(&mut self, o: u64, b: &mut [u8]) -> Result<(), MemcardIoError> { + self.file.read_at(o, b) + } + fn sync(&mut self) -> Result<(), MemcardIoError> { + self.file.sync() + } + fn write_at(&mut self, o: u64, b: &[u8]) -> Result<(), MemcardIoError> { + let payload = o >= prometeu_system::memcard::image::DATA_OFFSET; + self.payload_seen |= payload; + let publication = self.payload_seen && (o == 8192 || o == 12288); + if !self.fired && if self.inside_publication { publication } else { payload } { + self.fired = true; + if self.inside_publication { + self.file.write_at(o, b)?; + } + self.entered.send(()).unwrap(); + self.continue_io.recv_timeout(Duration::from_secs(10)).unwrap(); + return Err(MemcardIoError::IoError); + } + self.file.write_at(o, b) + } +} + +#[test] +fn unceased_io_retains_lock_and_terminal_result_survives_late_return_and_reconcile() { + for inside_publication in [false, true] { + let f = Fixture::new(MemcardFixture::Write); + let file = FileMemcard::create(&f.image, IMAGE_BYTES, |io, id| { + Card::format(io, id).map_err(|_| MemcardIoError::IoError) + }) + .unwrap(); + let (entered_tx, entered) = mpsc::channel(); + let (continue_io, release_rx) = mpsc::channel(); + let mut host = HeadlessHost::new(); + host.media.path = Some(f.image.clone()); + host.media.access = Some(MediaAccess::ReadWrite); + host.install_memcard(Box::new(GateStore { + file, + inside_publication, + payload_seen: false, + fired: false, + entered: entered_tx, + continue_io: release_rx, + })) + .unwrap(); + host.boot_with_memcard_choice(f.cart.to_string_lossy(), Choice::Persistent).unwrap(); + host.advance_frame().unwrap(); + entered.recv_timeout(Duration::from_secs(3)).unwrap(); + host.firmware.os.memcard().poll(Instant::now() + Duration::from_secs(2)); + let before = host.get_memcard_state(); + assert!(before.io.active); + assert!(before.recovery.restart_required); + assert_eq!( + before.request.as_ref().unwrap().state, + if inside_publication { "indeterminate" } else { "failure" } + ); + assert!( + matches!(host.shutdown(TeardownPolicy{discard_unsaved:true,..Default::default()}),Err(HostError::Memcard(e)) if e.reason=="restart_required") + ); + assert!(matches!(FileMemcard::open(&f.image, false), Err(MemcardIoError::Busy))); + continue_io.send(()).unwrap(); + settle(&mut host); + let returned = host.get_memcard_state().request; + let original = before.request.as_ref().unwrap(); + let late = returned.as_ref().unwrap(); + assert_eq!( + (&late.id, late.state, late.reason), + (&original.id, original.state, original.reason), + "late completion cannot rewrite the original result" + ); + assert_eq!(late.storage_error, Some("io_error")); + pause_for_media(&mut host); + let restored = host.reconcile_memcard().unwrap(); + assert_eq!( + restored.request, returned, + "recovery must not consume or rewrite the guest result" + ); + assert!(!restored.recovery.restart_required); + host.shutdown(TeardownPolicy { discard_unsaved: true, ..Default::default() }).unwrap(); + } +} diff --git a/crates/host/prometeu-host-headless/src/resource_qualification_tests.rs b/crates/host/prometeu-host-headless/src/resource_qualification_tests.rs index 2beeb79..b1cc321 100644 --- a/crates/host/prometeu-host-headless/src/resource_qualification_tests.rs +++ b/crates/host/prometeu-host-headless/src/resource_qualification_tests.rs @@ -61,7 +61,7 @@ fn thousand_reset_reload_cycles_release_session_owners_and_preserve_controls() { )); assert_eq!(&*host.get_state().stack_top, &[Value::Int32(73)]); assert!(host.get_fault().is_none()); - host.reset(); + host.reset().expect("reset"); assert_eq!(host.firmware.os.sessions().vm_session_count(), 0); assert_eq!( observer.diagnostic_snapshot().used, diff --git a/crates/host/prometeu-host-headless/tests/deterministic_control.rs b/crates/host/prometeu-host-headless/tests/deterministic_control.rs index c306444..e41abc4 100644 --- a/crates/host/prometeu-host-headless/tests/deterministic_control.rs +++ b/crates/host/prometeu-host-headless/tests/deterministic_control.rs @@ -37,7 +37,7 @@ fn controlled_civil_time_is_independent_of_frames_pause_and_reset() { host.controlled_wall_clock().unwrap().set(10); host.advance_frame().expect("frame after clock adjustment"); assert_eq!(host.wall_clock().utc_unix_seconds(), 10); - host.reset(); + host.reset().expect("reset"); assert_eq!(host.wall_clock().utc_unix_seconds(), 10); host.boot(&cartridge).expect("reboot"); assert_eq!(host.wall_clock().utc_unix_seconds(), 10); @@ -57,7 +57,7 @@ fn injected_civil_clock_remains_the_runtime_source_across_lifecycle() { assert_eq!(host.wall_clock().utc_unix_seconds(), u64::MAX); clock.set(42); assert_eq!(host.wall_clock().utc_unix_seconds(), 42); - host.reset(); + host.reset().expect("reset"); clock.advance(3); assert_eq!(host.wall_clock().utc_unix_seconds(), 45); } @@ -290,7 +290,7 @@ fn two_runs_match_oracle() { fn reset_matches_fresh_host() { let mut host = boot_color(); let _ = run_on(&mut host); - host.reset(); + host.reset().expect("reset"); assert_eq!(host.get_state().status, HostExecutionStatus::Terminated); assert_eq!(host.capture_frame(), Err(HostError::NoFrameAvailable)); host.boot(color_cartridge()).expect("reboot"); @@ -357,7 +357,7 @@ fn batch_stops_early_on_fault_and_reports_partial_progress() { #[test] fn advance_after_reset_reports_termination_without_ticking() { let mut host = boot_color(); - host.reset(); + host.reset().expect("reset"); let before = host.get_state().tick_index; assert_eq!(host.advance_frame().expect("termination outcome"), AdvanceFrameOutcome::Terminated); diff --git a/crates/tools/prometeu-cli/src/lib.rs b/crates/tools/prometeu-cli/src/lib.rs index 12df0bd..2d5151c 100644 --- a/crates/tools/prometeu-cli/src/lib.rs +++ b/crates/tools/prometeu-cli/src/lib.rs @@ -2,6 +2,28 @@ use clap::Args; use prometeu_host_headless::automation::Limits; +#[derive(Args, Debug)] +pub struct DesktopMediaArgs { + /// Explicit memory-card image used by the desktop host. + #[arg(long, value_name = "PATH")] + pub memcard: Option, + /// Create a new image; never replace an existing destination. + #[arg(long, requires = "memcard")] + pub create_memcard: bool, +} +impl DesktopMediaArgs { + pub fn forwarded_args(&self) -> Vec { + let mut args = Vec::new(); + if let Some(path) = &self.memcard { + args.extend(["--memcard".into(), path.clone()]); + } + if self.create_memcard { + args.push("--create-memcard".into()); + } + args + } +} + #[derive(Args, Debug)] pub struct HeadlessArgs { /// Use the versioned JSONL stdin/stdout protocol (required). diff --git a/crates/tools/prometeu-cli/src/main.rs b/crates/tools/prometeu-cli/src/main.rs index cf4a633..8d86857 100644 --- a/crates/tools/prometeu-cli/src/main.rs +++ b/crates/tools/prometeu-cli/src/main.rs @@ -25,6 +25,8 @@ enum Commands { Run { /// Path to the cartridge (directory or .pmc file). cart: String, + #[command(flatten)] + media: prometeu_cli::DesktopMediaArgs, }, /// Executes a cartridge in Assisted Mode (Debug). /// The runtime will wait for a DevTools connection before starting. @@ -34,6 +36,8 @@ enum Commands { /// TCP port for the DevTools server (default: 7777). #[arg(long, default_value_t = 7777)] port: u16, + #[command(flatten)] + media: prometeu_cli::DesktopMediaArgs, }, } @@ -72,15 +76,17 @@ fn main() { let borrowed: Vec<&str> = args.iter().map(String::as_str).collect(); dispatch(&exe_dir, "prometeu-headless", &borrowed); } - Some(Commands::Run { cart }) => { - dispatch(&exe_dir, "prometeu-runtime", &["--run", &cart]); + Some(Commands::Run { cart, media }) => { + let mut args = vec!["--run".into(), cart]; + args.extend(media.forwarded_args()); + let borrowed: Vec<&str> = args.iter().map(String::as_str).collect(); + dispatch(&exe_dir, "prometeu-runtime", &borrowed); } - Some(Commands::Debug { cart, port }) => { - dispatch( - &exe_dir, - "prometeu-runtime", - &["--debug", &cart, "--port", &port.to_string()], - ); + Some(Commands::Debug { cart, port, media }) => { + let mut args = vec!["--debug".into(), cart, "--port".into(), port.to_string()]; + args.extend(media.forwarded_args()); + let borrowed: Vec<&str> = args.iter().map(String::as_str).collect(); + dispatch(&exe_dir, "prometeu-runtime", &borrowed); } None => { use clap::CommandFactory; diff --git a/crates/tools/prometeu-cli/tests/automation_process.rs b/crates/tools/prometeu-cli/tests/automation_process.rs index 6791c87..0bff9b1 100644 --- a/crates/tools/prometeu-cli/tests/automation_process.rs +++ b/crates/tools/prometeu-cli/tests/automation_process.rs @@ -16,6 +16,8 @@ use std::sync::{ mpsc, }; use std::time::{Duration, Instant}; +#[path = "support/memcard_process.rs"] +mod memcard_process; struct TempDir(PathBuf); impl TempDir { @@ -241,7 +243,7 @@ fn png_bytes(capture: &Value) -> Vec { fn handshake_versions_capabilities_and_limits_are_explicit() { let mut c = Client::new(&["--stdio"]); assert_eq!(c.hello["runtimeVersion"], env!("CARGO_PKG_VERSION")); - assert_eq!(c.hello["protocolVersion"], json!({"major":1,"minor":0})); + assert_eq!(c.hello["protocolVersion"], json!({"major":1,"minor":1})); assert_eq!( c.hello["limits"], json!({"maxFrames":600,"maxCommandBytes":65536,"maxResponseBytes":33554432, @@ -267,7 +269,7 @@ fn handshake_versions_capabilities_and_limits_are_explicit() { "initialize", json!({"protocolVersion":{"major":1,"minor":42},"requiredCapabilities":[]}) )["protocolVersion"]["minor"], - 0 + 1 ); assert_eq!( c.call( diff --git a/crates/tools/prometeu-cli/tests/support/memcard_process.rs b/crates/tools/prometeu-cli/tests/support/memcard_process.rs new file mode 100644 index 0000000..a0b70d9 --- /dev/null +++ b/crates/tools/prometeu-cli/tests/support/memcard_process.rs @@ -0,0 +1,355 @@ +use super::*; +use prometeu_test_support::memcard_fixture::{MemcardFixture, memcard_program}; + +fn card(kind: MemcardFixture, version: &str) -> TempDir { + let dir = TempDir::new(); + fs::write(dir.0.join("program.pbx"), memcard_program(kind)).unwrap(); + fs::write( + dir.0.join("manifest.json"), + serde_json::to_vec(&json!({ + "magic":"PMTU","cartridge_version":1,"app_id":4294967295u32, + "title":"Neutral persistence","app_version":version,"app_mode":"Game", + "capabilities":["memcard"],"memcard_slots":1 + })) + .unwrap(), + ) + .unwrap(); + dir +} +fn start_at(binary: &Path) -> Client { + let mut c = Client::spawn(binary, &["headless", "--stdio"], Some(&std::env::temp_dir())); + c.ok( + "initialize", + json!({"protocolVersion":{"major":1,"minor":1},"requiredCapabilities":["memcard"]}), + ); + c +} +fn start() -> Client { + start_at(Path::new(env!("CARGO_BIN_EXE_prometeu"))) +} +fn mount(c: &mut Client, path: &Path, action: &str, access: &str) -> Value { + c.ok("memcard_mount", json!({"path":path,"action":action,"access":access})) +} +fn launch(c: &mut Client, dir: &TempDir, choice: &str) { + c.ok("boot", json!({"path":dir.0,"memcardChoice":choice})); +} +fn oracle(c: &mut Client, expected: i64) { + let deadline = Instant::now() + Duration::from_secs(5); + loop { + let advance = c.ok("advance", json!({"frames":1})); + assert_eq!( + advance["stop"], + "completed", + "{advance}; state={}; mem={}; fault={}", + c.ok("get_state", json!({})), + c.ok("get_memcard_state", json!({})), + c.ok("get_fault", json!({})) + ); + let state = c.ok("get_state", json!({})); + let top = state["stackTop"].as_array().unwrap(); + if top.last().and_then(|v| v["value"].as_str()) == Some(&expected.to_string()) { + return; + } + assert!(Instant::now() < deadline, "oracle {expected} not reached: {state}"); + } +} +fn reason(c: &mut Client, command: &str, params: Value, expected: &str) -> Value { + let error = c.call(command, params)["error"].clone(); + assert_eq!(error["code"], "memcard_error", "{error}"); + assert_eq!(error["details"]["reason"], expected, "{error}"); + error["details"]["state"].clone() +} +fn persistence(binary: &Path) { + let root = TempDir::new(); + let image = root.0.join("save.pmc"); + let write = card(MemcardFixture::Write, "1"); + let mut first = start_at(binary); + let mounted = mount(&mut first, &image, "create", "read_write"); + assert_eq!(mounted["media"]["cardId"].as_str().unwrap().len(), 32); + launch(&mut first, &write, "persistent"); + oracle(&mut first, 101); + let saved = first.ok("get_memcard_state", json!({})); + assert_eq!(saved["request"]["state"], "success"); + assert_eq!(saved["request"]["retained"], true); + assert_eq!(saved["dirty"], false); + assert_eq!(saved["io"]["active"], false); + first.close(); + let bytes = fs::read(&image).unwrap(); + for version in ["1", "2"] { + let read = card(MemcardFixture::Read, version); + let mut next = start_at(binary); + mount(&mut next, &image, "open", "read_write"); + launch(&mut next, &read, "persistent"); + oracle(&mut next, 201); + assert_eq!(next.ok("get_state", json!({}))["appId"], 4294967295u32); + assert_eq!( + next.ok("get_memcard_state", json!({}))["request"], + Value::Null, + "reader must not submit a save" + ); + next.close(); + assert!(fs::read(&image).unwrap() == bytes, "readback must not rewrite the image"); + } + let read = card(MemcardFixture::Read, "2"); + let mut memory = start_at(binary); + mount(&mut memory, &image, "open", "read_only"); + reason(&mut memory, "boot", json!({"path":read.0,"memcardChoice":"persistent"}), "read_only"); + memory.ok("reset", json!({})); + launch(&mut memory, &read, "memory_existing"); + oracle(&mut memory, 201); + assert_eq!(memory.ok("get_memcard_state", json!({}))["session"]["mode"], "memory_only"); + memory.close(); + assert!(fs::read(&image).unwrap() == bytes); +} + +#[test] +fn memcard_public_distinct_process_save_readback_and_version_identity() { + persistence(Path::new(env!("CARGO_BIN_EXE_prometeu"))); +} +#[test] +#[ignore = "requires PROMETEU_PROTOCOL_TEST_INSTALL pointing to an extracted dist archive"] +fn packaged_memcard_process_persistence() { + let installation = PathBuf::from( + std::env::var_os("PROMETEU_PROTOCOL_TEST_INSTALL").expect("extracted distribution"), + ); + persistence(&installation.join("prometeu")); +} +#[test] +fn memcard_dirty_refusal_retains_channel_and_explicit_ram_has_no_save() { + let dirty = card(MemcardFixture::Dirty, "1"); + let mut c = start(); + launch(&mut c, &dirty, "memory_fresh"); + oracle(&mut c, 301); + for command in ["shutdown", "reset"] { + let state = reason(&mut c, command, json!({}), "unsaved_changes"); + assert_eq!(state["dirty"], true); + assert_eq!(state["session"]["resident"], true); + assert_eq!(c.ok("get_state", json!({}))["appId"], 4294967295u32); + } + let reset = c.ok("reset", json!({"discardUnsaved":true,"pendingWrites":"cancel"})); + assert_eq!(reset["memcard"]["dirty"], false); + let write = card(MemcardFixture::Write, "1"); + launch(&mut c, &write, "memory_fresh"); + oracle(&mut c, 104); + let state = c.ok("get_memcard_state", json!({})); + assert_eq!(state["request"]["state"], "memory_only"); + assert_eq!(state["dirty"], true); + assert_eq!(state["io"]["active"], false); + assert_eq!(state["media"]["path"], Value::Null); + c.ok("shutdown", json!({"discardUnsaved":true})); + c.wait_exit(); +} +#[test] +fn memcard_media_errors_and_negotiation_never_select_a_fallback() { + let root = TempDir::new(); + let missing = root.0.join("missing.pmc"); + let mut old = Client::new(&["--stdio"]); + old.initialize(); + assert_eq!( + old.call("memcard_mount", json!({"path":missing,"action":"create","access":"read_write"})) + ["error"]["code"], + "unsupported_capability" + ); + assert!(!missing.exists()); + old.close(); + let mut c = Client::new(&["--stdio"]); + assert_eq!( + c.call( + "initialize", + json!({"protocolVersion":{"major":1,"minor":0},"requiredCapabilities":["memcard"]}) + )["error"]["code"], + "incompatible_version" + ); + c.ok( + "initialize", + json!({"protocolVersion":{"major":1,"minor":1},"requiredCapabilities":["memcard"]}), + ); + reason( + &mut c, + "memcard_mount", + json!({"path":missing,"action":"open","access":"read_write"}), + "unavailable", + ); + assert!(!missing.exists()); + let cart = card(MemcardFixture::Write, "1"); + reason(&mut c, "boot", json!({"path":cart.0}), "choice_required"); + assert_eq!(c.ok("get_state", json!({}))["logicalFrameIndex"], 0); + c.ok("reset", json!({})); + let corrupt = root.0.join("corrupt.pmc"); + let mut bytes = vec![0; 5_259_264]; + bytes[..8].copy_from_slice(b"PMCARD1\0"); + bytes[8] = 1; + fs::write(&corrupt, &bytes).unwrap(); + reason( + &mut c, + "memcard_mount", + json!({"path":corrupt,"action":"open","access":"read_write"}), + "corrupt", + ); + assert!(fs::read(&corrupt).unwrap() == bytes); + assert_eq!(c.ok("get_memcard_state", json!({}))["session"]["mode"], Value::Null); + c.close(); +} +#[cfg(unix)] +#[test] +fn memcard_process_ownership_covers_aliases_readers_and_release() { + let root = TempDir::new(); + let image = root.0.join("save.pmc"); + let hard = root.0.join("hard.pmc"); + let sym = root.0.join("sym.pmc"); + let mut owner = start(); + mount(&mut owner, &image, "create", "read_write"); + fs::hard_link(&image, &hard).unwrap(); + std::os::unix::fs::symlink(&image, &sym).unwrap(); + let bytes = fs::read(&image).unwrap(); + let mut contender = start(); + for path in [&image, &hard, &sym] { + for access in ["read_only", "read_write"] { + reason( + &mut contender, + "memcard_mount", + json!({"path":path,"action":"open","access":access}), + "busy", + ); + } + } + reason( + &mut contender, + "memcard_mount", + json!({"path":image,"action":"create","access":"read_write"}), + "already_exists", + ); + assert!(fs::read(&image).unwrap() == bytes); + owner.ok("memcard_unmount", json!({})); + mount(&mut contender, &image, "open", "read_only"); + reason( + &mut owner, + "memcard_mount", + json!({"path":image,"action":"open","access":"read_only"}), + "busy", + ); + contender.close(); + mount(&mut owner, &image, "open", "read_write"); + owner.close(); +} + +#[cfg(unix)] +#[test] +fn memcard_creation_race_and_process_death_release_real_ownership() { + let root = TempDir::new(); + let image = root.0.join("race.pmc"); + // Kill the actual storage-owning process rather than its dispatcher parent. + let mut a = Client::new(&["--stdio"]); + let mut b = Client::new(&["--stdio"]); + for c in [&mut a, &mut b] { + c.ok( + "initialize", + json!({"protocolVersion":{"major":1,"minor":1},"requiredCapabilities":["memcard"]}), + ); + } + let params = json!({"path":image,"action":"create","access":"read_write"}); + let aid = a.send("memcard_mount", params.clone()); + let bid = b.send("memcard_mount", params); + let ar = a.response(&aid); + let br = b.response(&bid); + assert_ne!( + ar.get("result").is_some(), + br.get("result").is_some(), + "exactly one creator must win" + ); + let (winner, loser, error) = + if ar.get("result").is_some() { (&mut a, &mut b, br) } else { (&mut b, &mut a, ar) }; + assert_eq!(error["error"]["details"]["reason"], "already_exists"); + let before = fs::read(&image).unwrap(); + winner.child.kill().unwrap(); + winner.child.wait().unwrap(); + mount(loser, &image, "open", "read_write"); + loser.close(); + assert!(fs::read(&image).unwrap() == before); +} + +#[cfg(unix)] +#[test] +fn memcard_access_denial_is_typed_and_does_not_create_or_modify_media() { + use std::os::unix::fs::PermissionsExt; + let root = TempDir::new(); + let image = root.0.join("denied.pmc"); + let mut creator = start(); + mount(&mut creator, &image, "create", "read_write"); + creator.close(); + let before = fs::read(&image).unwrap(); + fs::set_permissions(&image, fs::Permissions::from_mode(0o0)).unwrap(); + let mut c = start(); + reason( + &mut c, + "memcard_mount", + json!({"path":image,"action":"open","access":"read_write"}), + "access_denied", + ); + c.close(); + fs::set_permissions(&image, fs::Permissions::from_mode(0o600)).unwrap(); + assert!(fs::read(&image).unwrap() == before); +} + +#[cfg(unix)] +#[test] +fn desktop_dispatch_forwards_explicit_media_without_interpreting_player_policy() { + use std::os::unix::fs::PermissionsExt; + let installation = TempDir::new(); + let dispatcher = installation.0.join("prometeu"); + fs::copy(env!("CARGO_BIN_EXE_prometeu"), &dispatcher).unwrap(); + let runtime = installation.0.join("prometeu-runtime"); + fs::write(&runtime, "#!/bin/sh\nprintf '%s\\n' \"$@\"\n").unwrap(); + fs::set_permissions(&runtime, fs::Permissions::from_mode(0o755)).unwrap(); + for command in ["run", "debug"] { + let output = Command::new(&dispatcher) + .args([command, "cartridge", "--memcard", "image with spaces.pmc", "--create-memcard"]) + .output() + .unwrap(); + assert!(output.status.success()); + let actual = String::from_utf8(output.stdout).unwrap(); + let mut expected = vec![format!("--{command}"), "cartridge".into()]; + if command == "debug" { + expected.extend(["--port".into(), "7777".into()]); + } + expected.extend([ + "--memcard".into(), + "image with spaces.pmc".into(), + "--create-memcard".into(), + ]); + assert_eq!(actual.lines().collect::>(), expected); + } + assert!( + !Command::new(&dispatcher) + .args(["run", "cartridge", "--create-memcard"]) + .output() + .unwrap() + .status + .success() + ); +} +#[test] +fn memcard_idle_observation_never_advances_guest_counters() { + let root = TempDir::new(); + let image = root.0.join("save.pmc"); + let cart = card(MemcardFixture::Write, "1"); + let mut c = start(); + mount(&mut c, &image, "create", "read_write"); + launch(&mut c, &cart, "persistent"); + c.ok("advance", json!({"frames":1})); + let before = c.ok("get_state", json!({})); + let deadline = Instant::now() + Duration::from_secs(3); + loop { + let state = c.ok("get_memcard_state", json!({})); + if !state["io"]["active"].as_bool().unwrap() { + assert_eq!(state["request"]["state"], "success"); + break; + } + assert!(Instant::now() < deadline); + } + let after = c.ok("get_state", json!({})); + for field in ["pc", "logicalFrameIndex", "tickIndex", "stackTop"] { + assert_eq!(before[field], after[field], "{field}"); + } + c.close(); +} diff --git a/devtools/headless-protocol/invalid-requests.json b/devtools/headless-protocol/invalid-requests.json index d1de3ca..b3dfe93 100644 --- a/devtools/headless-protocol/invalid-requests.json +++ b/devtools/headless-protocol/invalid-requests.json @@ -45,5 +45,59 @@ "requestId": "null-params", "command": "get_state", "params": null + }, + { + "requestId": "bad-mem-8", + "command": "memcard_mount", + "params": { + "path": "x", + "action": "create", + "access": "read_only" + } + }, + { + "requestId": "bad-mem-9", + "command": "memcard_mount", + "params": { + "path": "x", + "action": "open" + } + }, + { + "requestId": "bad-mem-10", + "command": "boot", + "params": { + "path": "x", + "memcardChoice": null + } + }, + { + "requestId": "bad-mem-11", + "command": "boot", + "params": { + "path": "x", + "memcardChoice": "auto" + } + }, + { + "requestId": "bad-mem-12", + "command": "shutdown", + "params": { + "discardUnsaved": null + } + }, + { + "requestId": "bad-mem-13", + "command": "reset", + "params": { + "pendingWrites": "save" + } + }, + { + "requestId": "bad-mem-14", + "command": "get_memcard_state", + "params": { + "anything": true + } } ] diff --git a/devtools/headless-protocol/request.schema.json b/devtools/headless-protocol/request.schema.json index 1ab40ce..890be0f 100644 --- a/devtools/headless-protocol/request.schema.json +++ b/devtools/headless-protocol/request.schema.json @@ -1,7 +1,7 @@ { "$schema": "https://json-schema.org/draft/2020-12/schema", "$id": "https://prometeu.dev/headless/v1/request.schema.json", - "title": "Prometeu Headless v1 Request", + "title": "Prometeu Headless v1.1 Request", "type": "object", "additionalProperties": false, "required": [ @@ -65,6 +65,13 @@ "type": "string", "minLength": 1, "pattern": "\\S" + }, + "memcardChoice": { + "enum": [ + "persistent", + "memory_fresh", + "memory_existing" + ] } } } @@ -129,7 +136,19 @@ }, "params": { "type": "object", - "maxProperties": 0 + "properties": { + "discardUnsaved": { + "type": "boolean" + }, + "pendingWrites": { + "enum": [ + "wait", + "cancel" + ] + } + }, + "required": [], + "additionalProperties": false } } }, @@ -184,7 +203,120 @@ }, "params": { "type": "object", - "maxProperties": 0 + "properties": { + "discardUnsaved": { + "type": "boolean" + }, + "pendingWrites": { + "enum": [ + "wait", + "cancel" + ] + } + }, + "required": [], + "additionalProperties": false + } + } + }, + { + "properties": { + "command": { + "const": "memcard_mount" + }, + "params": { + "type": "object", + "properties": { + "path": { + "type": "string", + "minLength": 1, + "pattern": "\\S" + }, + "action": { + "enum": [ + "open", + "create" + ] + }, + "access": { + "enum": [ + "read_write", + "read_only" + ] + } + }, + "required": [ + "path", + "action", + "access" + ], + "additionalProperties": false, + "not": { + "properties": { + "action": { + "const": "create" + }, + "access": { + "const": "read_only" + } + }, + "required": [ + "action", + "access" + ] + } + } + } + }, + { + "properties": { + "command": { + "const": "memcard_unmount" + }, + "params": { + "type": "object", + "properties": {}, + "required": [], + "additionalProperties": false + } + } + }, + { + "properties": { + "command": { + "const": "get_memcard_state" + }, + "params": { + "type": "object", + "properties": {}, + "required": [], + "additionalProperties": false + } + } + }, + { + "properties": { + "command": { + "const": "memcard_reconcile" + }, + "params": { + "type": "object", + "properties": {}, + "required": [], + "additionalProperties": false + } + } + }, + { + "properties": { + "command": { + "const": "memcard_continue_in_memory" + }, + "params": { + "type": "object", + "properties": {}, + "required": [], + "additionalProperties": false } } } diff --git a/devtools/headless-protocol/requests.json b/devtools/headless-protocol/requests.json index 5ab3213..228678e 100644 --- a/devtools/headless-protocol/requests.json +++ b/devtools/headless-protocol/requests.json @@ -74,5 +74,79 @@ "params": { "targetRequestId": "advance" } + }, + { + "requestId": "mem-11", + "command": "initialize", + "params": { + "protocolVersion": { + "major": 1, + "minor": 1 + }, + "requiredCapabilities": [ + "memcard" + ] + } + }, + { + "requestId": "mem-12", + "command": "memcard_mount", + "params": { + "path": "/save.pmc", + "action": "open", + "access": "read_only" + } + }, + { + "requestId": "mem-13", + "command": "memcard_mount", + "params": { + "path": "/new.pmc", + "action": "create", + "access": "read_write" + } + }, + { + "requestId": "mem-14", + "command": "boot", + "params": { + "path": "/cartridge", + "memcardChoice": "memory_existing" + } + }, + { + "requestId": "mem-15", + "command": "get_memcard_state", + "params": {} + }, + { + "requestId": "mem-16", + "command": "memcard_unmount", + "params": {} + }, + { + "requestId": "mem-17", + "command": "memcard_reconcile", + "params": {} + }, + { + "requestId": "mem-18", + "command": "memcard_continue_in_memory", + "params": {} + }, + { + "requestId": "mem-19", + "command": "reset", + "params": { + "discardUnsaved": true, + "pendingWrites": "cancel" + } + }, + { + "requestId": "mem-20", + "command": "shutdown", + "params": { + "pendingWrites": "wait" + } } ] diff --git a/devtools/headless-protocol/response.schema.json b/devtools/headless-protocol/response.schema.json index adc5fad..544bedb 100644 --- a/devtools/headless-protocol/response.schema.json +++ b/devtools/headless-protocol/response.schema.json @@ -1,7 +1,7 @@ { "$schema": "https://json-schema.org/draft/2020-12/schema", - "title": "Prometeu headless server messages v1.0", - "$comment": "requestId additionally has a 128 UTF-8-byte bound; uint counters require lossless decoding. v1.0 producers are checked strictly. Consumers must allow compatible minor extensions.", + "title": "Prometeu headless server messages v1.1", + "$comment": "Producer schema for supported 1.0/1.1 shapes. Consumers permit compatible minor additions; 64-bit identities require lossless decoding.", "oneOf": [ { "type": "object", @@ -167,12 +167,18 @@ "properties": { "closed": { "const": true + }, + "memcard": { + "$ref": "#/$defs/memcard" } }, "required": [ "closed" ], "additionalProperties": false + }, + { + "$ref": "#/$defs/memcard" } ] } @@ -222,7 +228,42 @@ "message", "details" ], - "additionalProperties": false + "additionalProperties": false, + "allOf": [ + { + "if": { + "properties": { + "code": { + "const": "memcard_error" + } + } + }, + "then": { + "properties": { + "details": { + "type": "object", + "properties": { + "operation": { + "type": "string" + }, + "reason": { + "$ref": "#/$defs/memcardReason" + }, + "state": { + "$ref": "#/$defs/memcard" + } + }, + "required": [ + "operation", + "reason", + "state" + ], + "additionalProperties": false + } + } + } + } + ] }, "stack": { "oneOf": [ @@ -271,8 +312,24 @@ "const": "heap_ref" }, "value": { - "type": "integer", - "minimum": 0 + "type": "object", + "properties": { + "index": { + "type": "integer", + "minimum": 0, + "maximum": 4294967295 + }, + "generation": { + "type": "integer", + "minimum": 0, + "maximum": 4294967295 + } + }, + "required": [ + "index", + "generation" + ], + "additionalProperties": false } }, "required": [ @@ -347,6 +404,9 @@ "terminated", "faulted" ] + }, + "memcard": { + "$ref": "#/$defs/memcard" } }, "required": [ @@ -694,7 +754,8 @@ "faulted", "terminated", "canceled", - "host_error" + "host_error", + "action_required" ] }, "fault": { @@ -952,7 +1013,7 @@ "DuplicateFn", "StructuralTypeCycle", "CaptureIndex", - "CaptureCount", + "CaptureCount", "CapturedDirectCall", "RemovedOpcode", "ArrayCycle", @@ -1368,6 +1429,338 @@ "additionalProperties": false } ] + }, + "memcardReason": { + "enum": [ + "choice_required", + "unavailable", + "corrupt", + "unsupported", + "read_only", + "access_denied", + "already_exists", + "busy", + "no_space", + "out_of_memory", + "invalid_state", + "invalid_range", + "counter_exhausted", + "identity_mismatch", + "unsaved_changes", + "indeterminate", + "restart_required", + "io_error", + "canceled" + ] + }, + "memcard": { + "type": "object", + "properties": { + "media": { + "type": "object", + "properties": { + "path": { + "anyOf": [ + { + "type": "string" + }, + { + "type": "null" + } + ] + }, + "cardId": { + "anyOf": [ + { + "type": "string", + "pattern": "^[0-9a-f]{32}$" + }, + { + "type": "null" + } + ] + }, + "access": { + "anyOf": [ + { + "enum": [ + "read_write", + "read_only" + ] + }, + { + "type": "null" + } + ] + }, + "mountEpoch": { + "type": "string", + "pattern": "^(0|[1-9][0-9]*)$" + }, + "preparation": { + "enum": [ + "idle", + "pending", + "ready", + "failed" + ] + }, + "error": { + "anyOf": [ + { + "$ref": "#/$defs/memcardReason" + }, + { + "type": "null" + } + ] + }, + "recovered": { + "type": "boolean" + }, + "degraded": { + "type": "boolean" + }, + "writeBlocked": { + "type": "boolean" + } + }, + "required": [ + "path", + "cardId", + "access", + "mountEpoch", + "preparation", + "error", + "recovered", + "degraded", + "writeBlocked" + ], + "additionalProperties": false + }, + "session": { + "type": "object", + "properties": { + "appId": { + "anyOf": [ + { + "type": "integer", + "minimum": 0, + "maximum": 4294967295 + }, + { + "type": "null" + } + ] + }, + "choice": { + "anyOf": [ + { + "enum": [ + "persistent", + "memory_fresh", + "memory_existing" + ] + }, + { + "type": "null" + } + ] + }, + "mode": { + "anyOf": [ + { + "enum": [ + "persistent", + "memory_only" + ] + }, + { + "type": "null" + } + ] + }, + "bootAttempted": { + "type": "boolean" + }, + "bootPhase": { + "enum": [ + "idle", + "loading", + "choice_required", + "preparing", + "running", + "failed" + ] + }, + "resident": { + "type": "boolean" + }, + "actionRequired": { + "type": "boolean" + } + }, + "required": [ + "appId", + "choice", + "mode", + "bootAttempted", + "bootPhase", + "resident", + "actionRequired" + ], + "additionalProperties": false + }, + "dirty": { + "type": "boolean" + }, + "dirtySlots": { + "type": "array", + "items": { + "type": "integer", + "minimum": 0, + "maximum": 63 + }, + "uniqueItems": true, + "maxItems": 64 + }, + "request": { + "anyOf": [ + { + "type": "object", + "properties": { + "id": { + "type": "string", + "pattern": "^(0|[1-9][0-9]*)$" + }, + "state": { + "enum": [ + "pending", + "success", + "failure", + "indeterminate", + "memory_only" + ] + }, + "reason": { + "anyOf": [ + { + "$ref": "#/$defs/memcardReason" + }, + { + "enum": [ + "none", + "timeout" + ] + } + ] + }, + "storageError": { + "anyOf": [ + { + "$ref": "#/$defs/memcardReason" + }, + { + "type": "null" + } + ] + }, + "operation": { + "enum": [ + "commit", + "presentation" + ] + }, + "slot": { + "anyOf": [ + { + "type": "integer", + "minimum": 0, + "maximum": 63 + }, + { + "type": "null" + } + ] + }, + "retained": { + "type": "boolean" + } + }, + "required": [ + "id", + "state", + "reason", + "storageError", + "operation", + "slot", + "retained" + ], + "additionalProperties": false + }, + { + "type": "null" + } + ] + }, + "io": { + "type": "object", + "properties": { + "active": { + "type": "boolean" + }, + "deferred": { + "type": "boolean" + }, + "phase": { + "enum": [ + "idle", + "preparing", + "deferred", + "queued", + "running", + "returned" + ] + } + }, + "required": [ + "active", + "deferred", + "phase" + ], + "additionalProperties": false + }, + "recovery": { + "type": "object", + "properties": { + "removalPending": { + "type": "boolean" + }, + "reconciliationRequired": { + "type": "boolean" + }, + "restartRequired": { + "type": "boolean" + } + }, + "required": [ + "removalPending", + "reconciliationRequired", + "restartRequired" + ], + "additionalProperties": false + } + }, + "required": [ + "media", + "session", + "dirty", + "dirtySlots", + "request", + "io", + "recovery" + ], + "additionalProperties": false } } } diff --git a/discussion/lessons/DSC-0068-memcard-public-host-persistence/LSN-0073-public-persistence-is-a-process-and-ownership-contract.md b/discussion/lessons/DSC-0068-memcard-public-host-persistence/LSN-0073-public-persistence-is-a-process-and-ownership-contract.md new file mode 100644 index 0000000..fea4123 --- /dev/null +++ b/discussion/lessons/DSC-0068-memcard-public-host-persistence/LSN-0073-public-persistence-is-a-process-and-ownership-contract.md @@ -0,0 +1,128 @@ +--- +id: LSN-0073 +ticket: memcard-public-host-persistence +title: Public persistence is a process and ownership contract +created: 2026-10-30 +tags: [memcard, persistence, headless, host, ownership] +--- + +## Context + +The runtime now exposes media preparation, three explicit boot choices, native +observation, protected teardown and same-media recovery through its installed +headless protocol. The file backend has a single owner across compatible hosts, +including read-only opens. Runtime tests remain neutral PBX/ABI programs and do +not depend on a source-language frontend or another application's build. + +Historical source: accepted decision DEC-0068, executed through PLN-0199 from +AGD-0071. Their workflow files are disposable. The published contracts are +[Save Memory and MEMCARD](../../../docs/specs/runtime/08-save-memory-and-memcard.md) +and [Headless Automation](../../../docs/specs/runtime/11a-headless-automation-protocol.md#memcard-controls). +This lesson explains those published results rather than defining new behavior. + +## A native API is not an installed integration surface + +Injecting storage into an in-process host is useful for controlled faults, but +does not establish that a consumer can configure the distributed executable. +Media preparation and player choice therefore became explicit operations of +the existing transport. The negotiated minor and capability identify support; +an executable version string alone does not. A client without the extension +continues using the original non-memcard shapes. + +Preparing media separately from boot lets missing, corrupt, read-only and busy +files produce native domain errors before game initialization. Opening is not +creation. A persistent choice does not turn into fresh RAM after a failure. +These distinctions belong to the provider so every consumer sees the same +storage and admission policy. + +## Result knowledge, RAM state and resource lifetime are separate + +A retained terminal result is a statement about an attempt. It is not evidence +that a worker still owns the source, and absence of a mounted backend is not +evidence that the worker is active. In particular, reacquisition can fail after +the previous IO safely returned. An explicit worker-return observation separates +that case from an outstanding operation. + +This distinction also matters after watchdog escalation. A late completion can +provide the original worker error and return its resources without rewriting the +terminal result already exposed to the game. Same-card reconciliation keeps that +original result available until guest release. It does not consume the result +to make media operations easier. Controlled tests exercise both a refusal before +publication and an uncertain attempt inside metadata publication. + +Ending a session does not establish media health. An installed image with an +indeterminate publication stays write-blocked after reset, and a new persistent +admission cannot bypass the need for explicit revalidation. + +RAM has its own state. A memory-only commit completes without a durability claim +and leaves modified RAM dirty. Teardown first waits for or cancels already +admitted IO, then reevaluates RAM. It can avoid an unnecessary discard prompt if +the save completes cleanly during that wait. If dirty data remains, refusal keeps +the process, session and channel available for a later explicit decision. + +## A process boundary makes file ownership visible + +Serializing one runtime's transactions does not exclude another process that +opened the same image from making decisions against an older map. The shared +file backend now attaches an exclusive OS lock to the open file, including +read-only access. Hardlink and symlink tests exercise identity rather than path +string equality. Creation locks its new file before publishing a non-replacing +name. Resource ownership continues through cancellation, result release and +blocked teardown until IO actually ceases or the owner process dies. + +Recovery has to account for the lock held by the same host. Opening another +descriptor before relinquishing the safely quiescent backend can conflict with +that host's own lock. The recovery boundary transfers ownership, validates the +expected card identity before mutation and preserves local RAM on failure. +The selected path containing a different card is an identity error, not implicit +permission to register or load a replacement game record. + +## Deterministic guest progress and asynchronous observation coexist + +The headless owner polls native IO between commands. Completion and deadlines +can become observable while guest PC, stack, tick and frame remain unchanged. +Driving IO does not require inventing game frames or restarting initialization. + +Two integration details were exposed by the first real memcard frame. A +controlled bootstrap slice can consume the runtime's step marker before a logical +frame closes; the host retains its requested advancement until the frame or an +explicit stop boundary. Also, a host dialog can reuse frame ID zero. Its producer +is excluded from canonical game capture, so an initial game frame is neither +mistaken for the dialog nor rejected merely for sharing that numeric ID. + +A resident game waiting for external media action is paused rather than +terminated. Recovery preserves its continuation and admitted RAM. It does not +call bootstrap again. Explicit continuation in RAM uses the existing SO choice +and remains distinct from restarting a game with fresh memory. + +## A readback oracle should be unable to save its own answer + +The neutral writer stores bytes 0, 127, 128 and 255 and exposes the guest query +SUCCESS through public state inspection. A different process runs a reader with +no save or presentation import. It checks each prior byte, traps on a wrong or +missing payload and exposes a separate readback result. The entire image remains +unchanged by that reader. A further process changes app_version while retaining +the same uint32 app_id. Read-only loading into RAM is qualified independently. + +The same process oracle runs through the public dispatcher from another working +directory against a real extracted archive produced by the distribution workflow. +That establishes something stronger than reopening a native object in one test +process or copying target/debug binaries into a directory labeled as an install. +Archive, binary, schema and source fingerprints identify the evidence precisely +even while the implementation is an uncommitted checkout. + +## Evidence and ownership boundary + +[Qualification evidence](evidence/summary.json) records 1,107 passing workspace +tests, 73 passing release tests, strict formatter/clippy checks, and both extracted +distribution tests passing. The generic workspace gate has 14 ignored manual or +installation tests; the two installation tests were separately run successfully. +Execution was qualified on macOS arm64. This is not a physical power-cut, +cross-target or storage-latency qualification. + +The runtime delivery prepares a supported contract and its independent evidence. +No consumer source, configuration, SDK, workflow or tests were changed or run. +Future client/frontend integration uses the published surface and has its own +acceptance criteria. Its completion is neither claimed nor required to close +this provider work. This boundary prevents a provider plan from absorbing another +domain merely because that consumer originally discovered the missing interface. diff --git a/discussion/lessons/DSC-0068-memcard-public-host-persistence/evidence/clippy-final.log b/discussion/lessons/DSC-0068-memcard-public-host-persistence/evidence/clippy-final.log new file mode 100644 index 0000000..f68d3bd --- /dev/null +++ b/discussion/lessons/DSC-0068-memcard-public-host-persistence/evidence/clippy-final.log @@ -0,0 +1,6 @@ + Checking prometeu-system v0.1.0 (/Users/niltonconstantino/personal/workspace.personal/intrepid/prometeu/runtime/crates/console/prometeu-system) + Checking prometeu-firmware v0.1.0 (/Users/niltonconstantino/personal/workspace.personal/intrepid/prometeu/runtime/crates/console/prometeu-firmware) + Checking prometeu-host-headless v0.1.0 (/Users/niltonconstantino/personal/workspace.personal/intrepid/prometeu/runtime/crates/host/prometeu-host-headless) + Checking prometeu-host-desktop-winit v0.1.0 (/Users/niltonconstantino/personal/workspace.personal/intrepid/prometeu/runtime/crates/host/prometeu-host-desktop-winit) + Checking prometeu-cli v0.1.0 (/Users/niltonconstantino/personal/workspace.personal/intrepid/prometeu/runtime/crates/tools/prometeu-cli) + Finished `dev` profile [unoptimized + debuginfo] target(s) in 5.02s diff --git a/discussion/lessons/DSC-0068-memcard-public-host-persistence/evidence/dist-final.log b/discussion/lessons/DSC-0068-memcard-public-host-persistence/evidence/dist-final.log new file mode 100644 index 0000000..2f0780d --- /dev/null +++ b/discussion/lessons/DSC-0068-memcard-public-host-persistence/evidence/dist-final.log @@ -0,0 +1,44 @@ +Generated VERSION.txt with version 0.1.0 +Preparing dist-staging... +Preparing dist-staging/stable (existing archives are retained)... +building artifacts: + prometeu-cli-aarch64-apple-darwin.zip + prometeu-cli-aarch64-apple-darwin.zip.sha256 + prometeu-host-desktop-winit-aarch64-apple-darwin.zip + prometeu-host-desktop-winit-aarch64-apple-darwin.zip.sha256 + pbxgen-dummy-boy-aarch64-apple-darwin.zip + pbxgen-dummy-boy-aarch64-apple-darwin.zip.sha256 + pbxgen-stress-aarch64-apple-darwin.zip + pbxgen-stress-aarch64-apple-darwin.zip.sha256 + +building aarch64-apple-darwin target, using cargo profile dist --workspace) + Compiling prometeu-system v0.1.0 (/Users/niltonconstantino/personal/workspace.personal/intrepid/prometeu/runtime/crates/console/prometeu-system) + Compiling prometeu-firmware v0.1.0 (/Users/niltonconstantino/personal/workspace.personal/intrepid/prometeu/runtime/crates/console/prometeu-firmware) + Compiling prometeu-host-desktop-winit v0.1.0 (/Users/niltonconstantino/personal/workspace.personal/intrepid/prometeu/runtime/crates/host/prometeu-host-desktop-winit) + Compiling prometeu-host-headless v0.1.0 (/Users/niltonconstantino/personal/workspace.personal/intrepid/prometeu/runtime/crates/host/prometeu-host-headless) + Compiling prometeu-cli v0.1.0 (/Users/niltonconstantino/personal/workspace.personal/intrepid/prometeu/runtime/crates/tools/prometeu-cli) + Finished `dist` profile [optimized] target(s) in 39.63s +announcing v0.1.0 + prometeu-cli 0.1.0 + /Users/niltonconstantino/personal/workspace.personal/intrepid/prometeu/runtime/target/distrib/prometeu-cli-aarch64-apple-darwin.zip + [bin] prometeu + [bin] prometeu-headless + [bin] prometeu-runtime + [misc] 11a-headless-automation-protocol.md, LICENSE, README.md, headless-protocol + [checksum] /Users/niltonconstantino/personal/workspace.personal/intrepid/prometeu/runtime/target/distrib/prometeu-cli-aarch64-apple-darwin.zip.sha256 + prometeu-host-desktop-winit 0.1.0 + /Users/niltonconstantino/personal/workspace.personal/intrepid/prometeu/runtime/target/distrib/prometeu-host-desktop-winit-aarch64-apple-darwin.zip + [bin] prometeu-host-desktop-winit + [misc] LICENSE, README.md, VERSION.txt + [checksum] /Users/niltonconstantino/personal/workspace.personal/intrepid/prometeu/runtime/target/distrib/prometeu-host-desktop-winit-aarch64-apple-darwin.zip.sha256 + pbxgen-dummy-boy 0.1.0 + /Users/niltonconstantino/personal/workspace.personal/intrepid/prometeu/runtime/target/distrib/pbxgen-dummy-boy-aarch64-apple-darwin.zip + [bin] pbxgen-dummy-boy + [misc] LICENSE, README.md + [checksum] /Users/niltonconstantino/personal/workspace.personal/intrepid/prometeu/runtime/target/distrib/pbxgen-dummy-boy-aarch64-apple-darwin.zip.sha256 + pbxgen-stress 0.1.0 + /Users/niltonconstantino/personal/workspace.personal/intrepid/prometeu/runtime/target/distrib/pbxgen-stress-aarch64-apple-darwin.zip + [bin] pbxgen-stress + [misc] LICENSE, README.md + [checksum] /Users/niltonconstantino/personal/workspace.personal/intrepid/prometeu/runtime/target/distrib/pbxgen-stress-aarch64-apple-darwin.zip.sha256 +Copying target/distrib content to dist-staging/stable... diff --git a/discussion/lessons/DSC-0068-memcard-public-host-persistence/evidence/investigation/README.md b/discussion/lessons/DSC-0068-memcard-public-host-persistence/evidence/investigation/README.md new file mode 100644 index 0000000..043842f --- /dev/null +++ b/discussion/lessons/DSC-0068-memcard-public-host-persistence/evidence/investigation/README.md @@ -0,0 +1,3 @@ +# Historical baseline investigation + +These files record the diagnosis at revision `dcf6561ea73446e0a3e1cf1c73eda20923b38df0`, before the public memcard interface and exclusive backend locking were implemented. The probe intentionally tests the old behavior and is not a current conformance runner. Current qualification, commands, artifact fingerprints and limits are recorded in [the provider evidence summary](../summary.json). diff --git a/discussion/lessons/DSC-0068-memcard-public-host-persistence/evidence/investigation/review_probe.py b/discussion/lessons/DSC-0068-memcard-public-host-persistence/evidence/investigation/review_probe.py new file mode 100644 index 0000000..c905dae --- /dev/null +++ b/discussion/lessons/DSC-0068-memcard-public-host-persistence/evidence/investigation/review_probe.py @@ -0,0 +1,95 @@ +import json +from pathlib import Path +import subprocess +import tempfile + +root = Path.cwd() +scratch = Path(tempfile.mkdtemp(prefix="runtime-memcard-review-")) +source = scratch / "image_access.rs" +source.write_text(r''' +use prometeu_drivers::memcard::FileMemcard; +use prometeu_hal::memcard::MemcardIoError; +use prometeu_system::memcard::{image::IMAGE_BYTES, transaction::Card}; + +fn main() { + let args: Vec<_> = std::env::args().collect(); + let path = std::path::Path::new(&args[1]); + if args.get(2).is_some() { + let second = FileMemcard::open(path, false) + .map_err(|e| format!("{e:?}")) + .and_then(|io| Card::mount(Box::new(io)).map_err(|e| format!("{e:?}"))); + match second { + Ok(card) => { + println!("second_process_rw_mount_accepted"); + drop(card); + } + Err(error) => println!("second_process_rw_mount_rejected:{error}"), + } + return; + } + let io = FileMemcard::create(path, IMAGE_BYTES, |io, id| { + Card::format(io, id).map_err(|_| MemcardIoError::IoError) + }).expect("create private probe image"); + let first_card = Card::mount(Box::new(io)).expect("first mount"); + let output = std::process::Command::new(std::env::current_exe().unwrap()) + .arg(path).arg("child").output().expect("child process"); + assert!(output.status.success()); + print!("{}", String::from_utf8(output.stdout).unwrap()); + drop(first_card); +} +''') +binary = scratch / "image-access" +command = ["rustc", "--edition=2024", str(source), "-o", str(binary), + "-L", "dependency=" + str(root / "target/debug/deps")] +for crate in ("prometeu_drivers", "prometeu_hal", "prometeu_system"): + rlib = max((root / "target/debug/deps").glob("lib" + crate + "-*.rlib"), + key=lambda p: p.stat().st_mtime_ns) + command += ["--extern", crate + "=" + str(rlib)] +subprocess.run(command, check=True, capture_output=True, text=True) +access = subprocess.run([str(binary), str(scratch / "probe.pmc")], + check=True, capture_output=True, text=True) + +process = subprocess.Popen([str(root / "target/debug/prometeu"), "headless", "--stdio"], + stdin=subprocess.PIPE, stdout=subprocess.PIPE, + stderr=subprocess.PIPE, text=True) +hello = json.loads(process.stdout.readline()) +def request(identity, command, params): + process.stdin.write(json.dumps({"requestId": identity, "command": command, "params": params}) + "\n") + process.stdin.flush() + return json.loads(process.stdout.readline()) +required = request("probe-capability", "initialize", { + "protocolVersion": {"major": 1, "minor": 0}, "requiredCapabilities": ["memcard"]}) +initialized = request("init", "initialize", { + "protocolVersion": {"major": 1, "minor": 0}, "requiredCapabilities": []}) +invalid = request("probe-field", "boot", {"path": str(scratch), "memcard": {}}) +state = request("state", "get_state", {}) +shutdown = request("stop", "shutdown", {}) +process.stdin.close() +process.wait(timeout=10) +assert process.returncode == 0 +assert required["error"]["code"] == "unsupported_capability" +assert invalid["error"]["code"] == "invalid_params" +assert shutdown["result"] == {"closed": True} +report = { + "runtime_revision": subprocess.check_output(["git", "rev-parse", "HEAD"], text=True).strip(), + "scope": "read-only diagnosis using checkout debug binaries and isolated disposable image; no installed-process persistence qualification", + "scratch_directory": str(scratch), + "file_access_probe": { + "backend": "FileMemcard + Card::mount on a valid freshly created image", + "first_process_holds_rw_card": True, + "second_process_result": access.stdout.strip(), + "payload_writes": False, + }, + "wire_probe": { + "capabilities": hello["capabilities"], + "required_capability_memcard": required["error"], + "unknown_boot_field_memcard": invalid["error"], + "get_state_fields": sorted(state["result"]), + "shutdown": shutdown["result"], + "note": "The memcard capability/field names are intentionally unsupported test input, not a proposed public contract.", + }, +} +report_path = scratch / "summary.json" +report_path.write_text(json.dumps(report, indent=2) + "\n") +print(json.dumps(report, indent=2)) +print("report_path=" + str(report_path)) diff --git a/discussion/lessons/DSC-0068-memcard-public-host-persistence/evidence/investigation/summary.json b/discussion/lessons/DSC-0068-memcard-public-host-persistence/evidence/investigation/summary.json new file mode 100644 index 0000000..0024fba --- /dev/null +++ b/discussion/lessons/DSC-0068-memcard-public-host-persistence/evidence/investigation/summary.json @@ -0,0 +1,68 @@ +{ + "runtime_revision": "dcf6561ea73446e0a3e1cf1c73eda20923b38df0", + "scope": "read-only diagnosis using checkout debug binaries and isolated disposable image; no installed-process persistence qualification", + "scratch_directory": "/var/folders/0t/tfsqc14j5wbgh9h4s4dytwb00000gq/T/runtime-memcard-review-qa13v648", + "file_access_probe": { + "backend": "FileMemcard + Card::mount on a valid freshly created image", + "first_process_holds_rw_card": true, + "second_process_result": "second_process_rw_mount_accepted", + "payload_writes": false + }, + "wire_probe": { + "capabilities": [ + "boot", + "reset", + "set_input", + "clear_input", + "advance", + "capture", + "get_state", + "get_fault", + "cancel", + "shutdown" + ], + "required_capability_memcard": { + "code": "unsupported_capability", + "details": {}, + "message": "required capability unavailable" + }, + "unknown_boot_field_memcard": { + "code": "invalid_params", + "details": {}, + "message": "unknown field `memcard`, expected `path`" + }, + "get_state_fields": [ + "appId", + "logicalFrameIndex", + "pc", + "stackTop", + "status", + "tickIndex" + ], + "shutdown": { + "closed": true + }, + "note": "The memcard capability/field names are intentionally unsupported test input, not a proposed public contract." + }, + "date": "2026-10-29", + "platform": "macOS-27.0.1-arm64-arm-64bit-Mach-O", + "studio_revision": "3a3417eb44c2e99ca183ce6f3fbbfff738b70f87", + "reproduction": [ + "cargo test -p prometeu-cli --test automation_process -- --test-threads=1", + "python3 discussion/workflow/agendas/AGD-0071-evidence/review_probe.py" + ], + "automation_process_tests": { + "passed": 12, + "failed": 0, + "ignored": 1, + "ignored_test": "packaged_installation_smoke", + "ignored_reason": "requires PROMETEU_PROTOCOL_TEST_INSTALL pointing to an extracted dist archive", + "covers_memcard": false + }, + "qualification_limits": [ + "No Studio Gradle/native memcard suite was rerun; its summary was inspected as existing evidence.", + "No configured installed-runtime memcard persistence test was performed.", + "Two simultaneous valid RW mounts were accepted; no concurrent payload publication was attempted.", + "No product code, normative specs or Studio files were modified." + ] +} diff --git a/discussion/lessons/DSC-0068-memcard-public-host-persistence/evidence/packaged.log b/discussion/lessons/DSC-0068-memcard-public-host-persistence/evidence/packaged.log new file mode 100644 index 0000000..7a16545 --- /dev/null +++ b/discussion/lessons/DSC-0068-memcard-public-host-persistence/evidence/packaged.log @@ -0,0 +1,13 @@ + Compiling prometeu-system v0.1.0 (/Users/niltonconstantino/personal/workspace.personal/intrepid/prometeu/runtime/crates/console/prometeu-system) + Compiling prometeu-firmware v0.1.0 (/Users/niltonconstantino/personal/workspace.personal/intrepid/prometeu/runtime/crates/console/prometeu-firmware) + Compiling prometeu-host-headless v0.1.0 (/Users/niltonconstantino/personal/workspace.personal/intrepid/prometeu/runtime/crates/host/prometeu-host-headless) + Compiling prometeu-host-desktop-winit v0.1.0 (/Users/niltonconstantino/personal/workspace.personal/intrepid/prometeu/runtime/crates/host/prometeu-host-desktop-winit) + Compiling prometeu-cli v0.1.0 (/Users/niltonconstantino/personal/workspace.personal/intrepid/prometeu/runtime/crates/tools/prometeu-cli) + Finished `test` profile [unoptimized + debuginfo] target(s) in 6.37s + Running tests/automation_process.rs (target/debug/deps/automation_process-018fadef87e61183) + +running 2 tests +test memcard_process::packaged_memcard_process_persistence ... ok +test packaged_installation_smoke ... ok + +test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 20 filtered out; finished in 1.27s diff --git a/discussion/lessons/DSC-0068-memcard-public-host-persistence/evidence/release.log b/discussion/lessons/DSC-0068-memcard-public-host-persistence/evidence/release.log new file mode 100644 index 0000000..0b7ca7c --- /dev/null +++ b/discussion/lessons/DSC-0068-memcard-public-host-persistence/evidence/release.log @@ -0,0 +1,140 @@ + Compiling prometeu-system v0.1.0 (/Users/niltonconstantino/personal/workspace.personal/intrepid/prometeu/runtime/crates/console/prometeu-system) + Compiling prometeu-firmware v0.1.0 (/Users/niltonconstantino/personal/workspace.personal/intrepid/prometeu/runtime/crates/console/prometeu-firmware) + Compiling prometeu-host-headless v0.1.0 (/Users/niltonconstantino/personal/workspace.personal/intrepid/prometeu/runtime/crates/host/prometeu-host-headless) + Compiling prometeu-host-desktop-winit v0.1.0 (/Users/niltonconstantino/personal/workspace.personal/intrepid/prometeu/runtime/crates/host/prometeu-host-desktop-winit) + Compiling prometeu-cli v0.1.0 (/Users/niltonconstantino/personal/workspace.personal/intrepid/prometeu/runtime/crates/tools/prometeu-cli) + Finished `release` profile [optimized] target(s) in 39.83s + Running unittests src/lib.rs (target/release/deps/prometeu_cli-a2a569acb4d2123a) + +running 0 tests + +test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running unittests src/main.rs (target/release/deps/prometeu-233bd0c6f7dfd1c0) + +running 4 tests +test tests::child_exit_code_preserves_non_zero_one ... ok +test tests::child_exit_code_preserves_non_zero_other ... ok +test tests::child_exit_code_preserves_zero ... ok +test tests::child_exit_code_rejects_status_without_numeric_code ... ok + +test result: ok. 4 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running unittests src/bin/prometeu-headless.rs (target/release/deps/prometeu_headless-891734b93133c22e) + +running 0 tests + +test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running unittests src/bin/prometeu-runtime.rs (target/release/deps/prometeu_runtime-2d42636990523667) + +running 0 tests + +test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running tests/automation_process.rs (target/release/deps/automation_process-48ae7cde6854c255) + +running 22 tests +test malformed_fragmented_and_oversized_commands_do_not_desynchronize ... ok +test handshake_versions_capabilities_and_limits_are_explicit ... ok +test conflicting_work_is_rejected_and_cancellation_reports_partial_progress ... ok +test faults_and_boot_failures_are_structured_not_log_parsing ... ok +test lifecycle_and_capture_match_the_in_process_canonical_oracle ... ok +test idle_eof_and_truncated_eof_close_the_process ... ok +test dispatcher_works_from_a_relocated_installation_and_other_cwd ... ok +test memcard_process::packaged_memcard_process_persistence ... ignored, requires PROMETEU_PROTOCOL_TEST_INSTALL pointing to an extracted dist archive +test independent_processes_match_pixels_ids_state_and_fault ... ok +test packaged_installation_smoke ... ignored, requires PROMETEU_PROTOCOL_TEST_INSTALL pointing to an extracted dist archive +test memcard_process::desktop_dispatch_forwards_explicit_media_without_interpreting_player_policy ... ok +test memcard_process::memcard_creation_race_and_process_death_release_real_ownership ... ok +test memcard_process::memcard_access_denial_is_typed_and_does_not_create_or_modify_media ... ok +test memcard_process::memcard_media_errors_and_negotiation_never_select_a_fallback ... ok +test memcard_process::memcard_dirty_refusal_retains_channel_and_explicit_ram_has_no_save ... ok +test schemas_and_distributed_request_fixtures_are_consistent ... ok +test memcard_process::memcard_idle_observation_never_advances_guest_counters ... ok +test shutdown_and_eof_interrupt_active_work_without_resuming_it ... ok +test missing_binary_and_invalid_cli_limits_fail_explicitly ... ok +test memcard_process::memcard_process_ownership_covers_aliases_readers_and_release ... ok +test partial_guest_fault_and_host_watchdog_are_distinct_outcomes ... ok +test memcard_process::memcard_public_distinct_process_save_readback_and_version_identity ... ok + +test result: ok. 20 passed; 0 failed; 2 ignored; 0 measured; 0 filtered out; finished in 0.66s + + Running tests/registry_fault_schema.rs (target/release/deps/registry_fault_schema-2274560704287ef1) + +running 2 tests +test published_load_schema_requires_tag_context_and_the_matching_init_payload ... ok +test published_schema_accepts_structured_resource_fields_and_rejects_unknown_or_negative_values ... ok + +test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.05s + + Running unittests src/lib.rs (target/release/deps/prometeu_host_headless-751195d1585cd278) + +running 13 tests +test automation::tests::bounded_lines_accept_fragmentation_and_recover_after_oversize ... ok +test automation::tests::response_limit_counts_the_complete_envelope_and_keeps_correlation ... ok +test automation::tests::input_snapshot_is_replacement_and_rejects_unknown_fields ... ok +test automation::tests::distributed_request_fixtures_are_accepted_by_the_actual_parser ... ok +test automation::wire::fault_tests::resource_trap_wire_preserves_native_fields_and_source_span ... ok +test automation::tests::capture_preserves_independent_ids_and_excludes_padding_without_channel_loss ... ok +test automation::wire::fault_tests::load_failure_wire_uses_shared_structured_serializer_and_no_runtime_pc ... ok +test automation::wire::fault_tests::executed_closure_quota_refusal_reaches_wire_with_machine_fields ... ok +test automation::wire::fault_tests::active_host_native_type_fault_preserves_wire_machine_fields ... ok +test host::tests::termination_during_frame_advance_clears_host_step_control ... ok +test host::memcard::tests::explicit_continue_in_ram_preserves_dirty_snapshot_and_uses_no_new_boot ... ok +test host::memcard::tests::same_media_recovery_rejects_replacement_and_preserves_ram_continuation ... ok +test host::memcard::tests::unceased_io_retains_lock_and_terminal_result_survives_late_return_and_reconcile ... ok + +test result: ok. 13 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.09s + + Running tests/deterministic_control.rs (target/release/deps/deterministic_control-98e9b0ea3dcb6c52) + +running 25 tests +test headless_source_has_no_timing_wait_or_interactive_backend_dependency ... ok +test lifecycle_state_and_preconditions_are_structural ... ok +test instruction_step_fault_remains_structured ... ok +test batch_stops_early_on_fault_and_reports_partial_progress ... ok +test end_of_rom_completes_a_logical_frame ... ok +test advance_after_reset_reports_termination_without_ticking ... ok +test audio_play_does_not_need_a_device ... ok +test clear_input_drops_right ... ok +test injected_civil_clock_remains_the_runtime_source_across_lifecycle ... ok +test normalized_touch_edges_and_coordinates_use_the_same_input_surface ... ok +test one_frame_returns_and_captures_the_exact_published_frame ... ok +test normalized_button_press_hold_release_and_clear_are_observable ... ok +test right_hold_then_release_changes_pixels ... ok +test step_does_not_complete_a_logical_frame ... ok +test controlled_civil_time_is_independent_of_frames_pause_and_reset ... ok +test one_logical_frame_may_span_multiple_internal_ticks ... ok +test trap_is_structured ... ok +test stepping_frame_sync_is_not_a_fault_or_completed_runtime_frame ... ok +test vm_init_failure_is_returned_as_structured_boot_failure ... ok +test zero_frames_is_an_explicit_noop ... ok +test reset_matches_fresh_host ... ok +test two_runs_match_oracle ... ok +test three_hundred_frames_complete_without_realtime_pacing ... ok +test outer_frame_limit_is_a_host_error_and_finishes_paused ... ok +test audio_controls_quota_and_multiple_frames_are_device_independent ... ok + +test result: ok. 25 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.18s + + Running tests/input_queries.rs (target/release/deps/input_queries-2ee1672fd0295c9d) + +running 4 tests +test catalogue_has_exact_names_ids_signatures_and_no_endpoint_aliases ... ok +test every_known_query_faults_when_unavailable_and_rejects_arguments ... ok +test vm_queries_charge_one_cycle_each_and_allocate_no_guest_objects ... ok +test every_button_uses_its_own_snapshot_and_queries_do_not_advance_frames ... ok + +test result: ok. 4 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.01s + + Running tests/typed_runtime.rs (target/release/deps/typed_runtime-e31573f60bd59e2a) + +running 5 tests +test typed_native_argument_fault_inside_callback_reaches_active_host ... ok +test active_host_preserves_removed_opcode_load_context_and_null_fn_trap ... ok +test sync_in_callee_or_closure_resumes_next_pc_with_locals_and_init_once ... ok +test budget_exhaustion_inside_fn_keeps_the_same_open_logical_frame ... ok +test regenerated_cartridges_run_six_complete_frames_on_production_host ... ok + +test result: ok. 5 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.07s diff --git a/discussion/lessons/DSC-0068-memcard-public-host-persistence/evidence/summary.json b/discussion/lessons/DSC-0068-memcard-public-host-persistence/evidence/summary.json new file mode 100644 index 0000000..0329e9b --- /dev/null +++ b/discussion/lessons/DSC-0068-memcard-public-host-persistence/evidence/summary.json @@ -0,0 +1,157 @@ +{ + "date": "2026-10-30", + "scope": "runtime/host provider readiness only; no consumer modifications/builds/tests/configuration updates", + "baseline_revision": "dcf6561ea73446e0a3e1cf1c73eda20923b38df0", + "working_tree": "uncommitted implementation; identified by per-file SHA256 and combined source fingerprint", + "source_files_sha256": { + "crates/console/prometeu-drivers/src/memcard.rs": "cc0326c89033cca97d1798e7725f2bf52115c8592a12dab39146c9d3dcb19769", + "crates/console/prometeu-firmware/src/firmware/firmware_step_load_cartridge.rs": "3177c16ab016d45424b54e9b3bbf1746f9113db8ec607a2819cabc412202a4fb", + "crates/console/prometeu-hal/src/memcard.rs": "263d609d336d6e37b62fa4604d2be5ab98df26c45ec7c611557b0abfb8916bee", + "crates/console/prometeu-system/src/os/system_os.rs": "cbca29127df9ca28b6ed84bd5fa3f926b410a34f360c33bfce0456292cf4340b", + "crates/console/prometeu-system/src/services/memcard.rs": "a58517232ceef657d005da2f28fbc0cd484398bd407b2340b0d3571d083e53c5", + "crates/console/prometeu-system/src/services/memcard/admission.rs": "ecec0b0642da3aba3a38941ce25afdb35dc8d42b15f34d9da6ac9d06f765f741", + "crates/console/prometeu-system/src/services/memcard/diagnostics.rs": "99699c14c43090c8eb72624967e96846a99400a5809301a8dcc2564d8164ab61", + "crates/console/prometeu-system/src/services/memcard/guest.rs": "507913dc29ed07ab2a4ac6ec93583e935a73e35ec8f16798de0a5b55d392dd98", + "crates/console/prometeu-system/src/services/memcard/image.rs": "c4aedb43b050989ef95f8efbd5d0994b23928a16dd49358361ecd96ffed3811d", + "crates/console/prometeu-system/src/services/memcard/session.rs": "f6990ddac2f0cd2f2643d4323be6e18eef0e349ea1494c6dfd216cb5e2105d4a", + "crates/dev/prometeu-test-support/src/lib.rs": "4cf14e6065e40ec5bc84fdc20f653babee26e1d60c97687b1e68edfda9b1a219", + "crates/dev/prometeu-test-support/src/memcard_fixture.rs": "f63fd0c6dff5b862d228709d9160b38ab9edc1a90e62b051eb6540706977bd0f", + "crates/dev/prometeu-test-support/src/program.rs": "d6c2f720fb405355ea2d3648a5c08e7fa96f5fc8cfd289be0cfb17f911907696", + "crates/host/prometeu-host-headless/src/automation/mod.rs": "7d72c0eddf23b769047812e9a96746380f58dc18d5ef560188999160aee17c68", + "crates/host/prometeu-host-headless/src/automation/wire.rs": "0a1e3c786810499857f54d8d1795fded417ed809b17c4a03d1b39941b0d4dd28", + "crates/host/prometeu-host-headless/src/host.rs": "fc75f6c9dd842ec241e95f4389935d8edf619ed3c7c5134733d25b6dd58cbb2f", + "crates/host/prometeu-host-headless/src/lib.rs": "3b29775d61a26a6098562e2e4e98fba1d43580a36979be43682f44ce5f8655c8", + "crates/host/prometeu-host-headless/src/memcard.rs": "a32fcfc9cb30ddf18a2eb848101c34583a215817bf6e185124084a46f22ad329", + "crates/host/prometeu-host-headless/src/memcard_tests.rs": "66f566a8291014524a4ef0d5952252adf64d3f8c68b50bd9251f4482664e2f39", + "crates/host/prometeu-host-headless/src/resource_qualification_tests.rs": "243f51eadc91c30ef5895d34525574349dbad45ee7b77cb88bee25c7fd2e66a4", + "crates/host/prometeu-host-headless/tests/deterministic_control.rs": "5fe3f48575e0fd5f4f2640c76145603baa2571b67ad619de21caadf1ce35aa1b", + "crates/tools/prometeu-cli/src/lib.rs": "944840ef6e14400b98cc1dc659c95ba5eb6e7ef8a4cd4d28d37ba70392e7e2d6", + "crates/tools/prometeu-cli/src/main.rs": "2c956bc90756e31bc38cd6811933a717b3c49d1f0ab501ed39f5869e6b3d8c92", + "crates/tools/prometeu-cli/tests/automation_process.rs": "230dea8a6cabede2e168c35938284903fa41614eaa2619626bb6560a9527640f", + "crates/tools/prometeu-cli/tests/support/memcard_process.rs": "0a8581fb129238f39605a6e9485e813e58b639e7a2131e3cf06e9c390cce2bed", + "devtools/headless-protocol/invalid-requests.json": "f0f0a9a21735c7f90180e816093a884350c07303ea887ebe89a534fc6c8a7b3a", + "devtools/headless-protocol/request.schema.json": "d7e5b39917f0973e0cb697815937e21574bec7f24ebcab8c9a72ca3c05dca553", + "devtools/headless-protocol/requests.json": "5821af6fecb51a7b85e502fd27d22e046e140d417982bbb561fd260b9023ddf2", + "devtools/headless-protocol/response.schema.json": "0040bb288226eb2f34d4028d8a5f3f8a708d754d51d8f62eaa7e64b0da5c69a8", + "docs/specs/runtime/08-save-memory-and-memcard.md": "7ead27a4039a3451909e7319f8624ec37c62602fee4615f6766e4435b0f411d7", + "docs/specs/runtime/11a-headless-automation-protocol.md": "526e6aae664ffc5661289150410599fb3494e1a1665ba334fe802b0d69e46313" + }, + "source_fingerprint_sha256": "87474a7172e3e233a9144c97202a40001892ea0e8a6c814b47581b67527c2575", + "platform": "macOS-27.0.1-arm64-arm-64bit-Mach-O", + "architecture": "arm64", + "rustc": "rustc 1.98.1 (48a229cea 2026-09-01)", + "cargo": "cargo 1.98.1 (797e8a9bc 2026-08-05)", + "cargo_lock_sha256": "cffad9ed62f38a591538abd81dd39270d6022397342c8189f4ac6c7baaa8e795", + "protocol": { + "major": 1, + "minor": 1, + "capability": "memcard", + "schema_sha256": { + "invalid-requests.json": "f0f0a9a21735c7f90180e816093a884350c07303ea887ebe89a534fc6c8a7b3a", + "request.schema.json": "d7e5b39917f0973e0cb697815937e21574bec7f24ebcab8c9a72ca3c05dca553", + "requests.json": "5821af6fecb51a7b85e502fd27d22e046e140d417982bbb561fd260b9023ddf2", + "response.schema.json": "0040bb288226eb2f34d4028d8a5f3f8a708d754d51d8f62eaa7e64b0da5c69a8" + } + }, + "checks": { + "workspace_all_targets_all_features": { + "passed": 1107, + "failed": 0, + "ignored": 14, + "suites": 60 + }, + "release_cli_headless": { + "passed": 73, + "failed": 0, + "ignored": 2, + "suites": 10 + }, + "extracted_distribution": { + "passed": 2, + "failed": 0, + "ignored": 0, + "suites": 1 + }, + "clippy_all_targets_all_features": "passed; warnings denied", + "format": "passed", + "git_diff_check": "passed", + "docs_workflow_reference_scan": "no matches", + "edited_specification_links": "all resolve", + "uncertain_installed_media_admission": { + "passed": 1, + "failed": 0, + "ignored": 0, + "suites": 1 + } + }, + "commands": [ + "cargo test --workspace --all-targets --all-features --no-fail-fast", + "cargo test --release -p prometeu-host-headless -p prometeu-cli --lib --tests", + "cargo clippy --workspace --all-targets --all-features -- -D warnings", + "cargo fmt --all -- --check", + "./scripts/local-dist.sh --artifacts local --target aarch64-apple-darwin --allow-dirty", + "PROMETEU_PROTOCOL_TEST_INSTALL= cargo test -p prometeu-cli --test automation_process packaged_ -- --ignored --test-threads=1" + ], + "distribution": { + "builder": "cargo-dist 0.30.3 via existing local-dist workflow", + "target": "aarch64-apple-darwin", + "profile": "dist (inherits release, LTO)", + "archive": "target/distrib/prometeu-cli-aarch64-apple-darwin.zip", + "archive_sha256": "a6f66e814e0e9254cc4bba5e4a4307c9ec8a9963f8332f2f64a283a376d93b7c", + "extracted_to": "/tmp/pln199-install-0x57zot6", + "binary_sha256": { + "prometeu": "182e4d9a4d32201c8ad892a11c297de7059dcc0a837660bdd173be44808b9906", + "prometeu-headless": "7703190f63844d91fa125ba3a322b5e771db79a282b3cfbb3480eef76422b6ef", + "prometeu-runtime": "0e8e692395cedea799b6d555b416e40536dcabf3a98a2061327d2010c478e446" + }, + "included_schemas_and_spec": "byte-identical to current checkout", + "qualification_harness_profile": "dev harness invokes only extracted dist executables" + }, + "neutral_fixture": { + "producer": "runtime TestProgram / Registry writer / assembler; no frontend input or dependency", + "source": "crates/dev/prometeu-test-support/src/memcard_fixture.rs", + "source_sha256": "f63fd0c6dff5b862d228709d9160b38ab9edc1a90e62b051eb6540706977bd0f", + "save_bytes": [ + 0, + 127, + 128, + 255 + ], + "app_id": 4294967295, + "versions": [ + "1", + "2" + ], + "oracles": { + "101": "guest query SUCCESS", + "104": "MEMORY_ONLY, remains dirty", + "201": "exact prior readback, reader has no save/presentation import", + "301": "dirty RAM, no commit" + }, + "readback_checks": "separate public-dispatcher processes; exact bytes, no retained reader request and unchanged entire image; repeated across app_version and read-only memory-existing" + }, + "additional_qualification": [ + "minor/capability/schema parsing and 1.0 regression", + "dirty shutdown/reset refusal keeps session/channel; explicit discard and memory-only", + "missing/corrupt/read-only/access-denied errors, no fallback", + "cross-process RW/RO/hardlink/symlink exclusion, non-replacing creation race, actual owner process-death release", + "native controlled failures before/inside publication; lock retained with unceased IO; immutable original result and late worker error", + "same-card revalidation preserves RAM/continuation/original request; wrong identity rejected; explicit RAM detach", + "idle IO observation leaves guest PC/stack/tick/frame unchanged", + "desktop dispatcher forwards explicit options without launching a GUI", + "uncertain installed media remains write-blocked after session teardown; persistent readmission is refused pending explicit revalidation" + ], + "limits": [ + "Execution qualified on this macOS arm64 host, not other targets or storage devices.", + "No physical power-cut or latency claim.", + "14 unrelated/manual tests are ignored by the generic workspace gate; the two packaged tests are separately executed and passed.", + "Future frontend/client integration remains external and is not claimed." + ], + "implementation_findings": [ + "Lifecycle bootstrap can consume a debug step marker before the requested logical frame; headless retains its active advance until frame/stop.", + "Host dialogs may reuse FrameId zero; canonical capture excludes their producer.", + "Worker return is tracked separately from retained results and presence of a backend after failed reacquisition.", + "Ending a session does not clear uncertain publication; installed-media health and admission must preserve the write block." + ], + "historical_investigation": "investigation/summary.json records the earlier baseline diagnosis, not the implemented protocol" +} diff --git a/discussion/lessons/DSC-0068-memcard-public-host-persistence/evidence/uncertain.log b/discussion/lessons/DSC-0068-memcard-public-host-persistence/evidence/uncertain.log new file mode 100644 index 0000000..54c412a --- /dev/null +++ b/discussion/lessons/DSC-0068-memcard-public-host-persistence/evidence/uncertain.log @@ -0,0 +1,8 @@ + Compiling prometeu-system v0.1.0 (/Users/niltonconstantino/personal/workspace.personal/intrepid/prometeu/runtime/crates/console/prometeu-system) + Finished `test` profile [unoptimized + debuginfo] target(s) in 3.55s + Running unittests src/lib.rs (target/debug/deps/prometeu_system-5bd0bf863c9e944e) + +running 1 test +test services::memcard::admission::tests::idle_uncertain_media_remains_blocked_before_another_persistent_admission ... ok + +test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 231 filtered out; finished in 0.05s diff --git a/discussion/lessons/DSC-0068-memcard-public-host-persistence/evidence/workspace-final.log b/discussion/lessons/DSC-0068-memcard-public-host-persistence/evidence/workspace-final.log new file mode 100644 index 0000000..7493ab9 --- /dev/null +++ b/discussion/lessons/DSC-0068-memcard-public-host-persistence/evidence/workspace-final.log @@ -0,0 +1,1492 @@ + Compiling prometeu-system v0.1.0 (/Users/niltonconstantino/personal/workspace.personal/intrepid/prometeu/runtime/crates/console/prometeu-system) + Compiling prometeu-firmware v0.1.0 (/Users/niltonconstantino/personal/workspace.personal/intrepid/prometeu/runtime/crates/console/prometeu-firmware) + Compiling prometeu-host-headless v0.1.0 (/Users/niltonconstantino/personal/workspace.personal/intrepid/prometeu/runtime/crates/host/prometeu-host-headless) + Compiling prometeu-host-desktop-winit v0.1.0 (/Users/niltonconstantino/personal/workspace.personal/intrepid/prometeu/runtime/crates/host/prometeu-host-desktop-winit) + Compiling prometeu-cli v0.1.0 (/Users/niltonconstantino/personal/workspace.personal/intrepid/prometeu/runtime/crates/tools/prometeu-cli) + Finished `test` profile [unoptimized + debuginfo] target(s) in 18.63s + Running unittests src/lib.rs (target/debug/deps/pbxgen_dummy_boy-dce9258472bf6e2f) + +running 2 tests +test tests::generated_program_is_pbx_module_with_expected_syscalls ... ok +test tests::manifest_declares_distinct_game_identity ... ok + +test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running unittests src/main.rs (target/debug/deps/pbxgen_dummy_boy-589cfc49a516244f) + +running 0 tests + +test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running unittests src/lib.rs (target/debug/deps/pbxgen_stress-b18661403ab7c024) + +running 1 test +test tests::assets_pack_contains_preloaded_glyph_and_scene_assets ... ok + +test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running unittests src/main.rs (target/debug/deps/pbxgen_stress-a773de9e802e9b7f) + +running 0 tests + +test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running unittests src/lib.rs (target/debug/deps/prometeu_bytecode-b03903968aa4281f) + +running 5 tests +test decoder::tests::unknown_opcode_is_reported_deterministically ... ok +test load_limits::tests::peak_tracks_admitted_capacity_through_refunds_and_failed_transactions ... ok +test opcode_spec::tests::every_opcode_has_spec_and_imm_defined ... ok +test value::tests::test_value_conversions ... ok +test value::tests::test_value_equality ... ok + +test result: ok. 5 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running tests/disasm_roundtrip.rs (target/debug/deps/disasm_roundtrip-f43ba75c22920a7f) + +running 1 test +test roundtrip_disasm_assemble_byte_equal_with_typed_callables ... ok + +test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running tests/disasm_snapshot.rs (target/debug/deps/disasm_snapshot-fc78a4d37cd242d7) + +running 1 test +test snapshot_representative_program_is_stable ... ok + +test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running tests/registry_isa.rs (target/debug/deps/registry_isa-00db93a523224f1a) + +running 9 tests +test all_typed_instructions_match_independent_bytes_and_costs ... ok +test collection_literal_encodings_roundtrip_and_reject_every_truncation ... ok +test collection_effects_and_cached_initialization_width_are_exact ... ok +test decoder_extreme_pc_does_not_overflow ... ok +test invalid_type_immediates_are_contextual_load_errors ... ok +test range_copy_encoding_effects_and_registry_categories_are_independent_oracles ... ok +test removed_storage_encodings_and_mnemonics_are_unsupported ... ok +test slot_effects_resolve_semantic_widths_and_reference_categories ... ok +test assembler_rejects_missing_overflowing_or_ambiguous_type_ids ... ok + +test result: ok. 9 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.01s + + Running tests/registry_v0.rs (target/debug/deps/registry_v0-b660584b365b27f7) + +running 41 tests +test all_builtin_widths_native_layout_and_unknown_imports ... ok +test complete_module_writer_rejects_code_range_mismatch ... ok +test complete_module_writer_rejects_invalid_payload_records_without_retaining_scratch ... ok +test constant_string_limits_are_checked_before_materialization ... ok +test array_stride_uses_stored_element_layout_and_defaults_are_typed ... ok +test budget_boundaries_are_transactional_and_product_ceiling_cannot_be_raised ... ok +test captures_section_has_independent_bytes_and_strict_shape ... ok +test complete_module_writer_preserves_non_registry_encodings ... ok +test complete_module_writer_checks_constant_quotas_before_payload_allocation ... ok +test complete_module_writer_matches_independent_minimal_bytes_and_refunds_scratch ... ok +test duplicate_imports_and_arrays_and_structural_cycles_fail ... ok +test envelope_mutations_have_typed_reasons ... ok +test export_and_debug_references_are_checked_and_table_tails_rejected ... ok +test every_truncated_envelope_is_rejected_without_panic ... ok +test constants_are_strict_and_validate_every_tag_without_lossy_utf8 ... ok +test fn_array_structural_cycles_reject_and_nominal_anchors_terminate ... ok +test fn_descriptor_bytes_are_independent_of_execution_width_caches ... ok +test fn_keys_ignore_names_but_preserve_logical_parameter_and_result_order ... ok +test independent_multi_slot_signature_fixture_has_no_serialized_widths ... ok +test full_pbx_validation_accepts_independent_minimal_fixture ... ok +test invalid_references_are_not_indexed ... ok +test literal_zero_max_stack_is_preserved_and_frame_limits_are_not_truncated ... ok +test lifecycle_roles_resolve_and_roundtrip_with_strict_validation ... ok +test logical_scalar_layout_and_empty_nominal_identity ... ok +test mandatory_empty_sections_are_required ... ok +test memcard_role_has_its_own_signature_and_does_not_reinterpret_function_id ... ok +test multi_slot_signatures_derive_counts_and_validate_exact_trait_pair ... ok +test name_limits_include_aggregate_and_empty_is_not_absent ... ok +test nominal_recursion_and_forward_references_terminate ... ok +test oversized_counts_fail_before_dependent_allocation ... ok +test owned_payload_refusal_rolls_back_all_ownership_and_preserves_prior_budget ... ok +test nonfinite_constant_payloads_are_rejected_with_index_and_exact_offset ... ok +test owned_payloads_preserve_utf8_float_bits_names_and_binding_declarations ... ok +test owned_v0_decoder_accepts_independent_bytes_without_publishing_an_image ... ok +test record_flags_utf8_trailing_bytes_and_unknown_categories_fail ... ok +test reference_map_probe ... ignored, explicit layout measurement; not a timing assertion +test representative_records_match_fixed_bytes_and_preserve_names_without_debug ... ok +test work_retained_and_temporary_limits_refuse_before_publication ... ok +test syscall_identity_validation_keeps_versions_distinct_and_rejects_duplicates ... ok +test writer_matches_independent_minimal_envelope ... ok +test long_array_chain_uses_bounded_iteration ... ok + +test result: ok. 40 passed; 0 failed; 1 ignored; 0 measured; 0 filtered out; finished in 0.02s + + Running tests/roundtrip.rs (target/debug/deps/roundtrip-7d5813d2364cd15d) + +running 4 tests +test encode_decode_roundtrip_preserves_structure ... ok +test disasm_contains_expected_mnemonics_and_operands ... ok +test hostcall_roundtrips_with_decimal_index ... ok +test intrinsic_roundtrips_with_hex_id ... ok + +test result: ok. 4 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running unittests src/lib.rs (target/debug/deps/prometeu_cli-0e58d9c406069cd9) + +running 0 tests + +test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running unittests src/main.rs (target/debug/deps/prometeu-6799b88d64f9f2de) + +running 4 tests +test tests::child_exit_code_preserves_non_zero_one ... ok +test tests::child_exit_code_preserves_non_zero_other ... ok +test tests::child_exit_code_preserves_zero ... ok +test tests::child_exit_code_rejects_status_without_numeric_code ... ok + +test result: ok. 4 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running unittests src/bin/prometeu-headless.rs (target/debug/deps/prometeu_headless-5dc493f719f99803) + +running 0 tests + +test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running unittests src/bin/prometeu-runtime.rs (target/debug/deps/prometeu_runtime-358331af5bd37380) + +running 0 tests + +test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running tests/automation_process.rs (target/debug/deps/automation_process-2dffe56e1c9b4269) + +running 22 tests +test memcard_process::desktop_dispatch_forwards_explicit_media_without_interpreting_player_policy ... ok +test handshake_versions_capabilities_and_limits_are_explicit ... ok +test malformed_fragmented_and_oversized_commands_do_not_desynchronize ... ok +test conflicting_work_is_rejected_and_cancellation_reports_partial_progress ... ok +test faults_and_boot_failures_are_structured_not_log_parsing ... ok +test dispatcher_works_from_a_relocated_installation_and_other_cwd ... ok +test lifecycle_and_capture_match_the_in_process_canonical_oracle ... ok +test memcard_process::packaged_memcard_process_persistence ... ignored, requires PROMETEU_PROTOCOL_TEST_INSTALL pointing to an extracted dist archive +test memcard_process::memcard_creation_race_and_process_death_release_real_ownership ... ok +test packaged_installation_smoke ... ignored, requires PROMETEU_PROTOCOL_TEST_INSTALL pointing to an extracted dist archive +test idle_eof_and_truncated_eof_close_the_process ... ok +test memcard_process::memcard_access_denial_is_typed_and_does_not_create_or_modify_media ... ok +test missing_binary_and_invalid_cli_limits_fail_explicitly ... ok +test memcard_process::memcard_dirty_refusal_retains_channel_and_explicit_ram_has_no_save ... ok +test memcard_process::memcard_idle_observation_never_advances_guest_counters ... ok +test memcard_process::memcard_media_errors_and_negotiation_never_select_a_fallback ... ok +test shutdown_and_eof_interrupt_active_work_without_resuming_it ... ok +test memcard_process::memcard_process_ownership_covers_aliases_readers_and_release ... ok +test memcard_process::memcard_public_distinct_process_save_readback_and_version_identity ... ok +test independent_processes_match_pixels_ids_state_and_fault ... ok +test schemas_and_distributed_request_fixtures_are_consistent ... ok +test partial_guest_fault_and_host_watchdog_are_distinct_outcomes ... ok + +test result: ok. 20 passed; 0 failed; 2 ignored; 0 measured; 0 filtered out; finished in 9.53s + + Running tests/registry_fault_schema.rs (target/debug/deps/registry_fault_schema-27aab6f44850452e) + +running 2 tests +test published_load_schema_requires_tag_context_and_the_matching_init_payload ... ok +test published_schema_accepts_structured_resource_fields_and_rejects_unknown_or_negative_values ... ok + +test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.92s + + Running unittests src/lib.rs (target/debug/deps/prometeu_drivers-fcbe981857e539c1) + +running 111 tests +test asset::decode::tests::shared_scene_arithmetic_rejects_overflow_before_allocating ... ok +test asset::decode::tests::pcm_metadata_and_source_range_corpus ... ok +test asset::decode::tests::scene_header_ranges_nonfinite_and_truncation_corpus ... ok +test asset::resumable::tests::canceled_and_superseded_partial_decoders_never_publish ... ok +test asset::tests::shutdown_clears_physical_memory_bank_slots ... ok +test asset::resumable::tests::resumable_sound_and_scene_preserve_existing_formats ... ok +test asset::resumable::tests::shared_preload_waits_for_worker_and_frame_publication ... ok +test asset::resumable::tests::shared_decoder_yields_and_matches_existing_glyph_format ... ok +test asset::decode::tests::physically_truncated_pcm_file_is_rejected_by_both_modes ... ok +test asset::tests::test_asset_backlog_queue_keeps_only_latest_request_per_target ... ok +test asset::tests::test_asset_backlog_queue_reorders_pending_requests ... ok +test asset::decode::tests::physically_truncated_glyph_palette_is_rejected_by_both_modes ... ok +test asset::decode::tests::pcm_chunk_edges_and_odd_tails_have_explicit_baseline_outputs ... ok +test asset::decode::tests::physically_short_scene_file_is_rejected_by_both_modes ... ok +test asset::decode::tests::scene_tile_chunk_edges_flags_and_reserved_bytes ... ok +test asset::tests::test_asset_backlog_reorder_rejects_non_queued_request ... ok +test asset::tests::test_asset_dedup ... ok +test asset::tests::test_decode_glyph_bank_accepts_intermediate_palette_count ... ok +test asset::tests::test_decode_glyph_bank_accepts_max_palette_count ... ok +test asset::tests::test_decode_glyph_bank_reader_matches_buffer_for_variable_palette_count ... ok +test asset::tests::test_decode_glyph_bank_rejects_mismatched_variable_decoded_size ... ok +test asset::tests::test_asset_load_supersedes_previous_request_for_target_slot ... ok +test asset::tests::test_asset_load_uses_stable_handle_for_target_slot ... ok +test asset::tests::test_asset_loading_flow ... ok +test asset::tests::test_asset_pipeline_progress_and_telemetry_snapshot_for_failure ... ok +test asset::tests::test_decode_glyph_bank_rejects_palette_count_above_v1_max ... ok +test asset::tests::test_decode_glyph_bank_rejects_mismatched_variable_serialized_size ... ok +test asset::tests::test_decode_glyph_bank_rejects_palette_count_zero ... ok +test asset::tests::test_decode_glyph_bank_rejects_short_packed_buffer ... ok +test asset::tests::test_decode_scene_bank_from_binary_payload ... ok +test asset::tests::test_decode_scene_bank_rejects_invalid_tile_size ... ok +test asset::tests::test_decode_scene_bank_rejects_invalid_version ... ok +test asset::tests::test_decode_scene_bank_rejects_layer_count_mismatch ... ok +test asset::tests::test_decode_glyph_bank_unpacks_packed_pixels_and_reads_palette_colors ... ok +test asset::tests::test_decode_scene_bank_rejects_tile_count_mismatch ... ok +test asset::tests::test_load_returns_asset_not_found ... ok +test asset::tests::test_load_returns_slot_index_invalid ... ok +test asset::tests::test_op_mode_for_glyphs_none_stages_in_memory ... ok +test asset::tests::test_op_mode_for_glyphs_none_uses_typed_codec ... ok +test asset::tests::test_asset_pipeline_progress_and_telemetry_snapshot_for_success ... ok +test asset::tests::test_op_mode_for_scene_none_reads_direct_from_slice ... ok +test asset::tests::test_op_mode_for_sounds_none_reads_direct_from_slice ... ok +test asset::tests::test_preload_on_init ... ok +test audio::control_tests::failed_callback_cancels_unpublished_prefix_and_its_sample_reference ... ok +test audio::control_tests::lifecycle_publishes_prefix_first_and_aborted_batches_are_cancelled ... ok +test audio::control_tests::lifecycle_and_reset_bypass_full_guest_batch_and_release_samples ... ok +test asset::tests::test_asset_target_status_exposes_empty_and_ready_slot_handle ... ok +test asset::tests::test_status_returns_unknown_handle ... ok +test asset::tests::test_scene_preload_on_init ... ok +test audio::control_tests::prefix_flush_preserves_quota_and_combined_delivery_is_bounded ... ok +test audio::control_tests::quota_is_shared_and_rejections_never_publish_partial_effects ... ok +test audio::tests::play_returns_sample_not_found_when_sample_is_missing ... ok +test audio::tests::play_returns_voice_invalid_for_out_of_range_voice ... ok +test audio::tests::play_sample_returns_voice_invalid_without_side_effects ... ok +test audio::transport::reuse_tests::service_recycles_storage_and_releases_sample_owners ... ok +test audio::transport::tests::realtime_consumer_does_not_wait_for_publication_lock ... ok +test frame_composer::tests::bind_scene_derives_cache_and_resolver_from_eight_pixel_layers ... ok +test frame_composer::tests::bind_scene_stores_scene_identity_and_shared_reference ... ok +test frame_composer::tests::composer_buffer_preserves_integer_layer_ordering ... ok +test frame_composer::tests::composer_buffer_snapshot_closes_into_game2d_packet_without_fade_state ... ok +test frame_composer::tests::frame_composer_emits_ordered_sprites_for_rendering ... ok +test frame_composer::tests::frame_composer_exposes_shared_scene_bank_access ... ok +test frame_composer::tests::bind_scene_panics_when_scene_dependency_is_not_resident ... ok +test frame_composer::tests::frame_composer_starts_unbound_with_empty_owned_state ... ok +test frame_composer::tests::missing_scene_binding_falls_back_to_no_scene_state ... ok +test frame_composer::tests::game2d_frame_composer_facade_closes_equivalent_packet ... ok +test frame_composer::tests::render_frame_panics_when_dependency_disappears_after_bind ... ok +test frame_composer::tests::render_frame_with_scene_applies_refreshes_before_composition ... ok +test frame_composer::tests::render_frame_resolves_glyph_dependency_by_asset_id_not_by_slot_number ... ok +test frame_composer::tests::render_frame_realigns_cache_window_before_refresh_when_camera_moves ... ok +test frame_composer::tests::render_frame_without_scene_uses_sprite_only_path ... ok +test frame_composer::tests::sprite_controller_begin_frame_resets_sprite_count_and_buckets ... ok +test frame_composer::tests::set_camera_stores_top_left_pixel_coordinates ... ok +test frame_composer::tests::render_frame_survives_scene_transition_through_unbind_and_rebind ... ok +test frame_composer::tests::sprite_controller_orders_by_layer_then_priority_then_fifo ... ok +test frame_composer::tests::sprite_controller_drops_overflow_without_panicking ... ok +test frame_composer::tests::unbind_scene_clears_scene_and_cache_state ... ok +test gfx::tests::load_frame_sprites_replaces_slot_first_submission_for_render_state ... ok +test gfx::tests::render_game2d_frame_packet_applies_primitive_commands ... ok +test gfx::tests::cached_tile_draw_panics_for_invalid_palette_reference - should panic ... ok +test gfx::tests::test_cached_tile_draws_opaque_color_index_zero ... ok +test gfx::tests::render_scene_from_cache_preserves_layer_and_sprite_order ... ok +test gfx::tests::test_cached_tile_skips_alpha_zero_color_index_zero ... ok +test gfx::tests::test_draw_line ... ok +test gfx::tests::sprite_draw_panics_for_invalid_palette_reference - should panic ... ok +test gfx::tests::test_draw_pixel ... ok +test gfx::tests::render_scene_from_cache_uses_materialized_cache_not_canonical_scene ... ok +test gfx::tests::test_draw_rect ... ok +test gfx::tests::test_fill_circle ... ok +test gfx::tests::test_draw_square ... ok +test gfx::tests::test_sprite_draws_opaque_color_index_zero ... ok +test gfx::tests::test_sprite_skips_alpha_zero_color_index_zero ... ok +test hardware::tests::hardware_constructs_frame_composer_with_shared_scene_bank_access ... ok +test hardware::tests::emit_sprite_rejects_palette_id_outside_loaded_glyph_bank ... ok +test hardware::tests::render_submission_sink_accepts_owned_shell_ui_submission ... ok +test hardware::tests::publish_game2d_submission_applies_gfx2d_overlay_after_active_scene ... ok +test hardware::tests::render_submission_sink_accepts_owned_game2d_submission ... ok +test local_render_backend::tests::local_backend_renders_game2d_submission_to_owned_frame ... ok +test local_render_backend::tests::local_backend_renders_shell_ui_submission_to_owned_frame ... ok +test memory_banks::tests::render_resource_access_exposes_read_only_glyph_and_scene_banks_without_arc_contract ... ok +test memory_banks::tests::render_resource_access_traits_are_thread_safe ... ok +test hardware::tests::hardware_can_render_scene_from_shared_scene_bank_pipeline ... ok +test wall_clock::tests::explicit_changes_allow_regression_and_saturate_without_advancing_on_read ... ok +test test_platform::tests::test_platform_initializes_required_facades ... ok +test test_platform::tests::selected_clock_is_shared_with_hardware_and_can_be_injected ... ok +test hardware::tests::publish_game2d_submission_uses_packet_scene_and_sprites_not_live_frame_state ... ok +test asset::tests::test_asset_telemetry_incremental ... ok +test asset::tests::test_commit_and_cancel_return_explicit_statuses ... ok +test asset::tests::test_sound_asset_loading ... ok +test asset::tests::test_scene_asset_loading ... ok +test asset::decode::tests::glyph_layout_palette_nibbles_and_chunk_boundaries ... ok + +test result: ok. 111 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.04s + + Running unittests src/lib.rs (target/debug/deps/prometeu_firmware-52d0583f5e328b59) + +running 46 tests +test firmware::firmware::tests::host_home_request_delivers_pause_tick_before_forced_suspension ... ok +test firmware::firmware::tests::audio_lifecycle_publishes_interrupted_frame_prefix_before_hook ... ok +test firmware::firmware::tests::audio_lifecycle_publishes_with_pending_frame_and_reset_invalidates_session ... ok +test firmware::firmware::tests::direct_game_boot_does_not_depend_on_userland_run_cart_syscall ... ok +test firmware::firmware::tests::game_running_transitions_to_app_crashes_when_runtime_surfaces_trap ... ok +test firmware::firmware::tests::audio_lifecycle_flushes_prefix_when_optional_hooks_are_absent ... ok +test firmware::firmware::tests::hub_home_does_not_launch_shell_before_home_input_is_armed ... ok +test firmware::firmware::tests::hub_home_click_launches_shell_a_as_native_shell_task_window ... ok +test firmware::firmware::tests::hub_home_click_launches_shell_b_as_native_shell_task_window ... ok +test firmware::firmware::tests::direct_boot_target_still_reaches_game_running_without_games_root ... ok +test firmware::firmware::tests::lifecycle_debugger_hostcalls_use_real_session_handles ... ok +test firmware::firmware::tests::games_root_home_click_reaches_game_running ... ok +test firmware::firmware::tests::lifecycle_debugger_retains_budget_and_steps_without_game_frames ... ok +test firmware::firmware::tests::lifecycle_direct_suspend_and_shell_handoff_wait_for_callback ... ok +test firmware::firmware::tests::hub_home_click_launches_game_library_entry_through_load_cartridge ... ok +test firmware::firmware::tests::hub_home_clicking_resident_game_resumes_same_task_without_reloading ... ok +test firmware::firmware::tests::lifecycle_home_resume_callbacks_are_outside_frames_and_preserve_pc ... ok +test firmware::firmware::tests::lifecycle_resume_failure_blocks_gameplay_and_conflicting_pause_request ... ok +test firmware::firmware::tests::hub_home_failed_game_launch_remains_home_and_logs_error ... ok +test firmware::firmware::tests::invalid_games_root_candidate_is_omitted_from_home_launch_boundary ... ok +test firmware::firmware::tests::load_cartridge_routes_system_apps_to_system_running ... ok +test firmware::firmware::tests::load_cartridge_routes_game_apps_to_game_running ... ok +test firmware::firmware::tests::load_cartridge_transitions_to_app_crashes_when_vm_init_fails ... ok +test firmware::firmware::tests::reset_routes_cartridge_boot_target_to_launch_hub ... ok +test firmware::firmware::tests::reset_clears_vm_sessions_and_runtime_identity ... ok +test firmware::firmware::tests::lifecycle_roles_are_independently_optional ... ok +test firmware::firmware::tests::reset_routes_hub_boot_target_to_splash_screen ... ok +test firmware::firmware::tests::failed_game_switch_returns_home_without_restoring_previous_game ... ok +test firmware::firmware::tests::resident_game_resume_restores_render_owner_after_resume_event_and_barriers_input ... ok +test firmware::firmware::tests::resident_game_termination_noops_when_no_game_is_resident ... ok +test firmware::firmware::tests::shell_running_closes_task_and_returns_hub_home_for_focused_hub_window ... ok +test firmware::firmware::tests::shell_running_close_click_uses_lifecycle_and_returns_hub_home ... ok +test firmware::firmware::tests::memory_only_admission_runs_typed_guest_boot_and_warns_before_discard ... ok +test firmware::firmware::tests::shell_running_closes_task_and_returns_hub_home_for_focused_overlay_window ... ok +test firmware::firmware::tests::resident_game_and_vm_shell_sessions_tick_independently ... ok +test firmware::firmware::tests::shell_running_closes_task_and_returns_hub_home_for_other_task_window ... ok +test firmware::firmware_step_crash_screen::tests::crash_step_formats_trap_from_structured_report ... ok +test firmware::firmware::tests::hub_home_clicking_different_game_terminates_previous_resident_session ... ok +test firmware::firmware::tests::shell_running_closes_task_and_returns_hub_home_without_focused_window ... ok +test firmware::firmware::tests::system_running_ticks_focused_system_app_through_hub_pipeline ... ok +test firmware::firmware::tests::shell_running_start_close_uses_lifecycle_and_returns_hub_home ... ok +test firmware::firmware::tests::hub_kill_control_click_terminates_resident_game_and_stays_home ... ok +test firmware::firmware::tests::resident_game_termination_closes_session_and_cleans_runtime_state ... ok +test firmware::firmware::tests::lifecycle_faults_exhaustion_and_halt_never_resume_gameplay ... ok +test firmware::firmware::tests::repository_stress_to_dummy_boy_switch_is_end_to_end ... ok +test firmware::firmware::tests::game_home_shell_hub_same_game_flow_is_end_to_end_deterministic ... ok + +test result: ok. 46 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.53s + + Running unittests src/lib.rs (target/debug/deps/prometeu_hal-c5fd798be115d0b0) + +running 97 tests +test cartridge_loader::tests::load_with_asset_capability_requires_assets_pa ... ok +test cartridge_loader::tests::directory_loader_rejects_oversized_pbx_with_default_limit ... ok +test cartridge_loader::tests::load_rejects_invalid_assets_pa_prelude ... ok +test cartridge_loader::tests::load_rejects_unknown_codec_string_in_assets_pa_header ... ok +test cartridge_loader::tests::load_rejects_invalid_assets_pa_header_json ... ok +test cartridge_loader::tests::load_rejects_preload_slot_clash_per_bank_type ... ok +test cartridge_loader::tests::load_with_all_capability_normalizes_to_all_flags ... ok +test cartridge_loader::tests::load_rejects_preload_with_missing_asset_id ... ok +test cartridge_loader::tests::load_reads_asset_table_and_preload_from_assets_pa_header ... ok +test cartridge_loader::tests::load_rejects_legacy_raw_codec_string_in_assets_pa_header ... ok +test cartridge_loader::tests::program_admission_accepts_exact_limit_and_rejects_growth_after_metadata ... ok +test cartridge_loader::tests::program_admission_handles_empty_short_and_interrupted_reads ... ok +test cartridge_loader::tests::program_admission_rejects_oversized_metadata_before_reading ... ok +test debugger_protocol::tests::test_fault_event_serialization ... ok +test debugger_protocol::tests::test_get_state_serialization ... ok +test debugger_protocol::tests::test_telemetry_event_serialization ... ok +test glyph_bank::tests::glyph_bank_can_materialize_v1_max_palette_count ... ok +test glyph_bank::tests::invalid_palette_lookup_is_distinct_from_transparent_color ... ok +test glyph_bank::tests::glyph_bank_rejects_zero_resident_palettes - should panic ... ok +test glyph_bank::tests::new_glyph_bank_uses_single_resident_palette ... ok +test host_return::tests::full_native_result_buffer_does_not_invoke_string_allocator ... ok +test host_return::tests::native_results_cannot_grow_the_reserved_buffer_or_exceed_the_signature ... ok +test log::log_service::tests::test_get_after ... ok +test log::log_service::tests::test_get_recent ... ok +test log::log_service::tests::test_ring_buffer_capacity ... ok +test host_return::tests::measured_native_encoding_matches_utf8_lossy_hex_and_join_semantics ... ok +test owned_frame::tests::checked_constructor_rejects_empty_dimensions ... ok +test owned_frame::tests::checked_constructor_rejects_short_pixel_buffer ... ok +test owned_frame::tests::owned_rgba8888_frame_preserves_metadata_and_pixels ... ok +test cartridge_loader::tests::load_with_duplicate_capabilities_fails ... ok +test cartridge_loader::tests::load_with_legacy_input_capability_fails ... ok +test owned_frame::tests::checked_constructor_rejects_stride_smaller_than_width ... ok +test cartridge_loader::tests::load_with_multiple_capabilities_combines_flags ... ok +test owned_frame::tests::row_returns_visible_width_without_stride_padding ... ok +test platform::tests::core_platform_facades_are_object_safe ... ok +test platform::tests::render_submit_error_is_typed_and_debuggable ... ok +test render_resources::tests::missing_resources_return_none ... ok +test cartridge_loader::tests::load_with_none_capability_keeps_zero_flags ... ok +test render_resources::tests::reads_resident_resources_by_id ... ok +test cartridge_loader::tests::load_with_unknown_capability_fails ... ok +test render_submission::tests::closed_submission_owns_command_payload ... ok +test render_submission::tests::coherence_check_rejects_mismatched_envelope ... ok +test render_submission::tests::frame_id_advances_monotonically_with_wrapping_arithmetic ... ok +test render_submission::tests::constructors_pin_app_mode_to_packet_kind ... ok +test cartridge_loader::tests::load_with_single_capability_normalizes_to_flag ... ok +test render_submission::tests::ownership_can_be_stamped_by_runtime ... ok +test render_worker::tests::render_worker_telemetry_defaults_to_zero ... ok +test render_worker::tests::render_worker_error_is_copy_equatable_and_debuggable ... ok +test render_worker::tests::render_worker_telemetry_records_counters_and_frame_ids ... ok +test scene_bank::tests::scene_bank_owns_exactly_four_layers ... ok +test cartridge_loader::tests::load_without_asset_capability_accepts_missing_assets_pa ... ok +test scene_layer::tests::scene_layer_preserves_parallax_factor_and_tilemap_ownership ... ok +test scene_viewport_cache::tests::cache_entry_fields_are_derived_from_scene_tiles ... ok +test scene_viewport_cache::tests::column_refresh_only_updates_the_requested_column ... ok +test scene_viewport_cache::tests::corner_style_region_update_does_not_touch_outside_tiles ... ok +test scene_viewport_cache::tests::layer_cache_wraps_ring_origin_for_negative_and_large_movements ... ok +test scene_viewport_cache::tests::layer_cache_wraps_ring_origin_under_window_movement ... ok +test scene_viewport_cache::tests::line_refresh_only_updates_the_requested_line ... ok +test scene_viewport_cache::tests::materialization_populates_all_four_layers ... ok +test cartridge_loader::tests::load_without_capabilities_defaults_to_none ... ok +test scene_viewport_cache::tests::move_window_to_matches_incremental_ring_movement ... ok +test scene_viewport_cache::tests::out_of_bounds_logical_origins_materialize_default_entries_after_wrap ... ok +test scene_viewport_cache::tests::partial_refresh_uses_wrapped_physical_slots_after_window_move ... ok +test scene_viewport_cache::tests::refresh_after_wrapped_window_move_materializes_new_logical_tiles ... ok +test scene_viewport_cache::tests::region_refresh_only_updates_the_requested_area ... ok +test scene_viewport_cache::tests::scene_swap_invalidation_clears_all_layers ... ok +test scene_viewport_cache::tests::ringbuffer_preserves_logical_tile_mapping_across_long_mixed_movements ... ok +test scene_viewport_resolver::tests::reset_scene_requests_full_invalidation_for_all_layers ... ok +test scene_viewport_resolver::tests::first_update_initializes_master_and_layer_anchors ... ok +test syscalls::tests::audio_control_abi_and_capability_are_stable ... ok +test scene_viewport_resolver::tests::per_layer_copy_requests_follow_parallax_factor ... ok +test scene_viewport_resolver::tests::corner_trigger_converts_to_non_overlapping_region_requests ... ok +test syscalls::tests::declared_resolver_accepts_mixed_status_first_surface_as_a_single_module ... ok +test scene_viewport_resolver::tests::hysteresis_prevents_small_back_and_forth_refresh_churn ... ok +test scene_viewport_resolver::tests::anchors_clamp_near_scene_edges ... ok +test syscalls::tests::declared_resolver_rejects_abi_mismatch ... ok +test syscalls::tests::declared_resolver_rejects_missing_capability ... ok +test syscalls::tests::declared_resolver_rejects_legacy_status_first_signatures ... ok +test syscalls::tests::declared_resolver_rejects_unknown_identity ... ok +test syscalls::tests::declared_resolver_returns_expected_id_for_known_identity ... ok +test scene_viewport_resolver::tests::repeated_high_speed_movement_advances_in_tile_steps ... ok +test syscalls::tests::resolver_enforces_capabilities ... ok +test syscalls::tests::resolver_exposes_split_render_capabilities ... ok +test syscalls::tests::resolver_rejects_removed_bank_slot_info_identity ... ok +test syscalls::tests::resolver_rejects_removed_legacy_gfx_set_sprite_identity ... ok +test syscalls::tests::resolver_rejects_unknown_identity ... ok +test syscalls::tests::resolver_returns_expected_id_for_known_identity ... ok +test syscalls::tests::resolver_rejects_userland_system_run_cart_identity ... ok +test syscalls::tests::every_syscall_has_metadata ... ok +test syscalls::tests::memcard_syscall_signatures_are_pinned ... ok +test syscalls::tests::status_first_syscall_signatures_are_pinned ... ok +test telemetry::tests::snapshot_includes_internal_allocation_evidence ... ok +test telemetry::tests::snapshot_maps_render_worker_telemetry ... ok +test telemetry::tests::snapshot_uses_persisted_last_frame_logs ... ok +test telemetry::tests::test_certifier_violations ... ok +test tilemap::tests::tilemap_tile_write_and_read_remain_canonical ... ok +test value_snapshot::tests::serialization_contains_values_and_never_exports_native_domain_metadata ... ok + +test result: ok. 97 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.02s + + Running unittests src/lib.rs (target/debug/deps/prometeu_host_desktop_winit-88b36c5554b717c1) + +running 59 tests +test audio::control_tests::desktop_audio_device_smoke ... ignored, requires a real desktop audio device; emits a brief quiet tone +test audio::control_tests::empty_samples_terminate_without_indexing ... ok +test audio::control_tests::fractional_interpolation_uses_loop_seam_or_actual_tail ... ok +test audio::control_tests::one_shot_ignores_markers_and_loop_preserves_intro ... ok +test audio::control_tests::fifo_reuse_and_inactive_setters_do_not_create_play_defaults ... ok +test audio::control_tests::pcm_controls_preserve_position_and_stop_is_idempotent ... ok +test audio::control_tests::failed_or_stalled_output_releases_backpressure ... ok +test audio::control_tests::absent_partial_and_invalid_markers_fall_back_to_full_sample ... ok +test audio::control_tests::multiple_wrap_pitch_preserves_selected_interval_and_signal ... ok +test audio::control_tests::pause_and_session_reset_work_with_pending_batches ... ok +test audio::control_tests::play_before_home_cannot_restart_after_callback_stop_and_resume ... ok +test audio::control_tests::short_loops_and_extreme_pitch_remain_finite_and_release_at_completion ... ok +test audio::control_tests::unloading_bank_keeps_playback_until_stop ... ok +test audio::tests::test_init_returns_error_when_no_output_device_exists ... ok +test audio::control_tests::extreme_pitch_and_source_rates_keep_positions_finite ... ok +test audio::reclamation_tests::stale_delivery_moves_whole_vectors_to_service_without_changing_playback ... ok +test audio::tests::test_init_populates_audio_state_on_success ... ok +test audio::tests::test_init_returns_error_when_stream_build_fails ... ok +test audio::tests::test_init_returns_error_when_stream_play_fails ... ok +test audio::tests::test_service_without_audio_is_safe ... ok +test audio::reclamation_tests::failure_stall_and_teardown_release_callback_and_pending_owners ... ok +test audio::tests::test_update_stats_without_audio_is_safe ... ok +test cap::tests::test_load_cap_config_not_found ... ok +test audio::reclamation::tests::two_packets_conserve_capacity_across_service_starvation ... ok +test debugger::tests::setup_boot_target_ignores_hub_and_non_debug_cartridges ... ok +test debugger::tests::handle_command_start_leaves_waiting_for_start_mode ... ok +test debugger::tests::handle_command_updates_pause_and_step_flags_without_host_io ... ok +test input::tests::clearing_guest_signals_preserves_system_home_control ... ok +test input::tests::escape_requests_home_without_mutating_guest_pad ... ok +test input::tests::existing_keyboard_pad_mapping_is_preserved ... ok +test input::tests::home_release_does_not_emit_a_new_home_request ... ok +test input::tests::physical_home_requests_home_without_mutating_guest_pad ... ok +test runner::tests::desired_control_flow_uses_idle_poll_when_machine_is_not_running ... ok +test runner::tests::desired_control_flow_waits_until_next_logical_deadline_while_running ... ok +test debugger::tests::breakpoint_commands_mutate_active_vm_session ... ok +test runner::tests::host_debugger_maps_telemetry_from_atomic_snapshot_fields ... ok +test runner::tests::host_presentation_observes_worker_publication_store ... ok +test runner::tests::presentation_state_requests_redraw_for_host_invalidation_without_new_frame ... ok +test runner::tests::host_debugger_maps_cert_events_from_host_owned_sources ... ok +test runner::tests::presentation_state_requests_redraw_for_new_frame_publication ... ok +test cap::tests::test_load_cap_config ... ok +test runner::tests::presentation_state_requests_redraw_when_ownership_changes_with_lower_frame_id ... ok +test runner::tests::presentation_state_requires_initial_redraw_only_once ... ok +test runner::tests::test_debug_port_opens ... ignored, requires localhost TCP bind/connect; run via `make test-debugger-socket` +test runner::tests::test_debug_reconnection ... ignored, requires localhost TCP bind/connect; run via `make test-debugger-socket` +test runner::tests::test_debug_refuse_second_connection ... ignored, requires localhost TCP bind/connect; run via `make test-debugger-socket` +test runner::tests::test_debug_resume_on_disconnect ... ignored, requires localhost TCP bind/connect; run via `make test-debugger-socket` +test runner::tests::test_get_state_returns_response ... ignored, requires localhost TCP bind/connect; run via `make test-debugger-socket` +test runner::tests::worker_frame_presentation_requires_game_state_and_current_ownership ... ok +test utilities::tests::draw_owned_frame_to_rgba8_uses_owned_rgba8888_pixels ... ok +test wall_clock::tests::conversion_truncates_fractions_and_saturates_at_both_limits ... ok +test utilities::tests::draw_rgba8888_to_rgba8_preserves_channel_order_and_alpha ... ok +test wall_clock::tests::system_provider_reads_current_local_time ... ok +test fs_backend::tests::test_host_dir_backend_rejects_delete_root ... ok +test fs_backend::tests::test_host_dir_backend_rejects_traversal_write_and_read ... ok +test fs_backend::tests::test_host_dir_backend_rejects_traversal_for_exists_and_list_dir ... ok +test fs_backend::tests::test_host_dir_backend_mount_and_dirs ... ok +test fs_backend::tests::test_host_dir_backend_round_trip ... ok +test runner::tests::desktop_worker_survives_repeated_home_resume_and_cold_reset ... ok + +test result: ok. 53 passed; 0 failed; 6 ignored; 0 measured; 0 filtered out; finished in 0.39s + + Running unittests src/main.rs (target/debug/deps/prometeu_host_desktop_winit-ebce2a8f41fa6bcb) + +running 0 tests + +test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running tests/audio_callback_allocations.rs (target/debug/deps/audio_callback_allocations-9e6da35af9161daf) + +running 6 tests +test callback_duration_16_voices_with_io_pressure ... ignored, release timing observation with temporary asset-read/save-write pressure +test physical_callback_duration_16_voices_with_io_pressure ... ignored, requires physical audio output; 16 quiet voices and temporary file I/O +test unloaded_banks_empty_samples_and_controls_reclaim_on_service ... ok +test callback_owners_do_not_use_allocator ... ok +test stalled_service_bounds_retention_and_recovers_pending_delivery ... ok +test full_frame_and_combined_lifecycle_fit_one_packet ... ok + +test result: ok. 4 passed; 0 failed; 2 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running benches/wall_clock.rs (target/debug/deps/wall_clock-0889636e36dbadc7) +target=aarch64-macos debug_assertions=true; batch means include dynamic dispatch and loop overhead +system: batches=101 reads_per_batch=10000 ns/read batch_mean p50=63.78 p95=295.79 max=541.67 +controlled: batches=101 reads_per_batch=10000 ns/read batch_mean p50=9.55 p95=290.39 max=554.25 + Running unittests src/lib.rs (target/debug/deps/prometeu_host_headless-e984640770c0f919) + +running 14 tests +test automation::tests::input_snapshot_is_replacement_and_rejects_unknown_fields ... ok +test automation::tests::bounded_lines_accept_fragmentation_and_recover_after_oversize ... ok +test automation::tests::distributed_request_fixtures_are_accepted_by_the_actual_parser ... ok +test automation::wire::fault_tests::load_failure_wire_uses_shared_structured_serializer_and_no_runtime_pc ... ok +test automation::wire::fault_tests::resource_trap_wire_preserves_native_fields_and_source_span ... ok +test automation::tests::response_limit_counts_the_complete_envelope_and_keeps_correlation ... ok +test automation::tests::capture_preserves_independent_ids_and_excludes_padding_without_channel_loss ... ok +test automation::wire::fault_tests::executed_closure_quota_refusal_reaches_wire_with_machine_fields ... ok +test automation::wire::fault_tests::active_host_native_type_fault_preserves_wire_machine_fields ... ok +test host::tests::termination_during_frame_advance_clears_host_step_control ... ok +test host::memcard::tests::explicit_continue_in_ram_preserves_dirty_snapshot_and_uses_no_new_boot ... ok +test host::memcard::tests::same_media_recovery_rejects_replacement_and_preserves_ram_continuation ... ok +test host::memcard::tests::unceased_io_retains_lock_and_terminal_result_survives_late_return_and_reconcile ... ok +test host::resource_qualification_tests::thousand_reset_reload_cycles_release_session_owners_and_preserve_controls ... ok + +test result: ok. 14 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 11.05s + + Running tests/deterministic_control.rs (target/debug/deps/deterministic_control-881ffee51bb6f9f9) + +running 25 tests +test headless_source_has_no_timing_wait_or_interactive_backend_dependency ... ok +test injected_civil_clock_remains_the_runtime_source_across_lifecycle ... ok +test lifecycle_state_and_preconditions_are_structural ... ok +test advance_after_reset_reports_termination_without_ticking ... ok +test clear_input_drops_right ... ok +test batch_stops_early_on_fault_and_reports_partial_progress ... ok +test instruction_step_fault_remains_structured ... ok +test end_of_rom_completes_a_logical_frame ... ok +test audio_play_does_not_need_a_device ... ok +test one_frame_returns_and_captures_the_exact_published_frame ... ok +test controlled_civil_time_is_independent_of_frames_pause_and_reset ... ok +test normalized_touch_edges_and_coordinates_use_the_same_input_surface ... ok +test normalized_button_press_hold_release_and_clear_are_observable ... ok +test step_does_not_complete_a_logical_frame ... ok +test stepping_frame_sync_is_not_a_fault_or_completed_runtime_frame ... ok +test trap_is_structured ... ok +test vm_init_failure_is_returned_as_structured_boot_failure ... ok +test zero_frames_is_an_explicit_noop ... ok +test right_hold_then_release_changes_pixels ... ok +test two_runs_match_oracle ... ok +test reset_matches_fresh_host ... ok +test one_logical_frame_may_span_multiple_internal_ticks ... ok +test three_hundred_frames_complete_without_realtime_pacing ... ok +test outer_frame_limit_is_a_host_error_and_finishes_paused ... ok +test audio_controls_quota_and_multiple_frames_are_device_independent ... ok + +test result: ok. 25 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 1.38s + + Running tests/input_queries.rs (target/debug/deps/input_queries-0c56105c6b3cb13e) + +running 4 tests +test catalogue_has_exact_names_ids_signatures_and_no_endpoint_aliases ... ok +test vm_queries_charge_one_cycle_each_and_allocate_no_guest_objects ... ok +test every_button_uses_its_own_snapshot_and_queries_do_not_advance_frames ... ok +test every_known_query_faults_when_unavailable_and_rejects_arguments ... ok + +test result: ok. 4 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.01s + + Running tests/typed_runtime.rs (target/debug/deps/typed_runtime-303718de85c412f9) + +running 5 tests +test typed_native_argument_fault_inside_callback_reaches_active_host ... ok +test active_host_preserves_removed_opcode_load_context_and_null_fn_trap ... ok +test sync_in_callee_or_closure_resumes_next_pc_with_locals_and_init_once ... ok +test regenerated_cartridges_run_six_complete_frames_on_production_host ... ok +test budget_exhaustion_inside_fn_keeps_the_same_open_logical_frame ... ok + +test result: ok. 5 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.71s + + Running benches/temporal.rs (target/debug/deps/temporal-44072dc86bfb3c86) +headless advance_frames: median=0.013716s frames=300 throughput=21872.27 frames/s samples=10 + Running unittests src/lib.rs (target/debug/deps/prometeu_layer_tests-089575000756f9f0) + +running 0 tests + +test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running tests/bytecode_encode_decode.rs (target/debug/deps/bytecode_encode_decode-a7ece7b1a90fc6e8) + +running 1 test +test encode_decode_edge_immediates_roundtrip ... ok + +test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running tests/frame_continuation.rs (target/debug/deps/frame_continuation-05d51e1e8d7801ba) + +running 1 test +test single_context_frame_continuation_is_deterministic ... ok + +test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running tests/gc_collect_unreachable.rs (target/debug/deps/gc_collect_unreachable-b76473b70c18eff0) + +running 1 test +test gc_collects_unreachable_closures_and_retains_active_environment_through_sync ... ok + +test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.02s + + Running tests/typed_collections.rs (target/debug/deps/typed_collections-d12d79da04710b05) + +running 1 test +test serialized_guest_cycle_and_dynamic_box_cross_real_safepoints_then_reclaim ... ok + +test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.02s + + Running tests/typed_fn.rs (target/debug/deps/typed_fn-9b39c770876a55fa) + +running 1 test +test tuple_returned_callbacks_capture_state_across_a_real_frame_boundary ... ok + +test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running tests/verifier_closure_reject.rs (target/debug/deps/verifier_closure_reject-4d37158151a7a3ec) + +running 1 test +test invalid_image_format_is_rejected_before_execution ... ok + +test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running tests/vm_exec_valid.rs (target/debug/deps/vm_exec_valid-68dbb441e9302291) + +running 1 test +test vm_executes_valid_program_in_slices ... ok + +test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running unittests src/lib.rs (target/debug/deps/prometeu_quality_checks-e45b3e167e81b19a) + +running 0 tests + +test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running tests/coverage_domains.rs (target/debug/deps/coverage_domains-dac57e703061d363) + +running 10 tests +test specialized_entry_files_and_all_descendants_have_the_expected_owner ... ok +test new_source_without_an_owner_is_rejected_even_if_uninstrumented ... ok +test repository_sources_have_exactly_one_coverage_owner ... ok +test malformed_config_and_impossible_line_counts_fail_with_diagnostics ... ok +test unknown_or_duplicate_report_sources_cannot_add_coverage ... ok +test overlapping_domains_are_rejected_before_percentage_comparison ... ok +test specialized_ownership_survives_absent_and_zero_instrumentation ... ok +test missing_empty_or_zero_line_evidence_never_passes_zero_baselines ... ok +test residual_gate_excludes_specialized_domain_and_still_rejects_regression ... ok +test exclusions_and_absolute_relative_report_names_have_exclusive_ownership ... ok + +test result: ok. 10 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 2.30s + + Running tests/no_legacy.rs (target/debug/deps/no_legacy-5e3ea3d69769b110) + +running 1 test +test test_no_legacy_artifacts ... ok + +test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.25s + + Running tests/pvm_frontend_neutrality.rs (target/debug/deps/pvm_frontend_neutrality-cf76f4f317299bc4) + +running 1 test +test pbx_and_pvm_crates_must_not_depend_on_compiler_or_frontend_crates ... ok + +test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running unittests src/lib.rs (target/debug/deps/prometeu_system-688a3e2ef3c05c46) + +running 232 tests +test crash_report::init_diagnostic::tests::all_load_codes_serialize_to_the_normative_tags ... ok +test os::system_os::tests::foreground_stack_starts_at_hub ... ok +test os::system_os::tests::game_session_registers_single_resident_game ... ok +test os::system_os::tests::crash_task_marks_task_and_process_crashed ... ok +test os::system_os::tests::closing_foreground_shell_returns_to_hub ... ok +test crash_report::init_diagnostic::tests::load_tag_and_reference_context_survive_without_fabricating_runtime_pc ... ok +test os::system_os::tests::close_task_marks_task_closed_and_process_stopped_without_removing_entities ... ok +test os::system_os::tests::lifecycle_exposes_process_kind_for_shell_tasks ... ok +test os::system_os::tests::home_request_notifies_game_before_budget_suspends_it ... ok +test os::system_os::tests::lifecycle_operation_missing_task_returns_typed_error ... ok +test os::system_os::tests::lifecycle_operation_missing_process_returns_typed_error ... ok +test crash_report::init_diagnostic::tests::native_abi_and_resource_context_are_machine_fields ... ok +test os::system_os::tests::native_shell_task_does_not_create_vm_session ... ok +test os::system_os::tests::native_shell_foreground_suspends_foreground_resident_game ... ok +test os::system_os::tests::resume_task_from_non_suspended_state_returns_invalid_transition ... ok +test os::system_os::tests::same_resident_game_app_reuses_existing_vm_session ... ok +test os::system_os::tests::resume_task_marks_suspended_task_foreground_and_process_running ... ok +test os::system_os::tests::second_foreground_shell_is_rejected ... ok +test os::system_os::tests::second_resident_game_is_rejected ... ok +test os::system_os::tests::session_cartridge_initialization_returns_typed_error_for_missing_session ... ok +test os::system_os::tests::set_foreground_task_marks_task_and_process_running ... ok +test os::system_os::tests::suspend_task_marks_task_and_process_suspended ... ok +test os::system_os::tests::shell_foreground_keeps_game_resident_and_marks_it_suspended ... ok +test os::system_os::tests::terminate_resident_game_preserves_foreground_shell ... ok +test os::system_os::tests::vm_game_task_creates_vm_session ... ok +test os::system_os::tests::terminate_resident_game_closes_task_and_removes_vm_session ... ok +test os::system_os::tests::vm_debug_operations_target_foreground_shell_before_resident_game ... ok +test os::system_os::tests::vm_session_creation_returns_typed_error_for_missing_process ... ok +test os::system_os::tests::vm_shell_foreground_suspends_foreground_resident_game ... ok +test os::system_os::tests::vm_session_creation_returns_typed_error_for_missing_task ... ok +test os::system_os::tests::vm_shell_load_returns_typed_error_when_foreground_shell_exists ... ok +test os::system_os::tests::vm_shell_task_creates_vm_session ... ok +test programs::prometeu_hub::prometeu_hub::tests::close_button_click_emits_close_only_in_shell ... ok +test programs::prometeu_hub::prometeu_hub::tests::button_hit_test_excludes_right_and_bottom_edges ... ok +test programs::prometeu_hub::prometeu_hub::tests::held_pointer_does_not_emit_click_action ... ok +test programs::prometeu_hub::prometeu_hub::tests::home_layout_exposes_exactly_two_manual_shell_buttons ... ok +test programs::prometeu_hub::prometeu_hub::tests::game_row_click_emits_launch_game_action ... ok +test os::system_os::tests::vm_sessions_hold_independent_runtime_state ... ok +test programs::prometeu_hub::prometeu_hub::tests::home_render_omits_suspended_game_kill_control_without_resident_game ... ok +test programs::prometeu_hub::prometeu_hub::tests::home_render_produces_shell_ui_packet_commands ... ok +test programs::prometeu_hub::prometeu_hub::tests::home_render_shows_suspended_game_kill_control_when_game_is_resident ... ok +test programs::prometeu_hub::prometeu_hub::tests::hub_starts_with_home_input_disarmed ... ok +test programs::prometeu_hub::prometeu_hub::tests::resident_game_indicator_uses_only_resident_game_sessions ... ok +test programs::prometeu_hub::prometeu_hub::tests::shell_a_button_click_emits_launch_action ... ok +test programs::prometeu_hub::prometeu_hub::tests::shell_b_button_click_emits_launch_action ... ok +test programs::prometeu_hub::prometeu_hub::tests::shell_close_button_sits_inside_shell_frame ... ok +test programs::prometeu_hub::prometeu_hub::tests::suspended_game_kill_control_click_emits_kill_action ... ok +test services::async_work::tests::async_work_lane_rejects_submit_after_shutdown ... ok +test programs::prometeu_hub::prometeu_hub::tests::suspended_game_kill_control_truncates_long_titles ... ok +test services::async_work::tests::async_work_lane_shutdown_discards_pending_jobs ... ok +test services::foreground::tests::home_request_moves_resident_game_to_pause_requested ... ok +test services::foreground::tests::foreground_stack_starts_at_hub ... ok +test services::foreground::tests::pause_budget_decrements_before_expiry ... ok +test services::async_work::tests::async_work_lane_runs_jobs_in_submission_order ... ok +test services::foreground::tests::pause_budget_expiry_suspends_game_and_returns_to_hub ... ok +test services::async_work::tests::async_work_lane_runs_higher_priority_io_before_assets ... ok +test services::async_work::tests::async_work_lane_has_one_active_job ... ok +test services::foreground::tests::resume_request_precedes_game_foreground_restore ... ok +test services::foreground::tests::second_resident_game_is_rejected ... ok +test services::foreground::tests::setting_game_foreground_registers_resident_game ... ok +test services::foreground::tests::shell_foreground_keeps_resident_game ... ok +test services::fs::virtual_fs::tests::fs_async_lane_operations_classify_priority_without_public_api_changes ... ok +test services::fs::virtual_fs::tests::test_delete_root_is_rejected_before_backend ... ok +test services::async_work::step_tests::yielded_asset_resumes_same_job_after_priority_save ... ok +test services::fs::virtual_fs::tests::test_invalid_paths_never_reach_backend ... ok +test services::fs::virtual_fs::tests::test_normalize_path_rejects_parent_traversal ... ok +test services::fs::virtual_fs::tests::test_virtual_fs_operations ... ok +test services::fs::virtual_fs::tests::test_virtual_fs_health ... ok +test services::game_library::tests::switch_target_preserves_resolved_identity ... ok +test services::memcard::image::tests::closed_catalog_rejects_duplicates_and_deep_input ... ok +test services::game_library::tests::missing_root_returns_diagnostic_and_no_entries ... ok +test services::game_library::tests::repository_test_cartridges_include_stress_and_dummy_boy ... ok +test services::memcard::image::tests::crc_vectors_and_identity_golden ... ok +test services::memcard::session::tests::memory_snapshot_limits_isolation_and_no_fake_durability ... ok +test services::memcard::session::tests::clear_and_sparse_writes_do_not_expose_previous_bytes ... ok +test services::memcard::image::tests::descriptor_roundtrip_rejects_reserved_and_alias ... ok +test services::async_work::tests::async_work_lane_supports_cooperative_cancellation ... ok +test programs::prometeu_hub::prometeu_hub::tests::native_shell_profile_start_close_does_not_tick_vm ... ok +test programs::prometeu_hub::prometeu_hub::tests::native_shell_profile_close_button_does_not_tick_vm ... ok +test services::memcard::image::tests::maximum_catalog_and_icons_fit_and_preserve_uint64 ... ok +test services::memcard::transaction::tests::async_commit_protects_only_source_and_retains_result_without_occupying_lane ... ok +test services::memcard::transaction::tests::cancellation_prevents_publication_and_generations_do_not_wrap ... ok +test services::memcard::transaction::tests::boot_commit_waits_for_ready_and_publishes_registration_before_payload ... ok +test services::memcard::transaction::tests::corrupted_new_payload_recovers_old_map_with_diagnostic ... ok +test services::game_library::tests::discovery_samples_once_per_scan_and_preserves_adjustments_and_full_range ... ok +test services::memcard::transaction::tests::deferred_boot_memcard_deadline_stays_timeout ... ok +test services::memcard::admission::tests::idle_uncertain_media_remains_blocked_before_another_persistent_admission ... ok +test services::memcard::transaction::tests::ending_a_session_releases_a_completed_unconsumed_request ... ok +test services::memcard::transaction::tests::full_card_admission_preserves_card_and_memory_only_can_extend_existing_data ... ok +test services::memcard::transaction::tests::grow_shrink_removal_and_clean_reassignment ... ok +test services::memcard::transaction::tests::qualify_file_commits_with_production_asset_decoder ... ignored, manual file-host latency qualification; prints measurements for this host +test services::memcard::transaction::tests::lifecycle_cancellation_is_not_a_watchdog_timeout ... ok +test services::memcard::transaction::tests::quarantine_survives_remount_and_is_never_selected ... ok +test services::game_library::tests::discovery_returns_only_immediate_valid_game_directories ... ok +test services::process::process_manager::tests::mark_stopped_updates_process_state ... ok +test services::process::process_manager::tests::mark_suspended_updates_process_state ... ok +test services::memcard::transaction::tests::queued_memcard_watchdog_preserves_timeout_and_guest_reason ... ok +test services::memcard::transaction::tests::reinsertion_retains_ram_and_different_card_requires_explicit_load ... ok +test services::process::process_manager::tests::spawn_native_shell_creates_running_process ... ok +test services::process::process_manager::tests::remove_stopped_keeps_running_processes ... ok +test services::process::process_manager::tests::spawn_vm_game_creates_running_process ... ok +test services::process::process_manager::tests::spawn_vm_shell_creates_running_process ... ok +test services::process::process_manager::tests::unknown_process_transition_returns_false ... ok +test services::task::task_manager::tests::crashed_foreground_task_clears_foreground ... ok +test services::task::task_manager::tests::close_foreground_task_clears_foreground ... ok +test services::task::task_manager::tests::create_game_task_registers_task ... ok +test services::task::task_manager::tests::set_foreground_marks_task_as_foreground ... ok +test services::task::task_manager::tests::set_foreground_moves_previous_task_to_background ... ok +test services::task::task_manager::tests::set_foreground_unknown_task_returns_false ... ok +test services::task::task_manager::tests::suspend_foreground_task_clears_foreground ... ok +test services::vm_runtime::async_render_contract_tests::async_render_contract_matrix_rows_have_validation ... ok +test services::vm_runtime::async_render_contract_tests::matrix_epoch_stale_discard_and_telemetry_sync_remain_consistent ... ok +test services::vm_runtime::async_render_contract_tests::matrix_packet_policy_and_pacing_are_mode_specific ... ok +test services::vm_runtime::async_render_contract_tests::matrix_sync_and_worker_paths_share_latest_wins_handoff_contract ... ok +test services::vm_runtime::frame_scheduler::tests::authorizes_one_game_frame_until_completion ... ok +test services::vm_runtime::async_render_contract_tests::matrix_shutdown_failure_and_repeat_are_observable ... ok +test services::vm_runtime::frame_scheduler::tests::completion_is_sequential_without_catch_up_frames ... ok +test services::vm_runtime::frame_scheduler::tests::records_logical_frame_overrun_without_advancing_frame_id ... ok +test services::vm_runtime::lifecycle::tests::vm_runtime_records_and_drains_delivered_game_lifecycle_events ... ok +test services::vm_runtime::render_manager::tests::active_render_policy_follows_app_mode_transition ... ok +test services::vm_runtime::render_manager::tests::app_mode_switch_records_noop_transition_placeholder ... ok +test services::memcard::transaction::tests::catalog_cuts_never_publish_partial_registration ... ok +test services::memcard::transaction::tests::explicit_revalidation_preserves_exclusions_until_separate_reintegration ... ok +test services::vm_runtime::render_manager::tests::close_frame_stamps_submission_with_active_ownership ... ok +test services::vm_runtime::render_manager::tests::frame_closure_assigns_monotonic_frame_ids ... ok +test services::vm_runtime::render_manager::tests::latest_complete_submission_wins_without_queue_growth ... ok +test services::vm_runtime::render_manager::tests::present_panic_is_reported_without_unwinding_to_vm ... ok +test services::vm_runtime::render_manager::tests::local_render_worker_consumes_latest_game_submission ... ok +test services::vm_runtime::render_manager::tests::publish_latest_consumes_pending_but_keeps_observable_last_submission ... ok +test services::vm_runtime::render_manager::tests::publish_latest_discards_stale_epoch_before_present ... ok +test services::vm_runtime::render_manager::tests::publish_latest_hands_submission_to_surface ... ok +test services::vm_runtime::render_manager::tests::rejects_packet_that_does_not_match_active_app_mode ... ok +test services::vm_runtime::render_manager::tests::render_handoff_counts_replacement_before_consume ... ok +test services::vm_runtime::render_manager::tests::render_handoff_discards_pending_submission ... ok +test services::vm_runtime::render_manager::tests::render_handoff_takes_owned_latest_submission ... ok +test services::vm_runtime::render_manager::tests::render_policy_keeps_shell_local_even_when_worker_capability_is_enabled ... ok +test services::vm_runtime::render_manager::tests::render_policy_maps_game_to_frame_scheduled_worker_capable ... ok +test services::vm_runtime::render_manager::tests::render_policy_maps_shell_to_lifecycle_driven_local_sync ... ok +test services::vm_runtime::render_manager::tests::render_policy_resolves_game_worker_only_when_capability_is_enabled ... ok +test services::vm_runtime::render_manager::tests::render_telemetry_counts_produced_replaced_consumed_and_presented ... ok +test services::vm_runtime::render_manager::tests::render_telemetry_counts_stale_repeat_and_error_hooks ... ok +test services::vm_runtime::render_manager::tests::render_telemetry_syncs_to_atomic_telemetry ... ok +test services::memcard::transaction::tests::persistent_save_preempts_real_multichunk_asset_decoders ... ok +test services::vm_runtime::render_manager::tests::request_shutdown_discards_pending_submission_without_presenting ... ok +test services::vm_runtime::render_manager::tests::stopped_consumer_discards_new_pending_submission_before_present ... ok +test services::vm_runtime::render_manager::tests::resume_consumer_allows_presentation_after_shutdown ... ok +test services::vm_runtime::render_manager::tests::transition_render_owner_increments_epoch_for_same_mode_app_swap ... ok +test services::vm_runtime::render_worker::tests::latest_render_frame_store_is_sink_and_observable_publication_source ... ok +test services::vm_runtime::render_worker::tests::render_worker_controller_repeats_latest_published_frame_without_rendering ... ok +test services::vm_runtime::render_worker::tests::render_worker_controller_renders_and_publishes_submission ... ok +test services::vm_runtime::render_worker::tests::render_worker_controller_captures_backend_panic_as_typed_failure ... ok +test services::vm_runtime::render_worker::tests::render_worker_controller_discards_stale_frame_before_publish ... ok +test services::vm_runtime::render_worker::tests::render_worker_controller_starts_and_stops_waiting_worker ... ok +test services::vm_runtime::render_worker_handoff::tests::render_worker_handoff_is_latest_wins_and_counts_replacements ... ok +test services::vm_runtime::render_worker_handoff::tests::render_worker_handoff_takes_owned_submission ... ok +test services::vm_runtime::render_worker::tests::runtime_publishes_game_submissions_to_worker_without_waiting_for_render ... ok +test services::vm_runtime::render_worker_handoff::tests::render_worker_handoff_wait_take_returns_pending_without_blocking ... ok +test services::vm_runtime::render_worker_handoff::tests::render_worker_handoff_wait_returns_shutdown_signal ... ok +test services::vm_runtime::render_worker_test_harness::tests::render_worker_harness_blocks_and_releases_render_without_timing_delay ... ok +test services::vm_runtime::render_worker_test_harness::tests::render_worker_harness_builds_game_and_shell_submissions ... ok +test services::vm_runtime::render_worker_handoff::tests::render_worker_handoff_waits_for_publish_without_timing_delay ... ok +test services::vm_runtime::render_worker_test_harness::tests::render_worker_harness_injects_backend_errors ... ok +test services::vm_runtime::render_worker_test_harness::tests::render_worker_harness_records_published_owned_frames ... ok +test services::vm_runtime::tests::asset_bank::initialize_vm_rejects_removed_bank_slot_info_syscall_identity ... ok +test services::vm_runtime::render_worker::tests::render_worker_controller_reports_shutdown_timeout ... ok +test services::vm_runtime::tests::asset_bank::tick_asset_cancel_unknown_handle_returns_status_not_crash ... ok +test services::vm_runtime::tests::asset_bank::tick_asset_backlog_promote_unknown_handle_returns_status_not_crash ... ok +test services::vm_runtime::tests::asset_bank::tick_asset_commit_operational_error_returns_status_not_crash ... ok +test services::memcard::transaction::tests::file_backend_allocates_full_image_and_reopens_verified_save_without_replacing_files ... ok +test services::vm_runtime::tests::asset_bank::tick_asset_commit_invalid_transition_returns_status_not_crash ... ok +test services::vm_runtime::tests::asset_bank::tick_asset_load_invalid_slot_returns_status_and_zero_handle ... ok +test services::vm_runtime::tests::asset_bank::tick_status_first_surface_smoke_across_composer_audio_and_asset ... ok +test services::vm_runtime::tests::asset_bank::tick_asset_load_missing_asset_returns_status_and_zero_handle ... ok +test services::vm_runtime::tests::asset_bank::tick_asset_target_status_empty_slot_returns_status_first_payload ... ok +test services::vm_runtime::tests::asset_bank::tick_bank_info_returns_slot_summary_not_json ... ok +test services::vm_runtime::tests::asset_bank::tick_asset_status_unknown_handle_returns_status_not_crash ... ok +test services::vm_runtime::tests::audio_controls::normal_entry_return_is_a_successful_implicit_audio_frame ... ok +test services::vm_runtime::tests::audio_controls::frame_publication_backpressure_abort_and_debug_steps ... ok +test services::vm_runtime::tests::fs_memcard::tick_memcard_boot_is_denied_for_non_game_profile ... ok +test services::vm_runtime::tests::fs_memcard::tick_memcard_boot_receives_admitted_context_and_precedes_first_frame ... ok +test services::vm_runtime::tests::initialize_vm_applies_cartridge_capabilities_before_loader_resolution ... ok +test services::vm_runtime::tests::initialize_vm_succeeds_when_cartridge_capabilities_cover_hostcalls ... ok +test services::vm_runtime::tests::initialize_vm_failure_clears_previous_identity_and_handles ... ok +test services::vm_runtime::tests::initialize_vm_success_clears_previous_crash_report ... ok +test services::vm_runtime::tests::reset_clears_cartridge_scoped_runtime_state ... ok +test services::vm_runtime::tests::tick_already_materialized_string_path_records_zero_internal_allocations ... ok +test services::vm_runtime::tests::tick_audio_play_missing_asset_returns_status_not_crash ... ok +test services::vm_runtime::tests::asset_bank::tick_asset_cancel_invalid_transition_returns_status_not_crash ... ok +test services::vm_runtime::tests::tick_audio_play_sample_operational_error_returns_status_not_crash ... ok +test services::vm_runtime::tests::tick_composer_bind_scene_operational_error_returns_status_not_crash ... ok +test services::vm_runtime::tests::tick_audio_play_type_mismatch_surfaces_trap_not_panic ... ok +test services::vm_runtime::tests::tick_audio_play_voice_invalid_returns_status_not_crash ... ok +test services::vm_runtime::tests::tick_composer_emit_sprite_invalid_layer_returns_status_not_crash ... ok +test services::vm_runtime::tests::tick_composer_emit_sprite_invalid_range_returns_status_not_crash ... ok +test services::vm_runtime::tests::tick_composer_emit_sprite_invalid_palette_returns_bank_invalid ... ok +test services::vm_runtime::tests::tick_composer_emit_sprite_operational_error_returns_status_not_crash ... ok +test services::vm_runtime::tests::tick_composer_emit_sprite_type_mismatch_surfaces_trap_not_panic ... ok +test services::memcard::transaction::tests::blocked_host_memcard_watchdog_preserves_outcome_and_escalation ... ok +test services::vm_runtime::tests::tick_draw_text_survives_no_scene_frame_path ... ok +test services::vm_runtime::tests::tick_game_profile_rejects_gfxui_shell_surface ... ok +test services::vm_runtime::tests::tick_game_submissions_are_immutable_and_latest_complete_wins ... ok +test services::vm_runtime::tests::tick_numeric_happy_path_records_zero_internal_allocations ... ok +test services::vm_runtime::tests::tick_renders_bound_eight_pixel_scene_through_frame_composer_path ... ok +test services::vm_runtime::tests::audio_controls::guest_audio_status_matrix_and_type_traps ... ok +test services::vm_runtime::tests::tick_renders_scene_through_public_composer_syscalls ... ok +test services::vm_runtime::tests::audio_controls::guest_play_validates_raw_bank_loop_and_preserves_both_play_forms ... ok +test services::vm_runtime::tests::tick_system_profile_can_use_shared_log_transport ... ok +test services::vm_runtime::tests::tick_returns_error_when_vm_ends_slice_with_trap ... ok +test services::vm_runtime::tests::tick_shell_profile_closes_gfxui_commands_into_shell_packet ... ok +test services::vm_runtime::tests::unpatched_hostcall_is_rejected_before_tick ... ok +test services::vm_runtime::tests::tick_system_profile_rejects_bank_game_surface ... ok +test services::vm_runtime::tests::tick_system_profile_rejects_gfx_game_surface ... ok +test services::vm_runtime::tests::tick_system_profile_rejects_composer_game_surface ... ok +test services::vm_session::tests::creates_vm_game_session_for_vm_game_task ... ok +test services::vm_session::tests::creates_vm_shell_session_for_vm_shell_task ... ok +test services::vm_session::tests::rejects_native_shell_process ... ok +test services::vm_session::tests::finds_resident_game_by_app_id ... ok +test services::vm_session::tests::session_runtime_state_is_independent_per_session ... ok +test services::windows::window_manager::tests::focused_window_belongs_to_task_matches_focused_task_owner ... ok +test services::windows::window_manager::tests::focused_window_belongs_to_task_rejects_hub_owner ... ok +test services::vm_session::tests::remove_for_task_removes_only_matching_session ... ok +test services::windows::window_manager::tests::focused_window_belongs_to_task_rejects_other_task_owner ... ok +test services::windows::window_manager::tests::focused_window_belongs_to_task_rejects_overlay_owner ... ok +test services::windows::window_manager::tests::focused_window_belongs_to_task_rejects_stale_focus ... ok +test services::windows::window_manager::tests::test_window_manager_remove_window ... ok +test services::windows::window_manager::tests::focused_window_belongs_to_task_returns_false_without_focus ... ok +test services::windows::window_manager::tests::test_window_manager_focus ... ok +test services::memcard::transaction::tests::cut_every_commit_step_including_sync_that_persists_then_errors ... ok +test services::memcard::transaction::tests::full_pool_rotates_and_empty_keeps_ownership ... ok +test services::vm_runtime::tests::audio_controls::guest_quota_is_deterministic_and_resets_on_next_frame ... ok +test services::vm_runtime::tests::tick_gfx2d_draw_text_buffers_without_immediate_pixel_mutation_before_frame_close ... ok +test services::vm_runtime::tests::tick_gfx2d_clear_buffers_without_immediate_pixel_mutation_before_frame_close ... ok + +test result: ok. 231 passed; 0 failed; 1 ignored; 0 measured; 0 filtered out; finished in 0.42s + + Running unittests src/lib.rs (target/debug/deps/prometeu_test_support-a1d4104b45210277) + +running 2 tests +test tests::ticking_clock_advances_deterministically ... ok +test tests::rng_reproducible_sequences ... ok + +test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running unittests src/lib.rs (target/debug/deps/prometeu_vm-9829fc21878cfd82) + +running 319 tests +test builtins::tests::builtin_field_offsets_are_stable ... ok +test builtins::tests::builtin_layout_flattening_matches_expected_widths ... ok +test builtins::tests::builtin_constant_materializes_color_values ... ok +test builtins::tests::builtin_lookup_uses_canonical_identity ... ok +test builtins::tests::intrinsic_metadata_exposes_arg_and_return_layouts ... ok +test builtins::tests::input_intrinsic_requires_hardware_context ... ok +test builtins::tests::builtin_constant_registry_is_separate_from_intrinsics ... ok +test builtins::tests::builtin_constant_materializes_vec2_zero ... ok +test builtins::tests::intrinsic_implementations_are_registered_without_syscalls ... ok +test builtins::tests::color_intrinsics_construct_and_project_rgba8888 ... ok +test builtins::tests::pixel_flat_values_validate_with_color_carrier_slot ... ok +test heap::dynamic_box::tests::zero_width_storage_owns_no_allocation_and_is_not_a_valid_guest_box ... ok +test heap::dynamic_tests::forged_box_category_type_width_group_and_registry_are_rejected ... ok +test heap::dynamic_box::tests::interrupted_native_initialization_drops_the_constructed_prefix_and_refunds ... ok +test heap::dynamic_tests::box_guest_quota_boundary_and_late_table_failure_refund_all_reservations ... ok +test heap::dynamic_tests::collecting_a_trait_box_drops_transitive_native_owners_once ... ok +test hashing::tests::matches_all_independent_c_reference_vectors ... ok +test heap::dynamic_tests::box_is_not_a_guest_instance_or_collection_and_cannot_be_a_trait_receiver ... ok +test heap::dynamic_tests::invalid_pack_never_allocates_or_consumes_source_values ... ok +test heap::dynamic_tests::failed_trait_box_publication_preserves_source_roots_and_existing_table_capacities ... ok +test heap::dynamic_tests::malformed_dynamic_queries_fault_before_reporting_ordinary_mismatch ... ok +test heap::dynamic_tests::trait_box_keeps_receiver_identity_and_gc_reaches_through_typed_dynamic_storage ... ok +test heap::dynamic_tests::multi_slot_pack_has_one_exact_charged_box_and_immutable_copied_values ... ok +test heap::dynamic_tests::null_compatibility_preserves_typed_identity_and_rebuilds_absent_trait ... ok +test heap::dynamic_tests::query_and_unpack_succeed_at_full_heap_quota_without_allocating ... ok +test heap::dynamic_tests::raw_box_storage_drops_native_owners_even_for_rejected_groups ... ok +test heap::dynamic_tests::repack_and_dynamic_extraction_preserve_the_pair_without_another_box ... ok +test heap::dynamic_tests::scalar_string_and_reference_payloads_are_direct_and_exact ... ok +test heap::tests::basic_allocation_returns_valid_refs ... ok +test heap::tests::closure_allocation_with_empty_env ... ok +test hashing::tests::sequential_handles_spread_and_bucket_collisions_do_not_imply_identity ... ok +test heap::tests::gc_scans_closure_env_and_keeps_captured_heap_object ... ok +test heap::tests::closure_allocation_with_env_and_access ... ok +test heap::tests::guest_header_and_payload_limits_refund_failed_construction ... ok +test heap::tests::live_handles_remain_stable_when_freelist_is_reused ... ok +test heap::tests::mark_handles_cycles ... ok +test heap::tests::maximum_generation_is_retired_without_wraparound ... ok +test heap::tests::freelist_reuse_is_deterministic_lifo ... ok +test heap::tests::duplicate_edges_and_roots_need_one_work_slot_per_live_object ... ok +test heap::tests::gc_collects_unreferenced_closure_and_captures ... ok +test heap::tests::gc_scans_nested_closures_and_keeps_inner_when_outer_is_rooted ... ok +test heap::tests::mark_does_not_mark_unreachable ... ok +test heap::tests::handle_limit_counts_free_and_retired_slots_and_reuse_does_not_charge_twice ... ok +test heap::tests::mark_worklist_refusal_changes_no_marks_or_objects ... ok +test heap::tests::mark_reachable_through_array ... ok +test heap::tests::quota_pressure_does_not_collect_outside_a_safepoint ... ok +test heap::tests::stale_references_cannot_access_a_reused_incarnation ... ok +test heap::tests::sweep_keeps_indices_stable_and_len_counts_live ... ok +test heap::tests::sweep_reclaims_unreachable_and_invalidates_handles ... ok +test heap::tests::sweep_reclaims_unrooted_cycle ... ok +test heap::tests::sweep_reuses_freed_slot_on_next_allocation ... ok +test heap::tests::table_growth_is_atomic_when_a_later_table_exceeds_auxiliary_quota ... ok +test program_image::tests::sealed_image_load_probe ... ignored, explicit release measurement; not a timing assertion +test program_image::tests::binding_precedes_publication_and_does_not_mutate_input ... ok +test program_image::tests::final_session_and_snapshot_drop_release_image_and_constant_domain ... ok +test program_image::tests::native_binding_errors_keep_identity_and_roll_back_image_ownership ... ok +test program_image::tests::late_work_refusal_releases_all_new_owners ... ok +test program_image::tests::publication_shares_owners_and_preserves_payload_bits_and_names ... ok +test program_image::tests::constant_strings_share_image_domain_across_sessions_and_native_snapshots ... ok +test program_image::tests::raw_or_unbound_calls_cannot_reach_an_image ... ok +test program_image::tests::string_sort_exhaustion_rolls_back_sealed_load_domains ... ok +test program_image::tests::verification_rejects_unreachable_bad_instructions_and_underflow ... ok +test random::tests::sixty_fourth_success_and_cap_are_distinct ... ok +test random::tests::threshold_boundaries_full_width_and_unit_consumption ... ok +test random::tests::zero_rotation_state_and_float_endpoints ... ok +test registry_verifier::tests::declared_range_is_not_extended_into_gaps_or_neighbor_functions ... ok +test registry_verifier::tests::expected_fn_signature_checks_argument_height_after_permutations ... ok +test registry_verifier::tests::expected_fn_type_ids_never_wrap_or_become_argument_counts ... ok +test registry_verifier::tests::local_bounds_use_derived_parameter_widths_and_u32_local_counts ... ok +test registry_verifier::tests::jumps_reject_cross_range_and_mid_instruction_even_when_unreachable ... ok +test registry_verifier::tests::native_lookup_work_refusal_retains_the_actual_instruction_pc ... ok +test registry_verifier::tests::scratch_and_work_exhaustion_fail_with_context_and_no_counter_leak ... ok +test registry_verifier::tests::scratch_is_refunded_per_function_and_preserves_prior_load_ownership ... ok +test registry_verifier::tests::stack_analysis_refunds_all_state_buffers_and_preserves_prior_ownership ... ok +test registry_verifier::tests::stack_analysis_checks_returns_empty_bodies_and_implicit_end_branches ... ok +test registry_verifier::tests::stack_analysis_rejects_different_join_heights_and_accepts_a_bounded_loop ... ok +test registry_verifier::tests::spawn_arity_does_not_truncate_and_closure_function_ids_are_checked ... ok +test registry_verifier::tests::stack_analysis_accepts_unknown_fn_targets_and_rejects_removed_opcodes ... ok +test registry_verifier::tests::stack_analysis_accounts_only_reachable_transfers_but_preflights_dead_operands ... ok +test registry_verifier::tests::stack_analysis_cannot_consume_parameters_or_extra_locals_as_temporaries ... ok +test registry_verifier::tests::stack_analysis_charges_work_for_loop_reprocessing_and_refunds_on_exhaustion ... ok +test registry_verifier::tests::stack_analysis_honors_literal_zero_and_wide_pop_operands ... ok +test registry_verifier::tests::stack_analysis_resolves_multislot_calls_and_registry_operations ... ok +test program_image::tests::string_identity_binary_search_preserves_constant_order_and_lease_indices ... ok +test registry_verifier::tests::truncated_immediates_cannot_borrow_bytes_from_the_next_function ... ok +test registry_verifier::tests::typed_opcodes_and_relative_jumps_are_resolved_in_declared_ranges ... ok +test registry_verifier::tests::unreachable_bad_type_ids_and_categories_preserve_function_and_pc ... ok +test registry_verifier::tests::unreachable_function_constant_boolean_and_native_operands_are_checked ... ok +test program_image::tests::string_heap_sort_precharges_each_comparison_and_swap_without_scratch ... ok +test registry_verifier::types::tests::arithmetic_promotions_do_not_promote_typed_boundaries ... ok +test registry_verifier::types::tests::equal_height_mixed_type_joins_are_order_independent_and_require_runtime_checks ... ok +test registry_verifier::types::tests::exact_nominal_groups_need_an_explicit_reference_cast ... ok +test registry_verifier::types::tests::known_closure_receivers_are_not_faked_as_user_struct_types ... ok +test registry_verifier::types::tests::generic_null_locals_are_nullable_but_never_numeric_defaults ... ok +test registry_verifier::types::tests::intrinsic_and_reference_operands_are_checked_after_convergence ... ok +test registry_verifier::types::tests::invalid_trait_dynamic_pairs_and_color_ranges_are_proved_mismatches ... ok +test registry_verifier::types::tests::partial_multislot_writes_keep_carriers_but_drop_the_relational_proof ... ok +test registry_verifier::types::tests::loop_widening_happens_before_type_error_decisions ... ok +test registry_verifier::types::tests::proved_call_and_return_mismatches_preserve_exact_type_and_pc ... ok +test resource_budget::tests::accepted_limits_are_fixed_and_can_only_be_lowered ... ok +test registry_verifier::types::tests::type_analysis_is_metered_and_releases_scratch_on_success_and_failure ... ok +test resource_budget::tests::growth_falls_back_to_exact_capacity_at_shared_and_coexistence_limits ... ok +test resource_budget::tests::shared_reservations_refund_on_failure_and_follow_their_owner ... ok +test resource_budget::tests::incremental_growth_moves_a_linear_number_of_elements ... ok +test resource_budget::tests::size_and_length_overflow_fail_before_growth ... ok +test resource_budget::tests::stack_capacity_is_retained_until_drop_and_transfer_does_not_charge_twice ... ok +test resource_budget::tests::temporary_growth_refusal_keeps_old_buffer_and_refunds_provisional_charge ... ok +test roots::tests::visits_heapref_on_operand_stack ... ok +test string_identity_index::tests::collision_chains_distinguish_full_identity_and_survive_tombstones ... ok +test string_ledger::tests::concatenation_accounts_utf8_length_and_temporary_result_coexistence ... ok +test resource_diagnostics::tests::bounded_histogram_reports_upper_bounds_and_exact_max ... ok +test string_identity_index::tests::tombstone_reuse_keeps_collision_successors_and_length_is_part_of_key ... ok +test string_ledger::tests::allocation_count_failure_refunds_provisional_content_charge ... ok +test string_ledger::tests::bounded_formatting_preserves_existing_value_text_without_unmetered_string_buffers ... ok +test string_ledger::tests::clones_share_charge_but_equal_independent_allocations_do_not ... ok +test string_ledger::tests::content_and_individual_limits_are_checked_before_materialization ... ok +test string_identity_index::tests::controlled_probe_counts_and_half_load_survive_growth_and_rebuild ... ok +test string_ledger::tests::domain_construction_refusal_does_not_publish_a_partial_owner ... ok +test string_ledger::tests::index_growth_refuses_auxiliary_temporary_and_allocator_before_materialization ... ok +test string_ledger::tests::empty_strings_still_consume_distinct_allocation_records ... ok +test string_ledger::tests::foreign_arc_import_copies_into_destination_without_implicit_session_sharing ... ok +test string_ledger::tests::formatting_refuses_result_and_temporary_limits_with_no_content_publication ... ok +test string_ledger::tests::index_initial_allocation_failure_and_rebuild_failure_refund_reservations ... ok +test string_ledger::tests::ledger_growth_is_fallible_and_keeps_live_records_on_refusal ... ok +test string_ledger::tests::native_provenance_lease_keeps_accounting_domain_alive_after_session_owner ... ok +test string_ledger::tests::native_writer_length_mismatch_cannot_grow_buffer_and_refunds_content_reservations ... ok +test string_ledger::tests::native_writer_quota_refusal_happens_before_callback_or_content_materialization ... ok +test string_ledger::tests::temporary_refusal_leaves_no_published_content_or_content_reservation ... ok +test typed_storage::ownership_tests::session_string_charge_survives_alias_removal_until_last_storage_owner_is_collected ... ok +test string_ledger::tests::pressure_reconciliation_reclaims_only_dead_owners_and_reuses_capacity ... ok +test typed_storage::tests::defaults_are_typed_compact_and_construct_no_referenced_objects ... ok +test string_ledger::tests::shared_domain_survives_one_consumer_and_final_drop_releases_weak_storage ... ok +test string_ledger::tests::tombstone_rebuild_allocator_refusal_preserves_live_keys_and_charges ... ok +test typed_storage::tests::allocation_failure_after_native_initialization_refunds_every_domain ... ok +test typed_storage::tests::compact_reference_arrays_require_exact_type_live_generation_and_registry ... ok +test typed_storage::tests::complete_trait_pairs_accept_implementation_zero_and_preserve_receiver_aliases ... ok +test typed_storage::tests::dynamic_checks_semantic_ids_and_direct_or_typed_null_payloads ... ok +test typed_storage::tests::dynamic_reference_roots_and_array_references_preserve_identity ... ok +test typed_storage::tests::empty_bounds_null_and_wrong_category_are_distinct ... ok +test typed_storage::tests::exact_scalar_roundtrips_preserve_float_bits_pixel_width_and_color_range ... ok +test typed_storage::tests::failed_multislot_writes_are_atomic_and_do_not_drop_native_owners ... ok +test typed_storage::tests::storage_and_gc_probe ... ignored, explicit release measurement; not a timing assertion +test typed_storage::tests::huge_array_fails_before_initialization_and_reused_storage_gets_defaults ... ok +test typed_storage::tests::string_reads_share_identity_and_failed_overwrite_keeps_the_old_owner ... ok +test typed_storage::tests::mixed_struct_gc_uses_reference_maps_and_drops_native_dynamic_strings ... ok +test typed_storage::tests::native_slots_are_aligned_and_corrupt_compact_pairs_are_rejected ... ok +test typed_storage::tests::typed_boundaries_never_use_cross_numeric_value_equality_or_partial_groups ... ok +test typed_storage::tests::typed_dynamic_self_cycle_uses_one_mark_worklist_entry ... ok +test typed_storage::tests::unpublished_native_prefix_cleanup_drops_only_initialized_slots ... ok +test value_contract::reference_tests::arrays_use_exact_constructor_identity_and_never_implement_traits ... ok +test value_contract::reference_tests::cross_trait_conversion_preserves_receiver_and_accepts_implementation_zero ... ok +test value_contract::reference_tests::incompatible_present_values_fault_only_on_conversion ... ok +test value_contract::reference_tests::null_queries_are_false_and_null_conversions_preserve_absence ... ok +test value_contract::reference_tests::malformed_trait_pairs_are_not_ordinary_mismatches ... ok +test value_contract::reference_tests::reference_operations_reject_dynamic_builtin_and_wrong_immediate_categories ... ok +test value_contract::reference_tests::stale_wrong_registry_and_false_source_type_remain_errors ... ok +test virtual_machine::array_copy::tests::checked_cost_covers_the_full_sum_without_wrap_or_saturation ... ok +test registry_verifier::tests::stack_analysis_straight_line_storage_is_bounded_by_blocks_not_instruction_frames ... ok +test virtual_machine::array_copy_tests::empty_copy_validates_both_receivers_and_strict_ranges_without_scratch ... ok +test virtual_machine::array_copy_tests::copied_groups_preserve_owners_and_references_through_collection_without_guest_growth ... ok +test virtual_machine::array_copy_tests::zero_budget_and_positive_overshoot_preserve_trap_priority_and_step_count ... ok +test virtual_machine::array_copy_tests::overlap_snapshots_complete_multislot_groups_and_has_no_identity_discount ... ok +test virtual_machine::array_copy_tests::incomplete_temporary_operands_never_read_frame_locals_for_cost ... ok +test virtual_machine::array_copy_tests::late_invalid_source_group_releases_partial_preparation_without_any_write ... ok +test virtual_machine::array_copy_tests::invalid_count_selects_only_base_without_reordering_ordinary_faults ... ok +test virtual_machine::array_copy_tests::raw_copy_preserves_absence_and_box_identity_without_heap_allocations ... ok +test virtual_machine::array_copy_tests::refused_copy_keeps_source_and_previous_target_native_owners_rooted ... ok +test virtual_machine::array_copy_tests::scratch_quota_and_allocator_refusals_preserve_all_destinations_and_work ... ok +test virtual_machine::callable_tests::bad_return_height_preserves_frame_and_owners ... ok +test virtual_machine::callable_tests::callable_budget_zero_preserves_state_and_positive_slice_finishes_one_instruction ... ok +test virtual_machine::callable_tests::closure_call_depth_failure_preserves_fn_and_charges_once ... ok +test virtual_machine::callable_tests::fn_creation_identity_aliasing_and_capture_order ... ok +test virtual_machine::callable_tests::closure_temporary_growth_refusal_preserves_capture ... ok +test virtual_machine::callable_tests::closure_quota_refusal_keeps_captures_and_owners ... ok +test virtual_machine::array_copy_tests::calculable_work_is_precharged_on_receivers_carriers_and_ranges_in_fault_order ... ok +test virtual_machine::callable_tests::multi_slot_capture_is_one_logical_group ... ok +test virtual_machine::callable_tests::malformed_trait_views_trap_once_and_preserve_sources ... ok +test virtual_machine::callable_tests::fn_snapshot_is_not_a_guest_root_or_an_import_authority ... ok +test virtual_machine::callable_tests::mixed_trait_dynamic_string_vec2_captures_survive_sync_and_root_return ... ok +test virtual_machine::callable_tests::root_return_gc_roots_fn_result_before_collecting ... ok +test virtual_machine::callable_tests::unreachable_closure_cell_cycle_is_collected_at_sync ... ok +test virtual_machine::callable_tests::null_and_stale_fn_calls_trap_without_consuming_source ... ok +test virtual_machine::callable_tests::recursive_fn_calls_use_bounded_ordinary_frames ... ok +test virtual_machine::collections_tests::default_groups_and_roundtrip_all_storage_types_keep_identity_and_owners ... ok +test virtual_machine::collections_tests::incomplete_set_group_does_not_consume_a_frame_local_and_still_charges_static_cost ... ok +test virtual_machine::collections_tests::exact_struct_weights_and_empty_construction_charge_once ... ok +test virtual_machine::callable_tests::root_return_scratch_refusal_keeps_transferred_roots_without_partial_sweep ... ok +test virtual_machine::collections_tests::invalid_stale_wrong_nominal_and_foreign_registry_receivers_are_charged_and_preserved ... ok +test virtual_machine::collections_tests::invalid_string_overwrite_keeps_the_previous_native_owner ... ok +test virtual_machine::collections_tests::malformed_trait_and_dynamic_stores_reject_the_whole_group ... ok +test virtual_machine::collections_tests::arrays_of_every_builtin_and_reference_view_default_and_roundtrip_by_decoded_ops ... ok +test virtual_machine::collections_tests::new_attempt_costs_budget_and_transactional_refusal ... ok +test virtual_machine::collections_tests::decoded_stores_and_reads_preserve_complete_native_and_reference_groups ... ok +test virtual_machine::collections_tests::provisional_allocation_and_handle_refusals_publish_nothing ... ok +test virtual_machine::identity_tests::identity_faults_preserve_complete_groups_and_charge_once_in_left_to_right_order ... ok +test virtual_machine::collections_tests::pixel_get_cost_bounds_and_result_reservation_failures_preserve_sources ... ok +test virtual_machine::identity_tests::new_queries_ignore_exhausted_guest_and_scratch_quotas_and_do_not_collect ... ok +test virtual_machine::collections_tests::receiver_then_index_then_group_checks_preserve_operands_and_storage ... ok +test virtual_machine::collections_tests::underflow_is_charged_without_consuming_frame_storage ... ok +test virtual_machine::identity_tests::equal_string_content_hashes_across_image_session_and_import_owners ... ok +test virtual_machine::collections_tests::typed_loader_rejects_out_of_registry_collections_even_when_unreachable ... ok +test virtual_machine::collections_tests::rooted_native_owners_boxes_traits_and_cycles_survive_then_reclaim_at_real_safepoints ... ok +test virtual_machine::identity_tests::gc_preserves_live_aliases_but_hashes_do_not_root_collected_handles ... ok +test virtual_machine::identity_tests::shared_invocation_rejects_bad_outputs_without_consuming_original_string_owner ... ok +test virtual_machine::identity_tests::inline_faults_preserve_float_bits_owners_and_attempted_cost ... ok +test virtual_machine::random::tests::dynamic_defaults_exact_types_wrong_objects_and_no_trait_adaptation ... ok +test virtual_machine::random::tests::carrier_receiver_bounds_precedence_and_all_faults_retain_sources ... ok +test virtual_machine::random::tests::reset_unload_and_other_session_do_not_import_snapshot_handles ... ok +test virtual_machine::random::tests::resource_refusals_preserve_all_charges_seed_and_candidate_state ... ok +test virtual_machine::random::tests::short_stack_and_seed_carriers_charge_without_consumption ... ok +test virtual_machine::random::tests::real_unknown_carriers_wrong_kind_and_domain_rollback_resume ... ok +test virtual_machine::random::tests::synthetic_rejections_use_real_transaction_cost_and_rollback ... ok +test virtual_machine::tests::entry_depth_zero_returns_typed_setup_failure_without_allocating ... ok +test virtual_machine::tests::entry_preparation_needs_no_guest_heap_quota ... ok +test virtual_machine::tests::gc_scratch_failure_traps_before_sweep_and_preserves_roots ... ok +test virtual_machine::tests::call_depth_includes_entry_and_traps_before_frame_growth ... ok +test virtual_machine::random::tests::every_random_root_survives_gc_then_releases_and_stale_handles_fault ... ok +test virtual_machine::tests::test_calling_convention_multi_slot_return ... ok +test virtual_machine::tests::test_add_invalid_types_traps_type ... ok +test virtual_machine::tests::operand_globals_and_frames_share_one_auxiliary_limit ... ok +test virtual_machine::tests::test_add_stack_underflow_traps ... ok +test virtual_machine::tests::test_and_invalid_types_traps_type ... ok +test virtual_machine::tests::test_bitwise_promotion ... ok +test virtual_machine::tests::test_call_ret_scope_separation ... ok +test virtual_machine::tests::test_calling_convention_add ... ok +test virtual_machine::tests::test_calling_convention_void_call ... ok +test virtual_machine::tests::test_comparisons_lte_gte ... ok +test virtual_machine::tests::test_gc_simple_allocation_collection_cycle ... ok +test virtual_machine::tests::test_deterministic_pc_and_tick_trace_across_runs ... ok +test virtual_machine::tests::test_intrinsic_input_touch_x_requires_hardware_context ... ok +test virtual_machine::tests::test_comparisons_polymorphic ... ok +test virtual_machine::tests::test_div_by_zero_trap ... ok +test virtual_machine::tests::test_entry_point_ret_with_prepare_call ... ok +test virtual_machine::tests::test_debugger_breakpoint_remains_distinct_from_trap_opcode ... ok +test virtual_machine::tests::test_gc_keeps_roots_and_collects_unreachable_at_frame_sync ... ok +test virtual_machine::tests::test_gc_triggers_only_at_frame_sync ... ok +test virtual_machine::tests::test_intrinsic_argument_underflow_trap ... ok +test virtual_machine::tests::test_if_with_empty_branches ... ok +test virtual_machine::tests::test_jmp_if_non_boolean_trap ... ok +test virtual_machine::tests::test_loader_hardening_duplicate_sysc_identity ... ok +test virtual_machine::tests::test_intrinsic_vec2_dot_executes_without_syscalls ... ok +test virtual_machine::tests::test_intrinsic_vec2_length_executes_without_syscalls ... ok +test virtual_machine::tests::test_invalid_intrinsic_trap_is_distinct_from_syscall ... ok +test virtual_machine::tests::test_invalid_local_index_traps ... ok +test virtual_machine::tests::test_invalid_syscall_trap ... ok +test virtual_machine::tests::test_loader_hardening_boot_protocol_entrypoint_not_found ... ok +test virtual_machine::tests::test_jmp_if_true ... ok +test virtual_machine::tests::test_loader_hardening_invalid_magic ... ok +test virtual_machine::tests::test_loader_hardening_malformed_pbx_v0 ... ok +test virtual_machine::tests::test_loader_hardening_unsupported_version ... ok +test virtual_machine::tests::test_loader_patching_rejects_hostcall_index_out_of_bounds ... ok +test virtual_machine::tests::test_gc_many_short_lived_objects_stress ... ok +test virtual_machine::tests::test_loader_hardening_missing_sysc_section ... ok +test virtual_machine::tests::test_loader_hardening_successful_init ... ok +test virtual_machine::tests::test_loader_patching_propagates_abi_mismatch ... ok +test virtual_machine::tests::test_loader_patching_accepts_status_first_signatures ... ok +test virtual_machine::tests::test_loader_patching_propagates_missing_capability ... ok +test virtual_machine::tests::test_loader_patching_propagates_resolution_failure ... ok +test virtual_machine::tests::test_loader_patching_rejects_raw_syscall_in_preload_artifact ... ok +test virtual_machine::tests::test_loader_patching_rejects_legacy_status_first_ret_slots ... ok +test virtual_machine::tests::test_loader_patching_rejects_unused_syscall_decl ... ok +test virtual_machine::tests::test_locals_round_trip ... ok +test virtual_machine::tests::test_locals_per_call_isolation ... ok +test virtual_machine::tests::test_negation ... ok +test virtual_machine::tests::test_push_const_invalid_index_traps_oob ... ok +test virtual_machine::tests::test_loader_patching_rewrites_hostcall_before_verification ... ok +test virtual_machine::tests::test_neg_invalid_type_traps_type ... ok +test virtual_machine::tests::test_not_invalid_type_traps_type ... ok +test virtual_machine::tests::test_pop_n_opcode ... ok +test virtual_machine::tests::test_pop_underflow_traps ... ok +test virtual_machine::tests::test_nested_if ... ok +test virtual_machine::tests::test_push_bool_immediate ... ok +test virtual_machine::tests::test_push_const_string ... ok +test virtual_machine::tests::test_push_f64_immediate ... ok +test virtual_machine::tests::test_push_i32 ... ok +test virtual_machine::tests::test_syscall_arg_underflow_trap ... ok +test virtual_machine::tests::test_push_i64_immediate ... ok +test virtual_machine::tests::test_shared_string_clone_reuses_materialized_payload ... ok +test virtual_machine::tests::test_removed_input_endpoint_is_an_unknown_intrinsic ... ok +test virtual_machine::tests::test_ret_mandatory_value ... ok +test virtual_machine::tests::test_status_first_syscall_results_count_mismatch_panic ... ok +test virtual_machine::tests::test_syscall_abi_void_return ... ok +test virtual_machine::tests::test_syscall_arg_type_mismatch_trap ... ok +test virtual_machine::tests::test_syscall_missing_capability_trap ... ok +test virtual_machine::tests::test_syscall_abi_multi_slot_return ... ok +test virtual_machine::tests::test_trap_opcode ... ok +test virtual_machine::tests::test_syscall_results_count_mismatch_panic ... ok +test virtual_machine::tests::test_syscall_with_capability_success ... ok +test virtual_machine::tests::test_trap_bad_ret_slots ... ok +test virtual_machine::tests::test_trap_invalid_func ... ok +test virtual_machine::typed_tests::decoded_box_quota_failure_leaves_unpacked_values_rooted_and_unchanged ... ok +test virtual_machine::typed_tests::call_growth_refusal_does_not_publish_frame_or_keep_provisional_capacity ... ok +test virtual_machine::typed_tests::decoded_array_identity_is_invariant_and_arrays_have_no_trait_implementation ... ok +test virtual_machine::typed_tests::decoded_cross_trait_conversion_and_concrete_cast_preserve_receiver_without_wrappers ... ok +test virtual_machine::typed_tests::decoded_dynamic_box_roundtrip_and_identity_never_nest_boxes ... ok +test virtual_machine::typed_tests::decoded_dynamic_preserves_present_struct_array_and_trait_identity_in_one_session ... ok +test virtual_machine::typed_tests::direct_call_returns_zero_or_one_result_and_initializes_generic_locals ... ok +test virtual_machine::typed_tests::decoded_dynamic_malformed_pairs_trap_once_without_consuming_source ... ok +test virtual_machine::typed_tests::decoded_stale_handle_is_an_invalid_handle_even_when_target_type_differs ... ok +test virtual_machine::typed_tests::decoded_dynamic_scalar_string_reference_and_null_paths_have_exact_attempt_costs ... ok +test virtual_machine::typed_tests::decoded_string_add_accounts_content_and_preserves_inputs_on_quota_refusal ... ok +test virtual_machine::typed_tests::decoded_trait_box_is_the_only_receiver_root_across_frame_sync_gc ... ok +test virtual_machine::typed_tests::decoded_null_queries_are_false_and_null_conversions_are_absent ... ok +test virtual_machine::typed_tests::dynamic_query_consumes_pair_and_reports_fixed_cost_through_budget_report ... ok +test virtual_machine::typed_tests::entry_rejects_bad_complete_groups_before_frame_or_heap_publication ... ok +test virtual_machine::typed_tests::decoded_reference_malformed_source_never_becomes_false_or_null ... ok +test virtual_machine::typed_tests::lifecycle_tests::lifecycle_forbids_frame_sync_and_preserves_failure ... ok +test virtual_machine::typed_tests::lifecycle_tests::lifecycle_entry_quota_refusal_is_transactional_and_empty_context_is_supported ... ok +test virtual_machine::typed_tests::lifecycle_tests::lifecycle_nested_calls_keep_saved_roots_and_branch_returns_stop_at_boundary ... ok +test virtual_machine::typed_tests::lifecycle_tests::lifecycle_normal_return_wins_at_budget_boundary_and_halt_does_not_complete ... ok +test virtual_machine::typed_tests::native_byte_carrier_validates_entire_input_before_copy_and_charges_work ... ok +test virtual_machine::typed_tests::lifecycle_tests::lifecycle_preserves_continuation_and_does_not_run_gameplay_after_return ... ok +test virtual_machine::typed_tests::native_import_and_snapshot_retention_preserve_domain_across_session_close ... ok +test virtual_machine::typed_tests::native_string_failures_cannot_publish_partial_results_even_if_handler_ignores_error ... ok +test virtual_machine::typed_tests::ordered_multi_group_return_preserves_native_owners_and_receiver_identity ... ok +test virtual_machine::typed_tests::typed_sessions_share_image_but_have_independent_execution_and_heap ... ok +test virtual_machine::typed_tests::unknown_at_call_is_checked_after_branch_merge_without_publishing_bad_frame ... ok +test virtual_machine::typed_tests::unknown_return_refusal_keeps_frame_but_valid_return_needs_no_scratch ... ok +test virtual_machine::typed_tests::lifecycle_tests::lifecycle_budget_survives_slices_breakpoints_and_single_steps ... ok + +test result: ok. 317 passed; 0 failed; 2 ignored; 0 measured; 0 filtered out; finished in 0.38s + + Running tests/builtin_contract.rs (target/debug/deps/builtin_contract-81707fd865bc7104) + +running 4 tests +test color_range_and_aggregate_component_carriers_do_not_narrow ... ok +test primitive_carriers_are_exact_and_only_string_accepts_scalar_null ... ok +test all_ten_descriptors_match_registry_storage_and_canonical_defaults ... ok +test intrinsic_boundaries_reject_implicit_carrier_conversions_in_execution ... ok + +test result: ok. 4 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.01s + + Running tests/collection_conformance.rs (target/debug/deps/collection_conformance-51ff42520eca166d) + +running 10 tests +test guest_aliases_mutate_same_instance_and_groups_roundtrip_without_boxing ... ok +test converged_unknown_receiver_join_keeps_runtime_checks_and_valid_branch_executes ... ok +test verifier_rejects_proven_types_metadata_and_unreachable_invalid_fields ... ok +test collection_load_limits_and_analysis_refusals_keep_context_and_refund_scratch ... ok +test every_builtin_group_can_be_stored_and_loaded_by_decoded_struct_operations ... ok +test empty_instances_have_identity_and_nested_array_references_preserve_aliases ... ok +test independent_bytes_execute_default_array_and_len_on_sealed_image ... ok +test verifier_rejects_group_tearing_jumps_into_immediates_and_unequal_height_joins ... ok +test neutral_pbx_copy_moves_a_range_and_preserves_physical_length ... ok +test removed_storage_opcodes_reject_even_in_unreachable_instruction_positions ... ok + +test result: ok. 10 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.01s + + Running tests/execution_allocations.rs (target/debug/deps/execution_allocations-cd6f19c18694fff8) + +running 3 tests +test warmed_instruction_regions_do_not_allocate ... ok +test identity_and_borrowed_hash_instruction_regions_do_not_allocate ... ok +test provenance_queries_allocate_nothing_at_all_qualification_sizes ... ok + +test result: ok. 3 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 1.22s + + Running tests/execution_regressions.rs (target/debug/deps/execution_regressions-b6632822a3a49ce3) + +running 11 tests +test end_branch_preserves_multislot_results_and_frame_continuation ... ok +test end_branch_checks_unknown_results_without_releasing_frame ... ok +test end_branches_reject_proven_bad_results_at_load ... ok +test root_end_branch_returns_without_executing_neighbor_or_retaining_locals ... ok +test end_branch_returns_to_caller_from_direct_closure_and_trait_calls ... ok +test integer_division_and_remainder_overflow_wrap_without_host_panic ... ok +test direct_return_type_refusal_is_charged_once ... ok +test direct_call_depth_refusal_is_charged_once_and_zero_budget_is_inert ... ok +test conditional_end_branches_return_only_on_the_taken_edge ... ok +test maximum_width_mixed_return_preserves_order_and_caller_locals ... ok +test root_end_branch_roots_closure_result_before_safepoint_collection ... ok + +test result: ok. 11 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.04s + + Running tests/identity_hashing.rs (target/debug/deps/identity_hashing-e216012172710149) + +running 7 tests +test canonical_null_groups_compare_and_hash_without_instance_faults ... ok +test identities_survive_mutation_and_views_validate_implementation_zero ... ok +test whole_instruction_budget_admission_preserves_zero_and_overshoot ... ok +test every_eligible_absence_has_zero_hash_and_exact_identity_instruction_cost ... ok +test admission_rejects_ineligible_sources_and_bad_native_ids_even_when_dead ... ok +test array_closure_and_random_have_instance_identity ... ok +test scalar_pbx_execution_matches_independent_c_reference_vectors ... ok + +test result: ok. 7 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.02s + + Running tests/intrinsic_profiles.rs (target/debug/deps/intrinsic_profiles-c544ceaf6432e7e1) + +running 3 tests +test incompatible_descriptors_fail_instead_of_gaining_implicit_capabilities ... ok +test nullability_does_not_relax_existing_string_or_numeric_arguments ... ok +test schema_two_has_exact_columns_profiles_and_per_slot_nullable_lists ... ok + +test result: ok. 3 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running tests/numeric_contract.rs (target/debug/deps/numeric_contract-7f872decd978ea62) + +running 14 tests +test faults_validate_all_types_then_finitude_then_domain ... ok +test integer_limits_are_exact_and_abs_does_not_wrap ... ok +test float_opcodes_preserve_underflow_zero_division_and_numeric_faults ... ok +test atan2_has_explicit_zero_vector_and_signed_axis_contract ... ok +test load_rejects_nonfinite_immediates_and_unknown_intrinsics_even_when_dead ... ok +test catalog_has_exact_ids_costs_names_and_canonical_constants ... ok +test conversions_check_the_truncated_integer_without_saturating ... ok +test math_attempts_charge_before_failure_and_positive_budget_overshoots ... ok +test exported_artifacts_match_the_single_runtime_catalog ... ok +test signed_zero_limits_and_rounding_follow_bits ... ok +test every_scalar_and_vector_call_has_the_published_total_execution_cost ... ok +test native_signature_checks_all_types_before_rejecting_nonfinite ... ok +test vector_sequences_keep_stage_rounding_and_scaled_extremes ... ok +test mpfr_fixed_corpus_replays_without_a_runtime_or_test_mpfr_dependency ... ok + +test result: ok. 14 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.36s + + Running tests/producer_handoff.rs (target/debug/deps/producer_handoff-6008336294eb026d) + +running 1 test +test named_arguments_preserve_source_effect_order_and_call_in_signature_order_without_debug ... ok + +test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.01s + + Running tests/random_contract.rs (target/debug/deps/random_contract-e5d75a2cd7572055) + +running 13 tests +test catalog_reference_layout_effects_and_cost_models_are_exact ... ok +test random_parameter_result_and_typed_null_have_exact_dynamic_type ... ok +test random_storage_dynamic_and_capture_preserve_shared_identity ... ok +test all_random_attempts_charge_before_validation_and_budget_overshoot ... ok +test range_all_int64_spans_and_power_of_two_consumption ... ok +test interleaving_unit_range_aliases_and_equal_seed_independent_objects ... ok +test range_domain_fault_preserves_operands_and_shared_stream ... ok +test quota_refusal_new_preserves_seed_and_publishes_no_handle ... ok +test loader_rejects_unknown_unreachable_ids_and_new_random_construction ... ok +test published_emission_example_matches_bits_consumption_and_total_cycles ... ok +test real_pcg_rejection_consumes_two_words_and_one_instruction ... ok +test unknown_analysis_checks_null_receiver_at_runtime ... ok +test independent_words_signed_and_float_bits_for_all_seed_patterns ... ok + +test result: ok. 13 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.02s + + Running tests/registry_conformance.rs (target/debug/deps/registry_conformance-76e867419740b06d) + +running 3 tests +test independent_v0_bytes_load_publish_and_execute_through_the_public_sealed_boundary ... ok +test load_scratch_and_session_depth_are_separate_admission_failures ... ok +test single_violation_oracles_reject_before_image_publication_with_typed_context ... ok + +test result: ok. 3 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.01s + + Running tests/resource_stability.rs (target/debug/deps/resource_stability-1aca8e5e6015c0f4) + +running 5 tests +test refused_allocation_keeps_operands_and_charges_attempt_without_rescue_gc ... ok +test host_string_snapshot_keeps_its_domain_alive_then_final_drop_refunds_it ... ok +test depth_diagnostics_include_an_entry_that_returns_immediately ... ok +test no_sync_loop_returns_each_slice_without_gc_frames_or_allocation ... ok +test stationary_workloads_repeat_cycles_and_release_all_session_reservations ... ok + +test result: ok. 5 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.29s + + Running tests/smoke.rs (target/debug/deps/smoke-ae8989cd1bcc6cae) + +running 2 tests +test deterministic_rng_sequences_match ... ok +test vm_instantiation_is_stable ... ok + +test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.02s + + Running tests/syscall_input_removed.rs (target/debug/deps/syscall_input_removed-ef7e75e31ec1e421) + +running 1 test +test loader_rejects_legacy_input_syscall_id ... ok + +test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.01s + + Running tests/typed_closures.rs (target/debug/deps/typed_closures-be1731a23183dc48) + +running 13 tests +test captured_direct_calls_and_invalid_capture_indices_reject_at_load ... ok +test captures_are_not_public_parameters_and_survive_creator_return ... ok +test branch_selects_unknown_concrete_target_under_one_signature ... ok +test bound_trait_receiver_adapter_keeps_view_in_capture_environment ... ok +test host_cannot_prepare_a_capturing_body_or_capturant_trait_implementation ... ok +test fn_survives_struct_array_dynamic_storage_and_pass_return ... ok +test factory_returns_two_callbacks_sharing_a_mutable_cell ... ok +test independent_factories_do_not_share_mutable_cells ... ok +test logical_result_groups_distinguish_equal_width_signatures_at_load ... ok +test native_string_capture_survives_factory_return ... ok +test trait_dispatch_selects_exact_receiver_first_implementation ... ok +test recurring_roots_use_no_heap_execution_objects_or_handle_quota ... ok +test sync_and_gc_retain_active_frame_environment_after_fn_operand_is_consumed ... ok + +test result: ok. 13 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.06s + + Running unittests examples/export_numeric_catalog.rs (target/debug/examples/export_numeric_catalog-9cad62f1057926cd) + +running 0 tests + +test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running unittests examples/numeric_benchmark.rs (target/debug/examples/numeric_benchmark-9c4563d4f734228b) + +running 0 tests + +test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running unittests examples/numeric_probe.rs (target/debug/examples/numeric_probe-ee5dd40961cce379) + +running 0 tests + +test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running unittests examples/resource_qualification.rs (target/debug/examples/resource_qualification-1d93769d1e7891ad) + +running 0 tests + +test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s + + Running unittests examples/string_provenance_benchmark.rs (target/debug/examples/string_provenance_benchmark-1b6249ca4b5c8301) + +running 0 tests + +test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out; finished in 0.00s diff --git a/docs/specs/runtime/08-save-memory-and-memcard.md b/docs/specs/runtime/08-save-memory-and-memcard.md index c244d5f..ddbdfcf 100644 --- a/docs/specs/runtime/08-save-memory-and-memcard.md +++ b/docs/specs/runtime/08-save-memory-and-memcard.md @@ -328,6 +328,40 @@ ordinary storage failures are domain results. ## Host integration +### Public host controls + +The installed headless interface is the negotiated memcard surface of +[Headless Automation](11a-headless-automation-protocol.md#memcard-controls). +Media selection belongs to the host instance, never the cartridge manifest. +Opening, creation and the three boot choices are explicit. Missing, corrupt, +inaccessible or read-only media never silently select fresh RAM or create a file. + +File hosts acquire a nonblocking exclusive OS lock, including for read-only +access, before validating the opened image. The lock follows file identity and +therefore covers aliases across desktop/headless processes. Contention is BUSY; +unsupported locking is an explicit refusal. Creation locks the new file before +publishing its name and never replaces an existing destination. Locks and native +buffers remain owned until actual IO cessation, independently of result release, +discard consent and timeout. Inspection through a second mounted reader is not +supported while an owner holds the image. + +Native observation distinguishes dirty RAM, retained terminal results and actual +IO ownership. Reset/shutdown wait for admitted IO, or request cancellation when +explicitly selected, then reevaluate dirty RAM. Remaining dirty RAM requires +explicit discard consent; refusal preserves the resident session. Neither wait, +cancel nor discard starts a save or proves rollback. Unconfirmed cessation blocks +reset/closure confirmation and requires restart supervision. EOF/transport loss +attempts bounded cancellation/cleanup without saving or resuming the guest. +An installed image with an indeterminate publication remains write-blocked after +reset; another persistent admission requires explicit revalidation first. + +The headless owner polls IO/deadlines while idle without advancing VM instructions, +input, ticks or frames. A resident game awaiting media action is paused, not +terminated. Explicit reconciliation reopens only the selected card identity after +safe cessation, preserves RAM/continuation and the original retained request +result, and never reruns bootstrap. Different-card switching is not part of this +public host surface. + The desktop host accepts `--memcard PATH` for an existing image and `--memcard PATH --create-memcard` for explicit creation. Creation never replaces an existing file. File creation, opening, mount validation and save IO execute diff --git a/docs/specs/runtime/11a-headless-automation-protocol.md b/docs/specs/runtime/11a-headless-automation-protocol.md index 563a8c4..eabc5cf 100644 --- a/docs/specs/runtime/11a-headless-automation-protocol.md +++ b/docs/specs/runtime/11a-headless-automation-protocol.md @@ -30,7 +30,7 @@ and may terminate the process tree. There is no transport replay or durable queu ## Handshake and compatibility The server first emits a `hello` object with `sessionId`, `protocolVersion` -(`major: 1, minor: 0`), real `runtimeVersion`, `capabilities` and `limits`. +(`major: 1, minor: 1`), real `runtimeVersion`, `capabilities` and `limits`. Session identity is opaque and process-local, excluded from deterministic oracles. Before work, the client sends `initialize` with `protocolVersion` and an array @@ -130,6 +130,8 @@ if the process dies. The final response is authoritative when delivered. Shutdown/EOF requests cancellation, waits for the active work to reach its boundary, drops the host and exits; explicit shutdown receives its response after cleanup. +Negotiated memcard shutdown may refuse with native state and keep the channel +available, as specified in [Memcard controls](#memcard-controls). Disconnect never starts/resumes execution. A failed process requires a new explicit session, not replay. Host session loss does not implicitly release Studio authority. @@ -175,6 +177,106 @@ structured faults, progress on partial failure and retained desktop run/debug. Neither Studio UI nor an AI model is required. See `tests/automation_process.rs` in prometeu-cli and the in-process deterministic-control tests in the headless crate. +## Memcard controls + +Protocol minor 1.1 adds capability `memcard`. Initialize negotiates the lesser +minor. These commands and parameters require minor >= 1 and `memcard` in +requiredCapabilities; unsupported use fails before mutation. Clients negotiating +1.0 keep the previous command/result shapes. No executable-version inference, +default image, alternate transport or headless media startup flags are defined. + +| Command | Parameters | Meaning | +| --- | --- | --- | +| memcard_mount | path, action: open/create, access: read_write/read_only | prepare explicit media before boot; bounded result | +| memcard_unmount | empty object | release idle media outside a resident session | +| get_memcard_state | empty object | coherent native observation, without guest execution | +| boot | path, optional memcardChoice: persistent/memory_fresh/memory_existing | explicit player choice required for a memcard cartridge | +| memcard_reconcile | empty object | recover selected same-card identity while suspended | +| memcard_continue_in_memory | empty object | explicit safe SO detach, preserving RAM | +| reset / shutdown | optional discardUnsaved (false), pendingWrites: wait/cancel (wait) | controlled teardown; no autosave | + +Mount requires no resident game or outstanding IO. Create/read_only is invalid. +Paths are resolved relative to process cwd, reported absolutely; parent directories +must exist. Open does not create; create never replaces, converts or repairs media. +Persistent requires writable coherent media; memory_existing requires a readable +record for the cartridge appId. No error changes that choice automatically. +After an admitted boot attempt, retry requires explicit reset; parsing and +negotiation failures do not admit boot. Reset preserves selected media/lock. + +State has closed objects `media`, `session`, `io`, `recovery`, a nullable `request`, +`dirty` and `dirtySlots`. Media reports path/cardId/access/preparation/error/health; +session reports identity/choice/mode/boot phase/residency/action requirement. +Requests report original identity, operation, local slot, state, deadline reason, +storage error and retention, independently of IO activity. cardId is 32 lowercase +hex digits; request IDs and mount epochs are decimal strings. Unknown values are +null, never invented outcomes. Schemas distributed with the installation specify +all fields. Inspection never releases requests or exposes private save payloads. + +Domain failures use `memcard_error` with `details.operation`, `details.reason` +and `details.state`. Reasons include choice_required, unavailable, corrupt, +unsupported, read_only, access_denied, already_exists, busy, no_space, +out_of_memory, invalid_state, invalid_range, counter_exhausted, identity_mismatch, +unsaved_changes, indeterminate and restart_required. Human messages are not codes. +Original worker error, deadline cause and durable result are separate observations. + +Shutdown stops an active advance at its existing frame boundary, then evaluates +IO and dirty RAM. Wait/cancel only concern already admitted work. After IO ceases, +remaining dirty RAM without discard consent returns unsaved_changes and leaves +the session/channel usable. Terminal results retained by the guest alone do not +block closure. Unconfirmed IO cessation never returns closed:true or permits +resource/lock release. Successful negotiated reset adds `memcard` to the state +result; shutdown returns closed:true and its final `memcard` snapshot, after checked +cleanup. EOF/output loss attempts bounded cancellation without save/resumption; +process death does not establish publication outcome. + +An advance stopped for resident media action returns stop:action_required with +known completed progress. Resident state is paused; a host dialog is not counted +as a game frame. Idle IO polling leaves guest counters/input unchanged. Reconcile +accepts no replacement path, validates expected identity before changes, preserves +RAM/continuation/original retained results and does not rerun initialization. + +Runtime qualification uses neutral PBX/ABI fixtures, real distinct processes and +an isolated extracted distribution. It proves SUCCESS, termination, exact readback +without resave and stable appId across cartridge versions. Consumer source-language +compilation and client adaptation are separate work; the provider has no frontend +build dependency. No global installation or consumer configuration update is needed. + +### Integration sequence + +Start `prometeu headless --stdio` from the selected installation and consume its +hello before sending work. Require the capability explicitly: + +```json +{"requestId":"init","command":"initialize","params":{"protocolVersion":{"major":1,"minor":1},"requiredCapabilities":["memcard"]}} +{"requestId":"media","command":"memcard_mount","params":{"path":"/absolute/save.pmc","action":"open","access":"read_write"}} +{"requestId":"boot","command":"boot","params":{"path":"/absolute/cartridge","memcardChoice":"persistent"}} +{"requestId":"step","command":"advance","params":{"frames":1}} +{"requestId":"save-state","command":"get_memcard_state","params":{}} +{"requestId":"close","command":"shutdown","params":{"pendingWrites":"wait"}} +``` + +Each request above follows the successful response to the preceding one. Creating +new media requires a deliberate `action:create`; do not retry an open failure +with create. Memory choices are `memory_fresh` and `memory_existing`. No client +may replace a failed persistent choice with either automatically. + +If closure reports unsaved_changes, keep the process/session and expose that +native state to the caller. A later explicit choice may send +`{"discardUnsaved":true,"pendingWrites":"cancel"}`; do not infer that consent +from a UI stop, timeout or process error. A successful commit is the guest/native +request state `success`, independently of its reason; neither an advance response +nor closed:true proves that a save occurred. + +On reopening, launch a different process, open the same image and choose the +appropriate mode explicitly. The neutral process oracle verifies exact prior +bytes without resaving and repeats with a changed cartridge version and unchanged +appId. Run `cargo test -p prometeu-cli --test automation_process +memcard_public_distinct_process_save_readback_and_version_identity`; add +`--release` to qualify that profile independently. For an extracted archive, +set `PROMETEU_PROTOCOL_TEST_INSTALL` and run the ignored +`packaged_memcard_process_persistence` test. It invokes the installed dispatcher +from another cwd without modifying any consumer project or installation. + ## Program Registry integration When exposing initialization failures, retain the [structured load error](02c-program-registry-and-pbx-v0.md#errors-and-publication) code, typed reason and available context. Human-readable messages are not a parsing contract; a load error has no fabricated runtime PC. Failed loads must not publish executable sessions. Existing protocol request names and transport behavior are unchanged.