//! The plug-in ABI end to end: the example Invert plug-in, and hostile modules (infinite loops, //! memory bombs, out-of-bounds access, bad manifests…), which must all fail with an error, quickly. use std::time::{Duration, Instant}; use photocraft_color::{PixelFormat, SampleType}; use photocraft_geom::Rect; use photocraft_plugins::{Error, Limits, Plugin}; use photocraft_raster::Surface; use serde_json::json; const INVERT: &[u8] = include_bytes!("fixtures/invert.wasm"); /// A module implementing the ABI whose pieces can be swapped: `manifest` JSON, `version`, /// `filter` body (params `$buf $len $w $h $ch $fmt $pp $pl`, result i32) and extra items. fn module(manifest: &str, version: i32, filter: &str, extra: &str) -> Vec { let escaped = manifest.replace('\\', "\\\\").replace('"', "\\\""); let src = format!( r#"(module {extra} (memory (export "memory") 1) (data (i32.const 16) "{escaped}") (func (export "pc_abi_version") (result i32) (i32.const {version})) (func (export "pc_manifest") (result i64) (i64.or (i64.shl (i64.const {len}) (i64.const 32)) (i64.const 16))) (func (export "pc_alloc") (param $n i32) (result i32) (local $old i32) (local.set $old (memory.grow (i32.shr_u (i32.add (local.get $n) (i32.const 65535)) (i32.const 16)))) (if (result i32) (i32.eq (local.get $old) (i32.const -1)) (then (i32.const 0)) (else (i32.mul (local.get $old) (i32.const 65536))))) (func (export "pc_filter") (param $buf i32) (param $len i32) (param $w i32) (param $h i32) (param $ch i32) (param $fmt i32) (param $pp i32) (param $pl i32) (result i32) {filter}) )"#, len = manifest.len() ); wat::parse_str(&src).unwrap_or_else(|e| panic!("bad test WAT: {e}\n{src}")) } const MANIFEST: &str = r#"{"id":"test.plugin","name":"Test","version":"1","kind":"filter"}"#; fn ok_module(filter: &str) -> Vec { module(MANIFEST, 1, filter, "") } fn surface(fmt: PixelFormat, w: i32, h: i32) -> Surface { let mut s = Surface::new(fmt); for y in 0..h { for x in 0..w { let v = ((x * 7 + y * 13) % 31) as f32 / 30.0; let a = if (x + y) % 9 == 0 { 0.0 } else { 0.25 + 0.75 * ((x % 4) as f32 / 3.0) }; s.write_pixel(x, y, &[v, 1.0 - v, (x % 5) as f32 / 4.0, a]); } } s } /// Runs `bytes` as a filter on a small image; returns the error and how long it took. fn run_err(bytes: &[u8], limits: Limits) -> (Error, Duration) { let t = Instant::now(); let r = Plugin::load(bytes, limits).and_then(|p| { let s = surface(PixelFormat::RGBA8, 32, 24); p.apply(&s, Rect::new(0, 0, 32, 24), None, &json!({})) }); (r.expect_err("hostile module must fail"), t.elapsed()) } #[test] fn example_invert_loads_and_reports_its_manifest() { let p = Plugin::load(INVERT, Limits::default()).unwrap(); let m = p.manifest(); assert_eq!(m.id, "org.photocraft.example.invert"); assert_eq!(m.name, "Invert (WebAssembly)"); assert_eq!(m.kind, photocraft_plugins::Kind::Filter); assert!(m.params.is_empty()); assert!(p.size() < 4096, "the example stays tiny: {} bytes", p.size()); } #[test] fn example_invert_inverts_colour_at_every_depth() { let p = Plugin::load(INVERT, Limits::default()).unwrap(); for sample in SampleType::ALL { let fmt = PixelFormat { sample, ..PixelFormat::RGBA8 }; let s = surface(fmt, 40, 30); let out = p.apply(&s, Rect::new(0, 0, 40, 30), None, &json!({})).unwrap(); for (x, y) in [(1, 1), (0, 0), (17, 3), (39, 29)] { let (a, b) = (s.pixel(x, y), out.pixel(x, y)); if a[3] <= 0.0 { assert_eq!(a, b, "transparent pixels are left alone"); continue; } for c in 0..3 { assert!((b[c] - (1.0 - a[c])).abs() < 1e-6, "{sample:?} ({x},{y}) c{c}: {a:?} -> {b:?}"); } assert_eq!(a[3], b[3], "alpha is kept"); } } } #[test] fn bands_are_seamless_and_selection_blends() { // Tiny bands: many instances, same result as one band. let small = Limits { band_bytes: 40 * 4 * 4 * 3, ..Limits::default() }; let p1 = Plugin::load(INVERT, Limits::default()).unwrap(); let p2 = Plugin::load(INVERT, small).unwrap(); let s = surface(PixelFormat::RGBA16, 40, 30); let canvas = Rect::new(0, 0, 40, 30); assert_eq!(p1.apply(&s, canvas, None, &json!({})).unwrap(), p2.apply(&s, canvas, None, &json!({})).unwrap()); // A half-strength selection over the left half. let mut sel = Surface::new(PixelFormat::GRAY8); sel.fill_rect(Rect::new(0, 0, 20, 30), &[1.0]); sel.fill_rect(Rect::new(0, 0, 20, 10), &[0.5]); let out = p1.apply(&s, canvas, Some(&sel), &json!({})).unwrap(); assert_eq!(out.pixel(30, 20), s.pixel(30, 20), "outside the selection"); let (a, b) = (s.pixel(4, 20), out.pixel(4, 20)); assert!((b[0] - (1.0 - a[0])).abs() < 1e-4, "fully selected"); let (a, b) = (s.pixel(5, 5), out.pixel(5, 5)); let k = sel.pixel(5, 5)[0]; let half = a[0] + (1.0 - a[0] - a[0]) * k; assert!((b[0] - half).abs() < 2.0 / 65535.0, "half selected: {a:?} {b:?}"); } #[test] fn params_and_image_context_reach_the_plugin() { // Writes params_len / 1000 into every sample, so the host must pass the JSON through. let fill = r#"(local $i i32) (block $done (loop $l (br_if $done (i32.ge_u (local.get $i) (local.get $len))) (f32.store (i32.add (local.get $buf) (local.get $i)) (f32.div (f32.convert_i32_u (local.get $pl)) (f32.const 1000))) (local.set $i (i32.add (local.get $i) (i32.const 4))) (br $l))) (i32.const 0)"#; let man = r#"{"id":"test.params","name":"P","kind":"filter","params":{"amount":{"type":"number","min":0,"max":10,"default":5}}}"#; let p = Plugin::load(&module(man, 1, fill, ""), Limits::default()).unwrap(); assert_eq!(p.manifest().params_notation(), r#"{"amount":0..10=5}"#); let s = surface(PixelFormat::RGBA32F, 8, 8); let out = p.apply(&s, Rect::new(0, 0, 8, 8), None, &json!({"amount": 3})).unwrap(); let v = out.pixel(1, 1)[0] * 1000.0; assert!(v > 100.0 && v < 600.0, "params JSON length {v}"); // Wrong-typed params are refused before the plug-in runs. assert!(matches!(p.apply(&s, Rect::new(0, 0, 8, 8), None, &json!({"amount": "x"})), Err(Error::Params(_)))); } #[test] fn nan_and_out_of_range_output_is_sanitised() { // Fills the buffer with NaN: every pixel keeps its value. let nan = r#"(local $i i32) (block $done (loop $l (br_if $done (i32.ge_u (local.get $i) (local.get $len))) (f32.store (i32.add (local.get $buf) (local.get $i)) (f32.const nan)) (local.set $i (i32.add (local.get $i) (i32.const 4))) (br $l))) (i32.const 0)"#; let p = Plugin::load(&ok_module(nan), Limits::default()).unwrap(); let s = surface(PixelFormat::RGBA32F, 8, 8); assert_eq!(p.apply(&s, Rect::new(0, 0, 8, 8), None, &json!({})).unwrap(), s); } #[test] fn hostile_modules_fail_quickly() { let quick = Duration::from_secs(5); let cases: Vec<(&str, Vec)> = vec![ ("infinite loop", ok_module("(loop $l (br $l)) (i32.const 0)")), ("memory.grow bomb, then trap", ok_module("(loop $l (br_if $l (i32.ne (memory.grow (i32.const 512)) (i32.const -1)))) unreachable")), ("memory.grow forever", ok_module("(loop $l (drop (memory.grow (i32.const 1))) (br $l)) (i32.const 0)")), ("out-of-bounds write", ok_module("(i32.store (i32.const -4) (i32.const 0)) (i32.const 0)")), ("trap", ok_module("unreachable")), ("division by zero", ok_module("(i32.div_u (i32.const 1) (local.get $ch)) (drop) (i32.div_u (i32.const 1) (i32.const 0))")), ("deep recursion", module(MANIFEST, 1, "(call $r) (i32.const 0)", "(func $r (call $r))")), ("error code", ok_module("(i32.const 7)")), ("wrong ABI version", module(MANIFEST, 2, "(i32.const 0)", "")), ("bad manifest", module("not json", 1, "(i32.const 0)", "")), ("manifest with a bad id", module(r#"{"id":"a b","name":"x","kind":"filter"}"#, 1, "(i32.const 0)", "")), ("manifest of the wrong kind", module(r#"{"id":"a","name":"x","kind":"panel"}"#, 1, "(i32.const 0)", "")), ("start function loops", module(MANIFEST, 1, "(i32.const 0)", "(func $spin (loop $l (br $l))) (start $spin)")), ("WASI import", module(MANIFEST, 1, "(i32.const 0)", r#"(import "wasi_snapshot_preview1" "fd_write" (func (param i32 i32 i32 i32) (result i32)))"#)), ]; for (name, bytes) in cases { let (e, t) = run_err(&bytes, Limits::default()); assert!(t < quick, "{name} took {t:?}"); eprintln!("{name}: {e} ({t:?})"); } } #[test] fn malformed_and_oversized_modules_are_refused() { let half = &INVERT[..INVERT.len() / 2]; for (name, bytes) in [("empty", &b""[..]), ("garbage", &b"\0asm\x01\0\0\0\xff\xff\xff"[..]), ("not wasm", &b"MZ\x90\0"[..]), ("truncated", half)] { assert!(matches!(Plugin::load(bytes, Limits::default()), Err(Error::Module(_))), "{name}"); } let tiny = Limits { max_module_bytes: 100, ..Limits::default() }; assert!(matches!(Plugin::load(INVERT, tiny), Err(Error::Module(_)))); // Huge initial memory, manifest outside memory, missing exports, bogus allocations. let huge = wat::parse_str(r#"(module (memory (export "memory") 60000))"#).unwrap(); assert!(Plugin::load(&huge, Limits::default()).is_err()); let no_filter = wat::parse_str( r#"(module (memory (export "memory") 1) (func (export "pc_abi_version") (result i32) (i32.const 1)) (func (export "pc_manifest") (result i64) (i64.const 0)))"#, ) .unwrap(); assert!(Plugin::load(&no_filter, Limits::default()).is_err()); let src = r#"(module (memory (export "memory") 1) (func (export "pc_abi_version") (result i32) (i32.const 1)) (func (export "pc_manifest") (result i64) (i64.const 0x00000064ffffff00)) (func (export "pc_alloc") (param i32) (result i32) (i32.const 16)) (func (export "pc_filter") (param i32 i32 i32 i32 i32 i32 i32 i32) (result i32) (i32.const 0)))"#; assert!(matches!(Plugin::load(&wat::parse_str(src).unwrap(), Limits::default()), Err(Error::Abi(_)))); let bogus_alloc = wat::parse_str(format!( r#"(module (memory (export "memory") 1) (data (i32.const 16) "{}") (func (export "pc_abi_version") (result i32) (i32.const 1)) (func (export "pc_manifest") (result i64) (i64.const {})) (func (export "pc_alloc") (param i32) (result i32) (i32.const -16)) (func (export "pc_filter") (param i32 i32 i32 i32 i32 i32 i32 i32) (result i32) (i32.const 0)))"#, MANIFEST.replace('"', "\\\""), ((MANIFEST.len() as i64) << 32) | 16 )) .unwrap(); let (e, _) = run_err(&bogus_alloc, Limits::default()); assert!(matches!(e, Error::Abi(_)), "{e}"); } /// The message `Plugin::load` gives a file that is not WebAssembly and not recognised (#10362). const NOT_WASM: &str = "not a valid plug-in module: not a WebAssembly binary (missing \\0asm header)"; /// Loads `bytes`, which must be refused as a module, and returns the message. fn refusal(bytes: &[u8]) -> String { let Err(e) = Plugin::load(bytes, Limits::default()) else { panic!("{bytes:?} was accepted") }; assert!(matches!(e, Error::Module(_)), "{e}"); e.to_string() } /// The message names the format (`format`), says plug-ins are WebAssembly, and stays on one line /// (`Plugin::load` has only bytes, so the hint cannot carry a path). fn assert_names(bytes: &[u8], format: &str) { let m = refusal(bytes); assert!(m.starts_with(NOT_WASM), "{m}"); assert!(m.contains(format), "{m}"); assert!(m.contains("PhotoCraft plug-ins are WebAssembly modules"), "{m}"); assert!(!m.contains('\n'), "{m}"); } #[test] fn a_pe_coff_file_is_named_as_a_windows_binary() { // #10362: an old Photoshop plug-in (.8bt) is a native Windows module. assert_names(b"MZ\x90\x00\x03\0", "Windows"); assert!(refusal(b"MZ").contains("8bf")); } #[test] fn an_elf_file_is_named_as_a_linux_library() { assert_names(&[0x7f, b'E', b'L', b'F', 2, 1, 1], "Linux"); } #[test] fn a_mach_o_file_is_named_as_a_macos_binary() { for head in [[0xce, 0xfa, 0xed, 0xfe], [0xcf, 0xfa, 0xed, 0xfe], [0xca, 0xfe, 0xba, 0xbe], [0xbe, 0xba, 0xfe, 0xca]] { assert_names(&[&head[..], &[7, 1][..]].concat(), "macOS"); } } #[test] fn a_zip_file_is_named_as_a_zip_archive() { assert_names(b"PK\x03\x04\x14\0", "zip"); assert_names(b"PK\x05\x06\0\0", "zip"); } #[test] fn an_empty_or_unrecognised_file_keeps_the_plain_message() { // Nothing recognised (including a signature cut short): today's message, exactly. for bytes in [&b""[..], &b"x"[..], &b"junkjunk"[..], &[0x7f, b'E'][..], &b"PK"[..]] { assert_eq!(refusal(bytes), NOT_WASM, "{bytes:?}"); } } #[test] fn a_valid_wasm_module_still_loads_unchanged() { assert!(Plugin::load(INVERT, Limits::default()).is_ok()); } #[test] fn a_code_section_claiming_no_functions_but_many_bytes_is_refused() { // Header, then a code section (id 10) declaring 2000 bytes whose function count is 0, cut off // after the count (a truncated download) or padded to its full size. The spec makes the // count's own byte the whole section; wasmi's strict limits divided the size by the count. let truncated = b"\0asm\x01\0\0\0\x0a\xd0\x0f\x00".to_vec(); let mut padded = truncated.clone(); padded.resize(padded.len() + 1999, 0); // The same section after a valid empty one: a duplicate reaches the division before validation. let mut second = b"\0asm\x01\0\0\0\x0a\x01\x00".to_vec(); second.extend_from_slice(&padded[8..]); for (name, bytes) in [("truncated", truncated), ("padded", padded), ("second", second)] { assert!(matches!(Plugin::load(&bytes, Limits::default()), Err(Error::Module(_))), "{name}"); } // An empty code section (count 0, nothing after it) is valid; it fails only for the missing ABI exports. let empty = b"\0asm\x01\0\0\0\x0a\x01\x00"; assert!(matches!(Plugin::load(empty, Limits::default()), Err(Error::Abi(_)))); } #[test] fn budgets_stop_runaway_plugins() { let spin = ok_module("(loop $l (br $l)) (i32.const 0)"); // Instruction budget. let (e, _) = run_err(&spin, Limits { fuel_base: 1_000_000, fuel_per_sample: 10, ..Limits::default() }); assert_eq!(e, Error::Limit("instruction budget".into())); } #[test] fn parallel_bands_preserve_the_originating_error() { let pool = rayon::ThreadPoolBuilder::new().num_threads(2).build().unwrap(); let mut s = Surface::new(PixelFormat::RGBA8); s.fill_rect(Rect::new(0, 0, 256, 256), &[0.0, 0.0, 0.0, 1.0]); s.fill_rect(Rect::new(0, 256, 256, 512), &[1.0, 0.0, 0.0, 1.0]); for (body, expected) in [ ("(i32.const 7)", Error::Failed("pc_filter returned error code 7".into())), ("unreachable", Error::Trap("wasm `unreachable` instruction executed".into())), ] { // The later band fails immediately while the earlier one is still running (or hasn't // started). Collecting in band order must not turn that failure into sibling cancellation. let filter = format!( "(if (result i32) (f32.gt (f32.load (local.get $buf)) (f32.const 0.5)) \ (then {body}) (else (loop $spin (br $spin)) (i32.const 0)))" ); let limits = Limits { band_bytes: 1, fuel_base: 100_000_000, fuel_per_sample: 0, ..Limits::default() }; let p = Plugin::load(&ok_module(&filter), limits).unwrap(); let before = s.clone(); let e = pool.install(|| p.apply(&s, Rect::new(0, 0, 256, 512), None, &json!({}))).unwrap_err(); assert_eq!(e, expected); assert_eq!(s, before, "a failed run must not change the input"); } } #[test] fn parallel_bands_preserve_instruction_budget() { let pool = rayon::ThreadPoolBuilder::new().num_threads(4).build().unwrap(); let p = Plugin::load( &ok_module("(loop $spin (br $spin)) (i32.const 0)"), Limits { band_bytes: 1, fuel_base: 1_000_000, fuel_per_sample: 0, ..Limits::default() }, ) .unwrap(); let mut s = Surface::new(PixelFormat::RGBA8); s.fill_rect(Rect::new(0, 0, 768, 512), &[0.25, 0.5, 0.75, 1.0]); for _ in 0..8 { let e = pool.install(|| p.apply(&s, Rect::new(0, 0, 768, 512), None, &json!({}))).unwrap_err(); assert_eq!(e, Error::Limit("instruction budget".into())); } } #[test] fn wall_clock_budget_stops_runaway_plugins() { let spin = ok_module("(loop $l (br $l)) (i32.const 0)"); // Wall-clock budget, with an effectively unlimited instruction budget. let (e, t) = run_err(&spin, Limits { fuel_base: u64::MAX / 4, wall_time_ms: 300, ..Limits::default() }); assert_eq!(e, Error::Limit("time budget".into())); assert!(t < Duration::from_secs(3), "{t:?}"); } #[test] fn memory_cap_limits_bands() { // Memory cap: a band that can't fit is refused up front. let s = surface(PixelFormat::RGBA8, 64, 8); let p = Plugin::load(INVERT, Limits { max_memory_bytes: 4 << 20, band_bytes: 64 << 20, ..Limits::default() }).unwrap(); assert!(p.apply(&s, Rect::new(0, 0, 64, 8), None, &json!({})).is_ok(), "small bands still fit"); let p = Plugin::load(INVERT, Limits { max_memory_bytes: 1024, ..Limits::default() }); assert!(p.is_err() || p.unwrap().apply(&s, Rect::new(0, 0, 64, 8), None, &json!({})).is_err()); } #[test] fn registry_install_list_remove() { // Its own id: the registry is process-wide and tests run in parallel. let id = "test.registry"; let p = photocraft_plugins::registry::install_bytes(&module(r#"{"id":"test.registry","name":"R","kind":"filter"}"#, 1, "(i32.const 0)", "")).unwrap(); assert_eq!(p.id(), id); let rev = photocraft_plugins::registry::revision(); assert!(photocraft_plugins::registry::list().iter().any(|p| p.id() == id)); assert!(photocraft_plugins::registry::get(id).is_some()); assert!(photocraft_plugins::registry::remove(id)); assert!(!photocraft_plugins::registry::remove(id)); assert!(photocraft_plugins::registry::get(id).is_none()); assert!(photocraft_plugins::registry::revision() > rev); } #[test] fn folder_loading_skips_bad_files() { let dir = std::env::temp_dir().join(format!("photocraft-plugins-test-{}", std::process::id())); std::fs::create_dir_all(&dir).unwrap(); std::fs::write(dir.join("a-invert.wasm"), INVERT).unwrap(); std::fs::write(dir.join("b-broken.wasm"), b"\0asm junk").unwrap(); std::fs::write(dir.join("notes.txt"), b"ignored").unwrap(); let r = photocraft_plugins::registry::load_folder(&dir).unwrap(); assert_eq!(r.loaded, ["org.photocraft.example.invert"]); assert_eq!(r.failed.len(), 1); assert!(r.failed[0].0.ends_with("b-broken.wasm")); assert!(photocraft_plugins::registry::load_folder(&dir.join("missing")).is_err()); assert!(photocraft_plugins::registry::load_file(&dir, Limits::default()).is_err(), "a directory is not a module"); std::fs::remove_dir_all(&dir).ok(); } /// #8603: a run whose memory budget holds a single instance still covers every band on a /// many-worker pool, one band at a time, with the same pixels as a run of parallel bands. #[test] fn one_band_at_a_time_matches_parallel_bands() { let pool = rayon::ThreadPoolBuilder::new().num_threads(8).build().unwrap(); let s = surface(PixelFormat::RGBA8, 600, 300); let canvas = Rect::new(0, 0, 600, 300); let run = |limits: Limits| { let p = Plugin::load(INVERT, limits).unwrap(); pool.install(|| p.apply(&s, canvas, None, &json!({}))).unwrap() }; let parallel = run(Limits { band_bytes: 1, ..Limits::default() }); let serial = run(Limits { band_bytes: 1, max_total_memory_bytes: 512 << 20, ..Limits::default() }); assert_eq!(serial, parallel); assert_ne!(serial, s, "the filter ran"); } /// #8603: one run on 16 workers must not hold 16 instances at the 512 MiB cap (8 GiB). With the /// default limits it holds at most four (2 GiB); a smaller per-instance cap lets every worker /// run, and a budget under one cap still runs one band at a time rather than none. #[test] fn parallel_bands_fit_the_total_memory_budget() { let d = Limits::default(); assert_eq!(d.parallel_bands(16), 4); assert!(d.parallel_bands(64) * d.max_memory_bytes <= d.max_total_memory_bytes); assert_eq!(d.parallel_bands(2), 2, "fewer workers than the budget allows"); let small = Limits { max_memory_bytes: 64 << 20, ..Limits::default() }; assert_eq!(small.parallel_bands(16), 16, "small instances keep every worker busy"); let tight = Limits { max_total_memory_bytes: 1 << 20, ..Limits::default() }; assert_eq!(tight.parallel_bands(16), 1, "at least one band runs"); assert_eq!(d.parallel_bands(0), 1); } #[test] fn a_start_function_that_spins_is_cut_off_at_one_slice() { // `fuel_base` is what a call may use; the start function cannot be interrupted to check the // clock, so it gets one slice of it at most. let spin = "(func $spin (loop $l (br $l))) (start $spin)"; let limits = Limits { fuel_base: u64::MAX / 4, ..Limits::default() }; let (error, took) = run_err(&module(MANIFEST, 1, "(i32.const 0)", spin), limits); assert!(matches!(error, Error::Trap(_) | Error::Limit(_)), "{error:?}"); assert!(took < Duration::from_secs(30), "{took:?}"); } #[test] fn content_spread_over_millions_of_bands_is_refused_before_planning_them() { let p = Plugin::load(INVERT, Limits::default()).unwrap(); let mut s = Surface::new(PixelFormat::RGBA8); s.write_pixel(0, 0, &[0.1, 0.2, 0.3, 1.0]); s.write_pixel(4_000_000, 4_000_000, &[0.1, 0.2, 0.3, 1.0]); let t = Instant::now(); let e = p.apply(&s, Rect::new(0, 0, 8, 8), None, &json!({})).expect_err("a 15600 × 15600 tile grid is not one run"); assert!(matches!(e, Error::Limit(_)), "{e:?}"); assert!(t.elapsed() < Duration::from_secs(5), "{:?}", t.elapsed()); } #[cfg(unix)] #[test] fn a_fifo_in_place_of_a_module_file_does_not_block_loading() { let dir = std::env::temp_dir().join(format!("photocraft-plugin-fifo-{}", std::process::id())); std::fs::create_dir_all(&dir).unwrap(); let path = dir.join("evil.wasm"); let _ = std::fs::remove_file(&path); // `rustix::fs::mknodat` is unavailable on Apple targets. `mkfifo` is the // POSIX utility for creating this special file and keeps this regression // test available on macOS as well as other Unix platforms. let status = std::process::Command::new("mkfifo").arg(&path).status().unwrap(); assert!(status.success(), "mkfifo failed with {status}"); let (tx, rx) = std::sync::mpsc::channel(); let p = path.clone(); std::thread::spawn(move || { let _ = tx.send(photocraft_plugins::registry::load_file(&p, Limits::default()).map(|_| ())); }); let r = rx.recv_timeout(Duration::from_secs(10)).expect("loading a FIFO must not block"); assert!(matches!(r, Err(Error::Io(_))), "{r:?}"); let _ = std::fs::remove_dir_all(&dir); }