diff --git a/crates/pcraft-bundle/src/lib.rs b/crates/pcraft-bundle/src/lib.rs index acbe739b6..9156df70c 100644 --- a/crates/pcraft-bundle/src/lib.rs +++ b/crates/pcraft-bundle/src/lib.rs @@ -370,7 +370,8 @@ impl DirectoryBundleWriter { /// Saves an entry set incrementally. Existing objects are reused only after a hash check; /// unchanged file signatures may skip checks until they enter the rolling verification /// window. The manifest is atomically published last, then stale previews and objects are - /// collected while the bundle lock is held. + /// collected while the bundle lock is held. Collection is best-effort after publication: + /// inaccessible or unsafe leftovers cannot turn a committed save into a reported failure. pub fn save_directory(&mut self, root: &Path, bundle: ZipBundleWriter) -> Result { if !bundle.entries.contains_key(craft_pcraft_format::MANIFEST) { return Err(Error::InvalidBundle("manifest not set".into())); @@ -454,38 +455,29 @@ impl DirectoryBundleWriter { craft_atomic::atomic_write(&manifest_path, manifest).map_err(io_error)?; stats.written = stats.written.saturating_add(1); - let mut removed_paths = Vec::new(); + // The durable manifest is the commit boundary. Cleanup owns only canonical regular + // object files and previews; leave unsafe, inaccessible or locked leftovers for later. for kind in [craft_pcraft_format::TILES_DIR, craft_pcraft_format::BLOBS_DIR] { let dir = root.join(kind); - if !dir.exists() { + if !cleanup_directory(&dir) { continue; } - refuse_symlink(&dir)?; - for entry in fs::read_dir(&dir).map_err(io_error)? { - let entry = entry.map_err(io_error)?; + let Ok(entries) = fs::read_dir(&dir) else { continue }; + for entry in entries { + let Ok(entry) = entry else { continue }; let name = entry.file_name(); let path = format!("{kind}/{}", name.to_string_lossy()); - if is_object_path(&path) && !bundle.entries.contains_key(&path) { - let metadata = fs::symlink_metadata(entry.path()).map_err(io_error)?; - if metadata.file_type().is_symlink() || !metadata.is_file() { - return Err(Error::InvalidBundle(format!("refusing to collect non-file object {path}"))); - } - fs::remove_file(entry.path()).map_err(io_error)?; - removed_paths.push(path); + if is_object_path(&path) && !bundle.entries.contains_key(&path) && remove_cleanup_file(&entry.path()) { stats.removed = stats.removed.saturating_add(1); } } } for path in [craft_pcraft_format::THUMB, craft_pcraft_format::COMPOSITE, craft_pcraft_format::FULL_COMPOSITE] { if !bundle.entries.contains_key(path) { - let target = root.join(path); - refuse_symlink(&target)?; - if fs::symlink_metadata(&target).is_ok() { - fs::remove_file(&target).map_err(io_error)?; - } + let _ = remove_cleanup_file(&root.join(path)); } } - self.verified.retain(|path, _| bundle.entries.contains_key(path) && !removed_paths.contains(path)); + self.verified.retain(|path, _| bundle.entries.contains_key(path)); Ok(stats) } @@ -510,7 +502,32 @@ impl DirectoryBundleWriter { } fn is_object_path(path: &str) -> bool { - path.starts_with("tiles/") || path.starts_with("blobs/") + valid_object_path(path) +} + +/// Do not traverse symlinked object/preview directories, including Windows junctions. +fn cleanup_directory(path: &Path) -> bool { + fs::symlink_metadata(path).is_ok_and(|metadata| metadata.is_dir() && !cleanup_link(&metadata)) +} + +fn cleanup_link(metadata: &fs::Metadata) -> bool { + #[cfg(windows)] + { + use std::os::windows::fs::MetadataExt; + metadata.file_attributes() & 0x400 != 0 // FILE_ATTRIBUTE_REPARSE_POINT includes junctions. + } + #[cfg(not(windows))] + { + metadata.file_type().is_symlink() + } +} + +/// Cleanup never follows or removes a directory/link and never reports a post-commit failure. +fn remove_cleanup_file(path: &Path) -> bool { + if path.parent().is_none_or(|parent| !cleanup_directory(parent)) { + return false; + } + fs::symlink_metadata(path).is_ok_and(|metadata| metadata.is_file() && !cleanup_link(&metadata)) && fs::remove_file(path).is_ok() } fn file_signature(path: &Path) -> Result> { diff --git a/crates/pcraft-bundle/tests/directory_cleanup.rs b/crates/pcraft-bundle/tests/directory_cleanup.rs new file mode 100644 index 000000000..29c09f72b --- /dev/null +++ b/crates/pcraft-bundle/tests/directory_cleanup.rs @@ -0,0 +1,269 @@ +//! Publication succeeds independently of best-effort cleanup of the previous entry set. +#![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)] + +use craft_pcraft_bundle::{DirectoryBundle, DirectoryBundleWriter, Limits, ObjectKind, ZipBundleWriter}; +use craft_pcraft_format::{COMPOSITE, FULL_COMPOSITE, MANIFEST, THUMB}; +use std::fs; +use std::path::{Path, PathBuf}; +use std::sync::atomic::{AtomicU64, Ordering}; + +const OLD: &[u8] = br#"{"revision":1}"#; +const NEW: &[u8] = br#"{"revision":2}"#; + +struct Temporary(PathBuf); + +impl Temporary { + fn new() -> Self { + static NEXT: AtomicU64 = AtomicU64::new(0); + let path = std::env::temp_dir().join(format!("craft-bundle-cleanup-{}-{}", std::process::id(), NEXT.fetch_add(1, Ordering::Relaxed))); + fs::create_dir(&path).unwrap(); + Self(path) + } + + fn bundle(&self) -> PathBuf { + self.0.join("document.pcraft") + } +} + +impl Drop for Temporary { + fn drop(&mut self) { + let _ = fs::remove_dir_all(&self.0); + } +} + +fn entries(manifest: &[u8]) -> ZipBundleWriter { + let mut bundle = ZipBundleWriter::default(); + bundle.set_manifest(manifest.to_vec()).unwrap(); + bundle +} + +fn assert_manifest(root: &Path, expected: &[u8]) { + assert_eq!(fs::read(root.join(MANIFEST)).unwrap(), expected); + assert_eq!(DirectoryBundle::open(root, Limits::default()).unwrap().manifest().unwrap(), expected); +} + +#[test] +fn non_file_stale_object_does_not_fail_the_committed_save() { + let temp = Temporary::new(); + let root = temp.bundle(); + let mut writer = DirectoryBundleWriter::default(); + writer.save_directory(&root, entries(OLD)).unwrap(); + let stuck = root.join("tiles").join(format!("{}.zst", "0".repeat(64))); + fs::create_dir_all(stuck.join("inner")).unwrap(); + fs::write(stuck.join("inner/keep"), b"not an object file").unwrap(); + + let stats = writer.save_directory(&root, entries(NEW)).expect("cleanup cannot fail after manifest publication"); + assert_manifest(&root, NEW); + assert_eq!(stats.removed, 0); + assert_eq!(fs::read(stuck.join("inner/keep")).unwrap(), b"not an object file"); +} + +#[test] +fn cleanup_removes_only_canonical_stale_regular_objects_and_reuses_current_objects() { + let temp = Temporary::new(); + let root = temp.bundle(); + let mut writer = DirectoryBundleWriter::default(); + let mut first = entries(OLD); + let retained = first.add_object(ObjectKind::Tile, b"still referenced").unwrap(); + let stale = first.add_object(ObjectKind::Blob, b"old blob").unwrap(); + for preview in [THUMB, COMPOSITE, FULL_COMPOSITE] { + first.set_preview(preview, b"old preview".to_vec()).unwrap(); + } + writer.save_directory(&root, first).unwrap(); + let retained_bytes = fs::read(root.join(&retained)).unwrap(); + let unrelated = [ + "tiles/personal-notes.zst".to_string(), + "blobs/012345.zst".to_string(), + format!("blobs/{}.zst", "A".repeat(64)), + format!("tiles/{}.zst.backup", "b".repeat(64)), + ]; + for path in &unrelated { + fs::write(root.join(path), b"unrelated").unwrap(); + } + let nested = root.join("blobs/not-an-object-folder"); + fs::create_dir(&nested).unwrap(); + fs::write(nested.join(format!("{}.zst", "c".repeat(64))), b"unrelated nested file").unwrap(); + let mut second = entries(NEW); + assert_eq!(second.add_object(ObjectKind::Tile, b"still referenced").unwrap(), retained); + let stats = writer.save_directory(&root, second).unwrap(); + + assert_manifest(&root, NEW); + assert_eq!(stats.removed, 1); + assert_eq!(stats.reused, 1); + assert_eq!(stats.reused_objects.as_slice(), std::slice::from_ref(&retained)); + assert!(stats.written_objects.is_empty()); + assert!(!root.join(stale).exists()); + assert_eq!(fs::read(root.join(retained)).unwrap(), retained_bytes); + for path in unrelated { + assert_eq!(fs::read(root.join(path)).unwrap(), b"unrelated"); + } + assert!(nested.is_dir()); + for preview in [THUMB, COMPOSITE, FULL_COMPOSITE] { + assert!(!root.join(preview).exists()); + } +} + +#[test] +fn stale_preview_directories_are_preserved_after_commit() { + let temp = Temporary::new(); + let root = temp.bundle(); + let mut writer = DirectoryBundleWriter::default(); + writer.save_directory(&root, entries(OLD)).unwrap(); + for preview in [THUMB, COMPOSITE, FULL_COMPOSITE] { + fs::create_dir_all(root.join(preview)).unwrap(); + fs::write(root.join(preview).join("keep"), b"directory contents").unwrap(); + } + let stats = writer.save_directory(&root, entries(NEW)).unwrap(); + assert_manifest(&root, NEW); + assert_eq!(stats.removed, 0); + for preview in [THUMB, COMPOSITE, FULL_COMPOSITE] { + assert_eq!(fs::read(root.join(preview).join("keep")).unwrap(), b"directory contents"); + } +} + +#[test] +fn required_non_file_objects_and_previews_fail_before_manifest_publication() { + let temp = Temporary::new(); + let root = temp.bundle(); + let mut writer = DirectoryBundleWriter::default(); + writer.save_directory(&root, entries(OLD)).unwrap(); + let mut changed = entries(NEW); + let object = changed.add_object(ObjectKind::Tile, b"required object").unwrap(); + fs::create_dir_all(root.join(&object)).unwrap(); + assert!(writer.save_directory(&root, changed).is_err()); + assert_manifest(&root, OLD); + + for preview in [THUMB, COMPOSITE] { + fs::create_dir_all(root.join(preview)).unwrap(); + let mut changed = entries(NEW); + changed.set_preview(preview, b"required preview".to_vec()).unwrap(); + assert!(writer.save_directory(&root, changed).is_err()); + assert_manifest(&root, OLD); + } +} + +#[cfg(windows)] +#[test] +fn locked_stale_object_and_preview_do_not_fail_commit_and_are_collected_on_retry() { + use std::fs::OpenOptions; + use std::os::windows::fs::OpenOptionsExt; + let temp = Temporary::new(); + let root = temp.bundle(); + let mut writer = DirectoryBundleWriter::default(); + let mut first = entries(OLD); + let stale = first.add_object(ObjectKind::Tile, b"locked stale tile").unwrap(); + first.set_preview(FULL_COMPOSITE, b"locked preview".to_vec()).unwrap(); + writer.save_directory(&root, first).unwrap(); + let tile_lock = OpenOptions::new().read(true).share_mode(0).open(root.join(&stale)).unwrap(); + let preview_lock = OpenOptions::new().read(true).share_mode(0).open(root.join(FULL_COMPOSITE)).unwrap(); + let stats = writer.save_directory(&root, entries(NEW)).unwrap(); + assert_manifest(&root, NEW); + assert_eq!(stats.removed, 0); + assert!(root.join(&stale).exists()); + assert!(root.join(FULL_COMPOSITE).exists()); + drop(tile_lock); + drop(preview_lock); + let retry = writer.save_directory(&root, entries(NEW)).unwrap(); + assert_manifest(&root, NEW); + assert_eq!(retry.removed, 1); + assert!(!root.join(stale).exists()); + assert!(!root.join(FULL_COMPOSITE).exists()); +} + +#[cfg(unix)] +#[test] +fn cleanup_preserves_symlinks_and_does_not_traverse_linked_directories() { + use std::os::unix::fs::symlink; + let temp = Temporary::new(); + let root = temp.bundle(); + let outside = temp.0.join("outside"); + fs::create_dir(&outside).unwrap(); + let object_name = format!("{}.zst", "d".repeat(64)); + fs::write(outside.join(&object_name), b"outside object").unwrap(); + fs::write(outside.join("preview.png"), b"outside preview").unwrap(); + let mut writer = DirectoryBundleWriter::default(); + writer.save_directory(&root, entries(OLD)).unwrap(); + symlink(&outside, root.join("blobs")).unwrap(); + symlink(&outside, root.join("composite")).unwrap(); + symlink(outside.join("preview.png"), root.join(THUMB)).unwrap(); + fs::create_dir(root.join("tiles")).unwrap(); + let linked_object = root.join("tiles").join(&object_name); + symlink(outside.join(&object_name), &linked_object).unwrap(); + let stats = writer.save_directory(&root, entries(NEW)).unwrap(); + assert_manifest(&root, NEW); + assert_eq!(stats.removed, 0); + assert_eq!(fs::read(outside.join(object_name)).unwrap(), b"outside object"); + assert_eq!(fs::read(outside.join("preview.png")).unwrap(), b"outside preview"); + for link in [root.join("blobs"), root.join("composite"), root.join(THUMB), linked_object] { + assert!(fs::symlink_metadata(link).unwrap().file_type().is_symlink()); + } +} + +#[cfg(unix)] +#[test] +fn required_symlink_objects_and_previews_still_fail_before_commit() { + use std::os::unix::fs::symlink; + let temp = Temporary::new(); + let root = temp.bundle(); + let outside = temp.0.join("outside-file"); + fs::write(&outside, b"unchanged outside bytes").unwrap(); + let mut writer = DirectoryBundleWriter::default(); + writer.save_directory(&root, entries(OLD)).unwrap(); + let mut changed = entries(NEW); + let object = changed.add_object(ObjectKind::Tile, b"required object").unwrap(); + fs::create_dir(root.join("tiles")).unwrap(); + symlink(&outside, root.join(object)).unwrap(); + assert!(writer.save_directory(&root, changed).is_err()); + assert_manifest(&root, OLD); + symlink(&outside, root.join(THUMB)).unwrap(); + let mut changed = entries(NEW); + changed.set_preview(THUMB, b"new preview".to_vec()).unwrap(); + assert!(writer.save_directory(&root, changed).is_err()); + assert_manifest(&root, OLD); + assert_eq!(fs::read(outside).unwrap(), b"unchanged outside bytes"); +} + +#[cfg(windows)] +#[test] +fn cleanup_does_not_traverse_windows_directory_junctions() { + use std::os::windows::process::CommandExt; + struct Junction(PathBuf); + impl Drop for Junction { + fn drop(&mut self) { + let _ = fs::remove_dir(&self.0); + } + } + fn junction(link: PathBuf, target: &Path) -> Junction { + // Fixture-owned absolute paths only; junctions require no symlink privilege. + assert!(link.is_absolute() && target.is_absolute()); + let output = std::process::Command::new("cmd") + .args(["/C", "mklink", "/J"]) + .arg(&link) + .arg(target) + .creation_flags(0x0800_0000) // CREATE_NO_WINDOW + .output() + .unwrap(); + assert!(output.status.success(), "{}", String::from_utf8_lossy(&output.stderr)); + Junction(link) + } + let temp = Temporary::new(); + let root = temp.bundle(); + let outside = temp.0.join("outside"); + fs::create_dir(&outside).unwrap(); + let object_name = format!("{}.zst", "e".repeat(64)); + fs::write(outside.join(&object_name), b"outside object").unwrap(); + fs::write(outside.join("preview.png"), b"outside preview").unwrap(); + fs::write(outside.join("full.png"), b"outside full preview").unwrap(); + let mut writer = DirectoryBundleWriter::default(); + writer.save_directory(&root, entries(OLD)).unwrap(); + let _objects = junction(root.join("blobs"), &outside); + let _previews = junction(root.join("composite"), &outside); + let stats = writer.save_directory(&root, entries(NEW)).unwrap(); + assert_manifest(&root, NEW); + assert_eq!(stats.removed, 0); + assert_eq!(fs::read(outside.join(object_name)).unwrap(), b"outside object"); + assert_eq!(fs::read(outside.join("preview.png")).unwrap(), b"outside preview"); + assert_eq!(fs::read(outside.join("full.png")).unwrap(), b"outside full preview"); + assert!(root.join("blobs").exists()); + assert!(root.join("composite").exists()); +} diff --git a/crates/svg/src/tree.rs b/crates/svg/src/tree.rs index 9cb004d89..ecea12706 100644 --- a/crates/svg/src/tree.rs +++ b/crates/svg/src/tree.rs @@ -302,6 +302,7 @@ struct Used { raster_limit: AtomicUsize, invalid_svg: AtomicUsize, svg_limit: AtomicUsize, + svg_resource_limit: AtomicUsize, } /// What resolving one drawing's embedded images used or refused. @@ -323,6 +324,10 @@ pub struct ImageUsage { pub invalid_svg_images: usize, /// Embedded SVG data refused by byte or nesting limits. pub svg_limit_images: usize, + /// Subset of `svg_limit_images` refused by unpacked byte or embedded-document-chain limits. + /// XML/tree-depth omissions and invalid or corrupt data do not set this counter. Consumers + /// can reject resource overruns while still allowing an optional, over-deep child to be omitted. + pub svg_resource_limit_images: usize, } /// A data-URL resolver and the accounting for the one drawing it serves. @@ -350,6 +355,7 @@ impl ImageResolver { raster_limit: AtomicUsize::new(0), invalid_svg: AtomicUsize::new(0), svg_limit: AtomicUsize::new(0), + svg_resource_limit: AtomicUsize::new(0), }), } } @@ -376,6 +382,7 @@ impl ImageResolver { raster_limit_images: self.used.raster_limit.load(Ordering::Relaxed), invalid_svg_images: self.used.invalid_svg.load(Ordering::Relaxed), svg_limit_images: self.used.svg_limit.load(Ordering::Relaxed), + svg_resource_limit_images: self.used.svg_resource_limit.load(Ordering::Relaxed), } } } @@ -438,6 +445,7 @@ fn raster_image(used: &Used, limits: &Limits, data: Arc>, format: craft_ fn embedded(used: &Used, limits: &Limits, data: &[u8], options: &usvg::Options<'_>) -> Option { if used.depth.load(Ordering::Relaxed) >= limits.embedded_depth { used.svg_limit.fetch_add(1, Ordering::Relaxed); + used.svg_resource_limit.fetch_add(1, Ordering::Relaxed); return None; } let left = limits.embedded_bytes.saturating_sub(used.bytes.load(Ordering::Relaxed)); @@ -445,9 +453,12 @@ fn embedded(used: &Used, limits: &Limits, data: &[u8], options: &usvg::Options<' Ok(text) => text, // What a refused document unpacked before it was refused was work too: it uses up what // is left, so the next image can't repeat it. - Err(_) => { + Err(error) => { used.bytes.fetch_add(left, Ordering::Relaxed); used.svg_limit.fetch_add(1, Ordering::Relaxed); + if matches!(error, svgz::Error::TooLarge(_)) { + used.svg_resource_limit.fetch_add(1, Ordering::Relaxed); + } return None; } }; diff --git a/crates/svg/src/tree/tests.rs b/crates/svg/src/tree/tests.rs index 59b42dacc..dd645381a 100644 --- a/crates/svg/src/tree/tests.rs +++ b/crates/svg/src/tree/tests.rs @@ -245,6 +245,108 @@ fn embedded_svgs_are_read_within_their_budgets() { assert_eq!(found(&svg(r#""#), shallow()), [false; 0]); } +mod resource_limit_usage { + use super::*; + + fn data_image(bytes: &[u8]) -> String { + let encoded: String = bytes.iter().map(|byte| format!("%{byte:02X}")).collect(); + format!(r#""#) + } + + fn packed(text: &str, gzip: bool) -> Vec { + if gzip { svgz::compress(text.as_bytes()) } else { text.as_bytes().to_vec() } + } + + /// The outer document has its own generous text allowance, so tiny resolver limits + /// test the public embedded admission contract rather than rejecting the outer XML. + fn resolved(text: &str, limits: Limits, outer_depth: usize) -> (Vec, ImageUsage) { + let resolver = ImageResolver::new(limits); + resolver.set_document_depth(outer_depth); + let options = usvg::Options { image_href_resolver: resolver.resolver(), ..Default::default() }; + let tree = parse(text.as_bytes(), &shallow(), &options).unwrap(); + let mut found = Vec::new(); + images(tree.root(), &mut found); + (found, resolver.usage()) + } + + #[test] + fn embedded_chain_caps_are_explicit_resource_refusals_for_plain_and_gzip_children() { + for gzip in [false, true] { + let inner = svg(""); + let middle = svg(&data_image(&packed(&inner, gzip))); + let outer = svg(&data_image(&packed(&middle, gzip))); + let (found, usage) = resolved(&outer, Limits { embedded_depth: 1, ..shallow() }, 1); + assert_eq!(found, [true]); + assert_eq!(usage.embedded_svg_depth, 1); + assert_eq!(usage.svg_limit_images, 1, "strict consumers still see the existing limit flag"); + assert_eq!(usage.svg_resource_limit_images, 1, "a chain cap must not become a successful partial bounded preview"); + let (found, usage) = resolved(&outer, Limits { embedded_depth: 2, ..shallow() }, 1); + assert_eq!(found, [true, true]); + assert_eq!((usage.svg_limit_images, usage.svg_resource_limit_images), (0, 0)); + } + } + + #[test] + fn embedded_per_image_byte_caps_are_resource_refusals_for_plain_and_gzip_children() { + let inner = svg(""); + for gzip in [false, true] { + let outer = svg(&data_image(&packed(&inner, gzip))); + let (_, usage) = resolved(&outer, Limits { bytes: inner.len() - 1, embedded_bytes: inner.len() * 3, ..shallow() }, 1); + assert_eq!(usage.embedded_svg_count, 0); + assert_eq!((usage.svg_limit_images, usage.svg_resource_limit_images), (1, 1)); + let (found, usage) = resolved(&outer, Limits { bytes: inner.len(), ..shallow() }, 1); + assert_eq!(found, [true]); + assert_eq!((usage.svg_limit_images, usage.svg_resource_limit_images), (0, 0)); + } + } + + #[test] + fn aggregate_embedded_bytes_are_resource_refusals_even_when_each_child_fits() { + let inner = svg(""); + for gzip in [false, true] { + let image = data_image(&packed(&inner, gzip)); + let outer = svg(&format!("{image}{image}")); + let cap = inner.len() * 2 - 1; + let (found, usage) = resolved(&outer, Limits { embedded_bytes: cap, ..shallow() }, 1); + assert_eq!(found, [true]); + assert_eq!(usage.embedded_svg_bytes, cap, "a refused child still spends the remaining work allowance"); + assert_eq!((usage.svg_limit_images, usage.svg_resource_limit_images), (1, 1)); + let (found, usage) = resolved(&outer, Limits { embedded_bytes: inner.len() * 2, ..shallow() }, 1); + assert_eq!(found, [true, true]); + assert_eq!((usage.svg_limit_images, usage.svg_resource_limit_images), (0, 0)); + } + } + + #[test] + fn combined_xml_depth_omissions_remain_distinct_from_resource_refusals() { + let inner = svg(""); + for gzip in [false, true] { + let image = data_image(&packed(&inner, gzip)); + let outer = svg(&format!("{}{}{}", "".repeat(4), image, "".repeat(4))); + let (found, usage) = resolved(&outer, Limits { tree_depth: 6, ..shallow() }, 5); + assert!(found.is_empty()); + assert_eq!(usage.svg_limit_images, 1, "strict consumers must continue to reject this omission"); + assert_eq!(usage.svg_resource_limit_images, 0, "non-strict consumers may omit this child without disguising a byte/chain overrun"); + let (found, usage) = resolved(&svg(&image), Limits { tree_depth: 6, ..shallow() }, 1); + assert_eq!(found, [true]); + assert_eq!((usage.svg_limit_images, usage.svg_resource_limit_images), (0, 0)); + } + } + + #[test] + fn invalid_and_corrupt_children_do_not_claim_a_resource_limit() { + let mut corrupt = svgz::compress(svg("").as_bytes()); + let crc = corrupt.len() - 8; + corrupt[crc] ^= 1; + for data in [b"not XML".to_vec(), corrupt] { + let (found, usage) = resolved(&svg(&data_image(&data)), shallow(), 1); + assert!(found.is_empty()); + assert!(usage.invalid_svg_images > 0 || usage.svg_limit_images > 0, "strict consumers still observe unreadable content"); + assert_eq!(usage.svg_resource_limit_images, 0); + } + } +} + mod draw_checks { use super::*;