From 02ad76be2131ff9b77921f987e1df925e77d714d Mon Sep 17 00:00:00 2001 From: selune <35337584+0xlillith@users.noreply.github.com> Date: Fri, 30 Oct 2026 14:46:28 +0100 Subject: [PATCH] feat(render): preserve unrun partial-film host producer and narrow-card fix proposals --- proposals/render/2026-10-30/README.md | 6 + .../2026-10-30/c13-pinned-actions/README.md | 7 + .../c13-pinned-actions/proposal.patch | 92 ++ .../partial-stream-source-v1/README.md | 15 + .../partial-stream-source-v1/host.patch | 978 ++++++++++++++++ .../producer-A1-A2.patch | 1003 +++++++++++++++++ 6 files changed, 2101 insertions(+) create mode 100644 proposals/render/2026-10-30/c13-pinned-actions/README.md create mode 100644 proposals/render/2026-10-30/c13-pinned-actions/proposal.patch create mode 100644 proposals/render/2026-10-30/partial-stream-source-v1/README.md create mode 100644 proposals/render/2026-10-30/partial-stream-source-v1/host.patch create mode 100644 proposals/render/2026-10-30/partial-stream-source-v1/producer-A1-A2.patch diff --git a/proposals/render/2026-10-30/README.md b/proposals/render/2026-10-30/README.md index cd627bad8..c32053e36 100644 --- a/proposals/render/2026-10-30/README.md +++ b/proposals/render/2026-10-30/README.md @@ -13,6 +13,12 @@ | [Raster perspective candidate](parity-raster-main66bd/README.md) | Source-reviewed against its actual newer main API, not this older frozen candidate. Original perspective/legacy controls, no compiler/runtime claim or permission to overlay it blindly. | | [Native observations](native-followups/native-round-one.md) and [remaining EV/HDR/final journeys](native-followups/ev-hdr-final-acceptance-proposal.md) | First older-binary round was partial. Fresh current-source app build and mouse/keyboard acceptance remain pending; source tests do not close native UX. | +## New source packets and original detailed fixture + +- [C13 pinned-action correction](c13-pinned-actions/README.md): independently source-reviewed, unrun; original failing assertion retained. +- [Actual A1/A2 partial producer and host](partial-stream-source-v1/README.md): written source and original tests, unapplied/uncompiled/unrun; combined review and UI receiver still pending. +- [Original19-body long-render fixture and synthetic HDR](original-long-scene/README.md): privacy-reviewed source subset, attributed; no native creation/render/quality result. + ## Current validation C12 is terminal: formatter/check, repository lists, strict affected Clippy, default-feature wasm and the combined engine/UI/Render native library-test build exited0. Six inventories also exited0. Selection stopped before any test body because two names used the wrong module prefix (`job::tests` instead of `job::runtime_request_roundtrip_tests`). **Zero test bodies and zero CPU markers ran; this is a preparation error, not a product failure or53 passes.** Independent closure verified the13 exited command roots/empty owned Jobs, source/config/toolchain, the actual three CargoJSON artifacts and physical lease cleanup. diff --git a/proposals/render/2026-10-30/c13-pinned-actions/README.md b/proposals/render/2026-10-30/c13-pinned-actions/README.md new file mode 100644 index 000000000..313c3d828 --- /dev/null +++ b/proposals/render/2026-10-30/c13-pinned-actions/README.md @@ -0,0 +1,7 @@ +# Narrow-card Pause fix - independently source-reviewed, not executed + +C13 stopped on the original real UI assertion: at760x700, Pause y380..408 exceeded the card's visible y327..381. The observed native test exited101; overall1case passed,1failed,51did not run. Keep that failure and the original test unchanged. + +This one-file source proposal keeps the real action row outside and before the scrollable status, and limits status to remaining inner height. Ready/disabled logic, labels, actual target rectangles and command dispatch stay unchanged. It does not move Nathan's selection toolbar, panels, Results, Studio or gizmos, hide a failed test, raise a minimum-window threshold or crop target rectangles to fake containment. In a card with no remaining height, status is omitted; actions take priority. + +Base render_workspace_interactive.rs SHA2562b385ccba4e94aaff6318f70a3669cd8205d786edad502e01e3c1e03f2e43579; candidatefdc1c1cfa2a97671bcbb94d3dae7d3502eb61e9b9d676011c96baa7bddc37970. Engineer and independent Designer source review found no blocker for this narrow change. The213-test source and all assertions remain intact. No formatting, compilation, test execution or new native button coordinates exist for the fix. A new exact-source serial validation remains required; C13 is never relabelled as passed. diff --git a/proposals/render/2026-10-30/c13-pinned-actions/proposal.patch b/proposals/render/2026-10-30/c13-pinned-actions/proposal.patch new file mode 100644 index 000000000..ecaefa505 --- /dev/null +++ b/proposals/render/2026-10-30/c13-pinned-actions/proposal.patch @@ -0,0 +1,92 @@ +diff --git a/crates/ui-egui/src/render_workspace_interactive.rs b/crates/ui-egui/src/render_workspace_interactive.rs +--- a/crates/ui-egui/src/render_workspace_interactive.rs ++++ b/crates/ui-egui/src/render_workspace_interactive.rs +@@ -520,13 +520,9 @@ + |ui| { + ui.set_width(width); + ui.set_max_width(width); ++ ui.set_max_height(height); + ui.set_clip_rect(ui.clip_rect().intersect(bounds)); +- egui::ScrollArea::vertical() +- .id_salt("sc_render_interactive_controls_scroll") +- .min_scrolled_height(0.0) +- .max_height(height) +- .auto_shrink([false, true]) +- .show(ui, |ui| controls(app, ui)); ++ controls(app, ui); + }, + ); + crate::shell::register_panel(app, "render:interactive-card", Some(card.response.rect.intersect(bounds)), None); +@@ -551,30 +547,7 @@ + let dimensions = state.frame.as_ref().map(|frame| (frame.info.width, frame.info.height)); + let stale = state.frame.as_ref().is_some_and(|frame| frame.stale); + let final_active = state.final_active; +- ui_kit::text(ui, &label, ui_kit::Text::Inline); +- if running { +- ui_kit::text(ui, app.tr("render.interactive_provisional"), ui_kit::Text::Note("render.interactive_provisional")); +- } +- if let Some(samples) = samples { +- let label = crate::i18n::format("render.interactive_samples", &[("done", &samples.to_string()), ("total", "16")]); +- ui_kit::text(ui, &label, ui_kit::Text::Inline); +- } +- if let Some((width, height)) = dimensions { +- ui_kit::text(ui, &format!("{width} × {height} px"), ui_kit::Text::Inline); +- } +- if stale { +- ui_kit::text(ui, app.tr("render.interactive_stale"), ui_kit::Text::Note("render.interactive_stale")); +- } +- if final_active { +- ui_kit::text(ui, app.tr("render.interactive_final_active"), ui_kit::Text::Note("render.interactive_final_active")); +- } +- if let Some(error) = error { +- ui_kit::text(ui, &error, ui_kit::Text::Error("render.interactive_error")); +- } + let reason = ready(app).err(); +- if let Some(reason) = &reason { +- ui_kit::text(ui, reason, ui_kit::Text::Note("render.interactive_requires_cpu")); +- } + let mut action = None; + ui.horizontal_wrapped(|ui| { + for (action_value, name, key, enabled) in if !running { +@@ -603,6 +576,41 @@ + app.set_status(error, true); + } + ui.ctx().request_repaint(); ++ } ++ // Actions remain outside the scroller. In a short free rectangle, status ++ // text may scroll but must not push Pause/Resume/Off below the visible clip. ++ let height = ui.available_height().max(0.0); ++ if height > 0.0 { ++ egui::ScrollArea::vertical() ++ .id_salt("sc_render_interactive_controls_scroll") ++ .min_scrolled_height(0.0) ++ .max_height(height) ++ .auto_shrink([false, true]) ++ .show(ui, |ui| { ++ ui_kit::text(ui, &label, ui_kit::Text::Inline); ++ if running { ++ ui_kit::text(ui, app.tr("render.interactive_provisional"), ui_kit::Text::Note("render.interactive_provisional")); ++ } ++ if let Some(samples) = samples { ++ let label = crate::i18n::format("render.interactive_samples", &[("done", &samples.to_string()), ("total", "16")]); ++ ui_kit::text(ui, &label, ui_kit::Text::Inline); ++ } ++ if let Some((width, height)) = dimensions { ++ ui_kit::text(ui, &format!("{width} × {height} px"), ui_kit::Text::Inline); ++ } ++ if stale { ++ ui_kit::text(ui, app.tr("render.interactive_stale"), ui_kit::Text::Note("render.interactive_stale")); ++ } ++ if final_active { ++ ui_kit::text(ui, app.tr("render.interactive_final_active"), ui_kit::Text::Note("render.interactive_final_active")); ++ } ++ if let Some(error) = error { ++ ui_kit::text(ui, &error, ui_kit::Text::Error("render.interactive_error")); ++ } ++ if let Some(reason) = &reason { ++ ui_kit::text(ui, reason, ui_kit::Text::Note("render.interactive_requires_cpu")); ++ } ++ }); + } + } + pub(super) fn command_ready(app: &SolveApp) -> Result<(), String> { diff --git a/proposals/render/2026-10-30/partial-stream-source-v1/README.md b/proposals/render/2026-10-30/partial-stream-source-v1/README.md new file mode 100644 index 000000000..c75e374c0 --- /dev/null +++ b/proposals/render/2026-10-30/partial-stream-source-v1/README.md @@ -0,0 +1,15 @@ +# Actual partial-film producer and host - source-only proposal + +Written source, not applied, formatted, compiled or run. The receiver/engine/UI consumer is still being composed privately and is NOT in this packet. This is not an enabled feature, native acceptance, physical GPU acceptance, FPS claim or full CPU/GPU parity. + +Apply dependencies only after review: the complete current nested-certified-glass V2 plus Engine rebind comes first (the adjacent cpu-nested-boxes-v2-source-review packet). Producer image.rs expects its private candidate37257990; host.rs expects6ecc923f, rather than the earlier production files. Then the producer-A1-A2.patch contains BOTH original A1 film access and A2 producer; do not additionally apply the separate earlier A1 patch. The host.patch binds the same interface. No application of this packet is authorized by this archive. + +The source implements actual film representatives with per-cell sample counts, Unknown alpha0 versus real sampled black/miss, one existing RGBA scratch/encoder and checked work prepayment. Host retains at most TWO total payload slots including in-flight encoding, coalesces demand, freezes producer progress through hashing and keeps buffers billed until their last owning Arc dies. Old whole-pass APIs remain separate. Static host review found no host-local lifetime/slot blocker; complete producer+host memory/work review is still pending. Actual Rust layout guards, allocation capacities and test assertions are UNEXECUTED. + +Producer includes5 original A1 and8 original producer declarations; host includes8 original appended declarations. Old test prefixes and numerical expectations are preserved. Tests distinguish original real CPU producer paths from explicitly synthetic lease fixtures. Neither written test bodies nor text patch reconstruction is an observed test pass. + +The checked W=12M+65538 optional snapshot debit uses the existing cumulative budget, with no reset or refund. Optional work can consume later trace headroom; this source does not promise unchanged historical work or unconditional completion at an exhausted work cap. A detailed-scene acceptance must measure presentation overhead and final completion honestly. + +Interactive receiver authority, stale-job rejection, native display/Unknown UX and manual-final progressive display remain separate requirements. Progressive glass remains explicitly unsupported in this source; nested V2 glass only covers its certified fixed-final opt-in domain. General glass, material-library routing, indirect transport and finishing/export parity are not certified here. + +Tracked in https://github.com/tangency-labs/solidcraft/issues/6201 diff --git a/proposals/render/2026-10-30/partial-stream-source-v1/host.patch b/proposals/render/2026-10-30/partial-stream-source-v1/host.patch new file mode 100644 index 000000000..5463849c2 --- /dev/null +++ b/proposals/render/2026-10-30/partial-stream-source-v1/host.patch @@ -0,0 +1,978 @@ +--- a/crates/render/src/job/mod.rs ++++ b/crates/render/src/job/mod.rs +@@ -44,7 +44,7 @@ + pub(crate) use host::Reservation; + pub use host::{ + CpuHost, HostKind, ImageHost, JobEnvironmentInfo, JobHandle, JobStatus, LinearAlphaConvention, LinearColourEncoding, LinearMasterInfo, +- PreviewInfo, RenderFrame, RenderPreview, ++ PartialPreviewInfo, PartialPreviewProjection, PreviewInfo, RenderFrame, RenderPartialPreview, RenderPreview, + }; + pub use image::{Admission, ImageTask, TaskPoll, admit, admit_geometry, admit_geometry_with_limits}; + pub use lens::ThinLens; +@@ -1282,3 +1282,73 @@ + } + } + } ++ ++/// Fixed representative presentation plan; fitting never grants source admission. ++#[derive(Clone, Copy, Debug, PartialEq, Eq)] ++pub struct PartialPreviewPlan { ++ source_width: u32, ++ source_height: u32, ++ width: u32, ++ height: u32, ++} ++impl PartialPreviewPlan { ++ pub fn source_width(&self) -> u32 { self.source_width } ++ pub fn source_height(&self) -> u32 { self.source_height } ++ pub fn width(&self) -> u32 { self.width } ++ pub fn height(&self) -> u32 { self.height } ++ pub fn new(source_width: u32, source_height: u32) -> Result { ++ if source_width == 0 || source_height == 0 { ++ return Err(JobError::new(ErrorCode::InvalidRequest, "partial preview source dimensions must be positive")); ++ } ++ let edge = source_width.max(source_height); ++ let fit = |side: u32| { ++ if edge <= 1024 { side } else { ((u64::from(side) * 1024 + u64::from(edge) / 2) / u64::from(edge)).max(1) as u32 } ++ }; ++ Ok(Self { source_width, source_height, width: fit(source_width), height: fit(source_height) }) ++ } ++ pub fn validate(&self) -> Result<()> { ++ if *self != Self::new(self.source_width, self.source_height)? { ++ return Err(JobError::new(ErrorCode::InvalidRequest, "partial preview dimensions differ from the fixed plan")); ++ } ++ Ok(()) ++ } ++ pub fn pixels(&self) -> u64 { ++ u64::from(self.width) * u64::from(self.height) ++ } ++ pub fn source_index(&self, preview_index: usize) -> Result { ++ self.validate()?; ++ let index = u64::try_from(preview_index).map_err(|_| JobError::new(ErrorCode::LimitExceeded, "partial preview index overflow"))?; ++ if index >= self.pixels() { ++ return Err(JobError::new(ErrorCode::InvalidRequest, "partial preview index outside its plan")); ++ } ++ let x = (index % u64::from(self.width)) * u64::from(self.source_width) / u64::from(self.width); ++ let y = (index / u64::from(self.width)) * u64::from(self.source_height) / u64::from(self.height); ++ let source = y.checked_mul(u64::from(self.source_width)).and_then(|v| v.checked_add(x)) ++ .ok_or_else(|| JobError::new(ErrorCode::LimitExceeded, "partial source index overflow"))?; ++ usize::try_from(source).map_err(|_| JobError::new(ErrorCode::LimitExceeded, "partial source index exceeds address space")) ++ } ++ pub fn encoded_limit(&self) -> Result { ++ self.validate()?; ++ self.pixels().checked_mul(8).and_then(|v| v.checked_add(65_536)) ++ .ok_or_else(|| JobError::new(ErrorCode::LimitExceeded, "partial PNG capacity overflow")) ++ } ++ pub fn covered_bytes(&self) -> Result { ++ self.validate()?; ++ self.pixels().checked_mul(2).ok_or_else(|| JobError::new(ErrorCode::LimitExceeded, "partial coverage capacity overflow")) ++ } ++ pub fn snapshot_work(&self) -> Result { ++ self.validate()?; ++ self.pixels().checked_mul(12).and_then(|v| v.checked_add(65_538)) ++ .ok_or_else(|| JobError::new(ErrorCode::LimitExceeded, "partial work bound overflow")) ++ } ++ /// Two retained payload slots; existing admitted RGBA/encoder scratch is reused. ++ #[cfg(feature = "raytrace-cpu")] ++ pub(crate) fn additional_bytes(&self) -> Result { ++ self.slot_bytes()?.checked_mul(2).and_then(|v| v.checked_add(1024)) ++ .ok_or_else(|| JobError::new(ErrorCode::LimitExceeded, "partial preview admission overflow")) ++ } ++ pub(crate) fn slot_bytes(&self) -> Result { ++ self.encoded_limit()?.checked_add(self.covered_bytes()?).and_then(|v| v.checked_add(2048)) ++ .ok_or_else(|| JobError::new(ErrorCode::LimitExceeded, "partial retained slot overflow")) ++ } ++} +--- a/crates/render/src/job/host.rs ++++ b/crates/render/src/job/host.rs +@@ -107,6 +107,17 @@ + } + } + impl Reservation { ++ /// Merge unique portions of one admission without a second pool debit. ++ fn merge_from(&mut self, donor: &mut Self) -> Result<()> { ++ if !Arc::ptr_eq(&self.budget, &donor.budget) { ++ return Err(JobError::new(ErrorCode::WrongOwner, "cannot merge different image admission pools")); ++ } ++ let bytes = self.bytes.checked_add(donor.bytes).filter(|v| *v <= self.budget.limit) ++ .ok_or_else(|| JobError::new(ErrorCode::LimitExceeded, "image reservation merge overflow"))?; ++ self.bytes = bytes; ++ donor.bytes = 0; ++ Ok(()) ++ } + /// Transfer an already admitted portion without changing the pool's total. + /// CPU progressive admission includes every possible checkpoint up front. + fn split(&mut self, bytes: u64) -> Result { +@@ -362,6 +373,7 @@ + } + + struct Data { ++ partial_preview: Option>, + punctual_diagnostics: Option, + sampling: Option, + progress: Progress, +@@ -370,6 +382,7 @@ + preview: Option>, + } + struct Record { ++ partial: Option>, + presentation: Option>, + textures: Option, + options: JobOptions, +@@ -425,14 +438,18 @@ + }) + } + pub fn cancel(&self) -> Result { ++ if let Some(credits) = &self.0.partial { credits.close(); } ++ let mut released_partial = None; + { + let mut data = self.0.data.lock().map_err(|_| JobError::new(ErrorCode::Internal, "render status lock poisoned"))?; + if !data.progress.phase.terminal() { + self.0.cancel.cancel(); ++ released_partial = data.partial_preview.take(); + data.preview = None; + data.progress.phase = if data.progress.phase == Phase::Queued { Phase::Cancelled } else { Phase::Cancelling }; + } + } ++ drop(released_partial); + self.0.notify(); + self.status() + } +@@ -472,6 +489,14 @@ + } + } + ++struct Submission { ++ id: JobId, ++ scene_generation: u64, ++ scene: ProductScene, ++ request: ImageRequest, ++ options: JobOptions, ++ environment: Option, ++} + struct Work { + regrade: Option<(Arc, super::presentation::Presentation)>, + request: Option, +@@ -551,6 +576,8 @@ + handle: JobHandle, + reservation: Option, + next_preview_sequence: u32, ++ // Task/PNG allocations above die before the in-flight credit below. ++ partial: Option>, + } + + /// One fallibly allocated task, keeping the dispatch enum small in either build. +@@ -582,6 +609,8 @@ + } + + enum WorkPoll { ++ #[cfg(feature = "raytrace-cpu")] ++ Partial { png: Vec, covered: Vec, completed_passes: u32, updated_prefix: u64 }, + Existing(TaskPoll), + #[cfg(feature = "raytrace-cpu")] + Preview { +@@ -591,6 +620,37 @@ + } + + impl WorkTask { ++ fn partial_ready(&mut self, plan: super::PartialPreviewPlan) -> Result { ++ let _ = &plan; ++ match self { ++ #[cfg(feature = "raytrace-cpu")] ++ Self::Raytrace(task) => task.get_mut()?.partial_preview_ready(plan), ++ _ => Ok(false), ++ } ++ } ++ fn begin_partial(&mut self, plan: super::PartialPreviewPlan) -> Result { ++ let _ = &plan; ++ match self { ++ #[cfg(feature = "raytrace-cpu")] ++ Self::Raytrace(task) => match task.get_mut()?.begin_partial_preview(plan)? { ++ crate::raytrace::image::PartialBegin::Started => Ok(true), ++ crate::raytrace::image::PartialBegin::Exhausted => Ok(false), ++ }, ++ _ => Err(JobError::new(ErrorCode::InvalidRequest, "partial presentation requires the builtin CPU task")), ++ } ++ } ++ fn step_partial(&mut self, units: usize) -> Result { ++ let _ = &units; ++ match self { ++ #[cfg(feature = "raytrace-cpu")] ++ Self::Raytrace(task) => Ok(match task.get_mut()?.step_with_partial_previews(units)? { ++ crate::raytrace::image::PartialImagePoll::Pending(progress) => WorkPoll::Existing(TaskPoll::Pending(progress)), ++ crate::raytrace::image::PartialImagePoll::Complete(png) => WorkPoll::Existing(TaskPoll::Complete(png)), ++ crate::raytrace::image::PartialImagePoll::Preview { png, covered, completed_passes, updated_prefix } => WorkPoll::Partial { png, covered, completed_passes, updated_prefix }, ++ }), ++ _ => Err(JobError::new(ErrorCode::InvalidRequest, "partial presentation requires the builtin CPU task")), ++ } ++ } + fn punctual_diagnostics(&self) -> Option { + match self { + #[cfg(feature = "raytrace-cpu")] +@@ -625,15 +685,21 @@ + cancel: CancelToken, + environment: Option, + job_options: JobOptions, ++ partial: Option, + ) -> Result { +- let _ = (&environment, &job_options); ++ let _ = (&environment, &job_options, &partial); + match request.integrator { + Integrator::Raster => ImageTask::new(scene, request, cancel).and_then(TaskSlot::new).map(Self::Raster), + Integrator::Raytrace => { + #[cfg(feature = "raytrace-cpu")] + { + let options = request.raytrace.clone().unwrap_or_default(); +- crate::raytrace::image::ImageTask::new_with_environment_and_nested(scene, request, cancel, options, environment, job_options.nested_media) ++ let task = if let Some(plan) = partial { ++ crate::raytrace::image::ImageTask::new_with_environment_and_nested_and_partial(scene, request, cancel, options, environment, job_options.nested_media, plan) ++ } else { ++ crate::raytrace::image::ImageTask::new_with_environment_and_nested(scene, request, cancel, options, environment, job_options.nested_media) ++ }; ++ task + .and_then(TaskSlot::new) + .map(Self::Raytrace) + } +@@ -661,6 +727,8 @@ + } + + fn terminal(handle: &JobHandle, error: JobError) { ++ if let Some(credits) = &handle.0.partial { credits.close(); } ++ let mut released_partial = None; + if let Ok(mut data) = handle.0.data.lock() { + if data.progress.phase == Phase::Completed { + return; +@@ -674,7 +742,9 @@ + } + data.frame = None; + data.preview = None; ++ released_partial = data.partial_preview.take(); + } ++ drop(released_partial); + handle.0.notify(); + } + +@@ -702,12 +772,16 @@ + work.handle.0.cancel.clone(), + work.environment, + work.handle.0.options, ++ work.handle.0.partial.as_ref().map(|credits| credits.plan), + ) + } + })) + .unwrap_or_else(|_| Err(JobError::new(ErrorCode::Internal, "image executor failed while preparing the job"))); ++ let partial = work.handle.0.partial.as_ref().map(|credits| TaskSlot::new(PartialRunning::new(credits.clone()))).transpose(); ++ let task = task.and_then(|task| partial.map(|partial| (task, partial))); + match task { +- Ok(task) => Some(Self { ++ Ok((task, partial)) => Some(Self { ++ partial, + source_master: None, + task: Some(task), + pending_png: None, +@@ -727,7 +801,22 @@ + if self.pending_png.is_some() { + return self.advance_png(units); + } +- let result = self.task.as_mut().ok_or_else(|| JobError::new(ErrorCode::Internal, "missing render task"))?.step(units)?; ++ if let Some(partial) = self.partial.as_mut() { ++ let partial = partial.get_mut()?; ++ if partial.lease.is_none() && partial.credits.requested.load(Ordering::Acquire) && !partial.credits.exhausted.load(Ordering::Acquire) { ++ let task = self.task.as_mut().ok_or_else(|| JobError::new(ErrorCode::Internal, "missing partial CPU task"))?; ++ if task.partial_ready(partial.credits.plan)? && let Some(lease) = partial.credits.acquire()? { ++ // Keep the lease past any producer error until task buffers drop. ++ partial.lease = Some(lease); ++ if !task.begin_partial(partial.credits.plan)? { ++ partial.credits.exhaust(); ++ drop(partial.lease.take()); ++ } ++ } ++ } ++ } ++ let task = self.task.as_mut().ok_or_else(|| JobError::new(ErrorCode::Internal, "missing render task"))?; ++ let result = if self.partial.is_some() { task.step_partial(units)? } else { task.step(units)? }; + let mut data = self.handle.0.data.lock().map_err(|_| JobError::new(ErrorCode::Internal, "render status lock poisoned"))?; + data.punctual_diagnostics = self.task.as_ref().and_then(WorkTask::punctual_diagnostics); + // The final publication check is under the same lock as cancellation. +@@ -735,10 +824,20 @@ + data.progress.phase = Phase::Cancelled; + data.frame = None; + data.preview = None; ++ let released = data.partial_preview.take(); ++ drop(data); ++ if let Some(credits) = &self.handle.0.partial { credits.close(); } ++ drop(released); + self.handle.0.notify(); + return Ok(false); + } + match result { ++ #[cfg(feature = "raytrace-cpu")] ++ WorkPoll::Partial { png, covered, completed_passes, updated_prefix } => { ++ drop(data); ++ self.capture_partial(png, covered, completed_passes, updated_prefix)?; ++ Ok(true) ++ } + WorkPoll::Existing(TaskPoll::Pending(progress)) => { + data.progress = progress; + Ok(true) +@@ -789,6 +888,9 @@ + } + let PendingPng { png, digest, preview_samples, exr, exr_digest, .. } = + self.pending_png.take().ok_or_else(|| JobError::new(ErrorCode::Internal, "missing completed PNG digest"))?; ++ if self.partial.as_ref().and_then(|slot| slot.0.first()).is_some_and(|partial| partial.pending.is_some()) { ++ return self.publish_partial(png, digest); ++ } + let info = FrameInfo { + job: self.handle.0.id, + scene_generation: self.handle.0.scene_generation, +@@ -872,7 +974,11 @@ + _reservation: reservation, + })); + data.preview = None; ++ let released = data.partial_preview.take(); + data.progress = Progress { phase: Phase::Completed, done: 1, total: 1 }; ++ drop(data); ++ if let Some(credits) = &self.handle.0.partial { credits.close(); } ++ drop(released); + self.handle.0.notify(); + Ok(false) + } +@@ -880,6 +986,7 @@ + fn guarded_step(&mut self, units: usize) -> bool { + let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| self.advance(units))); + match result { ++ + Ok(Ok(more)) => more, + Ok(Err(e)) => { + terminal(&self.handle, e); +@@ -1064,6 +1171,17 @@ + } + + pub fn admit(&self, scene: &ProductScene, request: &ImageRequest, options: JobOptions) -> Result { ++ self.admit_with_policy(scene, request, options, None) ++ } ++ fn admit_with_policy(&self, scene: &ProductScene, request: &ImageRequest, options: JobOptions, partial: Option) -> Result { ++ if let Some(plan) = partial { ++ if self.0.executor.is_some() || request.integrator != Integrator::Raytrace || request.transparent_background ++ || request.environment.is_some() || request.textures.is_some() ++ || request.raytrace.as_ref().and_then(|v| v.progressive).is_none() ++ || plan != super::PartialPreviewPlan::new(request.width, request.height)? { ++ return Err(JobError::new(ErrorCode::InvalidRequest, "partial previews require the canonical builtin CPU progressive request")); ++ } ++ } + let scatter = |t: Option| t.and_then(|v| v.subsurface()).is_some_and(|s| s.active()); + if scene.meshes.iter().any(|b| scatter(b.transmission) || b.faces.iter().any(|f| scatter(f.transmission))) + && !self.0.executor.as_ref().is_some_and(|executor| executor.supports_subsurface()) +@@ -1116,6 +1234,18 @@ + if (JobOptions { nested_media: false, ..options }) != JobOptions::default() { + return Err(JobError::new(ErrorCode::InvalidRequest, "CPU images use raytrace options, not progressive sampling controls")); + } ++ if let Some(plan) = partial { ++ #[cfg(feature = "raytrace-cpu")] ++ { ++ let raytrace = request.raytrace.as_ref().ok_or_else(|| JobError::new(ErrorCode::InvalidRequest, "partial previews require CPU progressive options"))?; ++ return crate::raytrace::image::admit_with_partial_preview(scene, request, raytrace, options.nested_media, plan); ++ } ++ #[cfg(not(feature = "raytrace-cpu"))] ++ { ++ let _ = plan; ++ return Err(JobError::new(ErrorCode::HostUnavailable, "CPU raytracing is not compiled in; enable raytrace-cpu")); ++ } ++ } + if !options.nested_media { + return admit(scene, request); + } +@@ -1258,14 +1388,21 @@ + } + + pub fn submit_with_environment_and_options( +- &self, +- id: JobId, +- scene_generation: u64, +- scene: ProductScene, +- request: ImageRequest, +- options: JobOptions, ++ &self, id: JobId, scene_generation: u64, scene: ProductScene, request: ImageRequest, options: JobOptions, + environment: Option, + ) -> Result { ++ self.submit_with_policy(Submission { id, scene_generation, scene, request, options, environment }, None) ++ } ++ /// Transient CPU presentation policy. Final request and legacy observers are unchanged. ++ pub fn submit_cpu_partial_with_environment_and_options( ++ &self, id: JobId, scene_generation: u64, scene: ProductScene, request: ImageRequest, options: JobOptions, ++ environment: Option, ++ ) -> Result { ++ let plan = super::PartialPreviewPlan::new(request.width, request.height)?; ++ self.submit_with_policy(Submission { id, scene_generation, scene, request, options, environment }, Some(plan)) ++ } ++ fn submit_with_policy(&self, input: Submission, partial_plan: Option) -> Result { ++ let Submission { id, scene_generation, scene, request, options, environment } = input; + if self.0.executor.is_some() && environment.is_some() { + return Err(JobError::new(ErrorCode::InvalidRequest, "registered image executors do not accept CPU environments")); + } +@@ -1300,7 +1437,7 @@ + { + features.push(crate::RenderFeature::Refraction); + } +- let Admission { estimated_total_bytes, .. } = self.admit(&scene, &request, options)?; ++ let Admission { estimated_total_bytes, .. } = self.admit_with_policy(&scene, &request, options, partial_plan)?; + let environment_bytes = + environment.as_ref().map_or(Ok(0), |e| e.required_bytes()).map_err(|e| JobError::new(ErrorCode::InvalidRequest, e.to_string()))?; + let estimated_total_bytes = estimated_total_bytes +@@ -1337,8 +1474,9 @@ + return Err(JobError::new(ErrorCode::QueueFull, "image queue is full")); + } + self.check_request_sum(estimated_total_bytes, request_bytes, request.cpu_budget())?; +- let reservation = self.0.shared.budget.reserve(estimated_total_bytes)?; ++ let mut reservation = self.0.shared.budget.reserve(estimated_total_bytes)?; + let request_reservation = if request_bytes == 0 { None } else { Some(self.0.shared.budget.reserve(request_bytes)?) }; ++ let partial_credits = partial_plan.map(|plan| PartialCredits::new(plan, &mut reservation)).transpose()?; + // Preserve the original CPU option capacities in the retained request and its lease. + // Registered executors instead move resource Arcs into work and keep a small public copy. + let (public_request, work_request) = if self.0.executor.is_some() { +@@ -1347,6 +1485,7 @@ + (request, None) + }; + let handle = JobHandle(Arc::new(Record { ++ partial: partial_credits, + presentation: None, + textures, + options, +@@ -1358,6 +1497,7 @@ + resolved, + cancel: CancelToken::default(), + data: Mutex::new(Data { ++ partial_preview: None, + punctual_diagnostics: None, + sampling: None, + progress: Progress { phase: Phase::Queued, done: 0, total: 1 }, +@@ -1464,6 +1604,7 @@ + let metadata = self.0.shared.budget.reserve(metadata_bytes)?; + let origin = Arc::new(RetainedPresentation { info: origin, _reservation: metadata }); + let handle = JobHandle(Arc::new(Record { ++ partial: None, + presentation: Some(origin), + textures: None, + options, +@@ -1475,6 +1616,7 @@ + resolved, + cancel: CancelToken::default(), + data: Mutex::new(Data { ++ partial_preview: None, + punctual_diagnostics: None, + sampling: None, + progress: Progress { phase: Phase::Queued, done: 0, total: 1 }, +@@ -1858,3 +2000,236 @@ + JobId { session: owner, serial, generation: serial } + } + } ++ ++/// Provisional source-film observation, separate from complete-pass previews. ++#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize)] ++#[serde(rename_all = "snake_case")] ++pub enum PartialPreviewProjection { TopLeftRepresentativeV1 } ++#[derive(Clone, Debug, Serialize)] ++pub struct PartialPreviewInfo { ++ pub frame: FrameInfo, ++ pub sequence: u64, ++ pub source_width: u32, ++ pub source_height: u32, ++ pub completed_passes: u32, ++ pub updated_prefix: u64, ++ pub projection: PartialPreviewProjection, ++} ++/// Fields drop in declaration order: payload allocations die before credit return. ++pub struct RenderPartialPreview { ++ pub info: PartialPreviewInfo, ++ png: Vec, ++ covered: Vec, ++ _lease: ReturnReservation, ++} ++const _: [(); 1] = [(); (std::mem::size_of::() + 2 * crate::MAX_RENDER_ID_BYTES + 256 <= 2048) as usize]; ++impl RenderPartialPreview { ++ pub fn png(&self) -> &[u8] { &self.png } ++ pub fn covered(&self) -> &[u16] { &self.covered } ++} ++struct PartialCreditState { ++ free: Reservation, ++ in_flight: bool, ++ closed: bool, ++} ++struct PartialCredits { ++ plan: super::PartialPreviewPlan, ++ state: Mutex, ++ requested: AtomicBool, ++ exhausted: AtomicBool, ++ _metadata: Reservation, ++} ++const _: [(); 1] = [(); (std::mem::size_of::() + std::mem::size_of::() + std::mem::size_of::>() + 128 <= 1024) as usize]; ++impl PartialCredits { ++ fn new(plan: super::PartialPreviewPlan, reservation: &mut Reservation) -> Result> { ++ plan.validate()?; ++ let metadata = reservation.split(1024)?; ++ let bytes = plan.slot_bytes()?.checked_mul(2).ok_or_else(|| JobError::new(ErrorCode::LimitExceeded, "partial credit overflow"))?; ++ let free = reservation.split(bytes)?; ++ Ok(Arc::new(Self { ++ plan, ++ state: Mutex::new(PartialCreditState { free, in_flight: false, closed: false }), ++ requested: AtomicBool::new(false), ++ exhausted: AtomicBool::new(false), ++ _metadata: metadata, ++ })) ++ } ++ fn request(&self) -> Result { ++ let state = self.state.lock().map_err(|_| JobError::new(ErrorCode::Internal, "partial credit lock poisoned"))?; ++ if state.closed || self.exhausted.load(Ordering::Acquire) { return Ok(false); } ++ self.requested.store(true, Ordering::Release); ++ Ok(true) ++ } ++ fn acquire(self: &Arc) -> Result> { ++ let mut state = self.state.lock().map_err(|_| JobError::new(ErrorCode::Internal, "partial credit lock poisoned"))?; ++ let bytes = self.plan.slot_bytes()?; ++ if state.closed || state.in_flight || self.exhausted.load(Ordering::Acquire) ++ || !self.requested.load(Ordering::Acquire) || state.free.bytes < bytes { return Ok(None); } ++ let reservation = state.free.split(bytes)?; ++ state.in_flight = true; ++ self.requested.store(false, Ordering::Release); ++ Ok(Some(ReturnReservation { reservation: Some(reservation), credits: self.clone(), in_flight: true })) ++ } ++ fn exhaust(&self) { ++ self.exhausted.store(true, Ordering::Release); ++ self.requested.store(false, Ordering::Release); ++ } ++ fn close(&self) { ++ let mut state = match self.state.lock() { Ok(state) => state, Err(error) => error.into_inner() }; ++ state.closed = true; ++ state.in_flight = false; ++ self.requested.store(false, Ordering::Release); ++ // Atomic release only: no image destruction or user work under this lock. ++ let _ = state.free.shrink(0); ++ } ++} ++/// Unique lease; Arc payload clones never create another independent slot. ++struct ReturnReservation { ++ reservation: Option, ++ credits: Arc, ++ in_flight: bool, ++} ++impl ReturnReservation { ++ fn published(&mut self) -> Result<()> { ++ let mut state = self.credits.state.lock().map_err(|_| JobError::new(ErrorCode::Internal, "partial credit lock poisoned"))?; ++ if state.closed || !state.in_flight || !self.in_flight { ++ return Err(JobError::new(ErrorCode::Cancelled, "partial preview credit is no longer current")); ++ } ++ state.in_flight = false; ++ self.in_flight = false; ++ Ok(()) ++ } ++} ++impl Drop for ReturnReservation { ++ fn drop(&mut self) { ++ let Some(mut reservation) = self.reservation.take() else { return }; ++ let mut state = match self.credits.state.lock() { ++ Ok(state) => state, ++ Err(error) => { ++ let mut state = error.into_inner(); ++ state.closed = true; ++ let _ = state.free.shrink(0); ++ state ++ } ++ }; ++ if self.in_flight { state.in_flight = false; } ++ if !state.closed { ++ let limit = self.credits.plan.slot_bytes().ok().and_then(|v| v.checked_mul(2)); ++ if state.free.bytes.checked_add(reservation.bytes).zip(limit).is_some_and(|(total, limit)| total <= limit) { ++ if state.free.merge_from(&mut reservation).is_err() { state.closed = true; let _ = state.free.shrink(0); } ++ } else { state.closed = true; let _ = state.free.shrink(0); } ++ } ++ drop(state); ++ // A closed sink releases this uniquely held reservation globally. ++ } ++} ++struct PartialPending { ++ covered: Vec, ++ completed_passes: u32, ++ updated_prefix: u64, ++} ++// Error paths preserve the same payload-before-lease destruction order. ++struct PartialPublication { ++ png: Vec, ++ pending: PartialPending, ++ lease: ReturnReservation, ++} ++struct PartialRunning { ++ pending: Option, ++ lease: Option, ++ credits: Arc, ++ next_sequence: u64, ++} ++impl PartialRunning { ++ fn new(credits: Arc) -> Self { Self { pending: None, lease: None, credits, next_sequence: 1 } } ++} ++impl JobHandle { ++ /// Request presentation only; this is not a visual-authority certificate. ++ pub fn request_partial_preview(&self) -> Result { ++ let terminal = self.0.data.lock().map_err(|_| JobError::new(ErrorCode::Internal, "render status lock poisoned"))?.progress.phase.terminal(); ++ if terminal { return Ok(false); } ++ self.0.partial.as_ref().map_or(Ok(false), |credits| credits.request()) ++ } ++ pub fn partial_preview_exhausted(&self) -> Result { ++ Ok(self.0.partial.as_ref().is_some_and(|credits| credits.exhausted.load(Ordering::Acquire))) ++ } ++ pub fn partial_preview(&self) -> Result>> { ++ let data = self.0.data.lock().map_err(|_| JobError::new(ErrorCode::Internal, "render partial preview lock poisoned"))?; ++ let preview = data.partial_preview.clone(); ++ if preview.as_ref().is_some_and(|p| p.info.frame.job != self.0.id || p.info.frame.scene_generation != self.0.scene_generation) { ++ return Err(JobError::new(ErrorCode::WrongOwner, "partial preview identity does not match its job")); ++ } ++ Ok(preview) ++ } ++} ++impl Running { ++ #[cfg(feature = "raytrace-cpu")] ++ fn capture_partial(&mut self, png: Vec, covered: Vec, completed_passes: u32, updated_prefix: u64) -> Result<()> { ++ self.handle.0.cancel.check()?; ++ let partial = self.partial.as_mut().ok_or_else(|| JobError::new(ErrorCode::Internal, "partial output without its policy"))?.get_mut()?; ++ let plan = partial.credits.plan; ++ let source_pixels = u64::from(plan.source_width()) * u64::from(plan.source_height()); ++ let target = self.handle.0.request.raytrace.as_ref().and_then(|v| v.progressive) ++ .ok_or_else(|| JobError::new(ErrorCode::Internal, "partial output without progressive intent"))?.samples_per_pixel; ++ let covered_limit = plan.covered_bytes()?; ++ if partial.lease.is_none() || partial.pending.is_some() || completed_passes >= target || updated_prefix >= source_pixels ++ || (completed_passes == 0 && updated_prefix == 0) || covered.len() as u64 != plan.pixels() ++ || (covered.capacity() as u64).checked_mul(2).is_none_or(|v| v > covered_limit) ++ || png.capacity() as u64 > plan.encoded_limit()? { ++ return Err(JobError::new(ErrorCode::LimitExceeded, "partial payload exceeds its admitted frontier or capacities")); ++ } ++ // This sole sidecar verification scan was included in the producer's precharge. ++ for (index, count) in covered.iter().enumerate() { ++ self.handle.0.cancel.check()?; ++ let source = plan.source_index(index)? as u64; ++ let samples = completed_passes.checked_add(u32::from(source < updated_prefix)) ++ .ok_or_else(|| JobError::new(ErrorCode::LimitExceeded, "partial sample count overflow"))?; ++ if u32::from(*count) > samples { ++ return Err(JobError::new(ErrorCode::Internal, "partial coverage exceeds committed source samples")); ++ } ++ } ++ partial.pending = Some(PartialPending { covered, completed_passes, updated_prefix }); ++ self.pending_png = Some(PendingPng::new(png)); ++ Ok(()) ++ } ++ fn publish_partial(&mut self, png: Vec, digest: Sha256) -> Result { ++ self.handle.0.cancel.check()?; ++ let partial = self.partial.as_mut().ok_or_else(|| JobError::new(ErrorCode::Internal, "missing partial publication state"))?.get_mut()?; ++ let pending = partial.pending.take().ok_or_else(|| JobError::new(ErrorCode::Internal, "missing partial metadata"))?; ++ let lease = partial.lease.take().ok_or_else(|| JobError::new(ErrorCode::Internal, "missing partial publication credit"))?; ++ let mut publication = PartialPublication { png, pending, lease }; ++ let sequence = partial.next_sequence; ++ let next = sequence.checked_add(1).ok_or_else(|| JobError::new(ErrorCode::LimitExceeded, "partial preview sequence exhausted"))?; ++ let plan = partial.credits.plan; ++ let info = FrameInfo { ++ job: self.handle.0.id, scene_generation: self.handle.0.scene_generation, ++ backend: self.handle.0.resolved.backend.clone(), executor: self.handle.0.resolved.executor.clone(), ++ width: plan.width(), height: plan.height(), encoding: ColourEncoding::Srgb, alpha: AlphaConvention::Straight, ++ png_bytes: publication.png.len() as u64, png_sha256: format!("{:x}", digest.finalize()), ++ }; ++ let metadata = std::mem::size_of::().checked_add(64 + 2 * crate::MAX_RENDER_ID_BYTES) ++ .and_then(|v| v.checked_add(info.png_sha256.capacity())); ++ if metadata.is_none_or(|v| v > 2048) { return Err(JobError::new(ErrorCode::LimitExceeded, "partial payload metadata exceeds its slot")); } ++ // No Data lock while touching the credit coordinator. ++ publication.lease.published()?; ++ let PartialPublication { png, pending, lease } = publication; ++ let preview = Arc::new(RenderPartialPreview { ++ info: PartialPreviewInfo { frame: info, sequence, source_width: plan.source_width(), source_height: plan.source_height(), ++ completed_passes: pending.completed_passes, updated_prefix: pending.updated_prefix, projection: PartialPreviewProjection::TopLeftRepresentativeV1 }, ++ png, covered: pending.covered, _lease: lease, ++ }); ++ let mut data = self.handle.0.data.lock().map_err(|_| JobError::new(ErrorCode::Internal, "render partial publication lock poisoned"))?; ++ if self.handle.0.cancel.is_cancelled() || data.progress.phase.terminal() { ++ drop(data); ++ drop(preview); ++ return Err(JobError::new(ErrorCode::Cancelled, "late partial preview refused")); ++ } ++ let released = data.partial_preview.replace(preview); ++ partial.next_sequence = next; ++ // A demand arriving during encoding remains pending; never clear it here. ++ drop(data); ++ drop(released); ++ self.handle.0.notify(); ++ Ok(true) ++ } ++} +--- a/crates/render/src/job/host_tests.rs ++++ b/crates/render/src/job/host_tests.rs +@@ -1228,3 +1228,274 @@ + drop(lease); + assert_eq!(host.admitted_bytes(), 0); + } ++ ++mod partial_preview_contract { ++ use super::*; ++ use crate::job::PartialPreviewPlan; ++ ++ fn credits() -> (Arc, Reservation, Arc) { ++ let plan = PartialPreviewPlan::new(4, 1).unwrap(); ++ let total = 2 * plan.slot_bytes().unwrap() + 1024 + 17; ++ let budget = Arc::new(Budget { used: AtomicU64::new(0), limit: total }); ++ let mut work = budget.reserve(total).unwrap(); ++ let credits = PartialCredits::new(plan, &mut work).unwrap(); ++ assert_eq!(work.bytes, 17); ++ (budget, work, credits) ++ } ++ fn take(credits: &Arc) -> ReturnReservation { ++ assert!(credits.request().unwrap()); ++ credits.acquire().unwrap().unwrap() ++ } ++ fn payload(mut lease: ReturnReservation, sequence: u64) -> Arc { ++ lease.published().unwrap(); ++ Arc::new(RenderPartialPreview { ++ info: PartialPreviewInfo { ++ frame: FrameInfo { job: id(7724, 1), scene_generation: 19, backend: crate::builtin_backend().id, ++ executor: ExecutorId::new("cpu-raytrace").unwrap(), width: 4, height: 1, ++ encoding: ColourEncoding::Srgb, alpha: AlphaConvention::Straight, png_bytes: 4, png_sha256: "unit-lease-fixture".into() }, ++ sequence, source_width: 4, source_height: 1, completed_passes: 0, updated_prefix: 1, ++ projection: PartialPreviewProjection::TopLeftRepresentativeV1, ++ }, ++ png: vec![1, 2, 3, 4], covered: vec![1, 0, 0, 0], _lease: lease, ++ }) ++ } ++ #[test] ++ fn plan_is_canonical_no_upscale_and_maps_top_left_without_source_scan() { ++ for (w, h, expected) in [(16384, 4096, (1024, 256)), (2160, 3840, (576, 1024)), (4, 1, (4, 1)), (u32::MAX, 1, (1024, 1))] { ++ let plan = PartialPreviewPlan::new(w, h).unwrap(); ++ assert_eq!((plan.width(), plan.height()), expected); ++ assert_eq!((plan.source_width(), plan.source_height()), (w, h)); ++ assert_eq!(plan.source_index(0).unwrap(), 0); ++ assert!(plan.source_index(plan.pixels() as usize).is_err()); ++ assert!(plan.pixels() <= 1024 * 1024); ++ } ++ let plan = PartialPreviewPlan::new(16384, 4096).unwrap(); ++ assert_eq!(plan.source_index(1025).unwrap(), 16 * 16384 + 16); ++ assert_eq!(plan.snapshot_work().unwrap(), 12 * 1024 * 256 + 65538); ++ assert!(PartialPreviewPlan::new(0, 1).is_err()); ++ assert!(PartialPreviewPlan::new(1, 0).is_err()); ++ } ++ #[test] ++ fn same_budget_merge_moves_ownership_once_and_wrong_pool_preserves_both() { ++ let a = Arc::new(Budget { used: AtomicU64::new(0), limit: 100 }); ++ let b = Arc::new(Budget { used: AtomicU64::new(0), limit: 100 }); ++ let mut retained = a.reserve(80).unwrap(); ++ let mut donor = retained.split(30).unwrap(); ++ let mut foreign = b.reserve(9).unwrap(); ++ assert_eq!(retained.merge_from(&mut foreign).unwrap_err().code, ErrorCode::WrongOwner); ++ assert_eq!((retained.bytes, foreign.bytes), (50, 9)); ++ retained.merge_from(&mut donor).unwrap(); ++ assert_eq!((retained.bytes, donor.bytes, a.used.load(Ordering::Acquire)), (80, 0, 80)); ++ assert!(retained.split(81).is_err()); ++ assert_eq!(retained.bytes, 80); ++ drop(donor); ++ assert_eq!(a.used.load(Ordering::Acquire), 80); ++ drop(retained); ++ drop(foreign); ++ assert_eq!((a.used.load(Ordering::Acquire), b.used.load(Ordering::Acquire)), (0, 0)); ++ } ++ #[test] ++ fn two_total_slots_include_inflight_and_clones_do_not_mint_capacity() { ++ let (budget, work, credits) = credits(); ++ let total = budget.used.load(Ordering::Acquire); ++ let first = take(&credits); ++ assert!(credits.request().unwrap()); ++ assert!(credits.acquire().unwrap().is_none(), "one encoder even with another free slot"); ++ let first = payload(first, 1); ++ let held = first.clone(); ++ let second = payload(take(&credits), 2); ++ assert!(credits.request().unwrap()); ++ assert!(credits.acquire().unwrap().is_none()); ++ assert!(credits.requested.load(Ordering::Acquire), "full credit preserves coalesced demand"); ++ drop(first); ++ assert!(credits.acquire().unwrap().is_none(), "a clone retains the same first slot"); ++ assert_eq!(budget.used.load(Ordering::Acquire), total); ++ drop(held); ++ let third = credits.acquire().unwrap().unwrap(); ++ assert_eq!(budget.used.load(Ordering::Acquire), total, "return/transfer does not reserve globally again"); ++ assert_eq!(second.png(), &[1, 2, 3, 4]); ++ drop(third); ++ drop(second); ++ credits.close(); ++ assert_eq!(budget.used.load(Ordering::Acquire), 17 + 1024); ++ drop(credits); ++ drop(work); ++ assert_eq!(budget.used.load(Ordering::Acquire), 0); ++ } ++ #[test] ++ fn demand_during_inflight_survives_publication_and_terminal_held_frames_stay_billed() { ++ let (budget, work, credits) = credits(); ++ let first = take(&credits); ++ assert!(!credits.requested.load(Ordering::Acquire)); ++ assert!(credits.request().unwrap()); ++ let first = payload(first, 1); ++ assert!(credits.requested.load(Ordering::Acquire)); ++ let second = payload(credits.acquire().unwrap().unwrap(), 2); ++ let per_slot = credits.plan.slot_bytes().unwrap(); ++ credits.close(); ++ assert!(!credits.request().unwrap()); ++ assert!(credits.acquire().unwrap().is_none()); ++ drop(work); ++ assert_eq!(budget.used.load(Ordering::Acquire), 2 * per_slot + 1024); ++ drop(credits); ++ assert_eq!(first.covered(), &[1, 0, 0, 0]); ++ drop(first); ++ assert_eq!(budget.used.load(Ordering::Acquire), per_slot + 1024); ++ drop(second); ++ assert_eq!(budget.used.load(Ordering::Acquire), 0); ++ } ++ #[test] ++ fn optional_exhaustion_is_real_and_legacy_request_remains_noop() { ++ let (_, work, credits) = credits(); ++ assert!(credits.request().unwrap()); ++ credits.exhaust(); ++ assert!(credits.exhausted.load(Ordering::Acquire)); ++ assert!(!credits.request().unwrap()); ++ assert!(credits.acquire().unwrap().is_none()); ++ credits.close(); ++ drop(work); ++ let host = CpuHost::cooperative(); ++ let job = host.submit(id(7724, 2), 19, empty(), request()).unwrap(); ++ let before = serde_json::to_value(job.status().unwrap()).unwrap(); ++ assert!(!job.request_partial_preview().unwrap()); ++ assert!(!job.partial_preview_exhausted().unwrap()); ++ assert!(job.partial_preview().unwrap().is_none()); ++ assert_eq!(serde_json::to_value(job.status().unwrap()).unwrap(), before); ++ job.cancel().unwrap(); ++ assert!(!job.request_partial_preview().unwrap()); ++ } ++ ++ #[cfg(all(feature = "raytrace-cpu", not(target_arch = "wasm32")))] ++ fn real_fixture() -> (CpuHost, JobHandle, Running) { ++ let host = ImageHost(Arc::new(Owner { ++ executor: None, shared: CpuHost::shared(MEMORY_LIMIT), kind: HostKind::NativeWorker, ++ running: Mutex::new(None), _worker: None, ++ })); ++ let request = ImageRequest { ++ integrator: Integrator::Raytrace, ++ raytrace: Some(crate::job::RaytraceOptions { ++ progressive: Some(crate::job::CpuProgressiveOptions { samples_per_pixel: 5, seed: 123 }), ++ lights: Some(Vec::new()), ..Default::default() ++ }), width: 16, height: 16, ..request() ++ }; ++ let job = host.submit_cpu_partial_with_environment_and_options(id(7724, 3), 19, empty(), request, JobOptions::default(), None).unwrap(); ++ let work = host.0.shared.queue.lock().unwrap().pop_front().unwrap(); ++ let running = Running::begin(work).unwrap(); ++ (host, job, running) ++ } ++ #[cfg(all(feature = "raytrace-cpu", not(target_arch = "wasm32")))] ++ #[test] ++ fn real_partial_png_carries_unknown_and_two_held_payloads_do_not_block_final() { ++ let (host, job, mut running) = real_fixture(); ++ assert!(job.request_partial_preview().unwrap()); ++ let mut during = false; ++ for _ in 0..100_000 { ++ assert!(running.advance(1).unwrap()); ++ if !during && running.partial.as_ref().unwrap().0[0].lease.is_some() { ++ assert!(job.request_partial_preview().unwrap()); ++ during = true; ++ } ++ if job.partial_preview().unwrap().is_some() { break; } ++ } ++ let first = job.partial_preview().unwrap().unwrap(); ++ assert!(during); ++ assert_eq!(first.info.sequence, 1); ++ assert_eq!(first.info.completed_passes, 0); ++ assert!(first.info.updated_prefix > 0 && first.info.updated_prefix < 256); ++ assert!(job.preview().unwrap().is_none(), "partial mode never publishes uncredited legacy snapshots"); ++ let decoded = image::load_from_memory(first.png()).unwrap().to_rgba8(); ++ assert_eq!(decoded.dimensions(), (16, 16)); ++ for (i, rgba) in decoded.pixels().enumerate() { ++ assert_eq!(rgba.0[3], if (i as u64) < first.info.updated_prefix { 255 } else { 0 }); ++ assert_eq!(first.covered()[i], 0, "empty scene means a real miss, never a fabricated hit"); ++ } ++ let first_hash = Sha256::digest(first.png()); ++ for _ in 0..100_000 { ++ if job.partial_preview().unwrap().is_some_and(|p| p.info.sequence == 2) { break; } ++ assert!(running.advance(1).unwrap()); ++ } ++ let second = job.partial_preview().unwrap().unwrap(); ++ assert_eq!(second.info.sequence, 2, "request issued during encoding must survive first publication"); ++ assert!(job.request_partial_preview().unwrap()); ++ assert_eq!(job.0.partial.as_ref().unwrap().state.lock().unwrap().free.bytes, 0); ++ for _ in 0..100_000 { ++ if !running.advance(1).unwrap() { break; } ++ assert!(job.partial_preview().unwrap().is_some_and(|p| p.info.sequence == 2)); ++ assert!(running.partial.as_ref().unwrap().0[0].lease.is_none()); ++ assert!(running.partial.as_ref().unwrap().0[0].pending.is_none()); ++ } ++ assert_eq!(job.status().unwrap().progress.phase, Phase::Completed); ++ let final_frame = job.frame().unwrap().unwrap(); ++ assert_eq!((final_frame.info.width, final_frame.info.height), (16, 16)); ++ assert!(job.partial_preview().unwrap().is_none()); ++ assert!(!job.request_partial_preview().unwrap()); ++ assert_eq!(Sha256::digest(first.png()), first_hash); ++ let per_slot = job.0.partial.as_ref().unwrap().plan.slot_bytes().unwrap(); ++ drop(running); ++ let before = host.admitted_bytes(); ++ drop(first); ++ assert_eq!(host.admitted_bytes(), before - per_slot); ++ drop(second); ++ assert_eq!(host.admitted_bytes(), before - 2 * per_slot); ++ drop(final_frame); ++ drop(job); ++ assert_eq!(host.admitted_bytes(), 0); ++ } ++} ++ ++#[cfg(all(feature = "raytrace-cpu", not(target_arch = "wasm32")))] ++mod partial_preview_terminal_errors { ++ use super::*; ++ use crate::job::{CpuProgressiveOptions, RaytraceOptions}; ++ ++ #[test] ++ fn cancellation_during_real_partial_hash_closes_slots_and_publishes_nothing() { ++ let host = ImageHost(Arc::new(Owner { executor: None, shared: CpuHost::shared(MEMORY_LIMIT), ++ kind: HostKind::NativeWorker, running: Mutex::new(None), _worker: None })); ++ let request = ImageRequest { integrator: Integrator::Raytrace, raytrace: Some(RaytraceOptions { ++ progressive: Some(CpuProgressiveOptions { samples_per_pixel: 5, seed: 7 }), lights: Some(Vec::new()), ..Default::default() ++ }), width: 8, height: 8, ..request() }; ++ let job = host.submit_cpu_partial_with_environment_and_options(id(7725, 1), 19, empty(), request, JobOptions::default(), None).unwrap(); ++ let work = host.0.shared.queue.lock().unwrap().pop_front().unwrap(); ++ let mut running = Running::begin(work).unwrap(); ++ assert!(job.request_partial_preview().unwrap()); ++ for _ in 0..100_000 { ++ if running.pending_png.is_some() { break; } ++ assert!(running.advance(1).unwrap()); ++ } ++ assert!(running.pending_png.is_some()); ++ assert!(job.partial_preview().unwrap().is_none()); ++ assert!(running.partial.as_ref().unwrap().0[0].pending.is_some()); ++ job.cancel().unwrap(); ++ assert!(!job.request_partial_preview().unwrap()); ++ assert!(!running.guarded_step(1)); ++ assert_eq!(job.status().unwrap().progress.phase, Phase::Cancelled); ++ assert!(job.partial_preview().unwrap().is_none()); ++ assert!(job.frame().unwrap().is_none()); ++ drop(running); ++ drop(job); ++ assert_eq!(host.admitted_bytes(), 0); ++ } ++} ++ ++#[test] ++fn partial_credit_last_drop_fails_closed_after_poison_without_losing_leases() { ++ let plan = crate::job::PartialPreviewPlan::new(1, 1).unwrap(); ++ let bytes = 2 * plan.slot_bytes().unwrap() + 1024; ++ let budget = Arc::new(Budget { used: AtomicU64::new(0), limit: bytes }); ++ let mut work = budget.reserve(bytes).unwrap(); ++ let credits = PartialCredits::new(plan, &mut work).unwrap(); ++ credits.request().unwrap(); ++ let held = credits.acquire().unwrap().unwrap(); ++ let poisoned = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { ++ let _state = credits.state.lock().unwrap(); ++ panic!("deliberate test-only credit lock poison"); ++ })); ++ assert!(poisoned.is_err()); ++ drop(held); ++ assert_eq!(budget.used.load(Ordering::Acquire), 1024); ++ credits.close(); ++ drop(credits); ++ drop(work); ++ assert_eq!(budget.used.load(Ordering::Acquire), 0); ++} diff --git a/proposals/render/2026-10-30/partial-stream-source-v1/producer-A1-A2.patch b/proposals/render/2026-10-30/partial-stream-source-v1/producer-A1-A2.patch new file mode 100644 index 000000000..442b9d949 --- /dev/null +++ b/proposals/render/2026-10-30/partial-stream-source-v1/producer-A1-A2.patch @@ -0,0 +1,1003 @@ +--- a/crates/render/src/film_primary.rs ++++ b/crates/render/src/film_primary.rs +@@ -10,6 +10,23 @@ + struct Pixel { + sum: [f64; 3], + covered: u32, ++} ++ ++/// Observed scanline frontier; metadata only, never a caller-supplied authority. ++/// Every pixel before updated_prefix has one more sample than completed_passes. ++#[derive(Clone, Copy, Debug, PartialEq, Eq)] ++pub(crate) struct PartialFrontier { ++ pub completed_passes: u32, ++ pub updated_prefix: usize, ++ pub pixels: usize, ++} ++ ++/// A partial view never invents a zero sample for a pixel not yet observed. ++/// Sampled linear radiance includes zero contributions from primary misses. ++#[derive(Clone, Copy, Debug, PartialEq)] ++pub(crate) enum PartialPixel { ++ Unknown, ++ Sampled { linear_premultiplied: [f64; 3], covered: u32, count: u32 }, + } + + pub(crate) struct PrimaryFilm { +@@ -121,4 +138,49 @@ + let samples = u16::try_from(self.samples).map_err(|_| limit("primary sample count exceeds resolve representation"))?; + Ok((pixel.sum.map(|sum| sum / f64::from(self.samples)), covered, samples)) + } ++ /// Inspect only the real committed state. This value does not freeze the film ++ /// or authorize a snapshot. A caller resolving several pixels must keep the ++ /// film immutably borrowed at one completed-pixel frontier, and must charge ++ /// reads/copies and check cancellation against its existing job budget. ++ pub(crate) fn partial_frontier(&self) -> Result { ++ if !self.ready() ++ || self.next_pixel >= self.count ++ || self.samples > self.sample_limit ++ || (self.samples == self.sample_limit && self.next_pixel != 0) ++ { ++ return Err(invalid("primary film has no initialized partial frontier")); ++ } ++ Ok(PartialFrontier { completed_passes: self.samples, updated_prefix: self.next_pixel, pixels: self.count }) ++ } ++ ++ /// Bounded allocation-free read, separate from the strict complete-pass pixel(). ++ /// Counts come from this film, never from a supplied frontier or sample count. ++ /// Unknown means count0/covered0; a sampled miss has count>0 and covered0. ++ /// No exposure, tone mapping, background, work lease or publication occurs here. ++ /// The caller owes cancellation checks and work charges for each read/copy; ++ /// this accessor creates no independent budget and never advances an ordinal. ++ pub(crate) fn partial_pixel(&self, index: usize) -> Result { ++ let frontier = self.partial_frontier()?; ++ let pixel = self.pixels.get(index).ok_or_else(|| invalid("primary film partial index out of range"))?; ++ let count = frontier ++ .completed_passes ++ .checked_add(u32::from(index < frontier.updated_prefix)) ++ .filter(|count| *count <= self.sample_limit) ++ .ok_or_else(|| limit("primary partial sample count exceeded"))?; ++ if pixel.covered > count { ++ return Err(invalid("primary partial coverage exceeds its committed count")); ++ } ++ if count == 0 { ++ if pixel.covered != 0 || pixel.sum != [0.0; 3] { ++ return Err(invalid("unobserved primary pixel has accumulated data")); ++ } ++ return Ok(PartialPixel::Unknown); ++ } ++ Ok(PartialPixel::Sampled { ++ linear_premultiplied: pixel.sum.map(|sum| sum / f64::from(count)), ++ covered: pixel.covered, ++ count, ++ }) ++ } ++ + } +--- a/crates/render/src/film_tests.rs ++++ b/crates/render/src/film_tests.rs +@@ -275,3 +275,167 @@ + assert!(film.add(0, 512, [0.0; 3], true, &cancel, &mut || Ok(())).is_err()); + assert_eq!(film.samples(), 512); + } ++ ++ ++#[cfg(feature = "raytrace-cpu")] ++mod partial_camera_passes { ++ use super::primary::{PartialFrontier, PartialPixel, PrimaryFilm}; ++ use super::*; ++ use crate::job::{CpuBudget, CpuProgressiveOptions}; ++ ++ fn uninitialized(samples: u32, seed: u32) -> PrimaryFilm { ++ let options = CpuProgressiveOptions { samples_per_pixel: samples, seed }; ++ let bytes = PrimaryFilm::required_bytes(4, 1, options, CpuBudget::Compact).unwrap(); ++ PrimaryFilm::new(4, 1, options, bytes, &CancelToken::default(), CpuBudget::Compact).unwrap() ++ } ++ ++ fn ready(samples: u32, seed: u32) -> PrimaryFilm { ++ let mut film = uninitialized(samples, seed); ++ while !film.ready() { ++ film.initialize_one(&CancelToken::default(), &mut || Ok(())).unwrap(); ++ } ++ film ++ } ++ ++ fn observe(film: &PrimaryFilm) -> (PartialFrontier, Vec) { ++ (film.partial_frontier().unwrap(), (0..4).map(|index| film.partial_pixel(index).unwrap()).collect()) ++ } ++ ++ fn sampled(mean: [f64; 3], covered: u32, count: u32) -> PartialPixel { ++ PartialPixel::Sampled { linear_premultiplied: mean, covered, count } ++ } ++ ++ #[test] ++ fn partial_frontier_distinguishes_first_prefix_miss_and_unobserved_pixels() { ++ let mut film = ready(2, 7); ++ assert_eq!(observe(&film), ( ++ PartialFrontier { completed_passes: 0, updated_prefix: 0, pixels: 4 }, ++ vec![PartialPixel::Unknown; 4], ++ )); ++ film.add(0, 0, [2.0, 0.0, 0.0], true, &CancelToken::default(), &mut || Ok(())).unwrap(); ++ film.add(1, 0, [0.0; 3], false, &CancelToken::default(), &mut || Ok(())).unwrap(); ++ assert_eq!(observe(&film), ( ++ PartialFrontier { completed_passes: 0, updated_prefix: 2, pixels: 4 }, ++ vec![sampled([2.0, 0.0, 0.0], 1, 1), sampled([0.0; 3], 0, 1), PartialPixel::Unknown, PartialPixel::Unknown], ++ )); ++ assert!(film.pixel(0).is_err(), "legacy whole-pass reader still rejects the partial pass"); ++ assert!(film.pixel(1).is_err(), "a sampled miss does not imply a uniform pass"); ++ } ++ ++ #[test] ++ fn partial_counts_and_means_follow_real_interior_and_full_pass_frontiers() { ++ let mut film = ready(2, 0); ++ let cancel = CancelToken::default(); ++ for (index, value, covered) in [ ++ (0, [2.0, 0.0, 0.0], true), (1, [0.0; 3], false), ++ (2, [0.0, 0.0, 4.0], true), (3, [0.0; 3], false), ++ ] { ++ film.add(index, 0, value, covered, &cancel, &mut || Ok(())).unwrap(); ++ } ++ assert_eq!(film.partial_frontier().unwrap(), PartialFrontier { completed_passes: 1, updated_prefix: 0, pixels: 4 }); ++ assert_eq!(film.partial_pixel(3).unwrap(), sampled([0.0; 3], 0, 1)); ++ assert_eq!(film.pixel(0).unwrap(), ([2.0, 0.0, 0.0], 1, 1)); ++ ++ film.add(0, 1, [4.0, 0.0, 0.0], true, &cancel, &mut || Ok(())).unwrap(); ++ film.add(1, 1, [0.0, 2.0, 0.0], true, &cancel, &mut || Ok(())).unwrap(); ++ assert_eq!(observe(&film), ( ++ PartialFrontier { completed_passes: 1, updated_prefix: 2, pixels: 4 }, ++ vec![sampled([3.0, 0.0, 0.0], 2, 2), sampled([0.0, 1.0, 0.0], 1, 2), ++ sampled([0.0, 0.0, 4.0], 1, 1), sampled([0.0; 3], 0, 1)], ++ )); ++ assert!(film.pixel(0).is_err()); ++ ++ film.add(2, 1, [0.0, 0.0, 8.0], true, &cancel, &mut || Ok(())).unwrap(); ++ assert_eq!(film.partial_frontier().unwrap().updated_prefix, 3); ++ film.add(3, 1, [0.0; 3], false, &cancel, &mut || Ok(())).unwrap(); ++ assert_eq!(observe(&film), ( ++ PartialFrontier { completed_passes: 2, updated_prefix: 0, pixels: 4 }, ++ vec![sampled([3.0, 0.0, 0.0], 2, 2), sampled([0.0, 1.0, 0.0], 1, 2), ++ sampled([0.0, 0.0, 6.0], 2, 2), sampled([0.0; 3], 0, 2)], ++ )); ++ assert_eq!(film.pixel(2).unwrap(), ([0.0, 0.0, 6.0], 2, 2)); ++ assert!(film.add(0, 2, [0.0; 3], false, &cancel, &mut || Ok(())).is_err()); ++ assert_eq!(film.partial_frontier().unwrap().completed_passes, 2); ++ } ++ ++ #[test] ++ fn partial_access_refuses_uninitialized_storage_and_invalid_indices() { ++ let mut film = uninitialized(2, 7); ++ assert!(film.partial_frontier().is_err()); ++ assert!(film.partial_pixel(0).is_err()); ++ film.initialize_one(&CancelToken::default(), &mut || Ok(())).unwrap(); ++ assert!(film.partial_frontier().is_err(), "allocated prefix is not an initialized film"); ++ assert!(film.partial_pixel(0).is_err()); ++ while !film.ready() { ++ film.initialize_one(&CancelToken::default(), &mut || Ok(())).unwrap(); ++ } ++ assert_eq!(film.partial_pixel(0).unwrap(), PartialPixel::Unknown); ++ assert!(film.partial_pixel(4).is_err()); ++ assert!(film.partial_pixel(usize::MAX).is_err()); ++ assert_eq!(film.partial_frontier().unwrap().updated_prefix, 0); ++ } ++ ++ #[test] ++ fn failed_or_cancelled_updates_preserve_the_observed_partial_frontier() { ++ let mut film = ready(2, 7); ++ film.add(0, 0, [2.0, 0.0, 0.0], true, &CancelToken::default(), &mut || Ok(())).unwrap(); ++ let before = observe(&film); ++ for (index, ordinal, value, covered) in [ ++ (0, 0, [0.0; 3], false), (2, 0, [0.0; 3], false), (1, 1, [0.0; 3], false), ++ (1, 0, [f64::NAN; 3], true), (1, 0, [1.0; 3], false), ++ ] { ++ assert!(film.add(index, ordinal, value, covered, &CancelToken::default(), &mut || Ok(())).is_err()); ++ assert_eq!(observe(&film), before); ++ } ++ assert_eq!(film.add(1, 0, [4.0; 3], true, &CancelToken::default(), &mut || Err(limit("existing job exhausted"))).unwrap_err().code, ++ ErrorCode::LimitExceeded); ++ assert_eq!(observe(&film), before); ++ let cancel = CancelToken::default(); ++ let observer = cancel.clone(); ++ assert_eq!(film.add(1, 0, [4.0; 3], true, &cancel, &mut || { ++ observer.cancel(); ++ Ok(()) ++ }).unwrap_err().code, ErrorCode::Cancelled); ++ assert_eq!(observe(&film), before); ++ film.add(1, 0, [4.0; 3], true, &CancelToken::default(), &mut || Ok(())).unwrap(); ++ assert_eq!(film.partial_frontier().unwrap().updated_prefix, 2, "failed updates did not consume the next ordinal"); ++ } ++ ++ #[test] ++ fn reading_partial_pixels_preserves_default_sum_order_bits_and_charge_count() { ++ for seed in [0, 7, u32::MAX] { ++ let mut observed = ready(4, seed); ++ let mut control = ready(4, seed); ++ let mut observed_charges = 0; ++ let mut control_charges = 0; ++ for ordinal in 0..4 { ++ let red = if ordinal == 0 { 1e12 } else { 2.0_f64.powi(-15) }; ++ for index in 0..4 { ++ let value = [red, red * 0.5, 2.0]; ++ observed.add(index, ordinal, value, true, &CancelToken::default(), &mut || { ++ observed_charges += 1; ++ Ok(()) ++ }).unwrap(); ++ // These uncharged O(1) reads model only the accessor. A future ++ // snapshot caller still owes its own per-read/copy work charge. ++ let _ = observe(&observed); ++ control.add(index, ordinal, value, true, &CancelToken::default(), &mut || { ++ control_charges += 1; ++ Ok(()) ++ }).unwrap(); ++ } ++ } ++ assert_eq!((observed_charges, control_charges), (16, 16)); ++ assert_eq!(observed.samples(), 4); ++ for index in 0..4 { ++ let (actual, covered, count) = observed.pixel(index).unwrap(); ++ let (expected, expected_covered, expected_count) = control.pixel(index).unwrap(); ++ assert_eq!(actual.map(f64::to_bits), expected.map(f64::to_bits)); ++ assert_eq!(actual.map(f64::to_bits), [2.5e11_f64, 1.25e11_f64, 2.0_f64].map(f64::to_bits), ++ "ordered additions keep each sub-half-ULP contribution rounded at its original addition"); ++ assert_eq!((covered, count), (expected_covered, expected_count)); ++ assert_eq!(observed.partial_pixel(index).unwrap(), sampled(actual, 4, 4)); ++ } ++ } ++ } ++} +--- a/crates/render/src/raytrace/progressive.rs ++++ b/crates/render/src/raytrace/progressive.rs +@@ -8,6 +8,72 @@ + pub options: CpuProgressiveOptions, + pub resolving: bool, + pub resolve_pixel: usize, ++ pub partial_plan: Option, ++ pub partial: Option, ++ pub last_partial: Option, ++} ++ ++pub(super) struct PartialResolve { ++ pub plan: crate::job::PartialPreviewPlan, ++ pub frontier: crate::film::primary::PartialFrontier, ++ pub resume_pixel: usize, ++ pub next: usize, ++ pub covered: Vec, ++} ++ ++/// Read-only O(1) test for new represented data; no scan over the source film. ++/// A completed global pass is meaningful even if its last source pixels are ++/// not representatives: the receiver's global Unknown authority changes then. ++pub(super) fn represented_changed( ++ plan: crate::job::PartialPreviewPlan, ++ before: Option, ++ now: crate::film::primary::PartialFrontier, ++) -> crate::job::Result { ++ use crate::job::{ErrorCode, JobError}; ++ plan.validate()?; ++ let source_pixels = u64::from(plan.source_width()) * u64::from(plan.source_height()); ++ if u64::try_from(now.pixels).ok() != Some(source_pixels) || now.updated_prefix >= now.pixels { ++ return Err(JobError::new(ErrorCode::InvalidScene, "partial film frontier differs from its source plan")); ++ } ++ let Some(before) = before else { return Ok(now.completed_passes != 0 || now.updated_prefix != 0) }; ++ if before.pixels != now.pixels ++ || before.completed_passes > now.completed_passes ++ || (before.completed_passes == now.completed_passes && before.updated_prefix > now.updated_prefix) ++ { ++ return Err(JobError::new(ErrorCode::InvalidScene, "partial film frontier went backwards")); ++ } ++ if before.completed_passes != now.completed_passes { ++ return Ok(true); ++ } ++ if before.updated_prefix == now.updated_prefix { ++ return Ok(false); ++ } ++ let w = u64::from(plan.source_width()); ++ let h = u64::from(plan.source_height()); ++ let pw = u64::from(plan.width()); ++ let ph = u64::from(plan.height()); ++ let lower = u64::try_from(before.updated_prefix).map_err(|_| JobError::new(ErrorCode::LimitExceeded, "partial source index overflow"))?; ++ let x = lower % w; ++ let y = lower / w; ++ let mut v = y.checked_mul(ph).ok_or_else(|| JobError::new(ErrorCode::LimitExceeded, "partial row mapping overflow"))?.div_ceil(h); ++ if v >= ph { ++ return Ok(false); ++ } ++ let mut u = if v * h / ph == y { ++ x.checked_mul(pw).ok_or_else(|| JobError::new(ErrorCode::LimitExceeded, "partial column mapping overflow"))?.div_ceil(w) ++ } else { ++ 0 ++ }; ++ if u >= pw { ++ v += 1; ++ u = 0; ++ } ++ if v >= ph { ++ return Ok(false); ++ } ++ let display = v.checked_mul(pw).and_then(|n| n.checked_add(u)).ok_or_else(|| JobError::new(ErrorCode::LimitExceeded, "partial display index overflow"))?; ++ let display = usize::try_from(display).map_err(|_| JobError::new(ErrorCode::LimitExceeded, "partial display address overflow"))?; ++ Ok(plan.source_index(display)? < now.updated_prefix) + } + + /// Integer-only mixing before conversion to exactly representable 53-bit unit +--- a/crates/render/src/raytrace/image.rs ++++ b/crates/render/src/raytrace/image.rs +@@ -119,6 +119,37 @@ + options: &RaytraceOptions, + nested: bool, + ) -> job::Result { ++ admit_with_policy(scene, request, options, nested, None) ++} ++ ++pub(crate) fn admit_with_partial_preview( ++ scene: &ProductScene, ++ request: &ImageRequest, ++ options: &RaytraceOptions, ++ nested: bool, ++ plan: job::PartialPreviewPlan, ++) -> job::Result { ++ admit_with_policy(scene, request, options, nested, Some(plan)) ++} ++ ++fn admit_with_policy( ++ scene: &ProductScene, ++ request: &ImageRequest, ++ options: &RaytraceOptions, ++ nested: bool, ++ partial: Option, ++) -> job::Result { ++ if let Some(plan) = partial { ++ plan.validate()?; ++ if plan != job::PartialPreviewPlan::new(request.width, request.height)? ++ || options.progressive.is_none() ++ || request.environment.is_some() ++ || request.textures.is_some() ++ || scene.has_transmission() ++ { ++ return Err(JobError::new(ErrorCode::InvalidRequest, "partial preview requires the exact CPU progressive source plan")); ++ } ++ } + options.validate()?; + if let Some(original) = &request.raytrace { + original.validate()?; +@@ -228,8 +259,13 @@ + let n = usize::try_from(a.triangles).map_err(|_| error(TraceError::MemoryLimit))?; + let film_bytes = if let Some(progressive) = options.progressive { + let checkpoint = a.encoded_limit.checked_add(job::FRAME_METADATA_BYTES).ok_or_else(|| error(TraceError::MemoryLimit))?; ++ let previews = if let Some(plan) = partial { ++ plan.additional_bytes()? ++ } else { ++ u64::from(progressive.preview_count()).checked_mul(checkpoint).ok_or_else(|| error(TraceError::MemoryLimit))? ++ }; + PrimaryFilm::required_bytes(request.width, request.height, progressive, options.budget)? +- .checked_add(u64::from(progressive.preview_count()).checked_mul(checkpoint).ok_or_else(|| error(TraceError::MemoryLimit))?) ++ .checked_add(previews) + .and_then(|v| v.checked_add(std::mem::size_of::() as u64)) + .ok_or_else(|| error(TraceError::MemoryLimit))? + } else { +@@ -505,6 +541,23 @@ + Complete(Vec), + } + ++/// Additive host-only poll; the public legacy ImagePoll contract is unchanged. ++pub(crate) enum PartialImagePoll { ++ Pending(Progress), ++ Complete(Vec), ++ Preview { png: Vec, covered: Vec, completed_passes: u32, updated_prefix: u64 }, ++} ++ ++pub(crate) enum PartialBegin { ++ Started, ++ Exhausted, ++} ++ ++enum ImageAdvance { ++ Legacy(ImagePoll), ++ Partial { png: Vec, covered: Vec, completed_passes: u32, updated_prefix: u64 }, ++} ++ + impl ImageTask { + pub fn punctual_diagnostics(&self) -> Option { + (!self.punctual_diagnostics.is_empty()).then_some(self.punctual_diagnostics) +@@ -531,8 +584,32 @@ + input: Option, + nested: bool, + ) -> job::Result { ++ Self::new_with_policy(scene, request, cancel, options, input, nested, None) ++ } ++ ++ pub(crate) fn new_with_environment_and_nested_and_partial( ++ scene: ProductScene, ++ request: ImageRequest, ++ cancel: CancelToken, ++ options: RaytraceOptions, ++ input: Option, ++ nested: bool, ++ plan: job::PartialPreviewPlan, ++ ) -> job::Result { ++ Self::new_with_policy(scene, request, cancel, options, input, nested, Some(plan)) ++ } ++ ++ fn new_with_policy( ++ scene: ProductScene, ++ request: ImageRequest, ++ cancel: CancelToken, ++ options: RaytraceOptions, ++ input: Option, ++ nested: bool, ++ partial: Option, ++ ) -> job::Result { + cancel.check()?; +- let mut admission = admit_with_nested(&scene, &request, &options, nested)?; ++ let mut admission = admit_with_policy(&scene, &request, &options, nested, partial)?; + let mut optical = Vec::new(); + if !options.dielectrics.is_empty() { + let (certificates, parents) = certificates(&scene, &options, nested)?; +@@ -617,7 +694,7 @@ + .map(|options| -> job::Result { + let bytes = PrimaryFilm::required_bytes(request.width, request.height, options, budget)?; + let film = PrimaryFilm::new(request.width, request.height, options, bytes, &cancel, budget)?; +- Ok(Progressive { film, options, resolving: false, resolve_pixel: 0 }) ++ Ok(Progressive { film, options, resolving: false, resolve_pixel: 0, partial_plan: partial, partial: None, last_partial: None }) + }) + .transpose()?; + Ok(Self { +@@ -662,6 +739,12 @@ + pub fn progress(&self) -> Progress { + let (phase, done, total) = if self.done { + (Phase::Completed, 1, 1) ++ } else if let Some(partial) = self.progressive.as_ref().and_then(|p| p.partial.as_ref()) { ++ if let Some(encoder) = &self.encoder { ++ (Phase::Encoding, encoder.row() as u64, u64::from(partial.plan.height())) ++ } else { ++ (Phase::Encoding, partial.next as u64, partial.plan.pixels()) ++ } + } else if let Some(e) = &self.encoder { + (Phase::Encoding, e.row() as u64, self.request.height as u64) + } else if let Some(progressive) = &self.progressive { +@@ -1485,6 +1568,143 @@ + Ok(()) + } + ++ ++ pub(crate) fn partial_preview_ready(&self, plan: job::PartialPreviewPlan) -> job::Result { ++ self.cancel.check()?; ++ plan.validate()?; ++ if (plan.source_width(), plan.source_height()) != (self.request.width, self.request.height) { ++ return Err(JobError::new(ErrorCode::InvalidRequest, "partial preview source dimensions changed")); ++ } ++ let Some(progressive) = &self.progressive else { return Ok(false) }; ++ if progressive.partial_plan != Some(plan) { ++ return Err(JobError::new(ErrorCode::InvalidRequest, "partial preview plan differs from the task policy")); ++ } ++ if self.done || !progressive.film.ready() || !self.pending.is_none() ++ || self.encoder.is_some() || progressive.partial.is_some() || progressive.resolving || !self.pixels.is_empty() ++ { ++ return Ok(false); ++ } ++ let frontier = progressive.film.partial_frontier()?; ++ if frontier.completed_passes >= progressive.options.samples_per_pixel { ++ return Ok(false); ++ } ++ let safe = if frontier.updated_prefix == 0 { ++ frontier.completed_passes > 0 && self.pixel == frontier.pixels ++ } else { ++ self.pixel == frontier.updated_prefix ++ }; ++ if !safe { ++ return Ok(false); ++ } ++ progressive::represented_changed(plan, progressive.last_partial, frontier) ++ } ++ ++ /// Host must already hold its one in-flight credit. No host lease or clock ++ /// lives here; an insufficient optional debit does not mutate trace state. ++ pub(crate) fn begin_partial_preview(&mut self, plan: job::PartialPreviewPlan) -> job::Result { ++ if !self.partial_preview_ready(plan)? { ++ return Err(JobError::new(ErrorCode::InvalidRequest, "partial preview requires a fresh safe completed pixel")); ++ } ++ let frontier = self.progressive.as_ref().ok_or_else(|| invalid("missing progressive film"))?.film.partial_frontier()?; ++ let units = plan.snapshot_work()?; ++ if self.work.remaining() < units { ++ return Ok(PartialBegin::Exhausted); ++ } ++ self.work.charge(units, &self.cancel).map_err(error)?; ++ let count = usize::try_from(plan.pixels()).map_err(|_| error(TraceError::MemoryLimit))?; ++ let mut covered = Vec::new(); ++ covered.try_reserve_exact(count).map_err(|_| error(TraceError::AllocationFailed))?; ++ if covered.capacity() != count { ++ return Err(error(TraceError::MemoryLimit)); ++ } ++ self.cancel.check()?; ++ let progressive = self.progressive.as_mut().ok_or_else(|| invalid("missing progressive film"))?; ++ progressive.partial = Some(progressive::PartialResolve { plan, frontier, resume_pixel: self.pixel, next: 0, covered }); ++ Ok(PartialBegin::Started) ++ } ++ ++ /// One prepaid representative resolve, encoder setup, or encoding row. ++ /// Work was debited before allocation; cancel/continuation bounds remain real. ++ fn partial_preview_one(&mut self) -> job::Result> { ++ self.cancel.check()?; ++ let (plan, frontier, resume_pixel, next) = { ++ let partial = self.progressive.as_ref().and_then(|p| p.partial.as_ref()).ok_or_else(|| invalid("missing partial resolve state"))?; ++ (partial.plan, partial.frontier, partial.resume_pixel, partial.next) ++ }; ++ let count = usize::try_from(plan.pixels()).map_err(|_| error(TraceError::MemoryLimit))?; ++ if next < count { ++ let index = plan.source_index(next)?; ++ let value = self.progressive.as_ref().ok_or_else(|| invalid("missing partial film"))?.film.partial_pixel(index)?; ++ let (rgba, covered) = match value { ++ crate::film::primary::PartialPixel::Unknown => ([0; 4], 0), ++ crate::film::primary::PartialPixel::Sampled { linear_premultiplied, covered, count } => { ++ let covered = u16::try_from(covered).map_err(|_| error(TraceError::MemoryLimit))?; ++ let count = u16::try_from(count).map_err(|_| error(TraceError::MemoryLimit))?; ++ let [r, g, b] = linear_premultiplied; ++ (composite_spatial(Vec3::new(r, g, b), covered, count, self.request.background, self.options.exposure_ev)?, covered) ++ } ++ }; ++ if next.checked_mul(4) != Some(self.pixels.len()) { ++ return Err(invalid("partial RGBA cursor mismatch")); ++ } ++ self.cancel.check()?; ++ let partial = self.progressive.as_mut().and_then(|p| p.partial.as_mut()).ok_or_else(|| invalid("missing partial cell state"))?; ++ if partial.covered.len() != next || partial.covered.capacity() != count { ++ return Err(invalid("partial coverage cursor or capacity mismatch")); ++ } ++ self.pixels.extend_from_slice(&rgba); ++ partial.covered.push(covered); ++ partial.next += 1; ++ return Ok(None); ++ } ++ if next != count { ++ return Err(invalid("partial display cursor exceeded its plan")); ++ } ++ if self.encoder.is_none() { ++ let limit = plan.encoded_limit()?; ++ let capacity = usize::try_from(limit).map_err(|_| error(TraceError::MemoryLimit))?; ++ let mut output = Vec::new(); ++ output.try_reserve_exact(capacity).map_err(|_| error(TraceError::AllocationFailed))?; ++ if output.capacity() != capacity { ++ return Err(error(TraceError::MemoryLimit)); ++ } ++ self.cancel.check()?; ++ self.encoder = Some(job::encoding::PngEncoding::with_output(plan.width(), plan.height(), limit, self.cancel.clone(), output)?); ++ return Ok(None); ++ } ++ let png = self.encoder.as_mut().ok_or_else(|| invalid("missing partial encoder"))?.step(&self.pixels)?; ++ let Some(png) = png else { return Ok(None) }; ++ self.cancel.check()?; ++ let progressive = self.progressive.as_mut().ok_or_else(|| invalid("missing completed partial film"))?; ++ if progressive.film.partial_frontier()? != frontier || self.pixel != resume_pixel || !self.pending.is_none() { ++ return Err(invalid("partial snapshot changed its captured sample frontier")); ++ } ++ let partial = progressive.partial.take().ok_or_else(|| invalid("missing completed partial output"))?; ++ if partial.covered.len() != count || partial.covered.capacity() != count { ++ return Err(invalid("partial covered output differs from its plan")); ++ } ++ let updated_prefix = u64::try_from(frontier.updated_prefix).map_err(|_| error(TraceError::MemoryLimit))?; ++ progressive.last_partial = Some(frontier); ++ self.encoder = None; ++ self.pixels.clear(); ++ self.pixel = if resume_pixel == frontier.pixels { 0 } else { resume_pixel }; ++ Ok(Some(ImageAdvance::Partial { png, covered: partial.covered, completed_passes: frontier.completed_passes, updated_prefix })) ++ } ++ ++ pub(crate) fn step_with_partial_previews(&mut self, units: usize) -> job::Result { ++ if self.progressive.as_ref().is_none_or(|p| p.partial_plan.is_none()) { ++ return Err(JobError::new(ErrorCode::InvalidRequest, "partial polling requires the CPU partial policy")); ++ } ++ match self.advance_image(units)? { ++ ImageAdvance::Legacy(ImagePoll::Pending(progress)) => Ok(PartialImagePoll::Pending(progress)), ++ ImageAdvance::Legacy(ImagePoll::Complete(png)) => Ok(PartialImagePoll::Complete(png)), ++ ImageAdvance::Partial { png, covered, completed_passes, updated_prefix } => { ++ Ok(PartialImagePoll::Preview { png, covered, completed_passes, updated_prefix }) ++ } ++ ImageAdvance::Legacy(ImagePoll::Preview { .. }) => Err(invalid("partial policy produced a legacy checkpoint")), ++ } ++ } ++ + fn resolve_progressive_one(&mut self) -> job::Result<()> { + self.work.tick(&self.cancel).map_err(error)?; + let progressive = self.progressive.as_mut().ok_or_else(|| invalid("missing progressive resolve state"))?; +@@ -1517,12 +1737,26 @@ + /// At most four continuations/encoding rows. One cumulative work budget spans + /// geometry preparation, every absolute camera sample and every checkpoint. + pub fn step_with_previews(&mut self, units: usize) -> job::Result { ++ if self.progressive.as_ref().is_some_and(|p| p.partial_plan.is_some()) { ++ return Err(JobError::new(ErrorCode::InvalidRequest, "partial CPU tasks require their additive internal poll")); ++ } ++ match self.advance_image(units)? { ++ ImageAdvance::Legacy(poll) => Ok(poll), ++ ImageAdvance::Partial { .. } => Err(invalid("legacy policy produced a partial snapshot")), ++ } ++ } ++ ++ fn advance_image(&mut self, units: usize) -> job::Result { + self.cancel.check()?; + if units == 0 || units > 16384 || self.done { + return Err(JobError::new(ErrorCode::InvalidRequest, "invalid raytrace step or completed task")); + } + for _ in 0..units.min(4) { +- if self.progressive.as_ref().is_some_and(|p| !p.film.ready()) { ++ if self.progressive.as_ref().is_some_and(|p| p.partial.is_some()) { ++ if let Some(preview) = self.partial_preview_one()? { ++ return Ok(preview); ++ } ++ } else if self.progressive.as_ref().is_some_and(|p| !p.film.ready()) { + self.progressive + .as_mut() + .ok_or_else(|| invalid("missing progressive initialization"))? +@@ -1547,11 +1781,11 @@ + self.encoder = None; + self.pixels.clear(); + self.pixel = 0; +- return Ok(ImagePoll::Preview { png, samples_per_pixel }); ++ return Ok(ImageAdvance::Legacy(ImagePoll::Preview { png, samples_per_pixel })); + } + } + self.release_completed_work()?; +- return Ok(ImagePoll::Complete(png)); ++ return Ok(ImageAdvance::Legacy(ImagePoll::Complete(png))); + } + } else if self.progressive.as_ref().is_some_and(|p| p.resolving) { + self.resolve_progressive_one()?; +@@ -1567,7 +1801,7 @@ + if let Some(progressive) = &mut self.progressive { + self.work.tick(&self.cancel).map_err(error)?; + let samples = progressive.film.samples(); +- if samples == progressive.options.samples_per_pixel || samples.is_power_of_two() { ++ if samples == progressive.options.samples_per_pixel || (progressive.partial_plan.is_none() && samples.is_power_of_two()) { + progressive.resolving = true; + } else { + self.pixel = 0; +@@ -1596,7 +1830,7 @@ + self.prepare_one()?; + } + } +- Ok(ImagePoll::Pending(self.progress())) ++ Ok(ImageAdvance::Legacy(ImagePoll::Pending(self.progress()))) + } + } + /// Apply the already selected deterministic effect to the shared opaque hit. +--- a/crates/render/src/raytrace/primary_aa_tests.rs ++++ b/crates/render/src/raytrace/primary_aa_tests.rs +@@ -716,3 +716,340 @@ + } + panic!("area work ceiling was reset or the fixture did not finish"); + } ++ ++ ++fn partial_four_pixel_source(samples: u32, seed: u32) -> (ProductScene, ImageRequest, RaytraceOptions) { ++ let mut camera = crate::Camera { distance: 10.0, fov: 0.0, ..Default::default() }; ++ camera.set_view(StandardView::Top); ++ let body = |name: &str, x0: f64, x1: f64| { ++ let point = |x, y| { ++ let (origin, _) = camera.ray(x, y, 4.0, 1.0); ++ Vec3::new(origin.x, origin.y, 0.0) ++ }; ++ ProductMesh { ++ transmission: None, name: name.into(), ++ mesh: Arc::new(Mesh { ++ positions: vec![point(x0, 0.0), point(x1, 0.0), point(x1, 1.0), point(x0, 1.0)], ++ normals: vec![Vec3::Z; 4], triangles: vec![[0,1,2],[0,2,3]], tri_face: vec![0;2], ..Default::default() ++ }), ++ color: [0;3], opacity: 1.0, ++ surface: Some(OpaqueSurface::new(Vec3::ZERO, 0.0, 1.0, 1.5).unwrap()), ++ faces: Vec::new(), ++ } ++ }; ++ let meshes = vec![body("Partial red", 0.0, 1.0), body("Partial black", 2.0, 3.0)]; ++ let bounds = meshes.iter().fold(Aabb3::EMPTY, |bounds, body| bounds.union(&body.mesh.bounds())); ++ let options = RaytraceOptions { ++ progressive: Some(job::CpuProgressiveOptions { samples_per_pixel:samples, seed }), ++ lights: Some(Vec::new()), shadows: false, ++ emissions: Some(vec![job::SurfaceEmission { ++ body_index:0, body:"Partial red".into(), color:[1.0,0.0,0.0], strength:2.0, sides:job::EmissionSides::Both, ++ }]), ++ ..Default::default() ++ }; ++ let request = ImageRequest { ++ studio_weights:None, environment:None, textures:None, integrator:job::Integrator::Raytrace, ++ raytrace:Some(options.clone()), camera, width:4, height:1, ++ background:[10,20,30], transparent_background:false, ++ }; ++ (ProductScene { meshes, bounds }, request, options) ++} ++ ++fn partial_four_pixel_task(samples: u32, seed: u32, partial: bool) -> ImageTask { ++ let (scene, request, options) = partial_four_pixel_source(samples, seed); ++ if partial { ++ let plan = job::PartialPreviewPlan::new(4,1).unwrap(); ++ ImageTask::new_with_environment_and_nested_and_partial(scene,request,CancelToken::default(),options,None,false,plan).unwrap() ++ } else { ++ ImageTask::new(scene,request,CancelToken::default(),options).unwrap() ++ } ++} ++ ++type PartialRayLog = Vec<(usize,u32,[u64;6])>; ++fn record_partial_primary(task: &ImageTask, was_empty: bool, log: &mut PartialRayLog) { ++ if was_empty && let Some(pending) = task.pending.as_ref() { ++ let origin = pending.ray.origin(); ++ let direction = pending.ray.direction(); ++ let ordinal = task.progressive.as_ref().unwrap().film.samples(); ++ log.push((task.pixel,ordinal,[origin.x.to_bits(),origin.y.to_bits(),origin.z.to_bits(), ++ direction.x.to_bits(),direction.y.to_bits(),direction.z.to_bits()])); ++ } ++} ++fn reach_partial_frontier(task: &mut ImageTask, passes: u32, prefix: usize, rays: &mut PartialRayLog) { ++ for _ in 0..200_000 { ++ if let Some(progressive) = &task.progressive ++ && progressive.film.ready() ++ && progressive.film.partial_frontier().unwrap().completed_passes == passes ++ && progressive.film.partial_frontier().unwrap().updated_prefix == prefix ++ && task.pending.is_none() ++ { ++ return; ++ } ++ let was_empty = task.pending.is_none(); ++ assert!(matches!(task.step_with_partial_previews(1).unwrap(), PartialImagePoll::Pending(_))); ++ record_partial_primary(task,was_empty,rays); ++ } ++ panic!("real task did not reach requested committed frontier"); ++} ++fn finish_partial_snapshot(task: &mut ImageTask) -> (Vec,Vec,u32,u64) { ++ let paid = task.work.used(); ++ for _ in 0..200_000 { ++ let poll = task.step_with_partial_previews(1).unwrap(); ++ assert_eq!(task.work.used(),paid,"prepaid resolve/encode must not debit the job twice"); ++ match poll { ++ PartialImagePoll::Pending(_) => {} ++ PartialImagePoll::Preview { png,covered,completed_passes,updated_prefix } => return (png,covered,completed_passes,updated_prefix), ++ PartialImagePoll::Complete(_) => panic!("partial snapshot must not become a final frame"), ++ } ++ } ++ panic!("bounded partial snapshot did not finish"); ++} ++fn finish_partial_final(task: &mut ImageTask, partial: bool, rays: &mut PartialRayLog) -> (Vec,Vec<[u64;3]>) { ++ let target = task.options.progressive.unwrap().samples_per_pixel; ++ let mut bits = None; ++ for _ in 0..1_000_000 { ++ if bits.is_none() ++ && let Some(progressive) = &task.progressive ++ && progressive.film.ready() && progressive.film.samples() == target ++ { ++ bits = Some((0..task.request.width as usize * task.request.height as usize) ++ .map(|index| progressive.film.pixel(index).unwrap().0.map(f64::to_bits)).collect()); ++ } ++ let was_empty = task.pending.is_none(); ++ let complete = if partial { ++ match task.step_with_partial_previews(1).unwrap() { ++ PartialImagePoll::Pending(_) => None, ++ PartialImagePoll::Complete(png) => Some(png), ++ PartialImagePoll::Preview { .. } => panic!("producer created an unrequested partial snapshot"), ++ } ++ } else { ++ match task.step_with_previews(1).unwrap() { ++ ImagePoll::Pending(_) | ImagePoll::Preview { .. } => None, ++ ImagePoll::Complete(png) => Some(png), ++ } ++ }; ++ record_partial_primary(task,was_empty,rays); ++ if let Some(png) = complete { ++ return (png,bits.expect("uniform target film must exist before final resolution")); ++ } ++ } ++ panic!("partial/control final did not finish"); ++} ++ ++#[test] ++fn partial_real_film_png_distinguishes_unknown_miss_hit_and_known_black() { ++ let mut task = partial_four_pixel_task(5,123,true); ++ let plan = job::PartialPreviewPlan::new(4,1).unwrap(); ++ reach_partial_frontier(&mut task,0,2,&mut Vec::new()); ++ assert!(task.partial_preview_ready(plan).unwrap()); ++ let before = task.work.used(); ++ assert!(matches!(task.begin_partial_preview(plan).unwrap(),PartialBegin::Started)); ++ assert_eq!(task.work.used(),before+plan.snapshot_work().unwrap()); ++ let (png,covered,passes,prefix) = finish_partial_snapshot(&mut task); ++ assert_eq!((passes,prefix,task.pixel),(0,2,2)); ++ assert_eq!(covered,[1,0,0,0]); ++ let image = ::image::load_from_memory(&png).unwrap().to_rgba8(); ++ assert_eq!(image.dimensions(),(4,1)); ++ assert_eq!(image.get_pixel(0,0).0,[213,0,0,255],"linear red2 -> Reinhard2/3 -> sRGB213"); ++ assert_eq!(image.get_pixel(1,0).0,[10,20,30,255],"observed miss is the captured backplate"); ++ assert_eq!(image.get_pixel(2,0).0,[0,0,0,0]); ++ assert_eq!(image.get_pixel(3,0).0,[0,0,0,0]); ++ ++ reach_partial_frontier(&mut task,1,0,&mut Vec::new()); ++ assert!(matches!(task.begin_partial_preview(plan).unwrap(),PartialBegin::Started)); ++ let (png,covered,passes,prefix) = finish_partial_snapshot(&mut task); ++ assert_eq!((passes,prefix,task.pixel),(1,0,0),"full-pass sentinel resumes the next pass"); ++ assert_eq!(covered,[1,0,1,0]); ++ let image = ::image::load_from_memory(&png).unwrap().to_rgba8(); ++ assert_eq!(image.get_pixel(2,0).0,[0,0,0,255],"known black is opaque, not Unknown"); ++ assert_eq!(image.get_pixel(3,0).0,[10,20,30,255]); ++} ++ ++#[test] ++fn partial_snapshots_preserve_interior_cursor_absolute_rays_and_final_bits() { ++ for seed in [0,123] { ++ let mut task = partial_four_pixel_task(5,seed,true); ++ let plan = job::PartialPreviewPlan::new(4,1).unwrap(); ++ let mut actual_rays = Vec::new(); ++ for (passes,prefix) in [(0,1),(0,3),(1,0)] { ++ reach_partial_frontier(&mut task,passes,prefix,&mut actual_rays); ++ assert!(matches!(task.begin_partial_preview(plan).unwrap(),PartialBegin::Started)); ++ let _ = finish_partial_snapshot(&mut task); ++ assert_eq!(task.pixel,if prefix==0 {0}else{prefix}); ++ } ++ let actual = finish_partial_final(&mut task,true,&mut actual_rays); ++ let mut control = partial_four_pixel_task(5,seed,false); ++ let mut control_rays = Vec::new(); ++ let expected = finish_partial_final(&mut control,false,&mut control_rays); ++ assert_eq!(actual,expected,"final PNG and linear film bits must be exact"); ++ assert_eq!(actual_rays,control_rays,"snapshot timing cannot replay a camera pixel or ordinal"); ++ assert_eq!(actual_rays.len(),20); ++ } ++} ++ ++#[test] ++fn partial_work_preflight_is_optional_and_successful_debit_is_once() { ++ let plan = job::PartialPreviewPlan::new(4,1).unwrap(); ++ for enough in [false,true] { ++ let mut task = partial_four_pixel_task(5,123,true); ++ reach_partial_frontier(&mut task,0,2,&mut Vec::new()); ++ let frontier = task.progressive.as_ref().unwrap().film.partial_frontier().unwrap(); ++ let before = task.work.used(); ++ let cost = plan.snapshot_work().unwrap(); ++ task.work.limit = before+cost-u64::from(!enough); ++ if enough { ++ assert!(matches!(task.begin_partial_preview(plan).unwrap(),PartialBegin::Started)); ++ assert_eq!(task.work.used(),before+cost); ++ let _ = finish_partial_snapshot(&mut task); ++ assert_eq!(task.step_with_partial_previews(1).err().unwrap().code,ErrorCode::LimitExceeded, ++ "accepted presentation does not promise future trace headroom"); ++ } else { ++ assert!(matches!(task.begin_partial_preview(plan).unwrap(),PartialBegin::Exhausted)); ++ assert_eq!(task.work.used(),before); ++ assert_eq!(task.pixel,2); ++ assert_eq!(task.progressive.as_ref().unwrap().film.partial_frontier().unwrap(),frontier); ++ assert!(task.progressive.as_ref().unwrap().partial.is_none()); ++ assert!(task.encoder.is_none() && task.pixels.is_empty()); ++ assert!(matches!(task.step_with_partial_previews(1).unwrap(),PartialImagePoll::Pending(_))); ++ } ++ } ++} ++ ++#[test] ++fn partial_ready_requires_actual_safe_commit_plan_and_new_represented_state() { ++ let mut task = partial_four_pixel_task(5,123,true); ++ let plan = job::PartialPreviewPlan::new(4,1).unwrap(); ++ assert!(!task.partial_preview_ready(plan).unwrap()); ++ let mut observed_pending = false; ++ for _ in 0..200_000 { ++ let _ = task.step_with_partial_previews(1).unwrap(); ++ if !task.pending.is_none() { ++ assert!(!task.partial_preview_ready(plan).unwrap()); ++ let used=task.work.used(); ++ assert!(task.begin_partial_preview(plan).is_err()); ++ assert_eq!(task.work.used(),used); ++ observed_pending = true; ++ break; ++ } ++ } ++ assert!(observed_pending,"test must observe a real in-flight primary pixel"); ++ reach_partial_frontier(&mut task,0,1,&mut Vec::new()); ++ assert!(task.partial_preview_ready(job::PartialPreviewPlan::new(8,1).unwrap()).is_err()); ++ assert!(matches!(task.begin_partial_preview(plan).unwrap(),PartialBegin::Started)); ++ let _ = finish_partial_snapshot(&mut task); ++ assert!(!task.partial_preview_ready(plan).unwrap(),"same frontier cannot be a fresh snapshot"); ++ ++ use crate::film::primary::PartialFrontier; ++ let reduced = job::PartialPreviewPlan::new(4096,1).unwrap(); ++ let old = PartialFrontier { completed_passes:0, updated_prefix:1, pixels:4096 }; ++ assert!(!progressive::represented_changed(reduced,Some(old),PartialFrontier { updated_prefix:4,..old }).unwrap()); ++ assert!(progressive::represented_changed(reduced,Some(old),PartialFrontier { updated_prefix:5,..old }).unwrap()); ++} ++ ++#[test] ++fn partial_cancel_before_resolve_or_during_encoding_never_emits_payload() { ++ let plan = job::PartialPreviewPlan::new(4,1).unwrap(); ++ for during_encoding in [false,true] { ++ let mut task = partial_four_pixel_task(5,123,true); ++ reach_partial_frontier(&mut task,0,2,&mut Vec::new()); ++ assert!(matches!(task.begin_partial_preview(plan).unwrap(),PartialBegin::Started)); ++ let paid=task.work.used(); ++ if during_encoding { ++ for _ in 0..20 { ++ if task.encoder.is_some() { break } ++ assert!(matches!(task.step_with_partial_previews(1).unwrap(),PartialImagePoll::Pending(_))); ++ } ++ assert!(task.encoder.is_some()); ++ } ++ task.cancel.cancel(); ++ assert_eq!(task.step_with_partial_previews(1).err().unwrap().code,ErrorCode::Cancelled); ++ assert_eq!(task.work.used(),paid,"there is no refund or second partial-stage debit"); ++ assert!(!task.done); ++ } ++} ++ ++#[test] ++fn partial_reduced_resolve_is_bounded_by_display_cells_and_admission_is_not_legacy_prepay() { ++ let fixed=fixture(1,1,None); ++ let mut options=fixed.options.clone(); ++ options.progressive=Some(job::CpuProgressiveOptions { samples_per_pixel:5,seed:123 }); ++ let mut request=fixed.request.clone(); ++ request.width=1500; ++ request.raytrace=Some(options.clone()); ++ let plan=job::PartialPreviewPlan::new(1500,1).unwrap(); ++ let first=admit_with_partial_preview(&fixed.scene,&request,&options,false,plan).unwrap(); ++ options.progressive.as_mut().unwrap().samples_per_pixel=9; ++ request.raytrace=Some(options.clone()); ++ let second=admit_with_partial_preview(&fixed.scene,&request,&options,false,plan).unwrap(); ++ assert_eq!(first.estimated_total_bytes,second.estimated_total_bytes,"streaming reserves two slots, not every legacy power2 image"); ++ let mut task=ImageTask::new_with_environment_and_nested_and_partial( ++ fixed.scene,request,CancelToken::default(),options,None,false,plan).unwrap(); ++ reach_partial_frontier(&mut task,0,1,&mut Vec::new()); ++ assert!(matches!(task.begin_partial_preview(plan).unwrap(),PartialBegin::Started)); ++ let paid=task.work.used(); ++ let mut output=None; ++ let mut steps=0_u64; ++ for _ in 0..2000 { ++ steps+=1; ++ match task.step_with_partial_previews(1).unwrap() { ++ PartialImagePoll::Pending(_) => {} ++ PartialImagePoll::Preview { png,covered,.. } => { output=Some((png,covered)); break; } ++ PartialImagePoll::Complete(_) => panic!("display resolve cannot complete the final"), ++ } ++ assert_eq!(task.work.used(),paid); ++ } ++ let (png,covered)=output.expect("bounded reduced snapshot"); ++ assert_eq!(steps,plan.pixels()+u64::from(plan.height())+2); ++ assert_eq!(covered.len() as u64,plan.pixels()); ++ assert_eq!(::image::load_from_memory(&png).unwrap().to_rgba8().dimensions(),(1024,1)); ++ assert_eq!((task.request.width,task.request.height),(1500,1)); ++ assert_eq!(task.pixel,1); ++} ++ ++#[test] ++fn partial_area_first_pass_and_final_preserve_all_existing_emitter_sample_counts() { ++ for area_samples in [1,4,16,64] { ++ let source=progressive_area_fixture(area_samples,5,23,true); ++ let plan=job::PartialPreviewPlan::new(source.request.width,source.request.height).unwrap(); ++ let mut task=ImageTask::new_with_environment_and_nested_and_partial( ++ source.scene.clone(),source.request.clone(),CancelToken::default(),source.options.clone(),None,false,plan).unwrap(); ++ reach_partial_frontier(&mut task,1,0,&mut Vec::new()); ++ assert!(matches!(task.begin_partial_preview(plan).unwrap(),PartialBegin::Started)); ++ let (first,_,passes,prefix)=finish_partial_snapshot(&mut task); ++ assert_eq!((passes,prefix),(1,0)); ++ let (actual,_)=finish_partial_final(&mut task,true,&mut Vec::new()); ++ let (legacy_previews,expected,_)=progressive_complete(source,1); ++ assert_eq!(first,legacy_previews[0].1); ++ assert_eq!(actual,expected,"area source normalization/sampler must remain unchanged"); ++ } ++} ++ ++ ++fn partial_original_hdr() -> crate::lighting::environment_input::EnvironmentInput { ++ use crate::lighting::{HdrSource,environment_input::EnvironmentInput}; ++ let mut bytes=b"#?RADIANCE\nFORMAT=32-bit_rle_rgbe\nPRIMARIES=0.64 0.33 0.30 0.60 0.15 0.06 0.3127 0.3290\n\n-Y 2 +X 4\n".to_vec(); ++ for _ in 0..8 { bytes.extend_from_slice(&[128,128,128,129]); } ++ EnvironmentInput::new(HdrSource::new(bytes).unwrap(),0.0,1.0,4).unwrap() ++} ++ ++#[test] ++fn partial_hdr_rough_reflection_first_pass_and_final_match_legacy_sampling() { ++ let base=fixture(1,1,Some(true)); ++ let mut scene=base.scene.clone(); ++ scene.meshes[0].surface=Some(OpaqueSurface::new(Vec3::new(0.8,0.4,0.2),1.0,0.35,1.5).unwrap()); ++ let mut options=base.options.clone(); ++ options.progressive=Some(job::CpuProgressiveOptions { samples_per_pixel:5,seed:23 }); ++ let request=ImageRequest { raytrace:Some(options.clone()),..base.request.clone() }; ++ let plan=job::PartialPreviewPlan::new(request.width,request.height).unwrap(); ++ let mut task=ImageTask::new_with_environment_and_nested_and_partial( ++ scene.clone(),request.clone(),CancelToken::default(),options.clone(),Some(partial_original_hdr()),false,plan).unwrap(); ++ let control=ImageTask::new_with_environment(scene,request,CancelToken::default(),options,Some(partial_original_hdr())).unwrap(); ++ reach_partial_frontier(&mut task,1,0,&mut Vec::new()); ++ assert!(matches!(task.begin_partial_preview(plan).unwrap(),PartialBegin::Started)); ++ let (first,_,passes,prefix)=finish_partial_snapshot(&mut task); ++ assert_eq!((passes,prefix),(1,0)); ++ let (actual,_)=finish_partial_final(&mut task,true,&mut Vec::new()); ++ let (legacy_previews,expected,_)=progressive_complete(control,1); ++ assert_eq!(first,legacy_previews[0].1); ++ assert_eq!(actual,expected,"HDR and rough-reflection sample identity cannot depend on presentation"); ++}