From 7bbbb6e70ed2e9a2450f127f238e8c1c1f75fbfc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Thomas=20M=C3=BCller?=
 <1005065+DeepDiver1975@users.noreply.github.com>
Date: Mon, 31 Aug 2026 10:36:29 +0200
Subject: [PATCH 1/4] feat(wasserfoerderung): downloadable region packs for
 Einsatzgebiet (#150)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Stammdaten's Einsatzgebiet config was a raw folder-path text field with no
way to actually get map data onto a machine. Replace it with a dropdown
fed by a published region-pack catalog (regions.json + GitHub Releases,
one pack per Landkreis): pick a region, hit "Herunterladen", the app
fetches and extracts region.mbtiles/region.dem via IRegionPackCatalogService
and IRegionPackInstaller. Manual folder entry stays available under an
"Erweitert" fallback for a self-built or hand-placed pack.

The pack-building side (osmium extract, raster tile rendering, SRTM
elevation conversion) stays a documented external runbook under
tools/build-region-pack/, deliberately kept out of LageBuch.sln — it's a
one-time-per-region maintainer task, not something every installation
needs to run itself.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UwN31QccH98YV9eEc2bue2
Signed-off-by: Thomas Müller <1005065+DeepDiver1975@users.noreply.github.com>
---
 src/LageBuch.App.Android/MainActivity.cs      |   1 +
 .../Services/AndroidAppPaths.cs               |   3 +
 src/LageBuch.App.Shared/CompositionRoot.cs    |  13 +-
 .../Views/MasterDataEditorView.axaml          |  66 +++++--
 src/LageBuch.App/AppPaths.cs                  |   3 +
 src/LageBuch.App/Program.cs                   |   1 +
 .../Services/IRegionPackCatalogService.cs     |  28 +++
 .../Services/IRegionPackInstaller.cs          |   8 +
 .../Services/RegionPackCatalogJson.cs         |  79 ++++++++
 .../Services/RegionPackCatalogService.cs      |  23 +++
 .../Services/RegionPackInstaller.cs           |  56 ++++++
 .../ViewModels/EinsatzgebietSection.cs        |  91 +++++++++-
 .../ViewModels/MasterDataEditorViewModel.cs   |  12 +-
 .../AboutRenderTests.cs                       |  14 +-
 .../MasterDataEditorRenderTests.cs            |  67 ++++++-
 .../EinsatzgebietSectionTests.cs              | 169 ++++++++++++++++++
 .../MainWindowViewModelTests.cs               |   6 +-
 .../MasterDataEditorViewModelTests.cs         |  17 +-
 .../RegionPackCatalogJsonTests.cs             |  73 ++++++++
 .../RegionPackCatalogServiceTests.cs          |  73 ++++++++
 .../RegionPackInstallerTests.cs               | 109 +++++++++++
 tools/build-region-pack/README.md             | 157 ++++++++++++++++
 22 files changed, 1042 insertions(+), 27 deletions(-)
 create mode 100644 src/LageBuch.AppLogic/Services/IRegionPackCatalogService.cs
 create mode 100644 src/LageBuch.AppLogic/Services/IRegionPackInstaller.cs
 create mode 100644 src/LageBuch.AppLogic/Services/RegionPackCatalogJson.cs
 create mode 100644 src/LageBuch.AppLogic/Services/RegionPackCatalogService.cs
 create mode 100644 src/LageBuch.AppLogic/Services/RegionPackInstaller.cs
 create mode 100644 tests/LageBuch.AppLogic.Tests/EinsatzgebietSectionTests.cs
 create mode 100644 tests/LageBuch.AppLogic.Tests/RegionPackCatalogJsonTests.cs
 create mode 100644 tests/LageBuch.AppLogic.Tests/RegionPackCatalogServiceTests.cs
 create mode 100644 tests/LageBuch.AppLogic.Tests/RegionPackInstallerTests.cs
 create mode 100644 tools/build-region-pack/README.md

diff --git a/src/LageBuch.App.Android/MainActivity.cs b/src/LageBuch.App.Android/MainActivity.cs
index 21d06b6..0aee49d 100644
--- a/src/LageBuch.App.Android/MainActivity.cs
+++ b/src/LageBuch.App.Android/MainActivity.cs
@@ -65,6 +65,7 @@ protected override AppBuilder CustomizeAppBuilder(AppBuilder builder)
             new NoopIncidentHostController(),
             new LageBuch.App.Shared.Services.AvaloniaUiDispatcher(),
             typeof(MainActivity).Assembly.GetName().Version?.ToString() ?? "0.0.0",
+            AndroidAppPaths.RegionsDir(this),
             lastSaveFolder: null,
             attachmentCacheRoot: AndroidAppPaths.AttachmentCacheDir(this));
         return base.CustomizeAppBuilder(builder).WithInterFont();
diff --git a/src/LageBuch.App.Android/Services/AndroidAppPaths.cs b/src/LageBuch.App.Android/Services/AndroidAppPaths.cs
index 62deec0..d053fb9 100644
--- a/src/LageBuch.App.Android/Services/AndroidAppPaths.cs
+++ b/src/LageBuch.App.Android/Services/AndroidAppPaths.cs
@@ -27,4 +27,7 @@ public static string RecentFilesJsonPath(Context context) =>
 
     public static string AttachmentCacheDir(Context context) =>
         System.IO.Path.Combine(CacheDir(context), "attachment-cache");
+
+    public static string RegionsDir(Context context) =>
+        System.IO.Path.Combine(context.FilesDir!.AbsolutePath, "regions");
 }
diff --git a/src/LageBuch.App.Shared/CompositionRoot.cs b/src/LageBuch.App.Shared/CompositionRoot.cs
index 9d7bd52..d8a09e9 100644
--- a/src/LageBuch.App.Shared/CompositionRoot.cs
+++ b/src/LageBuch.App.Shared/CompositionRoot.cs
@@ -14,6 +14,13 @@ namespace LageBuch.App.Shared;
 /// </summary>
 public static class CompositionRoot
 {
+    /// <summary>
+    /// Raw-served manifest of published Wasserförderung region packs (#150 follow-up) — see
+    /// tools/build-region-pack/README.md for how a pack is built and published here.
+    /// </summary>
+    public const string RegionPackManifestUrl =
+        "https://raw.githubusercontent.com/CodeForFire/lagebuch-regions/main/regions.json";
+
     public static MainWindowViewModel CreateMainWindowViewModel(
         IIncidentStore store,
         IMasterDataProvider masterData,
@@ -26,11 +33,15 @@ public static MainWindowViewModel CreateMainWindowViewModel(
         IIncidentHostController hostController,
         IUiDispatcher uiDispatcher,
         string appVersion,
+        string regionsDir,
         ILastSaveFolderStore? lastSaveFolder = null,
         string? attachmentCacheRoot = null)
     {
         var home = new HomeViewModel(store, masterData, recent, dialogs, clock, ticker, alarm, hostController, appVersion, uiDispatcher, lastSaveFolder, attachmentCacheRoot, new RouteOverviewRenderer());
-        var editor = new MasterDataEditorViewModel(masterData, dialogs, masterDataFileService);
+        var httpClient = new HttpClient();
+        var regionCatalog = new RegionPackCatalogService(httpClient, RegionPackManifestUrl);
+        var regionInstaller = new RegionPackInstaller(httpClient, regionsDir);
+        var editor = new MasterDataEditorViewModel(masterData, dialogs, masterDataFileService, regionCatalog, regionInstaller);
         return new MainWindowViewModel(home, editor, dialogs, appVersion);
     }
 }
diff --git a/src/LageBuch.App.Shared/Views/MasterDataEditorView.axaml b/src/LageBuch.App.Shared/Views/MasterDataEditorView.axaml
index 2561551..8bdea8f 100644
--- a/src/LageBuch.App.Shared/Views/MasterDataEditorView.axaml
+++ b/src/LageBuch.App.Shared/Views/MasterDataEditorView.axaml
@@ -2,6 +2,7 @@
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
              xmlns:vm="clr-namespace:LageBuch.AppLogic.ViewModels;assembly=LageBuch.AppLogic"
              xmlns:md="clr-namespace:LageBuch.Persistence.MasterData;assembly=LageBuch.Persistence"
+             xmlns:services="clr-namespace:LageBuch.AppLogic.Services;assembly=LageBuch.AppLogic"
              x:Class="LageBuch.App.Shared.Views.MasterDataEditorView"
              x:DataType="vm:MasterDataEditorViewModel">
   <Panel>
@@ -108,18 +109,63 @@
                 </ScrollViewer>
               </DataTemplate>
 
-              <!-- Wasserförderung region of operation (#150 phase 2) -->
+              <!-- Wasserförderung region of operation (#150 phase 2 + region-pack follow-up):
+                   pick a published pack from the catalog and download it; manual folder entry
+                   stays available under "Erweitert" for a self-built or hand-placed pack. -->
               <DataTemplate x:DataType="vm:EinsatzgebietSection">
-                <StackPanel Spacing="12" MaxWidth="440" HorizontalAlignment="Left">
-                  <StackPanel Spacing="4">
-                    <TextBlock Text="NAME" Classes="overline" FontSize="10" />
-                    <TextBox Text="{Binding Name}" PlaceholderText="z. B. Landkreis Fürstenfeldbruck" />
-                  </StackPanel>
-                  <StackPanel Spacing="4">
-                    <TextBlock Text="ORDNER (region.mbtiles + region.dem)" Classes="overline" FontSize="10" />
-                    <TextBox Text="{Binding FolderPath}" PlaceholderText="z. B. /var/lib/lagebuch/regions/ffb" />
+                <ScrollViewer>
+                  <StackPanel Spacing="12" MaxWidth="480" HorizontalAlignment="Left">
+                    <StackPanel Spacing="4">
+                      <TextBlock Text="KARTENPAKET" Classes="overline" FontSize="10" />
+                      <Grid ColumnDefinitions="*,Auto" ColumnSpacing="8">
+                        <ComboBox x:Name="RegionComboBox" Grid.Column="0" HorizontalAlignment="Stretch"
+                                  ItemsSource="{Binding AvailableRegions}"
+                                  SelectedItem="{Binding SelectedRegion}"
+                                  PlaceholderText="Region auswählen…">
+                          <ComboBox.ItemTemplate>
+                            <DataTemplate x:DataType="services:RegionPackInfo">
+                              <TextBlock Text="{Binding Name}" />
+                            </DataTemplate>
+                          </ComboBox.ItemTemplate>
+                        </ComboBox>
+                        <Button x:Name="DownloadButton" Grid.Column="1" Content="HERUNTERLADEN"
+                                Command="{Binding DownloadSelectedRegionCommand}" />
+                      </Grid>
+                    </StackPanel>
+
+                    <Border x:Name="CatalogStatusBanner"
+                            IsVisible="{Binding CatalogStatus, Converter={x:Static ObjectConverters.IsNotNull}}"
+                            Background="#241608" BorderBrush="{StaticResource AmberBrush}" BorderThickness="1"
+                            CornerRadius="{StaticResource RadiusSm}" Padding="8,6">
+                      <TextBlock Text="{Binding CatalogStatus}" FontSize="12"
+                                 Foreground="{StaticResource AmberBrush}" TextWrapping="Wrap" />
+                    </Border>
+
+                    <ProgressBar x:Name="DownloadProgressBar" Minimum="0" Maximum="1"
+                                 Value="{Binding DownloadProgress}" Height="4" />
+
+                    <TextBlock x:Name="AttributionText" Text="{Binding SelectedRegion.Attribution}"
+                               IsVisible="{Binding SelectedRegion, Converter={x:Static ObjectConverters.IsNotNull}}"
+                               Classes="secondary" FontSize="11" TextWrapping="Wrap" />
+
+                    <TextBlock x:Name="KartendatenStatusText" Text="{Binding KartendatenStatus}"
+                               IsVisible="{Binding KartendatenStatus, Converter={x:Static ObjectConverters.IsNotNull}}"
+                               FontSize="12" TextWrapping="Wrap" />
+
+                    <Expander Header="Erweitert (manueller Ordnerpfad)">
+                      <StackPanel Spacing="12" Margin="0,12,0,0">
+                        <StackPanel Spacing="4">
+                          <TextBlock Text="NAME" Classes="overline" FontSize="10" />
+                          <TextBox Text="{Binding Name}" PlaceholderText="z. B. Landkreis Fürstenfeldbruck" />
+                        </StackPanel>
+                        <StackPanel Spacing="4">
+                          <TextBlock Text="ORDNER (region.mbtiles + region.dem)" Classes="overline" FontSize="10" />
+                          <TextBox Text="{Binding FolderPath}" PlaceholderText="z. B. /var/lib/lagebuch/regions/ffb" />
+                        </StackPanel>
+                      </StackPanel>
+                    </Expander>
                   </StackPanel>
-                </StackPanel>
+                </ScrollViewer>
               </DataTemplate>
 
               <!-- String-list / checklist editor -->
diff --git a/src/LageBuch.App/AppPaths.cs b/src/LageBuch.App/AppPaths.cs
index 48937db..4d44bd7 100644
--- a/src/LageBuch.App/AppPaths.cs
+++ b/src/LageBuch.App/AppPaths.cs
@@ -13,6 +13,9 @@ public static class AppPaths
 
     public static string AttachmentCacheDir => Path.Combine(AppDataDir, "attachment-cache");
 
+    /// <summary>Where downloaded Wasserförderung region packs (#150 follow-up) get extracted, one subfolder per slug.</summary>
+    public static string RegionsDir => Path.Combine(AppDataDir, "regions");
+
     public static string GetAppDataDir(string baseDir)
     {
         var dir = Path.Combine(baseDir, "Lagebuch");
diff --git a/src/LageBuch.App/Program.cs b/src/LageBuch.App/Program.cs
index f36d325..2fa7e10 100644
--- a/src/LageBuch.App/Program.cs
+++ b/src/LageBuch.App/Program.cs
@@ -37,6 +37,7 @@ private static MainWindowViewModel CreateMainViewModel()
             new IncidentHostController(clock, version, uiDispatcher),
             uiDispatcher,
             version,
+            AppPaths.RegionsDir,
             new JsonLastSaveFolderStore(AppPaths.LastSaveFolderJsonPath),
             AppPaths.AttachmentCacheDir);
     }
diff --git a/src/LageBuch.AppLogic/Services/IRegionPackCatalogService.cs b/src/LageBuch.AppLogic/Services/IRegionPackCatalogService.cs
new file mode 100644
index 0000000..58286bc
--- /dev/null
+++ b/src/LageBuch.AppLogic/Services/IRegionPackCatalogService.cs
@@ -0,0 +1,28 @@
+namespace LageBuch.AppLogic.Services;
+
+/// <summary>
+/// Lists the region packs (map tiles + elevation) publicly available for download (#150 follow-up)
+/// — the map-side counterpart to Stammdaten's Einsatzgebiet, which used to require hand-preparing
+/// region.mbtiles/region.dem with no guidance at all.
+/// </summary>
+public interface IRegionPackCatalogService
+{
+    /// <summary>
+    /// Never throws — a Stammdaten editor must stay usable offline, so a fetch/parse failure
+    /// yields an empty list rather than propagating an exception.
+    /// </summary>
+    Task<IReadOnlyList<RegionPackInfo>> GetAvailableRegionsAsync(CancellationToken ct = default);
+}
+
+/// <summary>One published, downloadable region pack.</summary>
+public sealed record RegionPackInfo(
+    string Name,
+    string Slug,
+    string DownloadUrl,
+    long SizeBytes,
+    double MinLat,
+    double MinLon,
+    double MaxLat,
+    double MaxLon,
+    string BuiltAt,
+    string Attribution);
diff --git a/src/LageBuch.AppLogic/Services/IRegionPackInstaller.cs b/src/LageBuch.AppLogic/Services/IRegionPackInstaller.cs
new file mode 100644
index 0000000..1b3e45a
--- /dev/null
+++ b/src/LageBuch.AppLogic/Services/IRegionPackInstaller.cs
@@ -0,0 +1,8 @@
+namespace LageBuch.AppLogic.Services;
+
+/// <summary>Downloads and unpacks a region pack (#150 follow-up) into a local folder.</summary>
+public interface IRegionPackInstaller
+{
+    /// <summary>Returns the folder the pack was extracted into (ready to use as Einsatzgebiet.FolderPath).</summary>
+    Task<string> DownloadAndInstallAsync(RegionPackInfo pack, IProgress<double>? progress, CancellationToken ct = default);
+}
diff --git a/src/LageBuch.AppLogic/Services/RegionPackCatalogJson.cs b/src/LageBuch.AppLogic/Services/RegionPackCatalogJson.cs
new file mode 100644
index 0000000..d191efd
--- /dev/null
+++ b/src/LageBuch.AppLogic/Services/RegionPackCatalogJson.cs
@@ -0,0 +1,79 @@
+using System.Text.Json;
+
+namespace LageBuch.AppLogic.Services;
+
+/// <summary>
+/// Reads the region-pack manifest format (#150 follow-up) — a flat JSON array, each entry
+/// describing one downloadable pack. Defensive like <c>MasterDataJson</c>: malformed input, or an
+/// entry missing a required field, is skipped rather than thrown — the manifest is fetched from a
+/// third-party-controlled URL, so a partially bad response must degrade gracefully, not crash
+/// Stammdaten.
+/// </summary>
+public static class RegionPackCatalogJson
+{
+    public static IReadOnlyList<RegionPackInfo> Parse(string json)
+    {
+        try
+        {
+            using var doc = JsonDocument.Parse(json);
+            if (doc.RootElement.ValueKind != JsonValueKind.Array)
+                return Array.Empty<RegionPackInfo>();
+
+            var result = new List<RegionPackInfo>();
+            foreach (var entry in doc.RootElement.EnumerateArray())
+            {
+                if (TryParseEntry(entry, out var region))
+                    result.Add(region);
+            }
+            return result;
+        }
+        catch (JsonException)
+        {
+            return Array.Empty<RegionPackInfo>();
+        }
+    }
+
+    private static bool TryParseEntry(JsonElement entry, out RegionPackInfo region)
+    {
+        region = null!;
+        if (entry.ValueKind != JsonValueKind.Object)
+            return false;
+
+        if (!TryGetString(entry, "name", out var name) ||
+            !TryGetString(entry, "slug", out var slug) ||
+            !TryGetString(entry, "downloadUrl", out var downloadUrl) ||
+            !TryGetString(entry, "builtAt", out var builtAt) ||
+            !TryGetString(entry, "attribution", out var attribution) ||
+            !entry.TryGetProperty("sizeBytes", out var sizeBytesEl) || sizeBytesEl.ValueKind != JsonValueKind.Number ||
+            !entry.TryGetProperty("boundingBox", out var bbox) || bbox.ValueKind != JsonValueKind.Object ||
+            !TryGetNumber(bbox, "minLat", out var minLat) ||
+            !TryGetNumber(bbox, "minLon", out var minLon) ||
+            !TryGetNumber(bbox, "maxLat", out var maxLat) ||
+            !TryGetNumber(bbox, "maxLon", out var maxLon))
+        {
+            return false;
+        }
+
+        region = new RegionPackInfo(name, slug, downloadUrl, sizeBytesEl.GetInt64(),
+            minLat, minLon, maxLat, maxLon, builtAt, attribution);
+        return true;
+    }
+
+    private static bool TryGetString(JsonElement e, string prop, out string value)
+    {
+        value = string.Empty;
+        if (!e.TryGetProperty(prop, out var v) || v.ValueKind != JsonValueKind.String)
+            return false;
+        value = v.GetString()!;
+        return true;
+    }
+
+    private static bool TryGetNumber(JsonElement e, string prop, out double value)
+    {
+        value = 0;
+        if (!e.TryGetProperty(prop, out var v) || v.ValueKind != JsonValueKind.Number)
+            return false;
+        value = v.GetDouble();
+        return true;
+    }
+}
diff --git a/src/LageBuch.AppLogic/Services/RegionPackCatalogService.cs b/src/LageBuch.AppLogic/Services/RegionPackCatalogService.cs
new file mode 100644
index 0000000..dd6e0bb
--- /dev/null
+++ b/src/LageBuch.AppLogic/Services/RegionPackCatalogService.cs
@@ -0,0 +1,23 @@
+namespace LageBuch.AppLogic.Services;
+
+/// <summary>
+/// Fetches the region-pack manifest over HTTP (#150 follow-up). The one place this offline-first
+/// app makes an unprompted network call — but only when the operator opens the Einsatzgebiet
+/// section, and it degrades to an empty list rather than surfacing any error, so Stammdaten stays
+/// fully usable without a connection.
+/// </summary>
+public sealed class RegionPackCatalogService(HttpClient httpClient, string manifestUrl) : IRegionPackCatalogService
+{
+    public async Task<IReadOnlyList<RegionPackInfo>> GetAvailableRegionsAsync(CancellationToken ct = default)
+    {
+        try
+        {
+            var json = await httpClient.GetStringAsync(manifestUrl, ct);
+            return RegionPackCatalogJson.Parse(json);
+        }
+        catch (HttpRequestException)
+        {
+            return Array.Empty<RegionPackInfo>();
+        }
+    }
+}
diff --git a/src/LageBuch.AppLogic/Services/RegionPackInstaller.cs b/src/LageBuch.AppLogic/Services/RegionPackInstaller.cs
new file mode 100644
index 0000000..236a350
--- /dev/null
+++ b/src/LageBuch.AppLogic/Services/RegionPackInstaller.cs
@@ -0,0 +1,56 @@
+using System.IO.Compression;
+
+namespace LageBuch.AppLogic.Services;
+
+/// <summary>
+/// Downloads a region pack's zip (region.mbtiles + region.dem) and extracts it into
+/// <c>&lt;regionsBaseDir&gt;/&lt;slug&gt;</c> (#150 follow-up). A re-install of the same slug replaces the
+/// folder outright, so a pack update never leaves stale files from a previous version behind.
+/// </summary>
+public sealed class RegionPackInstaller(HttpClient httpClient, string regionsBaseDir) : IRegionPackInstaller
+{
+    // Downloading is the slow part; reserve a small tail of the progress range for extraction so
+    // the caller sees forward motion continue past "download done" instead of jumping straight to 1.0.
+    private const double DownloadProgressShare = 0.9;
+
+    public async Task<string> DownloadAndInstallAsync(RegionPackInfo pack, IProgress<double>? progress, CancellationToken ct = default)
+    {
+        progress?.Report(0.0);
+
+        var zipBytes = await DownloadAsync(pack.DownloadUrl, progress, ct);
+
+        var folder = Path.Combine(regionsBaseDir, pack.Slug);
+        if (Directory.Exists(folder))
+            Directory.Delete(folder, recursive: true);
+        Directory.CreateDirectory(folder);
+
+        using (var zip = new ZipArchive(new MemoryStream(zipBytes), ZipArchiveMode.Read))
+            zip.ExtractToDirectory(folder);
+
+        progress?.Report(1.0);
+        return folder;
+    }
+
+    private async Task<byte[]> DownloadAsync(string url, IProgress<double>? progress, CancellationToken ct)
+    {
+        using var response = await httpClient.GetAsync(url, HttpCompletionOption.ResponseHeadersRead, ct);
+        response.EnsureSuccessStatusCode();
+
+        var totalBytes = response.Content.Headers.ContentLength;
+        await using var source = await response.Content.ReadAsStreamAsync(ct);
+        using var buffer = new MemoryStream();
+
+        var chunk = new byte[81920];
+        long readSoFar = 0;
+        int read;
+        while ((read = await source.ReadAsync(chunk, ct)) > 0)
+        {
+            await buffer.WriteAsync(chunk.AsMemory(0, read), ct);
+            readSoFar += read;
+            if (totalBytes is > 0)
+                progress?.Report(Math.Min(DownloadProgressShare, (double)readSoFar / totalBytes.Value * DownloadProgressShare));
+        }
+
+        return buffer.ToArray();
+    }
+}
diff --git a/src/LageBuch.AppLogic/ViewModels/EinsatzgebietSection.cs b/src/LageBuch.AppLogic/ViewModels/EinsatzgebietSection.cs
index 72b7e12..ff4f68b 100644
--- a/src/LageBuch.AppLogic/ViewModels/EinsatzgebietSection.cs
+++ b/src/LageBuch.AppLogic/ViewModels/EinsatzgebietSection.cs
@@ -1,21 +1,31 @@
+using System.Collections.ObjectModel;
 using CommunityToolkit.Mvvm.ComponentModel;
+using CommunityToolkit.Mvvm.Input;
+using LageBuch.AppLogic.Services;
 using LageBuch.Persistence.MasterData;
 
 namespace LageBuch.AppLogic.ViewModels;
 
 /// <summary>
-/// Editor for the Wasserförderung region of operation (#150 phase 2): a name and a folder path
-/// expected to hold <c>region.mbtiles</c> and <c>region.dem</c>. Two scalar strings, so this
-/// mirrors <see cref="SettingsSection"/>'s pattern rather than the list sections' — one bindable
-/// property each, reporting through the shared dirty callback.
+/// Editor for the Wasserförderung region of operation (#150 phase 2, region-pack follow-up):
+/// a name and a folder path expected to hold <c>region.mbtiles</c> and <c>region.dem</c>.
+/// Primarily populated by downloading a published pack from <see cref="IRegionPackCatalogService"/>
+/// via <see cref="IRegionPackInstaller"/> — manual <see cref="Name"/>/<see cref="FolderPath"/> entry
+/// stays available as a fallback for a self-built or hand-placed pack.
 /// </summary>
 public sealed partial class EinsatzgebietSection : EditorSection
 {
     private readonly Action _onChanged;
+    private readonly IRegionPackCatalogService _catalog;
+    private readonly IRegionPackInstaller _installer;
 
-    public EinsatzgebietSection(string title, Einsatzgebiet einsatzgebiet, Action onChanged) : base(title)
+    public EinsatzgebietSection(
+        string title, Einsatzgebiet einsatzgebiet, Action onChanged,
+        IRegionPackCatalogService catalog, IRegionPackInstaller installer) : base(title)
     {
         _onChanged = onChanged;
+        _catalog = catalog;
+        _installer = installer;
         _name = einsatzgebiet.Name;
         _folderPath = einsatzgebiet.FolderPath;
     }
@@ -24,10 +34,81 @@ public EinsatzgebietSection(string title, Einsatzgebiet einsatzgebiet, Action on
     private string _name = string.Empty;
 
     [ObservableProperty]
+    [NotifyPropertyChangedFor(nameof(KartendatenGefunden))]
+    [NotifyPropertyChangedFor(nameof(KartendatenStatus))]
     private string _folderPath = string.Empty;
 
     partial void OnNameChanged(string value) => _onChanged();
     partial void OnFolderPathChanged(string value) => _onChanged();
 
     public Einsatzgebiet ToEinsatzgebiet() => new(Name, FolderPath);
+
+    // --- Region-pack catalog / download ---
+
+    public ObservableCollection<RegionPackInfo> AvailableRegions { get; } = new();
+
+    [ObservableProperty]
+    private RegionPackInfo? _selectedRegion;
+
+    [ObservableProperty]
+    private string? _catalogStatus;
+
+    [ObservableProperty]
+    private double _downloadProgress;
+
+    [RelayCommand]
+    private async Task LoadCatalog()
+    {
+        var regions = await _catalog.GetAvailableRegionsAsync();
+        AvailableRegions.Clear();
+        foreach (var region in regions)
+            AvailableRegions.Add(region);
+
+        CatalogStatus = AvailableRegions.Count == 0
+            ? "Keine Regionen verfügbar — bitte Internetverbindung prüfen, oder Ordner manuell angeben."
+            : null;
+    }
+
+    private bool CanDownloadSelectedRegion => SelectedRegion is not null;
+
+    [RelayCommand(CanExecute = nameof(CanDownloadSelectedRegion))]
+    private async Task DownloadSelectedRegion()
+    {
+        var region = SelectedRegion!;
+        DownloadProgress = 0;
+        var progress = new Progress<double>(p => DownloadProgress = p);
+        var folder = await _installer.DownloadAndInstallAsync(region, progress);
+
+        Name = region.Name;
+        FolderPath = folder;
+        _onChanged();
+    }
+
+    partial void OnSelectedRegionChanged(RegionPackInfo? value) => DownloadSelectedRegionCommand.NotifyCanExecuteChanged();
+
+    // --- File-presence validation: is region.mbtiles/region.dem actually at FolderPath? ---
+
+    public bool KartendatenGefunden =>
+        !string.IsNullOrWhiteSpace(FolderPath)
+        && File.Exists(Path.Combine(FolderPath, "region.mbtiles"))
+        && File.Exists(Path.Combine(FolderPath, "region.dem"));
+
+    public string? KartendatenStatus
+    {
+        get
+        {
+            if (string.IsNullOrWhiteSpace(FolderPath))
+                return null;
+
+            var mbtilesFound = File.Exists(Path.Combine(FolderPath, "region.mbtiles"));
+            var demFound = File.Exists(Path.Combine(FolderPath, "region.dem"));
+            if (mbtilesFound && demFound)
+                return "✓ Kartendaten gefunden.";
+
+            var missing = new List<string>();
+            if (!mbtilesFound) missing.Add("region.mbtiles");
+            if (!demFound) missing.Add("region.dem");
+            return $"✗ Fehlt: {string.Join(", ", missing)}.";
+        }
+    }
 }
diff --git a/src/LageBuch.AppLogic/ViewModels/MasterDataEditorViewModel.cs b/src/LageBuch.AppLogic/ViewModels/MasterDataEditorViewModel.cs
index a8d7cb4..a210e7d 100644
--- a/src/LageBuch.AppLogic/ViewModels/MasterDataEditorViewModel.cs
+++ b/src/LageBuch.AppLogic/ViewModels/MasterDataEditorViewModel.cs
@@ -17,6 +17,8 @@ public sealed partial class MasterDataEditorViewModel : ObservableObject
     private readonly IMasterDataProvider _provider;
     private readonly IFileDialogService _dialogs;
     private readonly IMasterDataFileService _files;
+    private readonly IRegionPackCatalogService _regionCatalog;
+    private readonly IRegionPackInstaller _regionInstaller;
     private MasterDataSet _original = MasterDataSet.Empty;
     private bool _originalIsEmpty = true;
 
@@ -30,11 +32,15 @@ public sealed partial class MasterDataEditorViewModel : ObservableObject
     private SettingsSection _settings = null!;
     private EinsatzgebietSection _einsatzgebiet = null!;
 
-    public MasterDataEditorViewModel(IMasterDataProvider provider, IFileDialogService dialogs, IMasterDataFileService files)
+    public MasterDataEditorViewModel(
+        IMasterDataProvider provider, IFileDialogService dialogs, IMasterDataFileService files,
+        IRegionPackCatalogService regionCatalog, IRegionPackInstaller regionInstaller)
     {
         _provider = provider;
         _dialogs = dialogs;
         _files = files;
+        _regionCatalog = regionCatalog;
+        _regionInstaller = regionInstaller;
         Load();
     }
 
@@ -100,7 +106,9 @@ private void PopulateSections(MasterDataSet set)
         Sections.Add(_checklistAbbau = new ChecklistTemplateSection("Checkliste Abbau", set.ChecklistTemplateAbbau, MarkDirty));
         Sections.Add(_personnel = new PersonnelSection("Personal", set.Personnel, MarkDirty));
         Sections.Add(_vehicles = new VehiclesSection("Fahrzeuge", set.Vehicles, set.Brigades, set.RadioCallSigns, OnVehiclesChanged));
-        Sections.Add(_einsatzgebiet = new EinsatzgebietSection("Einsatzgebiet", set.Einsatzgebiet, MarkDirty));
+        Sections.Add(_einsatzgebiet = new EinsatzgebietSection(
+            "Einsatzgebiet", set.Einsatzgebiet, MarkDirty, _regionCatalog, _regionInstaller));
+        _einsatzgebiet.LoadCatalogCommand.Execute(null);
 
         SelectedSection = Sections[Math.Clamp(previousIndex < 0 ? 0 : previousIndex, 0, Sections.Count - 1)];
     }
diff --git a/tests/LageBuch.Acceptance.Tests/AboutRenderTests.cs b/tests/LageBuch.Acceptance.Tests/AboutRenderTests.cs
index dfd56d1..7a9f813 100644
--- a/tests/LageBuch.Acceptance.Tests/AboutRenderTests.cs
+++ b/tests/LageBuch.Acceptance.Tests/AboutRenderTests.cs
@@ -93,7 +93,7 @@ private static MainWindowViewModel BuildMainWindowViewModel()
         var home = new HomeViewModel(new FakeStore(), masterData,
             new EmptyRecent(), dialogs, new FixedClock(), new NoopTicker(), new NoopAlarmService(),
             new NoopIncidentHostController(), "0.1.0");
-        var editor = new MasterDataEditorViewModel(masterData, dialogs, new NoFiles());
+        var editor = new MasterDataEditorViewModel(masterData, dialogs, new NoFiles(), new NoRegionCatalog(), new NoRegionInstaller());
         return new MainWindowViewModel(home, editor, dialogs, "0.1.0");
     }
 
@@ -109,6 +109,18 @@ private sealed class NoFiles : IMasterDataFileService
         public void Write(string path, MasterDataSet set) { }
     }
 
+    private sealed class NoRegionCatalog : IRegionPackCatalogService
+    {
+        public Task<IReadOnlyList<RegionPackInfo>> GetAvailableRegionsAsync(CancellationToken ct = default) =>
+            Task.FromResult<IReadOnlyList<RegionPackInfo>>(Array.Empty<RegionPackInfo>());
+    }
+
+    private sealed class NoRegionInstaller : IRegionPackInstaller
+    {
+        public Task<string> DownloadAndInstallAsync(RegionPackInfo pack, IProgress<double>? progress, CancellationToken ct = default) =>
+            Task.FromResult(string.Empty);
+    }
+
     private sealed class EmptyRecent : IRecentFilesStore
     {
         private readonly List<string> _list = new();
diff --git a/tests/LageBuch.Acceptance.Tests/MasterDataEditorRenderTests.cs b/tests/LageBuch.Acceptance.Tests/MasterDataEditorRenderTests.cs
index d294d42..de9f816 100644
--- a/tests/LageBuch.Acceptance.Tests/MasterDataEditorRenderTests.cs
+++ b/tests/LageBuch.Acceptance.Tests/MasterDataEditorRenderTests.cs
@@ -51,10 +51,22 @@ private sealed class NoFiles : IMasterDataFileService
         public void Write(string path, MasterDataSet set) { }
     }
 
+    private sealed class NoRegionCatalog : IRegionPackCatalogService
+    {
+        public Task<IReadOnlyList<RegionPackInfo>> GetAvailableRegionsAsync(CancellationToken ct = default) =>
+            Task.FromResult<IReadOnlyList<RegionPackInfo>>(Array.Empty<RegionPackInfo>());
+    }
+
+    private sealed class NoRegionInstaller : IRegionPackInstaller
+    {
+        public Task<string> DownloadAndInstallAsync(RegionPackInfo pack, IProgress<double>? progress, CancellationToken ct = default) =>
+            Task.FromResult(string.Empty);
+    }
+
     [AvaloniaFact]
     public void The_editor_renders_with_every_category()
     {
-        var vm = new MasterDataEditorViewModel(new SampleProvider(), new FakeDialogs(), new NoFiles());
+        var vm = new MasterDataEditorViewModel(new SampleProvider(), new FakeDialogs(), new NoFiles(), new NoRegionCatalog(), new NoRegionInstaller());
         var view = new MasterDataEditorView { DataContext = vm };
         var window = new Window { Content = view, Width = 1080, Height = 680 };
         window.Show();
@@ -80,7 +92,7 @@ public void The_editor_renders_with_every_category()
     [AvaloniaFact]
     public void Checkliste_aufbau_section_renders_text_and_mandatory_checkbox_per_row()
     {
-        var vm = new MasterDataEditorViewModel(new SampleProvider(), new FakeDialogs(), new NoFiles());
+        var vm = new MasterDataEditorViewModel(new SampleProvider(), new FakeDialogs(), new NoFiles(), new NoRegionCatalog(), new NoRegionInstaller());
         vm.SelectedSection = vm.Sections.Single(s => s.Title == "Checkliste Aufbau");
         var view = new MasterDataEditorView { DataContext = vm };
         var window = new Window { Content = view, Width = 1080, Height = 680 };
@@ -104,7 +116,7 @@ public void Checkliste_aufbau_section_renders_text_and_mandatory_checkbox_per_ro
     [AvaloniaFact]
     public void Links_section_renders_name_and_url_per_row()
     {
-        var vm = new MasterDataEditorViewModel(new SampleProvider(), new FakeDialogs(), new NoFiles());
+        var vm = new MasterDataEditorViewModel(new SampleProvider(), new FakeDialogs(), new NoFiles(), new NoRegionCatalog(), new NoRegionInstaller());
         vm.SelectedSection = vm.Sections.Single(s => s.Title == "Links");
         var view = new MasterDataEditorView { DataContext = vm };
         var window = new Window { Content = view, Width = 1080, Height = 680 };
@@ -127,7 +139,7 @@ public void Links_section_renders_name_and_url_per_row()
     [AvaloniaFact]
     public void Fahrzeuge_section_renders_wache_callsign_and_seats_per_row()
     {
-        var vm = new MasterDataEditorViewModel(new SampleProvider(), new FakeDialogs(), new NoFiles());
+        var vm = new MasterDataEditorViewModel(new SampleProvider(), new FakeDialogs(), new NoFiles(), new NoRegionCatalog(), new NoRegionInstaller());
         var section = (VehiclesSection)vm.Sections.Single(s => s.Title == "Fahrzeuge");
         section.AddCommand.Execute(null);
         section.Rows[0].Wache = "FFB Wache 1";
@@ -158,4 +170,51 @@ public void Fahrzeuge_section_renders_wache_callsign_and_seats_per_row()
         using var frame = window.CaptureRenderedFrame()!;
         frame.SavePng(Path.Combine(dir, "master-data-editor-fahrzeuge-after.png"));
     }
+
+    private sealed class FakeRegionCatalog(IReadOnlyList<RegionPackInfo> regions) : IRegionPackCatalogService
+    {
+        public Task<IReadOnlyList<RegionPackInfo>> GetAvailableRegionsAsync(CancellationToken ct = default) =>
+            Task.FromResult(regions);
+    }
+
+    // #150 follow-up (downloadable region packs): a dropdown lists the published catalog, and
+    // the old manual-folder fields collapse behind "Erweitert" instead of being the primary path.
+    [AvaloniaFact]
+    public void Einsatzgebiet_section_renders_region_dropdown_with_advanced_fields_collapsed()
+    {
+        var pack = new RegionPackInfo(
+            "Landkreis Fürstenfeldbruck", "ffb", "https://example.org/ffb.zip", 12_345_678,
+            48.0877067, 10.9930275, 48.2967233, 11.4128816, "2026-09-01",
+            "© OpenStreetMap contributors (ODbL). Höhendaten: SRTM (NASA/USGS, gemeinfrei).");
+        var vm = new MasterDataEditorViewModel(new SampleProvider(), new FakeDialogs(), new NoFiles(),
+            new FakeRegionCatalog(new[] { pack }), new NoRegionInstaller());
+        vm.SelectedSection = vm.Sections.Single(s => s.Title == "Einsatzgebiet");
+        var view = new MasterDataEditorView { DataContext = vm };
+        var window = new Window { Content = view, Width = 1080, Height = 680 };
+        window.Show();
+        Dispatcher.UIThread.RunJobs();
+
+        var comboBox = view.GetVisualDescendants().OfType<ComboBox>().Single(c => c.Name == "RegionComboBox");
+        Assert.Single(comboBox.ItemsSource!.Cast<object>());
+
+        var expander = view.GetVisualDescendants().OfType<Expander>().Single();
+        Assert.False(expander.IsExpanded);
+
+        var dir = Path.Combine(Path.GetTempPath(), "lagebuch-shots");
+        Directory.CreateDirectory(dir);
+        using var frame = window.CaptureRenderedFrame()!;
+        frame.SavePng(Path.Combine(dir, "master-data-editor-einsatzgebiet-collapsed.png"));
+
+        // Expand "Erweitert" and re-capture: the manual Name/Ordner fields are still there.
+        expander.IsExpanded = true;
+        Dispatcher.UIThread.RunJobs();
+        var textBoxes = view.GetVisualDescendants().OfType<TextBox>()
+            .Where(t => t.PlaceholderText is not null &&
+                (t.PlaceholderText.Contains("Fürstenfeldbruck") || t.PlaceholderText.Contains("/regions/ffb")))
+            .ToList();
+        Assert.Equal(2, textBoxes.Count);
+
+        using var expandedFrame = window.CaptureRenderedFrame()!;
+        expandedFrame.SavePng(Path.Combine(dir, "master-data-editor-einsatzgebiet-expanded.png"));
+    }
 }
diff --git a/tests/LageBuch.AppLogic.Tests/EinsatzgebietSectionTests.cs b/tests/LageBuch.AppLogic.Tests/EinsatzgebietSectionTests.cs
new file mode 100644
index 0000000..b41ab57
--- /dev/null
+++ b/tests/LageBuch.AppLogic.Tests/EinsatzgebietSectionTests.cs
@@ -0,0 +1,169 @@
+using LageBuch.AppLogic.Services;
+using LageBuch.AppLogic.ViewModels;
+using LageBuch.Persistence.MasterData;
+
+namespace LageBuch.AppLogic.Tests;
+
+public class EinsatzgebietSectionTests : IDisposable
+{
+    private readonly List<string> _tempDirs = new();
+
+    public void Dispose()
+    {
+        foreach (var dir in _tempDirs)
+            if (Directory.Exists(dir)) Directory.Delete(dir, recursive: true);
+    }
+
+    private string NewTempDir()
+    {
+        var dir = Path.Combine(Path.GetTempPath(), $"einsatzgebiet-{Guid.NewGuid():N}");
+        Directory.CreateDirectory(dir);
+        _tempDirs.Add(dir);
+        return dir;
+    }
+
+    private static readonly RegionPackInfo Ffb = new(
+        "Landkreis Fürstenfeldbruck", "ffb", "https://example.org/ffb.zip", 42,
+        48.08, 10.99, 48.29, 11.41, "2026-09-01", "© OpenStreetMap contributors (ODbL)");
+
+    private sealed class FakeCatalog(IReadOnlyList<RegionPackInfo> regions) : IRegionPackCatalogService
+    {
+        public Task<IReadOnlyList<RegionPackInfo>> GetAvailableRegionsAsync(CancellationToken ct = default)
+            => Task.FromResult(regions);
+    }
+
+    private sealed class FakeInstaller(string installedFolder) : IRegionPackInstaller
+    {
+        public RegionPackInfo? LastInstalled { get; private set; }
+
+        public Task<string> DownloadAndInstallAsync(RegionPackInfo pack, IProgress<double>? progress, CancellationToken ct = default)
+        {
+            LastInstalled = pack;
+            progress?.Report(0.5);
+            progress?.Report(1.0);
+            return Task.FromResult(installedFolder);
+        }
+    }
+
+    private static EinsatzgebietSection NewSection(
+        IRegionPackCatalogService? catalog = null, IRegionPackInstaller? installer = null, Action? onChanged = null) =>
+        new("Einsatzgebiet", Einsatzgebiet.Empty,
+            onChanged ?? (() => { }),
+            catalog ?? new FakeCatalog(Array.Empty<RegionPackInfo>()),
+            installer ?? new FakeInstaller("/tmp/unused"));
+
+    [Fact]
+    public async Task LoadCatalogCommand_populates_AvailableRegions_on_success()
+    {
+        var section = NewSection(catalog: new FakeCatalog(new[] { Ffb }));
+
+        await section.LoadCatalogCommand.ExecuteAsync(null);
+
+        Assert.Equal("ffb", Assert.Single(section.AvailableRegions).Slug);
+    }
+
+    [Fact]
+    public async Task LoadCatalogCommand_leaves_the_list_empty_and_sets_a_quiet_status_when_nothing_is_returned()
+    {
+        var section = NewSection(catalog: new FakeCatalog(Array.Empty<RegionPackInfo>()));
+
+        await section.LoadCatalogCommand.ExecuteAsync(null);
+
+        Assert.Empty(section.AvailableRegions);
+        Assert.NotNull(section.CatalogStatus);
+    }
+
+    [Fact]
+    public async Task DownloadSelectedRegionCommand_installs_the_selected_region_and_sets_name_and_folder()
+    {
+        var installedFolder = NewTempDir();
+        var installer = new FakeInstaller(installedFolder);
+        var section = NewSection(installer: installer);
+        section.SelectedRegion = Ffb;
+
+        await section.DownloadSelectedRegionCommand.ExecuteAsync(null);
+
+        Assert.Equal(Ffb, installer.LastInstalled);
+        Assert.Equal("Landkreis Fürstenfeldbruck", section.Name);
+        Assert.Equal(installedFolder, section.FolderPath);
+    }
+
+    [Fact]
+    public async Task DownloadSelectedRegionCommand_fires_the_dirty_callback()
+    {
+        var changedCount = 0;
+        var section = NewSection(installer: new FakeInstaller(NewTempDir()), onChanged: () => changedCount++);
+        section.SelectedRegion = Ffb;
+
+        await section.DownloadSelectedRegionCommand.ExecuteAsync(null);
+
+        Assert.True(changedCount > 0);
+    }
+
+    [Fact]
+    public void DownloadSelectedRegionCommand_cannot_execute_without_a_selected_region()
+    {
+        var section = NewSection();
+
+        Assert.False(section.DownloadSelectedRegionCommand.CanExecute(null));
+    }
+
+    [Fact]
+    public async Task DownloadSelectedRegionCommand_reports_progress_up_to_one()
+    {
+        var section = NewSection(installer: new FakeInstaller(NewTempDir()));
+        section.SelectedRegion = Ffb;
+
+        await section.DownloadSelectedRegionCommand.ExecuteAsync(null);
+
+        Assert.Equal(1.0, section.DownloadProgress);
+    }
+
+    // --- File-presence validation: is region.mbtiles/region.dem actually at FolderPath? ---
+
+    [Fact]
+    public void KartendatenStatus_is_null_when_folder_path_is_empty()
+    {
+        var section = NewSection();
+
+        Assert.Null(section.KartendatenStatus);
+        Assert.False(section.KartendatenGefunden);
+    }
+
+    [Fact]
+    public void KartendatenStatus_reports_both_files_missing()
+    {
+        var section = NewSection();
+        section.FolderPath = NewTempDir();
+
+        Assert.False(section.KartendatenGefunden);
+        Assert.Contains("region.mbtiles", section.KartendatenStatus);
+        Assert.Contains("region.dem", section.KartendatenStatus);
+    }
+
+    [Fact]
+    public void KartendatenStatus_names_only_the_missing_file_when_one_is_present()
+    {
+        var section = NewSection();
+        var dir = NewTempDir();
+        File.WriteAllText(Path.Combine(dir, "region.mbtiles"), "x");
+        section.FolderPath = dir;
+
+        Assert.False(section.KartendatenGefunden);
+        Assert.DoesNotContain("region.mbtiles", section.KartendatenStatus);
+        Assert.Contains("region.dem", section.KartendatenStatus);
+    }
+
+    [Fact]
+    public void KartendatenStatus_is_positive_when_both_files_are_present()
+    {
+        var section = NewSection();
+        var dir = NewTempDir();
+        File.WriteAllText(Path.Combine(dir, "region.mbtiles"), "x");
+        File.WriteAllText(Path.Combine(dir, "region.dem"), "x");
+        section.FolderPath = dir;
+
+        Assert.True(section.KartendatenGefunden);
+        Assert.NotNull(section.KartendatenStatus);
+    }
+}
diff --git a/tests/LageBuch.AppLogic.Tests/MainWindowViewModelTests.cs b/tests/LageBuch.AppLogic.Tests/MainWindowViewModelTests.cs
index bde7dc9..21844ad 100644
--- a/tests/LageBuch.AppLogic.Tests/MainWindowViewModelTests.cs
+++ b/tests/LageBuch.AppLogic.Tests/MainWindowViewModelTests.cs
@@ -39,7 +39,7 @@ public class MainWindowViewModelTests
     private static MainWindowViewModel New(IFileDialogService? dialogs = null)
     {
         var home = new HomeViewModel(new FakeStore(), new MvFakeMasterData(), new FakeRecent(), new FakeDialogs(), new FixedClock(T0), new FakeTicker(), new FakeAlarmService(), new NoopIncidentHostController(), "1.0.0");
-        return new MainWindowViewModel(home, new MasterDataEditorViewModel(new MvFakeMasterData(), new FakeDialogs(), new NoFiles()), dialogs ?? new FakeDialogs(), "0.1.0");
+        return new MainWindowViewModel(home, new MasterDataEditorViewModel(new MvFakeMasterData(), new FakeDialogs(), new NoFiles(), new NoRegionCatalog(), new NoRegionInstaller()), dialogs ?? new FakeDialogs(), "0.1.0");
     }
 
     [Fact]
@@ -97,7 +97,7 @@ public void RequestOpenFile_opens_readonly_without_prompt()
         var clock = new FixedClock(T0);
         LocalIncidentSession.StartNew(store, clock, new SessionOperator("Müller"), "/x.fwincident", Array.Empty<(string, bool)>(), Array.Empty<(string, bool)>());
         var home = new HomeViewModel(store, new MvFakeMasterData(), new FakeRecent(), new OpenPathDialogs(), clock, new FakeTicker(), new FakeAlarmService(), new NoopIncidentHostController(), "1.0.0");
-        var vm = new MainWindowViewModel(home, new MasterDataEditorViewModel(new MvFakeMasterData(), new FakeDialogs(), new NoFiles()), new FakeDialogs(), "0.1.0");
+        var vm = new MainWindowViewModel(home, new MasterDataEditorViewModel(new MvFakeMasterData(), new FakeDialogs(), new NoFiles(), new NoRegionCatalog(), new NoRegionInstaller()), new FakeDialogs(), "0.1.0");
 
         vm.RequestOpenFileCommand.Execute(null);
 
@@ -113,7 +113,7 @@ public void OpenRecent_opens_readonly_without_prompt()
         var clock = new FixedClock(T0);
         LocalIncidentSession.StartNew(store, clock, new SessionOperator("Müller"), "/x.fwincident", Array.Empty<(string, bool)>(), Array.Empty<(string, bool)>());
         var home = new HomeViewModel(store, new MvFakeMasterData(), new FakeRecent(), new FakeDialogs(), clock, new FakeTicker(), new FakeAlarmService(), new NoopIncidentHostController(), "1.0.0");
-        var vm = new MainWindowViewModel(home, new MasterDataEditorViewModel(new MvFakeMasterData(), new FakeDialogs(), new NoFiles()), new FakeDialogs(), "0.1.0");
+        var vm = new MainWindowViewModel(home, new MasterDataEditorViewModel(new MvFakeMasterData(), new FakeDialogs(), new NoFiles(), new NoRegionCatalog(), new NoRegionInstaller()), new FakeDialogs(), "0.1.0");
 
         vm.OpenRecent("/x.fwincident");
 
diff --git a/tests/LageBuch.AppLogic.Tests/MasterDataEditorViewModelTests.cs b/tests/LageBuch.AppLogic.Tests/MasterDataEditorViewModelTests.cs
index 58017b5..22ee4fb 100644
--- a/tests/LageBuch.AppLogic.Tests/MasterDataEditorViewModelTests.cs
+++ b/tests/LageBuch.AppLogic.Tests/MasterDataEditorViewModelTests.cs
@@ -69,7 +69,8 @@ public void Write(string path, MasterDataSet set)
 
     private static MasterDataEditorViewModel Vm(
         IMasterDataProvider provider, IFileDialogService? dialogs = null, IMasterDataFileService? files = null) =>
-        new(provider, dialogs ?? new FakeDialogs(), files ?? new FakeFileService());
+        new(provider, dialogs ?? new FakeDialogs(), files ?? new FakeFileService(),
+            new NoRegionCatalog(), new NoRegionInstaller());
 
     private static EditableListSection Roles(MasterDataEditorViewModel vm) =>
         vm.Sections.OfType<EditableListSection>().First(s => s.Title == "Rollen");
@@ -550,3 +551,17 @@ public void Fixing_the_duplicate_re_enables_saving()
         Assert.True(vm.SaveCommand.CanExecute(null));
     }
 }
+
+// Shared no-op fakes for constructor sites that don't exercise region-pack behavior — reused from
+// MainWindowViewModelTests.cs, same convention as FakeDialogs/FakeStore/etc.
+internal sealed class NoRegionCatalog : IRegionPackCatalogService
+{
+    public Task<IReadOnlyList<RegionPackInfo>> GetAvailableRegionsAsync(CancellationToken ct = default)
+        => Task.FromResult<IReadOnlyList<RegionPackInfo>>(Array.Empty<RegionPackInfo>());
+}
+
+internal sealed class NoRegionInstaller : IRegionPackInstaller
+{
+    public Task<string> DownloadAndInstallAsync(RegionPackInfo pack, IProgress<double>? progress, CancellationToken ct = default)
+        => Task.FromResult("/unused");
+}
diff --git a/tests/LageBuch.AppLogic.Tests/RegionPackCatalogJsonTests.cs b/tests/LageBuch.AppLogic.Tests/RegionPackCatalogJsonTests.cs
new file mode 100644
index 0000000..643517b
--- /dev/null
+++ b/tests/LageBuch.AppLogic.Tests/RegionPackCatalogJsonTests.cs
@@ -0,0 +1,73 @@
+using LageBuch.AppLogic.Services;
+
+namespace LageBuch.AppLogic.Tests;
+
+public class RegionPackCatalogJsonTests
+{
+    [Fact]
+    public void Parse_reads_every_field_of_a_valid_manifest()
+    {
+        var json = """
+            [
+              {
+                "name": "Landkreis Fürstenfeldbruck",
+                "slug": "ffb",
+                "downloadUrl": "https://example.org/ffb.zip",
+                "sizeBytes": 12345678,
+                "boundingBox": { "minLat": 48.0877067, "minLon": 10.9930275, "maxLat": 48.2967233, "maxLon": 11.4128816 },
+                "builtAt": "2026-09-01",
+                "attribution": "© OpenStreetMap contributors (ODbL). Elevation: SRTM (NASA/USGS, public domain)."
+              }
+            ]
+            """;
+
+        var regions = RegionPackCatalogJson.Parse(json);
+
+        var ffb = Assert.Single(regions);
+        Assert.Equal("Landkreis Fürstenfeldbruck", ffb.Name);
+        Assert.Equal("ffb", ffb.Slug);
+        Assert.Equal("https://example.org/ffb.zip", ffb.DownloadUrl);
+        Assert.Equal(12345678, ffb.SizeBytes);
+        Assert.Equal(48.0877067, ffb.MinLat);
+        Assert.Equal(10.9930275, ffb.MinLon);
+        Assert.Equal(48.2967233, ffb.MaxLat);
+        Assert.Equal(11.4128816, ffb.MaxLon);
+        Assert.Equal("2026-09-01", ffb.BuiltAt);
+        Assert.Contains("OpenStreetMap", ffb.Attribution);
+    }
+
+    [Fact]
+    public void Parse_reads_multiple_entries_in_order()
+    {
+        var json = """
+            [
+              { "name": "A", "slug": "a", "downloadUrl": "https://x/a.zip", "sizeBytes": 1,
+                "boundingBox": { "minLat": 0, "minLon": 0, "maxLat": 1, "maxLon": 1 },
+                "builtAt": "2026-01-01", "attribution": "x" },
+              { "name": "B", "slug": "b", "downloadUrl": "https://x/b.zip", "sizeBytes": 2,
+                "boundingBox": { "minLat": 0, "minLon": 0, "maxLat": 1, "maxLon": 1 },
+                "builtAt": "2026-01-02", "attribution": "x" }
+            ]
+            """;
+
+        var regions = RegionPackCatalogJson.Parse(json);
+
+        Assert.Equal(new[] { "a", "b" }, regions.Select(r => r.Slug));
+    }
+
+    [Theory]
+    [InlineData("")]
+    [InlineData("not json")]
+    [InlineData("{}")]
+    [InlineData("""[{"name": "Missing required fields"}]""")]
+    public void Parse_never_throws_and_returns_empty_for_malformed_input(string malformed)
+    {
+        var regions = RegionPackCatalogJson.Parse(malformed);
+
+        Assert.Empty(regions);
+    }
+
+    [Fact]
+    public void Parse_of_an_empty_array_returns_an_empty_list()
+        => Assert.Empty(RegionPackCatalogJson.Parse("[]"));
+}
diff --git a/tests/LageBuch.AppLogic.Tests/RegionPackCatalogServiceTests.cs b/tests/LageBuch.AppLogic.Tests/RegionPackCatalogServiceTests.cs
new file mode 100644
index 0000000..cacce1e
--- /dev/null
+++ b/tests/LageBuch.AppLogic.Tests/RegionPackCatalogServiceTests.cs
@@ -0,0 +1,73 @@
+using System.Net;
+using LageBuch.AppLogic.Services;
+
+namespace LageBuch.AppLogic.Tests;
+
+public class RegionPackCatalogServiceTests
+{
+    private sealed class FakeHandler(Func<HttpRequestMessage, HttpResponseMessage> respond) : HttpMessageHandler
+    {
+        protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken ct)
+            => Task.FromResult(respond(request));
+    }
+
+    private static readonly string ValidManifest = """
+        [
+          { "name": "Landkreis Fürstenfeldbruck", "slug": "ffb", "downloadUrl": "https://example.org/ffb.zip",
+            "sizeBytes": 42, "boundingBox": { "minLat": 48.08, "minLon": 10.99, "maxLat": 48.29, "maxLon": 11.41 },
+            "builtAt": "2026-09-01", "attribution": "OSM" }
+        ]
+        """;
+
+    [Fact]
+    public async Task GetAvailableRegionsAsync_returns_the_parsed_manifest_on_success()
+    {
+        var handler = new FakeHandler(_ => new HttpResponseMessage(HttpStatusCode.OK)
+        {
+            Content = new StringContent(ValidManifest),
+        });
+        var service = new RegionPackCatalogService(new HttpClient(handler), "https://example.org/regions.json");
+
+        var regions = await service.GetAvailableRegionsAsync();
+
+        Assert.Equal("ffb", Assert.Single(regions).Slug);
+    }
+
+    [Fact]
+    public async Task GetAvailableRegionsAsync_fetches_the_configured_manifest_url()
+    {
+        HttpRequestMessage? seenRequest = null;
+        var handler = new FakeHandler(r =>
+        {
+            seenRequest = r;
+            return new HttpResponseMessage(HttpStatusCode.OK) { Content = new StringContent("[]") };
+        });
+        var service = new RegionPackCatalogService(new HttpClient(handler), "https://example.org/regions.json");
+
+        await service.GetAvailableRegionsAsync();
+
+        Assert.Equal("https://example.org/regions.json", seenRequest?.RequestUri?.ToString());
+    }
+
+    [Fact]
+    public async Task GetAvailableRegionsAsync_returns_empty_list_never_throws_on_http_failure()
+    {
+        var handler = new FakeHandler(_ => new HttpResponseMessage(HttpStatusCode.NotFound));
+        var service = new RegionPackCatalogService(new HttpClient(handler), "https://example.org/regions.json");
+
+        var regions = await service.GetAvailableRegionsAsync();
+
+        Assert.Empty(regions);
+    }
+
+    [Fact]
+    public async Task GetAvailableRegionsAsync_returns_empty_list_never_throws_when_the_handler_throws()
+    {
+        var handler = new FakeHandler(_ => throw new HttpRequestException("no route to host"));
+        var service = new RegionPackCatalogService(new HttpClient(handler), "https://example.org/regions.json");
+
+        var regions = await service.GetAvailableRegionsAsync();
+
+        Assert.Empty(regions);
+    }
+}
diff --git a/tests/LageBuch.AppLogic.Tests/RegionPackInstallerTests.cs b/tests/LageBuch.AppLogic.Tests/RegionPackInstallerTests.cs
new file mode 100644
index 0000000..76822cb
--- /dev/null
+++ b/tests/LageBuch.AppLogic.Tests/RegionPackInstallerTests.cs
@@ -0,0 +1,109 @@
+using System.IO.Compression;
+using System.Net;
+using LageBuch.AppLogic.Services;
+
+namespace LageBuch.AppLogic.Tests;
+
+public class RegionPackInstallerTests : IDisposable
+{
+    private readonly string _regionsBaseDir = Path.Combine(Path.GetTempPath(), $"regions-{Guid.NewGuid():N}");
+
+    public void Dispose()
+    {
+        if (Directory.Exists(_regionsBaseDir))
+            Directory.Delete(_regionsBaseDir, recursive: true);
+    }
+
+    private sealed class FakeHandler(Func<HttpRequestMessage, HttpResponseMessage> respond) : HttpMessageHandler
+    {
+        protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken ct)
+            => Task.FromResult(respond(request));
+    }
+
+    private static byte[] BuildFakePackZip(string mbtilesContent = "fake-mbtiles", string demContent = "fake-dem")
+    {
+        using var ms = new MemoryStream();
+        using (var zip = new ZipArchive(ms, ZipArchiveMode.Create, leaveOpen: true))
+        {
+            using (var entry = zip.CreateEntry("region.mbtiles").Open())
+            using (var writer = new StreamWriter(entry))
+                writer.Write(mbtilesContent);
+            using (var entry = zip.CreateEntry("region.dem").Open())
+            using (var writer = new StreamWriter(entry))
+                writer.Write(demContent);
+        }
+        return ms.ToArray();
+    }
+
+    private static RegionPackInfo FfbPack(string downloadUrl = "https://example.org/ffb.zip") => new(
+        "Landkreis Fürstenfeldbruck", "ffb", downloadUrl, 42, 48.08, 10.99, 48.29, 11.41, "2026-09-01", "OSM");
+
+    [Fact]
+    public async Task DownloadAndInstallAsync_extracts_the_zip_into_a_slug_named_folder()
+    {
+        var handler = new FakeHandler(_ => new HttpResponseMessage(HttpStatusCode.OK)
+        {
+            Content = new ByteArrayContent(BuildFakePackZip()),
+        });
+        var installer = new RegionPackInstaller(new HttpClient(handler), _regionsBaseDir);
+
+        var folder = await installer.DownloadAndInstallAsync(FfbPack(), progress: null);
+
+        Assert.Equal(Path.Combine(_regionsBaseDir, "ffb"), folder);
+        Assert.Equal("fake-mbtiles", await File.ReadAllTextAsync(Path.Combine(folder, "region.mbtiles")));
+        Assert.Equal("fake-dem", await File.ReadAllTextAsync(Path.Combine(folder, "region.dem")));
+    }
+
+    [Fact]
+    public async Task DownloadAndInstallAsync_requests_the_packs_download_url()
+    {
+        HttpRequestMessage? seenRequest = null;
+        var handler = new FakeHandler(r =>
+        {
+            seenRequest = r;
+            return new HttpResponseMessage(HttpStatusCode.OK) { Content = new ByteArrayContent(BuildFakePackZip()) };
+        });
+        var installer = new RegionPackInstaller(new HttpClient(handler), _regionsBaseDir);
+
+        await installer.DownloadAndInstallAsync(FfbPack("https://example.org/specific-ffb.zip"), progress: null);
+
+        Assert.Equal("https://example.org/specific-ffb.zip", seenRequest?.RequestUri?.ToString());
+    }
+
+    [Fact]
+    public async Task DownloadAndInstallAsync_re_installing_the_same_slug_removes_stale_files()
+    {
+        var handler = new FakeHandler(_ => new HttpResponseMessage(HttpStatusCode.OK)
+        {
+            Content = new ByteArrayContent(BuildFakePackZip()),
+        });
+        var installer = new RegionPackInstaller(new HttpClient(handler), _regionsBaseDir);
+        var folder = await installer.DownloadAndInstallAsync(FfbPack(), progress: null);
+        var staleFile = Path.Combine(folder, "old-junk.txt");
+        await File.WriteAllTextAsync(staleFile, "leftover from a previous version");
+
+        await installer.DownloadAndInstallAsync(FfbPack(), progress: null);
+
+        Assert.False(File.Exists(staleFile));
+        Assert.True(File.Exists(Path.Combine(folder, "region.mbtiles")));
+    }
+
+    [Fact]
+    public async Task DownloadAndInstallAsync_reports_progress_from_zero_to_one()
+    {
+        var handler = new FakeHandler(_ => new HttpResponseMessage(HttpStatusCode.OK)
+        {
+            Content = new ByteArrayContent(BuildFakePackZip()),
+        });
+        var installer = new RegionPackInstaller(new HttpClient(handler), _regionsBaseDir);
+        var reported = new List<double>();
+        var progress = new Progress<double>(reported.Add);
+
+        await installer.DownloadAndInstallAsync(FfbPack(), progress);
+        // Progress<T> marshals via SynchronizationContext.Post when one is captured; without one
+        // (the xunit test-runner thread has none) it invokes synchronously, so this is deterministic.
+
+        Assert.NotEmpty(reported);
+        Assert.Equal(1.0, reported[^1]);
+    }
+}
diff --git a/tools/build-region-pack/README.md b/tools/build-region-pack/README.md
new file mode 100644
index 0000000..c05c425
--- /dev/null
+++ b/tools/build-region-pack/README.md
@@ -0,0 +1,157 @@
+# Building a Wasserförderung region pack
+
+This is a runbook, not an app component. It documents how a maintainer builds and publishes one
+region pack (one Landkreis) for the Wasserförderung "Karte" map mode (#150 follow-up). It is
+**deliberately not part of `LageBuch.sln`** — it doesn't ship with the app, doesn't run in the
+app's CI, and isn't built/tested by `dotnet build`/`dotnet test`. It's a manual, occasional process
+a maintainer runs on their own machine with real internet access, using off-the-shelf OSS tools.
+
+The app itself only ever *downloads* a pack someone already built this way — see
+`src/LageBuch.AppLogic/Services/IRegionPackCatalogService.cs` and `IRegionPackInstaller.cs`.
+
+## What a pack contains
+
+A zip with exactly two files at its root:
+
+- `region.mbtiles` — raster map tiles, standard MBTiles SQLite schema, TMS row numbering, zoom
+  11–15. Read by `src/LageBuch.AppLogic/Services/MbTilesFileSource.cs`.
+- `region.dem` — elevation grid in this app's own binary format ("FWDM"): little-endian header
+  (magic, version, origin lat/lon, cell-size-degrees, rows, cols) + row-major `Int16` body,
+  `-32768` = NoData. See `src/LageBuch.AppLogic/Services/DemFileElevationSampler.cs`'s doc comment
+  for the exact byte layout. SRTM's own Skadi `.hgt` format is nearly identical (same NoData
+  sentinel, same 1-arcsecond grid) — the only real conversion is a byte order swap and writing our
+  small header.
+
+## Licensing (read this before publishing anything)
+
+- **OpenStreetMap data (ODbL 1.0)**: rendered raster tiles are a "Produced Work", not a
+  "Derivative Database" — see the OSM Foundation's Legal FAQ. Produced Works need **attribution
+  only** ("© OpenStreetMap contributors", linking to the ODbL/copyright page); share-alike does
+  **not** apply. If a future pack ever ships raw/vector OSM data instead of flattened raster
+  images, revisit this — vector tiles with queryable attributes are much closer to a Derivative
+  Database and ODbL's share-alike would likely apply.
+- **SRTM elevation (NASA/USGS)**: US federal government work, public domain, freely
+  redistributable. No legal attribution requirement (a courtesy credit is still included below).
+- **Copernicus DEM**: higher resolution than SRTM and tempting as a future upgrade, but its exact
+  redistribution terms for derived/cropped public extracts have **not been confirmed**. Don't use
+  it for a published pack until someone has actually read the license and confirmed this is
+  permitted.
+- Every published pack's `regions.json` entry carries an `attribution` string (see below) that the
+  app surfaces directly under the installed region in Stammdaten → Einsatzgebiet. Keep that string
+  accurate for what the pack actually contains.
+
+## Prerequisites
+
+- [`osmium-tool`](https://osmcode.org/osmium-tool/) — extracts a bounded region from a larger
+  `.osm.pbf` without needing a database.
+- A raster tile renderer that reads `.osm`/`.pbf` directly and needs no database setup — e.g.
+  [Maperitive](http://maperitive.net/) (single executable, built-in default style) or
+  [Mapnik](https://mapnik.org/) + the classic `generate_tiles.py` script. Pin whichever is actually
+  available and maintained at the time you run this — don't assume either is still the best choice.
+- `sqlite3` CLI (to assemble/inspect the `.mbtiles` file — most tile renderers write this format
+  natively; if yours doesn't, `mbutil` converts a tile directory into one).
+- `curl` and `gzip` (SRTM `.hgt.gz` download).
+- A `.NET` SDK is **not** required for any of this — none of it touches `LageBuch.sln`.
+
+## 1. Find the region's exact boundary
+
+Look up the Landkreis's OSM relation and precise administrative boundary via Nominatim:
+
+```sh
+curl -s "https://nominatim.openstreetmap.org/lookup?osm_ids=R<relation-id>&format=json&polygon_geojson=1" \
+  -o boundary.json
+```
+
+For Landkreis Fürstenfeldbruck this is relation **62595**, bounding box
+**48.0877067,10.9930275 – 48.2967233,11.4128816**.
+
+## 2. Extract the region from a Geofabrik regional extract
+
+Download the containing regional `.osm.pbf` from [Geofabrik](https://download.geofabrik.de/)
+(e.g. `bayern-latest.osm.pbf` for a Bavarian Landkreis), then clip to the precise boundary:
+
+```sh
+osmium extract --polygon boundary.geojson bayern-latest.osm.pbf -o ffb.osm.pbf
+```
+
+(`boundary.geojson` is `boundary.json`'s `geojson` field extracted into its own file — osmium wants
+a bare GeoJSON polygon, not the full Nominatim response.)
+
+## 3. Render raster tiles, zoom 11–15
+
+Render directly from `ffb.osm.pbf` with whichever tool you picked above, output as a directory of
+`{z}/{x}/{y}.png` tiles or directly as MBTiles if the tool supports it. Zoom 11–15 is enough detail
+for route planning at Landkreis scale without an unreasonably large pack.
+
+## 4. Pack into `region.mbtiles`
+
+If your renderer didn't write MBTiles directly, pack the tile directory with `mbutil`:
+
+```sh
+mb-util --image_format=png tiles/ region.mbtiles
+```
+
+`MbTilesFileSource.cs` expects the standard schema (`tiles(zoom_level, tile_column, tile_row,
+tile_data)`) with **TMS row numbering** (row 0 = south) — this is what `mb-util` and most tile
+tools produce natively; no manual row-flipping should be needed.
+
+## 5. Build `region.dem` from SRTM
+
+Download the SRTM `.hgt.gz` tiles covering the bbox (+2 km padding) from the public
+`elevation-tiles-prod` S3 bucket:
+
+```sh
+curl -sO https://s3.amazonaws.com/elevation-tiles-prod/skadi/N48/N48E010.hgt.gz
+curl -sO https://s3.amazonaws.com/elevation-tiles-prod/skadi/N48/N48E011.hgt.gz
+gunzip N48E010.hgt.gz N48E011.hgt.gz
+```
+
+Mosaic adjacent tiles (de-duplicating the shared edge column/row between neighboring 1°×1° tiles),
+then convert to `region.dem`:
+
+- SRTM `.hgt` is big-endian `Int16`, 1 arcsecond/cell (3601×3601 per tile), `-32768` = void. Our
+  format is little-endian with the same cell size and the same NoData sentinel — no resampling
+  needed, just a byte-swap and prepending our 40-byte header (magic `FWDM`, version, origin
+  lat/lon, cell-size-degrees, row count, column count — see `DemFileElevationSampler.cs`).
+- `build-dem.py` (or equivalent) is intentionally left as a short script you write against the
+  exact header layout in that file at the time you run this — the format is simple enough that
+  hand-rolling a ~30-line converter beats depending on a library for a once-per-pack step.
+
+## 6. Zip and publish
+
+```sh
+zip ffb.zip region.mbtiles region.dem
+```
+
+Publish as a GitHub Release asset in the region-pack repo (recommended: a separate repo, e.g.
+`CodeForFire/lagebuch-regions`, kept apart from this app's own release history so a pack update is
+never confused with an app version) — one tag per pack, e.g. `ffb-v1`.
+
+Add (or update) the pack's entry in that repo's `regions.json`, served raw at
+`https://raw.githubusercontent.com/CodeForFire/lagebuch-regions/main/regions.json` (this exact URL
+is `CompositionRoot.RegionPackManifestUrl` in this repo — update both if the manifest ever moves):
+
+```json
+{
+  "name": "Landkreis Fürstenfeldbruck",
+  "slug": "ffb",
+  "downloadUrl": "https://github.com/CodeForFire/lagebuch-regions/releases/download/ffb-v1/ffb.zip",
+  "sizeBytes": 12345678,
+  "minLat": 48.0877067,
+  "minLon": 10.9930275,
+  "maxLat": 48.2967233,
+  "maxLon": 11.4128816,
+  "builtAt": "2026-09-01",
+  "attribution": "© OpenStreetMap contributors (ODbL). Höhendaten: SRTM (NASA/USGS, gemeinfrei)."
+}
+```
+
+The app fetches this manifest, lists every entry in the Stammdaten → Einsatzgebiet dropdown, and
+downloads/extracts whichever one the operator picks. No app code change is needed to publish a new
+region — only a `regions.json` update.
+
+## What this runbook does not cover
+
+Actually running these steps for Landkreis Fürstenfeldbruck (~244 MB regional extract, real tile
+rendering, real SRTM download) needs a machine with real internet access and takes a while — that's
+a manual follow-up outside this repo/session, not something covered by `dotnet test`.

From 5ed0997f0164b636ca8c13dc13722b3ecf5a6f1f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Thomas=20M=C3=BCller?=
 <1005065+DeepDiver1975@users.noreply.github.com>
Date: Mon, 31 Aug 2026 10:39:21 +0200
Subject: [PATCH 2/4] fix(wasserfoerderung): reject path-traversal slugs in
 region-pack manifest
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

RegionPackInstaller joins pack.Slug straight onto the regions base
directory (<regionsBaseDir>/<slug>). Since regions.json is fetched from a
third-party-controlled URL, a manifest entry with a slug like "../../etc"
could extract a downloaded pack outside the regions directory.

Reject unsafe slugs at parse time in RegionPackCatalogJson (same
"malformed entry is skipped, not thrown" defensive style already used for
missing/wrong-typed fields), and add a defense-in-depth path-containment
check in RegionPackInstaller itself in case a slug ever reaches it another
way.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UwN31QccH98YV9eEc2bue2
Signed-off-by: Thomas Müller <1005065+DeepDiver1975@users.noreply.github.com>
---
 .../Services/RegionPackCatalogJson.cs         |  8 +++-
 .../Services/RegionPackInstaller.cs           |  9 +++-
 .../RegionPackCatalogJsonTests.cs             | 42 +++++++++++++++++++
 3 files changed, 57 insertions(+), 2 deletions(-)

diff --git a/src/LageBuch.AppLogic/Services/RegionPackCatalogJson.cs b/src/LageBuch.AppLogic/Services/RegionPackCatalogJson.cs
index d191efd..08df716 100644
--- a/src/LageBuch.AppLogic/Services/RegionPackCatalogJson.cs
+++ b/src/LageBuch.AppLogic/Services/RegionPackCatalogJson.cs
@@ -1,4 +1,5 @@
 using System.Text.Json;
+using System.Text.RegularExpressions;
 
 namespace LageBuch.AppLogic.Services;
 
@@ -11,6 +12,11 @@ namespace LageBuch.AppLogic.Services;
 /// </summary>
 public static class RegionPackCatalogJson
 {
+    // RegionPackInstaller joins this straight onto a base directory (<regionsBaseDir>/<slug>) —
+    // reject anything that could escape that directory (path separators, "..", empty) here rather
+    // than trusting the installer alone to catch it.
+    private static readonly Regex SafeSlug = new("^[a-z0-9][a-z0-9_-]{0,63}$", RegexOptions.Compiled);
+
     public static IReadOnlyList<RegionPackInfo> Parse(string json)
     {
         try
@@ -40,7 +46,7 @@ private static bool TryParseEntry(JsonElement entry, out RegionPackInfo region)
             return false;
 
         if (!TryGetString(entry, "name", out var name) ||
-            !TryGetString(entry, "slug", out var slug) ||
+            !TryGetString(entry, "slug", out var slug) || !SafeSlug.IsMatch(slug) ||
             !TryGetString(entry, "downloadUrl", out var downloadUrl) ||
             !TryGetString(entry, "builtAt", out var builtAt) ||
             !TryGetString(entry, "attribution", out var attribution) ||
diff --git a/src/LageBuch.AppLogic/Services/RegionPackInstaller.cs b/src/LageBuch.AppLogic/Services/RegionPackInstaller.cs
index 236a350..d8bd319 100644
--- a/src/LageBuch.AppLogic/Services/RegionPackInstaller.cs
+++ b/src/LageBuch.AppLogic/Services/RegionPackInstaller.cs
@@ -19,7 +19,14 @@ public async Task<string> DownloadAndInstallAsync(RegionPackInfo pack, IProgress
 
         var zipBytes = await DownloadAsync(pack.DownloadUrl, progress, ct);
 
-        var folder = Path.Combine(regionsBaseDir, pack.Slug);
+        // Defense in depth: RegionPackCatalogJson already rejects unsafe slugs when parsing the
+        // manifest, but a slug ending up here from anywhere else must not be able to escape
+        // regionsBaseDir either.
+        var baseFull = Path.GetFullPath(regionsBaseDir) + Path.DirectorySeparatorChar;
+        var folder = Path.GetFullPath(Path.Combine(regionsBaseDir, pack.Slug));
+        if (!folder.StartsWith(baseFull, StringComparison.Ordinal))
+            throw new InvalidOperationException($"Region slug '{pack.Slug}' escapes the regions directory.");
+
         if (Directory.Exists(folder))
             Directory.Delete(folder, recursive: true);
         Directory.CreateDirectory(folder);
diff --git a/tests/LageBuch.AppLogic.Tests/RegionPackCatalogJsonTests.cs b/tests/LageBuch.AppLogic.Tests/RegionPackCatalogJsonTests.cs
index 643517b..a9ea2d2 100644
--- a/tests/LageBuch.AppLogic.Tests/RegionPackCatalogJsonTests.cs
+++ b/tests/LageBuch.AppLogic.Tests/RegionPackCatalogJsonTests.cs
@@ -70,4 +70,46 @@ public void Parse_never_throws_and_returns_empty_for_malformed_input(string malf
     [Fact]
     public void Parse_of_an_empty_array_returns_an_empty_list()
         => Assert.Empty(RegionPackCatalogJson.Parse("[]"));
+
+    // The manifest is fetched from a third-party-controlled URL and its slug ends up as a path
+    // component (RegionPackInstaller extracts to <regionsBaseDir>/<slug>) — an entry with a
+    // path-traversal slug like "../../etc" must be rejected rather than silently accepted.
+    [Theory]
+    [InlineData("../evil")]
+    [InlineData("..\\evil")]
+    [InlineData("a/b")]
+    [InlineData("a\\b")]
+    [InlineData("")]
+    [InlineData("UPPER")]
+    [InlineData(".")]
+    public void Parse_rejects_entries_with_an_unsafe_slug(string unsafeSlug)
+    {
+        var json = $$"""
+            [
+              { "name": "Evil", "slug": "{{unsafeSlug.Replace("\\", "\\\\")}}", "downloadUrl": "https://x/e.zip", "sizeBytes": 1,
+                "boundingBox": { "minLat": 0, "minLon": 0, "maxLat": 1, "maxLon": 1 },
+                "builtAt": "2026-01-01", "attribution": "x" }
+            ]
+            """;
+
+        Assert.Empty(RegionPackCatalogJson.Parse(json));
+    }
+
+    [Theory]
+    [InlineData("ffb")]
+    [InlineData("landkreis-ffb")]
+    [InlineData("region_1")]
+    [InlineData("a")]
+    public void Parse_accepts_entries_with_a_safe_slug(string safeSlug)
+    {
+        var json = $$"""
+            [
+              { "name": "OK", "slug": "{{safeSlug}}", "downloadUrl": "https://x/ok.zip", "sizeBytes": 1,
+                "boundingBox": { "minLat": 0, "minLon": 0, "maxLat": 1, "maxLon": 1 },
+                "builtAt": "2026-01-01", "attribution": "x" }
+            ]
+            """;
+
+        Assert.Equal(safeSlug, Assert.Single(RegionPackCatalogJson.Parse(json)).Slug);
+    }
 }

From 324643f5c54c246337fbb8c35a78f83224bea288 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Thomas=20M=C3=BCller?=
 <1005065+DeepDiver1975@users.noreply.github.com>
Date: Mon, 31 Aug 2026 14:46:56 +0200
Subject: [PATCH 3/4] fix(wasserfoerderung): center Karte mode on the
 configured region's real tiles
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Root cause (systematic-debugging): WasserfoerderungViewModel's initial map
center/zoom were a hardcoded constant (48.14, 11.58 — near Munich) picked
before any Einsatzgebiet had a knowable location. The real, published
Fürstenfeldbruck pack's tiles don't cover that point at all (z14 tile
column 8719 vs. the pack's actual [8691,8712] range), so Karte mode opened
on a blank map with no visible tiles — matching the report exactly.

Fix: derive the initial view from the tiles the configured region.mbtiles
actually has, via a new IMapTileSource.GetTileBounds() (lowest zoom level
present, TMS rows flipped back to XYZ), converted to a center through
WebMercator — moved from LageBuch.App.Shared to LageBuch.AppLogic since
IncidentWorkspaceViewModel now needs it too. This self-corrects for any
region (downloaded or manually placed under "Erweitert") since it reads
the actual tile data rather than trusting separately-tracked metadata.
The hardcoded fallback stays for the truly-no-tiles case.

Verified against the real published Fürstenfeldbruck pack: Karte mode now
opens already showing Fürstenfeldbruck/Olching/Puchheim/Germering, not a
blank canvas.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UwN31QccH98YV9eEc2bue2
Signed-off-by: Thomas Müller <1005065+DeepDiver1975@users.noreply.github.com>
---
 .../Controls/MapCanvasControl.cs              |  1 +
 .../Controls/MapDrawing.cs                    |  1 +
 .../Services}/WebMercator.cs                  |  6 +--
 .../ViewModels/IncidentWorkspaceViewModel.cs  | 23 +++++++-
 .../ViewModels/WasserfoerderungViewModel.cs   | 20 +++++--
 .../Wasserfoerderung/IMapTileSource.cs        |  7 +++
 .../Wasserfoerderung/MbTilesFileSource.cs     | 24 +++++++++
 .../MapCanvasControlTests.cs                  |  1 +
 .../RouteOverviewRendererTests.cs             |  1 +
 .../WebMercatorTests.cs                       |  2 +-
 .../IncidentWorkspaceViewModelTests.cs        | 53 +++++++++++++++++++
 .../WasserfoerderungViewModelTests.cs         | 26 +++++++++
 .../MbTilesFileSourceTests.cs                 | 48 +++++++++++++++++
 13 files changed, 204 insertions(+), 9 deletions(-)
 rename src/{LageBuch.App.Shared/Controls => LageBuch.AppLogic/Services}/WebMercator.cs (89%)

diff --git a/src/LageBuch.App.Shared/Controls/MapCanvasControl.cs b/src/LageBuch.App.Shared/Controls/MapCanvasControl.cs
index d38f166..1c0df3e 100644
--- a/src/LageBuch.App.Shared/Controls/MapCanvasControl.cs
+++ b/src/LageBuch.App.Shared/Controls/MapCanvasControl.cs
@@ -3,6 +3,7 @@
 using Avalonia.Controls;
 using Avalonia.Input;
 using Avalonia.Media;
+using LageBuch.AppLogic.Services;
 using LageBuch.Domain.Wasserfoerderung;
 using LageBuch.Persistence.Wasserfoerderung;
 
diff --git a/src/LageBuch.App.Shared/Controls/MapDrawing.cs b/src/LageBuch.App.Shared/Controls/MapDrawing.cs
index 80f0447..933e9d7 100644
--- a/src/LageBuch.App.Shared/Controls/MapDrawing.cs
+++ b/src/LageBuch.App.Shared/Controls/MapDrawing.cs
@@ -1,6 +1,7 @@
 using Avalonia;
 using Avalonia.Media;
 using Avalonia.Media.Imaging;
+using LageBuch.AppLogic.Services;
 using LageBuch.Domain.Wasserfoerderung;
 using LageBuch.Persistence.Wasserfoerderung;
 
diff --git a/src/LageBuch.App.Shared/Controls/WebMercator.cs b/src/LageBuch.AppLogic/Services/WebMercator.cs
similarity index 89%
rename from src/LageBuch.App.Shared/Controls/WebMercator.cs
rename to src/LageBuch.AppLogic/Services/WebMercator.cs
index 5b7bad3..a4df931 100644
--- a/src/LageBuch.App.Shared/Controls/WebMercator.cs
+++ b/src/LageBuch.AppLogic/Services/WebMercator.cs
@@ -1,11 +1,11 @@
 using LageBuch.Domain.Wasserfoerderung;
 
-namespace LageBuch.App.Shared.Controls;
+namespace LageBuch.AppLogic.Services;
 
 /// <summary>
 /// Standard OSM/slippy-map Web Mercator tile math (#150 Plan B) — pure functions, no Avalonia
-/// dependency, shared by the Wasserförderung map canvas's pan/zoom and the "click adds a route
-/// point" conversion.
+/// dependency, shared by the Wasserförderung map canvas's pan/zoom, the "click adds a route
+/// point" conversion, and deriving a region's initial map view from its tile bounds.
 /// </summary>
 public static class WebMercator
 {
diff --git a/src/LageBuch.AppLogic/ViewModels/IncidentWorkspaceViewModel.cs b/src/LageBuch.AppLogic/ViewModels/IncidentWorkspaceViewModel.cs
index 070df24..8a31310 100644
--- a/src/LageBuch.AppLogic/ViewModels/IncidentWorkspaceViewModel.cs
+++ b/src/LageBuch.AppLogic/ViewModels/IncidentWorkspaceViewModel.cs
@@ -5,6 +5,7 @@
 using LageBuch.Domain;
 using LageBuch.Domain.Time;
 using LageBuch.Domain.ValueObjects;
+using LageBuch.Domain.Wasserfoerderung;
 using LageBuch.Persistence.MasterData;
 using LageBuch.Persistence.Wasserfoerderung;
 using LageBuch.Sync;
@@ -239,7 +240,9 @@ private void BuildChildren()
 
         Wasserfoerderung?.Dispose();
         var (elevationSampler, tileSource) = BuildWasserfoerderungMapSources();
-        Wasserfoerderung = new WasserfoerderungViewModel(_session, OnChanged, elevationSampler, tileSource);
+        var initialMapView = InitialMapViewFrom(tileSource);
+        Wasserfoerderung = new WasserfoerderungViewModel(
+            _session, OnChanged, elevationSampler, tileSource, initialMapView?.Center, initialMapView?.Zoom);
 
         Reminder?.Dispose();
         // The ILS reminder is autonomous, time-driven host-side logging (§ IsRemote) — a joined
@@ -283,6 +286,24 @@ private void BuildChildren()
         return (new DemFileElevationSampler(demPath), new MbTilesFileSource(mbtilesPath));
     }
 
+    /// <summary>
+    /// Derives the Karte mode's initial view from the tiles the configured region actually has,
+    /// rather than an unrelated fixed fallback (#150 follow-up) — a real per-Landkreis pack has no
+    /// tiles anywhere near <see cref="WasserfoerderungViewModel"/>'s hardcoded German default, so
+    /// without this the map opened blank until the operator happened to pan to the right area.
+    /// </summary>
+    private static (GeoPoint Center, int Zoom)? InitialMapViewFrom(IMapTileSource? tileSource)
+    {
+        if (tileSource?.GetTileBounds() is not { } bounds)
+            return null;
+
+        var centerTileX = (bounds.MinX + bounds.MaxX + 1) / 2.0;
+        var centerTileY = (bounds.MinY + bounds.MaxY + 1) / 2.0;
+        var center = WebMercator.ToGeo(
+            centerTileX * WebMercator.TileSizePixels, centerTileY * WebMercator.TileSizePixels, bounds.Zoom);
+        return (center, bounds.Zoom);
+    }
+
     private bool CanClose => !IsReadOnly;
 
     // Closing is permanent (the incident becomes read-only), so confirm first. If a Trupp is
diff --git a/src/LageBuch.AppLogic/ViewModels/WasserfoerderungViewModel.cs b/src/LageBuch.AppLogic/ViewModels/WasserfoerderungViewModel.cs
index a079484..a277fc7 100644
--- a/src/LageBuch.AppLogic/ViewModels/WasserfoerderungViewModel.cs
+++ b/src/LageBuch.AppLogic/ViewModels/WasserfoerderungViewModel.cs
@@ -25,7 +25,8 @@ public sealed partial class WasserfoerderungViewModel : ObservableObject, IDispo
 
     public WasserfoerderungViewModel(
         IIncidentSession session, Action onChanged,
-        IElevationSampler? elevationSampler = null, IMapTileSource? tileSource = null)
+        IElevationSampler? elevationSampler = null, IMapTileSource? tileSource = null,
+        GeoPoint? initialMapCenter = null, int? initialMapZoom = null)
     {
         _session = session;
         _onChanged = onChanged;
@@ -36,6 +37,15 @@ public WasserfoerderungViewModel(
         DrawnRoutePoints = new ObservableCollection<GeoPoint>();
         DrawnRoutePoints.CollectionChanged += (_, _) => UndoLastRoutePointCommand.NotifyCanExecuteChanged();
         DrawnRoutePoints.CollectionChanged += (_, _) => FinishRouteCommand.NotifyCanExecuteChanged();
+
+        if (initialMapCenter is { } center)
+        {
+            _mapCenterLatitude = center.Latitude;
+            _mapCenterLongitude = center.Longitude;
+        }
+        if (initialMapZoom is { } zoom)
+            _mapZoom = Math.Clamp(zoom, MinZoom, MaxZoom);
+
         _session.Changed += Sync;
         Sync();
     }
@@ -57,9 +67,11 @@ public WasserfoerderungViewModel(
     [ObservableProperty]
     private bool _isMapMode;
 
-    // No configured Einsatzgebiet has an obvious default location, so the map opens on a fixed,
-    // reasonable German fallback; the operator pans from there. Bounds keep zooming out from
-    // going past a whole-continent view or in past building-level detail.
+    // The constructor overrides these from the configured region's actual tile bounds
+    // (IncidentWorkspaceViewModel, #150 follow-up) whenever one is available; a region with no
+    // tiles at all (or no Einsatzgebiet configured) falls back to this fixed, reasonable German
+    // default and the operator pans from there. Bounds keep zooming out from going past a
+    // whole-continent view or in past building-level detail.
     private const int MinZoom = 3;
     private const int MaxZoom = 19;
 
diff --git a/src/LageBuch.Persistence/Wasserfoerderung/IMapTileSource.cs b/src/LageBuch.Persistence/Wasserfoerderung/IMapTileSource.cs
index e7bb604..8b6d5ff 100644
--- a/src/LageBuch.Persistence/Wasserfoerderung/IMapTileSource.cs
+++ b/src/LageBuch.Persistence/Wasserfoerderung/IMapTileSource.cs
@@ -5,4 +5,11 @@ public interface IMapTileSource
 {
     /// <summary>Raw PNG/JPEG bytes for the XYZ/slippy-map tile, or null when it isn't present.</summary>
     byte[]? GetTile(int zoom, int x, int y);
+
+    /// <summary>
+    /// The XYZ tile-index bounds (inclusive) at the lowest zoom level this source has any tiles
+    /// at, or null when it has none — lets a caller derive a sensible initial map view from the
+    /// tiles actually present, instead of an unrelated fixed fallback (#150 follow-up).
+    /// </summary>
+    (int Zoom, int MinX, int MaxX, int MinY, int MaxY)? GetTileBounds();
 }
diff --git a/src/LageBuch.Persistence/Wasserfoerderung/MbTilesFileSource.cs b/src/LageBuch.Persistence/Wasserfoerderung/MbTilesFileSource.cs
index 2f77759..d8b4e40 100644
--- a/src/LageBuch.Persistence/Wasserfoerderung/MbTilesFileSource.cs
+++ b/src/LageBuch.Persistence/Wasserfoerderung/MbTilesFileSource.cs
@@ -25,4 +25,28 @@ public sealed class MbTilesFileSource(string mbtilesFilePath) : IMapTileSource
         var result = cmd.ExecuteScalar();
         return result as byte[];
     }
+
+    public (int Zoom, int MinX, int MaxX, int MinY, int MaxY)? GetTileBounds()
+    {
+        using var cn = SqliteConnectionFactory.OpenReadOnly(mbtilesFilePath);
+        using var cmd = cn.CreateCommand();
+        cmd.CommandText =
+            "SELECT zoom_level, MIN(tile_column), MAX(tile_column), MIN(tile_row), MAX(tile_row) " +
+            "FROM tiles WHERE zoom_level = (SELECT MIN(zoom_level) FROM tiles) GROUP BY zoom_level;";
+
+        using var reader = cmd.ExecuteReader();
+        if (!reader.Read())
+            return null;
+
+        var zoom = reader.GetInt32(0);
+        var minX = reader.GetInt32(1);
+        var maxX = reader.GetInt32(2);
+        var minTmsRow = reader.GetInt32(3);
+        var maxTmsRow = reader.GetInt32(4);
+
+        // Stored rows are TMS (row 0 = south); flipping back to XYZ (row 0 = north) inverts the
+        // ordering, so the max TMS row becomes the min XYZ row and vice versa.
+        var maxRow = (1 << zoom) - 1;
+        return (zoom, minX, maxX, maxRow - maxTmsRow, maxRow - minTmsRow);
+    }
 }
diff --git a/tests/LageBuch.Acceptance.Tests/MapCanvasControlTests.cs b/tests/LageBuch.Acceptance.Tests/MapCanvasControlTests.cs
index c002440..7521849 100644
--- a/tests/LageBuch.Acceptance.Tests/MapCanvasControlTests.cs
+++ b/tests/LageBuch.Acceptance.Tests/MapCanvasControlTests.cs
@@ -18,6 +18,7 @@ public class MapCanvasControlTests
     private sealed class FakeTileSource : IMapTileSource
     {
         public byte[]? GetTile(int zoom, int x, int y) => SolidTilePng.Bytes;
+        public (int Zoom, int MinX, int MaxX, int MinY, int MaxY)? GetTileBounds() => null;
     }
 
     // A real, decodable 4x4 solid-color PNG (built once via Avalonia's own encoder) so
diff --git a/tests/LageBuch.Acceptance.Tests/RouteOverviewRendererTests.cs b/tests/LageBuch.Acceptance.Tests/RouteOverviewRendererTests.cs
index 8762565..0097fae 100644
--- a/tests/LageBuch.Acceptance.Tests/RouteOverviewRendererTests.cs
+++ b/tests/LageBuch.Acceptance.Tests/RouteOverviewRendererTests.cs
@@ -12,6 +12,7 @@ public class RouteOverviewRendererTests
     private sealed class EmptyTileSource : IMapTileSource
     {
         public byte[]? GetTile(int zoom, int x, int y) => null;
+        public (int Zoom, int MinX, int MaxX, int MinY, int MaxY)? GetTileBounds() => null;
     }
 
     [AvaloniaFact]
diff --git a/tests/LageBuch.Acceptance.Tests/WebMercatorTests.cs b/tests/LageBuch.Acceptance.Tests/WebMercatorTests.cs
index 48b2801..035206e 100644
--- a/tests/LageBuch.Acceptance.Tests/WebMercatorTests.cs
+++ b/tests/LageBuch.Acceptance.Tests/WebMercatorTests.cs
@@ -1,4 +1,4 @@
-using LageBuch.App.Shared.Controls;
+using LageBuch.AppLogic.Services;
 using LageBuch.Domain.Wasserfoerderung;
 
 namespace LageBuch.Acceptance.Tests;
diff --git a/tests/LageBuch.AppLogic.Tests/IncidentWorkspaceViewModelTests.cs b/tests/LageBuch.AppLogic.Tests/IncidentWorkspaceViewModelTests.cs
index 3c7950f..ca247e3 100644
--- a/tests/LageBuch.AppLogic.Tests/IncidentWorkspaceViewModelTests.cs
+++ b/tests/LageBuch.AppLogic.Tests/IncidentWorkspaceViewModelTests.cs
@@ -73,6 +73,59 @@ private static IncidentWorkspaceViewModel EditableWorkspace(IIncidentHostControl
         return new IncidentWorkspaceViewModel(session, clock, new FakeTicker(), Md(), new FakeDialogs(), new FakeAlarmService(), host);
     }
 
+    // #150 follow-up: a configured region's actual tiles must drive the Karte mode's initial
+    // view, not the unrelated hardcoded German fallback (root cause of the real Fürstenfeldbruck
+    // pack opening on a blank map).
+    [Fact]
+    public void Wasserfoerderung_map_opens_centered_on_the_configured_regions_tiles()
+    {
+        var regionDir = Path.Combine(Path.GetTempPath(), $"region-{Guid.NewGuid():N}");
+        Directory.CreateDirectory(regionDir);
+        try
+        {
+            using (var writer = new BinaryWriter(File.Create(Path.Combine(regionDir, "region.dem"))))
+            {
+                writer.Write("FWDM"u8.ToArray());
+                writer.Write(1);
+                writer.Write(48.2);
+                writer.Write(11.4);
+                writer.Write(0.01);
+                writer.Write(10);
+                writer.Write(10);
+                for (var i = 0; i < 100; i++)
+                    writer.Write((short)500);
+            }
+
+            using (var cn = LageBuch.Persistence.Sqlite.SqliteConnectionFactory.OpenReadWrite(Path.Combine(regionDir, "region.mbtiles")))
+            using (var cmd = cn.CreateCommand())
+            {
+                cmd.CommandText =
+                    "CREATE TABLE tiles (zoom_level INTEGER, tile_column INTEGER, tile_row INTEGER, tile_data BLOB);";
+                cmd.ExecuteNonQuery();
+                // The single seeded tile is XYZ (z=11, x=1085, y=708) -> TMS row (2047-708)=1339.
+                cmd.CommandText = "INSERT INTO tiles VALUES (11, 1085, 1339, X'00');";
+                cmd.ExecuteNonQuery();
+            }
+
+            var clock = new FixedClock(T0);
+            var session = LocalIncidentSession.StartNew(new FakeStore(), clock, new SessionOperator("Müller"),
+                "/x.fwincident", Array.Empty<(string, bool)>(), Array.Empty<(string, bool)>());
+            var masterData = Md() with { Einsatzgebiet = new Einsatzgebiet("Testgebiet", regionDir) };
+            var vm = new IncidentWorkspaceViewModel(session, clock, new FakeTicker(), masterData,
+                new FakeDialogs(), new FakeAlarmService(), new NoopIncidentHostController());
+
+            // A single-tile bounds region centers on that exact tile's own center.
+            var expectedCenter = WebMercator.ToGeo(1085.5 * 256, 708.5 * 256, 11);
+            Assert.Equal(expectedCenter.Latitude, vm.Wasserfoerderung.MapCenterLatitude, 6);
+            Assert.Equal(expectedCenter.Longitude, vm.Wasserfoerderung.MapCenterLongitude, 6);
+            Assert.Equal(11, vm.Wasserfoerderung.MapZoom);
+        }
+        finally
+        {
+            Directory.Delete(regionDir, recursive: true);
+        }
+    }
+
     // --- Network sharing (no Tailscale required) --------------------------------------------
 
     [Fact]
diff --git a/tests/LageBuch.AppLogic.Tests/WasserfoerderungViewModelTests.cs b/tests/LageBuch.AppLogic.Tests/WasserfoerderungViewModelTests.cs
index 6151f72..e32f15b 100644
--- a/tests/LageBuch.AppLogic.Tests/WasserfoerderungViewModelTests.cs
+++ b/tests/LageBuch.AppLogic.Tests/WasserfoerderungViewModelTests.cs
@@ -29,6 +29,7 @@ public IReadOnlyList<ElevationProfileSample> Sample(IReadOnlyList<GeoPoint> poly
     private sealed class FakeTileSource : IMapTileSource
     {
         public byte[]? GetTile(int zoom, int x, int y) => null;
+        public (int Zoom, int MinX, int MaxX, int MinY, int MaxY)? GetTileBounds() => null;
     }
 
     private static (LocalIncidentSession Session, FakeStore Store) NewSession()
@@ -59,6 +60,31 @@ public void Map_mode_is_available_when_both_samplers_are_configured()
         Assert.True(vm.IsMapModeAvailable);
     }
 
+    // #150 follow-up: with a real region pack, the map must open already centered on the
+    // configured Einsatzgebiet's tiles, not the unrelated hardcoded German fallback.
+    [Fact]
+    public void Map_opens_centered_on_the_given_initial_view_when_provided()
+    {
+        var (session, _) = NewSession();
+        var vm = new WasserfoerderungViewModel(session, () => { }, new FakeElevationSampler(), new FakeTileSource(),
+            initialMapCenter: new GeoPoint(48.19, 11.15), initialMapZoom: 11);
+
+        Assert.Equal(48.19, vm.MapCenterLatitude);
+        Assert.Equal(11.15, vm.MapCenterLongitude);
+        Assert.Equal(11, vm.MapZoom);
+    }
+
+    [Fact]
+    public void Map_falls_back_to_the_hardcoded_default_when_no_initial_view_is_given()
+    {
+        var (session, _) = NewSession();
+        var vm = new WasserfoerderungViewModel(session, () => { }, new FakeElevationSampler(), new FakeTileSource());
+
+        Assert.Equal(48.14, vm.MapCenterLatitude);
+        Assert.Equal(11.58, vm.MapCenterLongitude);
+        Assert.Equal(14, vm.MapZoom);
+    }
+
     [Fact]
     public void AddRoutePoint_appends_and_UndoLastRoutePoint_removes_the_last_one()
     {
diff --git a/tests/LageBuch.Persistence.Tests/MbTilesFileSourceTests.cs b/tests/LageBuch.Persistence.Tests/MbTilesFileSourceTests.cs
index c71dfbb..7afc399 100644
--- a/tests/LageBuch.Persistence.Tests/MbTilesFileSourceTests.cs
+++ b/tests/LageBuch.Persistence.Tests/MbTilesFileSourceTests.cs
@@ -61,4 +61,52 @@ public void GetTile_returns_null_for_a_zoom_the_file_does_not_have()
 
         Assert.Null(source.GetTile(zoom: 10, x: 1, y: 2));
     }
+
+    [Fact]
+    public void GetTileBounds_returns_null_when_the_file_has_no_tiles()
+    {
+        var emptyPath = Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid()}.mbtiles");
+        using (var cn = SqliteConnectionFactory.OpenReadWrite(emptyPath))
+        using (var create = cn.CreateCommand())
+        {
+            create.CommandText =
+                "CREATE TABLE tiles (zoom_level INTEGER, tile_column INTEGER, tile_row INTEGER, tile_data BLOB);";
+            create.ExecuteNonQuery();
+        }
+        try
+        {
+            var source = new MbTilesFileSource(emptyPath);
+
+            Assert.Null(source.GetTileBounds());
+        }
+        finally
+        {
+            File.Delete(emptyPath);
+        }
+    }
+
+    [Fact]
+    public void GetTileBounds_flips_stored_tms_rows_back_to_xyz_and_uses_the_lowest_zoom_present()
+    {
+        using (var cn = SqliteConnectionFactory.OpenReadWrite(_path))
+        {
+            // Zoom 3 (already seeded: XYZ x=1,y=2 -> TMS row 5) gets a second tile to give it a
+            // real column/row spread. Zoom 5 is also seeded, deliberately with a wider spread, to
+            // prove the lowest zoom present (3) wins, not the widest bounds.
+            InsertTile(cn, zoom: 3, column: 3, tmsRow: 1, data: new byte[] { 0xCD }); // XYZ (x=3,y=6)
+            InsertTile(cn, zoom: 5, column: 0, tmsRow: 0, data: new byte[] { 0xEE });
+            InsertTile(cn, zoom: 5, column: 31, tmsRow: 31, data: new byte[] { 0xFF });
+        }
+
+        var source = new MbTilesFileSource(_path);
+        var bounds = source.GetTileBounds();
+
+        Assert.NotNull(bounds);
+        Assert.Equal(3, bounds!.Value.Zoom);
+        Assert.Equal(1, bounds.Value.MinX);
+        Assert.Equal(3, bounds.Value.MaxX);
+        // Seeded tiles: XYZ (x=1,y=2) -> TMS row 5; and TMS row 1 at zoom 3 -> XYZ row (8-1-1)=6.
+        Assert.Equal(2, bounds.Value.MinY);
+        Assert.Equal(6, bounds.Value.MaxY);
+    }
 }

From b2bbafe1c1bbd107c1a60146cd49281ba46ae42c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Thomas=20M=C3=BCller?=
 <1005065+DeepDiver1975@users.noreply.github.com>
Date: Mon, 31 Aug 2026 17:58:44 +0200
Subject: [PATCH 4/4] fix(wasserfoerderung): add wheel/pinch zoom and overzoom
 to Karte mode (#170)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

* fix(wasserfoerderung): add wheel/pinch zoom and overzoom to Karte mode

Reported: "I cannot zoom into the map data" (initially proposed introducing
Mapsui). Investigated first: MapCanvasControl had no scroll-wheel or pinch
zoom at all -- only two tiny +/- buttons -- and WasserfoerderungViewModel's
MinZoom/MaxZoom were fixed constants (3/19) unrelated to what the
configured region's region.mbtiles actually contains. The real,
published Fürstenfeldbruck pack only renders z11-15; MapDrawing silently
skipped any missing tile, so clicking + past z15 or - past z11 showed a
blank canvas with zero feedback. Mapsui would fix this too, but at real
cost (this app's first third-party dependency, blocked on Android today
since it needs Avalonia >=11.3.1 and Android is pinned to 11.2.2, and a
much bigger rewrite than the bug needs) -- fixed the actual root cause
instead.

- IMapTileSource.GetMaxZoom() (MbTilesFileSource: SELECT MAX(zoom_level)).
- WasserfoerderungViewModel: per-region MinZoom (from the same
  GetTileBounds() the center fix already computes -- the region's own
  lowest rendered zoom), a new ChangeMapViewCommand(MapViewChange) command
  applying a wheel/pinch-driven view change, clamped to Min/MaxZoom.
- MapCanvasControl: OnPointerWheelChanged and a PinchGestureRecognizer
  handler, both zooming while keeping the gesture's focal point
  geographically stationary, routed through the new ViewChangedCommand
  (matching the control's existing PointClickedCommand/UndoRequestedCommand
  pattern rather than two-way property binding).
- MapDrawing.DrawTiles: when the exact tile is missing past the source's
  actual max zoom, draws a cropped ancestor tile from the max zoom instead
  ("overzoom" -- standard map-app behavior past native detail).

Verified against the real published Fürstenfeldbruck pack: scrolling in
6 levels past z15 shows a legible overzoomed view (not blank); scrolling
out clamps cleanly at z11 (the pack's real minimum), never blank.

Pinch-to-zoom's scale->zoom-delta math is unit-tested directly
(Avalonia.Headless has no touch/gesture simulation API to drive the full
gesture pipeline).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UwN31QccH98YV9eEc2bue2
Signed-off-by: Thomas Müller <1005065+DeepDiver1975@users.noreply.github.com>

* fix(wasserfoerderung): require Ctrl for wheel-zoom so plain scroll reaches the page

Root cause (systematic-debugging): the wheel-zoom just added in this same
branch unconditionally captured every wheel event over MapCanvasControl
(e.Handled = true, no modifier check). The map sits inside the
Wasserförderung tab's own ScrollViewer (WasserfoerderungView.axaml) at
360px tall — on a laptop where the window is short enough that the tab
needs to scroll, the cursor is very likely to land on the map while the
operator scrolls the page. Every such scroll got swallowed as a zoom
instead of reaching the ScrollViewer, and a laptop trackpad's rapid
wheel-delta stream during a single scroll swipe could zoom dozens of
levels in an instant — "renders it unreadable," exactly as reported.

Fix: gate wheel-zoom on Ctrl (KeyModifiers.Control), matching how most
embedded maps resolve this exact conflict (Leaflet, Google Maps embeds,
etc.). Plain scroll no longer sets e.Handled, so it bubbles to the
ScrollViewer as normal; Ctrl+scroll still zooms exactly as before,
keeping the cursor's geo point stationary. Pinch-to-zoom is unaffected —
a pinch gesture doesn't conflict with page-scroll the way a plain wheel
notch does.

Verified against the real published Fürstenfeldbruck pack: plain scroll
over the map no longer changes zoom; Ctrl+scroll still zooms in by one
level as designed.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UwN31QccH98YV9eEc2bue2
Signed-off-by: Thomas Müller <1005065+DeepDiver1975@users.noreply.github.com>

* fix(wasserfoerderung): add Ctrl+drag pan and a reset-view control to Karte mode

Root cause (systematic-debugging): cursor-anchored wheel/pinch zoom
shifts the map's center as a side effect (correct, by design), but
MapCanvasControl had no drag-to-pan at all and WasserfoerderungViewModel
never kept the region's initial center/zoom anywhere. Once the view
drifted away from the configured region (trivial after a few zooms near
an edge), there was no way back at all -- matching the report exactly.
Considered Mapsui again; same conclusion as before (first third-party
dependency, blocked on Android's Avalonia pin, much bigger than this
gap needs) -- added the missing controls to the existing hand-rolled map
instead.

- WasserfoerderungViewModel: stores the view it opened with and exposes
  a new ResetMapViewCommand ("ZENTRIEREN") that returns to it.
- MapCanvasControl: Ctrl+left-drag pans (moving the center opposite the
  drag direction, standard map UX), routed through the same
  ViewChangedCommand as wheel/pinch zoom. Reuses the Ctrl convention
  already established for zoom, so it never risks being confused with
  the primary plain-left-click-to-draw-a-route-point gesture.
- Added a small "Strg + Scrollen: Zoom / Strg + Ziehen: Verschieben"
  hint next to the new button, since both interactions are otherwise
  undiscoverable.

Also fixed a real regression these additions exposed: the extra button
and hint line made the tab tall enough to trigger the outer
ScrollViewer's (Fluent overlay-style) vertical scrollbar at window sizes
that previously fit without scrolling. That scrollbar renders on top of
-- not narrowing -- the content, so it silently swallowed clicks on the
map's own right edge. Fixed by reserving a right margin matching the
scrollbar's width, so real content never sits flush against that edge
regardless of what triggers scrolling in the future.

Verified against the real published Fürstenfeldbruck pack: drifting the
view to Berlin, then Ctrl+drag panning and clicking ZENTRIEREN, both
bring it back to Fürstenfeldbruck exactly.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01UwN31QccH98YV9eEc2bue2
Signed-off-by: Thomas Müller <1005065+DeepDiver1975@users.noreply.github.com>

---------

Signed-off-by: Thomas Müller <1005065+DeepDiver1975@users.noreply.github.com>
Co-authored-by: Claude Sonnet 5 <noreply@anthropic.com>
---
 .../Controls/MapCanvasControl.cs              | 162 +++++++++++++++++-
 .../Controls/MapDrawing.cs                    |  37 +++-
 .../Views/WasserfoerderungView.axaml          |  12 +-
 .../Services/MapViewChange.cs                 |   9 +
 .../ViewModels/IncidentWorkspaceViewModel.cs  |  13 +-
 .../ViewModels/WasserfoerderungViewModel.cs   |  57 +++++-
 .../Wasserfoerderung/IMapTileSource.cs        |   7 +
 .../Wasserfoerderung/MbTilesFileSource.cs     |  10 ++
 .../MapCanvasControlTests.cs                  | 160 ++++++++++++++++-
 .../MapDrawingTests.cs                        |  62 +++++++
 .../RouteOverviewRendererTests.cs             |   1 +
 .../WasserfoerderungTabRenderTests.cs         |   9 +
 .../IncidentWorkspaceViewModelTests.cs        |  52 ++++++
 .../WasserfoerderungViewModelTests.cs         |  66 +++++++
 .../MbTilesFileSourceTests.cs                 |  34 ++++
 15 files changed, 665 insertions(+), 26 deletions(-)
 create mode 100644 src/LageBuch.AppLogic/Services/MapViewChange.cs
 create mode 100644 tests/LageBuch.Acceptance.Tests/MapDrawingTests.cs

diff --git a/src/LageBuch.App.Shared/Controls/MapCanvasControl.cs b/src/LageBuch.App.Shared/Controls/MapCanvasControl.cs
index 1c0df3e..f831397 100644
--- a/src/LageBuch.App.Shared/Controls/MapCanvasControl.cs
+++ b/src/LageBuch.App.Shared/Controls/MapCanvasControl.cs
@@ -16,7 +16,9 @@ namespace LageBuch.App.Shared.Controls;
 /// <see cref="PointClickedCommand"/>), right-click undoes the last one (via
 /// <see cref="UndoRequestedCommand"/>); finishing the route is a separate, explicit action in the
 /// view (not a click gesture here), to avoid a fast double left-click accidentally placing two
-/// points and then finishing.
+/// points and then finishing. Ctrl+left-drag pans instead of adding a point (#150 follow-up) —
+/// reusing the same Ctrl convention as wheel/pinch zoom, so the primary click-to-draw gesture is
+/// never at risk of being misread as a pan.
 /// </summary>
 public sealed class MapCanvasControl : Control
 {
@@ -41,13 +43,35 @@ public sealed class MapCanvasControl : Control
     public static readonly StyledProperty<ICommand?> UndoRequestedCommandProperty =
         AvaloniaProperty.Register<MapCanvasControl, ICommand?>(nameof(UndoRequestedCommand));
 
+    public static readonly StyledProperty<ICommand?> ViewChangedCommandProperty =
+        AvaloniaProperty.Register<MapCanvasControl, ICommand?>(nameof(ViewChangedCommand));
+
     static MapCanvasControl()
     {
         AffectsRender<MapCanvasControl>(
             TileSourceProperty, CenterLatitudeProperty, CenterLongitudeProperty, ZoomProperty, RoutePointsProperty);
     }
 
-    public MapCanvasControl() => Focusable = true;
+    // Cumulative pinch scale since the gesture started (Avalonia.Input.Gestures.PinchEvent reports
+    // Scale relative to gesture start, not incrementally) -- reset in OnPinchEnded.
+    private double _pinchStartScale = 1.0;
+    private int _pinchStartZoom;
+
+    // Ctrl+drag panning state (#150 follow-up) -- null when not currently panning.
+    private Point? _panStartScreenPoint;
+    private double _panStartCenterLatitude;
+    private double _panStartCenterLongitude;
+
+    public MapCanvasControl()
+    {
+        Focusable = true;
+        // Avalonia.Input.Gestures (which raises PinchEvent/PinchEndedEvent) is internal; the
+        // documented public way to opt a control into pinch recognition is registering a
+        // recognizer here, then handling the routed events declared on InputElement itself.
+        GestureRecognizers.Add(new PinchGestureRecognizer());
+        AddHandler(PinchEvent, OnPinch);
+        AddHandler(PinchEndedEvent, OnPinchEnded);
+    }
 
     public IMapTileSource? TileSource
     {
@@ -93,6 +117,18 @@ public ICommand? UndoRequestedCommand
         set => SetValue(UndoRequestedCommandProperty, value);
     }
 
+    /// <summary>
+    /// Invoked with a <see cref="MapViewChange"/> from a wheel or pinch zoom (#150 follow-up).
+    /// A command rather than two-way binding CenterLatitude/CenterLongitude/Zoom, matching this
+    /// control's existing pattern for control->VM communication (<see cref="PointClickedCommand"/>,
+    /// <see cref="UndoRequestedCommand"/>) instead of changing those three properties' binding mode.
+    /// </summary>
+    public ICommand? ViewChangedCommand
+    {
+        get => GetValue(ViewChangedCommandProperty);
+        set => SetValue(ViewChangedCommandProperty, value);
+    }
+
     public override void Render(DrawingContext context)
     {
         base.Render(context);
@@ -127,13 +163,127 @@ protected override void OnPointerPressed(PointerPressedEventArgs e)
         if (!current.Properties.IsLeftButtonPressed)
             return;
 
-        var (centerX, centerY) = WebMercator.ToWorldPixel(new GeoPoint(CenterLatitude, CenterLongitude), Zoom);
-        var worldX = current.Position.X + centerX - Bounds.Width / 2;
-        var worldY = current.Position.Y + centerY - Bounds.Height / 2;
-        var geoPoint = WebMercator.ToGeo(worldX, worldY, Zoom);
+        if ((e.KeyModifiers & KeyModifiers.Control) != 0)
+        {
+            _panStartScreenPoint = current.Position;
+            _panStartCenterLatitude = CenterLatitude;
+            _panStartCenterLongitude = CenterLongitude;
+            e.Handled = true;
+            return;
+        }
+
+        var geoPoint = ScreenToGeo(current.Position);
 
         if (PointClickedCommand?.CanExecute(geoPoint) == true)
             PointClickedCommand.Execute(geoPoint);
         e.Handled = true;
     }
+
+    protected override void OnPointerMoved(PointerEventArgs e)
+    {
+        base.OnPointerMoved(e);
+
+        if (_panStartScreenPoint is not { } start)
+            return;
+        if (!e.GetCurrentPoint(this).Properties.IsLeftButtonPressed)
+        {
+            _panStartScreenPoint = null;
+            return;
+        }
+
+        var current = e.GetPosition(this);
+        var (startWorldX, startWorldY) = WebMercator.ToWorldPixel(
+            new GeoPoint(_panStartCenterLatitude, _panStartCenterLongitude), Zoom);
+        // Dragging reveals content on the opposite side, so the center moves against the drag.
+        var newWorldX = startWorldX - (current.X - start.X);
+        var newWorldY = startWorldY - (current.Y - start.Y);
+        var newCenter = WebMercator.ToGeo(newWorldX, newWorldY, Zoom);
+        var change = new MapViewChange(newCenter.Latitude, newCenter.Longitude, Zoom);
+
+        if (ViewChangedCommand?.CanExecute(change) == true)
+            ViewChangedCommand.Execute(change);
+        e.Handled = true;
+    }
+
+    protected override void OnPointerReleased(PointerReleasedEventArgs e)
+    {
+        base.OnPointerReleased(e);
+
+        if (_panStartScreenPoint is null)
+            return;
+        _panStartScreenPoint = null;
+        e.Handled = true;
+    }
+
+    private GeoPoint ScreenToGeo(Point screenPoint)
+    {
+        var (centerX, centerY) = WebMercator.ToWorldPixel(new GeoPoint(CenterLatitude, CenterLongitude), Zoom);
+        var worldX = screenPoint.X + centerX - Bounds.Width / 2;
+        var worldY = screenPoint.Y + centerY - Bounds.Height / 2;
+        return WebMercator.ToGeo(worldX, worldY, Zoom);
+    }
+
+    protected override void OnPointerWheelChanged(PointerWheelEventArgs e)
+    {
+        base.OnPointerWheelChanged(e);
+
+        // The map sits inside the Wasserförderung tab's own scrollable page (see
+        // WasserfoerderungView.axaml) -- a plain scroll must fall through to that ScrollViewer
+        // instead of zooming here, or the page becomes unscrollable wherever the cursor happens to
+        // land on the map, and a laptop trackpad's rapid wheel-delta stream during a scroll swipe
+        // zooms wildly, rendering the map unreadable (#150 follow-up). Ctrl+scroll to zoom matches
+        // the same convention most embedded maps use for exactly this reason.
+        if ((e.KeyModifiers & KeyModifiers.Control) == 0)
+            return;
+
+        var newZoom = Zoom + (e.Delta.Y > 0 ? 1 : -1);
+        ZoomAt(e.GetPosition(this), newZoom);
+        e.Handled = true;
+    }
+
+    // PinchEventArgs.Scale is cumulative relative to the gesture's start, not incremental between
+    // events, so the target zoom is derived fresh each time from the gesture's starting zoom.
+    private void OnPinch(object? sender, PinchEventArgs e)
+    {
+        if (_pinchStartZoom == 0)
+        {
+            _pinchStartScale = e.Scale;
+            _pinchStartZoom = Zoom;
+        }
+
+        var relativeScale = e.Scale / _pinchStartScale;
+        var newZoom = _pinchStartZoom + PinchScaleToZoomDelta(relativeScale);
+        var origin = new Point(e.ScaleOrigin.X * Bounds.Width, e.ScaleOrigin.Y * Bounds.Height);
+        ZoomAt(origin, newZoom);
+        e.Handled = true;
+    }
+
+    private void OnPinchEnded(object? sender, PinchEndedEventArgs e)
+    {
+        _pinchStartZoom = 0;
+        _pinchStartScale = 1.0;
+    }
+
+    /// <summary>Each zoom level doubles resolution, so a relative pinch scale of 2x is +1 zoom
+    /// level — public/static for direct unit testing since Avalonia.Headless cannot synthesize
+    /// pinch/touch input to drive this through a full gesture pipeline (#150 follow-up).</summary>
+    public static int PinchScaleToZoomDelta(double relativeScale) =>
+        (int)Math.Round(Math.Log2(Math.Max(relativeScale, 0.01)));
+
+    /// <summary>Zooms to <paramref name="newZoom"/> while keeping the geo point currently under
+    /// <paramref name="screenPoint"/> stationary on screen (#150 follow-up) — the standard
+    /// "zoom to cursor"/"zoom to pinch centroid" map UX.</summary>
+    private void ZoomAt(Point screenPoint, int newZoom)
+    {
+        var anchorGeo = ScreenToGeo(screenPoint);
+
+        var (anchorWorldX, anchorWorldY) = WebMercator.ToWorldPixel(anchorGeo, newZoom);
+        var newCenterX = anchorWorldX - (screenPoint.X - Bounds.Width / 2);
+        var newCenterY = anchorWorldY - (screenPoint.Y - Bounds.Height / 2);
+        var newCenter = WebMercator.ToGeo(newCenterX, newCenterY, newZoom);
+        var change = new MapViewChange(newCenter.Latitude, newCenter.Longitude, newZoom);
+
+        if (ViewChangedCommand?.CanExecute(change) == true)
+            ViewChangedCommand.Execute(change);
+    }
 }
diff --git a/src/LageBuch.App.Shared/Controls/MapDrawing.cs b/src/LageBuch.App.Shared/Controls/MapDrawing.cs
index 933e9d7..36146a1 100644
--- a/src/LageBuch.App.Shared/Controls/MapDrawing.cs
+++ b/src/LageBuch.App.Shared/Controls/MapDrawing.cs
@@ -39,25 +39,58 @@ private static void DrawTiles(
 
         var (firstTileX, firstTileY) = WebMercator.ToTileIndex(centerX - width / 2, centerY - height / 2);
         var (lastTileX, lastTileY) = WebMercator.ToTileIndex(centerX + width / 2, centerY + height / 2);
+        var sourceMaxZoom = tileSource.GetMaxZoom();
 
         for (var tx = firstTileX; tx <= lastTileX; tx++)
         {
             for (var ty = firstTileY; ty <= lastTileY; ty++)
             {
                 var bytes = tileSource.GetTile(zoom, tx, ty);
+                var sourceRect = (Rect?)null;
+
                 if (bytes is null)
-                    continue;
+                {
+                    if (ComputeOverzoomTile(zoom, tx, ty, sourceMaxZoom) is not { } overzoom)
+                        continue;
+                    bytes = tileSource.GetTile(overzoom.Zoom, overzoom.X, overzoom.Y);
+                    if (bytes is null)
+                        continue;
+                    sourceRect = overzoom.SourceRect;
+                }
 
                 using var stream = new MemoryStream(bytes);
                 using var bitmap = new Bitmap(stream);
                 var screenX = tx * WebMercator.TileSizePixels - centerX + width / 2;
                 var screenY = ty * WebMercator.TileSizePixels - centerY + height / 2;
                 var destRect = new Rect(screenX, screenY, WebMercator.TileSizePixels, WebMercator.TileSizePixels);
-                context.DrawImage(bitmap, new Rect(bitmap.Size), destRect);
+                context.DrawImage(bitmap, sourceRect ?? new Rect(bitmap.Size), destRect);
             }
         }
     }
 
+    /// <summary>
+    /// When the exact tile at (<paramref name="zoom"/>, <paramref name="x"/>, <paramref name="y"/>)
+    /// isn't available and <paramref name="zoom"/> is past the source's actual max detail
+    /// (<paramref name="sourceMaxZoom"/>), computes the ancestor tile at that max zoom and the
+    /// source sub-rect within it covering this tile's area — "overzoom": an increasingly blurry
+    /// but still-oriented view past the region's native detail, instead of drawing nothing
+    /// (#150 follow-up). Null when zoom is already within range, or the source's max is unknown
+    /// (an empty tile source).
+    /// </summary>
+    public static (int Zoom, int X, int Y, Rect SourceRect)? ComputeOverzoomTile(int zoom, int x, int y, int? sourceMaxZoom)
+    {
+        if (sourceMaxZoom is not { } maxZoom || zoom <= maxZoom)
+            return null;
+
+        var levels = zoom - maxZoom;
+        var ancestorX = x >> levels;
+        var ancestorY = y >> levels;
+        var subSize = (double)WebMercator.TileSizePixels / (1 << levels);
+        var subX = (x - (ancestorX << levels)) * subSize;
+        var subY = (y - (ancestorY << levels)) * subSize;
+        return (maxZoom, ancestorX, ancestorY, new Rect(subX, subY, subSize, subSize));
+    }
+
     private static void DrawRoute(
         DrawingContext context, IReadOnlyList<GeoPoint>? routePoints, int zoom, double centerX, double centerY,
         double width, double height)
diff --git a/src/LageBuch.App.Shared/Views/WasserfoerderungView.axaml b/src/LageBuch.App.Shared/Views/WasserfoerderungView.axaml
index 675cd64..49c9cce 100644
--- a/src/LageBuch.App.Shared/Views/WasserfoerderungView.axaml
+++ b/src/LageBuch.App.Shared/Views/WasserfoerderungView.axaml
@@ -23,9 +23,11 @@
     <!-- Everything below the header scrolls as one unit rather than fighting the header/each
          other for space when the window is short or narrow (#150 phase 2 regression: a fixed
          Height map plus stacked Bottom-docked panels overflowed a modest window and rendered on
-         top of the header buttons). -->
+         top of the header buttons). Right margin matches Fluent's overlay scrollbar width (#150
+         follow-up regression: once content needs scrolling, that scrollbar renders on top of, not
+         narrowing, the content, silently swallowing clicks on the map's own right edge). -->
     <ScrollViewer>
-      <StackPanel Spacing="16">
+      <StackPanel Spacing="16" Margin="0,0,16,0">
         <Border Background="#0C1119" BorderBrush="{StaticResource HairlineBrush}" BorderThickness="1"
                 CornerRadius="{StaticResource RadiusMd}" ClipToBounds="True" Height="260">
           <DataGrid x:Name="WasserfoerderungGrid" ItemsSource="{Binding Rows}" IsReadOnly="{Binding IsReadOnly}"
@@ -103,6 +105,8 @@
               </HeaderedContentControl>
               <Button Content="−" Width="32" Command="{Binding ZoomOutCommand}" VerticalAlignment="Bottom" Margin="0,0,0,1" />
               <Button Content="+" Width="32" Command="{Binding ZoomInCommand}" VerticalAlignment="Bottom" Margin="0,0,0,1" />
+              <Button Content="ZENTRIEREN" Command="{Binding ResetMapViewCommand}"
+                      VerticalAlignment="Bottom" Margin="0,0,0,1" />
               <Button Content="RÜCKGÄNGIG" Command="{Binding UndoLastRoutePointCommand}"
                       VerticalAlignment="Bottom" Margin="0,0,0,1" />
               <Button Content="ROUTE LÖSCHEN" Command="{Binding ClearRouteCommand}"
@@ -110,6 +114,7 @@
               <Button Classes="signal" Content="FERTIG" Command="{Binding FinishRouteCommand}"
                       VerticalAlignment="Bottom" Margin="0,0,0,1" />
             </WrapPanel>
+            <TextBlock Text="Strg + Scrollen: Zoom · Strg + Ziehen: Verschieben" Classes="secondary hint" />
             <TextBlock Text="{Binding ErrorMessage}" Foreground="#FF3D2E" Classes="hint"
                        IsVisible="{Binding ErrorMessage, Converter={x:Static ObjectConverters.IsNotNull}}" />
           </StackPanel>
@@ -125,7 +130,8 @@
               Zoom="{Binding MapZoom}"
               RoutePoints="{Binding DrawnRoutePoints}"
               PointClickedCommand="{Binding AddRoutePointCommand}"
-              UndoRequestedCommand="{Binding UndoLastRoutePointCommand}" />
+              UndoRequestedCommand="{Binding UndoLastRoutePointCommand}"
+              ViewChangedCommand="{Binding ChangeMapViewCommand}" />
         </Border>
       </StackPanel>
     </ScrollViewer>
diff --git a/src/LageBuch.AppLogic/Services/MapViewChange.cs b/src/LageBuch.AppLogic/Services/MapViewChange.cs
new file mode 100644
index 0000000..87fa3e3
--- /dev/null
+++ b/src/LageBuch.AppLogic/Services/MapViewChange.cs
@@ -0,0 +1,9 @@
+namespace LageBuch.AppLogic.Services;
+
+/// <summary>
+/// A wheel/pinch-driven map view change from <c>MapCanvasControl</c> (#150 follow-up) — the
+/// control->VM counterpart of <c>GeoPoint</c> for <c>WasserfoerderungViewModel.ChangeMapViewCommand</c>,
+/// living alongside <see cref="WebMercator"/> (not in a specific ViewModel or the Domain layer)
+/// since both the App.Shared control and the AppLogic view model need to reference it.
+/// </summary>
+public sealed record MapViewChange(double CenterLatitude, double CenterLongitude, int Zoom);
diff --git a/src/LageBuch.AppLogic/ViewModels/IncidentWorkspaceViewModel.cs b/src/LageBuch.AppLogic/ViewModels/IncidentWorkspaceViewModel.cs
index 8a31310..db34f86 100644
--- a/src/LageBuch.AppLogic/ViewModels/IncidentWorkspaceViewModel.cs
+++ b/src/LageBuch.AppLogic/ViewModels/IncidentWorkspaceViewModel.cs
@@ -242,7 +242,8 @@ private void BuildChildren()
         var (elevationSampler, tileSource) = BuildWasserfoerderungMapSources();
         var initialMapView = InitialMapViewFrom(tileSource);
         Wasserfoerderung = new WasserfoerderungViewModel(
-            _session, OnChanged, elevationSampler, tileSource, initialMapView?.Center, initialMapView?.Zoom);
+            _session, OnChanged, elevationSampler, tileSource,
+            initialMapView?.Center, initialMapView?.Zoom, initialMinZoom: initialMapView?.Zoom);
 
         Reminder?.Dispose();
         // The ILS reminder is autonomous, time-driven host-side logging (§ IsRemote) — a joined
@@ -287,10 +288,12 @@ private void BuildChildren()
     }
 
     /// <summary>
-    /// Derives the Karte mode's initial view from the tiles the configured region actually has,
-    /// rather than an unrelated fixed fallback (#150 follow-up) — a real per-Landkreis pack has no
-    /// tiles anywhere near <see cref="WasserfoerderungViewModel"/>'s hardcoded German default, so
-    /// without this the map opened blank until the operator happened to pan to the right area.
+    /// Derives the Karte mode's initial view — and, doubling as the region's lowest usable zoom
+    /// (<c>initialMinZoom</c>), the floor past which zooming out has nothing to show — from the
+    /// tiles the configured region actually has, rather than an unrelated fixed fallback (#150
+    /// follow-up). A real per-Landkreis pack has no tiles anywhere near
+    /// <see cref="WasserfoerderungViewModel"/>'s hardcoded German default and only ever renders a
+    /// narrow zoom band, so without this the map opened blank (or could be zoomed out to blank).
     /// </summary>
     private static (GeoPoint Center, int Zoom)? InitialMapViewFrom(IMapTileSource? tileSource)
     {
diff --git a/src/LageBuch.AppLogic/ViewModels/WasserfoerderungViewModel.cs b/src/LageBuch.AppLogic/ViewModels/WasserfoerderungViewModel.cs
index a277fc7..c8db13e 100644
--- a/src/LageBuch.AppLogic/ViewModels/WasserfoerderungViewModel.cs
+++ b/src/LageBuch.AppLogic/ViewModels/WasserfoerderungViewModel.cs
@@ -1,6 +1,7 @@
 using System.Collections.ObjectModel;
 using CommunityToolkit.Mvvm.ComponentModel;
 using CommunityToolkit.Mvvm.Input;
+using LageBuch.AppLogic.Services;
 using LageBuch.Domain.Wasserfoerderung;
 using LageBuch.Documents;
 using LageBuch.Persistence.Wasserfoerderung;
@@ -23,10 +24,18 @@ public sealed partial class WasserfoerderungViewModel : ObservableObject, IDispo
     private readonly IElevationSampler? _elevationSampler;
     private readonly IMapTileSource? _tileSource;
 
+    // The view the map opened with (region-derived center/zoom, or the hardcoded default) --
+    // kept so ResetMapViewCommand has a "home" to return to. Cursor-anchored wheel/pinch zoom
+    // shifts the center as a side effect, and there is no drag-to-pan, so without this a drifted
+    // view had no way back at all (#150 follow-up).
+    private readonly double _initialCenterLatitude;
+    private readonly double _initialCenterLongitude;
+    private readonly int _initialZoom;
+
     public WasserfoerderungViewModel(
         IIncidentSession session, Action onChanged,
         IElevationSampler? elevationSampler = null, IMapTileSource? tileSource = null,
-        GeoPoint? initialMapCenter = null, int? initialMapZoom = null)
+        GeoPoint? initialMapCenter = null, int? initialMapZoom = null, int? initialMinZoom = null)
     {
         _session = session;
         _onChanged = onChanged;
@@ -38,13 +47,20 @@ public WasserfoerderungViewModel(
         DrawnRoutePoints.CollectionChanged += (_, _) => UndoLastRoutePointCommand.NotifyCanExecuteChanged();
         DrawnRoutePoints.CollectionChanged += (_, _) => FinishRouteCommand.NotifyCanExecuteChanged();
 
+        if (initialMinZoom is { } minZoom)
+            _minZoom = minZoom;
+
         if (initialMapCenter is { } center)
         {
             _mapCenterLatitude = center.Latitude;
             _mapCenterLongitude = center.Longitude;
         }
         if (initialMapZoom is { } zoom)
-            _mapZoom = Math.Clamp(zoom, MinZoom, MaxZoom);
+            _mapZoom = Math.Clamp(zoom, _minZoom, MaxZoom);
+
+        _initialCenterLatitude = _mapCenterLatitude;
+        _initialCenterLongitude = _mapCenterLongitude;
+        _initialZoom = _mapZoom;
 
         _session.Changed += Sync;
         Sync();
@@ -67,12 +83,13 @@ public WasserfoerderungViewModel(
     [ObservableProperty]
     private bool _isMapMode;
 
-    // The constructor overrides these from the configured region's actual tile bounds
-    // (IncidentWorkspaceViewModel, #150 follow-up) whenever one is available; a region with no
-    // tiles at all (or no Einsatzgebiet configured) falls back to this fixed, reasonable German
-    // default and the operator pans from there. Bounds keep zooming out from going past a
-    // whole-continent view or in past building-level detail.
-    private const int MinZoom = 3;
+    // The constructor overrides MinZoom from the configured region's actual tile bounds
+    // (IncidentWorkspaceViewModel, #150 follow-up) whenever one is available — going lower than
+    // the region's own lowest rendered zoom has nothing to show. A region with no tiles at all
+    // (or no Einsatzgebiet configured) falls back to this fixed default. MaxZoom stays a generous
+    // constant regardless: zooming past a region's native detail is handled by MapDrawing's
+    // overzoom fallback (an increasingly blurry but still-oriented view), not blocked here.
+    private readonly int _minZoom = 3;
     private const int MaxZoom = 19;
 
     [ObservableProperty]
@@ -88,7 +105,29 @@ public WasserfoerderungViewModel(
     private void ZoomIn() => MapZoom = Math.Min(MaxZoom, MapZoom + 1);
 
     [RelayCommand]
-    private void ZoomOut() => MapZoom = Math.Max(MinZoom, MapZoom - 1);
+    private void ZoomOut() => MapZoom = Math.Max(_minZoom, MapZoom - 1);
+
+    /// <summary>Applies a wheel/pinch-driven view change from the map canvas (#150 follow-up) —
+    /// the control->VM counterpart of <see cref="AddRoutePointCommand"/>/<see cref="UndoLastRoutePointCommand"/>,
+    /// used instead of two-way property binding on CenterLatitude/CenterLongitude/Zoom.</summary>
+    [RelayCommand]
+    private void ChangeMapView(MapViewChange change)
+    {
+        MapCenterLatitude = change.CenterLatitude;
+        MapCenterLongitude = change.CenterLongitude;
+        MapZoom = Math.Clamp(change.Zoom, _minZoom, MaxZoom);
+    }
+
+    /// <summary>"Zentrieren": returns to the view the map opened with (#150 follow-up) — the only
+    /// way back once cursor-anchored zooming has drifted the center away from the region, since
+    /// there is no drag-to-pan.</summary>
+    [RelayCommand]
+    private void ResetMapView()
+    {
+        MapCenterLatitude = _initialCenterLatitude;
+        MapCenterLongitude = _initialCenterLongitude;
+        MapZoom = _initialZoom;
+    }
 
     [RelayCommand]
     private void AddRoutePoint(GeoPoint point) => DrawnRoutePoints.Add(point);
diff --git a/src/LageBuch.Persistence/Wasserfoerderung/IMapTileSource.cs b/src/LageBuch.Persistence/Wasserfoerderung/IMapTileSource.cs
index 8b6d5ff..138aa35 100644
--- a/src/LageBuch.Persistence/Wasserfoerderung/IMapTileSource.cs
+++ b/src/LageBuch.Persistence/Wasserfoerderung/IMapTileSource.cs
@@ -12,4 +12,11 @@ public interface IMapTileSource
     /// tiles actually present, instead of an unrelated fixed fallback (#150 follow-up).
     /// </summary>
     (int Zoom, int MinX, int MaxX, int MinY, int MaxY)? GetTileBounds();
+
+    /// <summary>
+    /// The highest zoom level this source has any tiles at, or null when it has none — lets a
+    /// caller detect when a requested zoom is past the region's native detail and fall back to
+    /// overzooming an ancestor tile instead of drawing nothing (#150 follow-up).
+    /// </summary>
+    int? GetMaxZoom();
 }
diff --git a/src/LageBuch.Persistence/Wasserfoerderung/MbTilesFileSource.cs b/src/LageBuch.Persistence/Wasserfoerderung/MbTilesFileSource.cs
index d8b4e40..4f4735a 100644
--- a/src/LageBuch.Persistence/Wasserfoerderung/MbTilesFileSource.cs
+++ b/src/LageBuch.Persistence/Wasserfoerderung/MbTilesFileSource.cs
@@ -49,4 +49,14 @@ public sealed class MbTilesFileSource(string mbtilesFilePath) : IMapTileSource
         var maxRow = (1 << zoom) - 1;
         return (zoom, minX, maxX, maxRow - maxTmsRow, maxRow - minTmsRow);
     }
+
+    public int? GetMaxZoom()
+    {
+        using var cn = SqliteConnectionFactory.OpenReadOnly(mbtilesFilePath);
+        using var cmd = cn.CreateCommand();
+        cmd.CommandText = "SELECT MAX(zoom_level) FROM tiles;";
+
+        var result = cmd.ExecuteScalar();
+        return result is long max ? (int)max : null;
+    }
 }
diff --git a/tests/LageBuch.Acceptance.Tests/MapCanvasControlTests.cs b/tests/LageBuch.Acceptance.Tests/MapCanvasControlTests.cs
index 7521849..b8189f9 100644
--- a/tests/LageBuch.Acceptance.Tests/MapCanvasControlTests.cs
+++ b/tests/LageBuch.Acceptance.Tests/MapCanvasControlTests.cs
@@ -7,6 +7,7 @@
 using Avalonia.Threading;
 using CommunityToolkit.Mvvm.Input;
 using LageBuch.App.Shared.Controls;
+using LageBuch.AppLogic.Services;
 using LageBuch.Domain.Wasserfoerderung;
 using LageBuch.Persistence.Wasserfoerderung;
 
@@ -19,6 +20,7 @@ private sealed class FakeTileSource : IMapTileSource
     {
         public byte[]? GetTile(int zoom, int x, int y) => SolidTilePng.Bytes;
         public (int Zoom, int MinX, int MaxX, int MinY, int MaxY)? GetTileBounds() => null;
+        public int? GetMaxZoom() => null;
     }
 
     // A real, decodable 4x4 solid-color PNG (built once via Avalonia's own encoder) so
@@ -39,7 +41,8 @@ private static byte[] Build()
     }
 
     private static (Window Window, MapCanvasControl Control) ShowControl(
-        IReadOnlyList<GeoPoint>? routePoints = null, RelayCommand<GeoPoint>? onPointClicked = null, RelayCommand? onUndo = null)
+        IReadOnlyList<GeoPoint>? routePoints = null, RelayCommand<GeoPoint>? onPointClicked = null,
+        RelayCommand? onUndo = null, RelayCommand<MapViewChange>? onViewChanged = null)
     {
         var control = new MapCanvasControl
         {
@@ -52,6 +55,7 @@ private static (Window Window, MapCanvasControl Control) ShowControl(
             RoutePoints = routePoints,
             PointClickedCommand = onPointClicked,
             UndoRequestedCommand = onUndo,
+            ViewChangedCommand = onViewChanged,
         };
         var window = new Window { Content = control, Width = 400, Height = 300 };
         window.Show();
@@ -69,6 +73,112 @@ public void Renders_tiles_and_a_route_without_throwing()
         Assert.NotNull(frame);
     }
 
+    // #150 follow-up: zooming past a tile source's actual max detail must still draw something
+    // (an overzoomed ancestor tile), not silently skip the tile.
+    private sealed class MaxZoomSpyTileSource : IMapTileSource
+    {
+        public readonly List<(int Zoom, int X, int Y)> Requested = new();
+
+        public byte[]? GetTile(int zoom, int x, int y)
+        {
+            Requested.Add((zoom, x, y));
+            return zoom <= 15 ? SolidTilePng.Bytes : null;
+        }
+
+        public (int Zoom, int MinX, int MaxX, int MinY, int MaxY)? GetTileBounds() => null;
+        public int? GetMaxZoom() => 15;
+    }
+
+    [AvaloniaFact]
+    public void Zooming_past_the_sources_max_detail_falls_back_to_the_overzoomed_ancestor_tile()
+    {
+        var spy = new MaxZoomSpyTileSource();
+        var control = new MapCanvasControl
+        {
+            Width = 256,
+            Height = 256,
+            TileSource = spy,
+            CenterLatitude = 48.0,
+            CenterLongitude = 11.0,
+            Zoom = 17,
+        };
+        var window = new Window { Content = control, Width = 256, Height = 256 };
+        window.Show();
+        Dispatcher.UIThread.RunJobs();
+
+        using var frame = window.CaptureRenderedFrame();
+
+        Assert.NotNull(frame);
+        Assert.Contains(spy.Requested, r => r.Zoom == 17); // tried the exact tile first
+        Assert.Contains(spy.Requested, r => r.Zoom == 15); // fell back to the max-zoom ancestor
+    }
+
+    // #150 follow-up: scroll-wheel zoom was entirely missing before this fix -- only two tiny
+    // +/- buttons existed. Ctrl+scrolling up over the control's exact center must zoom in by one
+    // level while keeping that same geo point (the center) stationary, i.e. center unchanged.
+    [AvaloniaFact]
+    public void CtrlScrolling_up_zooms_in_by_one_level_keeping_the_cursors_geo_point_stationary()
+    {
+        MapViewChange? change = null;
+        var command = new RelayCommand<MapViewChange>(c => change = c);
+        var (window, control) = ShowControl(onViewChanged: command);
+
+        var center = control.TranslatePoint(new Point(200, 150), window)!.Value;
+        window.MouseWheel(center, new Vector(0, 1), RawInputModifiers.Control);
+
+        Assert.NotNull(change);
+        Assert.Equal(16, change!.Zoom);
+        Assert.Equal(48.0, change.CenterLatitude, 3);
+        Assert.Equal(11.0, change.CenterLongitude, 3);
+    }
+
+    [AvaloniaFact]
+    public void CtrlScrolling_down_zooms_out_by_one_level()
+    {
+        MapViewChange? change = null;
+        var command = new RelayCommand<MapViewChange>(c => change = c);
+        var (window, control) = ShowControl(onViewChanged: command);
+
+        var center = control.TranslatePoint(new Point(200, 150), window)!.Value;
+        window.MouseWheel(center, new Vector(0, -1), RawInputModifiers.Control);
+
+        Assert.NotNull(change);
+        Assert.Equal(14, change!.Zoom);
+    }
+
+    // #150 follow-up regression fix: the map sits inside the tab's outer ScrollViewer (see
+    // WasserfoerderungView.axaml) -- plain scroll (no Ctrl) must NOT be swallowed as a zoom, or
+    // the whole page becomes unscrollable wherever the cursor happens to be over the map, and a
+    // laptop trackpad's rapid wheel-delta stream during a scroll swipe zooms wildly, rendering the
+    // map unreadable.
+    [AvaloniaFact]
+    public void Plain_scrolling_without_ctrl_does_not_zoom()
+    {
+        MapViewChange? change = null;
+        var command = new RelayCommand<MapViewChange>(c => change = c);
+        var (window, control) = ShowControl(onViewChanged: command);
+
+        var center = control.TranslatePoint(new Point(200, 150), window)!.Value;
+        window.MouseWheel(center, new Vector(0, 1));
+        window.MouseWheel(center, new Vector(0, -1));
+
+        Assert.Null(change);
+        Assert.Equal(15, control.Zoom);
+    }
+
+    // #150 follow-up: pinch-to-zoom (primarily for Android touch) can't be driven through
+    // Avalonia.Headless (no touch/gesture simulation API exists there), so its scale->zoom-delta
+    // math is unit-tested directly instead.
+    [Theory]
+    [InlineData(1.0, 0)]     // no pinch movement -> no zoom change
+    [InlineData(2.0, 1)]     // pinch-out to double size -> zoom in one level
+    [InlineData(4.0, 2)]     // quadruple size -> zoom in two levels
+    [InlineData(0.5, -1)]    // pinch-in to half size -> zoom out one level
+    [InlineData(1.4, 0)]     // small movement rounds back to no change
+    [InlineData(1.6, 1)]     // past the rounding midpoint commits to the next level
+    public void PinchScaleToZoomDelta_rounds_to_the_nearest_zoom_level(double relativeScale, int expectedDelta)
+        => Assert.Equal(expectedDelta, MapCanvasControl.PinchScaleToZoomDelta(relativeScale));
+
     [AvaloniaFact]
     public void Left_click_at_the_controls_center_invokes_PointClicked_with_the_center_geo_point()
     {
@@ -101,4 +211,52 @@ public void Right_click_invokes_UndoRequested_instead_of_PointClicked()
         Assert.Equal(1, undoCount);
         Assert.Null(clicked);
     }
+
+    // #150 follow-up: cursor-anchored zoom drifts the center with no drag-to-pan to correct it,
+    // so once the view drifted off the region entirely there was no way back. Ctrl+drag pans
+    // (moving the map opposite the drag direction, standard map UX), without also adding a route
+    // point (which plain left-click still does).
+    [AvaloniaFact]
+    public void CtrlDrag_pans_the_map_and_does_not_add_a_route_point()
+    {
+        GeoPoint? clicked = null;
+        MapViewChange? change = null;
+        var pointCommand = new RelayCommand<GeoPoint>(p => clicked = p);
+        var viewCommand = new RelayCommand<MapViewChange>(c => change = c);
+        var (window, control) = ShowControl(onPointClicked: pointCommand, onViewChanged: viewCommand);
+
+        var start = control.TranslatePoint(new Point(200, 150), window)!.Value;
+        var end = control.TranslatePoint(new Point(240, 150), window)!.Value; // drag 40px right
+
+        window.MouseDown(start, MouseButton.Left, RawInputModifiers.Control);
+        window.MouseMove(end, RawInputModifiers.LeftMouseButton);
+        window.MouseUp(end, MouseButton.Left);
+
+        Assert.Null(clicked); // dragging must not also place a route point
+        Assert.NotNull(change);
+        Assert.Equal(15, change!.Zoom); // pan alone leaves zoom untouched
+        // Dragging right reveals content that was to the left -- the center's longitude decreases.
+        Assert.True(change.CenterLongitude < 11.0, $"Expected longitude to decrease, was {change.CenterLongitude}");
+        Assert.Equal(48.0, change.CenterLatitude, 3); // purely horizontal drag -> latitude unchanged
+    }
+
+    [AvaloniaFact]
+    public void Plain_drag_without_ctrl_still_adds_a_route_point_and_does_not_pan()
+    {
+        GeoPoint? clicked = null;
+        MapViewChange? change = null;
+        var pointCommand = new RelayCommand<GeoPoint>(p => clicked = p);
+        var viewCommand = new RelayCommand<MapViewChange>(c => change = c);
+        var (window, control) = ShowControl(onPointClicked: pointCommand, onViewChanged: viewCommand);
+
+        var start = control.TranslatePoint(new Point(200, 150), window)!.Value;
+        var end = control.TranslatePoint(new Point(240, 150), window)!.Value;
+
+        window.MouseDown(start, MouseButton.Left);
+        window.MouseMove(end);
+        window.MouseUp(end, MouseButton.Left);
+
+        Assert.NotNull(clicked); // existing click-to-add-point behaviour is unaffected
+        Assert.Null(change); // no Ctrl held -> no pan
+    }
 }
diff --git a/tests/LageBuch.Acceptance.Tests/MapDrawingTests.cs b/tests/LageBuch.Acceptance.Tests/MapDrawingTests.cs
new file mode 100644
index 0000000..874bac0
--- /dev/null
+++ b/tests/LageBuch.Acceptance.Tests/MapDrawingTests.cs
@@ -0,0 +1,62 @@
+using Avalonia;
+using LageBuch.App.Shared.Controls;
+
+namespace LageBuch.Acceptance.Tests;
+
+// #150 follow-up: overzoom -- when a requested zoom is past the configured region's actual max
+// rendered detail, MapDrawing falls back to the nearest ancestor tile it does have instead of
+// drawing nothing, matching every other map app's "blurry but oriented" behavior past native zoom.
+public class MapDrawingTests
+{
+    [Fact]
+    public void ComputeOverzoomTile_returns_null_when_zoom_is_within_the_sources_range()
+    {
+        Assert.Null(MapDrawing.ComputeOverzoomTile(zoom: 14, x: 100, y: 200, sourceMaxZoom: 15));
+        Assert.Null(MapDrawing.ComputeOverzoomTile(zoom: 15, x: 100, y: 200, sourceMaxZoom: 15));
+    }
+
+    [Fact]
+    public void ComputeOverzoomTile_returns_null_when_the_source_has_no_known_max_zoom()
+    {
+        Assert.Null(MapDrawing.ComputeOverzoomTile(zoom: 20, x: 100, y: 200, sourceMaxZoom: null));
+    }
+
+    [Fact]
+    public void ComputeOverzoomTile_finds_the_direct_parent_one_level_up()
+    {
+        // Tile (x=100,y=200) at z16 is the top-left quadrant of its z15 parent (x=50,y=100).
+        var overzoom = MapDrawing.ComputeOverzoomTile(zoom: 16, x: 100, y: 200, sourceMaxZoom: 15);
+
+        Assert.NotNull(overzoom);
+        Assert.Equal(15, overzoom!.Value.Zoom);
+        Assert.Equal(50, overzoom.Value.X);
+        Assert.Equal(100, overzoom.Value.Y);
+        Assert.Equal(new Rect(0, 0, 128, 128), overzoom.Value.SourceRect);
+    }
+
+    [Fact]
+    public void ComputeOverzoomTile_picks_the_correct_quadrant_for_an_odd_tile_index()
+    {
+        // Tile (x=101,y=201) at z16 is the bottom-right quadrant of the same z15 parent (x=50,y=100).
+        var overzoom = MapDrawing.ComputeOverzoomTile(zoom: 16, x: 101, y: 201, sourceMaxZoom: 15);
+
+        Assert.NotNull(overzoom);
+        Assert.Equal(15, overzoom!.Value.Zoom);
+        Assert.Equal(50, overzoom.Value.X);
+        Assert.Equal(100, overzoom.Value.Y);
+        Assert.Equal(new Rect(128, 128, 128, 128), overzoom.Value.SourceRect);
+    }
+
+    [Fact]
+    public void ComputeOverzoomTile_climbs_multiple_levels_when_zoomed_in_further()
+    {
+        // Two levels up (z17 -> z15): a quarter-size crop of the ancestor tile.
+        var overzoom = MapDrawing.ComputeOverzoomTile(zoom: 17, x: 400, y: 800, sourceMaxZoom: 15);
+
+        Assert.NotNull(overzoom);
+        Assert.Equal(15, overzoom!.Value.Zoom);
+        Assert.Equal(100, overzoom.Value.X);
+        Assert.Equal(200, overzoom.Value.Y);
+        Assert.Equal(new Rect(0, 0, 64, 64), overzoom.Value.SourceRect);
+    }
+}
diff --git a/tests/LageBuch.Acceptance.Tests/RouteOverviewRendererTests.cs b/tests/LageBuch.Acceptance.Tests/RouteOverviewRendererTests.cs
index 0097fae..0e54d6f 100644
--- a/tests/LageBuch.Acceptance.Tests/RouteOverviewRendererTests.cs
+++ b/tests/LageBuch.Acceptance.Tests/RouteOverviewRendererTests.cs
@@ -13,6 +13,7 @@ private sealed class EmptyTileSource : IMapTileSource
     {
         public byte[]? GetTile(int zoom, int x, int y) => null;
         public (int Zoom, int MinX, int MaxX, int MinY, int MaxY)? GetTileBounds() => null;
+        public int? GetMaxZoom() => null;
     }
 
     [AvaloniaFact]
diff --git a/tests/LageBuch.Acceptance.Tests/WasserfoerderungTabRenderTests.cs b/tests/LageBuch.Acceptance.Tests/WasserfoerderungTabRenderTests.cs
index adda73b..64cf659 100644
--- a/tests/LageBuch.Acceptance.Tests/WasserfoerderungTabRenderTests.cs
+++ b/tests/LageBuch.Acceptance.Tests/WasserfoerderungTabRenderTests.cs
@@ -124,6 +124,15 @@ public void Karte_mode_draws_a_route_and_finishing_it_adds_a_route_based_leitung
             Dispatcher.UIThread.RunJobs();
             Assert.True(vm.Wasserfoerderung.IsMapMode);
 
+            // #150 follow-up regression: at this window size the tab's content is tall enough
+            // that the outer ScrollViewer shows its (Fluent overlay-style) vertical scrollbar,
+            // which renders on top of -- not narrowing -- the content. p2 deliberately clicks
+            // right at the map's own edge to prove that scrollbar no longer swallows the click
+            // (WasserfoerderungView.axaml reserves a matching right margin for exactly this).
+            var scrollBar = view.GetVisualDescendants().OfType<ScrollBar>()
+                .Single(sb => sb.Orientation == Avalonia.Layout.Orientation.Vertical && sb.IsVisible);
+            Assert.True(scrollBar.Bounds.Width > 0, "Test premise: a visible vertical scrollbar must exist here.");
+
             var canvas = view.GetVisualDescendants().OfType<MapCanvasControl>().Single();
             var p1 = canvas.TranslatePoint(new Point(10, 10), window)!.Value;
             var p2 = canvas.TranslatePoint(new Point(canvas.Bounds.Width - 10, 10), window)!.Value;
diff --git a/tests/LageBuch.AppLogic.Tests/IncidentWorkspaceViewModelTests.cs b/tests/LageBuch.AppLogic.Tests/IncidentWorkspaceViewModelTests.cs
index ca247e3..c0f4949 100644
--- a/tests/LageBuch.AppLogic.Tests/IncidentWorkspaceViewModelTests.cs
+++ b/tests/LageBuch.AppLogic.Tests/IncidentWorkspaceViewModelTests.cs
@@ -126,6 +126,58 @@ public void Wasserfoerderung_map_opens_centered_on_the_configured_regions_tiles(
         }
     }
 
+    // #150 follow-up: zooming out must stop at the configured region's own lowest rendered zoom
+    // (there's nothing to show below it), not the unrelated fixed constant (3) — that constant
+    // would let the operator zoom out to a blank map for any per-Landkreis pack, which only ever
+    // renders a narrow zoom band.
+    [Fact]
+    public void Wasserfoerderung_map_cannot_zoom_out_past_the_configured_regions_lowest_zoom()
+    {
+        var regionDir = Path.Combine(Path.GetTempPath(), $"region-{Guid.NewGuid():N}");
+        Directory.CreateDirectory(regionDir);
+        try
+        {
+            using (var writer = new BinaryWriter(File.Create(Path.Combine(regionDir, "region.dem"))))
+            {
+                writer.Write("FWDM"u8.ToArray());
+                writer.Write(1);
+                writer.Write(48.2);
+                writer.Write(11.4);
+                writer.Write(0.01);
+                writer.Write(10);
+                writer.Write(10);
+                for (var i = 0; i < 100; i++)
+                    writer.Write((short)500);
+            }
+
+            using (var cn = LageBuch.Persistence.Sqlite.SqliteConnectionFactory.OpenReadWrite(Path.Combine(regionDir, "region.mbtiles")))
+            using (var cmd = cn.CreateCommand())
+            {
+                cmd.CommandText =
+                    "CREATE TABLE tiles (zoom_level INTEGER, tile_column INTEGER, tile_row INTEGER, tile_data BLOB);";
+                cmd.ExecuteNonQuery();
+                cmd.CommandText = "INSERT INTO tiles VALUES (11, 1085, 1339, X'00');";
+                cmd.ExecuteNonQuery();
+            }
+
+            var clock = new FixedClock(T0);
+            var session = LocalIncidentSession.StartNew(new FakeStore(), clock, new SessionOperator("Müller"),
+                "/x.fwincident", Array.Empty<(string, bool)>(), Array.Empty<(string, bool)>());
+            var masterData = Md() with { Einsatzgebiet = new Einsatzgebiet("Testgebiet", regionDir) };
+            var vm = new IncidentWorkspaceViewModel(session, clock, new FakeTicker(), masterData,
+                new FakeDialogs(), new FakeAlarmService(), new NoopIncidentHostController());
+
+            for (var i = 0; i < 20; i++)
+                vm.Wasserfoerderung.ZoomOutCommand.Execute(null);
+
+            Assert.Equal(11, vm.Wasserfoerderung.MapZoom);
+        }
+        finally
+        {
+            Directory.Delete(regionDir, recursive: true);
+        }
+    }
+
     // --- Network sharing (no Tailscale required) --------------------------------------------
 
     [Fact]
diff --git a/tests/LageBuch.AppLogic.Tests/WasserfoerderungViewModelTests.cs b/tests/LageBuch.AppLogic.Tests/WasserfoerderungViewModelTests.cs
index e32f15b..a876dbd 100644
--- a/tests/LageBuch.AppLogic.Tests/WasserfoerderungViewModelTests.cs
+++ b/tests/LageBuch.AppLogic.Tests/WasserfoerderungViewModelTests.cs
@@ -1,3 +1,4 @@
+using LageBuch.AppLogic.Services;
 using LageBuch.AppLogic.ViewModels;
 using LageBuch.Domain;
 using LageBuch.Domain.Wasserfoerderung;
@@ -30,6 +31,7 @@ private sealed class FakeTileSource : IMapTileSource
     {
         public byte[]? GetTile(int zoom, int x, int y) => null;
         public (int Zoom, int MinX, int MaxX, int MinY, int MaxY)? GetTileBounds() => null;
+        public int? GetMaxZoom() => null;
     }
 
     private static (LocalIncidentSession Session, FakeStore Store) NewSession()
@@ -85,6 +87,70 @@ public void Map_falls_back_to_the_hardcoded_default_when_no_initial_view_is_give
         Assert.Equal(14, vm.MapZoom);
     }
 
+    // #150 follow-up: wheel/pinch zoom on the map canvas routes through this command instead of
+    // two-way property binding (matching PointClickedCommand/UndoRequestedCommand's existing
+    // control->VM pattern), so it must apply the new view exactly as given.
+    [Fact]
+    public void ChangeMapView_applies_the_given_center_and_zoom()
+    {
+        var (session, _) = NewSession();
+        var vm = new WasserfoerderungViewModel(session, () => { }, new FakeElevationSampler(), new FakeTileSource());
+
+        vm.ChangeMapViewCommand.Execute(new MapViewChange(48.2, 11.3, 13));
+
+        Assert.Equal(48.2, vm.MapCenterLatitude);
+        Assert.Equal(11.3, vm.MapCenterLongitude);
+        Assert.Equal(13, vm.MapZoom);
+    }
+
+    [Fact]
+    public void ChangeMapView_clamps_zoom_to_the_configured_min_and_max()
+    {
+        var (session, _) = NewSession();
+        var vm = new WasserfoerderungViewModel(session, () => { }, new FakeElevationSampler(), new FakeTileSource(),
+            initialMinZoom: 11);
+
+        vm.ChangeMapViewCommand.Execute(new MapViewChange(48.2, 11.3, 5));
+        Assert.Equal(11, vm.MapZoom);
+
+        vm.ChangeMapViewCommand.Execute(new MapViewChange(48.2, 11.3, 25));
+        Assert.Equal(19, vm.MapZoom);
+    }
+
+    // #150 follow-up: with no drag-to-pan and no way back, zooming (cursor-anchored, so it shifts
+    // the center) could drift the operator's view off the region's tiles entirely with no way to
+    // recover. ResetMapViewCommand must restore the view exactly where it started.
+    [Fact]
+    public void ResetMapView_restores_the_initial_center_and_zoom_after_drifting_away()
+    {
+        var (session, _) = NewSession();
+        var vm = new WasserfoerderungViewModel(session, () => { }, new FakeElevationSampler(), new FakeTileSource(),
+            initialMapCenter: new GeoPoint(48.19, 11.15), initialMapZoom: 13, initialMinZoom: 11);
+
+        vm.ChangeMapViewCommand.Execute(new MapViewChange(50.0, 20.0, 19));
+        Assert.Equal(50.0, vm.MapCenterLatitude);
+
+        vm.ResetMapViewCommand.Execute(null);
+
+        Assert.Equal(48.19, vm.MapCenterLatitude);
+        Assert.Equal(11.15, vm.MapCenterLongitude);
+        Assert.Equal(13, vm.MapZoom);
+    }
+
+    [Fact]
+    public void ResetMapView_restores_the_hardcoded_default_when_no_initial_view_was_given()
+    {
+        var (session, _) = NewSession();
+        var vm = new WasserfoerderungViewModel(session, () => { }, new FakeElevationSampler(), new FakeTileSource());
+
+        vm.ChangeMapViewCommand.Execute(new MapViewChange(50.0, 20.0, 19));
+        vm.ResetMapViewCommand.Execute(null);
+
+        Assert.Equal(48.14, vm.MapCenterLatitude);
+        Assert.Equal(11.58, vm.MapCenterLongitude);
+        Assert.Equal(14, vm.MapZoom);
+    }
+
     [Fact]
     public void AddRoutePoint_appends_and_UndoLastRoutePoint_removes_the_last_one()
     {
diff --git a/tests/LageBuch.Persistence.Tests/MbTilesFileSourceTests.cs b/tests/LageBuch.Persistence.Tests/MbTilesFileSourceTests.cs
index 7afc399..210641c 100644
--- a/tests/LageBuch.Persistence.Tests/MbTilesFileSourceTests.cs
+++ b/tests/LageBuch.Persistence.Tests/MbTilesFileSourceTests.cs
@@ -109,4 +109,38 @@ public void GetTileBounds_flips_stored_tms_rows_back_to_xyz_and_uses_the_lowest_
         Assert.Equal(2, bounds.Value.MinY);
         Assert.Equal(6, bounds.Value.MaxY);
     }
+
+    [Fact]
+    public void GetMaxZoom_returns_null_when_the_file_has_no_tiles()
+    {
+        var emptyPath = Path.Combine(Path.GetTempPath(), $"{Guid.NewGuid()}.mbtiles");
+        using (var cn = SqliteConnectionFactory.OpenReadWrite(emptyPath))
+        using (var create = cn.CreateCommand())
+        {
+            create.CommandText =
+                "CREATE TABLE tiles (zoom_level INTEGER, tile_column INTEGER, tile_row INTEGER, tile_data BLOB);";
+            create.ExecuteNonQuery();
+        }
+        try
+        {
+            var source = new MbTilesFileSource(emptyPath);
+
+            Assert.Null(source.GetMaxZoom());
+        }
+        finally
+        {
+            File.Delete(emptyPath);
+        }
+    }
+
+    [Fact]
+    public void GetMaxZoom_returns_the_highest_zoom_level_present()
+    {
+        using (var cn = SqliteConnectionFactory.OpenReadWrite(_path))
+            InsertTile(cn, zoom: 7, column: 0, tmsRow: 0, data: new byte[] { 0x11 });
+
+        var source = new MbTilesFileSource(_path);
+
+        Assert.Equal(7, source.GetMaxZoom());
+    }
 }