//! Pre-engine project validation, recent-project discovery, and sandbox scaffolding. use std::collections::HashSet; use std::path::{Component, Path, PathBuf}; use std::process::Command; use bevy::app::AppExit; use bevy::prelude::*; use bevy::window::{CompositeAlphaMode, PresentMode, WindowPlugin}; use bevy_egui::{egui, EguiContext, EguiPlugin, EguiPrimaryContextPass, PrimaryEguiContext}; use settings::{ save_project_settings_to_string, ProjectKind, ProjectSettings, DEFAULT_PROJECT_PATH, PROJECT_TEMPLATE_VERSION, }; use crate::native_dialog::{NativeDialogBroker, NativeDialogPlugin}; use crate::project_io::UserPreferences; use crate::scene::recovery::atomic_write; use crate::ui::theme::{ apply_editor_theme, ACCENT, BORDER, CANVAS_BG, PANEL_BG, PANEL_BG_DARK, SELECTION, TEXT, TEXT_DIM, TEXT_MUTED, }; const SANDBOX_DIRECTORIES: &[&str] = &[ "assets/.index", "assets/.trash", "assets/audio", "assets/build_profiles", "assets/levels", "assets/materials", "assets/meshes/generated", "assets/models", "assets/post_fx", "assets/rendering_profiles", "assets/shaders", "assets/textures", ]; #[derive(Debug, Clone, PartialEq, Eq)] pub struct ProjectSummary { pub root: PathBuf, pub project_id: String, pub name: String, pub project_kind: ProjectKind, pub template_version: u32, pub capabilities: Vec, pub default_level: PathBuf, pub last_scene: Option, } #[derive(Debug, Clone, PartialEq, Eq, Default)] pub struct StartupArguments { pub project: Option, pub help: bool, } #[derive(Resource)] struct ProjectLauncherUi { recents: Vec, sandbox_name: String, sandbox_destination: Option, status: Option, } impl Default for ProjectLauncherUi { fn default() -> Self { let mut preferences = crate::project_io::read_user_preferences(); if let Ok(root) = std::env::current_dir().and_then(|root| root.canonicalize()) { crate::project_io::remember_project_root(&mut preferences, &root); } Self { recents: recent_project_summaries(&preferences), sandbox_name: "New Sandbox".to_string(), sandbox_destination: None, status: None, } } } pub fn run_project_launcher() { let mut app = App::new(); app.add_plugins(DefaultPlugins.set(WindowPlugin { primary_window: Some(Window { title: "Blacksite Project Browser".to_string(), name: Some("blacksite-project-launcher".to_string()), resolution: (960, 620).into(), present_mode: PresentMode::AutoVsync, transparent: false, composite_alpha_mode: CompositeAlphaMode::Opaque, ..default() }), ..default() })) .add_plugins(EguiPlugin::default()) .add_plugins(NativeDialogPlugin) .init_resource::() .add_systems(Startup, spawn_project_launcher_camera) .add_systems(EguiPrimaryContextPass, project_launcher_ui_system); app.run(); } fn spawn_project_launcher_camera(mut commands: Commands) { commands.spawn((Camera2d, PrimaryEguiContext)); } pub fn spawn_project_launcher_process() -> Result<(), String> { let executable = sibling_executable("project_launcher")?; let root = std::env::current_dir() .map_err(|error| format!("could not resolve active project root: {error}"))?; spawn_detached(&executable, &[], &root) } pub fn reveal_project_root(root: &Path) -> Result<(), String> { Command::new("xdg-open") .arg(root) .spawn() .map_err(|error| format!("could not reveal {}: {error}", root.display()))?; Ok(()) } fn project_launcher_ui_system(world: &mut World) { let Ok(context) = world .query_filtered::<&mut EguiContext, With>() .single(world) else { return; }; let mut context = context.clone(); world.resource_scope(|world, mut state: Mut| { project_launcher_ui(world, context.get_mut(), &mut state); }); } #[expect( deprecated, reason = "bevy_egui exposes a Context during EguiPrimaryContextPass, requiring one top-level context-based panel" )] fn project_launcher_ui(world: &mut World, context: &egui::Context, state: &mut ProjectLauncherUi) { apply_editor_theme(context); egui::CentralPanel::default() .frame( egui::Frame::new() .fill(CANVAS_BG) .inner_margin(egui::Margin::same(24)), ) .show(context, |ui| { let content_width = ui.available_width().min(1240.0); let side_space = ((ui.available_width() - content_width) * 0.5).max(0.0); ui.horizontal(|ui| { ui.add_space(side_space); ui.vertical(|ui| { ui.set_width(content_width); ui.horizontal(|ui| { ui.vertical(|ui| { ui.label( egui::RichText::new("BLACKSITE") .size(22.0) .strong() .color(ACCENT), ); ui.label( egui::RichText::new("PROJECT BROWSER") .size(11.0) .color(TEXT_DIM), ); }); ui.add_space(18.0); ui.separator(); ui.add_space(10.0); ui.label( egui::RichText::new( "Choose a validated workspace before the engine starts", ) .color(TEXT_DIM), ); }); ui.add_space(22.0); ui.horizontal(|ui| { ui.vertical(|ui| { ui.set_width(340.0); launcher_actions(world, ui, state); }); ui.add_space(18.0); ui.vertical(|ui| { ui.set_width((content_width - 358.0).max(360.0)); recent_projects(world, ui, state); }); }); if let Some(status) = state.status.as_deref() { ui.add_space(12.0); ui.separator(); ui.label(egui::RichText::new(status).color(TEXT_DIM)); } }); }); }); } fn launcher_actions(world: &mut World, ui: &mut egui::Ui, state: &mut ProjectLauncherUi) { egui::Frame::new() .fill(PANEL_BG_DARK) .stroke(egui::Stroke::new(1.0, BORDER)) .inner_margin(egui::Margin::same(16)) .show(ui, |ui| { ui.set_min_height(455.0); ui.heading("Open Project"); ui.label( egui::RichText::new("Select a root containing assets/project.ron").color(TEXT_DIM), ); ui.add_space(8.0); let dialog_pending = world.resource::().is_pending(); if ui .add_enabled(!dialog_pending, egui::Button::new("Browse Existing...")) .clicked() { let result = world.resource::().request( || rfd::FileDialog::new().pick_folder(), |world, root| { let Some(root) = root else { return; }; world.resource_scope(|world, mut state: Mut| { open_project_from_launcher(world, &mut state, root); }); }, ); if let Err(error) = result { state.status = Some(format!("Project browser unavailable: {error}")); } } ui.add_space(24.0); ui.separator(); ui.add_space(14.0); ui.heading("New Sandbox"); ui.label( egui::RichText::new("Creates a clean content workspace with a valid empty level") .color(TEXT_DIM), ); ui.add_space(8.0); ui.label(egui::RichText::new("Project name").color(TEXT_DIM)); ui.text_edit_singleline(&mut state.sandbox_name); ui.add_space(6.0); let destination = state .sandbox_destination .as_ref() .map(|path| path.display().to_string()) .unwrap_or_else(|| "No destination selected".to_string()); ui.add( egui::Label::new( egui::RichText::new(destination) .monospace() .color(TEXT_MUTED), ) .truncate(), ); if ui .add_enabled(!dialog_pending, egui::Button::new("Choose Empty Folder...")) .clicked() { let result = world.resource::().request( || rfd::FileDialog::new().pick_folder(), |world, destination| { if let Some(destination) = destination { world .resource_mut::() .sandbox_destination = Some(destination); } }, ); if let Err(error) = result { state.status = Some(format!("Folder browser unavailable: {error}")); } } let can_create = state.sandbox_destination.is_some() && !state.sandbox_name.trim().is_empty(); if ui .add_enabled(can_create, egui::Button::new("Create And Open Sandbox")) .clicked() { let destination = state.sandbox_destination.clone().unwrap(); match scaffold_sandbox_project(&destination, &state.sandbox_name) { Ok(summary) => launch_editor_and_close(world, state, &summary), Err(error) => state.status = Some(error), } } }); } fn recent_projects(world: &mut World, ui: &mut egui::Ui, state: &mut ProjectLauncherUi) { ui.horizontal(|ui| { ui.heading("Recent Projects"); ui.add_space(8.0); ui.label(egui::RichText::new(state.recents.len().to_string()).color(TEXT_MUTED)); }); ui.label( egui::RichText::new("Missing and invalid projects are filtered automatically") .color(TEXT_DIM), ); ui.add_space(10.0); if state.recents.is_empty() { egui::Frame::new() .fill(PANEL_BG) .stroke(egui::Stroke::new(1.0, BORDER)) .inner_margin(egui::Margin::same(16)) .show(ui, |ui| { ui.label(egui::RichText::new("No valid recent projects").color(TEXT)); ui.label( egui::RichText::new("Browse an existing project or create a sandbox.") .color(TEXT_DIM), ); }); return; } let recents = state.recents.clone(); egui::ScrollArea::vertical() .id_salt("project_launcher_recents") .show(ui, |ui| { for summary in recents { let response = egui::Frame::new() .fill(PANEL_BG) .stroke(egui::Stroke::new(1.0, BORDER)) .inner_margin(egui::Margin::same(14)) .show(ui, |ui| { ui.horizontal(|ui| { ui.vertical(|ui| { ui.label(egui::RichText::new(&summary.name).strong().color(TEXT)); ui.label( egui::RichText::new(summary.root.display().to_string()) .monospace() .size(11.0) .color(TEXT_MUTED), ); let detail = summary.last_scene.as_ref().map_or_else( || format!("{:?} | default scene", summary.project_kind), |scene| { format!( "{:?} | {}", summary.project_kind, scene .strip_prefix(&summary.root) .unwrap_or(scene) .display() ) }, ); ui.label(egui::RichText::new(detail).size(11.0).color(TEXT_DIM)); }); ui.with_layout( egui::Layout::right_to_left(egui::Align::Center), |ui| { if ui.button("Open").clicked() { launch_editor_and_close(world, state, &summary); } }, ); }); }); if response.response.hovered() { ui.painter().rect_stroke( response.response.rect, 0.0, egui::Stroke::new(1.0, SELECTION), egui::StrokeKind::Inside, ); } ui.add_space(8.0); } }); } fn open_project_from_launcher(world: &mut World, state: &mut ProjectLauncherUi, root: PathBuf) { match inspect_project(&root, None) { Ok(summary) => launch_editor_and_close(world, state, &summary), Err(error) => state.status = Some(error), } } fn launch_editor_and_close( world: &mut World, state: &mut ProjectLauncherUi, summary: &ProjectSummary, ) { match spawn_editor_process(&summary.root) { Ok(()) => { state.status = Some(format!("Opening {}", summary.name)); world.write_message(AppExit::Success); } Err(error) => state.status = Some(error), } } fn spawn_editor_process(root: &Path) -> Result<(), String> { let executable = sibling_executable("editor")?; spawn_detached( &executable, &[std::ffi::OsStr::new("--project"), root.as_os_str()], root, ) } #[cfg(target_os = "linux")] fn spawn_detached( executable: &Path, arguments: &[&std::ffi::OsStr], cwd: &Path, ) -> Result<(), String> { let mut command = Command::new("systemd-run"); command .args(["--user", "--collect", "--quiet", "--service-type=exec"]) .arg(format!("--working-directory={}", cwd.display())); for variable in [ "PATH", "WAYLAND_DISPLAY", "DISPLAY", "XAUTHORITY", "XDG_RUNTIME_DIR", "HYPRLAND_INSTANCE_SIGNATURE", "DBUS_SESSION_BUS_ADDRESS", "XDG_CURRENT_DESKTOP", "XDG_SESSION_DESKTOP", "XDG_SESSION_TYPE", "XDG_DATA_HOME", "XDG_CONFIG_HOME", "XDG_STATE_HOME", "GDK_BACKEND", "LD_LIBRARY_PATH", "WGPU_VALIDATION", "BEVY_FPS_HDR", ] { if let Some(value) = std::env::var_os(variable) { command.arg(format!("--setenv={variable}={}", value.to_string_lossy())); } } let status = command .arg(executable) .args(arguments) .status() .map_err(|error| format!("could not invoke systemd-run: {error}"))?; status.success().then_some(()).ok_or_else(|| { format!( "systemd-run could not start {} (status {status})", executable.display() ) }) } #[cfg(not(target_os = "linux"))] fn spawn_detached( executable: &Path, arguments: &[&std::ffi::OsStr], cwd: &Path, ) -> Result<(), String> { Command::new(executable) .args(arguments) .current_dir(cwd) .spawn() .map_err(|error| format!("could not start {}: {error}", executable.display()))?; Ok(()) } fn sibling_executable(name: &str) -> Result { let current = std::env::current_exe() .map_err(|error| format!("could not locate current executable: {error}"))?; let extension = current .extension() .map(|extension| extension.to_os_string()); let mut executable = current.with_file_name(name); if let Some(extension) = extension { executable.set_extension(extension); } executable .is_file() .then_some(executable.clone()) .ok_or_else(|| format!("required executable is not built: {}", executable.display())) } pub fn parse_startup_arguments( arguments: impl IntoIterator, ) -> Result { let mut parsed = StartupArguments::default(); let mut arguments = arguments.into_iter(); while let Some(argument) = arguments.next() { match argument.as_str() { "--project" => { if parsed.project.is_some() { return Err("--project may only be provided once".to_string()); } let path = arguments .next() .ok_or_else(|| "--project requires a project root path".to_string())?; parsed.project = Some(PathBuf::from(path)); } "--help" | "-h" => parsed.help = true, unknown => return Err(format!("unknown editor argument `{unknown}`")), } } Ok(parsed) } pub fn command_line_help() -> &'static str { "Blacksite Editor\n\nUSAGE:\n editor [--project ]\n\nOPTIONS:\n --project Open a validated Blacksite project before engine startup\n -h, --help Print this help" } pub fn activate_project_root(root: &Path) -> Result { let summary = inspect_project(root, None)?; std::env::set_current_dir(&summary.root).map_err(|error| { format!( "could not activate project root {}: {error}", summary.root.display() ) })?; Ok(summary) } pub fn inspect_project(root: &Path, last_scene: Option<&Path>) -> Result { let root = root .canonicalize() .map_err(|error| format!("could not open project root {}: {error}", root.display()))?; if !root.is_dir() { return Err(format!( "project root is not a directory: {}", root.display() )); } let manifest_path = root.join(DEFAULT_PROJECT_PATH); let text = std::fs::read_to_string(&manifest_path) .map_err(|error| format!("could not read {}: {error}", manifest_path.display()))?; let manifest: ProjectSettings = ron::from_str(&text).map_err(|error| { format!( "invalid project manifest {}: {error}", manifest_path.display() ) })?; if manifest.name.trim().is_empty() { return Err(format!( "project name is empty in {}", manifest_path.display() )); } manifest.audio.validate().map_err(|error| { format!( "invalid audio settings in {}: {error}", manifest_path.display() ) })?; let default_reference = Path::new(&manifest.default_level); if !default_reference.starts_with("assets/levels") || !manifest.default_level.ends_with(".scn.ron") { return Err("default_level must be a .scn.ron scene under assets/levels/".into()); } let default_level = safe_project_path(&root, default_reference, "default_level")?; let default_metadata = std::fs::symlink_metadata(&default_level).ok(); if !default_metadata .as_ref() .is_some_and(std::fs::Metadata::is_file) || default_metadata.is_some_and(|metadata| metadata.file_type().is_symlink()) { return Err(format!( "default level is missing or is not a regular file: {}", default_level.display() )); } let default_level_text = std::fs::read_to_string(&default_level).map_err(|error| { format!( "could not read default level {}: {error}", default_level.display() ) })?; scene::validate_level_text(&default_level_text).map_err(|error| { format!( "default level failed validation {}: {error}", default_level.display() ) })?; scene::validate_composition_graph(&default_level, &root).map_err(|error| { format!( "default level composition failed validation {}: {error}", default_level.display() ) })?; let last_scene = last_scene .and_then(|path| safe_project_path(&root, path, "last_scene").ok()) .filter(|path| path.is_file()); let project_id = if manifest.project_id.trim().is_empty() { format!("legacy:{}", root.display()) } else { manifest.project_id }; Ok(ProjectSummary { root, project_id, name: manifest.name, project_kind: manifest.project_kind, template_version: manifest.template_version, capabilities: manifest.capabilities, default_level, last_scene, }) } pub fn recent_project_summaries(preferences: &UserPreferences) -> Vec { let mut seen = HashSet::new(); preferences .recent_projects .iter() .filter_map(|root| { let root = PathBuf::from(root); let last_scene = preferences .recent_levels .iter() .map(PathBuf::from) .find(|scene| root.join(scene).is_file()); inspect_project(&root, last_scene.as_deref()).ok() }) .filter(|summary| seen.insert(summary.root.clone())) .collect() } pub fn scaffold_sandbox_project(destination: &Path, name: &str) -> Result { let name = name.trim(); if name.is_empty() { return Err("sandbox project name cannot be empty".to_string()); } if destination.exists() { let mut entries = std::fs::read_dir(destination) .map_err(|error| format!("could not inspect {}: {error}", destination.display()))?; if entries.next().is_some() { return Err(format!( "sandbox destination must be empty: {}", destination.display() )); } } for directory in SANDBOX_DIRECTORIES { std::fs::create_dir_all(destination.join(directory)).map_err(|error| { format!( "could not create sandbox directory {}: {error}", destination.join(directory).display() ) })?; } let default_level = "assets/levels/main.scn.ron"; let empty_scene = format!( "(schema_version: {},\n resources: {{}},\n entities: {{}},\n)\n", scene::CURRENT_SCENE_SCHEMA_VERSION ); scene::validate_level_text(&empty_scene)?; atomic_write(&destination.join(default_level), empty_scene.as_bytes())?; let manifest = ProjectSettings { project_id: uuid::Uuid::new_v4().to_string(), name: name.to_string(), project_kind: ProjectKind::Sandbox, template_version: PROJECT_TEMPLATE_VERSION, capabilities: vec![ "editor".into(), "gameplay".into(), "rendering".into(), "audio".into(), ], default_level: default_level.to_string(), asset_roots: vec![ "assets/audio".into(), "assets/levels".into(), "assets/materials".into(), "assets/meshes".into(), "assets/models".into(), "assets/textures".into(), ], ..ProjectSettings::default() }; let manifest_text = save_project_settings_to_string(&manifest) .map_err(|error| format!("could not serialize sandbox manifest: {error}"))?; atomic_write( &destination.join(DEFAULT_PROJECT_PATH), manifest_text.as_bytes(), )?; for (name, profile) in sandbox_build_profiles(default_level) { atomic_write( &destination.join("assets/build_profiles").join(name), profile.as_bytes(), )?; } inspect_project(destination, None) } fn sandbox_build_profiles(default_level: &str) -> [(&'static str, String); 3] { [ ( "development.ron", format!( "(version:1,name:\"Development\",cargo_profile:Development,target:None,features:[],rendering_tier:\"development\",default_scene:Some(\"{default_level}\"),output_dir:\"dist/development\")\n" ), ), ( "qa.ron", format!( "(version:1,name:\"QA\",cargo_profile:Qa,target:None,features:[],rendering_tier:\"representative\",default_scene:Some(\"{default_level}\"),output_dir:\"dist/qa\")\n" ), ), ( "release.ron", format!( "(version:1,name:\"Release\",cargo_profile:Release,target:None,features:[],rendering_tier:\"shipping\",default_scene:Some(\"{default_level}\"),output_dir:\"dist/release\")\n" ), ), ] } fn safe_project_path(root: &Path, path: impl AsRef, field: &str) -> Result { let path = path.as_ref(); if path.as_os_str().is_empty() || path.is_absolute() { return Err(format!("{field} must be a non-empty project-relative path")); } if path.components().any(|component| { matches!( component, Component::ParentDir | Component::RootDir | Component::Prefix(_) ) }) { return Err(format!("{field} cannot escape the project root")); } Ok(root.join(path)) } #[cfg(test)] mod tests { use super::*; fn temp_root(label: &str) -> PathBuf { std::env::temp_dir().join(format!("blacksite-{label}-{}", uuid::Uuid::new_v4())) } #[test] fn startup_arguments_parse_project_and_reject_unknown_flags() { let parsed = parse_startup_arguments(["--project".to_string(), "/tmp/project".to_string()]).unwrap(); assert_eq!(parsed.project, Some(PathBuf::from("/tmp/project"))); assert!(parse_startup_arguments(["--mystery".to_string()]).is_err()); assert!(parse_startup_arguments(["--project".to_string()]).is_err()); } #[test] fn sandbox_scaffold_can_be_inspected_and_reloaded() { let root = temp_root("sandbox"); let created = scaffold_sandbox_project(&root, "Prototype").unwrap(); let reopened = inspect_project(&root, Some(Path::new("assets/levels/main.scn.ron"))).unwrap(); assert_eq!(created.project_id, reopened.project_id); assert_eq!(reopened.name, "Prototype"); assert_eq!(reopened.project_kind, ProjectKind::Sandbox); assert_eq!(reopened.template_version, PROJECT_TEMPLATE_VERSION); assert!(reopened.capabilities.iter().any(|item| item == "audio")); let manifest = settings::load_project_settings_from_path( root.join(DEFAULT_PROJECT_PATH).to_string_lossy().as_ref(), ); assert!(manifest.audio.validate().is_ok()); assert!(manifest.audio.bus(settings::AUDIO_BUS_SFX_ID).is_some()); assert_eq!( reopened.last_scene, Some(root.join("assets/levels/main.scn.ron")) ); for directory in SANDBOX_DIRECTORIES { assert!(root.join(directory).is_dir(), "missing {directory}"); } for profile in ["development.ron", "qa.ron", "release.ron"] { let text = std::fs::read_to_string(root.join("assets/build_profiles").join(profile)).unwrap(); assert!(text.contains("assets/levels/main.scn.ron"), "{profile}"); assert!(text.contains("output_dir"), "{profile}"); } std::fs::remove_dir_all(root).unwrap(); } #[test] fn recent_projects_filter_missing_invalid_and_duplicate_roots() { let valid = temp_root("recent-valid"); let invalid = temp_root("recent-invalid"); scaffold_sandbox_project(&valid, "Valid").unwrap(); std::fs::create_dir_all(&invalid).unwrap(); let preferences = UserPreferences { recent_projects: vec![ valid.display().to_string(), "/definitely/missing/blacksite-project".to_string(), invalid.display().to_string(), valid.display().to_string(), ], recent_levels: vec!["assets/levels/main.scn.ron".to_string()], ..Default::default() }; let summaries = recent_project_summaries(&preferences); assert_eq!(summaries.len(), 1); assert_eq!(summaries[0].name, "Valid"); assert!(summaries[0].last_scene.is_some()); std::fs::remove_dir_all(valid).unwrap(); std::fs::remove_dir_all(invalid).unwrap(); } #[test] fn project_inspection_rejects_invalid_audio_bus_graphs() { let root = temp_root("invalid-audio-buses"); scaffold_sandbox_project(&root, "Invalid Audio").unwrap(); let manifest_path = root.join(DEFAULT_PROJECT_PATH); let mut manifest = settings::load_project_settings_from_path(manifest_path.to_string_lossy().as_ref()); manifest .audio .bus_mut(settings::AUDIO_BUS_SFX_ID) .unwrap() .parent = Some("missing".into()); std::fs::write( &manifest_path, save_project_settings_to_string(&manifest).unwrap(), ) .unwrap(); let error = inspect_project(&root, None).unwrap_err(); assert!(error.contains("invalid audio settings"), "{error}"); std::fs::remove_dir_all(root).unwrap(); } #[test] fn sandbox_scaffold_refuses_nonempty_destination_and_path_escape() { let root = temp_root("sandbox-nonempty"); std::fs::create_dir_all(&root).unwrap(); std::fs::write(root.join("keep.txt"), "user data").unwrap(); assert!(scaffold_sandbox_project(&root, "Unsafe").is_err()); assert!(safe_project_path(&root, "../outside", "test").is_err()); assert_eq!( std::fs::read_to_string(root.join("keep.txt")).unwrap(), "user data" ); std::fs::remove_dir_all(root).unwrap(); } #[test] fn project_default_level_must_use_the_audited_levels_tree() { let root = temp_root("default-level-contract"); scaffold_sandbox_project(&root, "Contract").unwrap(); std::fs::create_dir_all(root.join("assets/custom")).unwrap(); std::fs::write( root.join("assets/custom/start.scn.ron"), format!( "(schema_version:{},resources:{{}},entities:{{}})", scene::CURRENT_SCENE_SCHEMA_VERSION ), ) .unwrap(); let mut manifest = settings::load_project_settings_from_path( root.join(DEFAULT_PROJECT_PATH).to_string_lossy().as_ref(), ); manifest.default_level = "assets/custom/start.scn.ron".into(); std::fs::write( root.join(DEFAULT_PROJECT_PATH), save_project_settings_to_string(&manifest).unwrap(), ) .unwrap(); let error = inspect_project(&root, None).unwrap_err(); assert!(error.contains("assets/levels"), "{error}"); std::fs::remove_dir_all(root).unwrap(); } }