@@ -5,10 +5,13 @@
 from OTAnalytics.application.logger import logger
 from OTAnalytics.application.parser.track_parser import TrackParser, TracksParseResult
 from OTAnalytics.application.state import TracksMetadata, VideosMetadata
-from OTAnalytics.domain.progress import ProgressbarBuilder
+from OTAnalytics.domain.progress import ProgressbarBuilder, RunningProgressbar
 from OTAnalytics.domain.track_repository import TrackFileRepository, TrackRepository
 from OTAnalytics.domain.video import VideoRepository
 
+PARSING_DESCRIPTION = "Parsing track files"
+PARSING_UNIT = "files"
+
 
 class LoadTrackFiles:
     def __init__(
@@ -51,7 +54,11 @@ def __call__(self, files: list[Path]) -> None:
                 " Use load() instead."
             )
         if files_to_load := self._files_to_load(files):
-            self._publish(self._parse(files_to_load), files_to_load)
+            progressbar = self._start_progress(files_to_load)
+            try:
+                self._publish(self._parse(files_to_load), files_to_load)
+            finally:
+                progressbar.close()
 
     async def load(self, files: list[Path]) -> None:
         """Load and parse track files together with their videos.
@@ -63,11 +70,32 @@ async def load(self, files: list[Path]) -> None:
             files (list[Path]): files in ottrk format.
         """
         if files_to_load := self._files_to_load(files):
-            # parse_files must stay pure: no repository, no observer, no ui. It runs
-            # on a worker thread here, and repositories notify observers that mutate
-            # widgets, which is only safe on the event loop.
-            parse_result = await asyncio.to_thread(self._parse, files_to_load)
-            self._publish(parse_result, files_to_load)
+            progressbar = self._start_progress(files_to_load)
+            try:
+                # parse_files must stay pure: no repository, no observer, no ui. It
+                # runs on a worker thread here, and repositories notify observers
+                # that mutate widgets, which is only safe on the event loop.
+                parse_result = await asyncio.to_thread(self._parse, files_to_load)
+                self._publish(parse_result, files_to_load)
+            finally:
+                progressbar.close()
+
+    def _start_progress(self, files_to_load: list[Path]) -> RunningProgressbar:
+        """Show that track files are being parsed until the caller closes it again.
+
+        The parser reports nothing until it is done with all of the files, so this
+        counts no progress. It says what is keeping the application busy, and it
+        goes away once the files are loaded.
+
+        Args:
+            files_to_load (list[Path]): the files about to be parsed.
+
+        Returns:
+            RunningProgressbar: the progressbar to close once the files are loaded.
+        """
+        return self._progressbar.start(
+            PARSING_DESCRIPTION, PARSING_UNIT, len(files_to_load)
+        )
 
     @staticmethod
     def _event_loop_is_running() -> bool:
 
@@ -41,6 +41,27 @@ def __iter__(self) -> Iterator:
         raise NotImplementedError
 
 
+class RunningProgressbar(ABC):
+    """A progressbar shown for as long as the caller keeps it open.
+
+    Work handed to a worker thread cannot be tracked by iterating a sequence,
+    because only the thread doing the work would advance it. Such a caller opens
+    a progressbar, does the work, and closes it again.
+    """
+
+    @abstractmethod
+    def close(self) -> None:
+        """Stop showing the progress."""
+        raise NotImplementedError
+
+
+class NoRunningProgressbar(RunningProgressbar):
+    """A progressbar showing nothing, for builders that only decorate sequences."""
+
+    def close(self) -> None:
+        pass
+
+
 class ProgressbarBuilder(ABC):
     """Interface defining a Progressbar builder.
 
@@ -62,6 +83,22 @@ def __call__(self, sequence: Sequence, description: str, unit: str) -> Iterable:
         """
         raise NotImplementedError
 
+    def start(self, description: str, unit: str, total: int) -> RunningProgressbar:
+        """Show progress of work that is not driven by iterating a sequence.
+
+        Builders that can only decorate a sequence show nothing, which is what a
+        command line run wants: its output is already a log.
+
+        Args:
+            description (str): what the operation being tracked is doing.
+            unit (str): the unit of the counted items.
+            total (int): the number of items expected to complete.
+
+        Returns:
+            RunningProgressbar: the progressbar to close once the work is done.
+        """
+        return NoRunningProgressbar()
+
 
 class NoProgressbarBuilder(ProgressbarBuilder):
     def __call__(self, sequence: Sequence, description: str, unit: str) -> Iterable:
 
@@ -12,15 +12,15 @@
     GeneralKeys,
     ResourceManager,
 )
-from OTAnalytics.domain.progress import Counter, ProgressbarBuilder
+from OTAnalytics.domain.progress import Counter, ProgressbarBuilder, RunningProgressbar
 from OTAnalytics.plugin_ui.nicegui_gui.test_constants import TEST_ID
 
 MARKER_PROGRESSBAR_CANCEL = "progressbar-cancel"
 MARKER_MESSAGE = "progressbar-message"
 MARKER_CURRENT_ITEM = "progressbar-current-item"
 
 
-class NiceguiProgressbar:
+class NiceguiProgressbar(RunningProgressbar):
     """A determinate progressbar rendered in the browser.
 
     Shows how many of the expected items are done, which item was completed last,
@@ -154,6 +154,19 @@ def progressbar(self) -> NiceguiProgressbar:
             raise ValueError("No progressbar has been built yet")
         return self._progressbar
 
+    def start(self, description: str, unit: str, total: int) -> NiceguiProgressbar:
+        """Show a progressbar until the caller closes it again.
+
+        Args:
+            description (str): what the operation being tracked is doing.
+            unit (str): the unit of the counted items.
+            total (int): the number of items expected to complete.
+
+        Returns:
+            NiceguiProgressbar: the opened progressbar.
+        """
+        return self.build(description, unit, total)
+
     def build(self, description: str, unit: str, total: int) -> NiceguiProgressbar:
         """Build and show a progressbar advanced by reporting completions.
 
 
@@ -22,6 +22,12 @@
 PLAYWRIGHT_QUICK_VISIBLE_TIMEOUT_MS = 1000
 # Short one-off UI settle wait (milliseconds)
 PLAYWRIGHT_SHORT_WAIT_MS = 150
+# Parsing track files runs off the event loop and may take a while on a cold
+# feather cache, so waiting it out needs far more headroom than the other ui waits
+TRACK_LOADING_TIMEOUT_MS = 120_000
+# Exports take seconds rather than milliseconds, and more of them on a busy
+# machine, so give them room instead of guessing a sleep
+EXPORT_TIMEOUT_MS = 120_000
 # Polling intervals (milliseconds)
 PLAYWRIGHT_POLL_INTERVAL_MS = 50
 PLAYWRIGHT_POLL_INTERVAL_SLOW_MS = 100
 
@@ -12,7 +12,11 @@
     TrackParser,
     TracksParseResult,
 )
-from OTAnalytics.application.use_cases.load_track_files import LoadTrackFiles
+from OTAnalytics.application.use_cases.load_track_files import (
+    PARSING_DESCRIPTION,
+    PARSING_UNIT,
+    LoadTrackFiles,
+)
 from OTAnalytics.domain.georeference import GeoreferenceMetadata
 from OTAnalytics.domain.track import TrackId
 from OTAnalytics.domain.track_dataset.track_dataset import (
@@ -416,6 +420,119 @@ def record_publishes_so_far(files: list[Path]) -> Any:
         given.track_repository.add_all.assert_called_once()
 
 
+class TestLoadTrackFilesShowsProgress:
+    """#Requirement https://openproject.platomo.de/wp/10282"""
+
+    def test_blocking_call_shows_a_progressbar_until_the_files_are_loaded(
+        self,
+    ) -> None:
+        given = setup(
+            track_ids=[TrackId("1"), TrackId("2")],
+            video_files=[Path("video1.mp4"), Path("video2.mp4")],
+            track_files=[some_file, other_file],
+            existing_track_files=[],
+            classes={"class1"},
+        )
+        target = create_target(given)
+
+        target([some_file, other_file])
+
+        given.progressbar.start.assert_called_once_with(
+            PARSING_DESCRIPTION, PARSING_UNIT, 2
+        )
+        given.progressbar.start.return_value.close.assert_called_once_with()
+
+    async def test_shows_a_progressbar_until_the_files_are_loaded(self) -> None:
+        """Parsing off the event loop leaves the ui free to show what it is doing."""
+        given = setup(
+            track_ids=[TrackId("1")],
+            video_files=[Path("video1.mp4")],
+            track_files=[some_file],
+            existing_track_files=[],
+            classes={"class1"},
+        )
+        target = create_target(given)
+
+        await target.load([some_file])
+
+        given.progressbar.start.assert_called_once_with(
+            PARSING_DESCRIPTION, PARSING_UNIT, 1
+        )
+        given.progressbar.start.return_value.close.assert_called_once_with()
+
+    async def test_counts_only_the_files_it_is_going_to_parse(self) -> None:
+        given = setup(
+            track_ids=[TrackId("1")],
+            video_files=[Path("video1.mp4")],
+            track_files=[other_file],
+            existing_track_files=[some_file],
+            classes={"class1"},
+        )
+        target = create_target(given)
+
+        await target.load([some_file, other_file])
+
+        given.progressbar.start.assert_called_once_with(
+            PARSING_DESCRIPTION, PARSING_UNIT, 1
+        )
+
+    async def test_opens_the_progressbar_before_parsing_and_closes_it_after(
+        self,
+    ) -> None:
+        given = setup(
+            track_ids=[TrackId("1")],
+            video_files=[Path("video1.mp4")],
+            track_files=[some_file],
+            existing_track_files=[],
+            classes={"class1"},
+        )
+        target = create_target(given)
+
+        await target.load([some_file])
+
+        assert call_names(given) == [
+            "progressbar.start",
+            "track_parser.parse_files",
+            "videos_metadata.update",
+            "video_parser.parse",
+            "video_repository.add_all",
+            "track_repository.add_all",
+            "tracks_metadata.update_detection_classes",
+            "progressbar.start().close",
+        ]
+
+    async def test_closes_the_progressbar_when_parsing_fails(self) -> None:
+        """A progressbar left open would hide the ui behind it for good."""
+        given = setup(
+            track_ids=[TrackId("1")],
+            video_files=[Path("video1.mp4")],
+            track_files=[some_file],
+            existing_track_files=[],
+            classes={"class1"},
+        )
+        given.track_parser.parse_files.side_effect = ValueError("broken track file")
+        target = create_target(given)
+
+        with pytest.raises(ValueError):
+            await target.load([some_file])
+
+        given.progressbar.start.return_value.close.assert_called_once_with()
+
+    async def test_shows_nothing_when_every_file_is_loaded_already(self) -> None:
+        given = setup(
+            track_ids=[],
+            video_files=[],
+            track_files=[],
+            existing_track_files=[some_file],
+            classes=set(),
+        )
+        target = create_target(given)
+
+        await target.load([some_file])
+
+        given.progressbar.start.assert_not_called()
+
+
 def call_names(given: "Given") -> list[str]:
     """The collaborator methods called, in call order."""
     return [name for name, _, _ in given.order.mock_calls]
@@ -451,6 +568,7 @@ def __post_init__(self) -> None:
         self.order.track_repository = self.track_repository
         self.order.video_parser = self.video_parser
         self.order.tracks_metadata = self.tracks_metadata
+        self.order.progressbar = self.progressbar
 
 
 def setup(
 
@@ -180,6 +180,31 @@ def page() -> None:
         assert progressbars[1].is_open is True
 
 
+class TestProgressbarForWorkOffTheEventLoop:
+    """#Requirement https://openproject.platomo.de/wp/10282"""
+
+    @pytest.mark.asyncio
+    async def test_stays_open_until_the_caller_closes_it(
+        self, user: User, resource_manager: ResourceManager
+    ) -> None:
+        """Parsing on a worker thread reports nothing until it is done."""
+        given = create_given(resource_manager)
+        target = create_builder(given)
+        progressbars = []
+
+        @ui.page("/test")
+        def page() -> None:
+            progressbars.append(target.start("Parsing track files", "files", 2))
+
+        await user.open("/test")
+        await user.should_see("Parsing track files 0 / 2 files")
+        assert progressbars[0].is_open is True
+
+        progressbars[0].close()
+
+        assert progressbars[0].is_open is False
+
+
 class TestProgressbarWithoutABrowser:
 
     @pytest.mark.asyncio