From 205a520708246d2a8a9689f48e9cb62875e7c5d7 Mon Sep 17 00:00:00 2001
From: livio <livio.merola@gmail.com>
Date: Thu, 24 Sep 2026 17:21:25 +0200
Subject: [PATCH] Rilascia gestione completa progetti e aggiornamenti 0.4.0

---
 Components/Pages/Home.razor       | 365 +++++++++++++++++-
 LMEMappeCatastaliApp.csproj       |   5 +-
 MauiProgram.cs                    |   2 +
 README.md                         |  27 +-
 Services/AppUpdateService.cs      |  44 +++
 Services/CloudSyncService.cs      |  54 +++
 Services/MapExportService.cs      |  73 +++-
 Services/ProjectStorageService.cs |  60 ++-
 wwwroot/css/app.css               | 194 +++++++++-
 wwwroot/js/lme-map.js             | 607 ++++++++++++++++++++++++++++--
 10 files changed, 1366 insertions(+), 65 deletions(-)
 create mode 100644 Services/AppUpdateService.cs
 create mode 100644 Services/CloudSyncService.cs

diff --git a/Components/Pages/Home.razor b/Components/Pages/Home.razor
index 66b2291..0a9b7ab 100644
--- a/Components/Pages/Home.razor
+++ b/Components/Pages/Home.razor
@@ -8,6 +8,8 @@
 @inject AzureMapsService AzureMapsService
 @inject ProjectStorageService ProjectStorageService
 @inject MapExportService MapExportService
+@inject CloudSyncService CloudSyncService
+@inject AppUpdateService AppUpdateService
 @implements IAsyncDisposable
 
 <PageTitle>LME Mappe Catastali</PageTitle>
@@ -19,9 +21,11 @@
         <header class="map-toolbar">
             <div class="app-identity">
                 <strong>LME Catasto</strong>
-                <span>@Status</span>
+                <span class="app-status-line">@Status @if (HasUnsavedChanges) { <i title="Modifiche non salvate"></i> }</span>
             </div>
             <div class="toolbar-actions">
+                <button class="map-icon-command" title="Annulla ultima operazione" aria-label="Annulla" @onclick="UndoMapChange">↶</button>
+                <button class="map-icon-command" title="Ripristina operazione" aria-label="Ripristina" @onclick="RedoMapChange">↷</button>
                 <button class="toolbar-button layer-button @(LayerPanelOpen ? "is-active" : null)"
                         title="Layer catastali"
                         aria-expanded="@LayerPanelOpen"
@@ -29,10 +33,25 @@
                     <span class="layer-symbol" aria-hidden="true"></span>
                     <span>Layer</span>
                 </button>
-                <button class="toolbar-button" @onclick='() => SelectTab(ActiveTab == "search" ? "map" : "search")'>Cerca</button>
+                <button class="map-menu-button @(NavigationMenuOpen ? "is-active" : null)" title="Apri menu" aria-label="Apri menu" aria-expanded="@NavigationMenuOpen" @onclick="ToggleNavigationMenu">☰</button>
             </div>
         </header>
 
+        @if (NavigationMenuOpen)
+        {
+            <nav class="map-navigation-menu" aria-label="Menu principale">
+                <button @onclick='() => SelectTab("map")'>Mappa</button>
+                <button @onclick='() => SelectTab("search")'>Cerca località</button>
+                <button @onclick='() => SelectTab("cadastre")'>Ricerca catastale</button>
+                <button @onclick='() => SelectTab("data")'>Dati e disegni</button>
+                <button @onclick='() => SelectTab("projects")'>Progetti</button>
+                <button @onclick='() => SelectTab("save")'>Esporta</button>
+                <button @onclick='() => SelectTab("tools")'>Strumenti avanzati</button>
+                <button @onclick='() => SelectTab("settings")'>Impostazioni</button>
+                <div class="menu-credits"><strong>LME Mappe Catastali</strong><span>Autore: Livio Merola</span><a href="mailto:info@liviomerola.net">info@liviomerola.net</a><span>Mappe: Esri, OpenStreetMap, CARTO, OpenTopoMap. Catasto: Agenzia delle Entrate CC BY 4.0.</span></div>
+            </nav>
+        }
+
         <div class="map-search @(ActiveTab == "search" ? "is-open" : null)">
             <input @bind="SearchText" @bind:event="oninput" placeholder="Localita, indirizzo o coordinate" />
             <button @onclick="SearchLocation">Vai</button>
@@ -317,14 +336,13 @@
                                     <option value="">Seleziona un progetto</option>
                                     @foreach (var project in Projects)
                                     {
-                                        <option value="@project.Id">@(project.IsArchived ? "[ARCHIVIATO] " : "")@(string.IsNullOrWhiteSpace(project.Folder) ? "" : $"{project.Folder} / ")@project.Name - @project.UpdatedAt.ToLocalTime().ToString("dd/MM/yyyy HH:mm")</option>
+                                        <option value="@project.Id">@(project.IsArchived ? "[ARCHIVIATO] " : "")@(project.IsReadOnly ? "[SOLA LETTURA] " : "")@(string.IsNullOrWhiteSpace(project.Folder) ? "" : $"{project.Folder} / ")@project.Name - @project.UpdatedAt.ToLocalTime().ToString("dd/MM/yyyy HH:mm")</option>
                                     }
                                 </select>
                             </label>
                             <div class="button-row">
                                 <button @onclick="LoadProject" disabled="@(ProjectBusy || string.IsNullOrWhiteSpace(SelectedProjectId))">Apri</button>
                                 <button class="danger-command" @onclick="DeleteProject" disabled="@(ProjectBusy || string.IsNullOrWhiteSpace(SelectedProjectId))">Elimina</button>
-                            </div>
                             <label>
                                 Cartella
                                 <input @bind="ProjectFolder" placeholder="Es. Cantieri 2026" maxlength="60" />
@@ -335,7 +353,13 @@
                             </div>
                             <div class="button-row">
                                 <button class="secondary-command" @onclick="ToggleProjectArchive" disabled="@(ProjectBusy || string.IsNullOrWhiteSpace(SelectedProjectId))">@(SelectedProject?.IsArchived == true ? "Ripristina" : "Archivia")</button>
-                                <button class="secondary-command" @onclick="ShareProject" disabled="@(ProjectBusy || string.IsNullOrWhiteSpace(SelectedProjectId))">Condividi</button>
+                                <button class="secondary-command" @onclick='() => ShareProject(false)' disabled="@(ProjectBusy || string.IsNullOrWhiteSpace(SelectedProjectId))">Condividi modificabile</button>
+                            </div>
+                            <button class="secondary-command" @onclick='() => ShareProject(true)' disabled="@(ProjectBusy || string.IsNullOrWhiteSpace(SelectedProjectId))">Condividi in sola lettura</button>
+                            @if (SelectedProject?.IsReadOnly == true)
+                            {
+                                <small class="field-help">Questo progetto è protetto. Usa Duplica per crearne una copia modificabile.</small>
+                            }
                             </div>
                             <label>
                                 Revisione precedente
@@ -385,6 +409,46 @@
                         </section>
                     </section>
                 }
+                else if (ActiveTab == "tools")
+                {
+                    <section class="panel-content">
+                        <section class="panel-section">
+                            <h2>Oggetti e coordinate</h2>
+                            <button class="primary-command" @onclick="ShowObjectTable">Apri tabella oggetti e particelle</button>
+                            <button class="secondary-command" @onclick="ShowCoordinateInspector">Coordinate WGS84 e UTM</button>
+                            <button class="secondary-command" @onclick="ShowAuditLog">Registro operazioni</button>
+                        </section>
+                        <section class="panel-section">
+                            <h2>Controllo geometrie</h2>
+                            <small class="field-help">Seleziona gli oggetti dalla mappa o dal pannello Layer.</small>
+                            <div class="button-row">
+                                <button class="secondary-command" @onclick="ValidateSelectedGeometries">Controlla e ripara</button>
+                                <button class="secondary-command" @onclick="CreateSelectedHole">Crea foro</button>
+                            </div>
+                            <button class="secondary-command" @onclick="CompareSelectedGeometries">Confronta due confini</button>
+                        </section>
+                        <section class="panel-section">
+                            <h2>Cestino</h2>
+                            <div class="button-row">
+                                <button class="secondary-command" @onclick="RestoreTrashItem">Ripristina ultima rimozione</button>
+                                <button class="danger-command" @onclick="EmptyTrash">Svuota cestino</button>
+                            </div>
+                        </section>
+                        <section class="panel-section">
+                            <h2>Mappe offline</h2>
+                            <label>
+                                Livelli di zoom aggiuntivi
+                                <input type="number" min="0" max="4" @bind="OfflineExtraZoomLevels" />
+                            </label>
+                            <button class="primary-command" @onclick="DownloadOfflineArea" disabled="@OfflineBusy">@(OfflineBusy ? "Download in corso..." : "Scarica area visibile")</button>
+                            <div class="button-row">
+                                <button class="secondary-command" @onclick="UseOfflineMap">Usa mappe offline</button>
+                                <button class="danger-command" @onclick="ClearOfflineArea">Svuota archivio</button>
+                            </div>
+                            <small class="field-help">@OfflineStatus</small>
+                        </section>
+                    </section>
+                }
                 else if (ActiveTab == "settings")
                 {
                     <section class="panel-content">
@@ -399,7 +463,7 @@
                                     <option value="topographic">Topografica - Esri World Topographic</option>
                                     <option value="terrain">Terreno - OpenTopoMap</option>
                                     <option value="carto">Strade chiare - CARTO Voyager</option>
-                                    <option value="offline">Offline - solo dati vettoriali</option>
+                                    <option value="offline">Mappe salvate offline</option>
                                     <option value="azure-road">Strade - Azure Maps</option>
                                     <option value="azure-satellite">Satellite - Azure Maps</option>
                                     <option value="google-satellite">Satellite - Google Maps</option>
@@ -436,6 +500,18 @@
                                 <input type="checkbox" @bind="AutoSaveEnabled" @bind:after="ApplyAdvancedOptions" />
                                 <span>Autosalvataggio locale dopo ogni modifica</span>
                             </label>
+                            <label class="toggle-line project-save-option">
+                                <input type="checkbox" @bind="AutoSaveOpenProject" @bind:after="SaveFlagPreferences" />
+                                <span>Aggiorna automaticamente il progetto aperto</span>
+                            </label>
+                            <label>
+                                Backup automatico
+                                <select @bind="AutomaticBackupFrequency" @bind:after="SaveFlagPreferences">
+                                    <option value="off">Disattivato</option>
+                                    <option value="daily">Giornaliero</option>
+                                    <option value="weekly">Settimanale</option>
+                                </select>
+                            </label>
                             <label class="toggle-line project-save-option">
                                 <input type="checkbox" @bind="SnapEnabled" @bind:after="ApplyAdvancedOptions" />
                                 <span>Aggancia i vertici agli oggetti vicini</span>
@@ -446,6 +522,42 @@
                             </label>
                         </section>
 
+                        <section class="panel-section">
+                            <h2>Sincronizzazione WebDAV</h2>
+                            <label>
+                                Indirizzo cartella o file WebDAV
+                                <input type="url" @bind="WebDavEndpoint" placeholder="https://server/remote.php/dav/files/utente/cartella" />
+                            </label>
+                            <label>
+                                Nome utente
+                                <input @bind="WebDavUserName" autocomplete="username" />
+                            </label>
+                            <label>
+                                Password o password applicazione
+                                <input type="password" @bind="WebDavPassword" autocomplete="current-password" />
+                            </label>
+                            <button class="secondary-command" @onclick="SaveWebDavSettings">Salva configurazione</button>
+                            <div class="button-row">
+                                <button class="primary-command" @onclick="SyncUpload" disabled="@SyncBusy">Invia al cloud</button>
+                                <button class="secondary-command" @onclick="SyncDownload" disabled="@SyncBusy">Scarica dal cloud</button>
+                            </div>
+                            <small class="field-help">@SyncStatus</small>
+                        </section>
+
+                        <section class="panel-section">
+                            <h2>Aggiornamenti applicazione</h2>
+                            <button class="primary-command" @onclick="CheckForUpdates" disabled="@UpdateBusy">@(UpdateBusy ? "Controllo..." : "Controlla nuova versione")</button>
+                            @if (!string.IsNullOrWhiteSpace(UpdateDownloadUrl))
+                            {
+                                <button class="secondary-command" @onclick="OpenUpdateDownload">Scarica aggiornamento</button>
+                            }
+                            <small class="field-help">@UpdateStatus</small>
+                            @if (!string.IsNullOrWhiteSpace(UpdateReleaseNotes))
+                            {
+                                <pre class="release-notes">@UpdateReleaseNotes</pre>
+                            }
+                        </section>
+
                         <section class="panel-section">
                             <h2>GPS e percorso</h2>
                             <label class="toggle-line project-save-option">
@@ -456,6 +568,10 @@
                                 <input type="checkbox" @bind="TrailEnabled" @bind:after="ApplyTrailOption" />
                                 <span>Registra la traccia mentre cammini</span>
                             </label>
+                            <div class="button-row">
+                                <button class="secondary-command" @onclick="ShowTrailStats">Riepilogo traccia</button>
+                                <button class="danger-command" @onclick="ClearGpsTrail">Elimina traccia</button>
+                            </div>
                             <label class="toggle-line project-save-option">
                                 <input type="checkbox" @bind="GpsProximityEnabled" @bind:after="ApplyAdvancedOptions" />
                                 <span>Distanza e direzione dal bordo selezionato</span>
@@ -504,14 +620,6 @@
             </section>
         </div>
 
-        <nav class="bottom-tabs" aria-label="Sezioni principali">
-            <button class="@(ActiveTab == "map" || ActiveTab == "search" ? "active" : null)" @onclick='() => SelectTab("map")'>Mappa</button>
-            <button class="@(ActiveTab == "cadastre" ? "active" : null)" @onclick='() => SelectTab("cadastre")'>Catasto</button>
-            <button class="@(ActiveTab == "data" ? "active" : null)" @onclick='() => SelectTab("data")'>Dati</button>
-            <button class="@(ActiveTab == "projects" ? "active" : null)" @onclick='() => SelectTab("projects")'>Progetti</button>
-            <button class="@(ActiveTab == "save" ? "active" : null)" @onclick='() => SelectTab("save")'>Salvataggio</button>
-            <button class="@(ActiveTab == "settings" ? "active" : null)" @onclick='() => SelectTab("settings")'>Impostazioni</button>
-        </nav>
     </section>
 </div>
 
@@ -546,6 +654,8 @@
     private bool DrawToolsVisible { get; set; }
     private bool TrailEnabled { get; set; }
     private bool LayerPanelOpen { get; set; }
+    private bool NavigationMenuOpen { get; set; }
+    private bool HasUnsavedChanges { get; set; }
     private DotNetObjectReference<Home>? MapCallbackReference { get; set; }
     private bool IncludeCadastralParcels { get; set; } = true;
     private bool IncludeKmlSheetLayer { get; set; }
@@ -562,12 +672,27 @@
     private bool ExportTrail { get; set; } = true;
     private bool ExportSelectedOnly { get; set; }
     private bool AutoSaveEnabled { get; set; } = true;
+    private bool AutoSaveOpenProject { get; set; }
+    private string AutomaticBackupFrequency { get; set; } = "daily";
     private bool SnapEnabled { get; set; } = true;
     private int SnapDistancePixels { get; set; } = 14;
     private bool GpsProximityEnabled { get; set; } = true;
     private bool GpsBoundaryAlertEnabled { get; set; }
+    private int OfflineExtraZoomLevels { get; set; } = 2;
+    private bool OfflineBusy { get; set; }
+    private string OfflineStatus { get; set; } = "Nessuna area verificata.";
+    private string WebDavEndpoint { get; set; } = string.Empty;
+    private string WebDavUserName { get; set; } = string.Empty;
+    private string WebDavPassword { get; set; } = string.Empty;
+    private bool SyncBusy { get; set; }
+    private string SyncStatus { get; set; } = "Sincronizzazione non configurata.";
+    private bool UpdateBusy { get; set; }
+    private string UpdateStatus { get; set; } = $"Versione installata: {AppUpdateService.CurrentVersion}";
+    private string UpdateDownloadUrl { get; set; } = string.Empty;
+    private string UpdateReleaseNotes { get; set; } = string.Empty;
     private CancellationTokenSource? CatalogCancellation { get; set; }
     private CancellationTokenSource? GpsLookupCancellation { get; set; }
+    private CancellationTokenSource? ProjectAutoSaveCancellation { get; set; }
     private long LastGpsLookupAt;
     private int GpsLookupInProgress;
 
@@ -591,6 +716,7 @@
         "data" => "Dati e disegni",
         "projects" => "Archivio progetti",
         "save" => "Salvataggio ed esportazione",
+        "tools" => "Strumenti avanzati",
         "settings" => "Impostazioni",
         _ => string.Empty
     };
@@ -601,6 +727,7 @@
         "data" => "File GIS, misure e POI",
         "projects" => "Salva, apri e visualizza i tuoi lavori",
         "save" => "Esporta file GIS",
+        "tools" => "Oggetti, geometrie, coordinate e offline",
         "settings" => "Mappa, GPS e servizi ufficiali",
         _ => string.Empty
     };
@@ -637,6 +764,11 @@
             AzureMapsSubscriptionKey = string.Empty;
         }
 
+        WebDavEndpoint = Preferences.Default.Get("webdav_endpoint", string.Empty);
+        WebDavUserName = Preferences.Default.Get("webdav_username", string.Empty);
+        try { WebDavPassword = await SecureStorage.Default.GetAsync("webdav_password") ?? string.Empty; }
+        catch { WebDavPassword = string.Empty; }
+
         try
         {
             Regions = await CatalogService.GetRegionsAsync();
@@ -659,6 +791,9 @@
             await ApplyAdvancedOptions();
             await CenterOnInitialLocationAsync();
             await MigrateLegacyProjectAsync();
+            var offlineCount = await JS.InvokeAsync<int>("lmeMap.getOfflineTileStats");
+            OfflineStatus = offlineCount == 0 ? "Nessuna tessera salvata." : $"{offlineCount} tessere disponibili offline.";
+            await InvokeAsync(StateHasChanged);
         }
     }
 
@@ -778,6 +913,7 @@
 
     private async Task SelectTab(string tab)
     {
+        NavigationMenuOpen = false;
         ActiveTab = tab;
         if (tab != "map")
         {
@@ -795,6 +931,12 @@
         }
     }
 
+    private void ToggleNavigationMenu()
+    {
+        NavigationMenuOpen = !NavigationMenuOpen;
+        if (NavigationMenuOpen) LayerPanelOpen = false;
+    }
+
     private async Task ToggleLayerPanel()
     {
         LayerPanelOpen = !LayerPanelOpen;
@@ -1147,6 +1289,46 @@
         return InvokeAsync(StateHasChanged);
     }
 
+    [JSInvokable]
+    public Task OnMapChanged(string action)
+    {
+        HasUnsavedChanges = true;
+        if (AutoSaveOpenProject && SelectedProject is { IsReadOnly: false })
+        {
+            ProjectAutoSaveCancellation?.Cancel();
+            ProjectAutoSaveCancellation?.Dispose();
+            ProjectAutoSaveCancellation = new CancellationTokenSource();
+            _ = AutoSaveCurrentProjectAsync(ProjectAutoSaveCancellation.Token);
+        }
+        return InvokeAsync(StateHasChanged);
+    }
+
+    [JSInvokable]
+    public Task OnProjectSaved()
+    {
+        HasUnsavedChanges = false;
+        return InvokeAsync(StateHasChanged);
+    }
+
+    private async Task AutoSaveCurrentProjectAsync(CancellationToken cancellationToken)
+    {
+        try
+        {
+            await Task.Delay(TimeSpan.FromSeconds(3), cancellationToken);
+            var project = SelectedProject;
+            if (project is null || project.IsReadOnly) return;
+            var snapshot = await JS.InvokeAsync<string>("lmeMap.createProjectSnapshot", IncludeCadastralParcels);
+            await ProjectStorageService.SaveAsync(project.Name, snapshot, IncludeCadastralParcels, project.Id);
+            await JS.InvokeVoidAsync("lmeMap.markProjectSaved");
+            await RefreshProjectsAsync();
+        }
+        catch (OperationCanceledException) { }
+        catch (Exception error)
+        {
+            await JS.InvokeVoidAsync("lmeMap.showInfo", $"Autosalvataggio progetto non riuscito: {error.GetBaseException().Message}");
+        }
+    }
+
     private async Task ToggleDrawTools()
     {
         DrawToolsVisible = !DrawToolsVisible;
@@ -1194,6 +1376,13 @@
     private Task RedoMapChange() => JS.InvokeVoidAsync("lmeMap.redoMapChange").AsTask();
     private Task RestoreAutosave() => JS.InvokeVoidAsync("lmeMap.restoreAutosave").AsTask();
     private Task SaveGpsMeasurementPoint() => JS.InvokeVoidAsync("lmeMap.saveGpsMeasurementPoint").AsTask();
+    private async Task ShowTrailStats()
+    {
+        var stats = await JS.InvokeAsync<TrailStats>("lmeMap.getGpsTrailStats");
+        var duration = TimeSpan.FromSeconds(stats.DurationSeconds);
+        await JS.InvokeVoidAsync("lmeMap.showInfo", $"Traccia: {stats.Points} punti, {stats.Length:0} m, durata {duration:hh\\:mm\\:ss}, {(stats.Recording ? "in registrazione" : "in pausa")}.");
+    }
+    private Task ClearGpsTrail() => JS.InvokeVoidAsync("lmeMap.clearGpsTrail").AsTask();
 
     private async Task DuplicateProject()
     {
@@ -1221,11 +1410,11 @@
         await JS.InvokeVoidAsync("lmeMap.showInfo", project.IsArchived ? "Progetto ripristinato." : "Progetto archiviato.");
     }
 
-    private async Task ShareProject()
+    private async Task ShareProject(bool readOnly)
     {
         if (SelectedProject is null) return;
-        var path = await ProjectStorageService.CreateProjectPackageAsync(SelectedProject.Id);
-        await Share.Default.RequestAsync(new ShareFileRequest { Title = "Condividi progetto LME", File = new ShareFile(path, "application/json") });
+        var path = await ProjectStorageService.CreateProjectPackageAsync(SelectedProject.Id, readOnly);
+        await Share.Default.RequestAsync(new ShareFileRequest { Title = readOnly ? "Condividi progetto LME in sola lettura" : "Condividi progetto LME modificabile", File = new ShareFile(path, "application/json") });
     }
 
     private async Task ShareFullBackup()
@@ -1267,6 +1456,7 @@
     private async Task LoadProjectVersion()
     {
         if (SelectedProject is null || string.IsNullOrWhiteSpace(SelectedVersionId)) return;
+        if (!await JS.InvokeAsync<bool>("lmeMap.confirmDiscardChanges", "aprire la revisione")) return;
         var snapshot = await ProjectStorageService.LoadVersionAsync(SelectedProject.Id, SelectedVersionId);
         var options = await JS.InvokeAsync<ProjectDisplayOptions>("lmeMap.loadProjectSnapshot", snapshot, $"{SelectedProject.Name} - revisione");
         ApplyProjectDisplayOptions(options);
@@ -1352,6 +1542,10 @@
             await RefreshProjectsAsync();
             SelectedProjectId = saved.Id;
             NewProjectName = saved.Name;
+            await JS.InvokeVoidAsync("lmeMap.setProjectReadOnly", false);
+            await JS.InvokeVoidAsync("lmeMap.markProjectSaved");
+            HasUnsavedChanges = false;
+            await CreateAutomaticBackupIfDue();
             await JS.InvokeVoidAsync(
                 "lmeMap.showInfo",
                 IncludeCadastralParcels
@@ -1376,6 +1570,7 @@
             await JS.InvokeVoidAsync("lmeMap.showInfo", "Seleziona il progetto da caricare.");
             return;
         }
+        if (!await JS.InvokeAsync<bool>("lmeMap.confirmDiscardChanges", "aprire un altro progetto")) return;
 
         ProjectBusy = true;
         try
@@ -1387,6 +1582,9 @@
             NewProjectName = project.Name;
             ExportFileName = project.Name;
             IncludeCadastralParcels = project.IncludesCadastralParcels;
+            await JS.InvokeVoidAsync("lmeMap.setProjectReadOnly", project.IsReadOnly);
+            await JS.InvokeVoidAsync("lmeMap.markProjectSaved");
+            HasUnsavedChanges = false;
             ActiveTab = "map";
             await Task.Delay(30);
             await JS.InvokeVoidAsync("lmeMap.resize");
@@ -1452,6 +1650,115 @@
             ProjectBusy = false;
         }
     }
+
+    private Task ShowObjectTable() => JS.InvokeVoidAsync("lmeMap.showObjectTable").AsTask();
+    private Task ShowAuditLog() => JS.InvokeVoidAsync("lmeMap.showAuditLog").AsTask();
+    private Task ShowCoordinateInspector() => JS.InvokeVoidAsync("lmeMap.showCoordinateInspector").AsTask();
+    private Task ValidateSelectedGeometries() => JS.InvokeVoidAsync("lmeMap.validateAndRepairSelected").AsTask();
+    private Task CreateSelectedHole() => JS.InvokeVoidAsync("lmeMap.createHoleFromSelected").AsTask();
+    private Task CompareSelectedGeometries() => JS.InvokeVoidAsync("lmeMap.compareSelectedGeometries").AsTask();
+    private Task RestoreTrashItem() => JS.InvokeVoidAsync("lmeMap.restoreLastTrashItem").AsTask();
+    private Task EmptyTrash() => JS.InvokeVoidAsync("lmeMap.emptyTrash").AsTask();
+
+    private async Task DownloadOfflineArea()
+    {
+        OfflineBusy = true;
+        try
+        {
+            var result = await JS.InvokeAsync<OfflineDownloadResult>("lmeMap.downloadOfflineArea", OfflineExtraZoomLevels);
+            OfflineStatus = $"{result.Saved} tessere disponibili, zoom {result.StartZoom}-{result.EndZoom}.";
+        }
+        catch (Exception error) { OfflineStatus = $"Download non riuscito: {error.GetBaseException().Message}"; }
+        finally { OfflineBusy = false; }
+    }
+
+    private async Task UseOfflineMap()
+    {
+        await JS.InvokeVoidAsync("lmeMap.setBaseLayer", "offline");
+        SelectedBaseLayer = "offline";
+    }
+
+    private async Task ClearOfflineArea()
+    {
+        if (!await JS.InvokeAsync<bool>("confirm", "Svuotare tutte le mappe salvate offline?")) return;
+        await JS.InvokeVoidAsync("lmeMap.clearOfflineTiles");
+        OfflineStatus = "Nessuna tessera salvata.";
+    }
+
+    private async Task SaveWebDavSettings()
+    {
+        Preferences.Default.Set("webdav_endpoint", WebDavEndpoint.Trim());
+        Preferences.Default.Set("webdav_username", WebDavUserName.Trim());
+        if (string.IsNullOrWhiteSpace(WebDavPassword)) SecureStorage.Default.Remove("webdav_password");
+        else await SecureStorage.Default.SetAsync("webdav_password", WebDavPassword);
+        SyncStatus = "Configurazione WebDAV salvata sul dispositivo.";
+    }
+
+    private async Task SyncUpload()
+    {
+        SyncBusy = true;
+        try
+        {
+            await SaveWebDavSettings();
+            var backup = await ProjectStorageService.CreateBackupAsync();
+            await CloudSyncService.UploadAsync(WebDavEndpoint, WebDavUserName, WebDavPassword, backup);
+            SyncStatus = $"Archivio inviato al cloud il {DateTime.Now:dd/MM/yyyy HH:mm}.";
+        }
+        catch (Exception error) { SyncStatus = $"Invio non riuscito: {error.GetBaseException().Message}"; }
+        finally { SyncBusy = false; }
+    }
+
+    private async Task SyncDownload()
+    {
+        if (!await JS.InvokeAsync<bool>("lmeMap.confirmDiscardChanges", "ripristinare l'archivio cloud")) return;
+        SyncBusy = true;
+        try
+        {
+            await SaveWebDavSettings();
+            var backup = await CloudSyncService.DownloadAsync(WebDavEndpoint, WebDavUserName, WebDavPassword);
+            var count = await ProjectStorageService.RestoreBackupAsync(backup);
+            await RefreshProjectsAsync();
+            SyncStatus = $"Sincronizzazione completata: {count} progetti ripristinati.";
+        }
+        catch (Exception error) { SyncStatus = $"Download non riuscito: {error.GetBaseException().Message}"; }
+        finally { SyncBusy = false; }
+    }
+
+    private async Task CheckForUpdates()
+    {
+        UpdateBusy = true;
+        UpdateDownloadUrl = string.Empty;
+        UpdateReleaseNotes = string.Empty;
+        try
+        {
+            var update = await AppUpdateService.CheckAsync();
+            UpdateReleaseNotes = update.ReleaseNotes;
+            if (update.IsAvailable)
+            {
+                UpdateStatus = $"Installata {AppUpdateService.CurrentVersion}. Disponibile {update.Version}.";
+                UpdateDownloadUrl = update.DownloadUrl;
+            }
+            else UpdateStatus = $"Versione {AppUpdateService.CurrentVersion} aggiornata. Ultima release Gitea: {update.Version}.";
+        }
+        catch (Exception error) { UpdateStatus = $"Controllo non riuscito: {error.GetBaseException().Message}"; }
+        finally { UpdateBusy = false; }
+    }
+
+    private Task OpenUpdateDownload() => string.IsNullOrWhiteSpace(UpdateDownloadUrl)
+        ? Task.CompletedTask
+        : Launcher.Default.OpenAsync(new Uri(UpdateDownloadUrl));
+
+    private async Task CreateAutomaticBackupIfDue()
+    {
+        if (AutomaticBackupFrequency == "off") return;
+        var latest = ProjectStorageService.GetLatestScheduledBackupTime();
+        var interval = AutomaticBackupFrequency == "weekly" ? TimeSpan.FromDays(7) : TimeSpan.FromDays(1);
+        if (latest is null || DateTimeOffset.UtcNow - latest.Value.ToUniversalTime() >= interval)
+        {
+            await ProjectStorageService.CreateScheduledBackupAsync();
+        }
+    }
+
     private Task CenterOnGps() => JS.InvokeVoidAsync("lmeMap.centerOnGps").AsTask();
     private async Task ApplyTrailOption()
     {
@@ -1584,8 +1891,11 @@
         ExportTrail = GetFlagPreference("export_trail", true);
         ExportSelectedOnly = GetFlagPreference("export_selected_only", false);
         AutoSaveEnabled = GetFlagPreference("auto_save", true);
+        AutoSaveOpenProject = GetFlagPreference("auto_save_project", false);
+        AutomaticBackupFrequency = Preferences.Default.Get($"{FlagPreferencePrefix}backup_frequency", "daily");
         SnapEnabled = GetFlagPreference("snap_enabled", true);
         SnapDistancePixels = Preferences.Default.Get($"{FlagPreferencePrefix}snap_distance", 14);
+        OfflineExtraZoomLevels = Preferences.Default.Get($"{FlagPreferencePrefix}offline_zoom_levels", 2);
         GpsProximityEnabled = GetFlagPreference("gps_proximity", true);
         GpsBoundaryAlertEnabled = GetFlagPreference("gps_boundary_alert", false);
 
@@ -1615,8 +1925,11 @@
         SetFlagPreference("export_trail", ExportTrail);
         SetFlagPreference("export_selected_only", ExportSelectedOnly);
         SetFlagPreference("auto_save", AutoSaveEnabled);
+        SetFlagPreference("auto_save_project", AutoSaveOpenProject);
+        Preferences.Default.Set($"{FlagPreferencePrefix}backup_frequency", AutomaticBackupFrequency);
         SetFlagPreference("snap_enabled", SnapEnabled);
         Preferences.Default.Set($"{FlagPreferencePrefix}snap_distance", SnapDistancePixels);
+        Preferences.Default.Set($"{FlagPreferencePrefix}offline_zoom_levels", OfflineExtraZoomLevels);
         SetFlagPreference("gps_proximity", GpsProximityEnabled);
         SetFlagPreference("gps_boundary_alert", GpsBoundaryAlertEnabled);
 
@@ -1718,12 +2031,30 @@
         public bool TrailEnabled { get; init; }
     }
 
+    private sealed class OfflineDownloadResult
+    {
+        public int Saved { get; init; }
+        public int Requested { get; init; }
+        public int StartZoom { get; init; }
+        public int EndZoom { get; init; }
+    }
+
+    private sealed class TrailStats
+    {
+        public int Points { get; init; }
+        public double Length { get; init; }
+        public int DurationSeconds { get; init; }
+        public bool Recording { get; init; }
+    }
+
     public ValueTask DisposeAsync()
     {
         CancelCatalogWork();
         LocationService.StopTracking();
         GpsLookupCancellation?.Cancel();
         GpsLookupCancellation?.Dispose();
+        ProjectAutoSaveCancellation?.Cancel();
+        ProjectAutoSaveCancellation?.Dispose();
         MapCallbackReference?.Dispose();
         return ValueTask.CompletedTask;
     }
diff --git a/LMEMappeCatastaliApp.csproj b/LMEMappeCatastaliApp.csproj
index d7d66cb..af0f740 100644
--- a/LMEMappeCatastaliApp.csproj
+++ b/LMEMappeCatastaliApp.csproj
@@ -28,8 +28,9 @@
         <ApplicationId>com.companyname.lmemappecatastaliapp</ApplicationId>
 
         <!-- Versions -->
-        <ApplicationDisplayVersion>0.3.0</ApplicationDisplayVersion>
-        <ApplicationVersion>34</ApplicationVersion>
+        <ApplicationDisplayVersion>0.4.0</ApplicationDisplayVersion>
+        <ApplicationVersion>35</ApplicationVersion>
+        <Version>$(ApplicationDisplayVersion)</Version>
 
         <!-- To develop, package, and publish an app to the Microsoft Store, see: https://aka.ms/MauiTemplateUnpackaged -->
         <WindowsPackageType>None</WindowsPackageType>
diff --git a/MauiProgram.cs b/MauiProgram.cs
index afe1ccc..2feaba8 100644
--- a/MauiProgram.cs
+++ b/MauiProgram.cs
@@ -24,6 +24,8 @@ public static class MauiProgram
         builder.Services.AddSingleton<AzureMapsService>();
         builder.Services.AddSingleton<ProjectStorageService>();
         builder.Services.AddSingleton<MapExportService>();
+        builder.Services.AddSingleton<CloudSyncService>();
+        builder.Services.AddSingleton<AppUpdateService>();
 
 #if DEBUG
         builder.Services.AddBlazorWebViewDeveloperTools();
diff --git a/README.md b/README.md
index 1440e82..52deada 100644
--- a/README.md
+++ b/README.md
@@ -2,7 +2,24 @@
 
 App .NET MAUI Blazor Hybrid per Android, iOS, Mac Catalyst e Windows, pensata per consultare mappe catastali e lavorare sul campo con GPS.
 
-## Funzioni gia implementate
+## Versione 0.4.0
+
+La mappa ora occupa tutta la schermata: il pannello `Layer` resta subito accessibile, mentre ricerca, catasto, dati, progetti, esportazione, strumenti avanzati e impostazioni sono raccolti nel menu in alto.
+
+Tra le funzioni principali della versione 0.4.0:
+
+- rinomina, ordinamento, selezione, blocco e rimozione reversibile di singoli oggetti e gruppi;
+- evidenziazione coordinata dei gruppi e gerarchia visiva tra padri, figli e livelli annidati;
+- annulla/ripristina, cestino, storico modifiche, autosalvataggio e backup programmati;
+- modifica o eliminazione del solo disegno selezionato oppure di tutti i disegni;
+- tabella oggetti, ricerca, attributi personalizzati, etichette, note e foto;
+- strumenti geometrici per buffer, unione, divisione, fori, confronto e controllo/riparazione;
+- importazione controllata di GeoJSON, KML e KMZ con analisi, pulizia e deduplicazione;
+- cache cartografica offline, sincronizzazione WebDAV e condivisione di progetti modificabili o in sola lettura;
+- controllo aggiornamenti da Gitea con versione installata, versione disponibile, note e download APK;
+- esportazione PDF con schema vettoriale, freccia nord, scala grafica e riferimenti catastali.
+
+## Funzioni implementate
 
 - Mappa interattiva Leaflet con sfondi Esri, OpenStreetMap, OpenTopoMap, CARTO Voyager, Google Maps e Azure Maps configurabili tramite chiave.
 - Layer WMS ufficiale Agenzia delle Entrate: particelle, numeri particella, fogli, fabbricati, strade e acque.
@@ -14,11 +31,11 @@ App .NET MAUI Blazor Hybrid per Android, iOS, Mac Catalyst e Windows, pensata pe
 - Migrazione automatica dei vecchi progetti: i GroundOverlay `DOC_...` salvati in precedenza insieme alle particelle vengono riconosciuti, separati e nascosti in tempo reale dal relativo check.
 - Inquadramento e pulizia dei layer importati.
 - Disegno di marker, linee, poligoni e rettangoli.
-- Area, Distanza e Cerchio disponibili nella barra Leaflet laterale, nascosta all'avvio e controllata dal pulsante nel tab Dati insieme agli altri strumenti.
+- Area, Distanza e Cerchio disponibili nella barra Leaflet laterale, nascosta all'avvio e controllata dalla sezione `Dati e disegni` insieme agli altri strumenti.
 - Misure permanenti attivabili anche sui layer importati da KML, KMZ e GeoJSON.
 - Toolbar di disegno completa di icone, modifica, eliminazione singola e pulizia di tutti i disegni/POI.
 - Archivio multiprogetto nella cartella privata dell'app, con nome, selezione da elenco, sovrascrittura ed eliminazione.
-- Tab distinti `Progetti` e `Salvataggio`: il primo gestisce archivio e opzioni live di visualizzazione, il secondo esporta selettivamente l'intera mappa in GeoJSON, KML o KMZ.
+- Sezioni `Progetti` ed `Esporta` nel menu: la prima gestisce archivio e opzioni live di visualizzazione, la seconda esporta selettivamente l'intera mappa in GeoJSON, KML o KMZ.
 - Ogni progetto salva file GIS, POI, disegni, traccia, inquadratura e tutte le opzioni di visualizzazione: sfondo, layer catastali, trasparenza, misure, foglio importato, barra strumenti e preferenze GPS.
 - GPS nativo MAUI ad alta precisione con permessi Android/iOS.
 - Centratura automatica una tantum all'apertura: prima tramite posizione approssimativa della connessione Internet, poi tramite singola lettura GPS se la rete non restituisce una posizione; nessun punto o cerchio viene mostrato e il tracking continuo non viene avviato.
@@ -26,13 +43,13 @@ App .NET MAUI Blazor Hybrid per Android, iOS, Mac Catalyst e Windows, pensata pe
 - Marker posizione, cerchio accuratezza in metri, tracciamento percorso.
 - Controllo se la posizione GPS cade dentro un poligono importato o disegnato.
 - Interrogazione WFS ufficiale Agenzia delle Entrate attorno alla posizione GPS per evidenziare la particella catastale corrente quando il servizio restituisce la geometria.
-- Mappa a tutto schermo con tab separati Catasto, Dati, Salvataggio e Impostazioni, adattabile agli schermi pieghevoli.
+- Mappa a tutto schermo con menu compatto e pannelli adattabili a telefoni, tablet e schermi pieghevoli.
 - Ingrandimento oltre lo zoom satellitare nativo senza tessere "Map data not yet available".
 - Tendine concatenate Regione, Comune, Foglio e Particella.
 - Ricerca di localita e indirizzi eseguita nativamente con fallback Esri e OpenStreetMap, senza richieste CORS dalla WebView.
 - Catalogo dei Comuni incluso nell'APK e cataloghi regionali OnData scaricati in cache solo quando servono.
 - Ricerca catastale eseguita dal codice .NET nativo, senza DuckDB WebAssembly nella WebView Android.
-- La registrazione della traccia GPS e' disattivata all'avvio; la toolbar di disegno completa puo' essere mostrata o nascosta dal tab Dati.
+- La registrazione della traccia GPS e' disattivata all'avvio; la toolbar di disegno completa puo' essere mostrata o nascosta dalla sezione `Dati e disegni`.
 - Pannello `Layer` accessibile direttamente dalla mappa, con checkbox sincronizzati per confini, numeri particella, fogli, fabbricati, strade e acque.
 - Le particelle cercate possono essere aggiunte una dopo l'altra, mantenendo contemporaneamente sulla mappa tutti i confini selezionati.
 - Comandi separati per rimuovere le particelle selezionate o pulire importazioni, disegni, POI e traccia GPS.
diff --git a/Services/AppUpdateService.cs b/Services/AppUpdateService.cs
new file mode 100644
index 0000000..66cae9c
--- /dev/null
+++ b/Services/AppUpdateService.cs
@@ -0,0 +1,44 @@
+using System.Net.Http.Json;
+using System.Reflection;
+using System.Text.Json.Serialization;
+
+namespace LMEMappeCatastaliApp.Services;
+
+public sealed class AppUpdateService
+{
+    private const string LatestReleaseUrl = "https://gitea.lmcloud.it/api/v1/repos/livio/LMEMappeCatastaliApp/releases/latest";
+    private readonly HttpClient _httpClient = new() { Timeout = TimeSpan.FromSeconds(20) };
+
+    public static string CurrentVersion =>
+        typeof(AppUpdateService).Assembly
+            .GetCustomAttribute<AssemblyInformationalVersionAttribute>()?
+            .InformationalVersion.Split('+')[0]
+        ?? AppInfo.Current.VersionString;
+
+    public async Task<AppUpdateResult> CheckAsync(CancellationToken cancellationToken = default)
+    {
+        var release = await _httpClient.GetFromJsonAsync<GiteaRelease>(LatestReleaseUrl, cancellationToken)
+            ?? throw new InvalidDataException("Risposta aggiornamenti non valida.");
+        var latestText = (release.TagName ?? string.Empty).TrimStart('v', 'V');
+        _ = Version.TryParse(CurrentVersion, out var current);
+        _ = Version.TryParse(latestText, out var latest);
+        var apk = release.Assets?.FirstOrDefault(item => item.Name?.EndsWith(".apk", StringComparison.OrdinalIgnoreCase) == true);
+        return new(latest is not null && current is not null && latest > current, latestText, release.HtmlUrl ?? string.Empty, apk?.BrowserDownloadUrl ?? release.HtmlUrl ?? string.Empty, release.Body ?? string.Empty);
+    }
+
+    private sealed class GiteaRelease
+    {
+        [JsonPropertyName("tag_name")] public string? TagName { get; set; }
+        [JsonPropertyName("html_url")] public string? HtmlUrl { get; set; }
+        [JsonPropertyName("assets")] public GiteaAsset[]? Assets { get; set; }
+        [JsonPropertyName("body")] public string? Body { get; set; }
+    }
+
+    private sealed class GiteaAsset
+    {
+        [JsonPropertyName("name")] public string? Name { get; set; }
+        [JsonPropertyName("browser_download_url")] public string? BrowserDownloadUrl { get; set; }
+    }
+}
+
+public sealed record AppUpdateResult(bool IsAvailable, string Version, string ReleaseUrl, string DownloadUrl, string ReleaseNotes);
diff --git a/Services/CloudSyncService.cs b/Services/CloudSyncService.cs
new file mode 100644
index 0000000..371c03d
--- /dev/null
+++ b/Services/CloudSyncService.cs
@@ -0,0 +1,54 @@
+using System.Net.Http.Headers;
+using System.Text;
+
+namespace LMEMappeCatastaliApp.Services;
+
+public sealed class CloudSyncService
+{
+    private readonly HttpClient _httpClient = new() { Timeout = TimeSpan.FromMinutes(3) };
+
+    public async Task UploadAsync(string endpoint, string userName, string password, string localPath, CancellationToken cancellationToken = default)
+    {
+        var target = BuildTarget(endpoint);
+        using var request = new HttpRequestMessage(HttpMethod.Put, target);
+        ApplyCredentials(request, userName, password);
+        request.Content = new StreamContent(File.OpenRead(localPath));
+        request.Content.Headers.ContentType = new MediaTypeHeaderValue("application/zip");
+        using var response = await _httpClient.SendAsync(request, cancellationToken);
+        response.EnsureSuccessStatusCode();
+    }
+
+    public async Task<string> DownloadAsync(string endpoint, string userName, string password, CancellationToken cancellationToken = default)
+    {
+        using var request = new HttpRequestMessage(HttpMethod.Get, BuildTarget(endpoint));
+        ApplyCredentials(request, userName, password);
+        using var response = await _httpClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancellationToken);
+        response.EnsureSuccessStatusCode();
+        var directory = Path.Combine(FileSystem.CacheDirectory, "CloudSync");
+        Directory.CreateDirectory(directory);
+        var path = Path.Combine(directory, $"LME-cloud-{DateTime.Now:yyyyMMdd-HHmmss}.lmebackup.zip");
+        await using var input = await response.Content.ReadAsStreamAsync(cancellationToken);
+        await using var output = File.Create(path);
+        await input.CopyToAsync(output, cancellationToken);
+        return path;
+    }
+
+    private static Uri BuildTarget(string endpoint)
+    {
+        if (!Uri.TryCreate(endpoint?.Trim(), UriKind.Absolute, out var uri)
+            || (uri.Scheme != Uri.UriSchemeHttps && uri.Scheme != Uri.UriSchemeHttp))
+        {
+            throw new ArgumentException("Inserisci un indirizzo WebDAV http o https valido.");
+        }
+        return uri.AbsolutePath.EndsWith(".zip", StringComparison.OrdinalIgnoreCase)
+            ? uri
+            : new Uri($"{uri.ToString().TrimEnd('/')}/LMEMappeCatastali-sync.lmebackup.zip");
+    }
+
+    private static void ApplyCredentials(HttpRequestMessage request, string userName, string password)
+    {
+        if (string.IsNullOrWhiteSpace(userName)) return;
+        var value = Convert.ToBase64String(Encoding.UTF8.GetBytes($"{userName}:{password}"));
+        request.Headers.Authorization = new AuthenticationHeaderValue("Basic", value);
+    }
+}
diff --git a/Services/MapExportService.cs b/Services/MapExportService.cs
index a864975..9f0862e 100644
--- a/Services/MapExportService.cs
+++ b/Services/MapExportService.cs
@@ -135,11 +135,43 @@ public sealed class MapExportService
 
     private static byte[] BuildPdfReport(JsonElement features, string title)
     {
+        var paths = features.EnumerateArray()
+            .Where(feature => feature.TryGetProperty("geometry", out _))
+            .SelectMany(feature => PdfCoordinatePaths(feature.GetProperty("geometry")))
+            .Where(path => path.Count > 0)
+            .ToArray();
+        var points = paths.SelectMany(path => path).ToArray();
+        var minLon = points.Length == 0 ? 0 : points.Min(point => point.Lon);
+        var maxLon = points.Length == 0 ? 1 : points.Max(point => point.Lon);
+        var minLat = points.Length == 0 ? 0 : points.Min(point => point.Lat);
+        var maxLat = points.Length == 0 ? 1 : points.Max(point => point.Lat);
+        var lonSpan = Math.Max(0.0000001, maxLon - minLon);
+        var latSpan = Math.Max(0.0000001, maxLat - minLat);
+        const double mapLeft = 48, mapBottom = 438, mapWidth = 499, mapHeight = 330;
+        var scale = Math.Min(mapWidth / lonSpan, mapHeight / latSpan);
+        var drawing = new StringBuilder("0.08 0.44 0.37 RG 0.86 0.94 0.91 rg 1.4 w ");
+        foreach (var path in paths.Take(400))
+        {
+            for (var pointIndex = 0; pointIndex < path.Count; pointIndex++)
+            {
+                var x = mapLeft + (path[pointIndex].Lon - minLon) * scale;
+                var y = mapBottom + (path[pointIndex].Lat - minLat) * scale;
+                drawing.AppendFormat(CultureInfo.InvariantCulture, "{0:0.##} {1:0.##} {2} ", x, y, pointIndex == 0 ? "m" : "l");
+            }
+            drawing.Append("S ");
+        }
+        drawing.Append("0 0 0 RG 1 w 497 730 m 497 758 l S 497 758 m 491 746 l 503 746 l h f ");
+        var middleLatitude = (minLat + maxLat) / 2;
+        var widthMeters = lonSpan * 111_320 * Math.Cos(middleLatitude * Math.PI / 180);
+        var scaleMeters = Math.Max(1, NiceScaleDistance(widthMeters / 4));
+        var scalePixels = widthMeters <= 0 ? 80 : Math.Clamp(scaleMeters / widthMeters * mapWidth, 35, 150);
+        drawing.AppendFormat(CultureInfo.InvariantCulture, "48 422 m {0:0.##} 422 l S 48 418 m 48 426 l S {0:0.##} 418 m {0:0.##} 426 l S ", 48 + scalePixels);
         var lines = new List<string>
         {
             title,
             $"Rapporto LME Mappe Catastali - {DateTime.Now:dd/MM/yyyy HH:mm}",
             $"Oggetti: {features.GetArrayLength()}",
+            $"Scala grafica: {scaleMeters:0} m | Nord: alto pagina",
             ""
         };
         var index = 1;
@@ -148,14 +180,17 @@ public sealed class MapExportService
             var properties = feature.TryGetProperty("properties", out var value) ? value : default;
             var category = GetString(properties, "_lmeCategory") ?? "drawing";
             var geometry = feature.TryGetProperty("geometry", out var geo) ? geo.GetProperty("type").GetString() : "-";
-            lines.Add($"{index++}. {FeatureName(properties, category)} [{category}, {geometry}]");
+            var sheet = GetString(properties, "foglio") ?? GetString(properties, "FOGLIO");
+            var parcel = GetString(properties, "particella") ?? GetString(properties, "PARTICELLA") ?? GetString(properties, "LABEL");
+            var reference = string.Join(" ", new[] { sheet is null ? null : $"F.{sheet}", parcel is null ? null : $"P.{parcel}" }.Where(item => item is not null));
+            lines.Add($"{index++}. {FeatureName(properties, category)} [{category}, {geometry}] {reference}".TrimEnd());
         }
-        var content = new StringBuilder("BT /F1 16 Tf 48 790 Td ");
-        foreach (var line in lines.Take(42))
+        var content = drawing.Append("BT /F1 12 Tf 48 810 Td ");
+        foreach (var line in lines.Take(21))
         {
             var safe = line.Replace("\\", "\\\\").Replace("(", "\\(").Replace(")", "\\)")
                 .Select(character => character <= 255 ? character : '?').ToArray();
-            content.Append('(').Append(safe).Append(") Tj 0 -18 Td ");
+            content.Append('(').Append(safe).Append(") Tj 0 -16 Td ");
         }
         content.Append("ET");
         var stream = Encoding.Latin1.GetBytes(content.ToString());
@@ -183,6 +218,36 @@ public sealed class MapExportService
         return output.ToArray();
     }
 
+    private static double NiceScaleDistance(double value)
+    {
+        if (value <= 0) return 1;
+        var power = Math.Pow(10, Math.Floor(Math.Log10(value)));
+        var normalized = value / power;
+        var nice = normalized >= 5 ? 5 : normalized >= 2 ? 2 : 1;
+        return nice * power;
+    }
+
+    private static IEnumerable<List<(double Lon, double Lat)>> PdfCoordinatePaths(JsonElement geometry)
+    {
+        if (!geometry.TryGetProperty("type", out var typeElement) || !geometry.TryGetProperty("coordinates", out var coordinates)) yield break;
+        var type = typeElement.GetString();
+        if (type == "Point") { yield return [PdfPoint(coordinates)]; yield break; }
+        if (type == "LineString") { yield return coordinates.EnumerateArray().Select(PdfPoint).ToList(); yield break; }
+        if (type == "Polygon" || type == "MultiLineString")
+        {
+            foreach (var path in coordinates.EnumerateArray()) yield return path.EnumerateArray().Select(PdfPoint).ToList();
+            yield break;
+        }
+        if (type == "MultiPolygon")
+        {
+            foreach (var polygon in coordinates.EnumerateArray())
+            foreach (var path in polygon.EnumerateArray()) yield return path.EnumerateArray().Select(PdfPoint).ToList();
+        }
+    }
+
+    private static (double Lon, double Lat) PdfPoint(JsonElement coordinate) =>
+        (coordinate[0].GetDouble(), coordinate[1].GetDouble());
+
     private static string BuildKml(JsonElement features, string documentName)
     {
         var document = new XElement(Kml + "Document",
diff --git a/Services/ProjectStorageService.cs b/Services/ProjectStorageService.cs
index 3c2ff52..5d59e1d 100644
--- a/Services/ProjectStorageService.cs
+++ b/Services/ProjectStorageService.cs
@@ -68,7 +68,7 @@ public sealed class ProjectStorageService
             }
             var document = new MapProjectDocument
             {
-                SchemaVersion = 2,
+                SchemaVersion = 3,
                 Id = id,
                 Name = normalizedName,
                 CreatedAt = existing?.Document.CreatedAt ?? now,
@@ -76,9 +76,15 @@ public sealed class ProjectStorageService
                 IncludesCadastralParcels = includesCadastralParcels,
                 Folder = existing?.Document.Folder ?? string.Empty,
                 IsArchived = existing?.Document.IsArchived ?? false,
+                AccessMode = existing?.Document.AccessMode ?? "editable",
                 Map = snapshotDocument.RootElement.Clone()
             };
 
+            if (existing?.Document.AccessMode == "readonly")
+            {
+                throw new InvalidOperationException("Il progetto e' in sola lettura. Duplicalo per modificarlo.");
+            }
+
             var path = existing?.Path ?? Path.Combine(ProjectsDirectory, BuildFileName(normalizedName, id));
             var temporaryPath = path + ".tmp";
             try
@@ -131,6 +137,7 @@ public sealed class ProjectStorageService
                 UpdatedAt = now,
                 IncludesCadastralParcels = source.Document.IncludesCadastralParcels,
                 Folder = source.Document.Folder,
+                AccessMode = "editable",
                 Map = source.Document.Map.Clone()
             };
             var path = Path.Combine(ProjectsDirectory, BuildFileName(name, id));
@@ -240,7 +247,7 @@ public sealed class ProjectStorageService
         finally { _gate.Release(); }
     }
 
-    public async Task<string> CreateProjectPackageAsync(string projectId)
+    public async Task<string> CreateProjectPackageAsync(string projectId, bool readOnly = false)
     {
         await _gate.WaitAsync();
         try
@@ -249,8 +256,22 @@ public sealed class ProjectStorageService
                 ?? throw new FileNotFoundException("Il progetto selezionato non esiste piu'.");
             var directory = Path.Combine(FileSystem.CacheDirectory, "Projects");
             Directory.CreateDirectory(directory);
-            var path = Path.Combine(directory, Path.GetFileName(project.Path));
-            File.Copy(project.Path, path, true);
+            var mode = readOnly ? "readonly" : "editable";
+            var path = Path.Combine(directory, $"{Path.GetFileNameWithoutExtension(project.Path)}-{mode}{ProjectExtension}");
+            var package = new MapProjectDocument
+            {
+                SchemaVersion = 3,
+                Id = project.Document.Id,
+                Name = project.Document.Name,
+                CreatedAt = project.Document.CreatedAt,
+                UpdatedAt = project.Document.UpdatedAt,
+                IncludesCadastralParcels = project.Document.IncludesCadastralParcels,
+                Folder = project.Document.Folder,
+                IsArchived = false,
+                AccessMode = mode,
+                Map = project.Document.Map.Clone()
+            };
+            await File.WriteAllTextAsync(path, JsonSerializer.Serialize(package, _jsonOptions), new UTF8Encoding(false));
             return path;
         }
         finally { _gate.Release(); }
@@ -269,6 +290,7 @@ public sealed class ProjectStorageService
             source.Name = NormalizeName(source.Name);
             source.CreatedAt = source.UpdatedAt = DateTimeOffset.UtcNow;
             source.IsArchived = false;
+            source.AccessMode = source.AccessMode == "readonly" ? "readonly" : "editable";
             Directory.CreateDirectory(ProjectsDirectory);
             var target = Path.Combine(ProjectsDirectory, BuildFileName(source.Name, source.Id));
             await File.WriteAllTextAsync(target, JsonSerializer.Serialize(source, _jsonOptions), new UTF8Encoding(false));
@@ -316,6 +338,30 @@ public sealed class ProjectStorageService
         }
     }
 
+    public async Task<string> CreateScheduledBackupAsync(int keep = 10)
+    {
+        var source = await CreateBackupAsync();
+        var directory = Path.Combine(FileSystem.AppDataDirectory, "AutomaticBackups");
+        Directory.CreateDirectory(directory);
+        var target = Path.Combine(directory, $"LME-auto-{DateTime.Now:yyyyMMdd-HHmmss}.lmebackup.zip");
+        File.Copy(source, target, true);
+        foreach (var stale in Directory.EnumerateFiles(directory, "*.lmebackup.zip")
+                     .OrderByDescending(File.GetLastWriteTimeUtc).Skip(Math.Clamp(keep, 2, 30)))
+        {
+            File.Delete(stale);
+        }
+        return target;
+    }
+
+    public DateTimeOffset? GetLatestScheduledBackupTime()
+    {
+        var directory = Path.Combine(FileSystem.AppDataDirectory, "AutomaticBackups");
+        if (!Directory.Exists(directory)) return null;
+        var latest = Directory.EnumerateFiles(directory, "*.lmebackup.zip")
+            .OrderByDescending(File.GetLastWriteTimeUtc).FirstOrDefault();
+        return latest is null ? null : File.GetLastWriteTimeUtc(latest);
+    }
+
     private async Task<IReadOnlyList<ProjectFileEntry>> ReadProjectFilesAsync()
     {
         Directory.CreateDirectory(ProjectsDirectory);
@@ -397,9 +443,10 @@ public sealed class ProjectStorageService
         public bool IncludesCadastralParcels { get; set; }
         public string Folder { get; set; } = string.Empty;
         public bool IsArchived { get; set; }
+        public string AccessMode { get; set; } = "editable";
         public JsonElement Map { get; set; }
 
-        public MapProjectSummary ToSummary() => new(Id, Name, UpdatedAt, IncludesCadastralParcels, Folder, IsArchived);
+        public MapProjectSummary ToSummary() => new(Id, Name, UpdatedAt, IncludesCadastralParcels, Folder, IsArchived, AccessMode == "readonly");
     }
 }
 
@@ -409,6 +456,7 @@ public sealed record MapProjectSummary(
     DateTimeOffset UpdatedAt,
     bool IncludesCadastralParcels,
     string Folder,
-    bool IsArchived);
+    bool IsArchived,
+    bool IsReadOnly);
 
 public sealed record MapProjectVersion(string Id, DateTimeOffset UpdatedAt);
diff --git a/wwwroot/css/app.css b/wwwroot/css/app.css
index b411f0d..e0c69ae 100644
--- a/wwwroot/css/app.css
+++ b/wwwroot/css/app.css
@@ -7,7 +7,7 @@
     --accent: #14705e;
     --accent-strong: #0c5749;
     --warning: #a34b08;
-    --nav-height: 64px;
+    --nav-height: 0px;
 }
 
 html,
@@ -135,6 +135,70 @@ input[type="checkbox"] {
     flex: 0 0 auto;
 }
 
+.map-icon-command,
+.map-menu-button {
+    width: 38px;
+    min-width: 38px;
+    min-height: 38px;
+    padding: 0;
+    background: #fff;
+    color: var(--ink);
+    font-size: 22px;
+    line-height: 1;
+}
+
+.map-menu-button.is-active {
+    background: #ccebe3;
+    color: var(--accent-strong);
+}
+
+.app-status-line i {
+    display: inline-block;
+    width: 8px;
+    height: 8px;
+    margin-left: 5px;
+    border-radius: 50%;
+    background: #fbbf24;
+}
+
+.map-navigation-menu {
+    position: absolute;
+    top: 70px;
+    right: 12px;
+    z-index: 1150;
+    display: grid;
+    width: min(300px, calc(100vw - 24px));
+    max-height: calc(100vh - 84px);
+    overflow-y: auto;
+    border: 1px solid var(--line);
+    border-radius: 8px;
+    padding: 7px;
+    background: rgba(255, 255, 255, 0.99);
+    box-shadow: 0 5px 22px rgba(0, 0, 0, 0.3);
+}
+
+.map-navigation-menu > button {
+    min-height: 40px;
+    border-bottom: 1px solid #e5eaed;
+    border-radius: 0;
+    background: transparent;
+    color: var(--ink);
+    text-align: left;
+}
+
+.menu-credits {
+    display: grid;
+    gap: 3px;
+    padding: 10px 12px 5px;
+    color: var(--muted);
+    font-size: 10px;
+    line-height: 1.35;
+}
+
+.menu-credits a {
+    color: var(--accent-strong);
+}
+
 .layer-button.is-active {
     background: #ccebe3;
     color: var(--accent-strong);
@@ -558,6 +622,129 @@ input[type="checkbox"] {
     font-weight: 400;
 }
 
+.layer-inline-lock {
+    grid-area: visibility;
+    justify-self: center;
+    width: 28px;
+    min-width: 28px;
+    min-height: 24px;
+    margin-left: 26px;
+    padding: 0;
+    background: transparent;
+    color: var(--ink);
+    font-size: 15px;
+}
+
+.layer-inline-lock.is-locked {
+    background: #fff2cc;
+}
+
+.project-readonly .leaflet-draw,
+.project-readonly .layer-rename-button,
+.project-readonly .layer-remove-button,
+.project-readonly .layer-inline-lock,
+.project-readonly .layer-object-tools,
+.project-readonly .layer-group-tools,
+.project-readonly .layer-batch-actions {
+    pointer-events: none;
+    opacity: 0.5;
+}
+
+.lme-app-dialog {
+    position: absolute;
+    inset: 0;
+    z-index: 1500;
+    display: grid;
+    place-items: center;
+    padding: 16px;
+    background: rgba(15, 23, 28, 0.48);
+}
+
+.lme-app-dialog > section {
+    display: flex;
+    flex-direction: column;
+    width: min(820px, 96vw);
+    max-height: 88vh;
+    overflow: hidden;
+    border-radius: 8px;
+    background: #fff;
+    box-shadow: 0 8px 30px rgba(0, 0, 0, 0.32);
+}
+
+.lme-app-dialog header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    padding: 10px 12px;
+    border-bottom: 1px solid var(--line);
+}
+
+.lme-app-dialog header button {
+    width: 36px;
+    min-width: 36px;
+    min-height: 34px;
+    padding: 0;
+    background: #e9eef0;
+    color: var(--ink);
+    font-size: 22px;
+}
+
+.lme-app-dialog-body {
+    overflow: auto;
+    padding: 12px;
+}
+
+.object-table-wrap {
+    overflow: auto;
+}
+
+.object-table-wrap table {
+    width: 100%;
+    border-collapse: collapse;
+    font-size: 12px;
+}
+
+.object-table-wrap th,
+.object-table-wrap td {
+    padding: 7px;
+    border-bottom: 1px solid var(--line);
+    text-align: left;
+    white-space: nowrap;
+}
+
+.object-table-wrap button {
+    width: 30px;
+    min-width: 30px;
+    min-height: 30px;
+    padding: 0;
+}
+
+.object-table-search,
+.coordinate-result {
+    display: grid;
+    gap: 8px;
+    margin-bottom: 10px;
+}
+
+.release-notes {
+    max-height: 220px;
+    overflow: auto;
+    margin: 8px 0 0;
+    padding: 9px;
+    border: 1px solid var(--line);
+    border-radius: 6px;
+    background: #fff;
+    color: var(--ink);
+    font-family: inherit;
+    font-size: 11px;
+    white-space: pre-wrap;
+}
+
+.lme-offline-image-tile {
+    width: 256px;
+    height: 256px;
+}
+
 .layer-manager-count {
     grid-area: count;
     justify-self: end;
@@ -1171,6 +1358,11 @@ footer {
         width: 50vw;
     }
 
+    .map-navigation-menu {
+        top: 66px;
+        right: 8px;
+    }
+
     .tool-sheet {
         top: 10%;
         bottom: var(--nav-height);
diff --git a/wwwroot/js/lme-map.js b/wwwroot/js/lme-map.js
index f039a89..54b24b3 100644
--- a/wwwroot/js/lme-map.js
+++ b/wwwroot/js/lme-map.js
@@ -46,6 +46,7 @@ const lmeState = {
     gpsParcelLayer: null,
     gpsTrailEnabled: false,
     gpsTrailPoints: [],
+    gpsTrailStartedAt: null,
     gpsWatchId: null,
     lastPosition: null,
     fileImportBound: false,
@@ -82,6 +83,13 @@ const lmeState = {
     gpsProximityEnabled: true,
     gpsBoundaryAlertEnabled: false,
     lastBoundaryState: null,
+    trash: [],
+    auditLog: [],
+    isDirty: false,
+    readOnly: false,
+    changeNotifyTimer: null,
+    offlineDbPromise: null,
+    offlineTileCount: 0,
     dotNetReference: null
 };
 
@@ -115,6 +123,11 @@ window.lmeMap = {
     clearDrawings,
     undoMapChange,
     redoMapChange,
+    getHistoryState,
+    markProjectSaved,
+    hasUnsavedChanges: () => lmeState.isDirty,
+    confirmDiscardChanges,
+    setProjectReadOnly,
     restoreAutosave,
     compareProjectSnapshots,
     setAdvancedOptions,
@@ -133,10 +146,23 @@ window.lmeMap = {
     stopGps,
     centerOnGps,
     toggleTrail,
+    clearGpsTrail,
+    getGpsTrailStats,
     setNativeGpsPosition,
     setGpsPositionVisible,
     setGpsError,
     saveGpsMeasurementPoint,
+    restoreLastTrashItem,
+    emptyTrash,
+    showObjectTable,
+    showAuditLog,
+    showCoordinateInspector,
+    validateAndRepairSelected,
+    createHoleFromSelected,
+    compareSelectedGeometries,
+    downloadOfflineArea,
+    clearOfflineTiles,
+    getOfflineTileStats,
     resize,
     showInfo: setInfo
 };
@@ -150,7 +176,8 @@ function init(dotNetReference) {
     }
 
     lmeState.map = L.map("map", {
-        zoomControl: false
+        zoomControl: false,
+        attributionControl: false
     }).setView([41.9028, 12.4964], 17);
 
     L.control.zoom({ position: "bottomright" }).addTo(lmeState.map);
@@ -191,12 +218,7 @@ function init(dotNetReference) {
         maxZoom: 22,
         attribution: "&copy; OpenStreetMap contributors &copy; CARTO"
     });
-    lmeState.baseLayers.offline = L.gridLayer({ attribution: "Sfondo offline" });
-    lmeState.baseLayers.offline.createTile = () => {
-        const tile = document.createElement("div");
-        tile.className = "lme-offline-tile";
-        return tile;
-    };
+    lmeState.baseLayers.offline = createOfflineTileLayer();
 
     lmeState.currentBase = lmeState.baseLayers.satellite.addTo(lmeState.map);
     restoreLayerOrder();
@@ -262,6 +284,18 @@ function init(dotNetReference) {
         if (event.key === "Escape") {
             closeCadastrePreview();
         }
+        if ((event.ctrlKey || event.metaKey) && !event.shiftKey && event.key.toLowerCase() === "z") {
+            event.preventDefault();
+            undoMapChange();
+        } else if ((event.ctrlKey || event.metaKey) && (event.key.toLowerCase() === "y" || (event.shiftKey && event.key.toLowerCase() === "z"))) {
+            event.preventDefault();
+            redoMapChange();
+        }
+    });
+    window.addEventListener("beforeunload", event => {
+        if (!lmeState.isDirty) return;
+        event.preventDefault();
+        event.returnValue = "";
     });
     if (!lmeState.managerOutsideSelectionBound) {
         document.addEventListener("pointerdown", event => {
@@ -582,6 +616,9 @@ function bindFileImport() {
         }
 
         try {
+            if (file.size > 100 * 1024 * 1024) throw new Error("file superiore a 100 MB; suddividilo prima dell'importazione");
+            setInfo(`Analisi di ${file.name} (${(file.size / 1024 / 1024).toFixed(1)} MB)...`);
+            await new Promise(resolve => window.setTimeout(resolve, 20));
             const result = await readGisFile(file);
             rememberMapChange();
             const geojson = result.geojson;
@@ -600,7 +637,8 @@ function bindFileImport() {
                 ? `; ${sheetCount} elementi foglio ${lmeState.importedSheetsVisible ? "visibili" : "nascosti"}`
                 : "";
             const reprojected = result.reprojected ? "; coordinate Web Mercator convertite" : "";
-            setInfo(`Caricato ${file.name}: ${featureCount} particelle/elementi${includedSheets}${ignored}${reprojected}.`);
+            const warnings = result.validationWarnings ? `; ${result.validationWarnings} geometrie da verificare` : "";
+            setInfo(`Caricato ${file.name}: ${featureCount} particelle/elementi${includedSheets}${ignored}${reprojected}${warnings}.`);
             updateGpsInsideState();
             refreshLayerManager();
             finishMapChange();
@@ -717,6 +755,25 @@ function normalizeGeoJson(value, fileName) {
         throw new Error(`sistema di coordinate non supportato (${crsText.slice(0, 80)})`);
     }
 
+    let validationWarnings = 0;
+    const unique = new Set();
+    root.features = root.features.filter(feature => {
+        try { turf.cleanCoords(feature, { mutate: true }); } catch { }
+        const key = JSON.stringify(feature.geometry);
+        if (unique.has(key)) return false;
+        unique.add(key);
+        if (typeof turf.booleanValid === "function" && !turf.booleanValid(feature)) {
+            feature.properties._lmeValidationWarning = "Geometria non valida: usa Controlla e ripara";
+            validationWarnings++;
+        }
+        return true;
+    });
+    if (root.features.length > 5000 && window.confirm(`Il file contiene ${root.features.length} geometrie. Semplificarle leggermente per migliorare le prestazioni?`)) {
+        root.features = root.features.map(feature => {
+            try { return turf.simplify(feature, { tolerance: 0.000001, highQuality: true, mutate: false }); } catch { return feature; }
+        });
+    }
+
     const normalizedCoordinates = collectGeoJsonCoordinates(root);
     if (!normalizedCoordinates.length || normalizedCoordinates.some(point =>
         !Number.isFinite(point[0])
@@ -731,7 +788,8 @@ function normalizeGeoJson(value, fileName) {
         geojson: root,
         sheetGeojson: emptyFeatureCollection(),
         ignoredCount: 0,
-        reprojected: webMercator
+        reprojected: webMercator,
+        validationWarnings
     };
 }
 
@@ -1216,6 +1274,7 @@ function managedObjectCanRename(record) {
 }
 
 function renameManagedObject(record, index) {
+    if (lmeState.readOnly) { setInfo("Il progetto e' in sola lettura."); return; }
     if (!managedObjectCanRename(record)) {
         return;
     }
@@ -1359,6 +1418,7 @@ function clearManagedObjectState(id) {
 }
 
 function removeManagedRecords(records, subject) {
+    if (lmeState.readOnly) { setInfo("Il progetto e' in sola lettura."); return; }
     if (!records.length) {
         return;
     }
@@ -1373,6 +1433,16 @@ function removeManagedRecords(records, subject) {
         return;
     }
     rememberMapChange();
+    lmeState.trash.push({
+        removedAt: new Date().toISOString(),
+        subject,
+        items: records.map(record => ({
+            categoryKey: record.categoryKey,
+            source: record.source,
+            feature: record.layer.toGeoJSON()
+        }))
+    });
+    if (lmeState.trash.length > 30) lmeState.trash.shift();
     const removedIds = new Set(records.map(record => record.id));
     const categoryKeys = new Set(records.map(record => record.categoryKey));
     records.forEach(record => {
@@ -1395,7 +1465,7 @@ function removeManagedRecords(records, subject) {
     refreshDrawingMeasurements();
     updateGpsInsideState();
     refreshLayerManager();
-    finishMapChange();
+    finishMapChange(`Rimozione: ${subject}`);
     setInfo(`${records.length === 1 ? "Oggetto rimosso" : `${records.length} oggetti rimossi`} dal progetto.`);
 }
 
@@ -1505,11 +1575,16 @@ function renderLayerManagerCategory(category, records) {
     const categoryVisible = !lmeState.managerHiddenCategories.has(category.key)
         && (!category.roots.length || category.roots.some(layer => lmeState.map.hasLayer(layer)));
     const visible = categoryVisible;
-    group.innerHTML = `<summary><button type="button" class="layer-drag-handle" aria-label="Trascina gruppo">☰</button><input type="checkbox" ${visible ? "checked" : ""} aria-label="Mostra ${escapeHtml(categoryName)}"><span class="layer-manager-title">${escapeHtml(categoryName)}</span>${rowActions}${layerManagerMoveButtons("gruppo")}<span class="layer-manager-count">${records.length}</span></summary><div class="layer-manager-children"></div>`;
+    const categoryLocked = records.length > 0 && records.every(record => Boolean(record.layer?.feature?.properties?._lmeLocked));
+    group.innerHTML = `<summary><button type="button" class="layer-drag-handle" aria-label="Trascina gruppo">☰</button><input type="checkbox" ${visible ? "checked" : ""} aria-label="Mostra ${escapeHtml(categoryName)}"><span class="layer-manager-title">${escapeHtml(categoryName)}</span><button type="button" class="layer-inline-lock ${categoryLocked ? "is-locked" : ""}" aria-label="${categoryLocked ? "Sblocca" : "Blocca"} gruppo" title="${categoryLocked ? "Sblocca" : "Blocca"}">${categoryLocked ? "🔒" : "🔓"}</button>${rowActions}${layerManagerMoveButtons("gruppo")}<span class="layer-manager-count">${records.length}</span></summary><div class="layer-manager-children"></div>`;
     const checkbox = group.querySelector("input");
     checkbox.indeterminate = categoryVisible && records.length > 0 && visibleCount < records.length;
     checkbox.addEventListener("click", event => event.stopPropagation());
     checkbox.addEventListener("change", () => setManagedCategoryVisible(category, checkbox.checked));
+    group.querySelector(".layer-inline-lock")?.addEventListener("click", event => {
+        event.preventDefault(); event.stopPropagation();
+        updateManagedProperties(records, properties => { properties._lmeLocked = !categoryLocked; });
+    });
     group.querySelector(".layer-rename-button")?.addEventListener("click", event => {
         event.preventDefault();
         event.stopPropagation();
@@ -1553,7 +1628,8 @@ function renderLayerManagerBlock(category, source, records) {
         `<button type="button" class="layer-rename-button" aria-label="Rinomina gruppo" title="Rinomina">Rinomina</button>`,
         `<button type="button" class="layer-remove-button" aria-label="Rimuovi gruppo dal progetto" title="Rimuovi dal progetto">Rimuovi</button>`);
     block.classList.add("layer-manager-with-actions");
-    block.innerHTML = `<summary><button type="button" class="layer-drag-handle" aria-label="Trascina blocco">☰</button><input type="checkbox" ${visible ? "checked" : ""} aria-label="Mostra ${escapeHtml(blockName)}"><span class="layer-manager-title">${escapeHtml(blockName)}</span>${rowActions}${layerManagerMoveButtons("blocco")}<span class="layer-manager-count">${records.length}</span></summary><div class="layer-manager-children"></div>`;
+    const blockLocked = records.length > 0 && records.every(record => Boolean(record.layer?.feature?.properties?._lmeLocked));
+    block.innerHTML = `<summary><button type="button" class="layer-drag-handle" aria-label="Trascina blocco">☰</button><input type="checkbox" ${visible ? "checked" : ""} aria-label="Mostra ${escapeHtml(blockName)}"><span class="layer-manager-title">${escapeHtml(blockName)}</span><button type="button" class="layer-inline-lock ${blockLocked ? "is-locked" : ""}" aria-label="${blockLocked ? "Sblocca" : "Blocca"} gruppo" title="${blockLocked ? "Sblocca" : "Blocca"}">${blockLocked ? "🔒" : "🔓"}</button>${rowActions}${layerManagerMoveButtons("blocco")}<span class="layer-manager-count">${records.length}</span></summary><div class="layer-manager-children"></div>`;
     const checkbox = block.querySelector("input");
     checkbox.indeterminate = visibleCount > 0 && !visible;
     checkbox.addEventListener("click", event => event.stopPropagation());
@@ -1561,6 +1637,10 @@ function renderLayerManagerBlock(category, source, records) {
         records.forEach(record => setManagedObjectVisible(record, checkbox.checked, false));
         refreshLayerManager();
     });
+    block.querySelector(".layer-inline-lock")?.addEventListener("click", event => {
+        event.preventDefault(); event.stopPropagation();
+        updateManagedProperties(records, properties => { properties._lmeLocked = !blockLocked; });
+    });
     block.querySelector(".layer-rename-button").addEventListener("click", event => {
         event.preventDefault();
         event.stopPropagation();
@@ -1598,7 +1678,8 @@ function renderLayerManagerObject(record, index) {
     const rowActions = layerManagerRowActions(renameButton, removeButton);
     object.classList.toggle("layer-manager-with-actions", Boolean(rowActions));
     const objectName = managedObjectLabel(record, index);
-    object.innerHTML = `<summary><button type="button" class="layer-drag-handle" aria-label="Trascina oggetto">☰</button><input type="checkbox" ${visible ? "checked" : ""} aria-label="Mostra oggetto"><span class="layer-manager-title">${escapeHtml(objectName)}</span>${rowActions}${layerManagerMoveButtons("oggetto")}<span class="layer-manager-count">›</span></summary><div class="layer-manager-details"></div>`;
+    const locked = Boolean(record.layer?.feature?.properties?._lmeLocked);
+    object.innerHTML = `<summary><button type="button" class="layer-drag-handle" aria-label="Trascina oggetto">☰</button><input type="checkbox" ${visible ? "checked" : ""} aria-label="Mostra oggetto"><span class="layer-manager-title">${escapeHtml(objectName)}</span><button type="button" class="layer-inline-lock ${locked ? "is-locked" : ""}" aria-label="${locked ? "Sblocca" : "Blocca"} oggetto" title="${locked ? "Sblocca" : "Blocca"}">${locked ? "🔒" : "🔓"}</button>${rowActions}${layerManagerMoveButtons("oggetto")}<span class="layer-manager-count">›</span></summary><div class="layer-manager-details"></div>`;
     const checkbox = object.querySelector("input");
     checkbox.addEventListener("click", event => event.stopPropagation());
     checkbox.addEventListener("change", () => setManagedObjectVisible(record, checkbox.checked, true));
@@ -1612,6 +1693,11 @@ function renderLayerManagerObject(record, index) {
         event.stopPropagation();
         removeManagedRecords([record], `'${objectName}'`);
     });
+    object.querySelector(".layer-inline-lock")?.addEventListener("click", event => {
+        event.preventDefault();
+        event.stopPropagation();
+        updateManagedProperties([record], value => { value._lmeLocked = !locked; });
+    });
     object.querySelector(".layer-manager-title").addEventListener("click", event => {
         event.preventDefault();
         event.stopPropagation();
@@ -1740,7 +1826,7 @@ function renderManagedObjectTools(record) {
         <label>Note<textarea data-field="notes" rows="2" maxlength="1000" placeholder="Note tecniche">${escapeHtml(properties._lmeNotes || "")}</textarea></label>
         <label class="layer-photo-picker">Foto<input type="file" data-field="photo" accept="image/*"></label>
         ${properties._lmePhoto ? `<img class="layer-photo-preview" src="${properties._lmePhoto}" alt="Foto allegata"><button type="button" data-action="remove-photo">Rimuovi foto</button>` : ""}
-        <div class="layer-compact-actions"><button type="button" data-action="duplicate">Duplica</button><button type="button" data-action="numeric">Coordinate</button><button type="button" data-action="move">Sposta</button><button type="button" data-action="buffer">Buffer</button></div>`;
+        <div class="layer-compact-actions"><button type="button" data-action="attributes">Attributi</button><button type="button" data-action="duplicate">Duplica</button><button type="button" data-action="numeric">Coordinate</button><button type="button" data-action="inspect">WGS84 / UTM</button><button type="button" data-action="move">Sposta</button><button type="button" data-action="buffer">Buffer</button></div>`;
     tools.querySelector("[data-field='selected']").addEventListener("change", event => {
         if (event.target.checked) lmeState.managerSelectedObjectIds.add(record.id);
         else lmeState.managerSelectedObjectIds.delete(record.id);
@@ -1764,8 +1850,10 @@ function renderManagedObjectTools(record) {
         updateManagedProperties([record], value => { value._lmePhoto = dataUrl; });
     });
     tools.querySelector("[data-action='remove-photo']")?.addEventListener("click", () => updateManagedProperties([record], value => { delete value._lmePhoto; }));
+    tools.querySelector("[data-action='attributes']").addEventListener("click", () => editManagedAttributes(record));
     tools.querySelector("[data-action='duplicate']").addEventListener("click", () => duplicateManagedRecords([record]));
     tools.querySelector("[data-action='numeric']").addEventListener("click", () => numericEditManagedRecord(record));
+    tools.querySelector("[data-action='inspect']").addEventListener("click", () => showCoordinateInspectorForRecord(record));
     tools.querySelector("[data-action='move']").addEventListener("click", () => moveManagedRecords([record]));
     tools.querySelector("[data-action='buffer']").addEventListener("click", () => bufferManagedRecords([record]));
     return tools;
@@ -1775,7 +1863,120 @@ function normalizedColor(value, fallback) {
     return /^#[0-9a-f]{6}$/i.test(String(value || "")) ? value : fallback;
 }
 
+function editManagedAttributes(record) {
+    if (lmeState.readOnly) { setInfo("Il progetto e' in sola lettura."); return; }
+    const properties = record.layer?.feature?.properties || {};
+    const reserved = new Set(["name", "Name", "label", "LABEL"]);
+    const current = Object.entries(properties)
+        .filter(([key, value]) => !key.startsWith("_lme") && !reserved.has(key) && ["string", "number", "boolean"].includes(typeof value))
+        .map(([key, value]) => `${key}=${value}`).join("\n");
+    const value = window.prompt("Attributi, uno per riga nel formato chiave=valore\nEsempi: foglio, particella, proprietario, qualita, data_rilievo, stato", current);
+    if (value === null) return;
+    const parsed = {};
+    value.split(/\r?\n/).forEach(line => {
+        const separator = line.indexOf("=");
+        if (separator < 1) return;
+        const key = line.slice(0, separator).trim().replace(/[^a-zA-Z0-9_ -]/g, "_").slice(0, 60);
+        const raw = line.slice(separator + 1).trim().slice(0, 500);
+        if (key) parsed[key] = raw;
+    });
+    updateManagedProperties([record], target => {
+        Object.keys(target).filter(key => !key.startsWith("_lme") && !reserved.has(key)).forEach(key => delete target[key]);
+        Object.assign(target, parsed);
+    });
+    finishMapChange("Aggiornamento attributi");
+    setInfo(`${Object.keys(parsed).length} attributi aggiornati.`);
+}
+
+function utmFromLatLng(latitude, longitude) {
+    const zone = Math.floor((longitude + 180) / 6) + 1;
+    const central = (zone - 1) * 6 - 180 + 3;
+    const a = 6378137; const eccSquared = 0.00669438; const k0 = 0.9996;
+    const latRad = latitude * Math.PI / 180; const lonRad = longitude * Math.PI / 180; const lonOriginRad = central * Math.PI / 180;
+    const eccPrimeSquared = eccSquared / (1 - eccSquared);
+    const n = a / Math.sqrt(1 - eccSquared * Math.sin(latRad) ** 2);
+    const t = Math.tan(latRad) ** 2; const c = eccPrimeSquared * Math.cos(latRad) ** 2;
+    const aa = Math.cos(latRad) * (lonRad - lonOriginRad);
+    const m = a * ((1 - eccSquared / 4 - 3 * eccSquared ** 2 / 64 - 5 * eccSquared ** 3 / 256) * latRad
+        - (3 * eccSquared / 8 + 3 * eccSquared ** 2 / 32 + 45 * eccSquared ** 3 / 1024) * Math.sin(2 * latRad)
+        + (15 * eccSquared ** 2 / 256 + 45 * eccSquared ** 3 / 1024) * Math.sin(4 * latRad)
+        - (35 * eccSquared ** 3 / 3072) * Math.sin(6 * latRad));
+    const easting = k0 * n * (aa + (1 - t + c) * aa ** 3 / 6 + (5 - 18 * t + t ** 2 + 72 * c - 58 * eccPrimeSquared) * aa ** 5 / 120) + 500000;
+    let northing = k0 * (m + n * Math.tan(latRad) * (aa ** 2 / 2 + (5 - t + 9 * c + 4 * c ** 2) * aa ** 4 / 24
+        + (61 - 58 * t + t ** 2 + 600 * c - 330 * eccPrimeSquared) * aa ** 6 / 720));
+    if (latitude < 0) northing += 10000000;
+    return { zone, band: latitude >= 0 ? "N" : "S", easting, northing };
+}
+
+function recordCenter(record) {
+    if (typeof record?.layer?.getBounds === "function" && record.layer.getBounds().isValid()) return record.layer.getBounds().getCenter();
+    return record?.layer?.getLatLng?.() || null;
+}
+
+function showCoordinateInspectorForRecord(record) {
+    const point = recordCenter(record);
+    if (!point) { setInfo("Coordinate non disponibili per questo oggetto."); return; }
+    showCoordinateDialog(point, managedObjectEditableName(record) || "Oggetto selezionato");
+}
+
+function showCoordinateInspector() {
+    const records = [...lmeState.managerSelectedObjectIds].map(id => lmeState.managerRecords?.get(id)).filter(Boolean);
+    const highlighted = lmeState.managerRecords?.get(lmeState.managerHighlightedObjectId);
+    const record = highlighted || records[0];
+    const point = record ? recordCenter(record) : lmeState.map.getCenter();
+    showCoordinateDialog(point, record ? managedObjectEditableName(record) || "Oggetto selezionato" : "Centro mappa");
+}
+
+function showCoordinateDialog(point, title) {
+    const utm = utmFromLatLng(point.lat, point.lng);
+    const text = `WGS84: ${point.lat.toFixed(7)}, ${point.lng.toFixed(7)}\nUTM ${utm.zone}${utm.band}: E ${utm.easting.toFixed(2)} m, N ${utm.northing.toFixed(2)} m`;
+    showAppDialog(title, `<div class="coordinate-result"><strong>WGS84</strong><span>${point.lat.toFixed(7)}, ${point.lng.toFixed(7)}</span><strong>UTM zona ${utm.zone}${utm.band}</strong><span>E ${utm.easting.toFixed(2)} m<br>N ${utm.northing.toFixed(2)} m</span><button type="button" data-copy-coordinate>Copia coordinate</button></div>`);
+    document.querySelector("[data-copy-coordinate]")?.addEventListener("click", async () => {
+        await navigator.clipboard?.writeText(text);
+        setInfo("Coordinate copiate.");
+    });
+}
+
+function showAppDialog(title, bodyHtml) {
+    document.getElementById("lmeAppDialog")?.remove();
+    const overlay = document.createElement("div");
+    overlay.id = "lmeAppDialog";
+    overlay.className = "lme-app-dialog";
+    overlay.innerHTML = `<section role="dialog" aria-modal="true"><header><strong>${escapeHtml(title)}</strong><button type="button" aria-label="Chiudi">×</button></header><div class="lme-app-dialog-body">${bodyHtml}</div></section>`;
+    overlay.querySelector("header button").addEventListener("click", () => overlay.remove());
+    overlay.addEventListener("click", event => { if (event.target === overlay) overlay.remove(); });
+    document.querySelector(".map-app")?.appendChild(overlay);
+    return overlay;
+}
+
+function showObjectTable() {
+    const records = layerManagerCategories().flatMap(category => managedRecordsForCategory(category));
+    const body = records.map((record, index) => {
+        const properties = record.layer?.feature?.properties || {};
+        const details = managedObjectDetails(record.layer);
+        return `<tr data-object-id="${escapeHtml(record.id)}"><td><button type="button" data-locate="${escapeHtml(record.id)}">⌖</button></td><td>${escapeHtml(managedObjectLabel(record, index))}</td><td>${escapeHtml(record.categoryKey)}</td><td>${escapeHtml(properties.foglio || properties.FOGLIO || "")}</td><td>${escapeHtml(properties.particella || properties.PARTICELLA || properties.LABEL || "")}</td><td>${escapeHtml(details.slice(0, 2).join(" | "))}</td></tr>`;
+    }).join("");
+    const dialog = showAppDialog("Elenco oggetti e particelle", `<label class="object-table-search">Filtra<input type="search" placeholder="Nome, foglio, particella o gruppo"></label><div class="object-table-wrap"><table><thead><tr><th></th><th>Nome</th><th>Gruppo</th><th>Foglio</th><th>Particella</th><th>Misure</th></tr></thead><tbody>${body || "<tr><td colspan='6'>Nessun oggetto</td></tr>"}</tbody></table></div>`);
+    const byId = new Map(records.map(record => [record.id, record]));
+    dialog.querySelector("input").addEventListener("input", event => {
+        const query = event.target.value.toLocaleLowerCase("it");
+        dialog.querySelectorAll("tbody tr").forEach(row => { row.hidden = query && !row.textContent.toLocaleLowerCase("it").includes(query); });
+    });
+    dialog.querySelectorAll("[data-locate]").forEach(button => button.addEventListener("click", () => {
+        const record = byId.get(button.dataset.locate); if (!record) return;
+        dialog.remove(); highlightManagedObject(record);
+    }));
+    return records.length;
+}
+
+function showAuditLog() {
+    const rows = [...lmeState.auditLog].reverse().map(item => `<tr><td>${escapeHtml(new Date(item.at).toLocaleString("it-IT"))}</td><td>${escapeHtml(item.action || "Modifica mappa")}</td></tr>`).join("");
+    showAppDialog("Registro operazioni", `<div class="object-table-wrap"><table><thead><tr><th>Data e ora</th><th>Operazione</th></tr></thead><tbody>${rows || "<tr><td colspan='2'>Nessuna operazione registrata</td></tr>"}</tbody></table></div>`);
+    return lmeState.auditLog.length;
+}
+
 function updateManagedProperties(records, change) {
+    if (lmeState.readOnly) { setInfo("Il progetto e' in sola lettura."); return; }
     rememberMapChange();
     records.forEach(record => {
         record.layer.feature ||= { type: "Feature", properties: {} };
@@ -1868,6 +2069,7 @@ function storedFeatureStyle(feature) {
 }
 
 function duplicateManagedRecords(records) {
+    if (lmeState.readOnly) { setInfo("Il progetto e' in sola lettura."); return; }
     if (records.some(record => record.layer?.feature?.properties?._lmeLocked)) { setInfo("Sblocca gli oggetti da duplicare."); return; }
     rememberMapChange();
     records.forEach((record, index) => {
@@ -1887,6 +2089,7 @@ function duplicateManagedRecords(records) {
 }
 
 function moveManagedRecords(records) {
+    if (lmeState.readOnly) { setInfo("Il progetto e' in sola lettura."); return; }
     if (records.some(record => record.layer?.feature?.properties?._lmeLocked)) { setInfo("Sblocca gli oggetti da spostare."); return; }
     const north = Number(window.prompt("Spostamento verso nord in metri (negativo verso sud)", "0"));
     if (!Number.isFinite(north)) return;
@@ -1903,6 +2106,7 @@ function moveManagedRecords(records) {
 }
 
 function bufferManagedRecords(records) {
+    if (lmeState.readOnly) { setInfo("Il progetto e' in sola lettura."); return; }
     const meters = Number(window.prompt("Distanza buffer in metri", "5"));
     if (!Number.isFinite(meters) || meters <= 0) return;
     rememberMapChange();
@@ -1917,6 +2121,7 @@ function bufferManagedRecords(records) {
 }
 
 function unionManagedRecords(records) {
+    if (lmeState.readOnly) { setInfo("Il progetto e' in sola lettura."); return; }
     const polygons = records.filter(record => record.layer instanceof L.Polygon).map(record => record.layer.toGeoJSON());
     if (polygons.length < 2) { setInfo("Per unire seleziona almeno due aree o poligoni."); return; }
     try {
@@ -1932,6 +2137,7 @@ function unionManagedRecords(records) {
 }
 
 function splitManagedRecords(records) {
+    if (lmeState.readOnly) { setInfo("Il progetto e' in sola lettura."); return; }
     const polygonRecord = records.find(record => record.layer instanceof L.Polygon);
     const lineRecord = records.find(record => record.layer instanceof L.Polyline && !(record.layer instanceof L.Polygon));
     if (!polygonRecord || !lineRecord) { setInfo("Per dividere seleziona un poligono e una linea di taglio."); return; }
@@ -1951,7 +2157,88 @@ function splitManagedRecords(records) {
     } catch (error) { setInfo(`Divisione non riuscita: ${error.message}`); }
 }
 
+function selectedManagedRecords() {
+    const current = lmeState.managerRecords || new Map();
+    return [...lmeState.managerSelectedObjectIds].map(id => current.get(id)).filter(Boolean);
+}
+
+function createHoleFromSelected() {
+    if (lmeState.readOnly) { setInfo("Il progetto e' in sola lettura."); return false; }
+    const polygons = selectedManagedRecords().filter(record => record.layer instanceof L.Polygon);
+    if (polygons.length !== 2) { setInfo("Seleziona esattamente due poligoni: prima l'area esterna e poi l'area da escludere."); return false; }
+    try {
+        const ordered = [...polygons].sort((left, right) => turf.area(right.layer.toGeoJSON()) - turf.area(left.layer.toGeoJSON()));
+        const outer = ordered[0].layer.toGeoJSON();
+        const inner = ordered[1].layer.toGeoJSON();
+        if (!turf.booleanWithin(inner, outer)) throw new Error("il poligono interno deve essere completamente contenuto nell'area esterna");
+        const result = turf.difference(turf.featureCollection([outer, inner]));
+        if (!result) throw new Error("nessun risultato geometrico");
+        rememberMapChange();
+        result.properties = { ...(outer.properties || {}), name: `${managedObjectLabel(ordered[0], 0)} con area esclusa`, _lmeManagerId: undefined };
+        addDrawingFeature(result, true);
+        ordered.forEach(removeRecordWithoutPrompt);
+        lmeState.managerSelectedObjectIds.clear();
+        finishManagedGeometryChange("Poligono con foro creato correttamente.");
+        return true;
+    } catch (error) { setInfo(`Creazione foro non riuscita: ${error.message}`); return false; }
+}
+
+function validateAndRepairSelected() {
+    if (lmeState.readOnly) { setInfo("Il progetto e' in sola lettura."); return "Progetto in sola lettura"; }
+    const records = selectedManagedRecords();
+    if (!records.length) { setInfo("Seleziona gli oggetti da controllare."); return "Nessuna selezione"; }
+    let valid = 0; let repaired = 0; let rejected = 0;
+    rememberMapChange();
+    records.forEach((record, index) => {
+        try {
+            let feature = turf.cleanCoords(record.layer.toGeoJSON(), { mutate: false });
+            if (feature.geometry?.type === "Polygon" && typeof turf.booleanValid === "function" && !turf.booleanValid(feature)) {
+                const parts = turf.unkinkPolygon(feature).features;
+                if (!parts.length) throw new Error("geometria non riparabile");
+                removeRecordWithoutPrompt(record);
+                parts.forEach((part, partIndex) => {
+                    part.properties = { ...(feature.properties || {}), name: `${managedObjectLabel(record, index)} - riparato ${partIndex + 1}`, _lmeManagerId: undefined };
+                    addDrawingFeature(part);
+                });
+                repaired++;
+            } else {
+                if (JSON.stringify(feature.geometry) !== JSON.stringify(record.layer.toGeoJSON().geometry)) {
+                    replaceManagedLayer(record, feature); repaired++;
+                } else valid++;
+            }
+        } catch { rejected++; }
+    });
+    lmeState.managerSelectedObjectIds.clear();
+    finishManagedGeometryChange(`Controllo geometrie: ${valid} valide, ${repaired} riparate, ${rejected} non riparabili.`);
+    return `${valid} valide, ${repaired} riparate, ${rejected} non riparabili`;
+}
+
+function compareSelectedGeometries() {
+    if (lmeState.readOnly) { setInfo("Il progetto e' in sola lettura."); return false; }
+    const polygons = selectedManagedRecords().filter(record => record.layer instanceof L.Polygon);
+    if (polygons.length !== 2) { setInfo("Seleziona esattamente due poligoni da confrontare."); return false; }
+    try {
+        const first = polygons[0].layer.toGeoJSON(); const second = polygons[1].layer.toGeoJSON();
+        const onlyFirst = turf.difference(turf.featureCollection([first, second]));
+        const onlySecond = turf.difference(turf.featureCollection([second, first]));
+        const overlap = turf.intersect(turf.featureCollection([first, second]));
+        rememberMapChange();
+        const addResult = (feature, name, color) => {
+            if (!feature) return;
+            feature.properties = { name, _lmeColor: color, _lmeFillColor: color, _lmeFillOpacity: 0.38, _lmeManagerId: undefined };
+            addDrawingFeature(feature);
+        };
+        addResult(onlyFirst, `Solo ${managedObjectLabel(polygons[0], 0)}`, "#ef4444");
+        addResult(onlySecond, `Solo ${managedObjectLabel(polygons[1], 1)}`, "#3b82f6");
+        addResult(overlap, "Sovrapposizione", "#16a34a");
+        const firstArea = onlyFirst ? turf.area(onlyFirst) : 0; const secondArea = onlySecond ? turf.area(onlySecond) : 0;
+        finishManagedGeometryChange(`Confronto creato: eccedenza ${formatArea(firstArea)}, mancanza ${formatArea(secondArea)}.`);
+        return true;
+    } catch (error) { setInfo(`Confronto non riuscito: ${error.message}`); return false; }
+}
+
 function numericEditManagedRecord(record) {
+    if (lmeState.readOnly) { setInfo("Il progetto e' in sola lettura."); return; }
     if (record.layer?.feature?.properties?._lmeLocked) { setInfo("Sblocca prima l'oggetto."); return; }
     if (record.layer instanceof L.Circle) {
         const center = record.layer.getLatLng();
@@ -2004,20 +2291,76 @@ function rememberMapChange() {
 }
 
 function finishMapChange() {
-    if (!lmeState.autoSaveEnabled || lmeState.historyBusy || !lmeState.map) return;
-    try { localStorage.setItem("lmeAutosaveV3", createProjectSnapshot(true)); } catch { }
+    if (lmeState.historyBusy || !lmeState.map) return;
+    const action = arguments[0] || "Modifica mappa";
+    lmeState.isDirty = true;
+    lmeState.auditLog.push({ at: new Date().toISOString(), action });
+    if (lmeState.auditLog.length > 250) lmeState.auditLog.shift();
+    if (lmeState.autoSaveEnabled) {
+        try { localStorage.setItem("lmeAutosaveV3", createProjectSnapshot(true)); } catch { }
+    }
+    window.clearTimeout(lmeState.changeNotifyTimer);
+    lmeState.changeNotifyTimer = window.setTimeout(() => {
+        void lmeState.dotNetReference?.invokeMethodAsync("OnMapChanged", action);
+    }, 450);
+}
+
+function getHistoryState() {
+    return { canUndo: lmeState.undoStack.length > 0, canRedo: lmeState.redoStack.length > 0, dirty: lmeState.isDirty };
+}
+
+function markProjectSaved() {
+    lmeState.isDirty = false;
+    void lmeState.dotNetReference?.invokeMethodAsync("OnProjectSaved");
+}
+
+function confirmDiscardChanges(actionLabel) {
+    return !lmeState.isDirty || window.confirm(`Ci sono modifiche non salvate. Continuare e ${actionLabel || "abbandonarle"}?`);
+}
+
+function setProjectReadOnly(enabled) {
+    lmeState.readOnly = Boolean(enabled);
+    document.querySelector(".map-app")?.classList.toggle("project-readonly", lmeState.readOnly);
+    if (lmeState.readOnly) setDrawToolsVisible(false);
+    refreshLayerManager();
+    setInfo(lmeState.readOnly ? "Progetto aperto in sola lettura. Duplicalo per modificarlo." : "Progetto modificabile.");
 }
 
 function undoMapChange() {
     if (!lmeState.undoStack.length) { setInfo("Nessuna operazione da annullare."); return; }
     lmeState.redoStack.push(createProjectSnapshot(true));
     restoreHistorySnapshot(lmeState.undoStack.pop(), "Operazione annullata.");
+    lmeState.isDirty = true;
 }
 
 function redoMapChange() {
     if (!lmeState.redoStack.length) { setInfo("Nessuna operazione da ripristinare."); return; }
     lmeState.undoStack.push(createProjectSnapshot(true));
     restoreHistorySnapshot(lmeState.redoStack.pop(), "Operazione ripristinata.");
+    lmeState.isDirty = true;
+}
+
+function restoreLastTrashItem() {
+    if (lmeState.readOnly) { setInfo("Il progetto e' in sola lettura."); return false; }
+    const entry = lmeState.trash.pop();
+    if (!entry) { setInfo("Il cestino e' vuoto."); return false; }
+    rememberMapChange();
+    entry.items.forEach(item => {
+        if (item.categoryKey === "imported") addImportedFeatures({ type: "FeatureCollection", features: [item.feature] });
+        else if (item.categoryKey === "importedSheets") addImportedSheetFeatures({ type: "FeatureCollection", features: [item.feature] });
+        else addDrawingFeature(item.feature);
+    });
+    refreshLayerManager();
+    finishManagedGeometryChange(`Ripristinati ${entry.items.length} oggetti dal cestino.`);
+    return true;
+}
+
+function emptyTrash() {
+    if (!lmeState.trash.length) { setInfo("Il cestino e' gia vuoto."); return 0; }
+    if (!window.confirm(`Eliminare definitivamente ${lmeState.trash.reduce((sum, entry) => sum + entry.items.length, 0)} oggetti dal cestino?`)) return lmeState.trash.length;
+    lmeState.trash = [];
+    setInfo("Cestino svuotato.");
+    return 0;
 }
 
 function restoreHistorySnapshot(snapshot, message) {
@@ -2597,7 +2940,7 @@ function addImportedFeatures(geojson) {
             fillColor: "#ffffff",
             fillOpacity: 0.9
         }),
-        onEachFeature: (feature, layer) => { bindStoredFeaturePopup(feature, layer); applyStyleFromProperties(layer); }
+        onEachFeature: (feature, layer) => { bindStoredFeaturePopup(feature, layer); applyStyleFromProperties(layer); bindManagedMapSelection(layer, "imported", lmeState.imported); }
     }).addTo(lmeState.imported);
     layer.lmeManagerLabel = managedGeoJsonLabel(geojson, "Dati importati");
     return layer;
@@ -2614,7 +2957,7 @@ function addImportedSheetFeatures(geojson) {
             fillColor: "#ffffff",
             fillOpacity: 0.85
         }),
-        onEachFeature: (feature, layer) => { bindStoredFeaturePopup(feature, layer); applyStyleFromProperties(layer); }
+        onEachFeature: (feature, layer) => { bindStoredFeaturePopup(feature, layer); applyStyleFromProperties(layer); bindManagedMapSelection(layer, "importedSheets", lmeState.importedSheets); }
     }).addTo(lmeState.importedSheets);
     layer.lmeManagerLabel = managedGeoJsonLabel(geojson, "Cornice o foglio");
     return layer;
@@ -2717,6 +3060,10 @@ function bindDrawingEvents() {
         return;
     }
     lmeState.map.on(L.Draw.Event.CREATED, event => {
+        if (lmeState.readOnly) {
+            setInfo("Il progetto e' in sola lettura.");
+            return;
+        }
         snapDrawingLayer(event.layer);
         annotateDrawingLayer(event.layer, event.layerType);
         lmeState.drawings.addLayer(event.layer);
@@ -3047,7 +3394,37 @@ function bindDrawingLayerSelection(layer) {
             event.originalEvent._lmeDrawingSelected = true;
             L.DomEvent.stopPropagation(event.originalEvent);
         }
+        const id = managedLayerId(layer, "drawings");
+        if (event.originalEvent?.ctrlKey || event.originalEvent?.metaKey || event.originalEvent?.shiftKey) {
+            if (lmeState.managerSelectedObjectIds.has(id)) lmeState.managerSelectedObjectIds.delete(id);
+            else lmeState.managerSelectedObjectIds.add(id);
+        } else {
+            lmeState.managerSelectedObjectIds.clear();
+            lmeState.managerSelectedObjectIds.add(id);
+        }
         selectDrawingLayer(layer);
+        refreshLayerManager();
+    });
+}
+
+function bindManagedMapSelection(layer, categoryKey, parent) {
+    if (layer.lmeManagedMapSelectionBound) return;
+    layer.lmeManagedMapSelectionBound = true;
+    layer.on("click", event => {
+        if (Date.now() < lmeState.ignoreMapClickUntil) return;
+        lmeState.ignoreMapClickUntil = Date.now() + 600;
+        if (event.originalEvent) {
+            event.originalEvent._lmeDrawingSelected = true;
+            L.DomEvent.stopPropagation(event.originalEvent);
+        }
+        const record = { id: managedLayerId(layer, categoryKey), categoryKey, layer, parent, source: String(layer?.feature?.properties?._lmeSource || "Progetto corrente") };
+        const multiple = event.originalEvent?.ctrlKey || event.originalEvent?.metaKey || event.originalEvent?.shiftKey;
+        if (!multiple) lmeState.managerSelectedObjectIds.clear();
+        if (multiple && lmeState.managerSelectedObjectIds.has(record.id)) lmeState.managerSelectedObjectIds.delete(record.id);
+        else lmeState.managerSelectedObjectIds.add(record.id);
+        highlightManagedObject(record);
+        refreshLayerManager();
+        setInfo(`Selezionato dalla mappa: ${managedObjectEditableName(record) || "oggetto"}.`);
     });
 }
 
@@ -3103,15 +3480,32 @@ function clearDrawings() {
 function snapDrawingLayer(layer) {
     if (!lmeState.snapEnabled || !layer || layer instanceof L.Circle || layer instanceof L.Marker) return;
     const candidates = [];
+    const segments = [];
     layerManagerCategories().forEach(category => managedRecordsForCategory(category).forEach(record => {
         if (record.layer === layer) return;
-        lineLatLngGroups(record.layer?.getLatLngs?.() || []).forEach(line => line.forEach(point => candidates.push(point)));
+        lineLatLngGroups(record.layer?.getLatLngs?.() || []).forEach(line => {
+            line.forEach(point => candidates.push(point));
+            for (let index = 1; index < line.length; index++) segments.push([line[index - 1], line[index]]);
+            if (record.layer instanceof L.Polygon && line.length > 2) segments.push([line.at(-1), line[0]]);
+        });
         const point = record.layer?.getLatLng?.(); if (point) candidates.push(point);
     }));
     const snapPoint = point => {
         const pixel = lmeState.map.latLngToContainerPoint(point);
         let nearest = null; let distance = lmeState.snapDistancePixels;
         candidates.forEach(candidate => { const current = pixel.distanceTo(lmeState.map.latLngToContainerPoint(candidate)); if (current < distance) { distance = current; nearest = candidate; } });
+        segments.forEach(([start, end]) => {
+            const a = lmeState.map.latLngToContainerPoint(start); const b = lmeState.map.latLngToContainerPoint(end);
+            const lengthSquared = (b.x - a.x) ** 2 + (b.y - a.y) ** 2;
+            if (!lengthSquared) return;
+            const ratio = Math.max(0, Math.min(1, ((pixel.x - a.x) * (b.x - a.x) + (pixel.y - a.y) * (b.y - a.y)) / lengthSquared));
+            const projected = L.point(a.x + ratio * (b.x - a.x), a.y + ratio * (b.y - a.y));
+            const current = pixel.distanceTo(projected);
+            if (current < distance) { distance = current; nearest = lmeState.map.containerPointToLatLng(projected); }
+            const midpoint = L.point((a.x + b.x) / 2, (a.y + b.y) / 2);
+            const midpointDistance = pixel.distanceTo(midpoint);
+            if (midpointDistance < distance) { distance = midpointDistance; nearest = lmeState.map.containerPointToLatLng(midpoint); }
+        });
         return nearest ? L.latLng(nearest.lat, nearest.lng) : point;
     };
     const transform = value => Array.isArray(value) ? value.map(transform) : snapPoint(value);
@@ -3448,7 +3842,7 @@ function circleToPolygon(center, radiusMeters) {
 function createProjectSnapshot(includeCadastralParcels) {
     const center = lmeState.map.getCenter();
     return JSON.stringify({
-        schemaVersion: 4,
+        schemaVersion: 5,
         view: {
             latitude: center.lat,
             longitude: center.lng,
@@ -3465,7 +3859,9 @@ function createProjectSnapshot(includeCadastralParcels) {
         trail: lmeState.gpsTrailPoints.map(point => [
             Number(point.lat ?? point[0]),
             Number(point.lng ?? point[1])
-        ])
+        ]),
+        trailStartedAt: lmeState.gpsTrailStartedAt,
+        auditLog: [...lmeState.auditLog]
     });
 }
 
@@ -3548,6 +3944,8 @@ function loadProjectSnapshot(raw, projectName) {
         }).addTo(lmeState.selectedParcelsLayer);
 
         lmeState.gpsTrailPoints = Array.isArray(data.trail) ? data.trail : [];
+        lmeState.gpsTrailStartedAt = data.trailStartedAt || null;
+        lmeState.auditLog = Array.isArray(data.auditLog) ? data.auditLog.slice(-250) : [];
         lmeState.gpsTrail.setLatLngs(lmeState.gpsTrailPoints);
         if (projectDisplayOptions) {
             applyProjectDisplayOptions(projectDisplayOptions);
@@ -3584,6 +3982,12 @@ function loadProjectSnapshot(raw, projectName) {
             : "";
         setInfo(`Progetto caricato: ${projectName || "senza nome"}.${hiddenSheets}`);
         refreshLayerManager();
+        if (!lmeState.historyBusy) {
+            lmeState.isDirty = false;
+            lmeState.undoStack = [];
+            lmeState.redoStack = [];
+            void lmeState.dotNetReference?.invokeMethodAsync("OnProjectSaved");
+        }
         return captureDisplayOptions();
     } catch (error) {
         setInfo(`Progetto non leggibile: ${error.message}`);
@@ -3798,6 +4202,136 @@ function updateStoredFeaturePopup(layer, sourceProperties) {
     }
 }
 
+function offlineDatabase() {
+    if (lmeState.offlineDbPromise) return lmeState.offlineDbPromise;
+    lmeState.offlineDbPromise = new Promise((resolve, reject) => {
+        const request = indexedDB.open("lmeOfflineMaps", 1);
+        request.onupgradeneeded = () => request.result.createObjectStore("tiles", { keyPath: "key" });
+        request.onsuccess = () => resolve(request.result);
+        request.onerror = () => reject(request.error);
+    });
+    return lmeState.offlineDbPromise;
+}
+
+async function offlineTileGet(key) {
+    const db = await offlineDatabase();
+    return new Promise((resolve, reject) => {
+        const request = db.transaction("tiles", "readonly").objectStore("tiles").get(key);
+        request.onsuccess = () => resolve(request.result || null);
+        request.onerror = () => reject(request.error);
+    });
+}
+
+async function offlineTilePut(value) {
+    const db = await offlineDatabase();
+    return new Promise((resolve, reject) => {
+        const request = db.transaction("tiles", "readwrite").objectStore("tiles").put(value);
+        request.onsuccess = () => resolve();
+        request.onerror = () => reject(request.error);
+    });
+}
+
+function createOfflineTileLayer() {
+    const layer = L.gridLayer({ attribution: "Tessere salvate offline", maxZoom: 22 });
+    layer.createTile = (coords, done) => {
+        const tile = document.createElement("img");
+        tile.alt = "";
+        tile.className = "lme-offline-image-tile";
+        offlineTileGet(`${coords.z}/${coords.x}/${coords.y}`).then(record => {
+            if (!record?.blob) {
+                tile.className = "lme-offline-tile";
+                done(null, tile);
+                return;
+            }
+            const url = URL.createObjectURL(record.blob);
+            tile.onload = () => { URL.revokeObjectURL(url); done(null, tile); };
+            tile.onerror = error => { URL.revokeObjectURL(url); done(error, tile); };
+            tile.src = url;
+        }).catch(error => done(error, tile));
+        return tile;
+    };
+    return layer;
+}
+
+function offlineSourceUrl(provider, z, x, y) {
+    const urls = {
+        osm: `https://a.tile.openstreetmap.org/${z}/${x}/${y}.png`,
+        satellite: `https://server.arcgisonline.com/ArcGIS/rest/services/World_Imagery/MapServer/tile/${z}/${y}/${x}`,
+        topographic: `https://server.arcgisonline.com/ArcGIS/rest/services/World_Topo_Map/MapServer/tile/${z}/${y}/${x}`,
+        "streets-esri": `https://server.arcgisonline.com/ArcGIS/rest/services/World_Street_Map/MapServer/tile/${z}/${y}/${x}`,
+        terrain: `https://a.tile.opentopomap.org/${z}/${x}/${y}.png`,
+        carto: `https://a.basemaps.cartocdn.com/rastertiles/voyager/${z}/${x}/${y}.png`
+    };
+    return urls[provider] || null;
+}
+
+function longitudeToTileX(longitude, zoom) {
+    return Math.floor((longitude + 180) / 360 * 2 ** zoom);
+}
+
+function latitudeToTileY(latitude, zoom) {
+    const value = Math.max(-85.0511, Math.min(85.0511, latitude)) * Math.PI / 180;
+    return Math.floor((1 - Math.log(Math.tan(value) + 1 / Math.cos(value)) / Math.PI) / 2 * 2 ** zoom);
+}
+
+async function downloadOfflineArea(extraZoomLevels = 2) {
+    const provider = lmeState.currentBaseName;
+    if (!offlineSourceUrl(provider, 0, 0, 0)) {
+        throw new Error("Per il download offline usa prima uno sfondo Esri, OpenStreetMap, OpenTopoMap o CARTO.");
+    }
+    const bounds = lmeState.map.getBounds();
+    const startZoom = Math.max(1, lmeState.map.getZoom());
+    const endZoom = Math.min(19, startZoom + Math.max(0, Math.min(4, Number(extraZoomLevels) || 0)));
+    const tiles = [];
+    for (let z = startZoom; z <= endZoom; z++) {
+        const max = 2 ** z - 1;
+        const x1 = Math.max(0, Math.min(max, longitudeToTileX(bounds.getWest(), z)));
+        const x2 = Math.max(0, Math.min(max, longitudeToTileX(bounds.getEast(), z)));
+        const y1 = Math.max(0, Math.min(max, latitudeToTileY(bounds.getNorth(), z)));
+        const y2 = Math.max(0, Math.min(max, latitudeToTileY(bounds.getSouth(), z)));
+        for (let x = Math.min(x1, x2); x <= Math.max(x1, x2); x++) {
+            for (let y = Math.min(y1, y2); y <= Math.max(y1, y2); y++) tiles.push({ z, x, y });
+        }
+    }
+    if (tiles.length > 600) throw new Error(`Area troppo ampia (${tiles.length} tessere). Aumenta lo zoom o riduci la zona visibile.`);
+    let saved = 0;
+    for (const tile of tiles) {
+        const key = `${tile.z}/${tile.x}/${tile.y}`;
+        if (await offlineTileGet(key)) { saved++; continue; }
+        const response = await fetch(offlineSourceUrl(provider, tile.z, tile.x, tile.y), { mode: "cors" });
+        if (!response.ok) continue;
+        await offlineTilePut({ key, blob: await response.blob(), provider, savedAt: new Date().toISOString() });
+        saved++;
+        if (saved % 10 === 0) setInfo(`Mappe offline: ${saved}/${tiles.length} tessere salvate...`);
+    }
+    lmeState.offlineTileCount = await getOfflineTileStats();
+    lmeState.baseLayers.offline.redraw();
+    setInfo(`Area offline pronta: ${saved} tessere, zoom ${startZoom}-${endZoom}.`);
+    return { saved, requested: tiles.length, startZoom, endZoom };
+}
+
+async function getOfflineTileStats() {
+    const db = await offlineDatabase();
+    return new Promise((resolve, reject) => {
+        const request = db.transaction("tiles", "readonly").objectStore("tiles").count();
+        request.onsuccess = () => resolve(request.result || 0);
+        request.onerror = () => reject(request.error);
+    });
+}
+
+async function clearOfflineTiles() {
+    const db = await offlineDatabase();
+    await new Promise((resolve, reject) => {
+        const request = db.transaction("tiles", "readwrite").objectStore("tiles").clear();
+        request.onsuccess = () => resolve();
+        request.onerror = () => reject(request.error);
+    });
+    lmeState.offlineTileCount = 0;
+    lmeState.baseLayers.offline.redraw();
+    setInfo("Archivio mappe offline svuotato.");
+    return true;
+}
+
 function setBaseLayer(name) {
     const selected = lmeState.baseLayers[name] || lmeState.baseLayers.satellite;
     if (lmeState.currentBase) {
@@ -3813,7 +4347,7 @@ function setBaseLayer(name) {
         topographic: "Topografica Esri",
         terrain: "OpenTopoMap",
         carto: "CARTO Voyager",
-        offline: "Offline, solo dati vettoriali",
+        offline: "Mappe salvate offline",
         "azure-road": "Strade Azure Maps",
         "azure-satellite": "Satellite Azure Maps",
         "google-satellite": "Satellite Google Maps",
@@ -3973,14 +4507,10 @@ function setAzureAttribution(text) {
         return;
     }
     lmeState.azureAttribution = escapeHtml(text);
-    lmeState.map.attributionControl.addAttribution(lmeState.azureAttribution);
 }
 
 function clearAzureAttribution() {
-    if (lmeState.azureAttribution) {
-        lmeState.map.attributionControl.removeAttribution(lmeState.azureAttribution);
-        lmeState.azureAttribution = null;
-    }
+    lmeState.azureAttribution = null;
 }
 
 function htmlToText(value) {
@@ -4220,9 +4750,26 @@ function centerOnGps() {
 
 function toggleTrail(enabled) {
     lmeState.gpsTrailEnabled = enabled;
-    if (!enabled) {
-        setInfo("Registrazione percorso disattivata.");
-    }
+    if (enabled && !lmeState.gpsTrailStartedAt) lmeState.gpsTrailStartedAt = new Date().toISOString();
+    setInfo(enabled ? "Registrazione percorso avviata." : "Registrazione percorso in pausa.");
+}
+
+function clearGpsTrail() {
+    if (!lmeState.gpsTrailPoints.length) { setInfo("La traccia GPS e' vuota."); return false; }
+    if (!window.confirm("Eliminare definitivamente la traccia GPS corrente?")) return false;
+    rememberMapChange();
+    lmeState.gpsTrailPoints = [];
+    lmeState.gpsTrail.setLatLngs([]);
+    lmeState.gpsTrailStartedAt = null;
+    finishMapChange("Eliminazione traccia GPS");
+    setInfo("Traccia GPS eliminata.");
+    return true;
+}
+
+function getGpsTrailStats() {
+    const length = lmeState.gpsTrailPoints.reduce((sum, point, index) => index ? sum + lmeState.map.distance(lmeState.gpsTrailPoints[index - 1], point) : 0, 0);
+    const durationSeconds = lmeState.gpsTrailStartedAt ? Math.max(0, Math.round((Date.now() - new Date(lmeState.gpsTrailStartedAt).getTime()) / 1000)) : 0;
+    return { points: lmeState.gpsTrailPoints.length, length, durationSeconds, recording: lmeState.gpsTrailEnabled };
 }
 
 function onGpsPosition(position) {