From 5a555d4741ce97cfe3e5237cf0ae2de9ff2568d5 Mon Sep 17 00:00:00 2001 From: selune <35337584+0xlillith@users.noreply.github.com> Date: Fri, 30 Oct 2026 19:36:10 +0100 Subject: [PATCH] feat(render): preserve reviewed paused camera and Raster directional source units --- proposals/render/2026-10-30/README.md | 5 + .../2026-10-30/next-source-units/README.md | 6 + .../paused-camera-framing/README.md | 13 + .../paused-camera-framing/bindings.json | 87 ++ .../paused-camera-framing/candidate.patch | 320 +++++++ .../01-base-main.patch | 879 ++++++++++++++++++ .../02-base-mechanical-non-ui.patch | 236 +++++ .../03-base-mechanical-ui.patch | 40 + .../04-f1-test-dto-path.patch | 38 + .../05-f2-empty-capacity.patch | 54 ++ .../06-f3-borrowed-json.patch | 98 ++ .../raster-directional-consumer/README.md | 28 + .../raster-directional-consumer/bindings.json | 876 +++++++++++++++++ 13 files changed, 2680 insertions(+) create mode 100644 proposals/render/2026-10-30/next-source-units/README.md create mode 100644 proposals/render/2026-10-30/next-source-units/paused-camera-framing/README.md create mode 100644 proposals/render/2026-10-30/next-source-units/paused-camera-framing/bindings.json create mode 100644 proposals/render/2026-10-30/next-source-units/paused-camera-framing/candidate.patch create mode 100644 proposals/render/2026-10-30/next-source-units/raster-directional-consumer/01-base-main.patch create mode 100644 proposals/render/2026-10-30/next-source-units/raster-directional-consumer/02-base-mechanical-non-ui.patch create mode 100644 proposals/render/2026-10-30/next-source-units/raster-directional-consumer/03-base-mechanical-ui.patch create mode 100644 proposals/render/2026-10-30/next-source-units/raster-directional-consumer/04-f1-test-dto-path.patch create mode 100644 proposals/render/2026-10-30/next-source-units/raster-directional-consumer/05-f2-empty-capacity.patch create mode 100644 proposals/render/2026-10-30/next-source-units/raster-directional-consumer/06-f3-borrowed-json.patch create mode 100644 proposals/render/2026-10-30/next-source-units/raster-directional-consumer/README.md create mode 100644 proposals/render/2026-10-30/next-source-units/raster-directional-consumer/bindings.json diff --git a/proposals/render/2026-10-30/README.md b/proposals/render/2026-10-30/README.md index c785dd63f..7000963d6 100644 --- a/proposals/render/2026-10-30/README.md +++ b/proposals/render/2026-10-30/README.md @@ -84,3 +84,8 @@ The original 516-case core result remains bound to its exact unchanged core sour ## Progress by consolidated issue [Evidence-milestone chart for U01-U17](progress/README.md): 17 open items, partial code in12 and earlier partial native improvements in8; no item fully resolved end to end. These are milestones, not percentages of effort or an ETA. Current C16 stopped at RAM admission before any build/tests. + + +## Separate reviewed source units + +[Camera/framing and Raster directional source units](next-source-units/README.md) preserve reviewed, unrun code without adopting or combining it. Camera/framing has3 original UI cases on C16 and leaves geometry/placement/visibility identity open. Raster preserves its33-file C15 archival base plus mandatory DTO-path, empty-capacity and borrowed-JSON fixes,14 new tests and explicit current UI/W2 rebind obligations. No source review or historical C15/C16 outcome is a runtime PASS; the later W2 core-policy packet is excluded until delivered/reviewed. diff --git a/proposals/render/2026-10-30/next-source-units/README.md b/proposals/render/2026-10-30/next-source-units/README.md new file mode 100644 index 000000000..2dd4795e0 --- /dev/null +++ b/proposals/render/2026-10-30/next-source-units/README.md @@ -0,0 +1,6 @@ +# Next Render source units — separate, unintegrated work + +- [Paused camera/framing](paused-camera-framing/README.md): three files based on actual adopted C16; three new UI declarations unrun. Full same-camera geometry/placement/visibility identity remains open. +- [Raster directional consumer](raster-directional-consumer/README.md): original33-file archival C15 receiver and mandatory F1/F2/F3 corrections;14 new declarations unrun. Current C16/W1/W2 rebind, UI lighting bridge, save/EV and actual execution remain pending. + +These are **separate source units**, not one combined production candidate. Their overlapping UI bases differ. Every original patch and its dependency/RAW endpoint/EOL binding is retained; no inferred current-source combination, runtime result or readiness claim is supplied. W2's later core-policy packet was still in preparation and is deliberately excluded. diff --git a/proposals/render/2026-10-30/next-source-units/paused-camera-framing/README.md b/proposals/render/2026-10-30/next-source-units/paused-camera-framing/README.md new file mode 100644 index 000000000..0fdac8003 --- /dev/null +++ b/proposals/render/2026-10-30/next-source-units/paused-camera-framing/README.md @@ -0,0 +1,13 @@ +# Paused Interactive — camera/framing source unit + +**Unapplied, unformatted, uncompiled and unrun.** This three-file unit was independently source-reviewed (`47c6b753`); no actionable blocker was found within its narrow camera/framing scope. It is separate from the Raster unit beside it and is not a combined production candidate. + +The exact base is adopted C16 source manifest `7a30db715b0f342b37e4f5c53f7297cef1d56e22cf65a55278d6e14fd46cc852`, reconstructed through [C16's source lineage](../../c16-defaults-auto-result/README.md). `candidate.patch` and `bindings.json` retain the exact three-file before/candidate hashes, sizes and LF endpoint policy. Verify that base; do not apply over arbitrary newer source, a future formatter stage or the Raster UI candidate without explicit rebind. + +The accepted real ImageRequest supplies Cached.camera in both validated PNG and partial paths. Geometry input is blocked only when currently paintable Interactive pixels disagree with the complete current camera or authored aspect. Paused reference pixels remain visible. Picking uses the same painted-image rectangle, excluding letterbox margins; shared navigation, release/Escape cleanup, current JobId/ticket checks, final/export authority and the earlier Unknown policy remain. It does not restore an old camera or globally prohibit useful same-camera appearance editing. + +Three original declarations append to the exact552355-byte UI255 prefix, producing UI258: real native-host Pause/pan/release against retained pixels, successive same-camera appearance assignments with letterbox exclusion, and drag release after authored-aspect change. They are **unrun in-process host/input tests**, not human mouse/keyboard evidence. An unsupported-host refusal branch cannot qualify CPU rendering. Partial camera assignment has source inspection only; no new hostile/concurrency/partial runtime qualification is claimed. + +**Not closed:** same-camera geometric model changes, placements and visibility. This unit does not prove full scene identity or close the whole paused-input issue. Separate geometry identity work remains necessary without overblocking appearance-only edits. No native layout, long-scene cadence, quality or full-CI result follows from the source review. + +Changes a default: no. Preserve Nateaux's UI and actual contributor interfaces. Engineer must rebind/review any later shared composition; only the sole builder may run a freshly admitted source-specific validation. No C15/C16 or older PASS is inherited. Only source and curated bindings are published here, without private controls, logs or machine paths. diff --git a/proposals/render/2026-10-30/next-source-units/paused-camera-framing/bindings.json b/proposals/render/2026-10-30/next-source-units/paused-camera-framing/bindings.json new file mode 100644 index 000000000..1d7c1cefd --- /dev/null +++ b/proposals/render/2026-10-30/next-source-units/paused-camera-framing/bindings.json @@ -0,0 +1,87 @@ +{ + "schema": 1, + "status": "PRIVATE_UNIT_SOURCE_CHECKPOINT_UNAPPLIED_UNFORMATTED_UNCOMPILED_UNRUN", + "authorship": "Worker #1, SolidCraft Render team under0xlillith; independent Designer narrow source review retained.", + "base": { + "source_manifest_sha256": "7a30db715b0f342b37e4f5c53f7297cef1d56e22cf65a55278d6e14fd46cc852", + "public_source": "../../c16-defaults-auto-result/README.md", + "description": "Exact actual adopted C16 pre-format source, not latest main or Raster archival source." + }, + "original_manifest_sha256": "60f5912a2cb2182c42f066747d915eb089ef499b40a5cceff1d4224486c195a6", + "original_binding_sha256": "3b7db4abeabe06e6711dc94dcf0d953dab637bfb4e3aad87d90334615bb652df", + "independent_source_review_sha256": "47c6b7535e2ea2a29d6b4d76ad1c51759dd36d65cdb6f616d24130bc0d654e65", + "patch": { + "path": "candidate.patch", + "bytes": 17967, + "sha256": "d804f38d981dedf3235060ef7d98274ef0765bf0602bc4650e68fd70aa71f296" + }, + "files": [ + { + "path": "crates/ui-egui/src/render_workspace_interactive.rs", + "before": { + "sha256": "ca191e803c2c9dceb96e85668b5c77d31f24475e5048f573e2ca5ed75059e813", + "bytes": 49827, + "EOL": "LF", + "CRLF": 0, + "LF": 1089, + "UTF8_BOM": false + }, + "candidate": { + "sha256": "fc8d2b4d5102d81f3711c6313bbb0cdc8bca58fdc9be5b1d9874ac7fa2859513", + "bytes": 51525, + "EOL": "LF", + "CRLF": 0, + "LF": 1130, + "UTF8_BOM": false + } + }, + { + "path": "crates/ui-egui/src/render_workspace.rs", + "before": { + "sha256": "e202f6006332d21942e6bd01a4889601c77f2f1ab84039c0bc5aea2fd0cc18f0", + "bytes": 107739, + "EOL": "LF", + "CRLF": 0, + "LF": 2444, + "UTF8_BOM": false + }, + "candidate": { + "sha256": "0b0eead2ec0ee12fafbe367960b6d46be6f362637f2a3184376553c96ea16894", + "bytes": 107938, + "EOL": "LF", + "CRLF": 0, + "LF": 2446, + "UTF8_BOM": false + } + }, + { + "path": "crates/ui-egui/src/render_workspace_tests.rs", + "before": { + "sha256": "2acd261a36f2baa0acedad44eed6cf67ad7d6ee895e2197539735a266c36ed3e", + "bytes": 552355, + "EOL": "LF", + "CRLF": 0, + "LF": 10169, + "UTF8_BOM": false + }, + "candidate": { + "sha256": "b38377aae33c2e933b81ac438f466ca80a148acacc5e5fe0e9c08156749d4bef", + "bytes": 562679, + "EOL": "LF", + "CRLF": 0, + "LF": 10343, + "UTF8_BOM": false + } + } + ], + "EOL_policy": "Original patch bytes are retained. For exact reconstruction, verify RAW preimage SHA, normalize only physical CRLF to LF where required for text-hunk replay, restore each declared endpoint EOL, and verify the exact RAW candidate SHA. No fuzzy whitespace or universal literal RAW replay claim.", + "UI_declarations": { + "before": 255, + "candidate": 258, + "added_unrun": 3 + }, + "original_UI255_RAW_prefix_bytes_preserved": 552355, + "full_scene_geometry_placement_visibility_identity_closed": false, + "Changes a default": "no", + "source_adopted_or_executed": false +} diff --git a/proposals/render/2026-10-30/next-source-units/paused-camera-framing/candidate.patch b/proposals/render/2026-10-30/next-source-units/paused-camera-framing/candidate.patch new file mode 100644 index 000000000..41d4b5829 --- /dev/null +++ b/proposals/render/2026-10-30/next-source-units/paused-camera-framing/candidate.patch @@ -0,0 +1,320 @@ +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 +@@ -240,6 +240,8 @@ + samples: u32, + partial: Option, + final_dimensions: [u32; 2], ++ // Accepted job camera, never the latest observed intent after Pause. ++ camera: solidcraft_engine::render::Camera, + stale: bool, + texture: Result, + } +@@ -565,6 +567,7 @@ + samples: 0, + partial: Some(sampling), + final_dimensions, ++ camera: request.camera, + stale: false, + texture: Ok(texture), + }); +@@ -611,6 +614,7 @@ + samples, + partial: None, + final_dimensions: self.issued_dimensions.ok_or_else(|| crate::i18n::tr("render.error_provisional_identity").to_string())?, ++ camera: request.camera, + stale: false, + texture, + }); +@@ -799,18 +803,56 @@ + } + } + ++fn input_frame(app: &SolveApp) -> Option<&Cached> { ++ let state = &app.render_workspace.interactive; ++ (super::active(app) ++ && app.render_workspace.view.method == ImageMethod::CpuRaytrace ++ && !app.render_workspace.view.result ++ && state.context.as_ref().is_some_and(|context| context.is_current(&app.session))) ++ .then_some(state.frame.as_ref()) ++ .flatten() ++} ++ ++/// Match accepted camera and authored aspect without using the latest visual ++/// revision: a paused appearance/light edit alone need not move geometry targets. ++fn camera_framing_matches(app: &SolveApp, frame: &Cached) -> bool { ++ let [width, height] = frame.final_dimensions; ++ let draft = &app.render_workspace.view.draft; ++ frame.camera == app.cam ++ && width != 0 ++ && height != 0 ++ && draft.width != 0 ++ && draft.height != 0 ++ && u64::from(width) * u64::from(draft.height) == u64::from(height) * u64::from(draft.width) ++} ++ + pub(super) fn blocks_geometry_input(app: &SolveApp) -> bool { + awaiting_current_frame(app) +- || (super::active(app) +- && app.render_workspace.view.method == ImageMethod::CpuRaytrace +- && !app.render_workspace.view.result +- && app.render_workspace.interactive.context.as_ref().is_some_and(|context| context.is_current(&app.session)) +- && app.render_workspace.interactive.frame.as_ref().is_some_and(|frame| { +- frame_visibility(&app.render_workspace.interactive, frame) +- .blocks_unknown(frame.partial.is_some_and(|sampling| sampling.source_unknown())) +- })) ++ || input_frame(app).is_some_and(|frame| { ++ let visibility = frame_visibility(&app.render_workspace.interactive, frame); ++ visibility.blocks_unknown(frame.partial.is_some_and(|sampling| sampling.source_unknown())) ++ || (visibility.paintable() && !camera_framing_matches(app, frame)) ++ }) + } + ++/// Use exactly the painted pixel rectangle for CAD projection and pointer bounds. ++/// Shared navigation keeps its existing viewport; no cached camera is installed. ++pub(super) fn geometry_input_rect(app: &SolveApp, rect: egui::Rect) -> egui::Rect { ++ input_frame(app) ++ .filter(|frame| frame_visibility(&app.render_workspace.interactive, frame).paintable()) ++ .and_then(|frame| pixel_rect(&frame.info, rect)) ++ .unwrap_or(rect) ++} ++ ++fn pixel_rect(info: &FrameInfo, rect: egui::Rect) -> Option { ++ if info.width == 0 || info.height == 0 || !rect.is_finite() || !rect.is_positive() { ++ return None; ++ } ++ let scale = (rect.width() / info.width as f32).min(rect.height() / info.height as f32); ++ let target = egui::Rect::from_center_size(rect.center(), egui::vec2(info.width as f32, info.height as f32) * scale); ++ (target.is_finite() && target.is_positive()).then_some(target) ++} ++ + fn paint_unknown_underlay(ui: &egui::Ui, rect: egui::Rect) { + let tokens = Tokens::get(); + let painter = ui.painter().with_clip_rect(rect); +@@ -834,8 +876,7 @@ + return false; + } + let Ok(texture) = &frame.texture else { return false }; +- let scale = (rect.width() / frame.info.width as f32).min(rect.height() / frame.info.height as f32); +- let target = egui::Rect::from_center_size(rect.center(), egui::vec2(frame.info.width as f32, frame.info.height as f32) * scale); ++ let Some(target) = pixel_rect(&frame.info, rect) else { return false }; + if frame.partial.is_some_and(|sampling| sampling.source_unknown()) { + paint_unknown_underlay(ui, target); + } +diff --git a/crates/ui-egui/src/render_workspace.rs b/crates/ui-egui/src/render_workspace.rs +--- a/crates/ui-egui/src/render_workspace.rs ++++ b/crates/ui-egui/src/render_workspace.rs +@@ -2170,6 +2170,8 @@ + // any geometry interaction, and observe again below after visible UI actions. + interactive::before_paint(app, ui.ctx()); + let waiting = interactive::blocks_geometry_input(app); ++ let geometry_rect = interactive::geometry_input_rect(app, rect); ++ let geometry_inside = input.inside && input.hover.is_some_and(|pos| geometry_rect.contains(pos)); + let navigating = input.scroll != 0.0 + || input.pinch != 1.0 + || input.pan != egui::Vec2::ZERO +@@ -2182,17 +2184,17 @@ + || app.cam_anim.is_some(); + let hits = input + .hover +- .filter(|_| input.inside && !navigating && !waiting) +- .map(|p| crate::viewport::pick_cached(app, &crate::viewport::projection(app, rect), p)) ++ .filter(|_| geometry_inside && !navigating && !waiting) ++ .map(|p| crate::viewport::pick_cached(app, &crate::viewport::projection(app, geometry_rect), p)) + .unwrap_or_default(); + let candidate = assign::candidate(app, &hits, input.mods); + app.viewport.hover = candidate.as_ref().map(|(hit, _)| hit.clone()); +- // No target or inside flag while blank; still drain drag release / Escape. +- let assigning = assign::input(app, ui, &response, candidate.as_ref(), input.inside && !navigating && !waiting); +- if !waiting && !assigning && input.inside && !navigating { ++ // No target while blank or misaligned; still drain drag release / Escape. ++ let assigning = assign::input(app, ui, &response, candidate.as_ref(), geometry_inside && !navigating && !waiting); ++ if !waiting && !assigning && geometry_inside && !navigating { + assign::hover_tooltip(app, &response, candidate.as_ref()); + } +- if !waiting && !assigning && response.clicked_by(egui::PointerButton::Primary) && input.inside && !navigating { ++ if !waiting && !assigning && response.clicked_by(egui::PointerButton::Primary) && geometry_inside && !navigating { + let (add, toggle) = crate::tool_modifiers::selection_click( + crate::tool_modifiers::Held::from_modifiers(input.mods), + app.preferences.selection_shift_add_only, +diff --git a/crates/ui-egui/src/render_workspace_tests.rs b/crates/ui-egui/src/render_workspace_tests.rs +--- a/crates/ui-egui/src/render_workspace_tests.rs ++++ b/crates/ui-egui/src/render_workspace_tests.rs +@@ -10167,3 +10167,177 @@ + assert_eq!(h.app.session.undo.len(), undo); + } + } ++ ++ ++// Original F1 regressions: real native accepted pixels, no injected cache/frame. ++// This first alignment block covers accepted camera and framing, not a new ++// proof of all possible scene/placement/visibility changes. ++#[cfg(not(target_arch = "wasm32"))] ++#[test] ++fn paused_known_image_after_finished_pan_blocks_current_camera_targets_but_keeps_navigation_and_escape() { ++ let Some((mut h, mut time, at)) = ++ interactive_canvas_input_fixture("paused_known_image_after_finished_pan_blocks_current_camera_targets_but_keeps_navigation_and_escape") ++ else { ++ return; ++ }; ++ h.app.run("render.interactive", json!({"action":"on"})).unwrap(); ++ let job = interactive_recovery_require_success(&mut h, time + 0.3, time + 0.4); ++ time += 0.4; ++ let handle = interactive::test_current(&h.app).unwrap().unwrap(); ++ let (accepted, samples, complete, texture) = interactive::test_cache(&h.app).unwrap(); ++ assert_eq!((accepted.job, samples, complete), (job, 16, true)); ++ h.app.run("render.interactive", json!({"action":"pause"})).unwrap(); ++ assert!(!interactive::blocks_geometry_input(&h.app)); ++ let camera = h.app.cam; ++ let document = h.app.session.doc.clone(); ++ let undo = h.app.session.undo.len(); ++ let end = at + egui::vec2(28.0, 12.0); ++ interactive_canvas_input_frame( ++ &mut h, ++ &mut time, ++ vec![ ++ egui::Event::PointerMoved(at), ++ egui::Event::PointerButton { pos: at, button: egui::PointerButton::Middle, pressed: true, modifiers: egui::Modifiers::NONE }, ++ ], ++ ); ++ interactive_canvas_input_frame(&mut h, &mut time, vec![egui::Event::PointerMoved(end)]); ++ interactive_canvas_input_frame( ++ &mut h, ++ &mut time, ++ vec![egui::Event::PointerButton { pos: end, button: egui::PointerButton::Middle, pressed: false, modifiers: egui::Modifiers::NONE }], ++ ); ++ interactive_canvas_input_frame(&mut h, &mut time, vec![]); ++ assert_ne!(h.app.cam.target, camera.target, "the real shared middle-pan must have moved the camera"); ++ assert_eq!(interactive::inspect(&h.app)["phase"], "Paused"); ++ assert_eq!(interactive::inspect(&h.app)["stale"], true); ++ assert!(!interactive::awaiting_current_frame(&h.app), "this is known paused evidence, not the existing blank/Unknown guard"); ++ assert!(interactive::blocks_geometry_input(&h.app)); ++ let viewport = h.app.viewport.rect.unwrap(); ++ let geometry_rect = interactive::geometry_input_rect(&h.app, viewport); ++ let projection = crate::viewport::projection(&h.app, geometry_rect); ++ let current_hit = projection.to_screen(camera.target).unwrap(); ++ assert!(geometry_rect.contains(current_hit)); ++ assert!(crate::viewport::pick(&h.app, &projection, current_hit).iter().any(|hit| { ++ matches!(hit, crate::viewport::Hit::Face { body, .. } if body == "Subject") ++ }), "prove there really is a current-camera target for the new guard to reject"); ++ interactive_canvas_input_click(&mut h, &mut time, current_hit, egui::PointerButton::Primary, egui::Modifiers::NONE); ++ assert!(h.app.viewport.hover.is_none() && h.app.session.selection.is_empty()); ++ interactive_canvas_input_click(&mut h, &mut time, current_hit, egui::PointerButton::Secondary, egui::Modifiers::NONE); ++ assert!(h.app.viewport.context_menu.is_none()); ++ assign::arm(&mut h.app, json!({"appearance":"ABS - Red"})).unwrap(); ++ interactive_canvas_input_click(&mut h, &mut time, current_hit, egui::PointerButton::Primary, egui::Modifiers::NONE); ++ assert_eq!(h.app.session.undo.len(), undo); ++ assert!(Arc::ptr_eq(&document, &h.app.session.doc)); ++ interactive_canvas_input_frame( ++ &mut h, ++ &mut time, ++ vec![egui::Event::Key { key: egui::Key::Escape, physical_key: None, pressed: true, repeat: false, modifiers: egui::Modifiers::NONE }], ++ ); ++ assert!(!h.app.render_workspace.view.assign.painting && !h.app.render_workspace.view.assign.sampling); ++ let (retained, retained_samples, retained_complete, retained_texture) = interactive::test_cache(&h.app).unwrap(); ++ assert_eq!((retained.job, retained.png_sha256, retained_samples, retained_complete, retained_texture), ++ (job, accepted.png_sha256, samples, complete, texture)); ++ let (mut output, painted) = interactive_acceptance_frame(&mut h, time + 0.01, false, true); ++ assert!(painted, "the retained image stays visible as a reference"); ++ output.textures_delta.clear(); ++ assert!(!h.app.render_workspace.interactive.pending()); ++ interactive_assert_final_export_isolation(&mut h, &handle); ++ h.app.run("render.interactive", json!({"action":"off"})).unwrap(); ++ assert!(!interactive::blocks_geometry_input(&h.app)); ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++#[test] ++fn paused_aligned_known_image_supports_repeated_material_edits_and_uses_its_painted_rectangle() { ++ let Some((mut h, mut time, at)) = ++ interactive_canvas_input_fixture("paused_aligned_known_image_supports_repeated_material_edits_and_uses_its_painted_rectangle") ++ else { ++ return; ++ }; ++ h.app.run("render.interactive", json!({"action":"on"})).unwrap(); ++ let job = interactive_recovery_require_success(&mut h, time + 0.3, time + 0.4); ++ time += 0.4; ++ h.app.run("render.interactive", json!({"action":"pause"})).unwrap(); ++ let camera = h.app.cam; ++ let viewport = h.app.viewport.rect.unwrap(); ++ let pixels = interactive::geometry_input_rect(&h.app, viewport); ++ assert!(pixels.width() < viewport.width(), "the original square image is letterboxed in this landscape viewport"); ++ assert!((pixels.width() - pixels.height()).abs() <= f32::EPSILON * pixels.height().max(1.0)); ++ let undo = h.app.session.undo.len(); ++ for (index, name) in ["ABS - Blue", "ABS - Red"].into_iter().enumerate() { ++ assert!(!interactive::blocks_geometry_input(&h.app), "Pause alone and an earlier appearance edit cannot block aligned input"); ++ assign::arm(&mut h.app, json!({"appearance":name})).unwrap(); ++ interactive_canvas_input_click(&mut h, &mut time, at, egui::PointerButton::Primary, egui::Modifiers::NONE); ++ assert_eq!(h.app.session.undo.len(), undo + index + 1); ++ assert_eq!(h.app.session.doc.appearances.bodies["Subject"].name, name); ++ assert_eq!(h.app.cam, camera); ++ assert_eq!(interactive::inspect(&h.app)["phase"], "Paused"); ++ assert_eq!(interactive::inspect(&h.app)["stale"], true); ++ assert_eq!(interactive::test_cache(&h.app).unwrap().0.job, job); ++ assert!(!interactive::blocks_geometry_input(&h.app)); ++ } ++ assign::stop(&mut h.app); ++ let selection = h.app.session.selection.clone(); ++ let outside_pixels = egui::pos2(viewport.left() + 1.0, viewport.center().y); ++ assert!(!pixels.contains(outside_pixels)); ++ interactive_canvas_input_click(&mut h, &mut time, outside_pixels, egui::PointerButton::Primary, egui::Modifiers::NONE); ++ assert!(h.app.viewport.hover.is_none()); ++ assert_eq!(h.app.session.selection, selection, "letterbox margins are not pixel-aligned CAD targets"); ++ assert!(!h.app.render_workspace.interactive.pending()); ++ h.app.run("render.interactive", json!({"action":"off"})).unwrap(); ++} ++ ++#[cfg(not(target_arch = "wasm32"))] ++#[test] ++fn paused_known_image_rejects_authored_aspect_change_without_blanket_pause_or_final_gate() { ++ let Some((mut h, mut time, at)) = ++ interactive_canvas_input_fixture("paused_known_image_rejects_authored_aspect_change_without_blanket_pause_or_final_gate") ++ else { ++ return; ++ }; ++ h.app.run("render.interactive", json!({"action":"on"})).unwrap(); ++ let job = interactive_recovery_require_success(&mut h, time + 0.3, time + 0.4); ++ time += 0.4; ++ h.app.run("render.interactive", json!({"action":"pause"})).unwrap(); ++ let camera = h.app.cam; ++ let width = h.app.render_workspace.view.draft.width; ++ assert!(!interactive::blocks_geometry_input(&h.app)); ++ let document = h.app.session.doc.clone(); ++ let revision = h.app.session.revision; ++ let undo = h.app.session.undo.len(); ++ assign::tile(&mut h.app, json!({"appearance":"ABS - Red"}), true).unwrap(); ++ interactive_canvas_input_frame( ++ &mut h, ++ &mut time, ++ vec![egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed: true, modifiers: egui::Modifiers::NONE }], ++ ); ++ assert!(assign::preview(&h.app).is_some(), "start a real drag against aligned accepted pixels"); ++ h.app.render_workspace.view.draft.width = width * 2; ++ interactive_canvas_input_frame(&mut h, &mut time, vec![]); ++ assert_eq!(h.app.cam, camera); ++ assert!(interactive::blocks_geometry_input(&h.app)); ++ assert!(!interactive::awaiting_current_frame(&h.app)); ++ assert_eq!(interactive::test_cache(&h.app).unwrap().0.job, job); ++ interactive_canvas_input_frame( ++ &mut h, ++ &mut time, ++ vec![egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed: false, modifiers: egui::Modifiers::NONE }], ++ ); ++ assert!(assign::preview(&h.app).is_none() && assign::hover(&h.app).is_none()); ++ assert!(!assign::cancel(&mut h.app), "the blocked release must drain the real drag"); ++ assert!(Arc::ptr_eq(&document, &h.app.session.doc)); ++ assert_eq!((h.app.session.revision, h.app.session.undo.len()), (revision, undo), ++ "the guard must stop a framing-only drag without relying on the document revision guard"); ++ h.app.render_workspace.view.draft.width = width; ++ interactive_canvas_input_frame(&mut h, &mut time, vec![]); ++ assert!(!interactive::blocks_geometry_input(&h.app), "restoring the accepted aspect restores aligned same-camera input"); ++ h.app.run("render.result.view", json!({"view":"image"})).unwrap(); ++ assert!(!interactive::blocks_geometry_input(&h.app), "the manual Result path owns its own camera and input policy"); ++ h.app.run("render.result.view", json!({"view":"model"})).unwrap(); ++ h.app.run("render.interactive", json!({"action":"resume"})).unwrap(); ++ interactive_canvas_input_frame(&mut h, &mut time, vec![]); ++ assert!(interactive::test_cache(&h.app).is_none()); ++ assert!(interactive::awaiting_current_frame(&h.app) && interactive::blocks_geometry_input(&h.app)); ++ h.app.run("render.interactive", json!({"action":"off"})).unwrap(); ++ assert!(!interactive::blocks_geometry_input(&h.app)); ++} diff --git a/proposals/render/2026-10-30/next-source-units/raster-directional-consumer/01-base-main.patch b/proposals/render/2026-10-30/next-source-units/raster-directional-consumer/01-base-main.patch new file mode 100644 index 000000000..5475e8924 --- /dev/null +++ b/proposals/render/2026-10-30/next-source-units/raster-directional-consumer/01-base-main.patch @@ -0,0 +1,879 @@ +--- a/crates/engine/src/cmd/render.rs ++++ b/crates/engine/src/cmd/render.rs +@@ -124,7 +124,7 @@ + CommandSpec::new("render.settings.capture_hdr", "Save Render Settings with HDR", resources::capture_settings).icon("settings").doc_only() + .params("name, set: typed CPU/GPU setup patch with hdr/environment unset; path: scoped HDR; expected_sha256?: digest returned by render.hdr.inspect (changed sources refuse); rotation_rad?:0, intensity?:1; samples?:1/4/16/64 for CPU only (default16); assume_linear_srgb?:false for GPU only. Captures immutable bytes and saves resource plus setup atomically in one undo, without a host; returns name/setup/resource metadata, never source bytes"), + CommandSpec::new("render.preflight", "Check Render Request", jobs::preflight).icon("inspect").noundo().doc_only() +- .params("setup?: saved name OR settings?: full RenderSetup. A typed job selects raster/cpu_raytrace/gpu_path and its numerical options plus embedded HDR before dispatch; only replace, transient studio_weights and progressive_feedback may accompany it. progressive_feedback?: false; transient protected display updates during CPU progressive rendering only; true refuses raster, GPU and fixed CPU requests. Omission preserves legacy admission/submission. Without job, the legacy runtime controls below remain available. See docs/render-settings.md. studio_weights?: three finite 0..1 visibility weights for raster or implicit GPU studio sources only; never saved. integrator?: raster (default) or raytrace; progressive?: false (registered GPU path, CPU integrator/LED options are mutually exclusive); samples?: 1..4096; max_depth?: 1..16; seed?: u32 for progressive; raytrace?: bounded runtime progressive/primary_samples/lights/punctual_lights/area_lights/area_samples/seed/exposure_ev/shadows/reflections/anisotropic_faces/emissions/surface_effects/dielectrics/environment options, only with raytrace. CPU raytrace.budget?: compact (legacy default), studio or workstation; see docs/render-cpu-resource-profiles.md for explicit image/geometry/memory/work limits. CPU raytrace.progressive?: {samples_per_pixel:1..profile limit, seed:u32}; requires primary_samples:1 and selected reflections.samples:1; bounded area/LED direct lights retain their existing source and emitter-sample limits; anisotropy requires fixed sampling; certified smooth thin-sheet/box dielectrics support fixed or progressive sampling under the same certificates and bounded optical transport. See docs/render-cpu-progressive.md; environment?: {path: scoped HDR, expected_sha256?: inspected digest, rotation_radians: 0, intensity: 1, samples: 16} OR {resource: saved HDR digest, rotation_radians, intensity, samples}; embedded resources cannot combine with path/hash; explicit sRGB/D65 HDR primaries required. Opaque CPU preview with selected mirror/rough-specular reflections and certified planar anisotropy. HDR with rough reflections or anisotropy requires fully metallic selected bodies and all effective faces; unsupported combinations refuse. No MIS or GI. CPU runtime dielectrics support only certified thin_sheet/closed_box boundaries with explicit IOR and Beer absorption. nested_media?: false is the existing JobOptions opt-in; fixed or progressive CPU images admit only strictly nested certified closed_box boundaries with an exterior camera, while touching/partial overlaps, sheets within volumes and clearcoat combinations refuse. Other nondefault JobOptions remain unsupported on CPU; progressive/Interactive optics retain primary_samples:1 and selected reflections.samples:1 limits and never drop unsupported intent. GPU progressive uses the same nested_media field with its own certified-media contract; see docs/render-raytrace-dielectrics.md. CPU emissions are visible radiance only; surface_effects change roughness/shading normals without geometry changes. led_strip?: continuous world-mm LED rectangle recipe; led_samples?: 1/4/16/64 for the whole strip, default16. At most8directional+8punctual+4rectangle/LED sources; shared area N. See docs/render-light-union.md. transparent_background?: false; replace?: false. With progressive:true, raytrace instead accepts GPU dielectrics/clear_coats/textures; environment instead accepts tagged hdr/embedded_hdr/sky with rotation_rad/intensity; file hdr supports expected_sha256, embedded_hdr uses a document resource digest. See docs/render-hdr-resources.md. GPU lens, studio lighting, tone_map, denoise, bounded finishing/backdrop and linear_exr retention are also available. GPU adaptive?: {pilot_samples:16..256,min_samples:16..samples,relative_error:0..1,absolute_error:0.000001..1000000,coverage_error:0.001..0.25} allocates independent production budgets; pilots are discarded, not a certified error guarantee. transmission_samples?:1|2|4 stratifies the first Fresnel branch with extra path cost. volume?:{min_mm:[x,y,z],max_mm:[x,y,z],extinction_per_mm:0..1000,scattering_albedo:[r,g,b],anisotropy:-0.95..0.95} is one finite homogeneous world-mm medium; active media require explicit lighting/environment and refuse glass, denoise and multiple transmission strata. These fields also persist in GPU job.options. See docs/render-materials/TRANSPORT-MASTER-BATCH-2026-10-23.md; see docs/render-transmission.md, render-environment.md, render-runtime-textures.md, render-thin-lens.md, render-studio-lighting.md and render-denoise.md. Optional CPU raytracing requires a raytrace-cpu build and native host, checked before scene capture. Stale geometry is rejected. See docs/render-jobs.md"), ++ .params("setup?: saved name OR settings?: full RenderSetup. A typed job selects raster/cpu_raytrace/gpu_path and its numerical options plus embedded HDR before dispatch; only replace, transient studio_weights, raster_lights and progressive_feedback may accompany it. raster_lights?: transient null (legacy studio) or 0..8 directional sources {direction:[x,y,z],color:[linear r,g,b],intensity:0..64}; empty array is dark direct lighting. Requires builtin Raster without studio_weights, raytrace, HDR, transmission, exposure or other method controls. Directions are finite/nonzero and bounded by 1e9; RGB is 0..1. Not saved; no shadows or physical glass. progressive_feedback?: false; transient protected display updates during CPU progressive rendering only; true refuses raster, GPU and fixed CPU requests. Omission preserves legacy admission/submission. Without job, the legacy runtime controls below remain available. See docs/render-settings.md. studio_weights?: three finite 0..1 visibility weights for raster or implicit GPU studio sources only; never saved. integrator?: raster (default) or raytrace; progressive?: false (registered GPU path, CPU integrator/LED options are mutually exclusive); samples?: 1..4096; max_depth?: 1..16; seed?: u32 for progressive; raytrace?: bounded runtime progressive/primary_samples/lights/punctual_lights/area_lights/area_samples/seed/exposure_ev/shadows/reflections/anisotropic_faces/emissions/surface_effects/dielectrics/environment options, only with raytrace. CPU raytrace.budget?: compact (legacy default), studio or workstation; see docs/render-cpu-resource-profiles.md for explicit image/geometry/memory/work limits. CPU raytrace.progressive?: {samples_per_pixel:1..profile limit, seed:u32}; requires primary_samples:1 and selected reflections.samples:1; bounded area/LED direct lights retain their existing source and emitter-sample limits; anisotropy requires fixed sampling; certified smooth thin-sheet/box dielectrics support fixed or progressive sampling under the same certificates and bounded optical transport. See docs/render-cpu-progressive.md; environment?: {path: scoped HDR, expected_sha256?: inspected digest, rotation_radians: 0, intensity: 1, samples: 16} OR {resource: saved HDR digest, rotation_radians, intensity, samples}; embedded resources cannot combine with path/hash; explicit sRGB/D65 HDR primaries required. Opaque CPU preview with selected mirror/rough-specular reflections and certified planar anisotropy. HDR with rough reflections or anisotropy requires fully metallic selected bodies and all effective faces; unsupported combinations refuse. No MIS or GI. CPU runtime dielectrics support only certified thin_sheet/closed_box boundaries with explicit IOR and Beer absorption. nested_media?: false is the existing JobOptions opt-in; fixed or progressive CPU images admit only strictly nested certified closed_box boundaries with an exterior camera, while touching/partial overlaps, sheets within volumes and clearcoat combinations refuse. Other nondefault JobOptions remain unsupported on CPU; progressive/Interactive optics retain primary_samples:1 and selected reflections.samples:1 limits and never drop unsupported intent. GPU progressive uses the same nested_media field with its own certified-media contract; see docs/render-raytrace-dielectrics.md. CPU emissions are visible radiance only; surface_effects change roughness/shading normals without geometry changes. led_strip?: continuous world-mm LED rectangle recipe; led_samples?: 1/4/16/64 for the whole strip, default16. At most8directional+8punctual+4rectangle/LED sources; shared area N. See docs/render-light-union.md. transparent_background?: false; replace?: false. With progressive:true, raytrace instead accepts GPU dielectrics/clear_coats/textures; environment instead accepts tagged hdr/embedded_hdr/sky with rotation_rad/intensity; file hdr supports expected_sha256, embedded_hdr uses a document resource digest. See docs/render-hdr-resources.md. GPU lens, studio lighting, tone_map, denoise, bounded finishing/backdrop and linear_exr retention are also available. GPU adaptive?: {pilot_samples:16..256,min_samples:16..samples,relative_error:0..1,absolute_error:0.000001..1000000,coverage_error:0.001..0.25} allocates independent production budgets; pilots are discarded, not a certified error guarantee. transmission_samples?:1|2|4 stratifies the first Fresnel branch with extra path cost. volume?:{min_mm:[x,y,z],max_mm:[x,y,z],extinction_per_mm:0..1000,scattering_albedo:[r,g,b],anisotropy:-0.95..0.95} is one finite homogeneous world-mm medium; active media require explicit lighting/environment and refuse glass, denoise and multiple transmission strata. These fields also persist in GPU job.options. See docs/render-materials/TRANSPORT-MASTER-BATCH-2026-10-23.md; see docs/render-transmission.md, render-environment.md, render-runtime-textures.md, render-thin-lens.md, render-studio-lighting.md and render-denoise.md. Optional CPU raytracing requires a raytrace-cpu build and native host, checked before scene capture. Stale geometry is rejected. See docs/render-jobs.md"), + CommandSpec::new("render.start", "Render Image", jobs::start).key("R").noundo().doc_only().at("RENDER", "IMAGE").icon("render_image") + .params("Same request as render.preflight. Captures an immutable product scene and queues a bounded image job. Returns its session-scoped job identity, captured scene_generation and progress. Does not change the design. See docs/render-jobs.md"), + CommandSpec::new("render.status", "Render Progress", jobs::status).icon("list").noundo().doc_only() +--- a/crates/engine/src/cmd/render/job_tests.rs ++++ b/crates/engine/src/cmd/render/job_tests.rs +@@ -1,6 +1,59 @@ + use super::*; + use solidcraft_render::job::{CpuHost, JobId}; + ++#[test] ++fn transient_raster_rig_survives_saved_normalization_check_start_status_and_png() { ++ let (mut s, host) = session(); ++ s.execute("solid.box", &json!({"length":20,"width":15,"height":10})).unwrap(); ++ s.execute("render.settings.set", &json!({"name":"Rig","set":{"width":32,"height":32,"job":{"method":"raster","transparent_background":false}}})).unwrap(); ++ let doc = s.doc.clone(); ++ let before = (s.revision, s.undo.len(), s.redo.len(), s.evaluations); ++ let legacy = s.execute("render.start", &json!({"setup":"Rig"})).unwrap(); ++ let legacy_id: JobId = serde_json::from_value(legacy["job"].clone()).unwrap(); ++ finish(&host); ++ let legacy_png = s.render_job_handle(legacy_id).unwrap().frame().unwrap().unwrap().png().to_vec(); ++ for rig in [json!([]), json!([{"direction":[0,-1,1],"color":[1,0,0],"intensity":2}])] { ++ let params = json!({"setup":"Rig","raster_lights":rig}); ++ let checked = s.execute("render.preflight", ¶ms).unwrap(); ++ assert_eq!(checked["request"]["raster_lights"].as_array().unwrap().len(), params["raster_lights"].as_array().unwrap().len()); ++ assert_eq!(checked["retained_request_bytes"].as_u64().unwrap() > 0, !params["raster_lights"].as_array().unwrap().is_empty()); ++ let started = s.execute("render.start", ¶ms).unwrap(); ++ let job: JobId = serde_json::from_value(started["job"].clone()).unwrap(); ++ finish(&host); ++ let status = s.execute("render.status", &json!({"job":job})).unwrap(); ++ assert_eq!(status["request"], checked["request"]); ++ assert_eq!(status["progress"]["phase"], "completed"); ++ let handle = s.render_job_handle(job).unwrap(); ++ let frame = handle.frame().unwrap().unwrap(); ++ assert!(frame.png().starts_with(b"\x89PNG\r\n\x1a\n")); ++ assert_ne!(frame.png(), legacy_png.as_slice()); ++ assert!(Arc::ptr_eq(&doc, &s.doc)); ++ assert_eq!(before, (s.revision, s.undo.len(), s.redo.len(), s.evaluations)); ++ assert!(!s.doc.to_json().contains("raster_lights")); ++ } ++} ++ ++#[test] ++fn raster_rig_rejects_foreign_intent_and_unsupported_setup_controls_without_reserving() { ++ let (mut s, host) = session(); ++ s.execute("solid.box", &json!({"length":20,"width":15,"height":10})).unwrap(); ++ s.execute("render.preflight", &json!({"raster_lights":[]})).unwrap(); ++ let doc = s.doc.clone(); ++ for command in ["render.preflight", "render.start"] { ++ for extra in [json!({"integrator":"raytrace"}), json!({"progressive":true}), json!({"studio_weights":[1,1,1]}), ++ json!({"raytrace":{}}), json!({"nested_media":true}), json!({"progressive_feedback":true}), ++ json!({"settings":{"exposure_ev":1}}), json!({"settings":{"environment_rotation":1}})] { ++ let mut params = json!({"raster_lights":[]}); ++ for (key, value) in extra.as_object().unwrap() { ++ params[key] = value.clone(); ++ } ++ assert!(s.execute(command, ¶ms).is_err(), "{command}: {params}"); ++ assert_eq!(host.admitted_bytes(), 0); ++ assert!(Arc::ptr_eq(&doc, &s.doc)); ++ } ++ } ++} ++ + fn session() -> (Session, CpuHost) { + let host = CpuHost::cooperative(); + let mut s = Session::default(); +--- a/crates/engine/src/cmd/render/jobs.rs ++++ b/crates/engine/src/cmd/render/jobs.rs +@@ -11,6 +11,8 @@ + #[derive(Default, Deserialize)] + #[serde(default, deny_unknown_fields)] + struct Start { ++ #[serde(default, deserialize_with = "solidcraft_render::job::deserialize_raster_lights")] ++ raster_lights: Option>, + progressive_feedback: bool, + nested_media: bool, + studio_weights: Option<[f64; 3]>, +@@ -112,6 +114,9 @@ + if object.contains_key("setup") || object.contains_key("replace") { + return Err(bad(command, "Interactive requires an explicit settings snapshot without setup or replace")); + } ++ if input.raster_lights.is_some() { ++ return Err(bad(command, "Interactive does not accept explicit Raster lights")); ++ } + if input.integrator != Integrator::Raytrace || input.progressive || input.transparent_background { + return Err(bad(command, "Interactive requires opaque CPU ray tracing, not GPU progressive or raster rendering")); + } +@@ -145,7 +150,7 @@ + return Err(bad(command, "choose either captured HDR or constant CPU environment")); + } + } +- let final_request = ImageRequest { ++ let final_request = ImageRequest { raster_lights: None, + camera: settings.camera, + width: settings.width, + height: settings.height, +@@ -573,7 +578,7 @@ + } else { + return Ok(None); + }; +- if let Some(key) = object.keys().find(|key| !matches!(key.as_str(), "setup" | "settings" | "replace" | "studio_weights" | "progressive_feedback")) ++ if let Some(key) = object.keys().find(|key| !matches!(key.as_str(), "setup" | "settings" | "replace" | "studio_weights" | "progressive_feedback" | "raster_lights")) + { + return Err(bad( + command, +@@ -613,6 +618,9 @@ + } + }; + lowered["settings"] = serde_json::to_value(settings).map_err(|e| bad(command, e.to_string()))?; ++ if let Some(lights) = object.get("raster_lights") { ++ lowered["raster_lights"] = lights.clone(); ++ } + if let Some(weights) = object.get("studio_weights") { + lowered["studio_weights"] = weights.clone(); + } +@@ -658,6 +666,13 @@ + )); + } + let mut input: Start = serde_json::from_value(params.clone()).map_err(|e| bad(command, e.to_string()))?; ++ solidcraft_render::job::validate_raster_lights(&input.raster_lights).map_err(job_error)?; ++ if input.raster_lights.is_some() ++ && (input.integrator != Integrator::Raster || input.progressive || input.progressive_feedback || input.nested_media ++ || input.raytrace.is_some() || input.studio_weights.is_some() || input.environment.is_some()) ++ { ++ return Err(bad(command, "explicit Raster lights require Raster without CPU/GPU controls, environment or studio_weights")); ++ } + if input.progressive_feedback + && (input.integrator != Integrator::Raytrace || input.raytrace.as_ref().and_then(|options| options.progressive).is_none()) + { +@@ -789,6 +804,11 @@ + // (the render workspace and the other executors use them) still renders here, and the reply + // names what this render leaves out (#5089). The raytrace path takes them only through a + // saved job, so a raytrace request with them is still refused. ++ if input.raster_lights.is_some() ++ && (settings.exposure_ev != 0.0 || settings.environment_rotation != 0.0 || settings.environment_intensity != 1.0) ++ { ++ return Err(bad(command, "explicit Raster lights do not implement exposure or environment controls")); ++ } + let ignored = if input.integrator == Integrator::Raster { ignored_controls(&settings) } else { Vec::new() }; + if input.integrator != Integrator::Raster + && (settings.exposure_ev != 0.0 || settings.environment_rotation != 0.0 || settings.environment_intensity != 1.0) +@@ -828,7 +848,7 @@ + if resolved.executor != expected_executor { + return Err(bad(command, "resolved executor is not installed as an image job host")); + } +- let request = ImageRequest { ++ let request = ImageRequest { raster_lights: input.raster_lights.take(), + studio_weights: validate_studio_weights(input.studio_weights, command)?, + environment: None, + textures: None, +@@ -847,6 +867,8 @@ + host.admit(&scene, &request, options).map_err(job_error)? + }; + let retained_lights = request.raytrace.as_ref().map_or(Ok(0), |o| o.retained_bytes()).map_err(job_error)?; ++ let retained_lights = retained_lights.checked_add(request.raster_lights_retained_bytes().map_err(job_error)?) ++ .ok_or_else(|| bad(command, "retained light metadata overflow"))?; + let retained_environment = + if environment_info.is_some() { std::mem::size_of::() as u64 } else { 0 }; + let retained_request_bytes = retained_lights.checked_add(retained_environment).ok_or_else(|| bad(command, "request metadata overflow"))?; +@@ -1054,7 +1076,7 @@ + if !host.is_available() { + return Err(bad(command, "image host is unavailable")); + } +- let request = ImageRequest { ++ let request = ImageRequest { raster_lights: None, + studio_weights: validate_studio_weights(input.studio_weights, command)?, + integrator: Default::default(), + raytrace: None, +--- a/crates/gpu/src/path/mod.rs ++++ b/crates/gpu/src/path/mod.rs +@@ -318,6 +318,9 @@ + } + + fn admission(scene: &ProductScene, request: &ImageRequest, options: JobOptions) -> Result { ++ if request.raster_lights.is_some() { ++ return Err(JobError::new(ErrorCode::InvalidRequest, "GPU path rendering does not accept explicit Raster lights")); ++ } + if request.integrator != solidcraft_render::job::Integrator::Raster || request.raytrace.is_some() { + return Err(JobError::new(ErrorCode::InvalidRequest, "GPU path rendering does not accept CPU raytrace options")); + } +@@ -474,6 +477,9 @@ + Ok(value) + } + fn admit(&self, scene: &ProductScene, request: &ImageRequest, options: JobOptions) -> Result { ++ if request.raster_lights.is_some() { ++ return Err(JobError::new(ErrorCode::InvalidRequest, "GPU path rendering does not accept explicit Raster lights")); ++ } + self.context.ensure_available()?; + let a = admission(scene, request, options)?; + let limit = self.context.device.limits().max_storage_buffer_binding_size; +--- a/crates/gpu/src/path/tests.rs ++++ b/crates/gpu/src/path/tests.rs +@@ -20,7 +20,7 @@ + fn request(size: u32) -> ImageRequest { + let mut camera = Camera { distance: 4.0, ..Default::default() }; + camera.set_view(StandardView::Top); +- ImageRequest { ++ ImageRequest { raster_lights: None, + studio_weights: None, + integrator: Default::default(), + raytrace: None, +@@ -429,7 +429,7 @@ + } + let bounds = meshes.iter().fold(Aabb3::EMPTY, |a, m| a.union(&m.mesh.bounds())); + let camera = Camera { target: Vec3::new(0.0, 0.0, 1.0), yaw: -0.45, pitch: 0.5, distance: 13.0, fov: 0.65, ..Default::default() }; +- let request = ImageRequest { ++ let request = ImageRequest { raster_lights: None, + studio_weights: None, + integrator: Default::default(), + raytrace: None, +@@ -3326,3 +3326,12 @@ + let backend = session.render_backend(); + assert!(backend.executors.iter().any(|d| d.id.as_str() == "gpu-path" && matches!(d.availability, Availability::Unavailable { .. }))); + } ++#[test] ++fn direct_gpu_admission_refuses_explicit_raster_rigs_even_when_empty() { ++ let mut input = request(16); ++ input.raster_lights = Some(Vec::new()); ++ let error = admission(&sphere(white()), &input, JobOptions::default()).unwrap_err(); ++ assert_eq!(error.code, ErrorCode::InvalidRequest); ++ assert!(error.message.contains("Raster lights")); ++} ++ +--- a/crates/render/src/job/host_tests.rs ++++ b/crates/render/src/job/host_tests.rs +@@ -1,6 +1,68 @@ + use super::*; + use solidcraft_geom::{Aabb3, Mesh}; + ++#[test] ++fn raster_rig_charges_original_and_task_capacity_then_retains_record_through_eviction() { ++ let host = CpuHost::cooperative(); ++ let legacy = host.admit(&empty(), &request(), JobOptions::default()).unwrap(); ++ let mut input = request(); ++ let mut lights = Vec::with_capacity(1); ++ lights.push(super::super::DirectionalLightOptions { direction: [0.0, 0.0, 1.0], color: [1.0; 3], intensity: 2.0 }); ++ let capacity = lights.capacity(); ++ input.raster_lights = Some(lights); ++ let retained = (capacity * std::mem::size_of::()) as u64; ++ let task_fee = (8 * std::mem::size_of::()) as u64; ++ let admitted = host.admit(&empty(), &input, JobOptions::default()).unwrap(); ++ assert_eq!(admitted.estimated_total_bytes, legacy.estimated_total_bytes + task_fee); ++ let job = host.submit(id(830, 1), 1, empty(), input).unwrap(); ++ assert_eq!(host.admitted_bytes(), admitted.estimated_total_bytes + retained); ++ let status = job.status().unwrap(); ++ assert_eq!(status.request.raster_lights.as_ref().unwrap().len(), 1); ++ assert!(status.request.raster_lights.as_ref().unwrap().capacity() <= 8); ++ assert_eq!(job.0.request.raster_lights.as_ref().unwrap().capacity(), capacity); ++ // Caller-owned status metadata is outside the host lease lifetime. ++ drop(status); ++ drain(&host); ++ let held_frame = job.frame().unwrap().unwrap(); ++ job.0.data.lock().unwrap().frame = None; ++ assert!(host.admitted_bytes() > retained); ++ drop(held_frame); ++ assert_eq!(host.admitted_bytes(), retained); ++ drop(job); ++ assert_eq!(host.admitted_bytes(), 0); ++ // These counters test fees/lifetimes; declaration-order source review separately ++ // verifies request payload destruction precedes release of request credits. ++} ++ ++#[test] ++fn raster_rig_cancel_retains_only_original_request_until_last_handle() { ++ let host = CpuHost::cooperative(); ++ let mut input = request(); ++ input.raster_lights = Some(vec![super::super::DirectionalLightOptions { direction: [0.0, 0.0, 1.0], color: [1.0; 3], intensity: 2.0 }]); ++ let retained = input.raster_lights_retained_bytes().unwrap(); ++ let job = host.submit(id(831, 1), 1, empty(), input).unwrap(); ++ job.cancel().unwrap(); ++ drain(&host); ++ assert_eq!(job.status().unwrap().progress.phase, Phase::Cancelled); ++ assert_eq!(host.admitted_bytes(), retained); ++ drop(job); ++ assert_eq!(host.admitted_bytes(), 0); ++} ++ ++#[test] ++fn registered_and_interactive_routes_refuse_even_empty_raster_rigs_without_work() { ++ let (registered, _) = probe_host(1024); ++ let mut input = request(); ++ input.raster_lights = Some(Vec::new()); ++ assert_eq!(registered.admit(&empty(), &input, JobOptions::default()).unwrap_err().code, ErrorCode::InvalidRequest); ++ assert_eq!(registered.submit(id(832, 1), 1, empty(), input.clone()).err().unwrap().code, ErrorCode::InvalidRequest); ++ assert_eq!(registered.admitted_bytes(), 0); ++ assert!(!registered.pump(1).unwrap()); ++ assert!(super::super::interactive::cpu_request(&input).is_err()); ++ input.integrator = Integrator::Raytrace; ++ assert!(super::super::interactive::cpu_request(&input).is_err()); ++} ++ + mod interactive { + use super::*; + use crate::job::{RaytraceOptions, interactive::*}; +@@ -568,7 +630,7 @@ + } + + fn request() -> ImageRequest { +- ImageRequest { ++ ImageRequest { raster_lights: None, + studio_weights: None, + integrator: Default::default(), + raytrace: None, +--- a/crates/render/src/job/host.rs ++++ b/crates/render/src/job/host.rs +@@ -148,7 +148,8 @@ + + /// Retained runtime input capacities survive work/PNG eviction through status handles. + fn retained_request_bytes(request: &ImageRequest) -> Result { +- request.raytrace.as_ref().map_or(Ok(0), |options| options.retained_bytes()) ++ let existing = request.raytrace.as_ref().map_or(Ok(0), |options| options.retained_bytes())?; ++ existing.checked_add(request.raster_lights_retained_bytes()?).ok_or_else(|| JobError::new(ErrorCode::LimitExceeded, "retained request size overflow")) + } + + #[cfg(all(test, feature = "raytrace-cpu", not(target_arch = "wasm32")))] +@@ -184,7 +185,7 @@ + for _ in 0..4 { + strip.append_to(&mut options, 64)?; + } +- Ok(ImageRequest { ++ Ok(ImageRequest { raster_lights: None, + studio_weights: None, + environment: None, + textures: None, +@@ -390,10 +391,11 @@ + textures: Option, + options: JobOptions, + environment: Option, +- _request_reservation: Option, + id: JobId, + scene_generation: u64, + request: ImageRequest, ++ // Rust fields drop in declaration order: payload before its retained credits. ++ _request_reservation: Option, + resolved: crate::ResolvedRequest, + cancel: CancelToken, + data: Mutex, +@@ -433,7 +435,7 @@ + environment: self.0.environment.clone(), + job: self.0.id, + scene_generation: self.0.scene_generation, +- request: self.0.request.clone(), ++ request: self.0.request.try_clone_for_host()?, + resolved: self.0.resolved.clone(), + progress: data.progress, + error: data.error.clone(), +@@ -832,7 +834,7 @@ + } else { + WorkTask::new( + work.scene, +- work.handle.0.request.clone(), ++ work.handle.0.request.try_clone_for_host()?, + work.handle.0.cancel.clone(), + work.environment, + work.handle.0.options, +@@ -1345,6 +1347,10 @@ + options: JobOptions, + partial: Option, + ) -> Result { ++ request.validate_raster_request()?; ++ if self.0.executor.is_some() && request.raster_lights.is_some() { ++ return Err(JobError::new(ErrorCode::InvalidRequest, "registered executors do not accept explicit Raster lights")); ++ } + if let Some(policy) = partial { + let plan = policy.preview_plan(); + if self.0.executor.is_some() +@@ -1676,13 +1682,14 @@ + } + self.check_request_sum(estimated_total_bytes, request_bytes, request.cpu_budget())?; + 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(|policy| match policy { + CpuPreviewPolicy::Shared(plan) => PartialCredits::new(plan, &mut reservation), + CpuPreviewPolicy::Protected(plan) => PartialCredits::new_protected(plan, &mut reservation), + }) + .transpose()?; ++ let request_reservation = if request_bytes == 0 { None } else { Some(self.0.shared.budget.reserve(request_bytes)?) }; + // 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() { +@@ -1779,7 +1786,7 @@ + }, + ) + .map_err(|e| JobError::new(ErrorCode::InvalidRequest, e.to_string()))?; +- let request = ImageRequest { ++ let request = ImageRequest { raster_lights: None, + studio_weights: None, + width: frame.info.width, + height: frame.info.height, +@@ -2005,7 +2012,7 @@ + fn request() -> ImageRequest { + let mut lights = Vec::with_capacity(8); + lights.push(super::super::DirectionalLightOptions { direction: [0.0, 0.0, 1.0], color: [1.0; 3], intensity: 1.0 }); +- ImageRequest { ++ ImageRequest { raster_lights: None, + studio_weights: None, + environment: None, + textures: None, +@@ -2075,7 +2082,7 @@ + let expected = std::mem::size_of::() as u64; + let mut host = CpuHost::for_platform().unwrap(); + let budget = host.0.shared.budget.clone(); +- let request = ImageRequest { ++ let request = ImageRequest { raster_lights: None, + studio_weights: None, + environment: None, + textures: None, +@@ -2188,7 +2195,7 @@ + } + + fn request() -> ImageRequest { +- ImageRequest { ++ ImageRequest { raster_lights: None, + studio_weights: None, + environment: None, + textures: None, +--- a/crates/render/src/job/image_tests.rs ++++ b/crates/render/src/job/image_tests.rs +@@ -6,7 +6,7 @@ + fn request() -> ImageRequest { + let mut camera = Camera { distance: 50.0, ..Default::default() }; + camera.set_view(StandardView::Front); +- ImageRequest { ++ ImageRequest { raster_lights: None, + studio_weights: None, + environment: None, + textures: None, +@@ -388,3 +388,88 @@ + assert_eq!((image.width(), image.height()), (4, 4)); + assert_eq!(image.get_pixel(3, 3).0, [20, 40, 60, 255]); + } ++ ++ ++#[test] ++fn explicit_raster_linear_rgb_reaches_png_with_one_display_transfer() { ++ let mut part = square("matte", [0; 3], 1.0, Vec3::ZERO); ++ part.surface = Some(crate::surface::OpaqueSurface::new(Vec3::new(0.8, 0.5, 0.25), 0.0, 1.0, 1.0).unwrap()); ++ let mut input = request(); ++ // Orthographic Front is exactly normal to the square, so no perspective-view approximation. ++ assert_eq!(input.camera.fov, 0.0); ++ input.raster_lights = Some(vec![super::DirectionalLightOptions { direction: [0.0, -1.0, 0.0], color: [0.25, 0.5, 1.0], intensity: 2.0 }]); ++ let png = finish(ImageTask::new(scene(vec![part]), input, CancelToken::default()).unwrap()); ++ let image = image::load_from_memory(&png).unwrap().to_rgba8(); ++ // Independently derived: [.4,.5,.5]/pi -> Reinhard -> piecewise sRGB -> nearest byte. ++ for (x, y) in [(32, 32), (31, 32), (32, 31)] { ++ assert_eq!(image.get_pixel(x, y).0, [94, 104, 104, 255]); ++ } ++ assert_eq!(image.get_pixel(0, 0).0, [0; 4]); ++} ++ ++#[test] ++fn explicit_raster_three_four_five_cosine_reaches_png() { ++ let mut part = square("matte", [0; 3], 1.0, Vec3::ZERO); ++ part.surface = Some(crate::surface::OpaqueSurface::new(Vec3::new(0.8, 0.5, 0.25), 0.0, 1.0, 1.0).unwrap()); ++ let mut input = request(); ++ input.raster_lights = Some(vec![super::DirectionalLightOptions { direction: [3.0, -4.0, 0.0], color: [1.0; 3], intensity: 2.0 }]); ++ let png = finish(ImageTask::new(scene(vec![part]), input, CancelToken::default()).unwrap()); ++ let image = image::load_from_memory(&png).unwrap().to_rgba8(); ++ // Independently derived: [1.28,.8,.4]/pi -> Reinhard -> sRGB. ++ assert_eq!(image.get_pixel(32, 32).0, [146, 124, 94, 255]); ++} ++ ++#[test] ++fn explicit_empty_raster_rig_is_dark_while_absence_keeps_legacy() { ++ let part = scene(vec![square("part", [200, 180, 160], 1.0, Vec3::ZERO)]); ++ let mut input = request(); ++ input.transparent_background = false; ++ let absent = finish(ImageTask::new(part.clone(), input.clone(), CancelToken::default()).unwrap()); ++ let wire = serde_json::to_value(&input).unwrap(); ++ assert!(wire.get("raster_lights").is_none()); ++ let mut null = wire.clone(); ++ null["raster_lights"] = serde_json::Value::Null; ++ let legacy: ImageRequest = serde_json::from_value(null).unwrap(); ++ assert_eq!(finish(ImageTask::new(part.clone(), legacy, CancelToken::default()).unwrap()), absent); ++ input.raster_lights = Some(Vec::new()); ++ let dark = finish(ImageTask::new(part, input, CancelToken::default()).unwrap()); ++ assert_ne!(dark, absent); ++ let image = image::load_from_memory(&dark).unwrap().to_rgba8(); ++ assert_eq!(image.get_pixel(32, 32).0, [0, 0, 0, 255]); ++ assert_eq!(image.get_pixel(0, 0).0, [20, 40, 60, 255]); ++} ++ ++#[test] ++fn explicit_raster_request_rejects_capacity_conflicts_and_foreign_integrators() { ++ let part = scene(vec![square("part", [200; 3], 1.0, Vec3::ZERO)]); ++ let light = super::DirectionalLightOptions { direction: [0.0, -1.0, 0.0], color: [1.0; 3], intensity: 1.0 }; ++ let mut input = request(); ++ let mut oversized = Vec::with_capacity(9); ++ oversized.push(light); ++ input.raster_lights = Some(oversized); ++ assert_eq!(admit(&part, &input).unwrap_err().code, ErrorCode::InvalidRequest); ++ input.raster_lights = Some(Vec::new()); ++ input.studio_weights = Some([1.0; 3]); ++ assert_eq!(admit(&part, &input).unwrap_err().code, ErrorCode::InvalidRequest); ++ input.studio_weights = None; ++ input.raytrace = Some(Default::default()); ++ assert_eq!(admit(&part, &input).unwrap_err().code, ErrorCode::InvalidRequest); ++ input.raytrace = None; ++ input.integrator = super::Integrator::Raytrace; ++ assert_eq!(admit(&part, &input).unwrap_err().code, ErrorCode::InvalidRequest); ++} ++ ++#[test] ++fn explicit_raster_scalar_surrogate_preserves_straight_alpha_without_claiming_glass() { ++ let part = square("scalar", [0; 3], 0.5, Vec3::ZERO); ++ let mut input = request(); ++ input.raster_lights = Some(vec![super::DirectionalLightOptions { direction: [0.0, -1.0, 0.0], color: [1.0; 3], intensity: 2.0 }]); ++ let png = finish(ImageTask::new(scene(vec![part.clone()]), input.clone(), CancelToken::default()).unwrap()); ++ let image = image::load_from_memory(&png).unwrap().to_rgba8(); ++ // Scalar surrogate rho=0, IOR=1.5, roughness=1: F0/4pi=.01/pi. ++ // Intensity2 gives .02/pi; Reinhard + sRGB independently rounds to19. ++ assert_eq!(image.get_pixel(32, 32).0, [19, 19, 19, 128]); ++ let mut physical = part; ++ physical.transmission = Some(crate::transmission::Transmission::new(Vec3::ZERO, None).unwrap()); ++ assert_eq!(admit(&scene(vec![physical]), &input).unwrap_err().code, ErrorCode::InvalidRequest); ++} +--- a/crates/render/src/job/image.rs ++++ b/crates/render/src/job/image.rs +@@ -49,6 +49,7 @@ + /// counted even when another owner already holds them. Allocator and codec internals are estimates. + /// Includes the CPU raster work estimate and its 384 MiB per-job check. + pub fn admit(scene: &ProductScene, request: &ImageRequest) -> Result { ++ request.validate_raster_request()?; + if request.environment.is_some() || request.textures.is_some() { + return Err(JobError::new(ErrorCode::InvalidRequest, "captured GPU environments and textures require a registered image executor")); + } +@@ -79,7 +80,7 @@ + } + + pub(crate) fn admit_base(scene: &ProductScene, request: &ImageRequest) -> Result { +- admit_raster(admit_source(scene, request, MAX_TRIANGLES)?) ++ admit_raster(admit_source(scene, request, MAX_TRIANGLES)?, request) + } + + /// Common camera, dimension and source admission for registered executors, without any CPU +@@ -107,6 +108,9 @@ + /// pixel/codec allowance, then let the ray tracer charge its actual BVH and film. + #[cfg(feature = "raytrace-cpu")] + pub(crate) fn admit_raytrace_source(scene: &ProductScene, request: &ImageRequest, budget: super::CpuBudget) -> Result { ++ if request.raster_lights.is_some() { ++ return Err(invalid("explicit Raster lights cannot enter CPU ray tracing")); ++ } + budget.validate_execution()?; + budget.validate_image(request.width, request.height, request.raytrace.as_ref().and_then(|o| o.progressive))?; + let source = admit_source_with_budget(scene, request, budget.limits().max_triangles, budget)?; +@@ -162,6 +166,10 @@ + max_geometry_bytes: u64, + image_limits: crate::RenderLimits, + ) -> Result { ++ request.validate_raster_request()?; ++ if request.raster_lights.is_some() && scene.has_transmission() { ++ return Err(invalid("explicit Raster lights do not implement physical transmission")); ++ } + if !request.camera.is_valid() { + return Err(JobError::new(ErrorCode::InvalidRequest, "invalid image camera")); + } +@@ -243,14 +251,16 @@ + } + + /// The CPU raster scratch/preparation estimate and its 384 MiB per-job check. +-fn admit_raster(source: Source) -> Result { ++fn admit_raster(source: Source, request: &ImageRequest) -> Result { + let mut a = source.admission; ++ let task_light_bytes = request.raster_lights_task_bytes()?; + // Three bounded 16-byte lists, a conservative map-node allowance, and codec overhead. + let preparation = a + .triangles + .checked_mul(48) + .and_then(|n| a.face_appearances.checked_mul(160).and_then(|f| n.checked_add(f))) + .and_then(|n| n.checked_add(source.bodies * 128 + 262_144)) ++ .and_then(|n| n.checked_add(task_light_bytes)) + .ok_or_else(|| limit("work list size overflow"))?; + let total = a + .geometry_bytes +@@ -664,7 +674,7 @@ + } + let triangle = self.triangle.as_mut().ok_or_else(|| invalid("missing raster triangle"))?; + let eye = (self.request.camera.fov > 0.0).then(|| self.request.camera.eye()); +- raster_pixel(triangle, self.sw, self.back, eye, self.request.studio_weights, &mut self.pixels, &mut self.depth)?; ++ raster_pixel(triangle, self.sw, self.back, eye, self.request.studio_weights, self.request.raster_lights.as_deref(), &mut self.pixels, &mut self.depth)?; + triangle.x += 1; + if triangle.x > triangle.bounds[1] { + triangle.x = triangle.bounds[0]; +@@ -730,6 +740,7 @@ + back: Vec3, + eye: Option, + studio_weights: Option<[f64; 3]>, ++ raster_lights: Option<&[super::DirectionalLightOptions]>, + pixels: &mut [[u8; 4]], + depth: &mut [f32], + ) -> Result<()> { +@@ -765,7 +776,19 @@ + return Ok(()); + } + let n = t.normals.iter().zip(weights).fold(Vec3::ZERO, |v, (n, w)| v + *n * (w / sum)).normalized().unwrap_or(Vec3::Z); +- let colour = if let Some(surface) = t.surface { ++ let colour = if let Some(lights) = raster_lights { ++ let surface = if let Some(surface) = t.surface { ++ surface ++ } else { ++ let [r, g, b] = t.colour; ++ crate::surface::OpaqueSurface::new(Vec3::new(r, g, b), 0.0, 1.0, 1.5).map_err(|e| invalid(&e.to_string()))? ++ }; ++ let world = t.world.iter().zip(weights).fold(Vec3::ZERO, |p, (v, w)| p + *v * (w / sum)); ++ let view = eye.map_or(back, |eye| eye - world); ++ let radiance = crate::studio::shade_directional(surface, n, view, lights).map_err(|e| invalid(&e.to_string()))?; ++ let mapped = crate::studio::tone_map(radiance).map_err(|e| invalid(&e.to_string()))?; ++ [mapped.x, mapped.y, mapped.z] ++ } else if let Some(surface) = t.surface { + let world = t.world.iter().zip(weights).fold(Vec3::ZERO, |p, (v, w)| p + *v * (w / sum)); + let view = eye.map_or(back, |eye| eye - world); + let radiance = crate::studio::shade_weighted(surface, n, view, studio_weights.unwrap_or([1.0; 3])).map_err(|e| invalid(&e.to_string()))?; +--- a/crates/render/src/job/interactive.rs ++++ b/crates/render/src/job/interactive.rs +@@ -10,6 +10,7 @@ + /// Prepare a separate low-resolution request. Never edits the final request, + /// changes renderer, removes optics/lights, or promises geometry admission. + pub fn cpu_request(final_request: &ImageRequest) -> Result { ++ final_request.validate_raster_request()?; + if final_request.integrator != Integrator::Raytrace || final_request.transparent_background { + return Err(JobError::new(ErrorCode::InvalidRequest, "Interactive CPU requires opaque ray tracing")); + } +--- a/crates/render/src/job/mod.rs ++++ b/crates/render/src/job/mod.rs +@@ -32,6 +32,7 @@ + mod png; + pub mod presentation; + mod punctual; ++mod raster_lights; + mod regrade; + #[cfg(test)] + mod rt2_tests; +@@ -51,6 +52,7 @@ + pub use lighting::{AreaLight, AreaLights, MAX_AREA_LIGHTS, StudioLighting, Sun, ToneMap}; + pub use png::PngTask; + pub use punctual::{PunctualDiagnostics, PunctualLightOptions, SpotConeOptions}; ++pub use raster_lights::{deserialize as deserialize_raster_lights, validate as validate_raster_lights}; + + /// Native path-tracing ceilings, further restricted by the actual device. + /// Kept in the device-independent layer so saved intent and UI agree with execution. +@@ -1051,6 +1053,9 @@ + #[derive(Clone, Debug, Serialize, Deserialize)] + #[serde(deny_unknown_fields)] + pub struct ImageRequest { ++ /// Explicit transient opaque Raster rig; None keeps the original implicit studio. ++ #[serde(default, deserialize_with = "deserialize_raster_lights", skip_serializing_if = "Option::is_none")] ++ pub raster_lights: Option>, + /// Transient visibility of the three implicit studio lights; never saved in a design. + #[serde(default, skip_serializing_if = "Option::is_none")] + pub studio_weights: Option<[f64; 3]>, +@@ -1083,6 +1088,47 @@ + } + + impl ImageRequest { ++ /// Reject explicit Raster intent before allocating or entering another producer. ++ pub fn validate_raster_request(&self) -> Result<()> { ++ raster_lights::validate(&self.raster_lights)?; ++ if self.raster_lights.is_some() ++ && (self.integrator != Integrator::Raster || self.raytrace.is_some() || self.studio_weights.is_some() ++ || self.environment.is_some() || self.textures.is_some()) ++ { ++ return Err(JobError::new(ErrorCode::InvalidRequest, "explicit Raster lights require Raster without raytrace, GPU resources or studio_weights")); ++ } ++ Ok(()) ++ } ++ ++ pub fn raster_lights_retained_bytes(&self) -> Result { ++ raster_lights::retained_bytes(&self.raster_lights) ++ } ++ ++ pub(super) fn raster_lights_task_bytes(&self) -> Result { ++ raster_lights::task_bytes(&self.raster_lights) ++ } ++ ++ /// Internal status/task copy: the new Vec allocation is bounded and fallible. ++ pub(super) fn try_clone_for_host(&self) -> Result { ++ self.validate_raster_request()?; ++ // Preserve the old path, including existing unrelated payload semantics. ++ if self.raster_lights.is_none() { ++ return Ok(self.clone()); ++ } ++ Ok(Self { ++ raster_lights: raster_lights::try_copy(&self.raster_lights)?, ++ studio_weights: self.studio_weights, ++ environment: self.environment.clone(), ++ textures: self.textures.clone(), ++ integrator: self.integrator, ++ raytrace: None, // validated absent above, never clone-then-clear ++ camera: self.camera, ++ width: self.width, ++ height: self.height, ++ background: self.background, ++ transparent_background: self.transparent_background, ++ }) ++ } + pub fn cpu_budget(&self) -> CpuBudget { + if self.integrator == Integrator::Raytrace { + self.raytrace.as_ref().map_or(CpuBudget::Compact, |options| options.budget) +@@ -1118,6 +1164,45 @@ + } + #[cfg(test)] + mod runtime_request_roundtrip_tests { ++ ++#[test] ++fn raster_light_wire_is_nullable_bounded_strict_and_fallibly_copied() { ++ #[derive(Serialize, Deserialize)] ++ #[serde(deny_unknown_fields)] ++ struct Rig { ++ #[serde(default, deserialize_with = "super::raster_lights::deserialize", skip_serializing_if = "Option::is_none")] ++ raster_lights: Option>, ++ } ++ use serde_json::json; ++ for value in [json!({}), json!({"raster_lights":null})] { ++ let rig: Rig = serde_json::from_value(value).unwrap(); ++ assert!(rig.raster_lights.is_none()); ++ assert_eq!(serde_json::to_value(rig).unwrap(), json!({})); ++ } ++ let light = json!({"direction":[0.0,0.0,1.0],"color":[0.25,0.5,1.0],"intensity":2.0}); ++ for count in [0, 1, 8] { ++ let rig: Rig = serde_json::from_value(json!({"raster_lights":vec![light.clone();count]})).unwrap(); ++ assert_eq!(rig.raster_lights.as_ref().unwrap().len(), count); ++ assert!(rig.raster_lights.as_ref().unwrap().capacity() <= 8); ++ let copy = super::raster_lights::try_copy(&rig.raster_lights).unwrap(); ++ assert_eq!(copy, rig.raster_lights); ++ assert!(copy.as_ref().unwrap().capacity() <= 8); ++ assert_eq!(serde_json::to_value(rig).unwrap(), json!({"raster_lights":vec![light.clone();count]})); ++ } ++ assert!(serde_json::from_value::(json!({"raster_lights":vec![light.clone();9]})).is_err()); ++ for value in [json!(true), json!({}), json!([{"direction":[0,0,0],"color":[1,1,1],"intensity":0}]), ++ json!([{"direction":[0,0,1],"color":[1,1,1],"intensity":1,"shadows":true}])] { ++ assert!(serde_json::from_value::(json!({"raster_lights":value})).is_err()); ++ } ++ let mut excessive = Vec::with_capacity(9); ++ excessive.push(DirectionalLightOptions { direction: [0.0, 0.0, 1.0], color: [1.0; 3], intensity: 1.0 }); ++ assert!(super::raster_lights::try_copy(&Some(excessive)).is_err()); ++ for intensity in [f64::NAN, f64::INFINITY, -1.0, 65.0] { ++ let invalid = Some(vec![DirectionalLightOptions { direction: [0.0, 0.0, 1.0], color: [1.0; 3], intensity }]); ++ assert!(super::raster_lights::try_copy(&invalid).is_err()); ++ } ++} ++ + use super::*; + #[test] + fn default_preset_and_empty_lights_requests_roundtrip_without_invalid_null_sequence() { +--- /dev/null ++++ b/crates/render/src/job/raster_lights.rs +@@ -0,0 +1,123 @@ ++//! Bounded transient Raster input. No design persistence or implicit light conversion. ++ ++use std::fmt; ++ ++use super::{DirectionalLightOptions, ErrorCode, JobError, Result}; ++ ++const MAX_LIGHTS: usize = crate::studio::MAX_SCHEMATIC_DIRECTIONAL_LIGHTS; ++ ++fn invalid(message: &str) -> JobError { ++ JobError::new(ErrorCode::InvalidRequest, message) ++} ++ ++fn validate_light(light: &DirectionalLightOptions) -> Result<()> { ++ if !light.direction.iter().all(|v| v.is_finite() && v.abs() <= 1e9) || !light.direction.iter().any(|v| *v != 0.0) { ++ return Err(invalid("Raster light direction must be finite, nonzero and bounded by 1e9")); ++ } ++ if !light.color.iter().all(|v| v.is_finite() && (0.0..=1.0).contains(v)) ++ || !light.intensity.is_finite() ++ || !(0.0..=64.0).contains(&light.intensity) ++ { ++ return Err(invalid("Raster light requires linear RGB in 0..1 and intensity in 0..64")); ++ } ++ Ok(()) ++} ++ ++pub fn validate(lights: &Option>) -> Result<()> { ++ if let Some(lights) = lights { ++ if lights.len() > MAX_LIGHTS || lights.capacity() > MAX_LIGHTS { ++ return Err(invalid("Raster light length and retained capacity must be at most eight")); ++ } ++ for light in lights { ++ validate_light(light)?; ++ } ++ } ++ Ok(()) ++} ++ ++fn reserve() -> Result> { ++ let mut lights = Vec::new(); ++ lights.try_reserve_exact(MAX_LIGHTS).map_err(|_| JobError::new(ErrorCode::AllocationFailed, "could not reserve Raster lights"))?; ++ if lights.capacity() > MAX_LIGHTS { ++ return Err(invalid("Raster light allocation exceeded its bounded capacity")); ++ } ++ Ok(lights) ++} ++ ++/// Copies only the bounded new payload; never whole-request clone-then-clear. ++pub(super) fn try_copy(lights: &Option>) -> Result>> { ++ validate(lights)?; ++ let Some(source) = lights else { return Ok(None) }; ++ if source.is_empty() { ++ return Ok(Some(Vec::new())); ++ } ++ let mut copy = reserve()?; ++ // Each element consists solely of fixed arrays and a scalar; no hidden allocation. ++ for light in source { ++ copy.push(DirectionalLightOptions { direction: light.direction, color: light.color, intensity: light.intensity }); ++ } ++ Ok(Some(copy)) ++} ++ ++pub(super) fn retained_bytes(lights: &Option>) -> Result { ++ validate(lights)?; ++ let capacity = lights.as_ref().map_or(0, Vec::capacity); ++ capacity ++ .checked_mul(std::mem::size_of::()) ++ .and_then(|bytes| u64::try_from(bytes).ok()) ++ .ok_or_else(|| JobError::new(ErrorCode::LimitExceeded, "Raster light retained size overflow")) ++} ++ ++/// Task clones reserve this conservative fee before allocating their rig. ++pub(super) fn task_bytes(lights: &Option>) -> Result { ++ validate(lights)?; ++ if lights.as_ref().is_none_or(Vec::is_empty) { ++ return Ok(0); ++ } ++ MAX_LIGHTS ++ .checked_mul(std::mem::size_of::()) ++ .and_then(|bytes| u64::try_from(bytes).ok()) ++ .ok_or_else(|| JobError::new(ErrorCode::LimitExceeded, "Raster task light size overflow")) ++} ++ ++/// Missing fields use serde(default); explicit null is the unchanged legacy path. ++pub fn deserialize<'de, D: serde::Deserializer<'de>>(deserializer: D) -> std::result::Result>, D::Error> { ++ struct Nullable; ++ impl<'de> serde::de::Visitor<'de> for Nullable { ++ type Value = Option>; ++ fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { ++ f.write_str("null or at most eight Raster directional lights") ++ } ++ fn visit_none(self) -> std::result::Result { ++ Ok(None) ++ } ++ fn visit_unit(self) -> std::result::Result { ++ Ok(None) ++ } ++ fn visit_some>(self, d: D) -> std::result::Result { ++ struct Sequence; ++ impl<'de> serde::de::Visitor<'de> for Sequence { ++ type Value = Vec; ++ fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { ++ f.write_str("at most eight Raster directional lights") ++ } ++ fn visit_seq>(self, mut sequence: A) -> std::result::Result { ++ let mut lights = Vec::new(); ++ while let Some(light) = sequence.next_element::()? { ++ if lights.len() == MAX_LIGHTS { ++ return Err(serde::de::Error::custom("at most eight Raster directional lights")); ++ } ++ validate_light(&light).map_err(serde::de::Error::custom)?; ++ if lights.is_empty() { ++ lights = reserve().map_err(serde::de::Error::custom)?; ++ } ++ lights.push(light); ++ } ++ Ok(lights) ++ } ++ } ++ d.deserialize_seq(Sequence).map(Some) ++ } ++ } ++ deserializer.deserialize_option(Nullable) ++} diff --git a/proposals/render/2026-10-30/next-source-units/raster-directional-consumer/02-base-mechanical-non-ui.patch b/proposals/render/2026-10-30/next-source-units/raster-directional-consumer/02-base-mechanical-non-ui.patch new file mode 100644 index 000000000..abe004dc6 --- /dev/null +++ b/proposals/render/2026-10-30/next-source-units/raster-directional-consumer/02-base-mechanical-non-ui.patch @@ -0,0 +1,236 @@ +--- a/crates/engine/src/render_jobs.rs ++++ b/crates/engine/src/render_jobs.rs +@@ -799,7 +799,7 @@ + fn final_cpu_protected_admission_accounts_captured_hdr_once_and_runs_real_host() { + use solidcraft_render::job::{CpuProgressiveOptions, ImageRequest, JobOptions, RaytraceOptions}; + let (session, host) = native().unwrap(); +- let request = ImageRequest { ++ let request = ImageRequest { raster_lights: None, + integrator: Integrator::Raytrace, + width: 13, + height: 7, +--- a/crates/gpu/src/path/denoise_tests.rs ++++ b/crates/gpu/src/path/denoise_tests.rs +@@ -156,7 +156,7 @@ + fn request(size: u32) -> ImageRequest { + let mut camera = Camera { distance: 4.0, ..Default::default() }; + camera.set_view(StandardView::Top); +- ImageRequest { ++ ImageRequest { raster_lights: None, + studio_weights: None, + integrator: Default::default(), + raytrace: None, +--- a/crates/render/examples/cpu_resource_smoke.rs ++++ b/crates/render/examples/cpu_resource_smoke.rs +@@ -30,7 +30,7 @@ + fn request(width: u32, height: u32, budget: CpuBudget) -> ImageRequest { + let mut camera = Camera { distance: 65.0, ..Default::default() }; + camera.set_view(StandardView::Top); +- ImageRequest { ++ ImageRequest { raster_lights: None, + studio_weights: None, + environment: None, + textures: None, +--- a/crates/render/src/job/host_regrade_tests.rs ++++ b/crates/render/src/job/host_regrade_tests.rs +@@ -46,7 +46,7 @@ + fn fixture(raw: bool) -> (ImageHost, JobHandle, Arc, Presentation) { + let begins = Arc::new(AtomicUsize::new(0)); + let host = ImageHost::cooperative_with(Arc::new(FixtureExecutor(begins.clone()))); +- let request = ImageRequest { ++ let request = ImageRequest { raster_lights: None, + studio_weights: None, + width: 16, + height: 16, +--- a/crates/render/src/job/png.rs ++++ b/crates/render/src/job/png.rs +@@ -103,7 +103,7 @@ + use super::*; + + fn request(width: u32, height: u32) -> ImageRequest { +- ImageRequest { ++ ImageRequest { raster_lights: None, + width, + height, + camera: Default::default(), +--- a/crates/render/src/job/regrade.rs ++++ b/crates/render/src/job/regrade.rs +@@ -93,7 +93,7 @@ + self.photographic = Some(task); + return self.pending(done, total); + } +- let request = ImageRequest { ++ let request = ImageRequest { raster_lights: None, + studio_weights: None, + width, + height, +@@ -175,7 +175,7 @@ + return self.pending(0, u64::from(width) * u64::from(height)); + } + self.linear = None; +- let request = ImageRequest { ++ let request = ImageRequest { raster_lights: None, + studio_weights: None, + width, + height, +--- a/crates/render/src/job/rt2_tests.rs ++++ b/crates/render/src/job/rt2_tests.rs +@@ -5,7 +5,7 @@ + use solidcraft_geom::Aabb3; + + fn request(integrator: Integrator) -> ImageRequest { +- ImageRequest { ++ ImageRequest { raster_lights: None, + studio_weights: None, + environment: None, + textures: None, +--- a/crates/render/src/job/led_strip/tests.rs ++++ b/crates/render/src/job/led_strip/tests.rs +@@ -191,7 +191,7 @@ + fn request(options: RaytraceOptions) -> ImageRequest { + let mut camera = Camera { distance: 50.0, ..Default::default() }; + camera.set_view(StandardView::Top); +- ImageRequest { ++ ImageRequest { raster_lights: None, + studio_weights: None, + environment: None, + textures: None, +--- a/crates/render/src/raytrace/anisotropic_faces_tests.rs ++++ b/crates/render/src/raytrace/anisotropic_faces_tests.rs +@@ -145,7 +145,7 @@ + #[test] + fn decoded_cpu_png_rotates_only_the_two_explicit_planar_targets() { + fn render(scene: ProductScene, camera: Camera, options: RaytraceOptions) -> ::image::RgbaImage { +- let request = ImageRequest { ++ let request = ImageRequest { raster_lights: None, + studio_weights: None, + environment: None, + textures: None, +--- a/crates/render/src/raytrace/anisotropic_reflection_image_tests.rs ++++ b/crates/render/src/raytrace/anisotropic_reflection_image_tests.rs +@@ -63,7 +63,7 @@ + shadows: false, + ..Default::default() + }; +- ImageRequest { ++ ImageRequest { raster_lights: None, + studio_weights: None, + environment: None, + textures: None, +--- a/crates/render/src/raytrace/deterministic_primary_tests.rs ++++ b/crates/render/src/raytrace/deterministic_primary_tests.rs +@@ -63,7 +63,7 @@ + }), + ..Default::default() + }; +- let request = ImageRequest { ++ let request = ImageRequest { raster_lights: None, + studio_weights: None, + environment: None, + textures: None, +@@ -228,7 +228,7 @@ + }), + ..Default::default() + }; +- let request = ImageRequest { ++ let request = ImageRequest { raster_lights: None, + studio_weights: None, + environment: None, + textures: None, +--- a/crates/render/src/raytrace/dielectric_tests.rs ++++ b/crates/render/src/raytrace/dielectric_tests.rs +@@ -42,7 +42,7 @@ + pub(in crate::raytrace) fn request(options: RaytraceOptions) -> ImageRequest { + let mut camera = crate::Camera { distance: 50.0, ..Default::default() }; + camera.set_view(crate::StandardView::Top); +- ImageRequest { ++ ImageRequest { raster_lights: None, + studio_weights: None, + environment: None, + textures: None, +--- a/crates/render/src/raytrace/environment_image_tests.rs ++++ b/crates/render/src/raytrace/environment_image_tests.rs +@@ -34,7 +34,7 @@ + fn request() -> ImageRequest { + let mut camera = crate::Camera { distance: 50.0, ..Default::default() }; + camera.set_view(crate::StandardView::Top); +- ImageRequest { ++ ImageRequest { raster_lights: None, + studio_weights: None, + environment: None, + textures: None, +--- a/crates/render/src/raytrace/environment_reflection_tests.rs ++++ b/crates/render/src/raytrace/environment_reflection_tests.rs +@@ -39,7 +39,7 @@ + fn request(mode: ReflectionMode) -> ImageRequest { + let mut camera = crate::Camera { distance: 50.0, ..Default::default() }; + camera.set_view(crate::StandardView::Top); +- ImageRequest { ++ ImageRequest { raster_lights: None, + studio_weights: None, + environment: None, + textures: None, +--- a/crates/render/src/raytrace/image_tests.rs ++++ b/crates/render/src/raytrace/image_tests.rs +@@ -175,7 +175,7 @@ + } + } + fn request() -> ImageRequest { +- ImageRequest { ++ ImageRequest { raster_lights: None, + studio_weights: None, + environment: None, + textures: None, +--- a/crates/render/src/raytrace/primary_aa_tests.rs ++++ b/crates/render/src/raytrace/primary_aa_tests.rs +@@ -173,7 +173,7 @@ + }), + ..Default::default() + }; +- let request = ImageRequest { ++ let request = ImageRequest { raster_lights: None, + studio_weights: None, + environment: None, + textures: None, +@@ -756,7 +756,7 @@ + }]), + ..Default::default() + }; +- let request = ImageRequest { ++ let request = ImageRequest { raster_lights: None, + studio_weights: None, + environment: None, + textures: None, +--- a/crates/render/src/raytrace/punctual_image_tests.rs ++++ b/crates/render/src/raytrace/punctual_image_tests.rs +@@ -43,7 +43,7 @@ + shadows, + ..Default::default() + }; +- let request = ImageRequest { ++ let request = ImageRequest { raster_lights: None, + studio_weights: None, + environment: None, + textures: None, +--- a/crates/render/src/raytrace/reflection_image_tests.rs ++++ b/crates/render/src/raytrace/reflection_image_tests.rs +@@ -182,7 +182,7 @@ + fn request(reflections: Option) -> ImageRequest { + let mut camera = crate::Camera { distance: 50.0, ..Default::default() }; + camera.set_view(crate::StandardView::Front); +- ImageRequest { ++ ImageRequest { raster_lights: None, + studio_weights: None, + environment: None, + textures: None, +--- a/tools/render-library/native_smoke.rs ++++ b/tools/render-library/native_smoke.rs +@@ -57,7 +57,7 @@ + fn request(root: &Path) -> Result> { + let hdr = HdrSource::new(fs::read(root.join("assets/render/starter/environments/exports/neutral-side-softbox.hdr"))?)?; + let environment = EnvironmentSource::from_hdr(hdr, std::f64::consts::PI, 1.0, false)?; +- Ok(ImageRequest { ++ Ok(ImageRequest { raster_lights: None, + camera: Camera { distance: 220.0, ..Default::default() }, + width: 320, + height: 240, diff --git a/proposals/render/2026-10-30/next-source-units/raster-directional-consumer/03-base-mechanical-ui.patch b/proposals/render/2026-10-30/next-source-units/raster-directional-consumer/03-base-mechanical-ui.patch new file mode 100644 index 000000000..acc898856 --- /dev/null +++ b/proposals/render/2026-10-30/next-source-units/raster-directional-consumer/03-base-mechanical-ui.patch @@ -0,0 +1,40 @@ +--- a/crates/ui-egui/src/render_workspace_tests.rs ++++ b/crates/ui-egui/src/render_workspace_tests.rs +@@ -1210,7 +1210,7 @@ + let eye = camera.eye().to_f32(); + let mut task = ImageTask::new( + scene, +- ImageRequest { ++ ImageRequest { raster_lights: None, + studio_weights: None, + environment: None, + textures: None, +@@ -3617,7 +3617,7 @@ + #[test] + fn large_image_display_uses_captured_profile_and_keeps_export_pixels_unchanged() { + use solidcraft_engine::render::job::{CpuBudget, ImageRequest, RaytraceOptions}; +- let request = ImageRequest { ++ let request = ImageRequest { raster_lights: None, + studio_weights: None, + integrator: Integrator::Raytrace, + raytrace: Some(RaytraceOptions { budget: CpuBudget::Studio, ..Default::default() }), +@@ -8604,7 +8604,7 @@ + + fn partial_png_contract_request() -> solidcraft_engine::render::job::ImageRequest { + use solidcraft_engine::render::job::{CpuProgressiveOptions, ImageRequest, RaytraceOptions}; +- ImageRequest { ++ ImageRequest { raster_lights: None, + studio_weights: None, + environment: None, + textures: None, +--- a/crates/ui-egui/src/render_workspace_thumbnails.rs ++++ b/crates/ui-egui/src/render_workspace_thumbnails.rs +@@ -137,7 +137,7 @@ + } + let permit = WorkerPermit; + let Some(setup) = app.session.doc.render.setups.get(&key.name) else { return }; +- let request = solidcraft_engine::render::job::ImageRequest { ++ let request = solidcraft_engine::render::job::ImageRequest { raster_lights: None, + studio_weights: None, + camera: setup.camera, + width: SIZE[0], diff --git a/proposals/render/2026-10-30/next-source-units/raster-directional-consumer/04-f1-test-dto-path.patch b/proposals/render/2026-10-30/next-source-units/raster-directional-consumer/04-f1-test-dto-path.patch new file mode 100644 index 000000000..6ecf79e25 --- /dev/null +++ b/proposals/render/2026-10-30/next-source-units/raster-directional-consumer/04-f1-test-dto-path.patch @@ -0,0 +1,38 @@ +--- a/crates/render/src/job/image_tests.rs ++++ b/crates/render/src/job/image_tests.rs +@@ -397,7 +397,7 @@ + let mut input = request(); + // Orthographic Front is exactly normal to the square, so no perspective-view approximation. + assert_eq!(input.camera.fov, 0.0); +- input.raster_lights = Some(vec![super::DirectionalLightOptions { direction: [0.0, -1.0, 0.0], color: [0.25, 0.5, 1.0], intensity: 2.0 }]); ++ input.raster_lights = Some(vec![crate::job::DirectionalLightOptions { direction: [0.0, -1.0, 0.0], color: [0.25, 0.5, 1.0], intensity: 2.0 }]); + let png = finish(ImageTask::new(scene(vec![part]), input, CancelToken::default()).unwrap()); + let image = image::load_from_memory(&png).unwrap().to_rgba8(); + // Independently derived: [.4,.5,.5]/pi -> Reinhard -> piecewise sRGB -> nearest byte. +@@ -412,7 +412,7 @@ + let mut part = square("matte", [0; 3], 1.0, Vec3::ZERO); + part.surface = Some(crate::surface::OpaqueSurface::new(Vec3::new(0.8, 0.5, 0.25), 0.0, 1.0, 1.0).unwrap()); + let mut input = request(); +- input.raster_lights = Some(vec![super::DirectionalLightOptions { direction: [3.0, -4.0, 0.0], color: [1.0; 3], intensity: 2.0 }]); ++ input.raster_lights = Some(vec![crate::job::DirectionalLightOptions { direction: [3.0, -4.0, 0.0], color: [1.0; 3], intensity: 2.0 }]); + let png = finish(ImageTask::new(scene(vec![part]), input, CancelToken::default()).unwrap()); + let image = image::load_from_memory(&png).unwrap().to_rgba8(); + // Independently derived: [1.28,.8,.4]/pi -> Reinhard -> sRGB. +@@ -442,7 +442,7 @@ + #[test] + fn explicit_raster_request_rejects_capacity_conflicts_and_foreign_integrators() { + let part = scene(vec![square("part", [200; 3], 1.0, Vec3::ZERO)]); +- let light = super::DirectionalLightOptions { direction: [0.0, -1.0, 0.0], color: [1.0; 3], intensity: 1.0 }; ++ let light = crate::job::DirectionalLightOptions { direction: [0.0, -1.0, 0.0], color: [1.0; 3], intensity: 1.0 }; + let mut input = request(); + let mut oversized = Vec::with_capacity(9); + oversized.push(light); +@@ -463,7 +463,7 @@ + fn explicit_raster_scalar_surrogate_preserves_straight_alpha_without_claiming_glass() { + let part = square("scalar", [0; 3], 0.5, Vec3::ZERO); + let mut input = request(); +- input.raster_lights = Some(vec![super::DirectionalLightOptions { direction: [0.0, -1.0, 0.0], color: [1.0; 3], intensity: 2.0 }]); ++ input.raster_lights = Some(vec![crate::job::DirectionalLightOptions { direction: [0.0, -1.0, 0.0], color: [1.0; 3], intensity: 2.0 }]); + let png = finish(ImageTask::new(scene(vec![part.clone()]), input.clone(), CancelToken::default()).unwrap()); + let image = image::load_from_memory(&png).unwrap().to_rgba8(); + // Scalar surrogate rho=0, IOR=1.5, roughness=1: F0/4pi=.01/pi. diff --git a/proposals/render/2026-10-30/next-source-units/raster-directional-consumer/05-f2-empty-capacity.patch b/proposals/render/2026-10-30/next-source-units/raster-directional-consumer/05-f2-empty-capacity.patch new file mode 100644 index 000000000..957cdc575 --- /dev/null +++ b/proposals/render/2026-10-30/next-source-units/raster-directional-consumer/05-f2-empty-capacity.patch @@ -0,0 +1,54 @@ +--- a/crates/render/src/job/raster_lights.rs ++++ b/crates/render/src/job/raster_lights.rs +@@ -68,10 +68,11 @@ + .ok_or_else(|| JobError::new(ErrorCode::LimitExceeded, "Raster light retained size overflow")) + } + +-/// Task clones reserve this conservative fee before allocating their rig. ++/// Covers host clones and public ImageTask callers retaining an original Vec, ++/// including an empty Vec with nonzero capacity. None keeps the legacy estimate. + pub(super) fn task_bytes(lights: &Option>) -> Result { + validate(lights)?; +- if lights.as_ref().is_none_or(Vec::is_empty) { ++ if lights.is_none() { + return Ok(0); + } + MAX_LIGHTS +--- a/crates/render/src/job/image_tests.rs ++++ b/crates/render/src/job/image_tests.rs +@@ -473,3 +473,35 @@ + physical.transmission = Some(crate::transmission::Transmission::new(Vec3::ZERO, None).unwrap()); + assert_eq!(admit(&scene(vec![physical]), &input).unwrap_err().code, ErrorCode::InvalidRequest); + } ++#[test] ++fn direct_raster_task_accounts_empty_rig_capacity_without_changing_dark_or_legacy_paths() { ++ let part = scene(vec![square("part", [200; 3], 1.0, Vec3::ZERO)]); ++ let legacy = request(); ++ let legacy_bytes = admit(&part, &legacy).unwrap().estimated_total_bytes; ++ assert!(ImageTask::new(part.clone(), legacy, CancelToken::default()).unwrap().request.raster_lights.is_none()); ++ let fee = (8 * std::mem::size_of::()) as u64; ++ let mut dark_png = None; ++ for capacity in [0, 8] { ++ let mut input = request(); ++ input.raster_lights = Some(Vec::with_capacity(capacity)); ++ let retained_capacity = input.raster_lights.as_ref().unwrap().capacity(); ++ assert!(retained_capacity >= capacity && retained_capacity <= 8); ++ let actual_bytes = (retained_capacity * std::mem::size_of::()) as u64; ++ let admitted = admit(&part, &input).unwrap(); ++ assert_eq!(admitted.estimated_total_bytes, legacy_bytes + fee); ++ assert!(admitted.estimated_total_bytes - legacy_bytes >= actual_bytes); ++ // This is the public direct constructor, not host try_copy/Record fees. ++ let task = ImageTask::new(part.clone(), input, CancelToken::default()).unwrap(); ++ assert_eq!(task.request.raster_lights.as_ref().unwrap().capacity(), retained_capacity); ++ assert_eq!(task.admission.estimated_total_bytes, legacy_bytes + fee); ++ let png = finish(task); ++ let image = image::load_from_memory(&png).unwrap().to_rgba8(); ++ assert_eq!(image.get_pixel(32, 32).0, [0, 0, 0, 255]); ++ if let Some(expected) = &dark_png { ++ assert_eq!(&png, expected); ++ } else { ++ dark_png = Some(png); ++ } ++ } ++} ++ diff --git a/proposals/render/2026-10-30/next-source-units/raster-directional-consumer/06-f3-borrowed-json.patch b/proposals/render/2026-10-30/next-source-units/raster-directional-consumer/06-f3-borrowed-json.patch new file mode 100644 index 000000000..1c24bd3b7 --- /dev/null +++ b/proposals/render/2026-10-30/next-source-units/raster-directional-consumer/06-f3-borrowed-json.patch @@ -0,0 +1,98 @@ +--- a/crates/engine/src/cmd/render/jobs.rs ++++ b/crates/engine/src/cmd/render/jobs.rs +@@ -109,7 +109,7 @@ + /// unsupported effects remain errors rather than disappearing from the request. + fn interactive_params(params: &Value) -> Result { + let command = "render.interactive"; +- let mut input: Start = serde_json::from_value(params.clone()).map_err(|e| bad(command, e.to_string()))?; ++ let mut input = Start::deserialize(params).map_err(|e| bad(command, e.to_string()))?; + let object = params.as_object().ok_or_else(|| bad(command, "Interactive requires an explicit CPU request object"))?; + if object.contains_key("setup") || object.contains_key("replace") { + return Err(bad(command, "Interactive requires an explicit settings snapshot without setup or replace")); +@@ -557,6 +557,11 @@ + } + + fn normalize_saved_job(s: &Session, params: &Value, command: &str) -> Result> { ++ // Validate the new payload by reference even if this turns out to be an ++ // unsaved request. Never clone an unbounded caller-owned light array. ++ let raster_override = params.get("raster_lights") ++ .map(|value| solidcraft_render::job::deserialize_raster_lights(value).map_err(|e| bad(command, e.to_string()))) ++ .transpose()?; + let Some(object) = params.as_object() else { + return Ok(None); + }; +@@ -618,8 +623,9 @@ + } + }; + lowered["settings"] = serde_json::to_value(settings).map_err(|e| bad(command, e.to_string()))?; +- if let Some(lights) = object.get("raster_lights") { +- lowered["raster_lights"] = lights.clone(); ++ if let Some(lights) = raster_override { ++ // Only the already validated, bounded representation is materialized. ++ lowered["raster_lights"] = serde_json::to_value(lights).map_err(|e| bad(command, e.to_string()))?; + } + if let Some(weights) = object.get("studio_weights") { + lowered["studio_weights"] = weights.clone(); +@@ -665,7 +671,7 @@ + "runtime GPU transmission, texture, lens, environment, lighting, tone-map and denoise controls require progressive rendering", + )); + } +- let mut input: Start = serde_json::from_value(params.clone()).map_err(|e| bad(command, e.to_string()))?; ++ let mut input = Start::deserialize(params).map_err(|e| bad(command, e.to_string()))?; + solidcraft_render::job::validate_raster_lights(&input.raster_lights).map_err(job_error)?; + if input.raster_lights.is_some() + && (input.integrator != Integrator::Raster || input.progressive || input.progressive_feedback || input.nested_media +--- a/crates/engine/src/cmd/render/job_tests.rs ++++ b/crates/engine/src/cmd/render/job_tests.rs +@@ -2,6 +2,51 @@ + use solidcraft_render::job::{CpuHost, JobId}; + + #[test] ++fn raster_json_is_bounded_before_saved_normalization_and_preserves_null_empty_semantics() { ++ let (mut s, host) = session(); ++ s.execute("render.settings.set", &json!({"name":"Bounded","set":{"width":16,"height":16,"job":{"method":"raster","transparent_background":false}}})).unwrap(); ++ let light = json!({"direction":[0,0,1],"color":[1,1,1],"intensity":1}); ++ let mut unknown = light.clone(); ++ unknown["unexpected"] = json!({"nested":vec![0;32]}); ++ let doc = s.doc.clone(); ++ for rig in [json!(vec![light;9]), json!([unknown])] { ++ for saved in [false, true] { ++ let mut params = json!({"raster_lights":rig}); ++ if saved { ++ params["setup"] = json!("Bounded"); ++ } ++ let before = params.clone(); // deliberately small adversarial fixture, not production lowering ++ for command in ["render.preflight", "render.start"] { ++ assert!(s.execute(command, ¶ms).is_err()); ++ assert_eq!(params, before); ++ assert_eq!(host.admitted_bytes(), 0); ++ assert!(Arc::ptr_eq(&doc, &s.doc)); ++ } ++ } ++ } ++ for saved in [false, true] { ++ for rig in [None, Some(Value::Null), Some(json!([]))] { ++ let empty = rig.as_ref().is_some_and(Value::is_array); ++ let mut params = json!({}); ++ if saved { ++ params["setup"] = json!("Bounded"); ++ } ++ if let Some(rig) = rig { ++ params["raster_lights"] = rig; ++ } ++ let checked = s.execute("render.preflight", ¶ms).unwrap(); ++ if empty { ++ assert_eq!(checked["request"]["raster_lights"], json!([])); ++ } else { ++ assert!(checked["request"].get("raster_lights").is_none()); ++ } ++ } ++ } ++ // Source inspection, not this outcome test, proves the raw new array was ++ // borrowed/validated before materialization. No real OOM test is claimed. ++} ++ ++#[test] + fn transient_raster_rig_survives_saved_normalization_check_start_status_and_png() { + let (mut s, host) = session(); + s.execute("solid.box", &json!({"length":20,"width":15,"height":10})).unwrap(); diff --git a/proposals/render/2026-10-30/next-source-units/raster-directional-consumer/README.md b/proposals/render/2026-10-30/next-source-units/raster-directional-consumer/README.md new file mode 100644 index 000000000..8359b891a --- /dev/null +++ b/proposals/render/2026-10-30/next-source-units/raster-directional-consumer/README.md @@ -0,0 +1,28 @@ +# Raster directional consumer — reviewed archival source chain + +**Unapplied, unformatted, uncompiled and unrun.** The original33-file packet plus all three required corrections has independent implementation/source review (`57569834` + F3 closure `b48743c2`). Fourteen new declarations remain unrun. No current production candidate, workspace integration, successful compile or visible Raster result has been constructed or qualified here. + +## Exact archival order; current integration still pending + +The receiver is the actual archived C15 post-format manifest `2fe4f37371e7376e02ae89a080e51fad82e6f6c564bfe8b8a8075c2951fe1f31`. Its [formatter bridge](../../c16-defaults-auto-result/c15-postformat-manifest.json) follows Actual19. This is **not** current C16 or the separate paused-camera source. On that archival base, all six exact patch files are required: + +1. `01-base-main.patch`:12 files, including the new bounded Raster-light module, actual command/host/task/pixel path and original tests. +2. `02-base-mechanical-non-ui.patch`:19 files, required `None` initializers for the new public ImageRequest field. +3. `03-base-mechanical-ui.patch`:two files, only the four original `None` initializers in UI tests/thumbnails. This adds no Raster light editor. +4. `04-f1-test-dto-path.patch`:four new-test DTO paths resolve through their actual job parent; no fixture/oracle changes. +5. `05-f2-empty-capacity.patch`:every `Some` receives the conservative eight-element task fee, including an empty Vec with retained capacity. This supersedes the original zero-empty-task-fee refinement. `None` remains zero; actual Record capacity fees stay separate. Adds one original public-constructor regression. +6. `06-f3-borrowed-json.patch`:strict bounded deserialization of the new payload occurs through borrowed Value before its raw wire copies in actual normal/saved/Interactive paths. Missing/null/empty semantics remain distinct. Adds one small hostile-input regression, not an allocator/OOM test. + +The three original groups are disjoint on C15; the corrections explicitly extend their pinned endpoints. `bindings.json` records all original33 before/candidate RAW bindings, correction chains, final reviewed archival endpoint hashes, EOL and original patch hashes. Original patch bytes remain unchanged. Reconstruct only physical EOL explicitly and verify exact RAW endpoints; no fuzzy application or universal literal RAW replay is claimed. + +**Do not apply the mechanical UI candidate over C16/W1.** Its UI252 preimage predates C16's corrected fixtures/AutoResult UI255 and W1's appended camera cases. Engineer must carry only the required field initializers onto the real agreed successor while retaining every new suffix, corrected fixture, preference and original assertion. Re-inventory any newly added full struct literals and rebind newer W2 files too. The archival C15 base still contains its known later-corrected fixture setup errors; this package does not roll those corrections back or claim an independently runnable candidate. No cross-unit combination is invented by this preservation step. + +## Proposed bounded behavior and limits + +The transient optional `raster_lights` vector reaches actual Raster pixels. Missing/null/None retains legacy lighting/serialization; `Some([])` means no direct light. One to eight finite bounded directional DTOs use relative RGB/intensity, actual perspective-correct view direction, existing PBR or an explicitly schematic scalar surrogate, one tone map/encode and legacy alpha compositing. Internal copies are bounded/fallible; request and task capacities are charged and payloads drop before their credits. Other CPU/Interactive/GPU routes refuse this payload before their relevant clone/device seams. JSON omission compatibility does not remove the public Rust struct-literal source break. + +**No UI lighting bridge, saved design format, nonzero-EV support, physical transmission, shadows, HDR, texture or GI is enabled.** This is an API-to-Raster-PNG source unit, not resolution of every Raster capability gap. Actual UI routing/save/EV are later units; do not silently drop unsupported intent. A device-free GPU refusal case is not physical GPU execution. + +The12 original new tests plus capacity and borrowed-wire cases total14. Their original Lambert/cosine/scalar PNG, None/alpha/perspective, ownership and hostile-input oracles are retained. New paths/fees were corrected by source findings; no observed output was blessed or tolerance weakened. Static copies/drop-order reasoning and authored tests are not actual layout/allocation/work/yield/renderer evidence. + +Next: explicit current-source rebind/composition review, then authorized sole-builder formatting, Rust/layout guards, focused/full/wasm gates and real Check/Start/PNG/native acceptance. C15's compiler failure and C16's pre-Cargo resource-admission stop remain separate historical outcomes, with no PASS transfer. The neighboring paused-camera source is separately based and does not close geometric/placement/visibility identity. No control scripts, logs, grants, machine paths or private strong index are copied here. diff --git a/proposals/render/2026-10-30/next-source-units/raster-directional-consumer/bindings.json b/proposals/render/2026-10-30/next-source-units/raster-directional-consumer/bindings.json new file mode 100644 index 000000000..bc751a712 --- /dev/null +++ b/proposals/render/2026-10-30/next-source-units/raster-directional-consumer/bindings.json @@ -0,0 +1,876 @@ +{ + "schema": 1, + "status": "PRIVATE_ARCHIVAL_SOURCE_CHAIN_UNAPPLIED_UNFORMATTED_UNCOMPILED_UNRUN", + "authorship": "Worker #3, SolidCraft Render team under0xlillith; independent Kernel implementation review and focal closure retained.", + "base": { + "source_manifest_sha256": "2fe4f37371e7376e02ae89a080e51fad82e6f6c564bfe8b8a8075c2951fe1f31", + "public_formatter_bridge": "../../c16-defaults-auto-result/c15-postformat-manifest.json", + "description": "Exact archived C15 post-format source. This is not the current C16/W1 UI receiver." + }, + "original_index_sha256": "73f6c9bde80c25c7d2a22f30409b9efaa1d9cda97231c1d99720df8d71637455", + "original_source_manifest_sha256": "5f1d83897823898e10f0daefdb8ec015295aae3ca021d96032c6ab6828612e2a", + "independent_source_review_sha256": "5756983402c707d4335416fa8e355c2d584e3cb57e3e4c1f69b2db534bf1e8d2", + "independent_F3_closure_sha256": "b48743c223e41e901d3c99182e0228daad174d9c2700d34eb8429536ecef1bad", + "patch_order": [ + { + "path": "01-base-main.patch", + "sha256": "b5efadddcda2dadfee82485d30ef6b1c23e36f175cd0580c9e245d62bb86e1e3", + "bytes": 53929, + "stage": "main", + "source_files": 12 + }, + { + "path": "02-base-mechanical-non-ui.patch", + "sha256": "6e23465532df7598e8e1ba15cf2f38721829e9d0256570ea75fc6c45d9c07561", + "bytes": 9018, + "stage": "mechanical_non_ui", + "source_files": 19 + }, + { + "path": "03-base-mechanical-ui.patch", + "sha256": "08cd6c2d25ef580203153bda6b089bbf21fad60fea3397a059c34f79d29320da", + "bytes": 1755, + "stage": "mechanical_ui", + "source_files": 2 + }, + { + "path": "04-f1-test-dto-path.patch", + "sha256": "0d297ec69b302844e7647458b27d25409ab8b90c84361f05b696df18f3841ac3", + "bytes": 2818, + "stage": "F1 test DTO paths", + "source_files": 1 + }, + { + "path": "05-f2-empty-capacity.patch", + "sha256": "4c8c1c05a3357137e5596cc0be00bca2c28cd83c6a5f868f3bdcc0d3b8f0d1bf", + "bytes": 2822, + "stage": "F2 empty capacity billing", + "source_files": 2 + }, + { + "path": "06-f3-borrowed-json.patch", + "sha256": "98911803290ef9a57be81b0cd17a5a1a0ff3a6aa3379ed4d510d15cde671c7a0", + "bytes": 5084, + "stage": "F3 borrowed JSON before copy", + "source_files": 2 + } + ], + "original33_file_source_bindings": [ + { + "path": "crates/engine/src/render_jobs.rs", + "group": "mechanical_non_ui", + "before": { + "sha256": "4a2d5c1886ca029d383874f9aece71b866390fad2b6651193e218b2c302c5f48", + "bytes": 42310, + "EOL": "LF", + "CRLF": 0, + "LF": 856, + "UTF8_BOM": false + }, + "candidate": { + "sha256": "80a110ce652c01d7de86a8627582a08a8d87f5670ba8e9703d1271f3592b40e7", + "bytes": 42331, + "EOL": "LF", + "CRLF": 0, + "LF": 856, + "UTF8_BOM": false + } + }, + { + "path": "crates/engine/src/cmd/render.rs", + "group": "main", + "before": { + "sha256": "c8e029139a5a01efa9196dd45c419fec4a6191f752a86e3b023e2bb0e0fc3ba4", + "bytes": 41491, + "EOL": "CRLF", + "CRLF": 424, + "LF": 424, + "UTF8_BOM": false + }, + "candidate": { + "sha256": "869a7bb3345d0dfe7d220eccfa9d8ac11421723fbccacb73b596a6bbfc0e5f02", + "bytes": 41892, + "EOL": "CRLF", + "CRLF": 424, + "LF": 424, + "UTF8_BOM": false + } + }, + { + "path": "crates/engine/src/cmd/render/job_tests.rs", + "group": "main", + "before": { + "sha256": "545f7e6043aa8fa1d24787021e199f25e2aebadeb4150641b1b77649ef38292a", + "bytes": 68734, + "EOL": "CRLF", + "CRLF": 1218, + "LF": 1218, + "UTF8_BOM": false + }, + "candidate": { + "sha256": "22ed3118fc92b84fbe80645ee4c44c64d1753e4979e4132677bdba6f4272156f", + "bytes": 71850, + "EOL": "CRLF", + "CRLF": 1271, + "LF": 1271, + "UTF8_BOM": false + } + }, + { + "path": "crates/engine/src/cmd/render/jobs.rs", + "group": "main", + "before": { + "sha256": "741caaaeb765853b6d89e0a69eaa8f425654689433a8eee48d3587d276144dd2", + "bytes": 64072, + "EOL": "LF", + "CRLF": 0, + "LF": 1255, + "UTF8_BOM": false + }, + "candidate": { + "sha256": "b4cbe807251130730b3f9ff3eb34ee9ce24b4ba28dd887d1d8beca646fce3e5c", + "bytes": 65570, + "EOL": "LF", + "CRLF": 0, + "LF": 1277, + "UTF8_BOM": false + } + }, + { + "path": "crates/gpu/src/path/denoise_tests.rs", + "group": "mechanical_non_ui", + "before": { + "sha256": "19d7d68e870e61e78da7f4f868c52fddb24f389c94d96745aa5f9b785dbfbbe7", + "bytes": 16109, + "EOL": "CRLF", + "CRLF": 349, + "LF": 349, + "UTF8_BOM": false + }, + "candidate": { + "sha256": "2e3d2f17590457407389be4458640257f39d629422dc03fd476adbd19077b313", + "bytes": 16130, + "EOL": "CRLF", + "CRLF": 349, + "LF": 349, + "UTF8_BOM": false + } + }, + { + "path": "crates/gpu/src/path/mod.rs", + "group": "main", + "before": { + "sha256": "56eb1fe9e358d08377e37ec28628463497faaae4365a3890d289ba94a66b1777", + "bytes": 51168, + "EOL": "CRLF", + "CRLF": 1034, + "LF": 1034, + "UTF8_BOM": false + }, + "candidate": { + "sha256": "7ac11bb0cff6d740fc520dd62840aae2815961f34e6251fd3e1cffdc4edede23", + "bytes": 51526, + "EOL": "CRLF", + "CRLF": 1040, + "LF": 1040, + "UTF8_BOM": false + } + }, + { + "path": "crates/gpu/src/path/tests.rs", + "group": "main", + "before": { + "sha256": "ea1d58e5fe879b35724879a65ddd4a738edfc0ea4fd57f17148ffc4a95b89f0a", + "bytes": 166721, + "EOL": "CRLF", + "CRLF": 3328, + "LF": 3328, + "UTF8_BOM": false + }, + "candidate": { + "sha256": "bc337ca1f22c3554fb51a47787de9d5a104e50311ec399ae2286e7e606b0b0bb", + "bytes": 167131, + "EOL": "CRLF", + "CRLF": 3337, + "LF": 3337, + "UTF8_BOM": false + } + }, + { + "path": "crates/render/examples/cpu_resource_smoke.rs", + "group": "mechanical_non_ui", + "before": { + "sha256": "b01e26fba1472ae504f8b177b2e151d6d077636381727f1fc358d8fb5c927225", + "bytes": 8602, + "EOL": "CRLF", + "CRLF": 188, + "LF": 188, + "UTF8_BOM": false + }, + "candidate": { + "sha256": "6200bd74b322b069c21253e6733385a4c296523b37cf2a12aea8259b2bd16674", + "bytes": 8623, + "EOL": "CRLF", + "CRLF": 188, + "LF": 188, + "UTF8_BOM": false + } + }, + { + "path": "crates/render/src/job/host_regrade_tests.rs", + "group": "mechanical_non_ui", + "before": { + "sha256": "7ccf5300f99f7e97883f5493513c00227713ba06c045b8e6255c33646c2efbf1", + "bytes": 7193, + "EOL": "CRLF", + "CRLF": 171, + "LF": 171, + "UTF8_BOM": false + }, + "candidate": { + "sha256": "0d6528440bca497a097600da7fbab084d946adba65ea0575919d6602be97f5f4", + "bytes": 7214, + "EOL": "CRLF", + "CRLF": 171, + "LF": 171, + "UTF8_BOM": false + } + }, + { + "path": "crates/render/src/job/host_tests.rs", + "group": "main", + "before": { + "sha256": "d35a649443908a80db0b061c8ab111d45271bbb941b47f48eed2aca55f6f4f14", + "bytes": 97653, + "EOL": "LF", + "CRLF": 0, + "LF": 2046, + "UTF8_BOM": false + }, + "candidate": { + "sha256": "9f85c3fc5f339fae97ab3cd39f06e54cfcc0231573baac563695f89fe4a5f269", + "bytes": 100887, + "EOL": "LF", + "CRLF": 0, + "LF": 2108, + "UTF8_BOM": false + } + }, + { + "path": "crates/render/src/job/host.rs", + "group": "main", + "before": { + "sha256": "1884acfd018cb38683bd6ec92b171eff5a1b39eb5fd7e79bec0e31a3e76aa879", + "bytes": 115999, + "EOL": "LF", + "CRLF": 0, + "LF": 2587, + "UTF8_BOM": false + }, + "candidate": { + "sha256": "f4892fbc5940d2151caeca66d1355d12d4b50570c422b83784bf0bae2a0f98e0", + "bytes": 116643, + "EOL": "LF", + "CRLF": 0, + "LF": 2594, + "UTF8_BOM": false + } + }, + { + "path": "crates/render/src/job/image_tests.rs", + "group": "main", + "before": { + "sha256": "98dfbb281a16aea600a6cff86652b3c92e566eb1188c2942a873df5742183368", + "bytes": 19074, + "EOL": "LF", + "CRLF": 0, + "LF": 390, + "UTF8_BOM": false + }, + "candidate": { + "sha256": "a82677ca2e3af1e7110b31e4ea74931ab23ff4f40863a756c2990367d98f995a", + "bytes": 23775, + "EOL": "LF", + "CRLF": 0, + "LF": 475, + "UTF8_BOM": false + } + }, + { + "path": "crates/render/src/job/image.rs", + "group": "main", + "before": { + "sha256": "0e6fa062eba9d5c0f4899fc92d7e7e667bbad295b35ff6bc8addbc9db7fd6285", + "bytes": 34526, + "EOL": "CRLF", + "CRLF": 813, + "LF": 813, + "UTF8_BOM": false + }, + "candidate": { + "sha256": "3e98059f9510e0ed9de16442a6c65801b6757a66cb88b902f427313c7e712912", + "bytes": 35902, + "EOL": "CRLF", + "CRLF": 836, + "LF": 836, + "UTF8_BOM": false + } + }, + { + "path": "crates/render/src/job/interactive.rs", + "group": "main", + "before": { + "sha256": "ccc8aaa5fc76038b39e8829f87b0888ccd92816567ea8b3d83778201364a4cce", + "bytes": 11088, + "EOL": "CRLF", + "CRLF": 288, + "LF": 288, + "UTF8_BOM": false + }, + "candidate": { + "sha256": "5fb7062276adfdc22d1fa651750119feb90870b31d12fb0fc0b852c4b430468d", + "bytes": 11135, + "EOL": "CRLF", + "CRLF": 289, + "LF": 289, + "UTF8_BOM": false + } + }, + { + "path": "crates/render/src/job/mod.rs", + "group": "main", + "before": { + "sha256": "10b26a76921445cce0029a19e2c9e591663dc5b8876c055b2f07618a4ddeab74", + "bytes": 62100, + "EOL": "LF", + "CRLF": 0, + "LF": 1474, + "UTF8_BOM": false + }, + "candidate": { + "sha256": "79c24d3f921c7e78044a32f3b829211380e234672f07a5b86f740dcf814fdebd", + "bytes": 66464, + "EOL": "LF", + "CRLF": 0, + "LF": 1559, + "UTF8_BOM": false + } + }, + { + "path": "crates/render/src/job/png.rs", + "group": "mechanical_non_ui", + "before": { + "sha256": "2d8c7204b6524515b9f13e0219bde0983f67562f8f49b8b7fae6a0d9ccb470fc", + "bytes": 7253, + "EOL": "LF", + "CRLF": 0, + "LF": 159, + "UTF8_BOM": false + }, + "candidate": { + "sha256": "61beefeaca1c219c427ec68c5f776f7b0e68c422c9930b3829c63119b9f2bdc9", + "bytes": 7274, + "EOL": "LF", + "CRLF": 0, + "LF": 159, + "UTF8_BOM": false + } + }, + { + "path": "crates/render/src/job/raster_lights.rs", + "group": "main", + "before": null, + "candidate": { + "sha256": "2e5de123b2aba2ac44ef409f3b07882dd909b077d0046080b6bd82de171ae469", + "bytes": 5402, + "EOL": "LF", + "CRLF": 0, + "LF": 123, + "UTF8_BOM": false + } + }, + { + "path": "crates/render/src/job/regrade.rs", + "group": "mechanical_non_ui", + "before": { + "sha256": "0f5e83d3d0ecbd0f0235ba6befcc2c34781a75c611ae26ab49e1f13a7c5a32d3", + "bytes": 9382, + "EOL": "LF", + "CRLF": 0, + "LF": 208, + "UTF8_BOM": false + }, + "candidate": { + "sha256": "6f7a76b2e153f444939e0475cf835a5dbc996513a5622ce803ac050f019bd08e", + "bytes": 9424, + "EOL": "LF", + "CRLF": 0, + "LF": 208, + "UTF8_BOM": false + } + }, + { + "path": "crates/render/src/job/rt2_tests.rs", + "group": "mechanical_non_ui", + "before": { + "sha256": "48385581616ef4d5dd3f8a4695fbd491064d1ff2eb99d071bd51b61b8a928fd9", + "bytes": 8507, + "EOL": "CRLF", + "CRLF": 175, + "LF": 175, + "UTF8_BOM": false + }, + "candidate": { + "sha256": "cb37434a1199d7a3b5dc60aba19a981e5712fffe4a5d95c5c6fcec507b189e82", + "bytes": 8528, + "EOL": "CRLF", + "CRLF": 175, + "LF": 175, + "UTF8_BOM": false + } + }, + { + "path": "crates/render/src/job/led_strip/tests.rs", + "group": "mechanical_non_ui", + "before": { + "sha256": "f34f73369332748ed6482be31698130d4dc4972fbc9d1a703a50ac18d814c0fb", + "bytes": 11914, + "EOL": "CRLF", + "CRLF": 254, + "LF": 254, + "UTF8_BOM": false + }, + "candidate": { + "sha256": "6cf184c9183e120394e5030c745e33e217d5915da914be7546389b8de480c037", + "bytes": 11935, + "EOL": "CRLF", + "CRLF": 254, + "LF": 254, + "UTF8_BOM": false + } + }, + { + "path": "crates/render/src/raytrace/anisotropic_faces_tests.rs", + "group": "mechanical_non_ui", + "before": { + "sha256": "0e4689451471f53fc969cb0291d3fa2e45184b11b24aa61982efac5759eef314", + "bytes": 11612, + "EOL": "CRLF", + "CRLF": 246, + "LF": 246, + "UTF8_BOM": false + }, + "candidate": { + "sha256": "7f3d88d1649bff3f99a13b7f38ee31cac0dc53f51e438d8320158fad5642e0a5", + "bytes": 11633, + "EOL": "CRLF", + "CRLF": 246, + "LF": 246, + "UTF8_BOM": false + } + }, + { + "path": "crates/render/src/raytrace/anisotropic_reflection_image_tests.rs", + "group": "mechanical_non_ui", + "before": { + "sha256": "8d994a5fd9ef7711fd853b0e6d79bc5debbd0e36356a1e5ebebabf94feb9bc5d", + "bytes": 14036, + "EOL": "CRLF", + "CRLF": 317, + "LF": 317, + "UTF8_BOM": false + }, + "candidate": { + "sha256": "fd27088c2ad9ed204d71a4c3dc383860fd8c02a32b4c2d6e49b88ca6b1991ce9", + "bytes": 14057, + "EOL": "CRLF", + "CRLF": 317, + "LF": 317, + "UTF8_BOM": false + } + }, + { + "path": "crates/render/src/raytrace/deterministic_primary_tests.rs", + "group": "mechanical_non_ui", + "before": { + "sha256": "efdd751d6b2e208d6be4b7ff7f2ed1c9f35cef8266a140eeff7405494e02ef07", + "bytes": 26598, + "EOL": "CRLF", + "CRLF": 612, + "LF": 612, + "UTF8_BOM": false + }, + "candidate": { + "sha256": "99f0590d106a85204bf404db64439adce0011980274159b3a8720fb5d34329b7", + "bytes": 26640, + "EOL": "CRLF", + "CRLF": 612, + "LF": 612, + "UTF8_BOM": false + } + }, + { + "path": "crates/render/src/raytrace/dielectric_tests.rs", + "group": "mechanical_non_ui", + "before": { + "sha256": "cd6654b63e310fa8c06972060e00c65d056fa691d52c081f2c01fbf41fd2c5cd", + "bytes": 34054, + "EOL": "LF", + "CRLF": 0, + "LF": 735, + "UTF8_BOM": false + }, + "candidate": { + "sha256": "e5feb689b944ee6a5247ea8dcab571728367b21faf49f1ecfc0a20ac4bcab198", + "bytes": 34075, + "EOL": "LF", + "CRLF": 0, + "LF": 735, + "UTF8_BOM": false + } + }, + { + "path": "crates/render/src/raytrace/environment_image_tests.rs", + "group": "mechanical_non_ui", + "before": { + "sha256": "48e78f834af1df766d602167c7032628bc158629eec655334d0ed781e8836c85", + "bytes": 14799, + "EOL": "CRLF", + "CRLF": 305, + "LF": 305, + "UTF8_BOM": false + }, + "candidate": { + "sha256": "ff7325ccdb9a56bd5b7e9163ba0691ae05bda7e55569f8a648958621d29f23d3", + "bytes": 14820, + "EOL": "CRLF", + "CRLF": 305, + "LF": 305, + "UTF8_BOM": false + } + }, + { + "path": "crates/render/src/raytrace/environment_reflection_tests.rs", + "group": "mechanical_non_ui", + "before": { + "sha256": "24e3d3378d6ef31a940e218cc0cbc072a7e9bad021411c24bb18e22bc861c0af", + "bytes": 12780, + "EOL": "CRLF", + "CRLF": 295, + "LF": 295, + "UTF8_BOM": false + }, + "candidate": { + "sha256": "beecd012fa3cb742198574c8cdc64179c260e08644986cb59198b014d25372cd", + "bytes": 12801, + "EOL": "CRLF", + "CRLF": 295, + "LF": 295, + "UTF8_BOM": false + } + }, + { + "path": "crates/render/src/raytrace/image_tests.rs", + "group": "mechanical_non_ui", + "before": { + "sha256": "4a4f46bc26e560fe4087a4fbf4439ea768d05fec2a414af7ad371f5a6897f62d", + "bytes": 115864, + "EOL": "LF", + "CRLF": 0, + "LF": 2455, + "UTF8_BOM": false + }, + "candidate": { + "sha256": "7973017ddeead9c87bd64e932c78a33fbcaaba2284a6af6e05f6e05f48350df2", + "bytes": 115885, + "EOL": "LF", + "CRLF": 0, + "LF": 2455, + "UTF8_BOM": false + } + }, + { + "path": "crates/render/src/raytrace/primary_aa_tests.rs", + "group": "mechanical_non_ui", + "before": { + "sha256": "66f4d53f8f544c8eeaad8ef7879b50163bcf64528d9aafd20f2c248b1e758e50", + "bytes": 89705, + "EOL": "LF", + "CRLF": 0, + "LF": 1810, + "UTF8_BOM": false + }, + "candidate": { + "sha256": "74b7d278b75a2f566301f458c7f6aac557bbf12faef8ce3cd3eb5c9baff3cac4", + "bytes": 89747, + "EOL": "LF", + "CRLF": 0, + "LF": 1810, + "UTF8_BOM": false + } + }, + { + "path": "crates/render/src/raytrace/punctual_image_tests.rs", + "group": "mechanical_non_ui", + "before": { + "sha256": "47a59a1361a6dfe6d4fb880c411c5932bbdf8809eb479058bd29237f4ce3f442", + "bytes": 11405, + "EOL": "CRLF", + "CRLF": 275, + "LF": 275, + "UTF8_BOM": false + }, + "candidate": { + "sha256": "d3f7ee57bfc84298fb36607989e71764734176f2a47e6f468e29fcd31fee6491", + "bytes": 11426, + "EOL": "CRLF", + "CRLF": 275, + "LF": 275, + "UTF8_BOM": false + } + }, + { + "path": "crates/render/src/raytrace/reflection_image_tests.rs", + "group": "mechanical_non_ui", + "before": { + "sha256": "8148967b0ca991b9d685a9c133f7082213cc00c5f442b27801eb8b500eebe575", + "bytes": 15786, + "EOL": "CRLF", + "CRLF": 324, + "LF": 324, + "UTF8_BOM": false + }, + "candidate": { + "sha256": "3e775cd9d2e1543ba629acdf6b0b5e4c48cd2c3f6222e6ffbdf0d1a54681182e", + "bytes": 15807, + "EOL": "CRLF", + "CRLF": 324, + "LF": 324, + "UTF8_BOM": false + } + }, + { + "path": "tools/render-library/native_smoke.rs", + "group": "mechanical_non_ui", + "before": { + "sha256": "f9563f490a5b636415a861b14a61e8c10f0719b86eb3b224c4f7e93b00561b48", + "bytes": 6578, + "EOL": "CRLF", + "CRLF": 147, + "LF": 147, + "UTF8_BOM": false + }, + "candidate": { + "sha256": "cbf897b7c16a613906967d00e4968c04d022785524919a20bc10ec0773cb4e7a", + "bytes": 6599, + "EOL": "CRLF", + "CRLF": 147, + "LF": 147, + "UTF8_BOM": false + } + }, + { + "path": "crates/ui-egui/src/render_workspace_tests.rs", + "group": "mechanical_ui", + "before": { + "sha256": "5eeb9bb333cad6936dae8bade8c3be0eece2cea7f52d274c6bd59b28c42625d9", + "bytes": 545234, + "EOL": "LF", + "CRLF": 0, + "LF": 10030, + "UTF8_BOM": false + }, + "candidate": { + "sha256": "8cdbbfafe9c65fef6be665198fd77b61bf494195310cad58bb43e9d0d1c20803", + "bytes": 545297, + "EOL": "LF", + "CRLF": 0, + "LF": 10030, + "UTF8_BOM": false + } + }, + { + "path": "crates/ui-egui/src/render_workspace_thumbnails.rs", + "group": "mechanical_ui", + "before": { + "sha256": "50c67ceb50118dd7e85f34beae80cf35974588f5e022c5c7461857f617087d29", + "bytes": 7454, + "EOL": "CRLF", + "CRLF": 184, + "LF": 184, + "UTF8_BOM": false + }, + "candidate": { + "sha256": "4b3f2cc6380600c536fdc0068f09ef48461e2d453f8e09be21b4a80eab05f823", + "bytes": 7475, + "EOL": "CRLF", + "CRLF": 184, + "LF": 184, + "UTF8_BOM": false + } + } + ], + "additive_correction_bindings": [ + { + "label": "F1 test DTO paths", + "original_manifest_sha256": "d7fdb13cfd7e2e1aaccc212726958ad41c91551792accb1d5a64535df79a4272", + "patch": "04-f1-test-dto-path.patch", + "files": [ + { + "path": "crates/render/src/job/image_tests.rs", + "before": { + "sha256": "a82677ca2e3af1e7110b31e4ea74931ab23ff4f40863a756c2990367d98f995a", + "bytes": 23775, + "EOL": "LF", + "CRLF": 0, + "LF": 475, + "UTF8_BOM": false + }, + "candidate": { + "sha256": "c1b82d29297c831c7cef6d6749c32887257078678edc5d334880898f8be8e60e", + "bytes": 23795, + "EOL": "LF", + "CRLF": 0, + "LF": 475, + "UTF8_BOM": false + } + } + ] + }, + { + "label": "F2 empty capacity billing", + "original_manifest_sha256": "68de0bc3a7311dc8020ca4f17df6393151c0e466c05c5a004438b366804aec2c", + "patch": "05-f2-empty-capacity.patch", + "files": [ + { + "path": "crates/render/src/job/raster_lights.rs", + "before": { + "sha256": "2e5de123b2aba2ac44ef409f3b07882dd909b077d0046080b6bd82de171ae469", + "bytes": 5402, + "EOL": "LF", + "CRLF": 0, + "LF": 123, + "UTF8_BOM": false + }, + "candidate": { + "sha256": "3ce43f30255b209dd9ad6bb36034f2678d7c0f03d7b6934ae4ba67dac908d63b", + "bytes": 5463, + "EOL": "LF", + "CRLF": 0, + "LF": 124, + "UTF8_BOM": false + } + }, + { + "path": "crates/render/src/job/image_tests.rs", + "before": { + "sha256": "c1b82d29297c831c7cef6d6749c32887257078678edc5d334880898f8be8e60e", + "bytes": 23795, + "EOL": "LF", + "CRLF": 0, + "LF": 475, + "UTF8_BOM": false + }, + "candidate": { + "sha256": "236e56d0943780929d0d31711d38807c1fad013877285aa4bc8f0aba31b53207", + "bytes": 25575, + "EOL": "LF", + "CRLF": 0, + "LF": 507, + "UTF8_BOM": false + } + } + ] + }, + { + "label": "F3 borrowed JSON before copy", + "original_manifest_sha256": "c68f10e3bbc0e70e241c1264f564c8357c1881098142dfe30747b84fdb2905ba", + "patch": "06-f3-borrowed-json.patch", + "files": [ + { + "path": "crates/engine/src/cmd/render/jobs.rs", + "before": { + "sha256": "b4cbe807251130730b3f9ff3eb34ee9ce24b4ba28dd887d1d8beca646fce3e5c", + "bytes": 65570, + "EOL": "LF", + "CRLF": 0, + "LF": 1277, + "UTF8_BOM": false + }, + "candidate": { + "sha256": "523346f6b0432c290c80180363ce7804de449623df884aa52a03c47d4589507c", + "bytes": 66004, + "EOL": "LF", + "CRLF": 0, + "LF": 1283, + "UTF8_BOM": false + } + }, + { + "path": "crates/engine/src/cmd/render/job_tests.rs", + "before": { + "sha256": "22ed3118fc92b84fbe80645ee4c44c64d1753e4979e4132677bdba6f4272156f", + "bytes": 71850, + "EOL": "CRLF", + "CRLF": 1271, + "LF": 1271, + "UTF8_BOM": false + }, + "candidate": { + "sha256": "cefb4fb9b11dffb79148a79b3a43eb0011df7f725fdd9a98c809bfad694a5cbb", + "bytes": 73905, + "EOL": "CRLF", + "CRLF": 1316, + "LF": 1316, + "UTF8_BOM": false + } + } + ] + } + ], + "final_reviewed_archival_endpoint_hashes": { + "crates/engine/src/cmd/render.rs": "869a7bb3345d0dfe7d220eccfa9d8ac11421723fbccacb73b596a6bbfc0e5f02", + "crates/engine/src/cmd/render/job_tests.rs": "cefb4fb9b11dffb79148a79b3a43eb0011df7f725fdd9a98c809bfad694a5cbb", + "crates/engine/src/cmd/render/jobs.rs": "523346f6b0432c290c80180363ce7804de449623df884aa52a03c47d4589507c", + "crates/engine/src/render_jobs.rs": "80a110ce652c01d7de86a8627582a08a8d87f5670ba8e9703d1271f3592b40e7", + "crates/gpu/src/path/denoise_tests.rs": "2e3d2f17590457407389be4458640257f39d629422dc03fd476adbd19077b313", + "crates/gpu/src/path/mod.rs": "7ac11bb0cff6d740fc520dd62840aae2815961f34e6251fd3e1cffdc4edede23", + "crates/gpu/src/path/tests.rs": "bc337ca1f22c3554fb51a47787de9d5a104e50311ec399ae2286e7e606b0b0bb", + "crates/render/examples/cpu_resource_smoke.rs": "6200bd74b322b069c21253e6733385a4c296523b37cf2a12aea8259b2bd16674", + "crates/render/src/job/host.rs": "f4892fbc5940d2151caeca66d1355d12d4b50570c422b83784bf0bae2a0f98e0", + "crates/render/src/job/host_regrade_tests.rs": "0d6528440bca497a097600da7fbab084d946adba65ea0575919d6602be97f5f4", + "crates/render/src/job/host_tests.rs": "9f85c3fc5f339fae97ab3cd39f06e54cfcc0231573baac563695f89fe4a5f269", + "crates/render/src/job/image.rs": "3e98059f9510e0ed9de16442a6c65801b6757a66cb88b902f427313c7e712912", + "crates/render/src/job/image_tests.rs": "236e56d0943780929d0d31711d38807c1fad013877285aa4bc8f0aba31b53207", + "crates/render/src/job/interactive.rs": "5fb7062276adfdc22d1fa651750119feb90870b31d12fb0fc0b852c4b430468d", + "crates/render/src/job/led_strip/tests.rs": "6cf184c9183e120394e5030c745e33e217d5915da914be7546389b8de480c037", + "crates/render/src/job/mod.rs": "79c24d3f921c7e78044a32f3b829211380e234672f07a5b86f740dcf814fdebd", + "crates/render/src/job/png.rs": "61beefeaca1c219c427ec68c5f776f7b0e68c422c9930b3829c63119b9f2bdc9", + "crates/render/src/job/raster_lights.rs": "3ce43f30255b209dd9ad6bb36034f2678d7c0f03d7b6934ae4ba67dac908d63b", + "crates/render/src/job/regrade.rs": "6f7a76b2e153f444939e0475cf835a5dbc996513a5622ce803ac050f019bd08e", + "crates/render/src/job/rt2_tests.rs": "cb37434a1199d7a3b5dc60aba19a981e5712fffe4a5d95c5c6fcec507b189e82", + "crates/render/src/raytrace/anisotropic_faces_tests.rs": "7f3d88d1649bff3f99a13b7f38ee31cac0dc53f51e438d8320158fad5642e0a5", + "crates/render/src/raytrace/anisotropic_reflection_image_tests.rs": "fd27088c2ad9ed204d71a4c3dc383860fd8c02a32b4c2d6e49b88ca6b1991ce9", + "crates/render/src/raytrace/deterministic_primary_tests.rs": "99f0590d106a85204bf404db64439adce0011980274159b3a8720fb5d34329b7", + "crates/render/src/raytrace/dielectric_tests.rs": "e5feb689b944ee6a5247ea8dcab571728367b21faf49f1ecfc0a20ac4bcab198", + "crates/render/src/raytrace/environment_image_tests.rs": "ff7325ccdb9a56bd5b7e9163ba0691ae05bda7e55569f8a648958621d29f23d3", + "crates/render/src/raytrace/environment_reflection_tests.rs": "beecd012fa3cb742198574c8cdc64179c260e08644986cb59198b014d25372cd", + "crates/render/src/raytrace/image_tests.rs": "7973017ddeead9c87bd64e932c78a33fbcaaba2284a6af6e05f6e05f48350df2", + "crates/render/src/raytrace/primary_aa_tests.rs": "74b7d278b75a2f566301f458c7f6aac557bbf12faef8ce3cd3eb5c9baff3cac4", + "crates/render/src/raytrace/punctual_image_tests.rs": "d3f7ee57bfc84298fb36607989e71764734176f2a47e6f468e29fcd31fee6491", + "crates/render/src/raytrace/reflection_image_tests.rs": "3e775cd9d2e1543ba629acdf6b0b5e4c48cd2c3f6222e6ffbdf0d1a54681182e", + "crates/ui-egui/src/render_workspace_tests.rs": "8cdbbfafe9c65fef6be665198fd77b61bf494195310cad58bb43e9d0d1c20803", + "crates/ui-egui/src/render_workspace_thumbnails.rs": "4b3f2cc6380600c536fdc0068f09ef48461e2d453f8e09be21b4a80eab05f823", + "tools/render-library/native_smoke.rs": "cbf897b7c16a613906967d00e4968c04d022785524919a20bc10ec0773cb4e7a" + }, + "EOL_policy": "Original patch bytes are retained. For exact reconstruction, verify RAW preimage SHA, normalize only physical CRLF to LF where required for text-hunk replay, restore each declared endpoint EOL, and verify the exact RAW candidate SHA. No fuzzy whitespace or universal literal RAW replay claim.", + "new_test_declarations_UNRUN": 14, + "original_review_findings": { + "F1": "New test DTO names fixed by04", + "F2": "Direct empty Vec retained capacity conservatively billed by05", + "F3": "Borrowed strict JSON validation precedes copying the new wire payload in06" + }, + "mechanical_UI_rebind_required": true, + "actual_current_C16_W1_W2_combination_invented_or_adopted": false, + "UI_editor_saved_format_nonzero_EV_supported_or_physical_glass_enabled": false +}