Fix project open/save: list projects, reload on save, capture map

Three fixes to the project lifecycle, all e2e-covered:

- Load listed no projects. The engine's NativeListDir only ever returns files
  (it never populates its directory result), so a project -- an .sdd folder --
  was invisible and Open project came back empty. list_assets now gets
  directories from SubDirs (which works), as the asset picker already does.

- First Save now reloads into the project, as Lua's Project:Save does for a new
  project. Save As emits the reload; ReloadIntoProjectCommand builds the start
  script from the in-memory ProjectManager (from_memory) rather than the
  script.txt the save is still writing asynchronously, so it does not race.

- A save from a booted/loaded editor wrote a mapless start script ("No map
  selected in startscript") because a full reload resets ProjectManager to
  default. SaveProjectInfoCommand now captures the engine's current map and game
  (via Game::get_game_map_info_owned) when the project has none, fixing both the
  on-disk script and the reload.

E2E: project_round_trip (create then Load it back), project_save_as (Save As
reloads into the saved project, verified past the reload), plus large_map_create
and new_project_create assert LoadProjectCommand.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: gajop

native/src/sbc/actions/project.rs

@@ -54,13 +54,12 @@ pub fn commit_new_project(
             project_name.to_string(),
             path.clone(),
             true,
-            Some(project.clone()),
+            Some(project),
         )),
-        Box::new(ReloadIntoProjectCommand::for_new_project(
+        Box::new(ReloadIntoProjectCommand::after_save(
             path,
             game_name,
             game_version,
-            project,
         )),
     ]
 }

native/src/sbc/actions/run.rs

@@ -216,18 +216,27 @@ fn open_save_as() -> ActionResult {
     };
     ActionResult::OpenFileDialog {
         config,
-        on_accept: Box::new(|result, _iface| {
+        on_accept: Box::new(|result, iface| {
             let name = result
                 .path
                 .strip_prefix(PROJECTS_DIR)
                 .unwrap_or(&result.path)
                 .trim_end_matches(".sdd")
                 .to_string();
             let path = result.path.clone();
+            let (game_name, game_version) = game_id(iface);
+            // Saving under a new name is a new project: reload into it, as Lua's
+            // Project:Save does for isNewProject. The save writes script.txt
+            // asynchronously, so the reload builds from the in-memory project.
             vec![
                 Box::new(SetProjectNamePathCommand::new(name.clone(), path.clone())),
                 Box::new(SaveProjectInfoCommand::new(name, path.clone(), true, None)),
-                Box::new(SaveCommand::new(path, true)),
+                Box::new(SaveCommand::new(path.clone(), true)),
+                Box::new(ReloadIntoProjectCommand::after_save(
+                    path,
+                    game_name,
+                    game_version,
+                )),
             ]
         }),
     }

native/src/sbc/panels/controls/grid.rs

@@ -394,31 +394,34 @@ pub(crate) fn list_assets(
     extensions: &[&str],
 ) -> Vec<GridItem> {
     let extensions = normalize_extensions(extensions);
-    // Non-recursive listing across every VFS mode, as Lua's Path.DirList does.
-    let Ok(entries) = interface.vfs().list_entries(dir, "*", "", false) else {
-        return Vec::new();
-    };
-
-    let mut dirs = Vec::new();
-    let mut files = Vec::new();
-    for entry in entries {
-        let name = entry.name;
-        if name.is_empty() {
-            continue;
-        }
-        let path = join_entry(dir, &name);
-        let caption = path.rsplit('/').next().unwrap_or(&path).to_string();
-
-        if entry.is_directory {
-            dirs.push(GridItem {
+    // Directories must come from SubDirs, not the entry listing: the engine's
+    // ListDir only ever returns files (it never fills its directory list), so a
+    // project -- an `.sdd` folder in the write dir -- is invisible to a plain
+    // entry listing and Load comes back empty. SubDirs defaults to VFS.RAW_FIRST,
+    // which sees the write dir, exactly as Lua's `Path.SubDirs` does.
+    let mut dirs: Vec<GridItem> = vfs_sub_dirs(interface, dir.trim_end_matches('/'))
+        .into_iter()
+        .map(|name| {
+            let path = join_entry(dir, &name);
+            GridItem {
                 id: path,
-                caption,
+                caption: name,
                 image: None,
                 is_directory: true,
                 tooltip: None,
                 tooltip_markup: None,
-            });
-        } else {
+            }
+        })
+        .collect();
+
+    let mut files = Vec::new();
+    if let Ok(entries) = interface.vfs().list_entries(dir, "*", "", false) {
+        for entry in entries {
+            if entry.is_directory || entry.name.is_empty() {
+                continue;
+            }
+            let path = join_entry(dir, &entry.name);
+            let caption = path.rsplit('/').next().unwrap_or(&path).to_string();
             let matches = extensions.is_empty()
                 || extensions.iter().any(|ext| {
                     caption

native/src/sbc/project/commands/reload_into_project_command.rs

@@ -9,7 +9,7 @@ use crate::sbc::command_system::context::Context;
 use crate::sbc::command_system::registry::register_command;
 use crate::sbc::project::ops::{project_info, reload};
 use crate::sbc::project::paths::ProjectPaths;
-use crate::sbc::project::ProjectData;
+use crate::sbc::project::ProjectManager;
 use crate::sbc::teams::TeamManager;
 
 #[derive(Deserialize, Debug)]
@@ -21,12 +21,13 @@ pub struct ReloadIntoProjectCommand {
     game_name: String,
     #[serde(rename = "gameVersion")]
     game_version: String,
-    /// A freshly created project whose `script.txt` write is still in flight on
-    /// the IO worker. When set, the reload builds the start script from this in
-    /// memory instead of reading the not-yet-written file. Loading an existing
-    /// project leaves it `None` and reads the on-disk script.
+    /// A project just saved this tick, whose `script.txt` write is still in
+    /// flight on the IO worker. Build the start script from the in-memory
+    /// `ProjectManager` (which the save populated) instead of reading the
+    /// not-yet-written file. Loading an existing project leaves it `false` and
+    /// reads the on-disk script.
     #[serde(skip)]
-    project: Option<ProjectData>,
+    from_memory: bool,
 }
 
 /// Accept a JSON object as a map; treat anything else as empty. Lua serializes
@@ -47,24 +48,20 @@ impl ReloadIntoProjectCommand {
             mod_options: Map::new(),
             game_name,
             game_version,
-            project: None,
+            from_memory: false,
         }
     }
 
-    /// Reload into a just-created project, building the start script from `project`
-    /// rather than the `script.txt` the save is still writing asynchronously.
-    pub(crate) fn for_new_project(
-        path: String,
-        game_name: String,
-        game_version: String,
-        project: ProjectData,
-    ) -> Self {
+    /// Reload into a project just saved this tick (New Project, or the first
+    /// Save of an unsaved project), building the start script from the live
+    /// `ProjectManager` rather than the `script.txt` the save is still writing.
+    pub(crate) fn after_save(path: String, game_name: String, game_version: String) -> Self {
         Self {
             path,
             mod_options: Map::new(),
             game_name,
             game_version,
-            project: Some(project),
+            from_memory: true,
         }
     }
 }
@@ -83,17 +80,16 @@ impl Command for ReloadIntoProjectCommand {
 
 impl ReloadIntoProjectCommand {
     fn run(&self, ctx: &mut Context) -> Result<(), String> {
-        // A new project's script.txt is still being written by the IO worker, so
-        // build it from the project in memory; an existing project reads disk.
-        let saved = match &self.project {
-            Some(project) => {
-                project_info::start_script(project, &ctx.model::<TeamManager>().all_teams())
-            }
-            None => {
-                let path = ProjectPaths::new(Path::new(&self.path)).file(SCRIPT_FILE);
-                std::fs::read_to_string(&path)
-                    .map_err(|err| format!("read {}: {err}", path.display()))?
-            }
+        // A just-saved project's script.txt is still being written by the IO
+        // worker, so build it from the project in memory; an existing project
+        // reads disk.
+        let saved = if self.from_memory {
+            let project = ctx.model::<ProjectManager>().serialize().clone();
+            project_info::start_script(&project, &ctx.model::<TeamManager>().all_teams())
+        } else {
+            let path = ProjectPaths::new(Path::new(&self.path)).file(SCRIPT_FILE);
+            std::fs::read_to_string(&path)
+                .map_err(|err| format!("read {}: {err}", path.display()))?
         };
         let script = reload::start_script(
             &saved,

native/src/sbc/project/commands/save_project_info_command.rs

@@ -1,6 +1,7 @@
 use std::path::PathBuf;
 
 use serde::Deserialize;
+use spring_native::prelude::NativeInterfaceRef;
 
 use crate::sbc::command_system::command::Command;
 use crate::sbc::command_system::context::Context;
@@ -49,6 +50,22 @@ impl Command for SaveProjectInfoCommand {
             .unwrap_or_else(|| ctx.model::<ProjectManager>().serialize().clone());
         project.name = Some(self.name.clone());
         project.path = Some(self.path.clone());
+        // A project saved from a booted or loaded editor carries no map or game:
+        // a full reload resets ProjectManager to default, so the fields the New
+        // Project dialog sets are gone. Capture the engine's current map and game
+        // when they are missing, or the saved start script has no map and the
+        // reload aborts with "No map selected in startscript".
+        if project.map_name.is_none() {
+            project.map_name = current_map_name(ctx.interface);
+        }
+        if project.game.is_none() {
+            if let Ok(info) = ctx.interface.game().get_game_mod_info_owned() {
+                project.game = Some(serde_json::json!({
+                    "name": info.game_name,
+                    "version": info.game_version,
+                }));
+            }
+        }
         if project.mutators.is_empty() {
             project.mutators = vec![format!("{} 1.0", self.name)];
         }
@@ -86,4 +103,10 @@ impl Command for SaveProjectInfoCommand {
     }
 }
 
+/// The name of the map the engine currently has loaded (Lua's `Game.mapName`).
+fn current_map_name(interface: &NativeInterfaceRef) -> Option<String> {
+    let name = interface.game().get_game_map_info_owned().ok()?.map_name;
+    (!name.is_empty()).then_some(name)
+}
+
 register_command!(SaveProjectInfoCommand, "SaveProjectInfoCommand");

tools/e2e/scenarios/gallery.py

@@ -371,12 +371,42 @@ def new_project_create(run_state: E2ERun) -> None:
     run_state.assert_command("LoadProjectCommand")
 
 
+@scenario()
+def project_round_trip(run_state: E2ERun) -> None:
+    """Create a project, then reopen it through Load -- proving it is on disk
+    and openable.
+
+    Create writes the project and reloads into it; the Load dialog must then
+    list the `.sdd` folder, and selecting it reloads back into it. Two reloads,
+    so this asserts on the command log rather than goldens. Guards the engine
+    ListDir directory-listing gap: a regression there empties Load.
+    """
+    left = panel_left(run_state)
+    run_state.focus()
+
+    run_state.click(*panel_point(left, TOOLBAR["new_project"]), delay=1.0)
+    run_state.click(*dialog_point(run_state, DIALOG["new_project_name"]), delay=0.2)
+    run_state.type_text("RoundTrip")
+    run_state.key("Return", delay=0.3)
+    run_state.click(*dialog_point(run_state, DIALOG["new_project_create"]), delay=4.0)
+
+    # Reloaded into the new project; Load must now list it.
+    run_state.click(*panel_point(left, TOOLBAR["load"]), delay=1.5)
+    run_state.screenshot("load-lists-project")
+    run_state.click(*dialog_point(run_state, DIALOG["file_first_cell"]), delay=0.5)
+    run_state.click(*dialog_point(run_state, DIALOG["file_ok"]), delay=4.0)
+    # Create + Load each reload; both entries survive in the append-only log.
+    run_state.assert_command_at_least("ReloadIntoProjectCommand", 2)
+    run_state.screenshot("after-load")
+
+
 @scenario()
 def project_save_as(run_state: E2ERun) -> None:
-    """Save As writes the current project under a new name (no reload).
+    """Save As writes the current project under a new name and reloads into it.
 
-    Emits SetProjectNamePath + SaveProjectInfo + Save. The name-input row pushes
-    the dialog footer down, so this uses the taller dialog's OK position.
+    Emits SetProjectNamePath + SaveProjectInfo + Save + Reload, as Lua's
+    Project:Save does for a new project. The name-input row pushes the dialog
+    footer down, so this uses the taller dialog's OK position.
     """
     left = panel_left(run_state)
     run_state.focus()
@@ -385,10 +415,15 @@ def project_save_as(run_state: E2ERun) -> None:
     run_state.click(*dialog_point(run_state, DIALOG["file_name"]), delay=0.3)
     run_state.type_text("SavedProj")
     run_state.key("Return", delay=0.3)
-    run_state.click(*dialog_point(run_state, DIALOG["file_ok_name"]), delay=1.5)
+    run_state.click(*dialog_point(run_state, DIALOG["file_ok_name"]), delay=4.0)
     run_state.assert_command("SetProjectNamePathCommand")
     run_state.assert_command("SaveProjectInfoCommand")
     run_state.assert_command("SaveCommand")
+    run_state.assert_command("ReloadIntoProjectCommand")
+    # The reload must actually complete: a screenshot here fails the run if the
+    # engine died reloading (a crash would exit it before this xwd).
+    run_state.move(1280, 700, delay=6.0)
+    run_state.screenshot("after-reload")
 
 
 @scenario()

tools/e2e/scenarios/geometry.py

@@ -246,6 +246,7 @@
     "new_project_create": (347, 407),
     "file_name": (240, 590),
     "file_type": (240, 629),
+    "file_ok": (347, 602),
     # A name-input dialog (Save As) has its footer one row below the plain one.
     "file_ok_name": (347, 641),
     "asset_core_cell": (104, 360),