diff --git a/crates/polymodel-renderer-protocol/src/lib.rs b/crates/polymodel-renderer-protocol/src/lib.rs index 0f66739..a9b89bc 100644 --- a/crates/polymodel-renderer-protocol/src/lib.rs +++ b/crates/polymodel-renderer-protocol/src/lib.rs @@ -704,59 +704,8 @@ pub enum RendererEvent { /// /// This compatibility helper is retained for callers that only have a command. New /// session-bound transports should use [`serialize_command_for_session`]. -pub fn serialize_command(cmd: &RendererCommand) -> Result, postcard::Error> { - serialize_command_for_session(cmd, 0) -} - -pub fn serialize_command_for_session( - cmd: &RendererCommand, - session_id: u64, -) -> Result, postcard::Error> { - postcard::to_allocvec(&CommandEnvelope { - version: PROTOCOL_VERSION, - session_id, - payload: CommandPayload::Command(cmd.clone()), - }) -} - -/// Serialize an event in the mandatory versioned envelope. -/// -/// This compatibility helper is retained for worker events emitted before a -/// transport session is negotiated. Session-bound worker bridges use -/// [`serialize_event_for_session`]. -pub fn serialize_event(evt: &RendererEvent) -> Result, postcard::Error> { - serialize_event_for_session(evt, 0) -} - -pub fn serialize_event_for_session( - evt: &RendererEvent, - session_id: u64, -) -> Result, postcard::Error> { - postcard::to_allocvec(&EventEnvelope { - version: PROTOCOL_VERSION, - session_id, - payload: EventPayload::Event(evt.clone()), - }) -} - -/// Deserialize a command only from the mandatory versioned envelope. -pub fn deserialize_command(bytes: &[u8]) -> Result { - let envelope: CommandEnvelope = postcard::from_bytes(bytes)?; - match envelope.payload { - CommandPayload::Command(command) if envelope.version == PROTOCOL_VERSION => Ok(command), - _ => Err(postcard::Error::DeserializeUnexpectedEnd), - } -} - -/// Deserialize an event only from the mandatory versioned envelope. -pub fn deserialize_event(bytes: &[u8]) -> Result { - let envelope: EventEnvelope = postcard::from_bytes(bytes)?; - match envelope.payload { - EventPayload::Event(event) if envelope.version == PROTOCOL_VERSION => Ok(event), - _ => Err(postcard::Error::DeserializeUnexpectedEnd), - } -} - +/// Serialize a command envelope. Scene-dependent commands must use the negotiated +/// non-zero session; only Hello and Accept envelopes use session zero. pub fn serialize_command_envelope(envelope: &CommandEnvelope) -> Result, postcard::Error> { postcard::to_allocvec(envelope) } @@ -773,6 +722,23 @@ pub fn deserialize_event_envelope(bytes: &[u8]) -> Result Option { + match command { + RendererCommand::StartCompoundLoad { .. } => Some(Capability::CompoundLdraw), + RendererCommand::RenderPreviewImage { .. } => Some(Capability::Preview), + RendererCommand::Cancel { .. } => Some(Capability::Cancellation), + RendererCommand::StartLoad { .. } + | RendererCommand::Resize { .. } + | RendererCommand::SetPointerState { .. } + | RendererCommand::PointerDown { .. } + | RendererCommand::PointerUp { .. } + | RendererCommand::Dispose + | RendererCommand::DebugCrash => None, + } +} + // --------------------------------------------------------------------------- // Tests // --------------------------------------------------------------------------- @@ -865,11 +831,33 @@ mod tests { } fn roundtrip_command(cmd: &RendererCommand) -> RendererCommand { - deserialize_command(&serialize_command(cmd).unwrap()).unwrap() + let envelope = CommandEnvelope { + version: PROTOCOL_VERSION, + session_id: 7, + payload: CommandPayload::Command(cmd.clone()), + }; + match deserialize_command_envelope(&serialize_command_envelope(&envelope).unwrap()) + .unwrap() + .payload + { + CommandPayload::Command(command) => command, + _ => panic!("expected command payload"), + } } fn roundtrip_event(evt: &RendererEvent) -> RendererEvent { - deserialize_event(&serialize_event(evt).unwrap()).unwrap() + let envelope = EventEnvelope { + version: PROTOCOL_VERSION, + session_id: 7, + payload: EventPayload::Event(evt.clone()), + }; + match deserialize_event_envelope(&serialize_event_envelope(&envelope).unwrap()) + .unwrap() + .payload + { + EventPayload::Event(event) => event, + _ => panic!("expected event payload"), + } } #[test] @@ -1031,7 +1019,74 @@ mod tests { #[test] fn old_bare_postcard_messages_are_not_accepted() { let bare = postcard::to_allocvec(&RendererCommand::Dispose).unwrap(); - assert!(deserialize_command(&bare).is_err()); + assert!(deserialize_command_envelope(&bare).is_err()); + } + + #[test] + fn session_zero_scene_envelopes_are_rejected_by_state_machine() { + let hello = ProtocolHello { + min_version: PROTOCOL_VERSION, + max_version: PROTOCOL_VERSION, + required: vec![Capability::CurrentFormats], + optional: vec![], + }; + let negotiated = negotiate(&hello, &hello, 9).unwrap(); + let mut state = HandshakeState::Negotiated(negotiated); + let command = CommandEnvelope { + version: PROTOCOL_VERSION, + session_id: 0, + payload: CommandPayload::Command(RendererCommand::Dispose), + }; + assert_eq!( + state.accept_command(&command), + Err(HandshakeError::OutOfOrder) + ); + } + + #[test] + fn handshake_rejects_duplicate_and_conflicting_messages() { + let duplicate = ProtocolHello { + min_version: PROTOCOL_VERSION, + max_version: PROTOCOL_VERSION, + required: vec![Capability::Preview, Capability::Preview], + optional: vec![], + }; + assert_eq!( + duplicate.validate(), + Err(HandshakeError::DuplicateCapability(Capability::Preview)) + ); + let conflict = ProtocolHello { + min_version: PROTOCOL_VERSION, + max_version: PROTOCOL_VERSION, + required: vec![Capability::Preview], + optional: vec![Capability::Preview], + }; + assert_eq!( + conflict.validate(), + Err(HandshakeError::ConflictingCapability(Capability::Preview)) + ); + } + + #[test] + fn independent_golden_command_envelope_bytes_remain_stable() { + let envelope = CommandEnvelope { + version: PROTOCOL_VERSION, + session_id: 7, + payload: CommandPayload::Command(RendererCommand::Dispose), + }; + let bytes = serialize_command_envelope(&envelope).unwrap(); + assert_eq!(bytes, [1, 7, 2, 8]); + } + + #[test] + fn independent_golden_event_envelope_bytes_remain_stable() { + let envelope = EventEnvelope { + version: PROTOCOL_VERSION, + session_id: 7, + payload: EventPayload::Event(RendererEvent::ContextAcquired), + }; + let bytes = serialize_event_envelope(&envelope).unwrap(); + assert_eq!(bytes, [1, 7, 3, 0]); } #[test] @@ -1053,9 +1108,9 @@ mod tests { #[test] fn deserialize_garbage_returns_error() { - assert!(deserialize_command(&[0xFF, 0xFE, 0xFD]).is_err()); - assert!(deserialize_event(&[0xFF, 0xFE, 0xFD]).is_err()); - assert!(deserialize_command(&[]).is_err()); - assert!(deserialize_event(&[]).is_err()); + assert!(deserialize_command_envelope(&[0xFF, 0xFE, 0xFD]).is_err()); + assert!(deserialize_event_envelope(&[0xFF, 0xFE, 0xFD]).is_err()); + assert!(deserialize_command_envelope(&[]).is_err()); + assert!(deserialize_event_envelope(&[]).is_err()); } } diff --git a/crates/polymodel-renderer-worker/src/worker.rs b/crates/polymodel-renderer-worker/src/worker.rs index cf3475c..0cae293 100644 --- a/crates/polymodel-renderer-worker/src/worker.rs +++ b/crates/polymodel-renderer-worker/src/worker.rs @@ -85,6 +85,10 @@ fn owner(load_epoch: u32, scene_generation: u32) -> ReservationOwner { ) } +fn load_owner(identity: LoadIdentity) -> ReservationOwner { + owner(identity.load_epoch, identity.scene_generation) +} + struct WorkerState { scope: DedicatedWorkerGlobalScope, canvas: Option, @@ -107,6 +111,7 @@ struct WorkerState { load_epoch: u32, scene_generation: u32, compound_abort: Option, + pending_events: Vec, handshake: HandshakeState, local_hello: ProtocolHello, } @@ -131,6 +136,7 @@ impl WorkerState { load_epoch: 0, scene_generation: 0, compound_abort: None, + pending_events: Vec::new(), handshake: HandshakeState::Created, local_hello: ProtocolHello { min_version: polymodel_renderer_protocol::PROTOCOL_VERSION, @@ -151,9 +157,9 @@ impl WorkerState { } } - fn post_event(&self, evt: &RendererEvent) { + fn post_event(&mut self, evt: &RendererEvent) { let Some(session_id) = self.handshake.session_id() else { - tracing::warn!("suppressing renderer event before handshake"); + self.pending_events.push(evt.clone()); return; }; self.post_envelope(&EventEnvelope { @@ -163,7 +169,14 @@ impl WorkerState { }); } - fn post_negotiated(&self, negotiated: &NegotiatedProtocol) { + fn flush_pending_events(&mut self) { + let pending = std::mem::take(&mut self.pending_events); + for event in pending { + self.post_event(&event); + } + } + + fn post_negotiated(&mut self, negotiated: &NegotiatedProtocol) { self.post_envelope(&EventEnvelope { version: polymodel_renderer_protocol::PROTOCOL_VERSION, session_id: negotiated.session_id, @@ -1245,10 +1258,7 @@ async fn load_compound_source( .map_err(|error| format!("compound plan encoding rejected: {error:?}"))?; compound_is_current(state, identity, abort.as_ref())?; let descriptors = plan.descriptors; - let owner = { - let st = state.borrow(); - owner(identity.load_epoch, st.scene_generation) - }; + let owner = load_owner(identity); let total_bytes = descriptors.iter().try_fold(0_u64, |total, descriptor| { total .checked_add(descriptor.byte_length) @@ -1506,6 +1516,7 @@ fn finish_loaded_mesh( fn handle_render_preview_image( state: &Rc>, + session_id: u64, request_id: u32, format: MeshFormat, primary_url: String, @@ -1545,7 +1556,7 @@ fn handle_render_preview_image( }; let envelope = EventEnvelope { version: polymodel_renderer_protocol::PROTOCOL_VERSION, - session_id: 0, + session_id, payload: EventPayload::Event(evt), }; match serialize_event_envelope(&envelope) { @@ -1682,8 +1693,27 @@ async fn fetch_bytes(url: &str, abort: Option<&AbortController>) -> Result(); - return Err(format!("fetch returned HTTP {status} {bounded}")); + let bounded_status = status_text.chars().take(96).collect::(); + let body = response + .text() + .ok() + .map(wasm_bindgen_futures::JsFuture::from) + .map(|future| async move { future.await.ok().and_then(|value| value.as_string()) }); + let bounded_body = match body { + Some(future) => future + .await + .unwrap_or_default() + .chars() + .take(512) + .collect::(), + None => String::new(), + }; + let detail = if bounded_body.is_empty() { + format!("fetch returned HTTP {status} {bounded_status}") + } else { + format!("fetch returned HTTP {status} {bounded_status}: {bounded_body}") + }; + return Err(detail); } let array_buffer_promise = response @@ -1718,14 +1748,8 @@ fn handle_command(state: &Rc>, cmd: RendererCommand) { tracing::warn!("rejecting scene command before negotiated session"); return; }; - let capability_allowed = match &cmd { - RendererCommand::StartCompoundLoad { .. } => { - capabilities.contains(&Capability::CompoundLdraw) - } - RendererCommand::RenderPreviewImage { .. } => capabilities.contains(&Capability::Preview), - RendererCommand::Cancel { .. } => capabilities.contains(&Capability::Cancellation), - _ => true, - }; + let capability_allowed = polymodel_renderer_protocol::required_capability(&cmd) + .is_none_or(|capability| capabilities.contains(&capability)); if !capability_allowed { tracing::warn!("renderer command rejected by negotiated capabilities"); return; @@ -1824,8 +1848,17 @@ fn handle_command(state: &Rc>, cmd: RendererCommand) { width, height, } => { + let session_id = st.handshake.session_id().unwrap_or_default(); drop(st); - handle_render_preview_image(state, request_id, format, primary_url, width, height); + handle_render_preview_image( + state, + session_id, + request_id, + format, + primary_url, + width, + height, + ); } RendererCommand::Resize { css_w, css_h, dpr } => { let _ = st.load_reducer.reduce(LoadEvent::Resize { @@ -2027,7 +2060,11 @@ pub fn entry() { tracing::debug!(command = ?cmd, "renderer worker: command received"); handle_command(&state_for_msg, cmd); } - Ok(None) => {} + Ok(None) => { + if matches!(st.handshake, HandshakeState::Negotiated(_)) { + st.flush_pending_events(); + } + } Err(error) => { tracing::warn!("rejected command before negotiated session: {error:?}") } diff --git a/src/publish.rs b/src/publish.rs index 957514e..c401d95 100644 --- a/src/publish.rs +++ b/src/publish.rs @@ -2733,31 +2733,51 @@ mod renderer_preview { session_id: protocol.session_id, payload: CommandPayload::Command(command.clone()), }; - for envelope in [accept, command_envelope] { - match serialize_command_envelope(&envelope) { - Ok(bytes) => { - if let Err(error) = worker_for_message.post_message( - &js_sys::Uint8Array::from(bytes.as_slice()), - ) { - let _ = reject_message.call1( - &JsValue::NULL, - &JsValue::from_str(&format!( - "preview command post: {error:?}" - )), - ); - return; - } - } - Err(error) => { + match serialize_command_envelope(&accept) { + Ok(bytes) => { + if let Err(error) = worker_for_message + .post_message(&js_sys::Uint8Array::from(bytes.as_slice())) + { let _ = reject_message.call1( &JsValue::NULL, &JsValue::from_str(&format!( - "preview command serialize: {error}" + "preview accept post: {error:?}" )), ); return; } } + Err(error) => { + let _ = reject_message.call1( + &JsValue::NULL, + &JsValue::from_str(&format!( + "preview accept serialize: {error}" + )), + ); + return; + } + } + match serialize_command_envelope(&command_envelope) { + Ok(bytes) => { + if let Err(error) = worker_for_message + .post_message(&js_sys::Uint8Array::from(bytes.as_slice())) + { + let _ = reject_message.call1( + &JsValue::NULL, + &JsValue::from_str(&format!( + "preview command post: {error:?}" + )), + ); + } + } + Err(error) => { + let _ = reject_message.call1( + &JsValue::NULL, + &JsValue::from_str(&format!( + "preview command serialize: {error}" + )), + ); + } } } return; diff --git a/src/viewer.rs b/src/viewer.rs index 280e6f2..7429aa6 100644 --- a/src/viewer.rs +++ b/src/viewer.rs @@ -335,6 +335,7 @@ pub fn ViewerPage(initial_model: DemoModel) -> Element { let resize_count = use_signal(|| 0_u64); let context_acquisitions = use_signal(|| 0_u64); let renderer_failed = use_signal(|| false); + let restart_epoch = use_signal(|| 0_u32); let mesh_stats: Signal> = use_signal(|| None); let status: Signal = use_signal(|| { ViewerStatus::Loading(SessionKey::new(initial_model.id, initial_model.generation)) @@ -406,6 +407,7 @@ pub fn ViewerPage(initial_model: DemoModel) -> Element { resize_count, context_acquisitions, renderer_failed, + restart_epoch, fallback: None, } } @@ -426,6 +428,7 @@ pub fn AssetViewer( let resize_count = use_signal(|| 0_u64); let context_acquisitions = use_signal(|| 0_u64); let renderer_failed = use_signal(|| false); + let restart_epoch = use_signal(|| 0_u32); let mesh_stats: Signal> = use_signal(|| None); let status: Signal = use_signal(|| { let key = source @@ -524,6 +527,7 @@ pub fn AssetViewer( resize_count, context_acquisitions, renderer_failed, + restart_epoch, fallback, } } @@ -818,6 +822,7 @@ pub struct ModelViewerProps { resize_count: Signal, context_acquisitions: Signal, renderer_failed: Signal, + restart_epoch: Signal, fallback: Option, } @@ -827,6 +832,7 @@ pub fn ModelViewer(props: ModelViewerProps) -> Element { let resize_count = props.resize_count; let context_acquisitions = props.context_acquisitions; let renderer_failed = props.renderer_failed; + let restart_epoch = props.restart_epoch; let fallback = props.fallback; let mesh_stats = props.mesh_stats; let status = props.status; @@ -869,6 +875,7 @@ pub fn ModelViewer(props: ModelViewerProps) -> Element { div { class: "model-viewer-stage", canvas { + key: "viewer-canvas-{restart_epoch.read()}", id: "polymodel-viewer-canvas", "data-mounted": "{canvas_mounted.read()}", "data-renderer-kind": renderer_kind, @@ -902,6 +909,7 @@ pub fn ModelViewer(props: ModelViewerProps) -> Element { resize_count, context_acquisitions, renderer_failed, + restart_epoch, mesh_stats, } } @@ -948,6 +956,7 @@ fn WorkerRendererSession( resize_count: Signal, context_acquisitions: Signal, renderer_failed: Signal, + restart_epoch: Signal, mesh_stats: Signal>, ) -> Element { rsx! { @@ -961,6 +970,7 @@ fn WorkerRendererSession( resize_count, context_acquisitions, renderer_failed, + restart_epoch, mesh_stats, } } @@ -978,6 +988,7 @@ fn WorkerSessionInner( resize_count: Signal, context_acquisitions: Signal, renderer_failed: Signal, + restart_epoch: Signal, mesh_stats: Signal>, ) -> Element { let _ = ( @@ -990,6 +1001,7 @@ fn WorkerSessionInner( resize_count, context_acquisitions, renderer_failed, + restart_epoch, mesh_stats, ); rsx! {} @@ -1007,6 +1019,7 @@ fn WorkerSessionInner( resize_count: Signal, context_acquisitions: Signal, mut renderer_failed: Signal, + restart_epoch: Signal, mesh_stats: Signal>, ) -> Element { use std::cell::RefCell; @@ -1023,6 +1036,7 @@ fn WorkerSessionInner( // Spawn the worker + attach message handler once. let bridge_for_spawn = bridge.clone(); use_effect(move || { + let _ = *restart_epoch.read(); let status_clone = status; let context_acquisitions_clone = context_acquisitions; let renderer_failed_clone = renderer_failed; @@ -1032,11 +1046,14 @@ fn WorkerSessionInner( let mut bt = bridge_for_spawn.borrow_mut(); if bt.worker.is_none() { bt.spawn_worker( + bridge_for_spawn.clone(), status_clone, context_acquisitions_clone, renderer_failed_clone, mesh_stats_clone, worker_ready_clone, + canvas_mounted, + restart_epoch, ); } }); @@ -1063,7 +1080,7 @@ fn WorkerSessionInner( // Send initial Resize after canvas transfer. if bt.canvas_transferred - && !bt.initial_resize_sent + && !*bt.initial_resize_sent.borrow() && let Some(canvas) = lookup_viewer_canvas() { let (css_w, css_h) = ( @@ -1073,12 +1090,12 @@ fn WorkerSessionInner( let dpr = web_sys::window() .map(|w| w.device_pixel_ratio() as f32) .unwrap_or(1.0); - bt.post_command(&RendererCommand::Resize { css_w, css_h, dpr }); - bt.initial_resize_sent = true; + bt.send_command(&RendererCommand::Resize { css_w, css_h, dpr }); + bt.flush_queue(); } // Send LoadMesh after canvas + initial resize. - if bt.canvas_transferred && bt.initial_resize_sent { + if bt.canvas_transferred && *bt.initial_resize_sent.borrow() { let source = render_source.read().clone().or_else(|| { fallback_to_demo .then(|| { @@ -1178,14 +1195,17 @@ use wasm_bindgen::closure::Closure; struct WorkerBridgeState { worker: Option, canvas_transferred: bool, - initial_resize_sent: bool, + initial_resize_sent: Rc>, load_reducer: Rc>, next_identity: LoadIdentity, current_session: Rc>>, handshake: Rc>, session_id: Rc>>, post_canvas_queue: Rc>>, + pending_resize: Option, compound_started_key: Option, + current_intent: Option, + restart_epoch: u32, resize_cleanup: Option>, pointer_cleanup: Option>, pointer_listeners_attached: bool, @@ -1212,7 +1232,7 @@ impl WorkerBridgeState { Self { worker: None, canvas_transferred: false, - initial_resize_sent: false, + initial_resize_sent: Rc::new(RefCell::new(false)), load_reducer: Rc::new(RefCell::new(LoadReducer::new( RendererNamespace::Interactive, ))), @@ -1221,7 +1241,10 @@ impl WorkerBridgeState { handshake: Rc::new(RefCell::new(HandshakeState::Created)), session_id: Rc::new(RefCell::new(None)), post_canvas_queue: Rc::new(RefCell::new(Vec::new())), + pending_resize: None, compound_started_key: None, + current_intent: None, + restart_epoch: 0, resize_cleanup: None, pointer_cleanup: None, pointer_listeners_attached: false, @@ -1234,11 +1257,14 @@ impl WorkerBridgeState { fn spawn_worker( &mut self, + bridge: std::rc::Rc>, status: Signal, context_acquisitions: Signal, mut renderer_failed: Signal, mesh_stats: Signal>, mut worker_ready: Signal, + canvas_mounted: Signal, + restart_epoch: Signal, ) { use wasm_bindgen::JsCast; @@ -1253,7 +1279,27 @@ impl WorkerBridgeState { } }; - // Set up onmessage handler. + // Set up onmessage handler. Both fatal event paths use the same reset so + // a worker cannot leave a transferred canvas or stale session behind. + let worker_ready_for_restart = Rc::new(RefCell::new(worker_ready)); + let canvas_mounted_for_restart = Rc::new(RefCell::new(canvas_mounted)); + let renderer_failed_for_restart = Rc::new(RefCell::new(renderer_failed)); + let restart_epoch_for_restart = Rc::new(RefCell::new(restart_epoch)); + let restart: Rc = Rc::new({ + let worker_ready = worker_ready_for_restart.clone(); + let canvas_mounted = canvas_mounted_for_restart.clone(); + let renderer_failed = renderer_failed_for_restart.clone(); + let restart_epoch = restart_epoch_for_restart.clone(); + move || { + let mut bt = bridge.borrow_mut(); + bt.reset_for_restart(); + worker_ready.borrow_mut().set(false); + canvas_mounted.borrow_mut().set(false); + renderer_failed.borrow_mut().set(true); + restart_epoch.borrow_mut().set(bt.restart_epoch); + } + }); + let restart_for_message = restart.clone(); let mut status_msg = status; let mut acquisitions_msg = context_acquisitions; let mut failed_msg = renderer_failed; @@ -1272,6 +1318,7 @@ impl WorkerBridgeState { && s == "__worker_ready" { worker_ready.set(true); + failed_msg.set(false); let hello = CommandEnvelope { version: polymodel_renderer_protocol::PROTOCOL_VERSION, session_id: 0, @@ -1448,12 +1495,32 @@ impl WorkerBridgeState { status_msg.set(ViewerStatus::Cancelled(session)); } } - RendererEvent::CompoundResourcesReady { .. } - | RendererEvent::PreviewImageRendered { .. } + RendererEvent::CompoundResourcesReady { + namespace, + identity, + source, + } => { + if namespace == RendererNamespace::Interactive + && reducer_msg.borrow().current_identity() == Some(identity) + { + if let Err(error) = + polymodel_renderer_protocol::handoff_compound_scene(source) + { + tracing::error!("compound scene handoff rejected: {error}"); + } else { + tracing::debug!( + "verified compound resources reached the typed scene seam" + ); + } + } else { + tracing::debug!("discarded stale compound resources event"); + } + } + RendererEvent::PreviewImageRendered { .. } | RendererEvent::PreviewImageError { .. } => {} RendererEvent::Error { fatal, message } => { if fatal { - failed_msg.set(true); + restart_for_message(); status_msg.set(ViewerStatus::RendererError(ViewerIssue::RendererInit)); } tracing::error!("renderer worker error: {message}"); @@ -1465,11 +1532,11 @@ impl WorkerBridgeState { worker.set_onmessage(Some(onmessage.as_ref().unchecked_ref())); // Set up onerror handler. - let mut failed_err = renderer_failed; + let restart_for_error = restart.clone(); let onerror = Closure::wrap(Box::new(move |event: web_sys::ErrorEvent| { let message = event.message(); tracing::error!("renderer worker error: {message}"); - failed_err.set(true); + restart_for_error(); }) as Box); worker.set_onerror(Some(onerror.as_ref().unchecked_ref())); @@ -1549,6 +1616,7 @@ impl WorkerBridgeState { return; } self.compound_started_key = Some(pending.key.clone()); + self.current_intent = Some(pending.clone()); *self.current_session.borrow_mut() = Some(SessionKey::new( pending.key, identity.scene_generation as u64, @@ -1587,11 +1655,32 @@ impl WorkerBridgeState { }); } + fn reset_for_restart(&mut self) { + if let Some(worker) = self.worker.take() { + worker.terminate(); + } + self.canvas_transferred = false; + *self.initial_resize_sent.borrow_mut() = false; + *self.handshake.borrow_mut() = HandshakeState::Created; + *self.session_id.borrow_mut() = None; + self.pending_resize = None; + self.post_canvas_queue.borrow_mut().clear(); + self.compound_started_key = None; + self.restart_epoch = self.restart_epoch.saturating_add(1); + let _ = self.load_reducer.borrow_mut().reduce(LoadEvent::Dispose { + namespace: RendererNamespace::Interactive, + }); + } + fn send_command(&mut self, cmd: &RendererCommand) { - if !self.canvas_transferred - || !self.initial_resize_sent - || self.session_id.borrow().is_none() - { + if matches!(cmd, RendererCommand::Resize { .. }) { + self.pending_resize = Some(cmd.clone()); + } + if !self.canvas_transferred || self.session_id.borrow().is_none() { + self.post_canvas_queue.borrow_mut().push(cmd.clone()); + return; + } + if !*self.initial_resize_sent.borrow() && !matches!(cmd, RendererCommand::Resize { .. }) { self.post_canvas_queue.borrow_mut().push(cmd.clone()); return; } @@ -1599,15 +1688,21 @@ impl WorkerBridgeState { } fn flush_queue(&mut self) { - if !self.canvas_transferred - || !self.initial_resize_sent - || self.session_id.borrow().is_none() - { + if !self.canvas_transferred || self.session_id.borrow().is_none() { + return; + } + if let Some(resize) = self.pending_resize.take() { + self.post_command(&resize); + *self.initial_resize_sent.borrow_mut() = true; + } + if !*self.initial_resize_sent.borrow() { return; } let queue = std::mem::take(&mut *self.post_canvas_queue.borrow_mut()); for command in queue { - self.post_command(&command); + if !matches!(command, RendererCommand::Resize { .. }) { + self.post_command(&command); + } } } @@ -2056,14 +2151,27 @@ mod tests { vertices: 1234, triangles: 4321, }; - let bytes = - polymodel_renderer_protocol::serialize_event(&RendererEvent::InstallSucceeded { - namespace: RendererNamespace::Interactive, - identity: LoadIdentity::new(1, 1), - stats, - }) - .expect("serialize"); - let evt = polymodel_renderer_protocol::deserialize_event(&bytes).expect("deserialize"); + let bytes = polymodel_renderer_protocol::serialize_event_envelope( + &polymodel_renderer_protocol::EventEnvelope { + version: polymodel_renderer_protocol::PROTOCOL_VERSION, + session_id: 7, + payload: polymodel_renderer_protocol::EventPayload::Event( + RendererEvent::InstallSucceeded { + namespace: RendererNamespace::Interactive, + identity: LoadIdentity::new(1, 1), + stats, + }, + ), + }, + ) + .expect("serialize"); + let evt = match polymodel_renderer_protocol::deserialize_event_envelope(&bytes) + .expect("deserialize") + .payload + { + polymodel_renderer_protocol::EventPayload::Event(evt) => evt, + _ => panic!("expected event"), + }; match evt { RendererEvent::InstallSucceeded { stats: s, .. } => { assert_eq!(s.vertices, 1234); @@ -2202,19 +2310,43 @@ mod tests { #[test] fn dispose_command_sent_on_drop() { // The WorkerBridgeState::drop sends Dispose + terminates the worker. - // This test verifies the command type exists and serializes. - let bytes = serialize_command(&RendererCommand::Dispose).expect("serialize"); + // This test verifies the command type exists and serializes in a session envelope. + let bytes = polymodel_renderer_protocol::serialize_command_envelope( + &polymodel_renderer_protocol::CommandEnvelope { + version: polymodel_renderer_protocol::PROTOCOL_VERSION, + session_id: 7, + payload: polymodel_renderer_protocol::CommandPayload::Command( + RendererCommand::Dispose, + ), + }, + ) + .expect("serialize"); let cmd = deserialize_command_at(&bytes); assert!(matches!(cmd, RendererCommand::Dispose)); } fn deserialize_command_at(bytes: &[u8]) -> RendererCommand { - polymodel_renderer_protocol::deserialize_command(bytes).expect("deserialize") + match polymodel_renderer_protocol::deserialize_command_envelope(bytes) + .expect("deserialize") + .payload + { + polymodel_renderer_protocol::CommandPayload::Command(command) => command, + _ => panic!("expected command"), + } } #[test] fn debug_crash_serializes() { - let bytes = serialize_command(&RendererCommand::DebugCrash).expect("serialize"); + let bytes = polymodel_renderer_protocol::serialize_command_envelope( + &polymodel_renderer_protocol::CommandEnvelope { + version: polymodel_renderer_protocol::PROTOCOL_VERSION, + session_id: 7, + payload: polymodel_renderer_protocol::CommandPayload::Command( + RendererCommand::DebugCrash, + ), + }, + ) + .expect("serialize"); let cmd = deserialize_command_at(&bytes); assert!(matches!(cmd, RendererCommand::DebugCrash)); }