diff --git a/crates/polymodel-renderer-worker/src/worker.rs b/crates/polymodel-renderer-worker/src/worker.rs index 68c35a1..9224aa2 100644 --- a/crates/polymodel-renderer-worker/src/worker.rs +++ b/crates/polymodel-renderer-worker/src/worker.rs @@ -67,7 +67,7 @@ struct RendererState { texture_reservations: Vec, } -struct CompoundAbortSlot { +struct PreviewAbortSlot { identity: LoadIdentity, controller: AbortController, } @@ -127,10 +127,9 @@ struct WorkerState { canvas_reservation: Option, load_epoch: u32, scene_generation: u32, - interactive_compound_abort: Option, - preview_compound_abort: Option, - preview_abort: Option, - preview_identity: Option, + preview_generation: u32, + interactive_compound_abort: Option, + preview_abort: Option, pending_events: Vec, handshake: HandshakeState, local_hello: ProtocolHello, @@ -156,10 +155,9 @@ impl WorkerState { canvas_reservation: None, load_epoch: 0, scene_generation: 0, + preview_generation: 0, interactive_compound_abort: None, - preview_compound_abort: None, preview_abort: None, - preview_identity: None, pending_events: Vec::new(), handshake: HandshakeState::Created, local_hello: ProtocolHello { @@ -1249,9 +1247,9 @@ fn handle_compound_load( if let Ok(mut st) = state.try_borrow_mut() { let slot = match namespace { RendererNamespace::Interactive => &mut st.interactive_compound_abort, - RendererNamespace::Preview => &mut st.preview_compound_abort, + RendererNamespace::Preview => &mut st.preview_abort, }; - if let Some(previous) = slot.replace(CompoundAbortSlot { + if let Some(previous) = slot.replace(PreviewAbortSlot { identity, controller: abort.clone(), }) { @@ -1273,7 +1271,7 @@ fn abort_compound_slot( ) { let slot = match namespace { RendererNamespace::Interactive => &mut state.interactive_compound_abort, - RendererNamespace::Preview => &mut state.preview_compound_abort, + RendererNamespace::Preview => &mut state.preview_abort, }; if slot.as_ref().is_some_and(|slot| slot.identity == identity) && let Some(slot) = slot.take() @@ -1373,7 +1371,7 @@ fn finish_compound_source( if let Ok(mut st) = state.try_borrow_mut() { let slot = match namespace { RendererNamespace::Interactive => &mut st.interactive_compound_abort, - RendererNamespace::Preview => &mut st.preview_compound_abort, + RendererNamespace::Preview => &mut st.preview_abort, }; if slot.as_ref().is_some_and(|slot| slot.identity == identity) { slot.take(); @@ -1455,11 +1453,9 @@ fn handle_render_preview_image( ) { let identity = { let mut st = state.borrow_mut(); - let identity = LoadIdentity::new(st.load_epoch, request_id); + st.preview_generation = st.preview_generation.saturating_add(1); + let identity = LoadIdentity::new(st.load_epoch, st.preview_generation); let previous = st.preview_reducer.current_identity(); - if let Some(abort) = st.preview_abort.take() { - abort.abort(); - } let transition = st.preview_reducer.reduce(LoadEvent::StartLoad { namespace: RendererNamespace::Preview, identity, @@ -1470,18 +1466,23 @@ fn handle_render_preview_image( ) { return; } - st.preview_identity = Some(identity); let abort = AbortController::new().ok(); - st.preview_abort = abort.clone(); - if let Some(previous) = previous - && identity > previous - { + if let Some(controller) = abort.clone() { + if let Some(previous_slot) = st.preview_abort.replace(PreviewAbortSlot { + identity, + controller, + }) { + previous_slot.controller.abort(); + } + } else if let Some(previous_slot) = st.preview_abort.take() { + previous_slot.controller.abort(); + } + if let Some(previous) = previous { st.post_event(&RendererEvent::LoadCancelled { namespace: RendererNamespace::Preview, identity: previous, }); } - let _ = previous; (identity, abort) }; let (identity, abort) = identity; @@ -1500,10 +1501,12 @@ fn handle_render_preview_image( let Ok(mut st) = state_clone.try_borrow_mut() else { return; }; - if st.preview_identity != Some(identity) { + if st.preview_reducer.current_identity() != Some(identity) + || st.preview_abort.as_ref().is_none_or(|slot| slot.identity != identity) + { return; } - st.preview_abort = None; + st.preview_abort.take(); let event = match result { Ok(png) => RendererEvent::PreviewImageRendered { request_id, png }, Err(message) => RendererEvent::PreviewImageError { @@ -1959,10 +1962,10 @@ fn handle_command(state: &Rc>, cmd: RendererCommand) { identity, } => { if namespace == RendererNamespace::Preview - && st.preview_identity == Some(identity) - && let Some(abort) = st.preview_abort.take() + && st.preview_abort.as_ref().is_some_and(|slot| slot.identity == identity) + && let Some(slot) = st.preview_abort.take() { - abort.abort(); + slot.controller.abort(); } abort_compound_slot(&mut st, namespace, identity); let reducer = match namespace { @@ -1986,8 +1989,6 @@ fn handle_command(state: &Rc>, cmd: RendererCommand) { renderer.model = None; } st.needs_render = true; - } else if st.preview_identity == Some(identity) { - st.preview_identity = None; } st.post_event(&RendererEvent::LoadCancelled { namespace, @@ -2088,11 +2089,9 @@ fn handle_command(state: &Rc>, cmd: RendererCommand) { st.interactive_compound_abort .take() .map(|slot| slot.controller.abort()); - st.preview_compound_abort + st.preview_abort .take() .map(|slot| slot.controller.abort()); - st.preview_abort.take().map(|abort| abort.abort()); - st.preview_identity = None; st.pending_scene = None; st.disposed = true; st.ledger.retire(owner(st.load_epoch, st.scene_generation)); diff --git a/src/appview/ldraw.rs b/src/appview/ldraw.rs index 221c776..b722b5b 100644 --- a/src/appview/ldraw.rs +++ b/src/appview/ldraw.rs @@ -94,6 +94,7 @@ pub(super) async fn compound_resources( let mut seen_bindings = HashSet::new(); let mut queue = VecDeque::from([path.clone()]); let mut manifest_edges = 0_usize; + let mut total_bytes = 0_u64; while let Some(current_path) = queue.pop_front() { let current = resolver @@ -109,7 +110,17 @@ pub(super) async fn compound_resources( "compound resource descriptor bound exceeded", )); } - let bytes = fetch_verified_bytes(&state, ¤t).await?; + let projected_length = current_binding.byte_length; + let remaining_budget = MAX_COMPOUND_TOTAL_BYTES + .checked_sub(total_bytes) + .ok_or_else(|| invalid_request("compound byte bound overflow"))?; + if projected_length > remaining_budget { + return Err(invalid_request("compound plan bounds exceeded")); + } + total_bytes = total_bytes + .checked_add(projected_length) + .ok_or_else(|| invalid_request("compound byte bound overflow"))?; + let bytes = fetch_verified_bytes(&state, ¤t, projected_length).await?; let references = extract_references(&bytes).map_err(|_| not_found())?; let rows = db( sqlx::query!( @@ -175,7 +186,6 @@ pub(super) async fn compound_resources( let mut descriptors = Vec::with_capacity(resources.len()); let mut seen_keys = HashSet::new(); - let mut total_bytes = 0_u64; let mut metadata_bytes = path.as_str().len(); for resource in resources { let binding = binding_for(&request.project, &resource)?; @@ -197,9 +207,6 @@ pub(super) async fn compound_resources( descriptor .validate() .map_err(|error| invalid_request(format!("invalid compound descriptor: {error}")))?; - total_bytes = total_bytes - .checked_add(descriptor.byte_length) - .ok_or_else(|| invalid_request("compound byte bound overflow"))?; let descriptor_metadata = descriptor .key .len() @@ -219,7 +226,7 @@ pub(super) async fn compound_resources( .ok_or_else(|| invalid_request("compound metadata bound overflow"))?; descriptors.push(descriptor); } - if total_bytes > MAX_COMPOUND_TOTAL_BYTES || metadata_bytes > MAX_COMPOUND_METADATA_BYTES { + if metadata_bytes > MAX_COMPOUND_METADATA_BYTES { return Err(invalid_request("compound plan bounds exceeded")); } let plan = CompoundLoadPlan { @@ -247,7 +254,7 @@ pub(super) async fn fetch_resource( if binding_for(&binding.project, &resource).map_err(|_| not_found())? != binding { return Err(not_found()); } - let bytes = fetch_verified_bytes(&state, &resource).await?; + let bytes = fetch_verified_bytes(&state, &resource, binding.byte_length).await?; Response::builder() .status(StatusCode::OK) .header(header::CONTENT_TYPE, resource.mime_type.as_str()) @@ -505,7 +512,11 @@ fn subroot_scope(root: RootId, path: &str) -> Result, ()> { } } -async fn fetch_verified_bytes(state: &AppState, resource: &ResolvedResource) -> AppResult> { +async fn fetch_verified_bytes( + state: &AppState, + resource: &ResolvedResource, + max_bytes: u64, +) -> AppResult> { let did = match resource.source.resource_uri.authority().convert() { jacquard_common::types::string::AtIdentifier::Did(did) => did, jacquard_common::types::string::AtIdentifier::Handle(handle) => { @@ -524,7 +535,15 @@ async fn fetch_verified_bytes(state: &AppState, resource: &ResolvedResource) -> .pds_endpoint() .ok_or_else(|| internal("DID document does not advertise a PDS endpoint"))? .to_owned(); - let mut bytes = Vec::new(); + let expected_length = u64::try_from(resource.byte_length) + .map_err(|_| invalid_request("negative LDraw resource length"))?; + if expected_length != max_bytes || expected_length > MAX_COMPOUND_TOTAL_BYTES { + return Err(invalid_request("LDraw byte admission failed")); + } + let capacity = usize::try_from(expected_length) + .map_err(|_| invalid_request("LDraw byte length is too large"))?; + let mut bytes = Vec::with_capacity(capacity); + let mut admitted = 0_u64; for value in &resource.source.blob_cids { let cid = Cid::new_owned(value.as_bytes()) .map_err(|error| internal(format!("invalid LDraw blob CID: {error}")))?; @@ -544,19 +563,28 @@ async fn fetch_verified_bytes(state: &AppState, resource: &ResolvedResource) -> ))); } let (_, body) = response.into_parts(); - let chunk = body - .into_inner() - .try_fold(Vec::new(), |mut bytes, chunk| async move { - bytes.extend_from_slice(&chunk); - Ok::<_, _>(bytes) - }) + let mut body_stream = body.into_inner(); + let mut chunk = Vec::new(); + while let Some(part) = body_stream + .try_next() .await - .map_err(|error| internal(format!("blob stream failed: {error}")))?; + .map_err(|error| internal(format!("blob stream failed: {error}")))? + { + let part_length = u64::try_from(part.len()) + .map_err(|_| invalid_request("LDraw chunk length overflow"))?; + admitted = admitted + .checked_add(part_length) + .ok_or_else(|| invalid_request("LDraw byte length overflow"))?; + if admitted > max_bytes { + return Err(invalid_request("LDraw byte admission exceeded")); + } + chunk.extend_from_slice(&part); + } verify_chunk_cid(value, &chunk) .map_err(|error| invalid_request(format!("chunk integrity check failed: {error}")))?; bytes.extend_from_slice(&chunk); } - if bytes.len() as i64 != resource.byte_length { + if admitted != expected_length || bytes.len() as u64 != expected_length { return Err(invalid_request("LDraw byte length verification failed")); } let digest = Sha256::digest(&bytes); diff --git a/src/viewer.rs b/src/viewer.rs index edb5f09..27b04d1 100644 --- a/src/viewer.rs +++ b/src/viewer.rs @@ -1466,25 +1466,6 @@ fn context_acquisitions_after_event(current: u64, event: &RendererEvent) -> u64 } } -#[derive(Debug, Default, PartialEq, Eq)] -struct BridgeDisposeTrace { - actions: Vec<&'static str>, -} - -impl BridgeDisposeTrace { - fn dispose_before_terminate(&mut self) { - self.actions.push("dispose"); - self.actions.push("terminate"); - } - - fn cleanup(&mut self) { - self.actions.push("cancel_raf"); - self.actions.push("drop_raf_closure"); - self.actions.push("remove_pointer_listeners"); - self.actions.push("remove_resize_listener"); - } -} - #[cfg(target_arch = "wasm32")] struct WorkerSpawnSignals { status: Signal, @@ -2620,38 +2601,6 @@ mod tests { assert_eq!(context_acquisitions_after_event(1, &other), 1); } - #[test] - fn bridge_disposes_before_termination_and_cleans_browser_handles() { - let mut trace = BridgeDisposeTrace::default(); - trace.cleanup(); - trace.dispose_before_terminate(); - assert_eq!( - trace.actions, - vec![ - "cancel_raf", - "drop_raf_closure", - "remove_pointer_listeners", - "remove_resize_listener", - "dispose", - "terminate", - ] - ); - } - - #[test] - fn restart_epoch_requires_fresh_canvas_and_plan_session() { - assert!(!pending_plan_is_current(0, 2)); - assert!(pending_plan_is_current(2, 2)); - assert_eq!( - context_acquisitions_after_event(1, &RendererEvent::ContextAcquired), - 1 - ); - assert_eq!( - context_acquisitions_after_event(1, &RendererEvent::RendererContextReady), - 1 - ); - } - fn deserialize_command_at(bytes: &[u8]) -> RendererCommand { match polymodel_renderer_protocol::deserialize_command_envelope(bytes) .expect("deserialize")