diff --git a/crates/polymodel-renderer-worker/src/worker.rs b/crates/polymodel-renderer-worker/src/worker.rs index 4443b8d..9e016b9 100644 --- a/crates/polymodel-renderer-worker/src/worker.rs +++ b/crates/polymodel-renderer-worker/src/worker.rs @@ -103,6 +103,7 @@ struct WorkerState { raf_closure: Option>, ledger: ReservationLedger, canvas_reservation: Option, + load_epoch: u32, scene_generation: u32, } @@ -123,6 +124,7 @@ impl WorkerState { raf_closure: None, ledger: ReservationLedger::new(), canvas_reservation: None, + load_epoch: 0, scene_generation: 0, } } @@ -921,6 +923,7 @@ fn handle_load_mesh( ) { return; } + st.load_epoch = identity.load_epoch; if let Some(renderer) = st.renderer.as_mut() { renderer.model = None; } @@ -937,10 +940,12 @@ fn handle_load_mesh( } let state_clone = state.clone(); + let load_epoch = identity.load_epoch; + let scene_generation = state.borrow().scene_generation; spawn_local(async move { let load_reservations = { let st = state_clone.borrow(); - let owner = owner(epoch, st.scene_generation); + let owner = owner(load_epoch, scene_generation); st.ledger.composite( owner, &[ @@ -962,10 +967,28 @@ fn handle_load_mesh( ) }; let Ok(_load_reservations) = load_reservations else { - if let Ok(st) = state_clone.try_borrow() { - st.post_event(&RendererEvent::MeshError { - message: "renderer admission rejected mesh load".into(), + if let Ok(mut st) = state_clone.try_borrow_mut() { + let error = LoadError { + code: LoadErrorCode::Renderer, + detail: "renderer admission rejected mesh load".into(), + }; + let result = st.load_reducer.reduce(LoadEvent::LoadFailed { + namespace, + identity, + error: error.clone(), + candidate: None, }); + if matches!( + result.outcome, + polymodel_renderer_protocol::TransitionOutcome::Committed + ) { + st.post_event(&RendererEvent::LoadFailed { + namespace, + identity, + code: error.code, + detail: error.detail, + }); + } } return; }; @@ -1000,36 +1023,58 @@ fn handle_load_mesh( identity, }); let (pw, ph) = (st.pixel_width, st.pixel_height); - let Some(renderer) = st.renderer.as_ref() else { - let error = LoadError { - code: LoadErrorCode::Renderer, - detail: "renderer context unavailable".into(), - }; - st.load_reducer.reduce(LoadEvent::InstallFailed { - namespace, - identity, - error: error.clone(), - candidate: None, - }); - st.post_event(&RendererEvent::LoadFailed { - namespace, - identity, - code: error.code, - detail: error.detail, - }); - return; + let context = match st + .renderer + .as_ref() + .map(|renderer| renderer.context.clone()) + { + Some(context) => context, + None => { + let error = LoadError { + code: LoadErrorCode::Renderer, + detail: "renderer context unavailable".into(), + }; + st.load_reducer.reduce(LoadEvent::InstallFailed { + namespace, + identity, + error: error.clone(), + candidate: None, + }); + st.post_event(&RendererEvent::LoadFailed { + namespace, + identity, + code: error.code, + detail: error.detail, + }); + return; + } }; st.scene_generation = st.scene_generation.saturating_add(1); let scene_owner = owner(st.load_epoch, st.scene_generation); let (scene_reservations, texture_reservations) = match admit_scene(&st.ledger, scene_owner, &model) { Ok(reservations) => reservations, - Err(message) => { - st.post_event(&RendererEvent::MeshError { message }); + Err(detail) => { + let error = LoadError { + code: LoadErrorCode::Install, + detail, + }; + st.load_reducer.reduce(LoadEvent::InstallFailed { + namespace, + identity, + error: error.clone(), + candidate: None, + }); + st.post_event(&RendererEvent::LoadFailed { + namespace, + identity, + code: error.code, + detail: error.detail, + }); return; } }; - let candidate = match build_scene(&renderer.context, &model, pw, ph) { + let candidate = match build_scene(&context, &model, pw, ph) { Ok(candidate) => candidate, Err(detail) => { drop(scene_reservations); diff --git a/tools/ldraw-compat-harness/src/main.rs b/tools/ldraw-compat-harness/src/main.rs index fbed69c..4235922 100644 --- a/tools/ldraw-compat-harness/src/main.rs +++ b/tools/ldraw-compat-harness/src/main.rs @@ -1,11 +1,12 @@ //! Native PM-77 corpus validator and D-phase LDParse oracle harness. use polymodel_ldraw_core::{ - InProcessRustAdapter, LdrawError, ParserProfile as CoreProfile, + DiagnosticCode, InProcessRustAdapter, LdrawError, ParserProfile as CoreProfile, }; use polymodel_ldraw_testkit::{ - coverage_report, inventory, named_gates, validate_inventory, CanonicalRecord, ExpectedOutcome, - FixtureCase, CorpusGateSet, OracleDiagnostic, OracleError, OracleModel, OracleProjection, - Profile, SCHEMA_VERSION, ORACLE_SCHEMA_VERSION, GATE_NAMES, LDRAW_LIMITS, + coverage_report, inventory, named_gates, serialize_canonical, validate_inventory, + CanonicalRecord, ExpectedOutcome, FixtureCase, CorpusGateSet, OracleDiagnostic, OracleError, + OracleModel, OracleProjection, Profile, SCHEMA_VERSION, ORACLE_SCHEMA_VERSION, GATE_NAMES, + LDRAW_LIMITS, }; use polymodel_renderer_ledger::{ReservationLedger, ReservationOwner}; use serde::{Deserialize, Serialize}; @@ -390,6 +391,57 @@ fn mutate(seed: u64, index: usize, source: &[u8]) -> Vec { output } +fn bounded_mutation_rejection(error: &LdrawError) -> bool { + match error { + LdrawError::Cancelled => true, + LdrawError::Diagnostic(diagnostic) => matches!( + diagnostic.code, + DiagnosticCode::InvalidUtf8 + | DiagnosticCode::PathOutOfRoot + | DiagnosticCode::PathForbiddenSyntax + | DiagnosticCode::PathEmpty + | DiagnosticCode::InvalidType1 + | DiagnosticCode::InvalidType2 + | DiagnosticCode::InvalidType3 + | DiagnosticCode::InvalidType4 + | DiagnosticCode::InvalidType5 + | DiagnosticCode::InvalidLineType + | DiagnosticCode::InvalidColour + | DiagnosticCode::MetaEmpty + | DiagnosticCode::TexmapNextType0 + | DiagnosticCode::ColourSlotsLimit + | DiagnosticCode::TexmapUnknownMetaStop + | DiagnosticCode::BfcInvalidDirective + | DiagnosticCode::BfcRecertifyUncertified + | DiagnosticCode::BfcInvalidCertifyArgument + | DiagnosticCode::BfcInvertNextOutsideCertified + | DiagnosticCode::BfcInvalidContext + | DiagnosticCode::TexmapInvalidArity + | DiagnosticCode::TexmapInvalidMethod + | DiagnosticCode::TexmapNextNested + | DiagnosticCode::TexmapInvalidValue + | DiagnosticCode::TexmapFallbackOutOfScope + | DiagnosticCode::TexmapDuplicateFallback + | DiagnosticCode::TexmapInvalidEnd + | DiagnosticCode::DataInvalid + | DiagnosticCode::DataTruncated + | DiagnosticCode::IncludeDepthLimit + | DiagnosticCode::GraphCycle + | DiagnosticCode::ResourceBytesLimit + | DiagnosticCode::CommandsLimit + | DiagnosticCode::InstancesLimit + | DiagnosticCode::TrianglesLimit + | DiagnosticCode::LinesLimit + | DiagnosticCode::TexturesLimit + | DiagnosticCode::FetchesLimit + | DiagnosticCode::DiagnosticsLimit + ), + LdrawError::LdrawDiagnostic(_) + | LdrawError::Reservation(_) + | LdrawError::Overflow(_) => false, + } +} + fn fuzz() -> Result { let fixtures = inventory(); validate_inventory(&fixtures)?; @@ -415,15 +467,72 @@ fn fuzz() -> Result { let path = temporary.join(format!("{index}-{}.ldr", hex::encode(digest))); fs::write(&path, &bytes).map_err(|error| error.to_string())?; let ledger = ReservationLedger::new(); - InProcessRustAdapter::parse_fixture( - fixture.id, - &bytes, - core_profile(fixture.expected.profile), - ReservationOwner::preview(1, index as u64 + 1, 1), - &ledger, - ) - .map_err(|error| format!("mutation {index} ({}) core parse failed: {error}", fixture.id))?; - run_oracle(&binary, &path, ORACLE_TIMEOUT).map_err(|error| format!("mutation {index} ({}) failed: {error}", fixture.id))?; + let parsed = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { + InProcessRustAdapter::parse_fixture( + fixture.id, + &bytes, + core_profile(fixture.expected.profile), + ReservationOwner::preview(1, index as u64 + 1, 1), + &ledger, + ) + })) + .map_err(|_| format!("mutation {index} ({}) core parser panicked", fixture.id))?; + match parsed { + Ok(parsed) => { + let first = serialize_canonical(&parsed.project()) + .map_err(|error| format!("mutation {index} ({}) projection failed: {error}", fixture.id))?; + drop(parsed); + if ledger.snapshot().reservations != 0 { + return Err(format!("mutation {index} ({}) leaked ledger reservations", fixture.id)); + } + let repeat_ledger = ReservationLedger::new(); + let repeat = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { + InProcessRustAdapter::parse_fixture( + fixture.id, + &bytes, + core_profile(fixture.expected.profile), + ReservationOwner::preview(1, index as u64 + 1, 1), + &repeat_ledger, + ) + })) + .map_err(|_| format!("mutation {index} ({}) repeated core parser panicked", fixture.id))? + .map_err(|error| format!("mutation {index} ({}) was nondeterministically rejected: {error}", fixture.id))?; + let second = serialize_canonical(&repeat.project()) + .map_err(|error| format!("mutation {index} ({}) repeated projection failed: {error}", fixture.id))?; + drop(repeat); + if repeat_ledger.snapshot().reservations != 0 { + return Err(format!("mutation {index} ({}) repeated parse leaked ledger reservations", fixture.id)); + } + if first != second { + return Err(format!("mutation {index} ({}) accepted parse is not deterministic", fixture.id)); + } + let oracle = run_oracle(&binary, &path, ORACLE_TIMEOUT) + .map_err(|error| format!("mutation {index} ({}) failed: {error}", fixture.id))?; + if oracle.status != "ok" { + return Err(format!("mutation {index} ({}) accepted core parse has oracle status {}", fixture.id, oracle.status)); + } + } + Err(error) if bounded_mutation_rejection(&error) => { + if index == 0 { + match error { + LdrawError::Diagnostic(diagnostic) + if diagnostic.code == DiagnosticCode::InvalidUtf8 => {} + other => { + return Err(format!( + "mutation 0 ({}) expected INVALID_UTF8, got {other}", + fixture.id + )); + } + } + } + if ledger.snapshot().reservations != 0 { + return Err(format!("mutation {index} ({}) rejected parse leaked ledger reservations", fixture.id)); + } + } + Err(error) => { + return Err(format!("mutation {index} ({}) core parse failed: {error}", fixture.id)); + } + } } Ok(()) })();