Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

122 KB
Raw Blame
use super::*;
use solidcraft_geom::{Aabb3, Mesh};

fn fixed_request_metadata_bytes() -> u64 {
    request().retained_resource_metadata_bytes()
}

#[cfg(all(feature = "raytrace-cpu", not(target_arch = "wasm32")))]
mod progressive_checkpoints {
    use super::*;
    use crate::job::{CpuProgressiveOptions, RaytraceOptions};

    // The production native admission/Running path, manually advanced so tests
    // can stop exactly between hashing and the cancellation/publication lock.
    fn fixture(samples: u32) -> (CpuHost, JobHandle, Running) {
        let host = ImageHost(Arc::new(Owner {
            executor: None,
            shared: CpuHost::shared(MEMORY_LIMIT),
            kind: HostKind::NativeWorker,
            running: Mutex::new(None),
            _worker: None,
        }));
        let request = ImageRequest {
            integrator: Integrator::Raytrace,
            raytrace: Some(RaytraceOptions {
                progressive: Some(CpuProgressiveOptions { samples_per_pixel: samples, seed: 123 }),
                lights: Some(Vec::new()),
                ..Default::default()
            }),
            width: 4,
            height: 4,
            ..request()
        };
        let expected = admit(&empty(), &request).unwrap().estimated_total_bytes + request.retained_resource_metadata_bytes();
        let job = host.submit(id(7300, 1), 19, empty(), request).unwrap();
        assert_eq!(host.admitted_bytes(), expected);
        let work = host.0.shared.queue.lock().unwrap().pop_front().unwrap();
        let running = Running::begin(work).unwrap();
        (host, job, running)
    }

    fn before_preview(running: &mut Running) {
        for _ in 0..100_000 {
            if running.pending_png.as_ref().is_some_and(|p| p.preview_samples.is_some()) {
                return;
            }
            assert!(running.advance(1).unwrap());
        }
        panic!("small CPU job did not reach its checkpoint");
    }

    #[test]
    fn checkpoints_transfer_png_allocations_and_keep_every_external_lease() {
        let (host, job, mut running) = fixture(3);
        let initial = host.admitted_bytes();
        let mut held = Vec::new();
        for (sequence, samples) in [(1, 1), (2, 2)] {
            before_preview(&mut running);
            let pointer = running.pending_png.as_ref().unwrap().png.as_ptr();
            assert!(running.task.is_some(), "a preview must retain film, BVH and task state");
            assert!(running.advance(1).unwrap());
            let preview = job.preview().unwrap().unwrap();
            assert_eq!(preview.png().as_ptr(), pointer, "PNG ownership moves without cloning its allocation");
            assert_eq!(preview.info.frame_sequence, sequence);
            assert_eq!(preview.info.samples_per_pixel, samples);
            assert_eq!(preview.info.frame.job, job.id());
            assert_eq!(preview.info.frame.scene_generation, 19);
            assert_eq!(preview.info.frame.png_sha256, format!("{:x}", Sha256::digest(preview.png())));
            assert!(job.frame().unwrap().is_none());
            assert!(job.status().unwrap().frame.is_none());
            assert_eq!(host.admitted_bytes(), initial, "splitting a prepaid lease does not change pool usage");
            held.push(preview);
        }
        let mut complete = false;
        for _ in 0..100_000 {
            if !running.advance(1).unwrap() {
                complete = true;
                break;
            }
        }
        assert!(complete);
        assert_eq!(job.status().unwrap().progress.phase, Phase::Completed);
        assert!(job.preview().unwrap().is_none());
        let frame = job.frame().unwrap().unwrap();
        assert_eq!(frame.info.job, job.id());
        let retained: u64 = held.iter().map(|p| p._reservation.bytes).sum();
        assert_eq!(host.admitted_bytes(), retained + frame._reservation.bytes + fixed_request_metadata_bytes());
        drop(running);
        drop(job);
        drop(frame);
        assert_eq!(host.admitted_bytes(), retained);
        while let Some(preview) = held.pop() {
            let before = host.admitted_bytes();
            let bytes = preview._reservation.bytes;
            drop(preview);
            assert_eq!(host.admitted_bytes(), before - bytes);
        }
        assert_eq!(host.admitted_bytes(), 0);
    }

    #[test]
    fn two_pass_target_retains_one_snapshot_slot_without_blocking_final() {
        let (host, job, mut running) = fixture(2);
        let credits = running.checkpoints.as_ref().unwrap();
        assert_eq!(credits.capacity, credits.slot_bytes + FRAME_METADATA_BYTES);
        before_preview(&mut running);
        assert!(running.advance(1).unwrap());
        let preview = job.preview().unwrap().unwrap();
        assert_eq!(preview.info.frame_sequence, 1);
        assert_eq!(preview.info.samples_per_pixel, 1);
        let before = preview.png().to_vec();
        while running.advance(1).unwrap() {}
        assert_eq!(job.status().unwrap().progress.phase, Phase::Completed);
        assert_eq!(job.status().unwrap().preview_retention_skips, 0);
        assert!(job.preview().unwrap().is_none());
        let frame = job.frame().unwrap().unwrap();
        assert_eq!(frame.info.job, job.id());
        assert_eq!(preview.png(), before, "the sole retained checkpoint remains immutable");
        assert_eq!(host.admitted_bytes(), frame._reservation.bytes + preview._reservation.bytes + fixed_request_metadata_bytes());
        drop(running);
        drop(job);
        drop(frame);
        assert_eq!(host.admitted_bytes(), preview._reservation.bytes);
        drop(preview);
        assert_eq!(host.admitted_bytes(), 0);
    }

    #[test]
    fn checkpoint_memory_is_independent_of_target_after_two_prepaid_slots() {
        let mut estimated = Vec::new();
        for samples in [3, 8, 64] {
            let (host, job, running) = fixture(samples);
            estimated.push(host.admitted_bytes());
            assert_eq!(running.checkpoints.as_ref().unwrap().capacity, 2 * running.checkpoints.as_ref().unwrap().slot_bytes + FRAME_METADATA_BYTES);
            drop(running);
            drop(job);
            assert_eq!(host.admitted_bytes(), 0);
        }
        assert!(estimated.windows(2).all(|pair| pair[0] == pair[1]));
        assert!(std::mem::size_of::<CheckpointCredits>() + 32 <= FRAME_METADATA_BYTES as usize);
    }

    #[test]
    fn every_pass_reuses_two_slots_without_consumer_acknowledgement() {
        let (host, job, mut running) = fixture(8);
        let initial = host.admitted_bytes();
        let mut prefixes = Vec::new();
        for samples in 1..8 {
            before_preview(&mut running);
            assert!(running.advance(1).unwrap());
            let preview = job.preview().unwrap().unwrap();
            assert_eq!(preview.info.samples_per_pixel, samples);
            assert_eq!(preview.info.frame_sequence, samples);
            assert_eq!(preview.info.frame.job, job.id());
            assert_eq!(preview.info.frame.scene_generation, 19);
            assert_eq!(preview.info.frame.png_sha256, format!("{:x}", Sha256::digest(preview.png())));
            prefixes.push(preview.png().to_vec());
            assert_eq!(host.admitted_bytes(), initial);
            assert_eq!(job.status().unwrap().preview_retention_skips, 0);
            // This temporary consumer drops its Arc; the host's old snapshot is
            // reclaimed by the next publication without an acknowledgement API.
        }
        while running.advance(1).unwrap() {}
        let frame = job.frame().unwrap().unwrap();
        assert_eq!(frame.info.job, job.id());
        assert_eq!(job.status().unwrap().progress.phase, Phase::Completed);
        assert_eq!(host.admitted_bytes(), frame._reservation.bytes + fixed_request_metadata_bytes());
        assert_eq!(prefixes.len(), 7);
        drop(running);
        drop(job);
        drop(frame);
        assert_eq!(host.admitted_bytes(), 0);
    }

    #[test]
    fn pinned_snapshots_skip_publication_then_resume_without_stalling_final_work() {
        let (host, job, mut running) = fixture(8);
        let initial = host.admitted_bytes();
        before_preview(&mut running);
        assert!(running.advance(1).unwrap());
        let first = job.preview().unwrap().unwrap();
        let first_bytes = first.png().to_vec();
        before_preview(&mut running);
        assert!(running.advance(1).unwrap());
        let second = job.preview().unwrap().unwrap();
        let second_bytes = second.png().to_vec();
        before_preview(&mut running);
        assert_eq!(running.pending_png.as_ref().unwrap().preview_samples, Some(3));
        assert!(running.advance(1).unwrap());
        assert_eq!(job.status().unwrap().preview_retention_skips, 1);
        let retained = job.preview().unwrap().expect("a skipped publication must keep the latest published preview available");
        assert!(Arc::ptr_eq(&retained, &second), "a pinned latest preview must retain its existing allocation and lease");
        let status = job.status().unwrap();
        let preview = status.preview.expect("status must still identify the latest published complete pass");
        assert_eq!(preview.frame_sequence, 2);
        assert_eq!(preview.samples_per_pixel, 2);
        assert_eq!(preview.frame.png_sha256, second.info.frame.png_sha256);
        drop(retained);
        assert!(job.frame().unwrap().is_none());
        assert_eq!(host.admitted_bytes(), initial);
        assert_eq!(first.png(), first_bytes);
        assert_eq!(second.png(), second_bytes);
        drop(first);
        for samples in 4..8 {
            before_preview(&mut running);
            assert!(running.advance(1).unwrap());
            let preview = job.preview().unwrap().unwrap();
            assert_eq!(preview.info.samples_per_pixel, samples);
            assert_eq!(preview.info.frame_sequence, samples - 1, "sequence counts real publications");
            assert_eq!(host.admitted_bytes(), initial);
        }
        while running.advance(1).unwrap() {}
        assert_eq!(job.status().unwrap().progress.phase, Phase::Completed);
        assert_eq!(job.status().unwrap().preview_retention_skips, 1);
        assert!(job.preview().unwrap().is_none());
        assert_eq!(second.png(), second_bytes, "old snapshots remain immutable through final publication");
        let frame = job.frame().unwrap().unwrap();
        assert_eq!(host.admitted_bytes(), frame._reservation.bytes + second._reservation.bytes + fixed_request_metadata_bytes());
        drop(running);
        drop(job);
        drop(frame);
        assert_eq!(host.admitted_bytes(), second._reservation.bytes);
        drop(second);
        assert_eq!(host.admitted_bytes(), 0);
    }

    #[test]
    fn retaining_both_slots_never_prevents_completion() {
        let (host, job, mut running) = fixture(8);
        before_preview(&mut running);
        assert!(running.advance(1).unwrap());
        let first = job.preview().unwrap().unwrap();
        before_preview(&mut running);
        assert!(running.advance(1).unwrap());
        let second = job.preview().unwrap().unwrap();
        while running.advance(1).unwrap() {}
        assert_eq!(job.status().unwrap().progress.phase, Phase::Completed);
        assert_eq!(job.status().unwrap().preview_retention_skips, 5);
        assert_eq!(first.info.samples_per_pixel, 1);
        assert_eq!(second.info.samples_per_pixel, 2);
        drop(running);
        drop(job);
        drop(first);
        drop(second);
        assert_eq!(host.admitted_bytes(), 0);
    }

    #[test]
    fn cancellation_before_or_after_digest_cannot_publish_a_late_preview() {
        for finish_digest in [false, true] {
            let (host, job, mut running) = fixture(3);
            before_preview(&mut running);
            assert!(running.advance(1).unwrap());
            let held = job.preview().unwrap().unwrap();
            before_preview(&mut running);
            if finish_digest {
                let pending = running.pending_png.as_mut().unwrap();
                while !pending.step(1, &job.0.cancel).unwrap() {}
                assert_eq!(pending.hashed, pending.png.len());
            }
            job.cancel().unwrap();
            assert!(job.preview().unwrap().is_none(), "cancel removes the provisional slot immediately");
            assert!(!running.guarded_step(1));
            assert_eq!(job.status().unwrap().progress.phase, Phase::Cancelled);
            assert!(job.frame().unwrap().is_none());
            drop(running);
            drop(job);
            assert_eq!(host.admitted_bytes(), held._reservation.bytes);
            assert_eq!(held.info.samples_per_pixel, 1);
            drop(held);
            assert_eq!(host.admitted_bytes(), 0);
        }
    }

    #[test]
    fn an_invalid_checkpoint_sequence_fails_without_replacing_the_old_snapshot() {
        let (host, job, mut running) = fixture(4);
        before_preview(&mut running);
        assert!(running.advance(1).unwrap());
        let held = job.preview().unwrap().unwrap();
        before_preview(&mut running);
        running.pending_png.as_mut().unwrap().preview_samples = Some(3);
        assert!(!running.guarded_step(1));
        assert_eq!(job.status().unwrap().progress.phase, Phase::Failed);
        assert!(job.preview().unwrap().is_none());
        assert!(job.frame().unwrap().is_none());
        assert_eq!(held.info.samples_per_pixel, 1);
        drop(running);
        drop(job);
        assert_eq!(host.admitted_bytes(), held._reservation.bytes);
        drop(held);
        assert_eq!(host.admitted_bytes(), 0);
    }
}

fn request() -> ImageRequest {
    ImageRequest {
        studio_weights: None,
        integrator: Default::default(),
        raytrace: None,
        textures: None,
        environment: None,
        camera: Default::default(),
        width: 16,
        height: 16,
        background: [40, 80, 120],
        transparent_background: false,
    }
}

#[test]
fn legacy_image_requests_default_to_raster_and_reject_unknown_integrators() {
    let mut value = serde_json::to_value(request()).unwrap();
    value.as_object_mut().unwrap().remove("integrator");
    let decoded: ImageRequest = serde_json::from_value(value.clone()).unwrap();
    assert_eq!(decoded.integrator, Integrator::Raster);
    value["integrator"] = serde_json::json!("gpu_pathtrace");
    assert!(serde_json::from_value::<ImageRequest>(value).is_err());
}

#[cfg(feature = "raytrace-cpu")]
#[test]
fn cooperative_raytrace_descriptor_matches_native_only_validation() {
    let host = CpuHost::cooperative();
    assert!(host.validate_integrator(Integrator::Raytrace).is_err());
    assert!(matches!(host.descriptor_for(Integrator::Raytrace).unwrap().availability, Availability::Unavailable { .. }));
    assert!(host.validate_integrator(Integrator::Raster).is_ok());
    assert!(!host.descriptor_for(Integrator::Raytrace).unwrap().profiles.iter().any(|p| p.features.contains(&crate::RenderFeature::Refraction)));
}

#[cfg(all(feature = "raytrace-cpu", not(target_arch = "wasm32")))]
#[test]
fn native_raytrace_refraction_capability_resolves_only_preview_images() {
    let host = CpuHost::for_platform().unwrap();
    let descriptor = host.descriptor_for(Integrator::Raytrace).unwrap();
    assert_eq!(descriptor.availability, Availability::Available);
    assert!(descriptor.profiles.iter().any(|profile| profile.features.contains(&crate::RenderFeature::Refraction)));
    let mut backend = crate::builtin_backend();
    backend.executors = vec![descriptor];
    let mut request = crate::RenderRequest {
        backend: None,
        mode: RenderMode::Preview,
        operation: RenderOperation::Image,
        width: 1,
        height: 1,
        format: Some(RenderFormat::Png),
        features: vec![crate::RenderFeature::Refraction],
        policy: Default::default(),
    };
    let resolved = crate::resolve_request(std::slice::from_ref(&backend), &request).unwrap();
    assert_eq!(resolved.executor.as_str(), "cpu-raytrace");
    request.mode = RenderMode::Final;
    assert!(crate::resolve_request(std::slice::from_ref(&backend), &request).is_err());
    request.mode = RenderMode::Preview;
    backend.executors = vec![host.descriptor_for(Integrator::Raster).unwrap()];
    assert!(crate::resolve_request(&[backend], &request).is_err(), "CPU raster must not advertise physical refraction");
    assert_eq!(host.admitted_bytes(), 0, "capability discovery never starts a render");
}

#[cfg(not(feature = "raytrace-cpu"))]
#[test]
fn compiled_out_raytracing_never_enters_the_host_queue() {
    let host = CpuHost::cooperative();
    let mut request = request();
    request.integrator = Integrator::Raytrace;
    assert!(host.validate_integrator(Integrator::Raytrace).unwrap_err().message.contains("not compiled in"));
    assert!(host.descriptor_for(Integrator::Raytrace).is_err());
    let error = host.submit(JobId { session: 1, serial: 1, generation: 1 }, 0, empty(), request).err().unwrap();
    assert_eq!(error.code, ErrorCode::HostUnavailable);
    assert_eq!(host.admitted_bytes(), 0);
    assert!(!host.pump(1).unwrap());
}
fn empty() -> ProductScene {
    ProductScene { meshes: Vec::new(), bounds: Aabb3::EMPTY }
}
fn id(owner: u64, serial: u64) -> JobId {
    JobId { session: owner, serial, generation: serial }
}
fn drain(host: &CpuHost) {
    for _ in 0..10_000 {
        if !host.pump(4096).unwrap() {
            return;
        }
    }
    panic!("small cooperative jobs did not drain");
}

#[test]
fn queue_is_bounded_and_cancelled_entries_release_their_reservations() {
    let host = CpuHost::cooperative();
    let a = host.submit(id(10, 1), 100, empty(), request()).unwrap();
    let b = host.submit(id(20, 1), 200, empty(), request()).unwrap();
    let before = host.admitted_bytes();
    assert_eq!(host.submit(id(30, 1), 300, empty(), request()).err().unwrap().code, ErrorCode::QueueFull);
    assert_eq!(host.admitted_bytes(), before);
    assert_eq!(a.cancel().unwrap().progress.phase, Phase::Cancelled);
    let c = host.submit(id(30, 1), 300, empty(), request()).unwrap();
    drain(&host);
    assert_eq!(a.status().unwrap().progress.phase, Phase::Cancelled);
    for (handle, owner, generation) in [(&b, 20, 200), (&c, 30, 300)] {
        let frame = handle.frame().unwrap().unwrap();
        assert_eq!(frame.info.job, id(owner, 1));
        assert_eq!(frame.info.scene_generation, generation);
        assert_eq!(frame.info.executor.as_str(), "cpu-product");
        assert_eq!(image::load_from_memory(frame.png()).unwrap().width(), 16);
        assert_eq!(frame.info.png_bytes, frame.png().len() as u64);
        assert_eq!(frame.info.png_sha256, format!("{:x}", Sha256::digest(frame.png())));
        assert_eq!(handle.status().unwrap().frame.unwrap().png_sha256, frame.info.png_sha256);
    }
    assert!(host.admitted_bytes() > 0 && host.admitted_bytes() < before);
    let frame = b.frame().unwrap().unwrap();
    drop(b);
    drop(c);
    assert!(host.admitted_bytes() > 0, "an externally retained frame retains its lease");
    drop(frame);
    assert_eq!(host.admitted_bytes(), fixed_request_metadata_bytes());
    drop(a);
    assert_eq!(host.admitted_bytes(), 0);
}

#[test]
fn cancellation_while_encoding_cannot_publish_a_late_frame() {
    let host = CpuHost::cooperative();
    let job = host.submit(id(1, 1), 8, empty(), request()).unwrap();
    for _ in 0..10_000 {
        host.pump(64).unwrap();
        let status = job.status().unwrap();
        if status.progress.phase == Phase::Encoding && status.progress.done > 0 {
            break;
        }
    }
    assert_eq!(job.status().unwrap().progress.phase, Phase::Encoding);
    assert_eq!(job.cancel().unwrap().progress.phase, Phase::Cancelling);
    drain(&host);
    assert_eq!(job.status().unwrap().progress.phase, Phase::Cancelled);
    assert!(job.frame().unwrap().is_none());
    assert_eq!(host.admitted_bytes(), fixed_request_metadata_bytes());
    drop(job);
    assert_eq!(host.admitted_bytes(), 0);
}

#[test]
fn malformed_geometry_is_rejected_without_stopping_the_host() {
    let host = CpuHost::cooperative();
    let scene = ProductScene {
        bounds: Aabb3::EMPTY,
        meshes: vec![crate::ProductMesh {
            name: "Broken".into(),
            mesh: Arc::new(Mesh { triangles: vec![[99, 99, 99]], ..Default::default() }),
            color: [0; 3],
            opacity: 1.0,
            surface: None,
            transmission: None,
            faces: Vec::new(),
        }],
    };
    let error = host.submit(id(1, 1), 1, scene, request()).err().unwrap();
    assert_eq!(error.code, ErrorCode::InvalidScene);
    assert_eq!(host.admitted_bytes(), 0);
    assert!(host.is_available());
    let healthy = host.submit(id(1, 2), 1, empty(), request()).unwrap();
    drain(&host);
    assert_eq!(healthy.status().unwrap().progress.phase, Phase::Completed);
}

#[test]
fn closing_the_host_cancels_active_and_queued_work() {
    let host = CpuHost::cooperative();
    let budget = host.0.shared.budget.clone();
    let active = host.submit(id(1, 1), 1, empty(), request()).unwrap();
    let queued = host.submit(id(2, 1), 1, empty(), request()).unwrap();
    host.pump(1).unwrap();
    drop(host);
    assert_eq!(active.status().unwrap().progress.phase, Phase::Cancelled);
    assert_eq!(queued.status().unwrap().progress.phase, Phase::Cancelled);
    assert_eq!(budget.used.load(Ordering::Acquire), 2 * fixed_request_metadata_bytes());
    drop(active);
    drop(queued);
    assert_eq!(budget.used.load(Ordering::Acquire), 0);
}

#[test]
fn a_foreign_frame_is_rejected_even_if_a_broken_host_puts_it_in_the_result_slot() {
    let host = CpuHost::cooperative();
    let job = host.submit(id(1, 1), 1, empty(), request()).unwrap();
    drain(&host);
    {
        let mut data = job.0.data.lock().unwrap();
        let frame = Arc::get_mut(data.frame.as_mut().unwrap()).unwrap();
        frame.info.job.session = 2;
    }
    assert_eq!(job.frame().err().unwrap().code, ErrorCode::WrongOwner);
}

#[cfg(not(target_arch = "wasm32"))]
#[test]
fn native_job_finishes_without_any_poll_or_ui_pump() {
    let host = CpuHost::for_platform().unwrap();
    assert_eq!(host.kind(), HostKind::NativeWorker);
    let job = host.submit(id(1, 1), 12, empty(), request()).unwrap();
    // A generous deadlock watchdog, not a performance assertion.
    let status = job.wait_timeout(std::time::Duration::from_secs(60)).unwrap();
    assert_eq!(status.progress.phase, Phase::Completed);
    assert_eq!(job.frame().unwrap().unwrap().info.scene_generation, 12);
    let frame = job.frame().unwrap().unwrap();
    assert_eq!(frame.info.png_bytes, frame.png().len() as u64);
    assert_eq!(frame.info.png_sha256, format!("{:x}", Sha256::digest(frame.png())));
    assert_eq!(status.frame.unwrap().png_sha256, frame.info.png_sha256);
    let duration = job.completed_duration().unwrap().unwrap();
    assert_eq!(job.completed_duration().unwrap(), Some(duration), "completed duration is independent of status polling");
}

#[test]
fn completed_duration_is_captured_at_publication_and_never_for_cancelled_work() {
    let host = CpuHost::cooperative();
    let job = host.submit(id(1, 1), 12, empty(), request()).unwrap();
    assert!(job.completed_duration().unwrap().is_none());
    drain(&host);
    let duration = job.completed_duration().unwrap().unwrap();
    assert!(duration.as_secs_f64().is_finite());
    job.status().unwrap();
    host.pump(1).unwrap();
    assert_eq!(job.completed_duration().unwrap(), Some(duration));
    let cancelled = host.submit(id(1, 2), 12, empty(), request()).unwrap();
    cancelled.cancel().unwrap();
    drain(&host);
    assert!(cancelled.completed_duration().unwrap().is_none());
}

/// Isolate the existing integrator-to-host completion boundary with a real PNG
/// from the production encoder. This does not pretend to render the noisy pixels.
fn pending_digest_fixture() -> (CpuHost, JobHandle, Running, usize) {
    let host = CpuHost::cooperative();
    let mut request = request();
    request.width = 256;
    request.height = 128;
    let mut rgba = vec![255; request.width as usize * request.height as usize * 4];
    let mut seed = 0x6a09_e667u32;
    for pixel in rgba.as_chunks_mut::<4>().0 {
        for channel in pixel.iter_mut().take(3) {
            seed ^= seed << 13;
            seed ^= seed >> 17;
            seed ^= seed << 5;
            *channel = seed as u8;
        }
    }
    let mut encoder = super::super::encoding::PngEncoding::new(
        request.width,
        request.height,
        u64::from(request.width) * u64::from(request.height) * 8 + 65_536,
        CancelToken::default(),
    )
    .unwrap();
    let png = loop {
        if let Some(png) = encoder.step(&rgba).unwrap() {
            break png;
        }
    };
    assert!(png.len() > PNG_HASH_CHUNK_BYTES * PNG_HASH_CHUNKS_PER_ADVANCE);
    let length = png.len();
    let job = host.submit(id(61, 1), 99, empty(), request).unwrap();
    let work = host.0.shared.queue.lock().unwrap().pop_front().unwrap();
    let mut running = Running::begin(work).unwrap();
    // Exactly the same state transition used when WorkTask returns Complete.
    running.task = None;
    running.pending_png = Some(PendingPng::new(png));
    (host, job, running, length)
}

#[test]
fn png_digest_is_incremental_and_keeps_the_original_allocation_and_lease_until_completion() {
    let (host, job, mut running, length) = pending_digest_fixture();
    let before = host.admitted_bytes();
    let pointer = running.pending_png.as_ref().unwrap().png.as_ptr();
    assert!(running.advance(0).unwrap());
    assert_eq!(running.pending_png.as_ref().unwrap().hashed, 0, "zero units cannot hash a chunk");
    assert_eq!(host.admitted_bytes(), before);
    assert!(job.frame().unwrap().is_none());
    assert!(running.advance(usize::MAX).unwrap());
    assert_eq!(running.pending_png.as_ref().unwrap().hashed, PNG_HASH_CHUNK_BYTES * PNG_HASH_CHUNKS_PER_ADVANCE);
    assert_eq!(host.admitted_bytes(), before, "hashing must retain the full original work lease");
    assert!(job.frame().unwrap().is_none());
    let mut previous = job.status().unwrap().progress.done;
    while running.advance(1).unwrap() {
        let progress = job.status().unwrap().progress;
        assert_eq!(progress.phase, Phase::Encoding);
        assert_eq!(progress.total, length as u64);
        assert_eq!(progress.done - previous, PNG_HASH_CHUNK_BYTES as u64);
        assert_eq!(host.admitted_bytes(), before);
        assert!(job.frame().unwrap().is_none());
        previous = progress.done;
    }
    assert!(running.task.is_none() && running.pending_png.is_none() && running.reservation.is_none());
    let status = job.status().unwrap();
    assert_eq!(status.progress.phase, Phase::Completed);
    let frame = job.frame().unwrap().unwrap();
    assert_eq!(frame.png().as_ptr(), pointer, "the original Vec moves into the retained frame without cloning");
    assert_eq!(frame.info.png_bytes, length as u64);
    assert_eq!(frame.info.png_sha256.len(), 64);
    assert!(frame.info.png_sha256.bytes().all(|c| c.is_ascii_digit() || (b'a'..=b'f').contains(&c)));
    assert_eq!(frame.info.png_sha256, format!("{:x}", Sha256::digest(frame.png())));
    assert_eq!(status.frame.unwrap().png_sha256, frame.info.png_sha256);
    let decoded = image::load_from_memory(frame.png()).unwrap().to_rgba8();
    assert_eq!(decoded.dimensions(), (256, 128));
    assert!(decoded.pixels().all(|p| p.0[3] == 255));
    assert!(decoded.pixels().any(|p| p.0[..3] != decoded.get_pixel(0, 0).0[..3]));
    let actual_metadata =
        std::mem::size_of::<Running>() + std::mem::size_of::<RenderFrame>() + frame.info.png_sha256.capacity() + 2 * crate::MAX_RENDER_ID_BYTES + 32;
    assert!(actual_metadata <= FRAME_METADATA_BYTES as usize, "digest Vec/offset/state and actual hex allocation must be admitted");
    assert_eq!(host.admitted_bytes(), frame.png.capacity() as u64 + FRAME_METADATA_BYTES + fixed_request_metadata_bytes());
    for _ in 0..3 {
        let current = job.status().unwrap();
        assert_eq!(current.frame.unwrap().png_sha256, frame.info.png_sha256);
        assert_eq!(frame.png().as_ptr(), pointer);
    }
    drop(running);
    drop(job);
    assert!(host.admitted_bytes() > 0);
    drop(frame);
    assert_eq!(host.admitted_bytes(), 0);
}

#[test]
fn cancellation_during_png_hashing_and_host_disposal_cannot_publish_a_frame() {
    for close_host in [false, true] {
        let (host, job, running, _) = pending_digest_fixture();
        let budget = host.0.shared.budget.clone();
        *host.0.running.lock().unwrap() = Some(running);
        assert!(host.pump(1).unwrap());
        assert!(host.0.running.lock().unwrap().as_ref().unwrap().pending_png.as_ref().unwrap().hashed > 0);
        assert_eq!(job.status().unwrap().progress.phase, Phase::Encoding);
        assert!(job.frame().unwrap().is_none());
        if close_host {
            drop(host);
        } else {
            assert_eq!(job.cancel().unwrap().progress.phase, Phase::Cancelling);
            assert!(!host.pump(1).unwrap());
            drop(host);
        }
        assert_eq!(job.status().unwrap().progress.phase, Phase::Cancelled);
        assert!(job.frame().unwrap().is_none());
        assert_eq!(budget.used.load(Ordering::Acquire), fixed_request_metadata_bytes());
        drop(job);
        assert_eq!(budget.used.load(Ordering::Acquire), 0);
    }
}

#[test]
fn a_cancel_after_the_last_digest_chunk_still_wins_the_publication_lock() {
    let (host, job, mut running, _) = pending_digest_fixture();
    let pending = running.pending_png.as_mut().unwrap();
    while !pending.step(1, &job.0.cancel).unwrap() {}
    assert_eq!(pending.hashed, pending.png.len());
    job.cancel().unwrap();
    assert!(!running.guarded_step(1));
    assert_eq!(job.status().unwrap().progress.phase, Phase::Cancelled);
    assert!(job.frame().unwrap().is_none());
    drop(running);
    assert_eq!(host.admitted_bytes(), fixed_request_metadata_bytes());
    drop(job);
    assert_eq!(host.admitted_bytes(), 0);
}

#[test]
fn png_and_exr_reuse_one_sha_state_without_mixing_chunk_boundaries() {
    let png: Vec<u8> = (0..PNG_HASH_CHUNK_BYTES + 7).map(|i| (i % 251) as u8).collect();
    let exr: Vec<u8> = (0..PNG_HASH_CHUNK_BYTES * 2 + 19).map(|i| (i % 239) as u8).collect();
    let mut pending = PendingPng::new(png.clone());
    pending.exr = Some(exr.clone());
    let cancel = CancelToken::default();
    assert!(!pending.step(1, &cancel).unwrap());
    assert!(pending.png_digest.is_none());
    assert!(!pending.step(1, &cancel).unwrap());
    assert_eq!(pending.png_digest.as_ref().unwrap(), &Sha256::digest(&png));
    assert_eq!(pending.exr_hashed, 0);
    while !pending.step(1, &cancel).unwrap() {}
    assert_eq!(pending.digest.finalize(), Sha256::digest(&exr));
    let metadata = std::mem::size_of::<Running>()
        + std::mem::size_of::<RenderFrame>()
        + std::mem::size_of::<RenderPreview>()
        + PREPARED_PROOF_HEADER_BYTES
        + 64
        + 2 * crate::MAX_RENDER_ID_BYTES
        + 32;
    assert!(metadata <= FRAME_METADATA_BYTES as usize);
    eprintln!(
        "fixed completion metadata: Running {}, final {}, preview {}, combined {metadata}/{}",
        std::mem::size_of::<Running>(),
        std::mem::size_of::<RenderFrame>(),
        std::mem::size_of::<RenderPreview>(),
        FRAME_METADATA_BYTES
    );
}

#[test]
fn png_digest_metadata_fits_the_existing_allowance_without_changing_admission() {
    // Fixed digest/offset state and the completed frame (including its bounded
    // hex string and backend/executor IDs) fit the existing 1024-byte allowance.
    assert!(std::mem::size_of::<PendingPng>() <= 512);
    for linear_master in [false, true] {
        let metadata = std::mem::size_of::<Running>()
            + std::mem::size_of::<RenderFrame>()
            + PREPARED_PROOF_HEADER_BYTES
            + 64
            + u32::from(linear_master) as usize * 64
            + 2 * crate::MAX_RENDER_ID_BYTES
            + 32;
        assert!(
            metadata <= FRAME_METADATA_BYTES as usize,
            "PNG/EXR completion metadata {metadata} exceeds {} (Running {}, Frame {}, linear_master {linear_master})",
            FRAME_METADATA_BYTES,
            std::mem::size_of::<Running>(),
            std::mem::size_of::<RenderFrame>()
        );
    }
    let host = CpuHost::cooperative();
    let expected = admit(&empty(), &request()).unwrap().estimated_total_bytes + fixed_request_metadata_bytes();
    let job = host.submit(id(70, 1), 1, empty(), request()).unwrap();
    assert_eq!(host.admitted_bytes(), expected);
    assert!(job.status().unwrap().frame.is_none());
    job.cancel().unwrap();
    drain(&host);
    assert_eq!(host.admitted_bytes(), fixed_request_metadata_bytes());
    drop(job);
    assert_eq!(host.admitted_bytes(), 0);
}

/// An executor whose task reports, as it is dropped, how much of the pool is admitted, and
/// completes after `steps` steps (or never, cancelled on its last one with `cancel_last`).
struct DropProbe {
    admitted_at_drop: Arc<AtomicU64>,
    budget: Arc<std::sync::OnceLock<Arc<Budget>>>,
    estimated: u64,
}
struct ProbeTask {
    admitted_at_drop: Arc<AtomicU64>,
    budget: Arc<std::sync::OnceLock<Arc<Budget>>>,
    steps: u32,
}
impl Drop for ProbeTask {
    fn drop(&mut self) {
        let used = self.budget.get().map_or(u64::MAX, |b| b.used.load(Ordering::Acquire));
        self.admitted_at_drop.store(used, Ordering::Release);
    }
}
impl ImageWork for ProbeTask {
    fn step(&mut self, _units: usize) -> Result<TaskPoll> {
        self.steps += 1;
        if self.steps < 3 {
            return Ok(TaskPoll::Pending(Progress { phase: Phase::Running, done: u64::from(self.steps), total: 3 }));
        }
        Ok(TaskPoll::Complete(vec![0u8; 100]))
    }
}
impl ImageExecutor for DropProbe {
    fn descriptor(&self) -> Result<ExecutorDescriptor> {
        CpuExecutor.descriptor()
    }
    fn admit(&self, _: &ProductScene, _: &ImageRequest, _: JobOptions) -> Result<Admission> {
        Ok(Admission {
            triangles: 0,
            face_appearances: 0,
            projected_pixel_tests: None,
            geometry_bytes: 0,
            pixel_scratch_bytes: self.estimated,
            preparation_bytes: 0,
            estimated_total_bytes: self.estimated,
            encoded_limit: 4096,
        })
    }
    fn begin(&self, _: ProductScene, _: ImageRequest, _: JobOptions, _: CancelToken) -> Result<Box<dyn ImageWork>> {
        Ok(Box::new(ProbeTask { admitted_at_drop: self.admitted_at_drop.clone(), budget: self.budget.clone(), steps: 0 }))
    }
}

fn probe_host(estimated: u64) -> (CpuHost, Arc<AtomicU64>) {
    let admitted_at_drop = Arc::new(AtomicU64::new(0));
    let budget = Arc::new(std::sync::OnceLock::new());
    let host = CpuHost::cooperative_with(Arc::new(DropProbe { admitted_at_drop: admitted_at_drop.clone(), budget: budget.clone(), estimated }));
    let _ = budget.set(host.0.shared.budget.clone());
    (host, admitted_at_drop)
}

#[test]
fn unqualified_executors_refuse_glass_models_and_caustics_before_acquiring_a_lease() {
    let (host, _) = probe_host(1024);
    let options = JobOptions { caustics: Some(Default::default()), ..Default::default() };
    let error = host.admit(&empty(), &request(), options).unwrap_err();
    assert_eq!(error.code, ErrorCode::InvalidRequest);
    assert!(error.message.contains("caustic photons"));
    assert_eq!(host.admitted_bytes(), 0);
    let mut scene = empty();
    scene.meshes.push(crate::ProductMesh {
        name: "Original unsupported-model fixture".into(),
        mesh: Arc::new(Mesh::default()),
        color: [255; 3],
        opacity: 1.0,
        surface: None,
        transmission: Some(
            crate::transmission::Transmission::new(solidcore_record::Vec3::ZERO, None)
                .unwrap()
                .with_model(crate::glass_model::GlassModel { roughness: 0.3, ..Default::default() })
                .unwrap(),
        ),
        faces: Vec::new(),
    });
    let error = host.admit(&scene, &request(), JobOptions::default()).unwrap_err();
    assert!(error.message.contains("advanced Glass models"));
    assert_eq!(host.admitted_bytes(), 0);
}

#[test]
fn a_completed_task_is_dropped_while_its_full_reservation_still_pays_for_it() {
    let estimated = 1 << 20;
    let (host, admitted_at_drop) = probe_host(estimated);
    let job = host.submit(id(1, 1), 1, empty(), request()).unwrap();
    drain(&host);
    assert_eq!(job.status().unwrap().progress.phase, Phase::Completed);
    // While the task (and its scratch) was being dropped, its whole charge was still held.
    assert_eq!(admitted_at_drop.load(Ordering::Acquire), estimated + fixed_request_metadata_bytes());
    // Afterwards only the PNG's lease remains, and the frame keeps it.
    let frame = job.frame().unwrap().unwrap();
    assert!(host.admitted_bytes() > 0 && host.admitted_bytes() < estimated, "{}", host.admitted_bytes());
    drop(job);
    drop(frame);
    assert_eq!(host.admitted_bytes(), 0);
}

#[test]
fn a_cancel_on_the_final_step_publishes_no_frame_and_drops_the_task() {
    let estimated = 1 << 20;
    let (host, admitted_at_drop) = probe_host(estimated);
    let job = host.submit(id(1, 1), 1, empty(), request()).unwrap();
    // Two pending steps, then cancel before the step that would complete.
    host.pump(1).unwrap();
    host.pump(1).unwrap();
    job.cancel().unwrap();
    drain(&host);
    assert_eq!(job.status().unwrap().progress.phase, Phase::Cancelled);
    assert!(job.frame().unwrap().is_none());
    assert_eq!(admitted_at_drop.load(Ordering::Acquire), estimated + fixed_request_metadata_bytes(), "the task went before its charge");
    assert_eq!(host.admitted_bytes(), fixed_request_metadata_bytes());
    drop(job);
    assert_eq!(host.admitted_bytes(), 0);
}

#[test]
fn cpu_and_registered_hosts_keep_separate_job_limits() {
    let cpu = CpuHost::cooperative();
    let (registered, _) = probe_host(400 * 1024 * 1024);
    assert_eq!(cpu.job_limit_bytes(), 384 * 1024 * 1024);
    assert_eq!(registered.job_limit_bytes(), 512 * 1024 * 1024);
    assert_eq!(cpu.pool_limit_bytes(), registered.pool_limit_bytes());
    assert_eq!(registered.pool_limit_bytes(), 512 * 1024 * 1024);
    assert_eq!(registered.admit(&empty(), &request(), JobOptions::default()).unwrap().estimated_total_bytes, 400 * 1024 * 1024);
    assert_eq!(admit_request_sum(400 * 1024 * 1024, 0).unwrap_err().code, ErrorCode::LimitExceeded);
    let (over_budget, _) = probe_host(512 * 1024 * 1024 + 1);
    assert_eq!(over_budget.admit(&empty(), &request(), JobOptions::default()).unwrap_err().code, ErrorCode::LimitExceeded);
    assert_eq!(registered.admitted_bytes(), 0);
}

#[test]
fn registered_hosts_refuse_cpu_integrators_and_options_before_reservation() {
    let (registered, _) = probe_host(1024 * 1024);
    let mut raytrace = request();
    raytrace.integrator = Integrator::Raytrace;
    assert_eq!(registered.validate_integrator(Integrator::Raytrace).unwrap_err().code, ErrorCode::InvalidRequest);
    assert_eq!(registered.descriptor_for(Integrator::Raytrace).unwrap_err().code, ErrorCode::InvalidRequest);
    assert_eq!(registered.admit(&empty(), &raytrace, JobOptions::default()).unwrap_err().code, ErrorCode::InvalidRequest);
    assert_eq!(registered.submit(id(250, 1), 1, empty(), raytrace).err().unwrap().code, ErrorCode::InvalidRequest);
    let mut options = request();
    options.raytrace = Some(super::super::RaytraceOptions::default());
    assert_eq!(registered.admit(&empty(), &options, JobOptions::default()).unwrap_err().code, ErrorCode::InvalidRequest);
    assert_eq!(registered.admitted_bytes(), 0);
    assert!(!registered.pump(1).unwrap());
}

#[test]
fn environment_payload_is_owned_by_admitted_work_not_retained_status() {
    struct ResourceExecutor;
    impl ImageExecutor for ResourceExecutor {
        fn descriptor(&self) -> Result<ExecutorDescriptor> {
            let mut descriptor = CpuExecutor.descriptor()?;
            descriptor.profiles[0].features.push(crate::RenderFeature::Hdri);
            Ok(descriptor)
        }
        fn admit(&self, scene: &ProductScene, request: &ImageRequest, _: JobOptions) -> Result<Admission> {
            let mut admission = admit(scene, &ImageRequest { environment: None, textures: None, ..request.clone() })?;
            admission.estimated_total_bytes += request.environment.as_ref().map_or(0, |source| source.admitted_bytes());
            Ok(admission)
        }
        fn begin(&self, scene: ProductScene, mut request: ImageRequest, _: JobOptions, cancel: CancelToken) -> Result<Box<dyn ImageWork>> {
            request.environment = None;
            Ok(Box::new(ImageTask::new(scene, request, cancel)?))
        }
    }
    for cancelled in [false, true] {
        let host = ImageHost(Arc::new(Owner {
            executor: Some(Arc::new(ResourceExecutor)),
            shared: ImageHost::shared(MEMORY_LIMIT),
            kind: HostKind::Cooperative,
            running: Mutex::new(None),
            #[cfg(not(target_arch = "wasm32"))]
            _worker: None,
        }));
        let source = Arc::new(crate::lighting::environment::EnvironmentSource::sky(Default::default(), 0.0, 1.0).unwrap());
        let weak = Arc::downgrade(&source);
        let mut input = request();
        input.environment = Some(source);
        let job = host.submit(id(1, 1), 1, empty(), input).unwrap();
        let status = job.status().unwrap();
        assert!(status.request.environment.is_none());
        assert!(matches!(status.environment.as_ref(), Some(JobEnvironmentInfo::Gpu(info)) if info.kind == "original_gradient_sky"));
        assert!(weak.upgrade().is_some(), "queuedwork owns source");
        if cancelled {
            job.cancel().unwrap();
        }
        drain(&host);
        assert!(weak.upgrade().is_none(), "completed/cancelled work releases captured source despite retained status/job");
        assert_eq!(job.status().unwrap().progress.phase, if cancelled { Phase::Cancelled } else { Phase::Completed });
    }
}

#[test]
fn texture_payload_is_owned_by_admitted_work_not_retained_status() {
    struct ResourceExecutor;
    impl ImageExecutor for ResourceExecutor {
        fn descriptor(&self) -> Result<ExecutorDescriptor> {
            let mut descriptor = CpuExecutor.descriptor()?;
            descriptor.profiles[0].features.push(crate::RenderFeature::Hdri);
            Ok(descriptor)
        }
        fn admit(&self, scene: &ProductScene, request: &ImageRequest, _: JobOptions) -> Result<Admission> {
            let mut admission = admit(scene, &ImageRequest { environment: None, textures: None, ..request.clone() })?;
            admission.estimated_total_bytes += request.textures.as_ref().map_or(0, |source| source.working_bytes());
            Ok(admission)
        }
        fn begin(&self, scene: ProductScene, mut request: ImageRequest, _: JobOptions, cancel: CancelToken) -> Result<Box<dyn ImageWork>> {
            request.textures = None;
            Ok(Box::new(ImageTask::new(scene, request, cancel)?))
        }
    }
    for cancelled in [false, true] {
        let host = ImageHost(Arc::new(Owner {
            executor: Some(Arc::new(ResourceExecutor)),
            shared: ImageHost::shared(MEMORY_LIMIT),
            kind: HostKind::Cooperative,
            running: Mutex::new(None),
            #[cfg(not(target_arch = "wasm32"))]
            _worker: None,
        }));
        use crate::job::textures::{PlanarFrame, RuntimeTextures, TextureBinding, TextureMap};
        use image::ImageEncoder;
        let mut bytes = Vec::new();
        image::codecs::png::PngEncoder::new(&mut bytes).write_image(&[128, 128, 255, 255], 1, 1, image::ExtendedColorType::Rgba8).unwrap();
        let source = Arc::new(
            RuntimeTextures::new(vec![TextureBinding {
                body_index: 0,
                body_name: "unused test resource".into(),
                frame: PlanarFrame { origin: [0.; 3], u: [1., 0., 0.], v: [0., 1., 0.] },
                normal_strength: 1.,
                base_color: Some(TextureMap::new(bytes, crate::texture_input::MapRole::BaseColor).unwrap()),
                normal: None,
                roughness: None,
                metallic: None,
                base_color_mode: Default::default(),
                flip_v: false,
            }])
            .unwrap(),
        );
        let weak = Arc::downgrade(&source);
        let mut input = request();
        input.textures = Some(source);
        let job = host.submit(id(1, 1), 1, empty(), input).unwrap();
        let status = job.status().unwrap();
        assert!(status.request.textures.is_none());
        assert_eq!(status.textures.as_ref().unwrap().bodies, 1);
        assert!(weak.upgrade().is_some(), "queuedwork owns source");
        if cancelled {
            job.cancel().unwrap();
        }
        drain(&host);
        assert!(weak.upgrade().is_none(), "completed/cancelled work releases captured source despite retained status/job");
        assert_eq!(job.status().unwrap().progress.phase, if cancelled { Phase::Cancelled } else { Phase::Completed });
    }
}

#[test]
fn cpu_film_snapshots_refuse_registered_executors_without_acquiring_a_lease() {
    let (host, _) = probe_host(1 << 20);
    let failure = host.reserve_film_snapshot(1024).err().unwrap();
    assert_eq!(failure.code, ErrorCode::InvalidRequest);
    assert!(failure.message.contains("builtin CPU host"));
    assert_eq!(host.admitted_bytes(), 0);
}

#[cfg(all(feature = "raytrace-cpu", not(target_arch = "wasm32"), target_pointer_width = "64"))]
#[test]
fn native_cpu_envelopes_do_not_expand_registered_or_cooperative_pools() {
    use super::super::{CpuBudget, NATIVE_CPU_POOL_BYTES, RaytraceOptions};
    let cpu = CpuHost::for_platform().unwrap();
    let cooperative = CpuHost::cooperative();
    let (registered, _) = probe_host(1024);
    assert_eq!(cpu.pool_limit_bytes(), NATIVE_CPU_POOL_BYTES);
    assert_eq!(cooperative.pool_limit_bytes(), 512 * 1024 * 1024);
    assert_eq!(registered.pool_limit_bytes(), 512 * 1024 * 1024);
    assert!(cpu.check_request_sum(400 * 1024 * 1024, 0, CpuBudget::Compact).is_err());
    assert!(cpu.check_request_sum(400 * 1024 * 1024, 0, CpuBudget::Studio).is_ok());
    assert!(cpu.check_request_sum(u64::MAX, 1, CpuBudget::Workstation).is_err());
    let mut r = request();
    r.integrator = Integrator::Raytrace;
    r.width = 3840;
    r.height = 2160;
    r.raytrace = Some(RaytraceOptions { budget: CpuBudget::Studio, ..Default::default() });
    assert_eq!(cpu.descriptor_for_request(&r).unwrap().limits, CpuBudget::Studio.image_limits(false));
    r.raytrace.as_mut().unwrap().budget = CpuBudget::Compact;
    assert!(cpu.descriptor_for_request(&r).is_err());
    assert_eq!(cpu.admitted_bytes(), 0);
}

#[cfg(all(not(target_arch = "wasm32"), target_pointer_width = "64"))]
#[test]
fn registered_large_pool_is_explicit_finite_and_accounted() {
    struct Envelope(u64);
    impl ImageExecutor for Envelope {
        fn memory_limit_bytes(&self) -> u64 {
            self.0
        }
        fn descriptor(&self) -> Result<ExecutorDescriptor> {
            CpuExecutor.descriptor()
        }
        fn admit(&self, _: &ProductScene, _: &ImageRequest, _: JobOptions) -> Result<Admission> {
            Ok(Admission {
                triangles: 0,
                face_appearances: 0,
                projected_pixel_tests: None,
                geometry_bytes: 0,
                pixel_scratch_bytes: 0,
                preparation_bytes: 0,
                estimated_total_bytes: 600 * 1024 * 1024,
                encoded_limit: 4096,
            })
        }
        fn begin(&self, _: ProductScene, _: ImageRequest, _: JobOptions, _: CancelToken) -> Result<Box<dyn ImageWork>> {
            Err(JobError::new(ErrorCode::InvalidRequest, "admission-only fixture"))
        }
    }
    for limit in [0, super::super::NATIVE_CPU_POOL_BYTES + 1] {
        assert!(ImageHost::with_executor(Arc::new(Envelope(limit))).is_err());
    }
    let host = ImageHost::with_executor(Arc::new(Envelope(1024 * 1024 * 1024))).unwrap();
    assert_eq!(host.pool_limit_bytes(), 1024 * 1024 * 1024);
    assert!(host.admit(&empty(), &request(), JobOptions::default()).is_ok());
    assert_eq!(host.admitted_bytes(), 0, "preflight does not allocate or reserve");
    let lease = host.0.shared.budget.reserve(600 * 1024 * 1024).unwrap();
    assert!(host.0.shared.budget.reserve(600 * 1024 * 1024).is_err());
    drop(lease);
    assert_eq!(host.admitted_bytes(), 0);
}
/// A registered executor exercises the shared publication boundary without a device.
/// Each pass encodes a real, distinct PNG; no final is returned with a preview.
struct CheckpointExecutor;
struct CheckpointWork {
    request: ImageRequest,
    cancel: CancelToken,
    samples: u32,
    target: u32,
    preview: Option<super::super::ImageWorkPreview>,
}
impl ImageWork for CheckpointWork {
    fn take_preview(&mut self) -> Option<super::super::ImageWorkPreview> {
        self.preview.take()
    }
    fn step(&mut self, _: usize) -> Result<TaskPoll> {
        self.cancel.check()?;
        self.samples += 1;
        let rgba = vec![self.samples as u8; (self.request.width * self.request.height * 4) as usize];
        let mut task = super::super::PngTask::new(&self.request, rgba, self.cancel.clone())?;
        let TaskPoll::Complete(png) = task.step(4)? else {
            return Err(JobError::new(ErrorCode::Internal, "small checkpoint fixture did not encode"));
        };
        if self.samples == self.target {
            Ok(TaskPoll::Complete(png))
        } else {
            self.preview = Some(super::super::ImageWorkPreview { png, samples_per_pixel: self.samples });
            Ok(TaskPoll::Pending(Progress { phase: Phase::Running, done: u64::from(self.samples), total: u64::from(self.target) }))
        }
    }
}
impl ImageExecutor for CheckpointExecutor {
    fn preview_samples(&self, options: JobOptions) -> Option<u32> {
        Some(options.samples)
    }
    fn descriptor(&self) -> Result<ExecutorDescriptor> {
        CpuExecutor.descriptor()
    }
    fn admit(&self, scene: &ProductScene, request: &ImageRequest, _: JobOptions) -> Result<Admission> {
        admit(scene, request)
    }
    fn begin(&self, _: ProductScene, request: ImageRequest, options: JobOptions, cancel: CancelToken) -> Result<Box<dyn ImageWork>> {
        Ok(Box::new(CheckpointWork { request, cancel, samples: 0, target: options.samples, preview: None }))
    }
}

/// A valid registered producer need not use the built-in dimension-based PNG bound.
struct BoundedCheckpointExecutor {
    encoded_limit: usize,
}
struct BoundedCheckpointWork {
    inner: CheckpointWork,
    encoded_limit: usize,
}
impl BoundedCheckpointWork {
    fn retain_png(&self, png: Vec<u8>) -> Vec<u8> {
        assert!(png.len() <= self.encoded_limit);
        let mut retained = Vec::with_capacity(self.encoded_limit);
        retained.extend_from_slice(&png);
        assert_eq!(retained.capacity(), self.encoded_limit);
        retained
    }
}
impl ImageWork for BoundedCheckpointWork {
    fn take_preview(&mut self) -> Option<super::super::ImageWorkPreview> {
        self.inner.take_preview()
    }
    fn step(&mut self, units: usize) -> Result<TaskPoll> {
        let poll = self.inner.step(units)?;
        if let Some(mut preview) = self.inner.preview.take() {
            preview.png = self.retain_png(preview.png);
            self.inner.preview = Some(preview);
        }
        Ok(match poll {
            TaskPoll::Complete(png) => TaskPoll::Complete(self.retain_png(png)),
            pending => pending,
        })
    }
}
impl ImageExecutor for BoundedCheckpointExecutor {
    fn preview_samples(&self, options: JobOptions) -> Option<u32> {
        Some(options.samples)
    }
    fn descriptor(&self) -> Result<ExecutorDescriptor> {
        CpuExecutor.descriptor()
    }
    fn admit(&self, scene: &ProductScene, request: &ImageRequest, _: JobOptions) -> Result<Admission> {
        // Pay the complete built-in encoder envelope and the overlapping repack
        // allocation independently of the custom retained-output bound.
        let mut admission = admit(scene, request)?;
        let repack_bytes = self.encoded_limit as u64 + 4096;
        admission.preparation_bytes += repack_bytes;
        admission.estimated_total_bytes += repack_bytes;
        admission.encoded_limit = self.encoded_limit as u64;
        Ok(admission)
    }
    fn begin(&self, _: ProductScene, request: ImageRequest, options: JobOptions, cancel: CancelToken) -> Result<Box<dyn ImageWork>> {
        Ok(Box::new(BoundedCheckpointWork {
            inner: CheckpointWork { request, cancel, samples: 0, target: options.samples, preview: None },
            encoded_limit: self.encoded_limit,
        }))
    }
}

fn registered_checkpoint_encoded_bound(encoded_limit: usize) {
    for cancel in [false, true] {
        let host = ImageHost::cooperative_with(Arc::new(BoundedCheckpointExecutor { encoded_limit }));
        let request = ImageRequest { width: 2, height: 2, ..request() };
        let options = JobOptions { samples: 5, ..Default::default() };
        let work_bytes = admit(&empty(), &request).unwrap().estimated_total_bytes + encoded_limit as u64 + 4096;
        let slot_bytes = encoded_limit as u64 + FRAME_METADATA_BYTES;
        let admission = host.admit(&empty(), &request, options).unwrap();
        assert_eq!(admission.encoded_limit, encoded_limit as u64);
        assert_eq!(admission.estimated_total_bytes, work_bytes + 2 * slot_bytes + FRAME_METADATA_BYTES);
        let job = host.submit_with_options(id(9023, 1), 57, empty(), request, options).unwrap();
        let admitted = host.admitted_bytes();
        let mut held = Vec::new();
        for samples in 1..=2 {
            for _ in 0..8 {
                host.pump(1).unwrap();
                let status = job.status().unwrap();
                assert_ne!(status.progress.phase, Phase::Failed, "custom encoded limit {encoded_limit}: {:?}", status.error);
                if job.preview().unwrap().is_some_and(|preview| preview.info.samples_per_pixel == samples) {
                    break;
                }
            }
            let preview = job.preview().unwrap().expect("an admitted custom PNG bound must publish its complete pass");
            assert_eq!(preview.info.samples_per_pixel, samples);
            assert_eq!(preview.png.capacity(), encoded_limit);
            assert_eq!(preview._reservation.bytes, slot_bytes);
            assert_eq!(preview.info.frame.png_sha256, format!("{:x}", Sha256::digest(preview.png())));
            let decoded = image::load_from_memory(preview.png()).unwrap().to_rgba8();
            assert_eq!(decoded.dimensions(), (2, 2));
            assert_eq!(decoded.as_raw(), &vec![samples as u8; 16]);
            assert!(job.frame().unwrap().is_none());
            assert_eq!(host.admitted_bytes(), admitted, "publication only transfers admitted credit");
            let running = host.0.running.lock().unwrap();
            let running = running.as_ref().unwrap();
            assert_eq!(running.reservation.as_ref().unwrap().bytes, work_bytes, "preview credits must not consume executor work");
            assert_eq!(running.checkpoints.as_ref().unwrap().slot_bytes, slot_bytes);
            held.push(preview);
        }
        if cancel {
            job.cancel().unwrap();
        }
        drain(&host);
        let status = job.status().unwrap();
        assert_eq!(status.progress.phase, if cancel { Phase::Cancelled } else { Phase::Completed });
        assert_eq!(status.preview_retention_skips, if cancel { 0 } else { 2 });
        assert!(job.preview().unwrap().is_none());
        assert!(job.work_released());
        let frame = job.frame().unwrap();
        if cancel {
            assert!(frame.is_none());
        } else {
            let frame = frame.as_ref().unwrap();
            assert_eq!(frame.png.capacity(), encoded_limit);
            assert_eq!(frame._reservation.bytes, slot_bytes);
            assert_eq!(frame.info.png_sha256, format!("{:x}", Sha256::digest(frame.png())));
            assert_eq!(image::load_from_memory(frame.png()).unwrap().to_rgba8().as_raw(), &vec![5; 16]);
        }
        for (index, preview) in held.iter().enumerate() {
            assert_eq!(preview.info.samples_per_pixel as usize, index + 1);
            assert_eq!(preview.info.frame.png_sha256, format!("{:x}", Sha256::digest(preview.png())));
            assert_eq!(image::load_from_memory(preview.png()).unwrap().to_rgba8().as_raw(), &vec![(index + 1) as u8; 16]);
        }
        drop(frame);
        drop(job);
        assert_eq!(host.admitted_bytes(), 2 * slot_bytes, "only externally pinned checkpoints retain admission");
        drop(held);
        assert_eq!(host.admitted_bytes(), 0);
    }
}

#[test]
fn registered_executor_checkpoint_slots_follow_smaller_admitted_encoded_limit() {
    registered_checkpoint_encoded_bound(4096);
}

#[test]
fn registered_executor_checkpoint_slots_follow_larger_admitted_encoded_limit() {
    registered_checkpoint_encoded_bound(131_072);
}

#[test]
fn registered_executor_checkpoints_are_bounded_immutable_and_never_final() {
    let host = ImageHost::cooperative_with(Arc::new(CheckpointExecutor));
    let request = ImageRequest { width: 2, height: 2, ..request() };
    let options = JobOptions { samples: 5, ..Default::default() };
    let base = admit(&empty(), &request).unwrap();
    let expected = base.estimated_total_bytes + 2 * (base.encoded_limit + FRAME_METADATA_BYTES) + FRAME_METADATA_BYTES;
    assert_eq!(host.admit(&empty(), &request, options).unwrap().estimated_total_bytes, expected);
    let job = host.submit_with_options(id(9021, 1), 55, empty(), request, options).unwrap();
    let mut held = Vec::new();
    for samples in 1..3 {
        for _ in 0..8 {
            host.pump(1).unwrap();
            if job.preview().unwrap().is_some_and(|preview| preview.info.samples_per_pixel == samples) {
                break;
            }
        }
        let preview = job.preview().unwrap().unwrap();
        assert_eq!(preview.info.samples_per_pixel, samples);
        assert_eq!(preview.info.frame.job, job.id());
        assert_eq!(preview.info.frame.scene_generation, 55);
        assert_eq!(preview.info.frame.png_sha256, format!("{:x}", Sha256::digest(preview.png())));
        assert!(job.frame().unwrap().is_none());
        held.push(preview);
    }
    while host.pump(1).unwrap() {}
    assert_eq!(job.status().unwrap().progress.phase, Phase::Completed);
    assert_eq!(job.status().unwrap().preview_retention_skips, 2);
    let frame = job.frame().unwrap().unwrap();
    assert_eq!(frame.info.job, job.id());
    for snapshot in &held {
        assert_ne!(snapshot.png(), frame.png());
        assert_eq!(snapshot.info.frame.png_sha256, format!("{:x}", Sha256::digest(snapshot.png())));
    }
    drop(frame);
    drop(job);
    assert!(host.admitted_bytes() > 0);
    drop(held);
    assert_eq!(host.admitted_bytes(), 0);
}

#[test]
fn cancelling_registered_checkpoint_work_preserves_held_snapshot_without_final() {
    let host = ImageHost::cooperative_with(Arc::new(CheckpointExecutor));
    let job = host
        .submit_with_options(
            id(9022, 1),
            56,
            empty(),
            ImageRequest { width: 2, height: 2, ..request() },
            JobOptions { samples: 5, ..Default::default() },
        )
        .unwrap();
    while job.preview().unwrap().is_none() {
        host.pump(1).unwrap();
    }
    let held = job.preview().unwrap().unwrap();
    job.cancel().unwrap();
    while host.pump(1).unwrap() {}
    assert_eq!(job.status().unwrap().progress.phase, Phase::Cancelled);
    assert!(job.preview().unwrap().is_none());
    assert!(job.frame().unwrap().is_none());
    assert_eq!(held.info.samples_per_pixel, 1);
    drop(job);
    assert_eq!(host.admitted_bytes(), held._reservation.bytes);
    drop(held);
    assert_eq!(host.admitted_bytes(), 0);
}

#[test]
fn cancellation_phase_precedes_the_actual_work_release_barrier() {
    let (host, job, mut running, _) = pending_digest_fixture();
    assert!(!job.work_released());
    assert!(host.admitted_bytes() > 0);
    job.cancel().unwrap();
    assert!(!running.guarded_step(1));
    assert_eq!(job.status().unwrap().progress.phase, Phase::Cancelled);
    assert!(!job.work_released(), "terminal status cannot admit a competing near-pool-sized job yet");
    assert!(host.admitted_bytes() > 0, "the Running owner still holds its work reservation");
    drop(running);
    assert!(job.work_released());
    assert_eq!(host.admitted_bytes(), fixed_request_metadata_bytes());
    drop(job);
    assert_eq!(host.admitted_bytes(), 0);
}

#[test]
fn queued_cancellation_releases_only_when_its_capture_and_reservation_drop() {
    let host = CpuHost::cooperative();
    let job = host.submit(id(9030, 1), 60, empty(), request()).unwrap();
    assert_eq!(job.cancel().unwrap().progress.phase, Phase::Cancelled);
    assert!(!job.work_released());
    assert!(host.admitted_bytes() > 0);
    assert!(!host.pump(1).unwrap());
    assert!(job.work_released());
    assert_eq!(host.admitted_bytes(), fixed_request_metadata_bytes());
    drop(job);
    assert_eq!(host.admitted_bytes(), 0);
}

#[test]
fn completed_work_barrier_does_not_claim_external_final_images_are_free() {
    let (host, job, mut running, _) = pending_digest_fixture();
    while running.advance(4096).unwrap() {}
    assert_eq!(job.status().unwrap().progress.phase, Phase::Completed);
    assert!(!job.work_released());
    let frame = job.frame().unwrap().unwrap();
    drop(running);
    assert!(job.work_released());
    assert!(host.admitted_bytes() > 0, "completed images have their own retained leases");
    drop(job);
    assert!(host.admitted_bytes() > 0);
    drop(frame);
    assert_eq!(host.admitted_bytes(), 0);
}

#[test]
fn host_shutdown_releases_both_queued_and_active_work_before_signalling() {
    let (host, active, running, _) = pending_digest_fixture();
    *host.0.running.lock().unwrap() = Some(running);
    let queued = host.submit(id(9031, 1), 61, empty(), request()).unwrap();
    assert!(!active.work_released());
    assert!(!queued.work_released());
    let budget = host.0.shared.budget.clone();
    drop(host);
    assert!(active.work_released());
    assert!(queued.work_released());
    assert_eq!(budget.used.load(Ordering::Acquire), 2 * fixed_request_metadata_bytes());
    drop(active);
    drop(queued);
    assert_eq!(budget.used.load(Ordering::Acquire), 0);
}

struct FailingBeginExecutor;
impl ImageExecutor for FailingBeginExecutor {
    fn descriptor(&self) -> Result<ExecutorDescriptor> {
        CpuExecutor.descriptor()
    }
    fn admit(&self, scene: &ProductScene, request: &ImageRequest, _: JobOptions) -> Result<Admission> {
        admit(scene, request)
    }
    fn begin(&self, _scene: ProductScene, _: ImageRequest, _: JobOptions, _: CancelToken) -> Result<Box<dyn ImageWork>> {
        Err(JobError::new(ErrorCode::InvalidScene, "original failing executor fixture"))
    }
}

#[test]
fn failed_begin_releases_captured_scene_and_reservation_before_signalling() {
    let host = ImageHost::cooperative_with(Arc::new(FailingBeginExecutor));
    let mesh = Arc::new(Mesh {
        positions: vec![solidcore_record::Vec3::ZERO, solidcore_record::Vec3::X, solidcore_record::Vec3::Y],
        normals: vec![solidcore_record::Vec3::Z; 3],
        triangles: vec![[0, 1, 2]],
        ..Default::default()
    });
    let captured = Arc::downgrade(&mesh);
    let scene = ProductScene {
        bounds: mesh.bounds(),
        meshes: vec![crate::ProductMesh {
            name: "original capture".into(),
            mesh,
            color: [128; 3],
            opacity: 1.0,
            surface: None,
            transmission: None,
            faces: Vec::new(),
        }],
    };
    let job = host.submit(id(9032, 1), 62, scene, request()).unwrap();
    let work = host.0.shared.queue.lock().unwrap().pop_front().unwrap();
    assert!(!job.work_released());
    assert!(captured.upgrade().is_some());
    assert!(Running::begin(work).is_none());
    assert!(captured.upgrade().is_none(), "the actual captured mesh must be released before the barrier");
    let status = job.status().unwrap();
    assert_eq!(status.progress.phase, Phase::Failed);
    assert_eq!(status.error.unwrap().message, "original failing executor fixture", "the fixture must reach executor begin");
    assert!(job.work_released());
    assert_eq!(host.admitted_bytes(), fixed_request_metadata_bytes());
    drop(job);
    assert_eq!(host.admitted_bytes(), 0);
}

#[cfg(all(feature = "raytrace-cpu", not(target_arch = "wasm32")))]
mod cpu_output_masters {
    use super::*;
    use crate::job::{CpuProgressiveOptions, OutputOptions, RaytraceOptions};
    fn fixture(host: &CpuHost, serial: u64) -> (JobHandle, Running) {
        let settings = OutputOptions {
            linear_exr: true,
            tone_map: crate::job::ToneMap::AcesFitted,
            finishing: crate::job::finishing::Finishing {
                bloom: Some(crate::job::bloom::Bloom { strength: 0.2, threshold: 0.0, radius: 1 }),
                ..Default::default()
            },
            ..Default::default()
        };
        let request = ImageRequest {
            integrator: Integrator::Raytrace,
            raytrace: Some(RaytraceOptions {
                progressive: Some(CpuProgressiveOptions { samples_per_pixel: 3, seed: 9 }),
                output: Some(Box::new(settings)),
                lights: Some(Vec::new()),
                ..Default::default()
            }),
            width: 2,
            height: 2,
            ..request()
        };
        let job = host.submit(id(9040, serial), 63, empty(), request).unwrap();
        let work = host.0.shared.queue.lock().unwrap().pop_front().unwrap();
        let running = Running::begin(work).unwrap();
        (job, running)
    }
    fn host() -> CpuHost {
        ImageHost(Arc::new(Owner {
            executor: None,
            shared: CpuHost::shared(MEMORY_LIMIT),
            kind: HostKind::NativeWorker,
            running: Mutex::new(None),
            _worker: None,
        }))
    }
    fn hold_checkpoints(job: &JobHandle, running: &mut Running) -> Vec<Arc<RenderPreview>> {
        let mut held = Vec::new();
        for _ in 0..100_000 {
            if let Some(preview) = job.preview().unwrap()
                && held.last().is_none_or(|last: &Arc<RenderPreview>| last.info.frame_sequence != preview.info.frame_sequence)
            {
                held.push(preview);
            }
            if running.pending_png.as_ref().is_some_and(|png| png.exr.is_some()) {
                return held;
            }
            assert!(running.advance(1).unwrap());
        }
        panic!("small CPU master did not reach its final digest");
    }
    #[test]
    fn cpu_master_and_every_retained_preview_keep_exact_independent_leases() {
        let host = host();
        let (job, mut running) = fixture(&host, 1);
        let held = hold_checkpoints(&job, &mut running);
        assert_eq!(held.len(), 2);
        assert!(job.frame().unwrap().is_none());
        while running.advance(1).unwrap() {}
        let frame = job.frame().unwrap().unwrap();
        let raw = frame.linear_exr().unwrap();
        assert_eq!(frame.info.executor.as_str(), "cpu-raytrace");
        assert_eq!(frame.linear_master_info().unwrap().sha256, format!("{:x}", Sha256::digest(raw)));
        assert_eq!(frame._reservation.bytes, frame.png.capacity() as u64 + frame.exr.as_ref().unwrap().0.capacity() as u64 + FRAME_METADATA_BYTES);
        let preview_bytes: u64 = held.iter().map(|preview| preview._reservation.bytes).sum();
        let frame_bytes = frame._reservation.bytes;
        drop(running);
        assert!(job.work_released());
        drop(job);
        assert_eq!(host.admitted_bytes(), frame_bytes + preview_bytes);
        drop(frame);
        assert_eq!(host.admitted_bytes(), preview_bytes);
        drop(held);
        assert_eq!(host.admitted_bytes(), 0);
    }
    #[test]
    fn cancelling_cpu_master_digest_preserves_previous_final_and_pinned_preview_ownership() {
        let host = host();
        let (previous, mut previous_running) = fixture(&host, 1);
        while previous_running.advance(1).unwrap() {}
        drop(previous_running);
        let final_frame = previous.frame().unwrap().unwrap();
        let previous_png = final_frame.png().to_vec();
        let previous_raw = final_frame.linear_exr().unwrap().to_vec();
        let (job, mut running) = fixture(&host, 2);
        let held = hold_checkpoints(&job, &mut running);
        assert!(job.frame().unwrap().is_none());
        job.cancel().unwrap();
        assert_eq!(running.advance(1).unwrap_err().code, ErrorCode::Cancelled);
        drop(running);
        assert!(job.work_released());
        assert!(job.frame().unwrap().is_none());
        assert_eq!(final_frame.png(), previous_png);
        assert_eq!(final_frame.linear_exr().unwrap(), previous_raw);
        drop(job);
        drop(previous);
        let preview_bytes: u64 = held.iter().map(|preview| preview._reservation.bytes).sum();
        assert_eq!(host.admitted_bytes(), final_frame._reservation.bytes + preview_bytes);
        drop(final_frame);
        assert_eq!(host.admitted_bytes(), preview_bytes);
        drop(held);
        assert_eq!(host.admitted_bytes(), 0);
    }
}

#[test]
fn registered_punctual_diagnostics_survive_work_release_and_retained_status_handles() {
    struct DiagnosticExecutor;
    struct DiagnosticWork(ImageTask);
    let counts = super::super::PunctualDiagnostics { near_source: 1_u64 << 33, radiance_limit: 7, shadow_offset_crossed: 11 };
    impl ImageWork for DiagnosticWork {
        fn punctual_diagnostics(&self) -> Option<super::super::PunctualDiagnostics> {
            Some(super::super::PunctualDiagnostics { near_source: 1_u64 << 33, radiance_limit: 7, shadow_offset_crossed: 11 })
        }
        fn step(&mut self, units: usize) -> Result<TaskPoll> {
            self.0.step(units)
        }
    }
    impl ImageExecutor for DiagnosticExecutor {
        fn descriptor(&self) -> Result<ExecutorDescriptor> {
            CpuExecutor.descriptor()
        }
        fn admit(&self, scene: &ProductScene, request: &ImageRequest, _: JobOptions) -> Result<Admission> {
            admit(scene, request)
        }
        fn begin(&self, scene: ProductScene, request: ImageRequest, _: JobOptions, cancel: CancelToken) -> Result<Box<dyn ImageWork>> {
            Ok(Box::new(DiagnosticWork(ImageTask::new(scene, request, cancel)?)))
        }
    }
    let host = CpuHost::cooperative_with(Arc::new(DiagnosticExecutor));
    let job = host.submit(id(9027, 1), 71, empty(), request()).unwrap();
    let retained = job.clone();
    drain(&host);
    assert_eq!(job.status().unwrap().progress.phase, Phase::Completed);
    assert_eq!(job.status().unwrap().punctual_diagnostics, Some(counts));
    assert!(job.work_released());
    assert!(job.frame().unwrap().is_some());
    drop(job);
    assert_eq!(retained.status().unwrap().punctual_diagnostics, Some(counts));
    drop(retained);
    assert_eq!(host.admitted_bytes(), 0);
}

#[cfg(all(feature = "raytrace-cpu", not(target_arch = "wasm32")))]
mod cpu_adaptive_checkpoints {
    use super::*;
    use crate::job::{
        CpuProgressiveOptions, OutputOptions, RaytraceOptions,
        adaptive::{AdaptiveSampling, PreviewStage},
    };
    #[test]
    fn cpu_adaptive_bounded_snapshots_span_pilot_reset_and_production_without_lending_the_final_master() {
        let host = ImageHost(Arc::new(Owner {
            executor: None,
            shared: CpuHost::shared(MEMORY_LIMIT),
            kind: HostKind::NativeWorker,
            running: Mutex::new(None),
            _worker: None,
        }));
        let request = ImageRequest {
            width: 1,
            height: 1,
            integrator: Integrator::Raytrace,
            raytrace: Some(RaytraceOptions {
                progressive: Some(CpuProgressiveOptions { samples_per_pixel: 48, seed: 81 }),
                adaptive: Some(Box::new(AdaptiveSampling { pilot_samples: 16, min_samples: 16, ..Default::default() })),
                output: Some(Box::new(OutputOptions { linear_exr: true, ..Default::default() })),
                lights: Some(Vec::new()),
                ..Default::default()
            }),
            ..request()
        };
        let request_bytes = retained_request_bytes(&request).unwrap() + request.retained_resource_metadata_bytes();
        assert_eq!(
            request_bytes,
            (std::mem::size_of::<AdaptiveSampling>() + std::mem::size_of::<OutputOptions>()) as u64 + fixed_request_metadata_bytes()
        );
        let expected = admit(&empty(), &request).unwrap().estimated_total_bytes + request_bytes;
        let job = host.submit(id(9120, 1), 91, empty(), request).unwrap();
        assert_eq!(host.admitted_bytes(), expected);
        let work = host.0.shared.queue.lock().unwrap().pop_front().unwrap();
        let mut running = Running::begin(work).unwrap();
        assert_eq!(running.checkpoint_target, 64);
        let credits = running.checkpoints.as_ref().unwrap();
        assert_eq!(credits.capacity, 2 * credits.slot_bytes + FRAME_METADATA_BYTES);
        let mut held: Vec<Arc<RenderPreview>> = Vec::new();
        let mut saw_reset_production = false;
        let mut published = Vec::new();
        for _ in 0..200_000 {
            if let Some(png) = running.pending_png.as_ref()
                && let Some(absolute) = png.preview_samples
            {
                assert!(job.frame().unwrap().is_none());
                if absolute == 17 {
                    drop(held.remove(0));
                }
                let before = job.status().unwrap();
                assert!(running.advance(1).unwrap());
                let status = job.status().unwrap();
                let preview = job.preview().unwrap().expect("publication or retention keeps a complete pass available");
                if status.preview_retention_skips != before.preview_retention_skips {
                    assert!((3..=16).contains(&absolute), "only the two pinned pilot snapshots skip publication");
                    assert_eq!(status.preview_retention_skips, before.preview_retention_skips + 1);
                    let retained = held.last().unwrap();
                    assert_eq!(retained.info.samples_per_pixel, 2);
                    assert!(Arc::ptr_eq(&preview, retained), "a skipped pass keeps the pinned second publication");
                    assert_eq!(serde_json::to_value(&preview.info).unwrap(), serde_json::to_value(&retained.info).unwrap());
                    assert_eq!(serde_json::to_value(&status.preview).unwrap(), serde_json::to_value(&before.preview).unwrap());
                    assert_eq!(serde_json::to_value(status.preview.as_ref().unwrap()).unwrap(), serde_json::to_value(&retained.info).unwrap());
                    assert_eq!(preview.info.frame.png_sha256, format!("{:x}", Sha256::digest(preview.png())));
                } else {
                    let metadata = preview.info.adaptive.unwrap();
                    assert_eq!(preview.info.samples_per_pixel, absolute);
                    assert_eq!(metadata.pilot_samples, 16);
                    assert_eq!((metadata.minimum_production_samples, metadata.maximum_production_samples), (16, 48));
                    assert_eq!(preview.info.frame.png_sha256, format!("{:x}", Sha256::digest(preview.png())));
                    if absolute <= 16 {
                        assert_eq!((metadata.stage, metadata.completed, metadata.target), (PreviewStage::Pilot, absolute, 16));
                    } else {
                        assert_eq!((metadata.stage, metadata.completed, metadata.target), (PreviewStage::Production, absolute - 16, 48));
                        saw_reset_production = true;
                    }
                    published.push(absolute);
                    if absolute <= 2 {
                        held.push(preview);
                    }
                }
                assert_eq!(host.admitted_bytes(), expected);
                continue;
            }
            if !running.advance(1).unwrap() {
                break;
            }
        }
        assert!(saw_reset_production);
        assert_eq!(&published[..2], &[1, 2]);
        assert!(published.contains(&17) && published.contains(&63));
        let status = job.status().unwrap();
        assert_eq!(status.progress.phase, Phase::Completed, "{:?}", status.error);
        assert_eq!(status.preview_retention_skips, 14);
        assert!(job.preview().unwrap().is_none());
        let report = status.sampling.unwrap();
        assert_eq!((report.pilot_samples_per_pixel, report.minimum_production_samples, report.maximum_production_samples), (16, 16, 16));
        assert_eq!((report.production_samples, report.primary_path_evaluations, report.pixels_at_cap), (16, 32, 0));
        drop(running);
        assert!(job.work_released());
        let frame = job.frame().unwrap().unwrap();
        assert!(frame.linear_exr().is_some());
        let retained = held.iter().map(|p| p._reservation.bytes).sum::<u64>();
        assert_eq!(
            host.admitted_bytes(),
            retained + frame._reservation.bytes + request_bytes,
            "the original captured adaptive/output boxes retain their independent request lease"
        );
        drop(job);
        drop(frame);
        assert_eq!(host.admitted_bytes(), retained);
        drop(held);
        assert_eq!(host.admitted_bytes(), 0);
    }
}

#[cfg(all(feature = "raytrace-cpu", not(target_arch = "wasm32")))]
#[test]
fn celestial_cancelled_capture_retains_only_exact_boxes_and_fixed_header_until_last_handle_drop() {
    use super::super::{CpuPathOptions, CpuProgressiveOptions, CpuSky, RaytraceOptions, Sun};
    let host = ImageHost(Arc::new(Owner {
        executor: None,
        shared: CpuHost::shared(MEMORY_LIMIT),
        kind: HostKind::NativeWorker,
        running: Mutex::new(None),
        _worker: None,
    }));
    let options = RaytraceOptions {
        path: Some(CpuPathOptions { max_depth: 2 }),
        progressive: Some(CpuProgressiveOptions { samples_per_pixel: 3, seed: 81 }),
        sun: Some(Box::new(Sun { direction: [0.0, 0.0, 1.0], angular_radius_rad: 0.02, radiance: [3.0, 2.0, 1.0] })),
        sky: Some(Box::new(CpuSky::default())),
        ..Default::default()
    };
    let fixed = ImageRequest::fixed_cpu_metadata_bytes();
    assert_eq!(
        fixed,
        (std::mem::size_of::<Option<super::super::CausticOptions>>()
            + std::mem::size_of::<Option<Box<Sun>>>()
            + std::mem::size_of::<Option<Box<CpuSky>>>()
            + std::mem::size_of::<Option<super::super::volume::HomogeneousVolume>>()) as u64
    );
    let captured = ImageRequest { integrator: Integrator::Raytrace, raytrace: Some(options.clone()), ..request() };
    assert_eq!(captured.retained_resource_metadata_bytes(), fixed);
    let retained = options.retained_bytes().unwrap() + fixed;
    let job = host.submit(id(9170, 1), 101, empty(), captured).unwrap();
    let work = host.0.shared.queue.lock().unwrap().pop_front().unwrap();
    job.cancel().unwrap();
    assert!(!job.work_released());
    drop(work);
    assert!(job.work_released());
    assert_eq!(job.status().unwrap().progress.phase, Phase::Cancelled);
    assert!(job.frame().unwrap().is_none());
    assert_eq!(host.admitted_bytes(), retained, "fixed request headers cannot borrow a released Work or absent final-frame lease");
    assert_eq!(job.0._request_reservation.as_ref().unwrap().bytes, retained);
    let held = job.clone();
    drop(job);
    assert_eq!(host.admitted_bytes(), retained);
    drop(held);
    assert_eq!(host.admitted_bytes(), 0);
    // Omitted boxes introduce no source buffer, but their actual inline header
    // growth remains explicitly billed even for the embedded None variant.
    let plain = request();
    assert!(plain.raytrace.is_none());
    assert_eq!(plain.retained_resource_metadata_bytes(), fixed);
}

#[cfg(all(feature = "raytrace-cpu", not(target_arch = "wasm32")))]
mod prepared_optical_submission {
    use super::*;
    use crate::job::{DielectricBoundary, DielectricOptions, RaytraceOptions};
    use solidcore_record::Vec3;

    fn host(limit: u64) -> CpuHost {
        ImageHost(Arc::new(Owner {
            executor: None,
            shared: CpuHost::shared(limit),
            kind: HostKind::NativeWorker,
            running: Mutex::new(None),
            _worker: None,
        }))
    }
    fn capture() -> (ProductScene, ImageRequest) {
        let mesh = Arc::new(Mesh {
            positions: (0..8)
                .map(|i| Vec3::new(if i & 1 == 0 { -1.0 } else { 1.0 }, if i & 2 == 0 { -1.0 } else { 1.0 }, if i & 4 == 0 { 0.0 } else { 2.0 }))
                .collect(),
            triangles: vec![
                [0, 2, 3],
                [0, 3, 1],
                [4, 5, 7],
                [4, 7, 6],
                [0, 4, 6],
                [0, 6, 2],
                [1, 3, 7],
                [1, 7, 5],
                [0, 1, 5],
                [0, 5, 4],
                [2, 6, 7],
                [2, 7, 3],
            ],
            ..Default::default()
        });
        let scene = ProductScene {
            bounds: mesh.bounds(),
            meshes: vec![crate::ProductMesh {
                name: "captured box".into(),
                mesh,
                color: [255; 3],
                opacity: 1.0,
                surface: None,
                faces: Vec::new(),
                transmission: None,
            }],
        };
        let mut request = ImageRequest { integrator: Integrator::Raytrace, width: 1, height: 1, ..request() };
        request.camera.set_view(crate::StandardView::Top);
        request.raytrace = Some(RaytraceOptions {
            lights: Some(Vec::new()),
            environment: Some(crate::job::RaytraceEnvironmentOptions { color: [1.0; 3], intensity: 1.0 }),
            dielectrics: vec![DielectricOptions {
                model: None,
                body_index: 0,
                body_name: "captured box".into(),
                boundary: DielectricBoundary::ClosedBox,
                ior: 1.5,
                absorption_per_mm: [0.0; 3],
                thickness_mm: 0.0,
                shadow_transmission: false,
                subsurface: None,
            }],
            ..Default::default()
        });
        (scene, request)
    }

    #[test]
    fn prepared_optics_debit_once_and_transfer_work_and_retained_leases_without_enqueuing_early() {
        let host = host(MEMORY_LIMIT);
        let (scene, request) = capture();
        let source = Arc::downgrade(&scene.meshes[0].mesh);
        let retained = retained_request_bytes(&request).unwrap() + request.retained_resource_metadata_bytes();
        let prepared = host.prepare_submission(scene, request, JobOptions::default(), None, CancelToken::default()).unwrap();
        assert_eq!(prepared.proof.len(), 1);
        assert!(prepared.options.is_none());
        assert!(host.0.shared.queue.lock().unwrap().is_empty(), "preparation has no job identity or queued work");
        let expected = prepared.admission().estimated_total_bytes + retained;
        assert_eq!(host.admitted_bytes(), expected);
        assert_eq!(prepared.reservation.bytes, prepared.admission().estimated_total_bytes);
        assert_eq!(prepared.request_reservation.as_ref().unwrap().bytes, retained);
        let job = host.submit_prepared(id(801, 1), 99, prepared).unwrap();
        assert_eq!(host.admitted_bytes(), expected, "enqueue moves rather than reserves credit");
        let work = host.0.shared.queue.lock().unwrap().pop_front().unwrap();
        assert_eq!(work.proof.len(), 1);
        let mut running = Running::begin(work).unwrap();
        for _ in 0..100_000 {
            if !running.advance(1).unwrap() {
                break;
            }
        }
        assert_eq!(job.status().unwrap().progress.phase, Phase::Completed);
        assert_eq!(job.id(), id(801, 1));
        drop(running);
        assert!(source.upgrade().is_none(), "certified source drops with actual work");
        let frame = job.frame().unwrap().unwrap();
        assert_eq!(host.admitted_bytes(), retained + frame._reservation.bytes);
        job.0.data.lock().unwrap().frame = None;
        drop(frame);
        assert_eq!(host.admitted_bytes(), retained, "captured option names/capacities outlive frame eviction");
        let clone = job.clone();
        drop(job);
        assert_eq!(host.admitted_bytes(), retained);
        drop(clone);
        assert_eq!(host.admitted_bytes(), 0);
    }

    #[test]
    fn preparation_drop_cancel_wrong_host_and_exact_pool_boundary_release_all_captures() {
        let original = host(MEMORY_LIMIT);
        let (scene, request) = capture();
        let prepared = original.prepare_submission(scene, request, JobOptions::default(), None, CancelToken::default()).unwrap();
        let required = original.admitted_bytes();
        drop(prepared);
        assert_eq!(original.admitted_bytes(), 0);
        for limit in [required - 1, required] {
            let host = host(limit);
            let (scene, request) = capture();
            let source = Arc::downgrade(&scene.meshes[0].mesh);
            let result = host.prepare_submission(scene, request, JobOptions::default(), None, CancelToken::default());
            assert_eq!(result.is_ok(), limit == required);
            drop(result);
            assert_eq!(host.admitted_bytes(), 0);
            assert!(source.upgrade().is_none());
        }
        let cancel = CancelToken::default();
        let (scene, request) = capture();
        let prepared = original.prepare_submission(scene, request, JobOptions::default(), None, cancel.clone()).unwrap();
        cancel.cancel();
        assert_eq!(original.submit_prepared(id(802, 1), 0, prepared).err().unwrap().code, ErrorCode::Cancelled);
        assert_eq!(original.admitted_bytes(), 0);
        let (scene, request) = capture();
        let prepared = original.prepare_submission(scene, request, JobOptions::default(), None, CancelToken::default()).unwrap();
        let other = host(MEMORY_LIMIT);
        assert_eq!(other.submit_prepared(id(802, 2), 0, prepared).err().unwrap().code, ErrorCode::WrongOwner);
        assert_eq!((original.admitted_bytes(), other.admitted_bytes()), (0, 0));
        assert!(original.0.shared.queue.lock().unwrap().is_empty());
    }

    #[test]
    fn strict_host_and_preparation_keep_precise_geometry_refusal_without_pool_or_queue_leaks() {
        let host = host(MEMORY_LIMIT);
        let (mut scene, request) = capture();
        Arc::make_mut(&mut scene.meshes[0].mesh).positions[0].z += 0.125;
        for error in [
            host.admit(&scene, &request, JobOptions::default()).err().unwrap(),
            host.prepare_submission(scene, request, JobOptions::default(), None, CancelToken::default()).err().unwrap(),
        ] {
            assert_eq!(error.code, ErrorCode::InvalidScene);
            assert!(error.message.contains("box face is not axis aligned"), "{}", error.message);
        }
        assert_eq!(host.admitted_bytes(), 0);
        assert!(host.0.shared.queue.lock().unwrap().is_empty());
    }
    #[test]
    fn borrowed_enqueue_keeps_failed_capsule_credit_and_source_until_worker_retirement() {
        let host = host(MEMORY_LIMIT);
        let (scene, request) = capture();
        let source = Arc::downgrade(&scene.meshes[0].mesh);
        let cancel = CancelToken::default();
        let prepared = host.prepare_submission(scene, request, JobOptions::default(), None, cancel.clone()).unwrap();
        let mut slot = Some(prepared);
        let own_bytes = host.admitted_bytes();
        let first = host.submit(id(803, 1), 0, empty(), super::request()).unwrap();
        let second = host.submit(id(803, 2), 0, empty(), super::request()).unwrap();
        let queued_bytes = host.admitted_bytes() - own_bytes;
        let error = host.try_submit_prepared(id(804, 1), 0, &mut slot).err().unwrap();
        assert_eq!(error.code, ErrorCode::QueueFull);
        assert!(slot.is_some() && source.upgrade().is_some());
        assert_eq!(host.admitted_bytes(), own_bytes + queued_bytes);
        // A racing cancellation does not make UI completion destroy queued
        // captures. Background draining will reclaim their work later.
        first.cancel().unwrap();
        assert_eq!(host.try_submit_prepared(id(804, 1), 0, &mut slot).err().unwrap().code, ErrorCode::QueueFull);
        assert_eq!(host.0.shared.queue.lock().unwrap().len(), 2);
        cancel.cancel();
        assert_eq!(host.try_submit_prepared(id(804, 1), 0, &mut slot).err().unwrap().code, ErrorCode::Cancelled);
        assert!(slot.is_some());
        let other = self::host(MEMORY_LIMIT);
        assert_eq!(other.try_submit_prepared(id(804, 1), 0, &mut slot).err().unwrap().code, ErrorCode::WrongOwner);
        assert_eq!(host.admitted_bytes(), own_bytes + queued_bytes);
        let (retire, receiver) = std::sync::mpsc::sync_channel(1);
        let (ack, released) = std::sync::mpsc::sync_channel(1);
        let worker = std::thread::spawn(move || {
            drop(receiver.recv().unwrap());
            ack.send(()).unwrap();
        });
        retire.send(slot.take().unwrap()).unwrap();
        released.recv().unwrap();
        worker.join().unwrap();
        assert!(slot.is_none() && source.upgrade().is_none());
        assert_eq!(host.admitted_bytes(), queued_bytes, "retirement ack follows actual owner/lease disposal");
        second.cancel().unwrap();
        drop(host.0.shared.queue.lock().unwrap().drain(..).collect::<Vec<_>>());
        drop((first, second));
        assert_eq!(host.admitted_bytes(), 0);
    }
    #[test]
    fn absent_optics_preserves_admission_and_has_no_proof_or_options_backing() {
        let host = host(MEMORY_LIMIT);
        for integrator in [Integrator::Raster, Integrator::Raytrace] {
            let request = ImageRequest { integrator, ..super::request() };
            let expected = super::admit(&empty(), &request).unwrap();
            let fixed = request.retained_resource_metadata_bytes();
            let prepared = host.prepare_submission(empty(), request, JobOptions::default(), None, CancelToken::default()).unwrap();
            assert_eq!(serde_json::to_value(prepared.admission()).unwrap(), serde_json::to_value(expected).unwrap());
            assert_eq!((prepared.proof.len(), prepared.proof.capacity()), (0, 0));
            assert!(prepared.options.is_none());
            assert_eq!(
                prepared.request_reservation.as_ref().unwrap().bytes,
                fixed,
                "None source paths still retain the exact CPU9 fixed header independently of Work"
            );
            assert_eq!(host.admitted_bytes(), expected.estimated_total_bytes + fixed);
            drop(prepared);
            assert_eq!(host.admitted_bytes(), 0);
        }
    }

    fn general_capture() -> (ProductScene, ImageRequest) {
        let (mut scene, mut request) = capture();
        // A rotated closed mesh is outside the legacy axis-aligned box subset.
        for p in &mut Arc::make_mut(&mut scene.meshes[0].mesh).positions {
            *p = Vec3::new((p.x + p.z) * std::f64::consts::FRAC_1_SQRT_2, p.y, (p.z - p.x) * std::f64::consts::FRAC_1_SQRT_2);
        }
        scene.bounds = scene.meshes[0].mesh.bounds();
        let options = request.raytrace.as_mut().unwrap();
        options.path = Some(crate::job::CpuPathOptions { max_depth: 16 });
        options.progressive = Some(crate::job::CpuProgressiveOptions { samples_per_pixel: 4, seed: 9 });
        options.shadows = true;
        options.dielectrics[0].boundary = DielectricBoundary::ClosedMesh;
        (scene, request)
    }

    #[test]
    fn general_glass_strict_admission_and_preparation_refuse_the_same_boundary_before_enqueue() {
        let host = host(MEMORY_LIMIT);
        for inward in [false, true] {
            let (mut scene, request) = general_capture();
            let mesh = Arc::make_mut(&mut scene.meshes[0].mesh);
            let expected = if inward {
                for t in &mut mesh.triangles {
                    t.swap(1, 2);
                }
                "outward"
            } else {
                mesh.triangles.pop();
                "two oppositely"
            };
            let source = Arc::downgrade(&scene.meshes[0].mesh);
            let original_triangles = scene.meshes[0].mesh.triangles.clone();
            let original_request = serde_json::to_value(&request).unwrap();
            for error in [
                crate::raytrace::image::admit(&scene, &request, request.raytrace.as_ref().unwrap()).err().unwrap(),
                super::admit(&scene, &request).err().unwrap(),
                host.admit(&scene, &request, JobOptions::default()).err().unwrap(),
            ] {
                assert_eq!(error.code, ErrorCode::InvalidScene);
                assert!(error.message.contains(expected) || (!inward && error.message.contains("closed edges")), "{error}");
                assert_eq!(host.admitted_bytes(), 0);
            }
            assert_eq!(scene.meshes[0].mesh.triangles, original_triangles);
            assert_eq!(serde_json::to_value(&request).unwrap(), original_request);
            let error = host.prepare_submission(scene, request, JobOptions::default(), None, CancelToken::default()).err().unwrap();
            assert_eq!(error.code, ErrorCode::InvalidScene);
            assert!(error.message.contains(expected) || (!inward && error.message.contains("closed edges")), "{error}");
            assert!(source.upgrade().is_none());
            assert_eq!(host.admitted_bytes(), 0);
            assert!(host.0.shared.queue.lock().unwrap().is_empty(), "failed Check never creates a render job");
        }
    }

    #[test]
    fn general_glass_prepared_proof_moves_with_exact_source_and_releases_work_before_retained_metadata() {
        let host = host(MEMORY_LIMIT);
        let (scene, request) = general_capture();
        let source = Arc::downgrade(&scene.meshes[0].mesh);
        let exact_mesh = Arc::as_ptr(&scene.meshes[0].mesh);
        let original_request = serde_json::to_value(&request).unwrap();
        let retained = retained_request_bytes(&request).unwrap() + request.retained_resource_metadata_bytes();
        let prepared = host.prepare_submission(scene, request, JobOptions::default(), None, CancelToken::default()).unwrap();
        assert_eq!((prepared.proof.len(), prepared.proof.capacity()), (1, 1));
        assert_eq!(Arc::as_ptr(&prepared.scene.meshes[0].mesh), exact_mesh);
        assert_eq!(serde_json::to_value(prepared.request()).unwrap(), original_request);
        assert!(host.0.shared.queue.lock().unwrap().is_empty());
        let required = prepared.admission().estimated_total_bytes + retained;
        assert_eq!(host.admitted_bytes(), required);
        let job = host.submit_prepared(id(805, 1), 7, prepared).unwrap();
        assert_eq!(host.admitted_bytes(), required, "publication only transfers existing credit");
        let work = host.0.shared.queue.lock().unwrap().pop_front().unwrap();
        assert_eq!(Arc::as_ptr(&work.scene.meshes[0].mesh), exact_mesh);
        assert_eq!(work.proof.len(), 1);
        let mut running = Running::begin(work).unwrap();
        for _ in 0..100_000 {
            if !running.advance(1).unwrap() {
                break;
            }
        }
        assert_eq!(job.status().unwrap().progress.phase, Phase::Completed);
        drop(running);
        assert!(source.upgrade().is_none());
        assert!(job.work_released());
        let frame = job.frame().unwrap().unwrap();
        assert_eq!(host.admitted_bytes(), retained + frame._reservation.bytes);
        job.0.data.lock().unwrap().frame = None;
        drop(frame);
        assert_eq!(host.admitted_bytes(), retained, "general proof and every certificate buffer belong to Work");
        drop(job);
        assert_eq!(host.admitted_bytes(), 0);
    }

    #[test]
    fn general_glass_proof_exact_pool_cancel_and_wrong_host_never_release_credit_before_ownership() {
        let original = host(MEMORY_LIMIT);
        let (scene, request) = general_capture();
        let prepared = original.prepare_submission(scene, request, JobOptions::default(), None, CancelToken::default()).unwrap();
        let required = original.admitted_bytes();
        drop(prepared);
        assert_eq!(original.admitted_bytes(), 0);
        for limit in [required - 1, required] {
            let host = host(limit);
            let (scene, request) = general_capture();
            let source = Arc::downgrade(&scene.meshes[0].mesh);
            let result = host.prepare_submission(scene, request, JobOptions::default(), None, CancelToken::default());
            assert_eq!(result.is_ok(), limit == required);
            drop(result);
            assert!(source.upgrade().is_none());
            assert_eq!(host.admitted_bytes(), 0);
        }
        let other = host(MEMORY_LIMIT);
        for cancel_after_preparation in [false, true] {
            let (scene, request) = general_capture();
            let source = Arc::downgrade(&scene.meshes[0].mesh);
            let cancel = CancelToken::default();
            let prepared = original.prepare_submission(scene, request, JobOptions::default(), None, cancel.clone()).unwrap();
            let mut slot = Some(prepared);
            if cancel_after_preparation {
                cancel.cancel();
            }
            let result = if cancel_after_preparation {
                original.try_submit_prepared(id(806, 1), 0, &mut slot)
            } else {
                other.try_submit_prepared(id(806, 2), 0, &mut slot)
            };
            assert_eq!(result.err().unwrap().code, if cancel_after_preparation { ErrorCode::Cancelled } else { ErrorCode::WrongOwner });
            assert!(slot.is_some() && source.upgrade().is_some());
            assert_eq!(original.admitted_bytes(), required, "failed borrowed enqueue retains the exact certificate owner");
            assert_eq!(other.admitted_bytes(), 0);
            drop(slot);
            assert!(source.upgrade().is_none());
            assert_eq!(original.admitted_bytes(), 0);
        }
    }
}

#[test]
fn independently_retained_metadata_never_borrows_work_credit_and_rejects_a_different_host_pool() {
    let host = CpuHost::cooperative();
    let first = host.prepare_submission(empty(), request(), JobOptions::default(), None, CancelToken::default()).unwrap();
    let work = host.admitted_bytes();
    let lease = first.reserve_retained_metadata(257).unwrap();
    assert_eq!(lease.bytes(), 257);
    assert_eq!(host.admitted_bytes(), work + 257);
    drop(first);
    assert_eq!(host.admitted_bytes(), 257, "independent backing survives actual Work capsule release");
    let second =
        host.prepare_submission_with_metadata(empty(), request(), JobOptions::default(), None, CancelToken::default(), Some(&lease)).unwrap();
    assert_eq!(host.admitted_bytes(), work + 257, "existing retained credit is counted but not reserved twice");
    let other = CpuHost::cooperative();
    assert_eq!(
        other
            .prepare_submission_with_metadata(empty(), request(), JobOptions::default(), None, CancelToken::default(), Some(&lease))
            .err()
            .unwrap()
            .code,
        ErrorCode::WrongOwner
    );
    assert_eq!(other.admitted_bytes(), 0);
    drop(second);
    assert_eq!(host.admitted_bytes(), 257);
    drop(lease);
    assert_eq!(host.admitted_bytes(), 0);
}

mod capture_credit {
    use super::*;

    struct MetadataExecutor(Arc<AtomicU64>);
    impl ImageExecutor for MetadataExecutor {
        fn descriptor(&self) -> Result<ExecutorDescriptor> {
            let mut descriptor = CpuExecutor.descriptor()?;
            // Deliberately noncanonical order: resolution sorts both lists.
            // The full raw descriptor still must remain exactly pinned.
            descriptor.profiles[0].features.push(crate::RenderFeature::Hdri);
            descriptor.profiles[0].formats.insert(0, RenderFormat::Exr);
            let state = self.0.load(Ordering::Acquire);
            descriptor.id = ExecutorId::new(if state == 1 { "changed-capture-map" } else { "capture-map" }).unwrap();
            if state == 3 {
                descriptor.scratch.sample_bytes_per_pixel += 1;
            }
            Ok(descriptor)
        }
        fn admit(&self, scene: &ProductScene, request: &ImageRequest, _options: JobOptions) -> Result<Admission> {
            let mut clean = request.clone();
            clean.textures = None;
            let mut result = admit(scene, &clean)?;
            if let Some(maps) = &request.textures {
                result.estimated_total_bytes += maps.working_bytes();
            }
            // Deliberately change layout metadata after the first pre-submit
            // check, without changing executor identity or profile.
            if self.0.load(Ordering::Acquire) == 2 {
                self.0.store(3, Ordering::Release);
            }
            Ok(result)
        }
        fn begin(&self, _scene: ProductScene, _request: ImageRequest, _options: JobOptions, _cancel: CancelToken) -> Result<Box<dyn ImageWork>> {
            Err(JobError::new(ErrorCode::InvalidRequest, "controlled capture factory failure"))
        }
    }
    fn registered(limit: u64, changed: Arc<AtomicU64>) -> ImageHost {
        ImageHost(Arc::new(Owner {
            executor: Some(Arc::new(MetadataExecutor(changed))),
            shared: ImageHost::shared(limit),
            kind: HostKind::Cooperative,
            running: Mutex::new(None),
            #[cfg(not(target_arch = "wasm32"))]
            _worker: None,
        }))
    }
    #[test]
    fn capture_registered_credit_has_actual_host_cap_and_pins_descriptor_token_and_retained_context() {
        let changed = Arc::new(AtomicU64::new(0));
        let host = registered(MEMORY_LIMIT, changed.clone());
        let cancel = CancelToken::default();
        let bytes = super::super::super::image::MAX_JOB_BYTES + 1;
        let lease = host.reserve_capture(bytes, CaptureProfile::Registered, &cancel, None).unwrap();
        assert_eq!(host.admitted_bytes(), bytes, "registered capture must not inherit Compact's smaller CPU cap");
        drop(lease);
        assert_eq!(host.admitted_bytes(), 0);
        assert!(
            matches!(host.reserve_capture(1,CaptureProfile::CpuRaytrace(super::super::super::CpuBudget::Compact),&cancel,None),Err(e) if e.code==ErrorCode::WrongOwner)
        );
        let retained = RetainedMetadata(host.0.shared.budget.reserve(123).unwrap());
        let mut lease = host.reserve_capture(100, CaptureProfile::Registered, &cancel, Some(&retained)).unwrap();
        assert_eq!(host.admitted_bytes(), 223);
        lease.try_extend(70, &cancel).unwrap();
        assert_eq!(lease.bytes(), 170);
        assert_eq!(host.admitted_bytes(), 293);
        let foreign = registered(MEMORY_LIMIT, Arc::new(AtomicU64::new(0)));
        let foreign_retained = RetainedMetadata(foreign.0.shared.budget.reserve(123).unwrap());
        assert!(matches!(host.reserve_capture(1,CaptureProfile::Registered,&cancel,Some(&foreign_retained)),Err(e) if e.code==ErrorCode::WrongOwner));
        let other = CancelToken::default();
        assert_eq!(lease.try_extend(1, &other).unwrap_err().code, ErrorCode::WrongOwner);
        assert_eq!(host.admitted_bytes(), 293);
        changed.store(1, Ordering::Release);
        assert_eq!(lease.try_extend(1, &cancel).unwrap_err().code, ErrorCode::HostUnavailable);
        assert_eq!(host.admitted_bytes(), 293);
        changed.store(0, Ordering::Release);
        cancel.cancel();
        assert_eq!(lease.try_extend(1, &cancel).unwrap_err().code, ErrorCode::Cancelled);
        drop(lease);
        assert_eq!(host.admitted_bytes(), 123);
        drop(retained);
        assert_eq!(host.admitted_bytes(), 0);
    }

    #[cfg(all(feature = "raytrace-cpu", not(target_arch = "wasm32")))]
    fn cpu(limit: u64) -> ImageHost {
        ImageHost(Arc::new(Owner {
            executor: None,
            shared: ImageHost::shared(limit),
            kind: HostKind::NativeWorker,
            running: Mutex::new(None),
            _worker: None,
        }))
    }
    #[cfg(all(feature = "raytrace-cpu", not(target_arch = "wasm32")))]
    fn mapped() -> (ProductScene, ImageRequest, Weak<Vec<u8>>) {
        use crate::{
            job::{
                CpuProgressiveOptions, DirectionalLightOptions, OutputOptions, RaytraceOptions,
                textures::{BaseColorMode, PlanarFrame, RuntimeTextures, TextureBinding, TextureMap},
            },
            surface::OpaqueSurface,
            texture_input::MapRole,
        };
        use image::ImageEncoder;
        let mut bytes = Vec::new();
        image::codecs::png::PngEncoder::new(&mut bytes).write_image(&[128, 64, 32, 255], 1, 1, image::ExtendedColorType::Rgba8).unwrap();
        let map = TextureMap::new(bytes, MapRole::BaseColor).unwrap();
        let weak = map.source().encoded_weak();
        let binding = TextureBinding {
            body_index: 0,
            body_name: "Mapped receiver".into(),
            frame: PlanarFrame { origin: [0.; 3], u: [1., 0., 0.], v: [0., 1., 0.] },
            base_color: Some(map),
            normal: None,
            roughness: None,
            metallic: None,
            base_color_mode: BaseColorMode::Replace,
            flip_v: false,
            normal_strength: 1.0,
        };
        let maps = Arc::new(RuntimeTextures::new(vec![binding]).unwrap());
        let mesh = Mesh {
            positions: vec![
                solidcore_record::Vec3::new(-10., -10., 0.),
                solidcore_record::Vec3::new(10., -10., 0.),
                solidcore_record::Vec3::new(10., 10., 0.),
                solidcore_record::Vec3::new(-10., 10., 0.),
            ],
            normals: vec![solidcore_record::Vec3::Z; 4],
            triangles: vec![[0, 1, 2], [0, 2, 3]],
            tri_face: vec![0, 0],
            ..Default::default()
        };
        let source = ProductScene {
            bounds: mesh.bounds(),
            meshes: vec![crate::ProductMesh {
                name: "Mapped receiver".into(),
                mesh: Arc::new(mesh),
                color: [255; 3],
                opacity: 1.0,
                surface: Some(OpaqueSurface::new(solidcore_record::Vec3::new(1., 1., 1.), 0., 0.5, 1.).unwrap()),
                transmission: None,
                faces: Vec::new(),
            }],
        };
        let mut image = request();
        image.width = 2;
        image.height = 2;
        image.camera.distance = 4.;
        image.camera.set_view(crate::StandardView::Top);
        image.integrator = Integrator::Raytrace;
        image.textures = Some(maps);
        image.raytrace = Some(RaytraceOptions {
            progressive: Some(CpuProgressiveOptions { samples_per_pixel: 2, seed: 17 }),
            lights: Some(vec![DirectionalLightOptions { direction: [0., 0., 1.], color: [1.; 3], intensity: std::f64::consts::PI }]),
            shadows: false,
            output: Some(Box::new(OutputOptions { linear_exr: true, ..Default::default() })),
            ..Default::default()
        });
        (source, image, weak)
    }
    #[cfg(all(feature = "raytrace-cpu", not(target_arch = "wasm32")))]
    #[test]
    fn capture_cpu_exact_cap_transfer_keeps_real_map_png_raw_and_releases_only_work_backing() {
        let render = |capture_excess: Option<u64>| {
            let (scene, image, weak) = mapped();
            let probe = cpu(MEMORY_LIMIT);
            let admission = probe.admit(&scene, &image, JobOptions::default()).unwrap();
            let retained = retained_request_bytes(&image).unwrap() + image.retained_resource_metadata_bytes();
            let total = admission.estimated_total_bytes + retained;
            drop(probe);
            let extra = capture_excess.unwrap_or(0);
            let host = cpu(total + extra + 123);
            let plan = RetainedMetadata(host.0.shared.budget.reserve(123).unwrap());
            let cancel = CancelToken::default();
            let prepared = if capture_excess.is_some() {
                let bytes = if extra == 0 { image.textures.as_ref().unwrap().captured_bytes().unwrap() } else { total + extra };
                let mut credit = host
                    .reserve_capture(bytes / 2, CaptureProfile::CpuRaytrace(super::super::super::CpuBudget::Compact), &cancel, Some(&plan))
                    .unwrap();
                credit.try_extend(bytes - bytes / 2, &cancel).unwrap();
                assert_eq!(host.admitted_bytes(), bytes + 123);
                host.prepare_submission_with_capture(scene, image, JobOptions::default(), None, cancel, Some(&plan), credit).unwrap()
            } else {
                host.prepare_submission_with_metadata(scene, image, JobOptions::default(), None, cancel, Some(&plan)).unwrap()
            };
            assert_eq!(prepared.admission().estimated_total_bytes, admission.estimated_total_bytes + extra);
            assert_eq!(prepared.admission().preparation_bytes, admission.preparation_bytes + extra);
            assert_eq!(host.admitted_bytes(), total + extra + 123, "exact pool leaves no room for a second combined reserve");
            let job = host.submit_prepared(id(9510, if capture_excess.is_some() { 2 } else { 1 }), 1, prepared).unwrap();
            assert!(job.0.request.textures.is_none(), "Record owns summary only, never captured map backing");
            let work = host.0.shared.queue.lock().unwrap().pop_front().unwrap();
            let mut running = Running::begin(work).unwrap();
            assert!(weak.upgrade().is_some(), "the actual CPU factory received the full captured map source");
            for _ in 0..200000 {
                if !running.guarded_step(16384) {
                    break;
                }
            }
            assert_eq!(job.status().unwrap().progress.phase, Phase::Completed);
            let frame = job.frame().unwrap().unwrap();
            let png = frame.png().to_vec();
            let raw = frame.linear_exr().unwrap().to_vec();
            let pixels = image::load_from_memory(&png).unwrap().to_rgba8();
            assert_eq!(pixels.dimensions(), (2, 2));
            assert!(
                pixels.pixels().all(|p| p[0] > p[1] && p[1] > p[2] && p[2] > 0 && p[3] == 255),
                "the actual PNG must show the red>green>blue map; the unmapped receiver and sole source are achromatic"
            );
            assert!(weak.upgrade().is_none(), "the completed CPU producer releases encoded maps before publishing a final image");
            drop(running);
            assert!(job.work_released());
            assert!(weak.upgrade().is_none(), "observed final handle/frame cannot pin encoded map backing");
            assert_eq!(host.admitted_bytes(), frame._reservation.bytes + retained + 123);
            job.0.data.lock().unwrap().frame = None;
            drop(frame);
            assert_eq!(host.admitted_bytes(), retained + 123);
            drop(job);
            assert_eq!(host.admitted_bytes(), 123);
            drop(plan);
            assert_eq!(host.admitted_bytes(), 0);
            (png, raw)
        };
        let original = render(None);
        assert_eq!(original, render(Some(0)), "new transfer must preserve actual CPU mapped PNG/raw bytes and sample stream");
        assert_eq!(original, render(Some(4096)), "retired capture scratch must not alter the actual mapped image or retained lease split");
    }

    #[cfg(all(feature = "raytrace-cpu", not(target_arch = "wasm32")))]
    #[test]
    fn capture_errors_drop_typed_resources_before_outer_credit_and_reject_context_changes() {
        let (scene, image, weak) = mapped();
        let host = cpu(MEMORY_LIMIT);
        let cancel = CancelToken::default();
        let bytes = image.textures.as_ref().unwrap().captured_bytes().unwrap();
        let retained = RetainedMetadata(host.0.shared.budget.reserve(123).unwrap());
        let mut credit =
            host.reserve_capture(bytes, CaptureProfile::CpuRaytrace(super::super::super::CpuBudget::Compact), &cancel, Some(&retained)).unwrap();
        // Observe the exact inner refusal boundary used by the consuming public
        // wrapper: parameters have died, but the enclosing credit is still alive.
        let result = host.prepare_submission_inner(scene, image, JobOptions::default(), None, cancel.clone(), None, Some(&mut credit));
        assert!(matches!(result,Err(e) if e.code==ErrorCode::WrongOwner));
        assert!(weak.upgrade().is_none());
        assert_eq!(host.admitted_bytes(), bytes + 123);
        drop(credit);
        assert_eq!(host.admitted_bytes(), 123);
        drop(retained);
        assert_eq!(host.admitted_bytes(), 0);
        let (scene, image, weak) = mapped();
        let cancel = CancelToken::default();
        let bytes = image.textures.as_ref().unwrap().captured_bytes().unwrap();
        let original = RetainedMetadata(host.0.shared.budget.reserve(123).unwrap());
        let same_sized = RetainedMetadata(host.0.shared.budget.reserve(123).unwrap());
        let mut credit =
            host.reserve_capture(bytes, CaptureProfile::CpuRaytrace(super::super::super::CpuBudget::Compact), &cancel, Some(&original)).unwrap();
        let error =
            host.prepare_submission_inner(scene, image, JobOptions::default(), None, cancel, Some(&same_sized), Some(&mut credit)).err().unwrap();
        assert_eq!(error.code, ErrorCode::WrongOwner, "equal byte count cannot substitute a different retained Plan owner");
        assert!(weak.upgrade().is_none());
        assert_eq!(host.admitted_bytes(), bytes + 246);
        drop(credit);
        drop(original);
        drop(same_sized);
        assert_eq!(host.admitted_bytes(), 0);
        for variant in 0..3 {
            let (scene, mut image, weak) = mapped();
            let cancel = CancelToken::default();
            let bytes = image.textures.as_ref().unwrap().captured_bytes().unwrap();
            let credit = host
                .reserve_capture(
                    if variant == 2 { bytes - 1 } else { bytes },
                    CaptureProfile::CpuRaytrace(super::super::super::CpuBudget::Compact),
                    &cancel,
                    None,
                )
                .unwrap();
            let other = cpu(MEMORY_LIMIT);
            if variant == 1 {
                image.raytrace.as_mut().unwrap().budget = super::super::super::CpuBudget::Studio;
            }
            let owner = if variant == 0 { &other } else { &host };
            let error = owner.prepare_submission_with_capture(scene, image, JobOptions::default(), None, cancel, None, credit).err().unwrap();
            assert_eq!(error.code, if variant == 2 { ErrorCode::LimitExceeded } else { ErrorCode::WrongOwner });
            assert!(weak.upgrade().is_none());
            assert_eq!(host.admitted_bytes(), 0);
            assert_eq!(other.admitted_bytes(), 0);
        }
    }
    #[cfg(all(feature = "raytrace-cpu", not(target_arch = "wasm32")))]
    #[test]
    fn capture_extension_counts_independent_retained_owner_at_exact_cpu_profile_boundary() {
        let host = cpu(MEMORY_LIMIT);
        let cancel = CancelToken::default();
        let plan = RetainedMetadata(host.0.shared.budget.reserve(123).unwrap());
        let maximum = super::super::super::CpuBudget::Compact.limits().max_job_bytes;
        let mut credit =
            host.reserve_capture(maximum - 123, CaptureProfile::CpuRaytrace(super::super::super::CpuBudget::Compact), &cancel, Some(&plan)).unwrap();
        assert_eq!(host.admitted_bytes(), maximum);
        assert_eq!(credit.try_extend(1, &cancel).unwrap_err().code, ErrorCode::LimitExceeded);
        assert_eq!(host.admitted_bytes(), maximum);
        drop(credit);
        assert_eq!(host.admitted_bytes(), 123);
        drop(plan);
        assert_eq!(host.admitted_bytes(), 0);
    }
    #[cfg(all(feature = "raytrace-cpu", not(target_arch = "wasm32")))]
    #[test]
    fn capture_pool_failure_and_cancelled_prepared_keep_credit_until_owned_backing_drops() {
        let (scene, image, weak) = mapped();
        let host = cpu(MEMORY_LIMIT);
        let options = JobOptions::default();
        let admission = host.admit(&scene, &image, options).unwrap();
        let total = admission.estimated_total_bytes + retained_request_bytes(&image).unwrap() + image.retained_resource_metadata_bytes();
        let busy = host.0.shared.budget.reserve(MEMORY_LIMIT - total + 1).unwrap();
        let cancel = CancelToken::default();
        let bytes = image.textures.as_ref().unwrap().captured_bytes().unwrap();
        let mut credit = host.reserve_capture(bytes, CaptureProfile::CpuRaytrace(super::super::super::CpuBudget::Compact), &cancel, None).unwrap();
        let error = host.prepare_submission_inner(scene, image, options, None, cancel, None, Some(&mut credit)).err().unwrap();
        assert_eq!(error.code, ErrorCode::LimitExceeded);
        assert!(weak.upgrade().is_none());
        assert_eq!(host.admitted_bytes(), busy.bytes + bytes);
        drop(credit);
        assert_eq!(host.admitted_bytes(), busy.bytes);
        drop(busy);
        assert_eq!(host.admitted_bytes(), 0);
        let (scene, image, weak) = mapped();
        let cancel = CancelToken::default();
        let admission = host.admit(&scene, &image, options).unwrap();
        let bytes = admission.estimated_total_bytes + retained_request_bytes(&image).unwrap() + image.retained_resource_metadata_bytes() + 4096;
        let credit = host.reserve_capture(bytes, CaptureProfile::CpuRaytrace(super::super::super::CpuBudget::Compact), &cancel, None).unwrap();
        let mut slot = Some(host.prepare_submission_with_capture(scene, image, options, None, cancel.clone(), None, credit).unwrap());
        assert_eq!(slot.as_ref().unwrap().admission().estimated_total_bytes, admission.estimated_total_bytes + 4096);
        let held = host.admitted_bytes();
        assert_eq!(held, bytes);
        cancel.cancel();
        assert_eq!(host.try_submit_prepared(id(9511, 1), 1, &mut slot).err().unwrap().code, ErrorCode::Cancelled);
        assert!(slot.is_some() && weak.upgrade().is_some());
        assert_eq!(host.admitted_bytes(), held, "failed publication retains the full funded capsule");
        drop(slot);
        assert!(weak.upgrade().is_none());
        assert_eq!(host.admitted_bytes(), 0);
    }
    #[cfg(all(feature = "raytrace-cpu", not(target_arch = "wasm32")))]
    #[test]
    fn capture_rechecks_actual_registered_layout_after_admission_before_merging_credit() {
        let (scene, mut image, weak) = mapped();
        image.integrator = Integrator::Raster;
        image.raytrace = None;
        let changed = Arc::new(AtomicU64::new(2));
        let host = registered(MEMORY_LIMIT, changed.clone());
        let cancel = CancelToken::default();
        let bytes = image.textures.as_ref().unwrap().captured_bytes().unwrap();
        let credit = host.reserve_capture(bytes, CaptureProfile::Registered, &cancel, None).unwrap();
        let error = host.prepare_submission_with_capture(scene, image, JobOptions::default(), None, cancel, None, credit).err().unwrap();
        assert_eq!(changed.load(Ordering::Acquire), 3);
        assert_eq!(error.code, ErrorCode::HostUnavailable);
        assert_eq!(error.message, "resolved capture executor metadata changed");
        assert!(weak.upgrade().is_none());
        assert_eq!(host.admitted_bytes(), 0);
        assert!(host.0.shared.queue.lock().unwrap().is_empty());
    }
    #[cfg(all(feature = "raytrace-cpu", not(target_arch = "wasm32")))]
    #[test]
    fn capture_registered_factory_failure_releases_source_credit_and_preserves_only_record_summary() {
        let (scene, mut image, weak) = mapped();
        image.integrator = Integrator::Raster;
        image.raytrace = None;
        let host = registered(MEMORY_LIMIT, Arc::new(AtomicU64::new(0)));
        let cancel = CancelToken::default();
        let retained = image.retained_resource_metadata_bytes();
        let bytes = image.textures.as_ref().unwrap().captured_bytes().unwrap();
        let credit = host.reserve_capture(bytes, CaptureProfile::Registered, &cancel, None).unwrap();
        let prepared = host.prepare_submission_with_capture(scene, image, JobOptions::default(), None, cancel, None, credit).unwrap();
        let job = host.submit_prepared(id(9512, 1), 1, prepared).unwrap();
        assert!(job.0.request.textures.is_none());
        let work = host.0.shared.queue.lock().unwrap().pop_front().unwrap();
        assert!(Running::begin(work).is_none());
        assert_eq!(job.status().unwrap().progress.phase, Phase::Failed);
        assert!(job.work_released());
        assert!(weak.upgrade().is_none());
        assert!(job.frame().unwrap().is_none());
        assert_eq!(host.admitted_bytes(), retained);
        drop(job);
        assert_eq!(host.admitted_bytes(), 0);
    }
}

#[cfg(all(feature = "raytrace-cpu", not(target_arch = "wasm32")))]
#[test]
fn actual_cpu_texture_worker_releases_sources_after_completion_or_cancel_while_status_is_retained() {
    use crate::job::textures::{PlanarFrame, RuntimeTextures, TextureBinding, TextureMap};
    use image::ImageEncoder;
    for cancelled in [false, true] {
        // Real native admission and ImageTask, manually pumped to avoid timing races.
        let host = ImageHost(Arc::new(Owner {
            executor: None,
            shared: CpuHost::shared(MEMORY_LIMIT),
            kind: HostKind::NativeWorker,
            running: Mutex::new(None),
            _worker: None,
        }));
        let mut encoded = Vec::new();
        image::codecs::png::PngEncoder::new(&mut encoded).write_image(&[128, 64, 32, 255], 1, 1, image::ExtendedColorType::Rgba8).unwrap();
        let resources = Arc::new(
            RuntimeTextures::new(vec![TextureBinding {
                body_index: 0,
                body_name: "Portable wood".into(),
                frame: PlanarFrame { origin: [0.; 3], u: [1., 0., 0.], v: [0., 1., 0.] },
                normal_strength: 1.,
                base_color: Some(TextureMap::new(encoded, crate::texture_input::MapRole::BaseColor).unwrap()),
                normal: None,
                roughness: None,
                metallic: None,
                base_color_mode: Default::default(),
                flip_v: false,
            }])
            .unwrap(),
        );
        let weak = Arc::downgrade(&resources);
        let mesh = Mesh {
            positions: vec![solidcore_record::Vec3::ZERO, solidcore_record::Vec3::X, solidcore_record::Vec3::Y],
            triangles: vec![[0, 1, 2]],
            ..Default::default()
        };
        let scene = ProductScene {
            bounds: mesh.bounds(),
            meshes: vec![crate::ProductMesh {
                name: "Portable wood".into(),
                mesh: Arc::new(mesh),
                color: [255; 3],
                opacity: 1.,
                surface: None,
                transmission: None,
                faces: vec![],
            }],
        };
        let input = ImageRequest {
            integrator: Integrator::Raytrace,
            raytrace: Some(Default::default()),
            textures: Some(resources),
            width: 2,
            height: 2,
            ..request()
        };
        let job = host.submit(id(1599, 1), 1, scene, input).unwrap();
        let status = job.status().unwrap();
        assert!(status.request.textures.is_none());
        assert_eq!(status.textures.as_ref().unwrap().bodies, 1);
        let work = host.0.shared.queue.lock().unwrap().pop_front().unwrap();
        let mut running = Running::begin(work).unwrap();
        assert!(weak.upgrade().is_some());
        assert!(running.guarded_step(1));
        if cancelled {
            job.cancel().unwrap();
        }
        let mut finished = false;
        for _ in 0..10_000 {
            if !running.guarded_step(4) {
                finished = true;
                break;
            }
        }
        assert!(finished);
        drop(running);
        assert!(weak.upgrade().is_none(), "terminal CPU status cannot retain encoded texture payloads");
        assert_eq!(job.status().unwrap().progress.phase, if cancelled { Phase::Cancelled } else { Phase::Completed });
        assert_eq!(job.frame().unwrap().is_some(), !cancelled);
        drop(status);
        drop(job);
        assert_eq!(host.admitted_bytes(), 0);
    }
}