Persist just-run write dir; repopulate project on load; map-export e2e

- just run (launch_manual) now uses a durable write dir (XDG data, or
  SBC_WRITE_DIR) so projects and imports/exports survive a restart; tests pass
  no write_dir and keep their throwaway temp dirs.

- LoadProjectCommand repopulates ProjectManager's name/path. A reload/open
  resets the model to default, which left the loaded project looking unsaved:
  Ctrl+S reopened Save As and Export failed with "missing project path". Now
  Save and Export work on a project after any reload.

- map_export e2e: save a project, sculpt and paint the whole map, Ctrl+S, then
  Export -> Spring archive, asserting the sculpt/paint/export commands and that
  the compiled .sdz lands on disk.

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

Author: gajop

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

@@ -6,6 +6,7 @@ use crate::sbc::command_system::command::Command;
 use crate::sbc::command_system::context::Context;
 use crate::sbc::command_system::registry::register_command;
 use crate::sbc::project::io_registries::load;
+use crate::sbc::project::ProjectManager;
 
 #[derive(Deserialize, Debug)]
 pub struct LoadProjectCommand {
@@ -14,7 +15,18 @@ pub struct LoadProjectCommand {
 
 impl Command for LoadProjectCommand {
     fn execute(&mut self, ctx: &mut Context) {
-        load::load_project(ctx, &PathBuf::from(&self.path));
+        let path = PathBuf::from(&self.path);
+        load::load_project(ctx, &path);
+        // A reload or open resets ProjectManager to default, so restore the
+        // project's identity here. Without it Save (Ctrl+S) treats the loaded
+        // project as unsaved and reopens Save As, and Export has no project path.
+        let name = path
+            .file_stem()
+            .and_then(|stem| stem.to_str())
+            .unwrap_or_default()
+            .to_string();
+        ctx.model::<ProjectManager>()
+            .set_name_path(&name, &self.path);
     }
 
     fn undoable(&self) -> bool {

tools/e2e/scenarios/geometry.py

@@ -249,6 +249,8 @@
     "file_ok": (347, 602),
     # A name-input dialog (Save As) has its footer one row below the plain one.
     "file_ok_name": (347, 641),
+    # Export adds a type dropdown as well, dropping the footer another row.
+    "file_ok_export": (347, 680),
     "asset_core_cell": (104, 360),
     "asset_ok": (343, 603),
     "asset_ok_gallery": (347, 602),

tools/e2e/scenarios/map.py

@@ -4,6 +4,9 @@
 
 from typing import TYPE_CHECKING
 
+import time
+from pathlib import Path
+
 from scenarios.geometry import (
     dropdown_option,
     DIALOG,
@@ -14,6 +17,7 @@
     PARK_PANEL,
     TAB_X,
     TAB_Y,
+    TOOLBAR,
     dialog_point,
     editor_point,
     panel_left,
@@ -461,3 +465,86 @@ def settings_panel(run_state: E2ERun) -> None:
     run_state.screenshot("specular-off")
     run_state.click(*panel_point(left, MAP["settings_map_size"]), delay=0.9)
     run_state.screenshot_root("specular-on-root")
+
+
+def _sweep(run_state: E2ERun, left: int, width: int, height: int) -> None:
+    """One held stroke across the map, so the whole surface is covered rather
+    than a patch. The map fills the screen at the default zoom, so no zooming is
+    needed; the sweep stays inside the map (its edges are sky)."""
+    y = height // 2
+    run_state.press(width // 3, y)
+    run_state.move(left - 200, y, delay=0.4)
+    run_state.release(left - 200, y)
+
+
+def _wait_for_archive(run_state: E2ERun, stem: str, timeout_s: float = 20.0) -> Path | None:
+    """Poll the write dir for the compiled `.sdz`. The archive is built off the
+    draw thread, so it lands a little after the export command is logged."""
+    assert run_state.write_dir is not None
+    deadline = time.monotonic() + timeout_s
+    while time.monotonic() < deadline:
+        matches = [p for p in run_state.write_dir.rglob(f"{stem}*.sdz")]
+        if matches:
+            return matches[0]
+        time.sleep(0.3)
+    return None
+
+
+@scenario()
+def map_export(run_state: E2ERun) -> None:
+    """The whole map pipeline: save a project, sculpt and paint the map, then
+    compile it to a Spring archive.
+
+    Save As establishes a project (Export needs its path); a Terrain/Add sweep
+    reshapes the ground across the whole map, a texture sweep paints it, Ctrl+S
+    saves, and Export -> Spring archive runs the bundled compiler. Asserts the
+    sculpt/paint/export commands and that the compiled `.sdz` lands on disk.
+    Deliberately fast -- the point is the pipeline runs end to end.
+    """
+    run_state.focus()
+    left = panel_left(run_state)
+    width, height = window_size(run_state)
+
+    # A project first: Export compiles the *saved* project, so it needs a path.
+    # Save As creates it and reloads into it (the one unavoidable wait).
+    run_state.click(*panel_point(left, TOOLBAR["save_as"]), delay=0.6)
+    run_state.click(*dialog_point(run_state, DIALOG["file_name"]), delay=0.15)
+    run_state.type_text("ExportMap")
+    run_state.key("Return", delay=0.15)
+    # The one unavoidable wait: Save As restarts the engine into the new project.
+    run_state.click(*dialog_point(run_state, DIALOG["file_ok_name"]), delay=8.0)
+
+    # Terrain: pick a pattern, arm Add, a fat brush, one sweep across the map.
+    run_state.click(left + TAB_X["map"], TAB_Y, delay=0.15)
+    run_state.click(*editor_point(left, "map", "terrain"), delay=0.3)
+    run_state.click(*panel_point(left, MAP["terrain_pattern"]), delay=0.15)
+    run_state.click(*panel_point(left, MAP_ACTIONS["terrain_add"]), delay=0.15)
+    click_field(run_state, left, MAP["terrain_size"], "1200")
+    click_field(run_state, left, MAP["terrain_height"], "80")
+    _sweep(run_state, left, width, height)
+    run_state.assert_command_at_least("TerrainShapeModifyCommand", 1)
+
+    # Texture: choose a material, pick a brush shape, paint across the map.
+    run_state.click(*editor_point(left, "map", "texture"), delay=0.3)
+    run_state.click(*panel_point(left, MAP["saved_brush_add"]), delay=0.4)
+    run_state.click(*dialog_point(run_state, DIALOG["asset_core_cell"]), delay=0.3)
+    run_state.click(*panel_point(left, MAP["saved_brush_rect"]), delay=0.15)
+    run_state.click(*panel_point(left, MAP_ACTIONS["texture_paint"]), delay=0.15)
+    _sweep(run_state, left, width, height)
+    run_state.assert_any_command("TerrainChangeTextureCommand", paintMode="paint")
+
+    # Save the edits, then Export -> Spring archive (the default type).
+    run_state.key("ctrl+s", delay=0.5)
+    run_state.assert_command_at_least("SaveCommand", 1)
+    run_state.click(*panel_point(left, TOOLBAR["export"]), delay=0.3)
+    run_state.click(*dialog_point(run_state, DIALOG["file_name"]), delay=0.15)
+    run_state.type_text("ExportMap")
+    run_state.key("Return", delay=0.15)
+    run_state.click(*dialog_point(run_state, DIALOG["file_ok_export"]), delay=0.3)
+    run_state.assert_command("ExportSpringArchiveCommand")
+
+    archive = _wait_for_archive(run_state, "ExportMap")
+    if archive is None:
+        raise AssertionError("export did not produce a .sdz archive")
+    if archive.stat().st_size < 1024:
+        raise AssertionError(f"compiled archive is suspiciously small: {archive}")

tools/smoke/run_sbc.py

@@ -61,7 +61,11 @@ def launch_manual(config: Path | None = None) -> int:
     The interactive twin of `boot()` — no timeout, no test spec. This is the whole
     body of the old tools/dev/launch.sh; that script now just calls it.
     """
-    write_dir, env, cmd = prepare(prefix="sbc-manual-", port_flags_config=config)
+    write_dir, env, cmd = prepare(
+        prefix="sbc-manual-",
+        port_flags_config=config,
+        write_dir=_manual_write_dir(),
+    )
     # Manual sessions intentionally use a fresh isolated engine write-dir, but
     # command history is user state rather than run output. Keep it outside the
     # temporary directory so restarting `just run` restores it. Honour an
@@ -113,6 +117,7 @@ def prepare(
     tags: list[str] | None = None,
     prefix: str = "sbc-",
     port_flags_config: Path | None = None,
+    write_dir: Path | None = None,
 ) -> tuple[Path, dict[str, str], list[str]]:
     """Set up an isolated write dir and return (write_dir, env, spring command).
 
@@ -137,9 +142,18 @@ def prepare(
             f"run `just build` (cargo build --release) in {sbc_root} first"
         )
 
-    write_dir = Path(tempfile.mkdtemp(prefix=prefix))
-    (write_dir / "games").mkdir()
+    # A persistent write dir (interactive `just run`) keeps projects, imports and
+    # exports across restarts; tests pass none and get a throwaway temp dir. Only
+    # the game copy is refreshed each run -- everything the editor writes under
+    # springboard/ is left untouched.
+    if write_dir is None:
+        write_dir = Path(tempfile.mkdtemp(prefix=prefix))
+    else:
+        write_dir.mkdir(parents=True, exist_ok=True)
+    (write_dir / "games").mkdir(exist_ok=True)
     game_dir = write_dir / "games" / "SpringBoard Core.sdd"
+    if game_dir.exists():
+        shutil.rmtree(game_dir)
     shutil.copytree(
         sbc_root,
         game_dir,
@@ -166,7 +180,9 @@ def prepare(
         Path(os.environ.get("XDG_CACHE_HOME", Path.home() / ".cache")) / "sbc-fontcache"
     )
     fontcache.mkdir(parents=True, exist_ok=True)
-    (write_dir / "fontcache").symlink_to(fontcache)
+    fontcache_link = write_dir / "fontcache"
+    fontcache_link.unlink(missing_ok=True)
+    fontcache_link.symlink_to(fontcache)
 
     # Shared dev config (tools/dev/). Its script.txt sets up two teams in two
     # ally-teams so team/alliance tests have something to act on (set_ally,
@@ -210,6 +226,17 @@ def _manual_history_path() -> Path:
     return state_home / "springboard" / "chonsole-history"
 
 
+def _manual_write_dir() -> Path:
+    """Durable write dir for interactive `just run`, so projects and imports/
+    exports survive a restart. `SBC_WRITE_DIR` overrides it; tests never set it
+    and keep their throwaway temp dirs."""
+    override = os.environ.get("SBC_WRITE_DIR")
+    if override:
+        return Path(override).expanduser()
+    data_home = Path(os.environ.get("XDG_DATA_HOME", Path.home() / ".local" / "share"))
+    return data_home / "springboard" / "write-dir"
+
+
 def _read_port_flags_config(path: Path) -> tuple[dict[str, str], dict[str, str]]:
     if not path.is_file():
         raise RuntimeError(f"run config does not exist: {path}")