Speed up Android test packages

Always retain KML lines and points
Use existing Base signing certificate
2026-09-28 20:29:51 +02:00 · 2026-09-28 20:29:21 +02:00 · 2026-09-28 19:55:22 +02:00 · 2026-09-28 19:42:26 +02:00 · 2026-09-25 22:44:54 +02:00 · 2026-09-25 21:33:53 +02:00
29 changed files with 11429 additions and 327 deletions
@@ -0,0 +1,115 @@
+<details class="menu-help">
+    <summary>
+        <span aria-hidden="true">?</span>
+        <strong>Guida rapida</strong>
+    </summary>
+    <div class="menu-help-content">
+        <p>@Introduction</p>
+        <ol>
+            @foreach (var instruction in Instructions)
+            {
+                <li>@instruction</li>
+            }
+        </ol>
+    </div>
+</details>
+
+@code {
+    [Parameter, EditorRequired]
+    public string Topic { get; set; } = string.Empty;
+
+    private string Introduction => Topic switch
+    {
+        "layers" => "Qui controlli visibilita, ordine, selezione e organizzazione di tutti gli oggetti presenti sulla mappa.",
+        "cadastre" => "Trova una particella nel catalogo catastale e mostrane il confine ufficiale sulla mappa.",
+        "data" => "Importa file GIS, crea disegni e misure oppure aggiungi punti di interesse.",
+        "save" => "Esporta gli elementi della mappa in un file compatibile con altre applicazioni GIS e GPS.",
+        "projects" => "Salva il lavoro completo, riaprilo, organizzalo e recupera revisioni o copie di sicurezza.",
+        "tools" => "Consulta e gestisci gli oggetti in modo avanzato, controlla le coordinate e prepara mappe offline.",
+        "settings" => "Personalizza mappa, salvataggi, GPS, sincronizzazione e servizi esterni.",
+        _ => "Consulta le indicazioni essenziali per usare questo pannello."
+    };
+
+    private IReadOnlyList<string> Instructions => Topic switch
+    {
+        "layers" =>
+        [
+            "Visibilita: usa la casella di una categoria o di un gruppo per mostrare o nascondere tutti i suoi contenuti; la casella del singolo oggetto agisce solo su quello.",
+            "Gerarchia: premi la freccia accanto alla maniglia per aprire un gruppo. Il rientro, il carattere e la tonalita indicano se una riga e figlia, nipote o di livello successivo.",
+            "Selezione multipla: attiva il flag sulle righe desiderate. Esempio: seleziona tre poligoni per esportare solo quelli oppure per bloccarli con una sola operazione.",
+            "Rinomina e attributi: Rinomina modifica il nome mostrato e salvato nei progetti e nei file esportati; Attributi apre un editor multilinea per consultare o correggere i dati associati.",
+            "Colori: espandi un padre o un figlio e usa gli editor di linea e riempimento. Puoi scegliere il colore, prelevarlo con il contagocce se supportato, oppure inserire e copiare i valori HEX, RGB e HSL; sul padre viene applicato a tutto il gruppo.",
+            "Blocco: il lucchetto impedisce modifiche e spostamenti involontari. Sblocca l'oggetto prima di usare la matita o gli strumenti geometrici.",
+            "Sposta nel gruppo cambia l'appartenenza. Esempio: trasferisci un poligono da Disegni e POI a Progetti e dati importati, oppure in un nuovo sottogruppo chiamato Rilievo nord.",
+            "Sposta geometria cambia invece le coordinate dell'oggetto, per esempio 100 metri verso nord; non modifica il gruppo di appartenenza.",
+            "Rimuovi dal progetto nasconde l'elemento e lo esclude dai salvataggi successivi; Elimina lo sposta nel cestino. Usa gli strumenti avanzati per ripristinare l'ultima rimozione o svuotare definitivamente il cestino.",
+            "Ordine: trascina la maniglia di una riga verso l'alto o il basso per cambiare la sovrapposizione sulla mappa."
+        ],
+        "cadastre" =>
+        [
+            "Compila i campi nell'ordine Regione, Comune, Foglio e Particella: ogni scelta carica l'elenco necessario al campo successivo.",
+            "Esempio: scegli Campania, il Comune, il foglio 12 e la particella 345, poi premi Mostra particella sulla mappa.",
+            "Il confine ufficiale viene evidenziato sulla mappa. Se Centra e zooma quando seleziono un oggetto e attivo nelle Impostazioni, la mappa lo inquadra automaticamente.",
+            "Se la particella e gia presente tra disegni, progetti o file GeoJSON, KML e KMZ, l'app riconosce il riferimento catastale o la geometria e riutilizza l'oggetto esistente senza duplicarlo.",
+            "Se un oggetto gia presente era nascosto, viene reso nuovamente visibile. La visibilita generale dei contorni evidenziati e dei dati importati resta controllabile dal pannello Layer.",
+            "Quando il servizio ufficiale non restituisce subito il confine, attendi il completamento indicato nel pannello e riprova mantenendo gli stessi dati selezionati."
+        ],
+        "data" =>
+        [
+            "Importazione: premi Carica KML, KMZ o GeoJSON e scegli il file dal dispositivo. I nomi e gli attributi riconosciuti vengono mantenuti.",
+            "Per KML e KMZ, Includi anche il layer del foglio conserva le cornici presenti nel file. Mostra cornice/layer del foglio recupera inoltre dal servizio ufficiale una cornice distinta per ciascun foglio delle particelle, senza creare un unico riquadro tra fogli lontani.",
+            "Usa Mostra dati importati e Mostra cornice per controllare separatamente la visibilita. Inquadra dati porta la mappa sull'estensione completa del file.",
+            "Disegno: premi Mostra strumenti sulla mappa, torna alla mappa e scegli linea, poligono, rettangolo, cerchio o POI nella barra Leaflet.",
+            "Modifica ed eliminazione possono agire sull'oggetto selezionato o su tutti i disegni. Prima seleziona sulla mappa la linea o il poligono interessato, poi scegli l'ambito dal piccolo comando accanto alla matita o al cestino.",
+            "Annulla e Ripristina coprono disegni, spostamenti, rinomine ed eliminazioni recenti. Recupera ultimo autosalvataggio ricarica invece l'ultima copia locale creata automaticamente.",
+            "Esempio POI: porta il centro della mappa sull'ingresso di un terreno, scrivi Cancello nord e premi Aggiungi POI al centro mappa.",
+            "Per rinominare, bloccare o trasferire un oggetto in un altro gruppo, apri Layer e usa i comandi della relativa riga."
+        ],
+        "save" =>
+        [
+            "Inserisci un nome riconoscibile, per esempio Rilievo particelle 12-345, poi scegli il formato in base all'uso previsto.",
+            "GeoJSON e adatto ai software GIS e conserva geometrie, nomi e attributi; KML e KMZ sono adatti a Google Earth, con KMZ piu compatto per invio e archiviazione.",
+            "GPX e pensato per dispositivi e applicazioni GPS; PDF crea un rapporto consultabile e stampabile invece di un file vettoriale modificabile.",
+            "Attiva solo le categorie da includere. Esempio: per consegnare disegni e particelle importate senza la traccia GPS, lascia attive quelle due voci e disattiva Traccia GPS.",
+            "Solo oggetti selezionati esporta esclusivamente le righe contrassegnate nel pannello Layer. Se non devi filtrare manualmente, lascia questa opzione disattivata.",
+            "Premi Esporta e salva file e scegli la cartella o l'app di destinazione proposta dal dispositivo.",
+            "Nomi rinominati e attributi vengono salvati in GeoJSON, KML e KMZ. Gli sfondi satellitari, stradali e WMS non vengono incorporati nei file vettoriali."
+        ],
+        "projects" =>
+        [
+            "Nuovo progetto: inserisci un nome, scegli se includere i contorni catastali evidenziati e premi Salva progetto. Vengono conservati oggetti, gruppi, nomi, attributi e opzioni di visualizzazione.",
+            "Aggiornamento: dopo aver aperto un progetto, usa di nuovo Salva progetto con lo stesso nome per aggiornarlo. Se nelle Impostazioni attivi Aggiorna automaticamente il progetto aperto, le modifiche vengono registrate dopo 3 secondi di inattivita.",
+            "Cartelle: seleziona un progetto, scrivi per esempio Cantieri 2026 e premi Sposta per organizzarlo nell'archivio; questa operazione non sposta le geometrie sulla mappa.",
+            "Rinomina cambia il nome del progetto selezionato senza alterarne contenuti e revisioni. Duplica crea invece una copia modificabile, utile prima di una variante importante o quando ricevi un progetto in sola lettura.",
+            "Archivia nasconde logicamente i lavori conclusi senza eliminarli; Ripristina li riporta tra quelli attivi. Elimina rimuove invece il progetto dall'archivio.",
+            "Condividi modificabile consente al destinatario di continuare il lavoro; Condividi in sola lettura protegge l'originale e richiede una duplicazione per modificarlo.",
+            "Revisioni: la prima viene creata quando salvi per la seconda volta un progetto gia esistente. L'elenco si aggiorna anche dopo i salvataggi automatici; seleziona una data e usa Apri revisione oppure Confronta.",
+            "Backup: Crea backup raccoglie tutti i progetti in un file trasferibile. Ripristina backup ricarica un archivio completo; Importa progetto aggiunge invece un singolo progetto condiviso."
+        ],
+        "tools" =>
+        [
+            "Tabella oggetti: apre una vista ordinata di particelle, file importati e disegni. Usa i flag per selezionare piu righe, il lucchetto per proteggerle e la matita per modificare i metadati.",
+            "Copia metadati: nella maschera Metadati oggetto scegli Copia da e l'oggetto sorgente. Attiva Importa anche i valori per copiare nomi e contenuti; disattivalo per creare soltanto gli stessi campi, lasciandoli vuoti o mantenendo i valori gia presenti.",
+            "Coordinate WGS84 e UTM: scegli un punto sulla mappa per leggere latitudine e longitudine oppure le coordinate metriche UTM, utili per rilievi e confronti tecnici.",
+            "Registro operazioni: mostra in ordine cronologico disegni, modifiche, rinomine, spostamenti ed eliminazioni, cosi puoi capire cosa e cambiato durante la sessione.",
+            "Cestino: Ripristina ultima rimozione recupera l'elemento eliminato piu recente. Svuota cestino elimina definitivamente tutti gli elementi rimossi e non consente ulteriori recuperi.",
+            "Mappe offline: prima inquadra sulla mappa la zona che ti servira sul campo, quindi scegli quanti livelli di zoom aggiuntivi scaricare. Valori maggiori offrono piu dettaglio ma richiedono piu spazio e tempo.",
+            "Esempio offline: inquadra il cantiere e le strade di accesso, imposta 2 livelli aggiuntivi e premi Scarica area visibile mentre hai connessione.",
+            "Usa mappe offline seleziona lo sfondo salvato localmente; Svuota archivio libera lo spazio occupato dalle tessere scaricate."
+        ],
+        "settings" =>
+        [
+            "Mappa e sfondo: scegli la cartografia di base e regola Trasparenza catasto per leggere meglio confini e immagini sottostanti. Esempio: riducila quando le linee coprono dettagli del terreno.",
+            "Autosalvataggio locale dopo ogni modifica: se attivo, ogni disegno, modifica, rinomina o eliminazione aggiorna immediatamente una copia di recupero nel dispositivo. Per usarla apri Dati e disegni e premi Recupera ultimo autosalvataggio.",
+            "Aggiorna automaticamente il progetto aperto: funziona solo dopo aver aperto o salvato un progetto modificabile. Dopo una modifica attende 3 secondi senza altre operazioni e aggiorna quel progetto; un progetto in sola lettura non viene mai sovrascritto.",
+            "Backup automatico: scegli Giornaliero o Settimanale. Alla successiva pressione di Salva progetto, se e trascorso l'intervallo, viene creata una copia interna di tutti i progetti; l'app conserva le 10 copie automatiche piu recenti. Disattivato non crea nuove copie programmate.",
+            "Esempio consigliato: lascia attivo l'autosalvataggio locale, attiva l'aggiornamento del progetto aperto durante i rilievi e imposta un backup giornaliero. Prima di modifiche importanti crea anche un backup manuale dal menu Progetti.",
+            "Aggancio ai vertici: avvicinando un nuovo vertice a uno esistente, l'app lo allinea entro la distanza in pixel scelta. Aumenta la distanza su schermi piccoli; riducila quando ci sono molti vertici ravvicinati.",
+            "Centra e zooma quando seleziono un oggetto: attivalo per inquadrare automaticamente ogni elemento scelto; disattivalo se vuoi mantenere ferma la vista mentre lavori dall'elenco Layer.",
+            "WebDAV: inserisci indirizzo, utente e password applicazione, salva la configurazione, poi usa Invia al cloud per caricare il backup o Scarica dal cloud per ripristinare quello remoto.",
+            "GPS e percorso: Mostra punto visualizza posizione e precisione; Registra traccia memorizza il cammino; distanza e avvisi aiutano a controllare l'avvicinamento e l'attraversamento del confine selezionato.",
+            "Google Maps e Azure Maps richiedono le rispettive chiavi solo quando scegli quegli sfondi. Controlla nuova versione confronta la versione installata con l'ultima pubblicata e mostra le relative modifiche."
+        ],
+        _ => []
+    };
+}
@@ -1,8 +1,8 @@
 <Project Sdk="Microsoft.NET.Sdk.Razor">

    <PropertyGroup>
-        <TargetFrameworks>net9.0-android;net9.0-ios;net9.0-maccatalyst</TargetFrameworks>
-        <TargetFrameworks Condition="$([MSBuild]::IsOSPlatform('windows'))">$(TargetFrameworks);net9.0-windows10.0.19041.0</TargetFrameworks>
+        <TargetFrameworks>net10.0-android;net10.0-ios;net10.0-maccatalyst</TargetFrameworks>
+        <TargetFrameworks Condition="$([MSBuild]::IsOSPlatform('windows'))">$(TargetFrameworks);net10.0-windows10.0.19041.0</TargetFrameworks>
        <!-- Uncomment to also build the tizen app. You will need to install tizen by following this: https://github.com/Samsung/Tizen.NET -->
        <!-- <TargetFrameworks>$(TargetFrameworks);net9.0-tizen</TargetFrameworks> -->

@@ -28,8 +28,9 @@
        <ApplicationId>com.companyname.lmemappecatastaliapp</ApplicationId>

        <!-- Versions -->
-        <ApplicationDisplayVersion>0.2.0</ApplicationDisplayVersion>
-        <ApplicationVersion>4</ApplicationVersion>
+        <ApplicationDisplayVersion>0.4.9</ApplicationDisplayVersion>
+        <ApplicationVersion>44</ApplicationVersion>
+        <Version>$(ApplicationDisplayVersion)</Version>

        <!-- To develop, package, and publish an app to the Microsoft Store, see: https://aka.ms/MauiTemplateUnpackaged -->
        <WindowsPackageType>None</WindowsPackageType>
@@ -42,9 +43,17 @@
        <SupportedOSPlatformVersion Condition="$([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'tizen'">6.5</SupportedOSPlatformVersion>
    </PropertyGroup>

+    <PropertyGroup Condition="'$(Configuration)' == 'Release' and $([MSBuild]::GetTargetPlatformIdentifier('$(TargetFramework)')) == 'android'">
+        <AndroidTargetSdkVersion>36</AndroidTargetSdkVersion>
+        <AndroidPackageFormat>aab</AndroidPackageFormat>
+        <AndroidUseAapt2>true</AndroidUseAapt2>
+        <AndroidCreatePackagePerAbi>false</AndroidCreatePackagePerAbi>
+        <RunAOTCompilation>true</RunAOTCompilation>
+    </PropertyGroup>
+
    <ItemGroup>
        <!-- App Icon -->
-        <MauiIcon Include="Resources\AppIcon\appicon.svg" ForegroundFile="Resources\AppIcon\appiconfg.svg" Color="#512BD4" />
+        <MauiIcon Include="Resources\AppIcon\appicon.svg" ForegroundFile="Resources\AppIcon\appiconfg.svg" Color="#075E54" />

        <!-- Splash Screen -->
        <MauiSplashScreen Include="Resources\Splash\splash.svg" Color="#512BD4" BaseSize="128,128" />
@@ -63,7 +72,7 @@
    <ItemGroup>
        <PackageReference Include="Microsoft.Maui.Controls" Version="$(MauiVersion)" />
        <PackageReference Include="Microsoft.AspNetCore.Components.WebView.Maui" Version="$(MauiVersion)" />
-        <PackageReference Include="Microsoft.Extensions.Logging.Debug" Version="9.0.9" />
+        <PackageReference Include="Microsoft.Extensions.Logging.Debug" Version="10.0.12" />
        <PackageReference Include="Parquet.Net" Version="6.1.0" />
    </ItemGroup>

@@ -18,6 +18,15 @@ public static class MauiProgram
        builder.Services.AddMauiBlazorWebView();
        builder.Services.AddSingleton<PreciseLocationService>();
        builder.Services.AddSingleton<CadastralCatalogService>();
+        builder.Services.AddSingleton<OfficialCadastreService>();
+        builder.Services.AddSingleton<LocationSearchService>();
+        builder.Services.AddSingleton<NetworkLocationService>();
+        builder.Services.AddSingleton<AzureMapsService>();
+        builder.Services.AddSingleton<ProjectStorageService>();
+        builder.Services.AddSingleton<MapExportService>();
+        builder.Services.AddSingleton<CloudSyncService>();
+        builder.Services.AddSingleton<AppUpdateService>();
+        builder.Services.AddSingleton(IncomingFileService.Shared);

 #if DEBUG
        builder.Services.AddBlazorWebViewDeveloperTools();
@@ -1,10 +1,75 @@
-using Android.App;
+using Android.App;
+using Android.Content;
 using Android.Content.PM;
+using Android.Database;
 using Android.OS;
+using Android.Provider;
+using LMEMappeCatastaliApp.Services;

 namespace LMEMappeCatastaliApp;

-[Activity(Theme = "@style/Maui.SplashTheme", MainLauncher = true, ConfigurationChanges = ConfigChanges.ScreenSize | ConfigChanges.Orientation | ConfigChanges.UiMode | ConfigChanges.ScreenLayout | ConfigChanges.SmallestScreenSize | ConfigChanges.Density)]
+[Activity(Theme = "@style/Maui.SplashTheme", MainLauncher = true, LaunchMode = LaunchMode.SingleTop, ConfigurationChanges = ConfigChanges.ScreenSize | ConfigChanges.Orientation | ConfigChanges.UiMode | ConfigChanges.ScreenLayout | ConfigChanges.SmallestScreenSize | ConfigChanges.Density)]
+[IntentFilter([Intent.ActionView], Categories = [Intent.CategoryDefault, Intent.CategoryBrowsable], DataMimeType = "application/json")]
+[IntentFilter([Intent.ActionView], Categories = [Intent.CategoryDefault, Intent.CategoryBrowsable], DataMimeType = "application/geo+json")]
+[IntentFilter([Intent.ActionView], Categories = [Intent.CategoryDefault, Intent.CategoryBrowsable], DataMimeType = "application/geojson")]
+[IntentFilter([Intent.ActionView], Categories = [Intent.CategoryDefault, Intent.CategoryBrowsable], DataMimeType = "application/vnd.google-earth.kml+xml")]
+[IntentFilter([Intent.ActionView], Categories = [Intent.CategoryDefault, Intent.CategoryBrowsable], DataMimeType = "application/vnd.google-earth.kmz")]
+[IntentFilter([Intent.ActionView], Categories = [Intent.CategoryDefault, Intent.CategoryBrowsable], DataMimeType = "application/xml")]
+[IntentFilter([Intent.ActionView], Categories = [Intent.CategoryDefault, Intent.CategoryBrowsable], DataMimeType = "text/xml")]
+[IntentFilter([Intent.ActionView], Categories = [Intent.CategoryDefault, Intent.CategoryBrowsable], DataMimeType = "application/zip")]
+[IntentFilter([Intent.ActionView], Categories = [Intent.CategoryDefault, Intent.CategoryBrowsable], DataMimeType = "application/x-zip-compressed")]
+[IntentFilter([Intent.ActionView], Categories = [Intent.CategoryDefault, Intent.CategoryBrowsable], DataMimeType = "application/octet-stream")]
 public class MainActivity : MauiAppCompatActivity
 {
+    protected override void OnCreate(Bundle? savedInstanceState)
+    {
+        base.OnCreate(savedInstanceState);
+        QueueViewedFile(Intent);
+    }
+
+    protected override void OnNewIntent(Intent? intent)
+    {
+        base.OnNewIntent(intent);
+        Intent = intent;
+        QueueViewedFile(intent);
+    }
+
+    private void QueueViewedFile(Intent? intent)
+    {
+        if (intent?.Action == Android.Content.Intent.ActionView && intent.Data is not null)
+        {
+            _ = CopyViewedFileAsync(intent);
+        }
+    }
+
+    private async Task CopyViewedFileAsync(Intent intent)
+    {
+        try
+        {
+            var uri = intent.Data!;
+            var fileName = ReadDisplayName(uri) ?? $"file-{Guid.NewGuid():N}";
+            fileName = string.Concat(fileName.Select(character => Path.GetInvalidFileNameChars().Contains(character) ? '_' : character));
+            var directory = Path.Combine(FileSystem.CacheDirectory, "Incoming");
+            Directory.CreateDirectory(directory);
+            var path = Path.Combine(directory, $"{Guid.NewGuid():N}-{fileName}");
+            await using var input = ContentResolver!.OpenInputStream(uri)
+                ?? throw new IOException("Impossibile leggere il file selezionato.");
+            await using var output = File.Create(path);
+            await input.CopyToAsync(output);
+            IncomingFileService.Shared.Enqueue(new IncomingFile(path, fileName, intent.Type));
+        }
+        catch (Exception error)
+        {
+            System.Diagnostics.Debug.WriteLine($"Apertura file LME non riuscita: {error}");
+        }
+    }
+
+    private string? ReadDisplayName(Android.Net.Uri uri)
+    {
+        if (uri.Scheme == ContentResolver.SchemeFile) return Path.GetFileName(uri.Path);
+        using ICursor? cursor = ContentResolver?.Query(uri, [IOpenableColumns.DisplayName], null, null, null);
+        if (cursor is null || !cursor.MoveToFirst()) return null;
+        var index = cursor.GetColumnIndex(IOpenableColumns.DisplayName);
+        return index >= 0 ? cursor.GetString(index) : null;
+    }
 }
@@ -2,24 +2,131 @@

 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.9

- Mappa interattiva Leaflet con sfondo satellitare Esri e sfondo stradale OpenStreetMap.
+- Linee e punti KML/KMZ vengono sempre importati, anche quando il documento viene riconosciuto come catastale; il filtro particelle separa soltanto i poligoni di foglio o cornice.
+
+## Versione 0.4.8
+
+- Aggiornamento a .NET 10 e target Android API 36.
+- KML e KMZ generici conservano punti, linee e poligoni; il filtro particelle viene applicato soltanto ai file riconosciuti come catastali.
+- Android propone LME tra le app disponibili per aprire KML, KMZ, GeoJSON, progetti JSON e backup ZIP.
+- I selettori file Android mostrano correttamente progetti condivisi e backup con estensione composta.
+
+## Versione 0.4.7
+
+- La ricerca nel pannello Layer conserva correttamente posizione e selezione del cursore durante il filtraggio; digitando `pio` il testo non viene piu invertito in `oip`.
+- L'elenco revisioni viene aggiornato dopo salvataggi manuali e automatici, rinomina, importazione e selezione del progetto.
+- Il pannello Progetti mostra quante revisioni sono disponibili e spiega quando un progetto appena creato non possiede ancora versioni precedenti.
+
+## Versione 0.4.6
+
+- `Mostra cornice/layer del foglio` carica dal WFS ufficiale AdE il vero confine `CP:CadastralZoning` di ciascun foglio delle particelle.
+- Le particelle appartenenti a fogli diversi producono cornici distinte, senza piu creare un unico rettangolo cumulativo tra aree lontane.
+- Le cornici gia presenti nel progetto o trasferite in un altro gruppo vengono riconosciute e non vengono scaricate o duplicate.
+- Ogni foglio e salvato come oggetto autonomo e puo essere rinominato, bloccato, rimosso o spostato in un altro gruppo dal pannello Layer.
+- I vecchi riquadri cumulativi generati automaticamente vengono rimossi durante il caricamento e sostituiti dai fogli ufficiali.
+
+## Versione 0.4.5
+
+- Corretto il layout del pannello Layer sui telefoni e sui foldable: checkbox, lucchetto, ordinamento e freccia di espansione non si sovrappongono e restano allineati.
+- La tabella oggetti include un comando dedicato per modificare i metadati di ciascun elemento.
+- L'editor metadati permette di copiare i campi da un altro oggetto, scegliendo se importare anche i valori oppure soltanto i nomi.
+- Il pannello Progetti consente di rinominare un progetto duplicato o esistente senza perdere contenuti, identita e revisioni.
+- La barra Leaflet include una guida completa con istruzioni ed esempi concreti per disegno, modifica, eliminazione, riparazione, fori e confronto confini.
+
+## Versione 0.4.4
+
+- I comandi `Rinomina`, `Sposta nel gruppo` e `Rimuovi` occupano una riga completa e restano visibili anche nei pannelli Layer molto stretti.
+- `Sposta nel gruppo` e disponibile per padri e figli di disegni, dati importati, cornici, fogli importati e particelle evidenziate dalla ricerca catastale.
+- Editor distinti per linea e riempimento su gruppi e singoli oggetti, con contagocce dove supportato e valori modificabili HEX, RGB e HSL.
+- Copia HEX per riutilizzare esattamente un colore su altri oggetti; stili conservati nei progetti e negli export.
+- Rimossi dai menu i riferimenti al colore rosso fisso delle particelle catastali.
+- Nei progetti in sola lettura anche il trasferimento tra gruppi viene correttamente disabilitato.
+
+## Versione 0.4.3
+
+- `Mostra particella sulla mappa` riattiva sempre il layer dei confini rossi e lo porta in primo piano.
+- Una particella gia evidenziata o temporaneamente nascosta viene recuperata senza creare duplicati.
+- Deduplicazione estesa alle particelle presenti in progetti e file GeoJSON, KML e KMZ, tramite riferimenti catastali o confronto geometrico.
+- Ricerca WFS ampliata per rendere piu affidabile il recupero dei confini di particelle estese o irregolari.
+- Guida rapida collassabile in fondo a Layer e a ogni pannello operativo, con istruzioni specifiche per le relative funzioni.
+
+## Versione 0.4.2
+
+- Nuovo comando `Sposta nel gruppo` visibile accanto a Rinomina e Rimuovi per padri, sottogruppi e singoli oggetti.
+- Scelta della categoria e del sottogruppo di destinazione, con possibilita di creare un nuovo gruppo.
+- I disegni possono essere organizzati in sottogruppi come i dati importati.
+- `Sposta geometria` resta separato e continua a traslare gli oggetti in metri verso nord, sud, est o ovest.
+
+## Versione 0.4.1
+
+- Pannelli operativi allineati a destra, con ricerca lasciata nella posizione precedente.
+- Espansione della gerarchia Layer esclusivamente tramite freccia accanto alla maniglia di trascinamento.
+- Colori coerenti tra gruppo padre e figli, intensita progressiva per livello e conteggio figli in grassetto.
+- Spostamento dei gruppi tra `Disegni e POI` e `Progetti e dati importati`.
+- Rinomine persistenti nei progetti e negli export GeoJSON, KML e KMZ.
+- Gli oggetti e i gruppi rimossi dal progetto non vengono piu inclusi nei salvataggi e negli export.
+- Editor interni per rinomina, attributi multilinea, coordinate, spostamento e buffer.
+- Selezione multipla e blocco disponibili anche nella tabella oggetti e particelle.
+- Evidenziazione nel Layer dell'oggetto selezionato sulla mappa e centratura automatica opzionale, disattivata per impostazione predefinita.
+- Strumenti controllo/riparazione, foro e confronto nella barra Leaflet, con risultati visibili in una finestra dedicata.
+- Comandi del pannello Progetti disposti verticalmente senza scorrimento orizzontale.
+
+## 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.
 - Trasparenza configurabile del layer catastale.
 - Interrogazione WMS con click/tap sulla mappa.
 - Import di file KML, KMZ, GeoJSON e JSON.
+- Import GeoJSON compatibile con BOM, geometrie singole, array, FeatureCollection e coordinate Web Mercator EPSG:3857.
+- Filtro KML/KMZ `solo particelle` attivo per impostazione predefinita, con separazione dei MultiPolygon ed esclusione di GroundOverlay e perimetri del foglio; il layer foglio resta importabile e puo essere mostrato o nascosto separatamente.
+- 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.
- POI/progetti salvabili in locale con `localStorage`.
+- 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.
+- 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.
+- Punto e cerchio di precisione del GPS live possono essere mostrati o nascosti dalle impostazioni senza fermare il rilevamento.
 - 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 Catasto, Progetti 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 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.
+- Anteprima WMS ufficiale mostrata dentro l'app senza aprire una nuova finestra Android.
+- Confini delle particelle selezionate e della particella GPS sovrapposti anche all'anteprima WMS corrente.
+- Richieste WMS catastali in EPSG:4258 compatibili con il servizio AdE; i numeri particella sono visibili alle scale di dettaglio consentite dal servizio (circa zoom 17 o superiore).
 - Collegamenti separati al Geoportale pubblico e all'Area riservata AdE per CAPTCHA, SPID/CIE e download ufficiali.

 ## Limite ufficiale AdE da considerare
@@ -34,6 +141,21 @@ Questo passaggio e' implementato nel tab `Catasto`. Regione e Comune sono dispon

 I layer cartografici pubblici WMS/WFS sono open data e non richiedono CAPTCHA. Il CAPTCHA o l'autenticazione SPID/CIE appartengono ai servizi web di consultazione e download documentale: l'app li apre nel sito ufficiale dell'Agenzia e non tenta di aggirarli.

+## Azure Maps Gen2
+
+Nel tab `Impostazioni` sono disponibili gli sfondi `Strade - Azure Maps` e `Satellite - Azure Maps`. Per usarli:
+
+1. crea una risorsa Azure Maps con piano Gen2 nel portale Azure;
+2. copia una delle chiavi di sottoscrizione della risorsa;
+3. inseriscila in `Chiave sottoscrizione Azure Maps Gen2` e premi `Salva chiave Azure Maps`.
+
+La chiave viene validata prima del salvataggio e rimane nel `SecureStorage` del dispositivo; non e' inclusa nel codice o nell'APK. Lasciando vuoto il campo e premendo il pulsante, la chiave viene rimossa.
+
+La quota gratuita mensile Gen2 indicata da Microsoft comprende 5.000 transazioni per le mappe di base e 1.000 per le immagini satellitari. Una transazione raggruppa fino a 15 richieste di tessere. Oltre la quota si applicano le condizioni economiche della sottoscrizione Azure, quindi e' opportuno configurare budget e avvisi nel portale.
+
+- Creazione account e autenticazione: https://learn.microsoft.com/azure/azure-maps/how-to-manage-account-keys
+- Prezzi e quota gratuita: https://azure.microsoft.com/pricing/details/azure-maps/
+
 ## Aprire in Visual Studio

 Apri `LMEMappeCatastaliApp.csproj` con Visual Studio 2022/2026 e seleziona:
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<svg width="456" height="456" viewBox="0 0 456 456" version="1.1" xmlns="http://www.w3.org/2000/svg">
-    <rect x="0" y="0" width="456" height="456" fill="#512BD4" />
+<?xml version="1.0" encoding="UTF-8"?>
+<svg width="456" height="456" viewBox="0 0 456 456" xmlns="http://www.w3.org/2000/svg">
+    <rect width="456" height="456" fill="#075E54" />
 </svg>
@@ -1,8 +1,13 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
-<svg width="456" height="456" viewBox="0 0 456 456" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xml:space="preserve" xmlns:serif="http://www.serif.com/" style="fill-rule:evenodd;clip-rule:evenodd;stroke-linejoin:round;stroke-miterlimit:2;">
-    <path d="m 105.50037,281.60863 c -2.70293,0 -5.00091,-0.90042 -6.893127,-2.70209 -1.892214,-1.84778 -2.837901,-4.04181 -2.837901,-6.58209 0,-2.58722 0.945687,-4.80389 2.837901,-6.65167 1.892217,-1.84778 4.190197,-2.77167 6.893127,-2.77167 2.74819,0 5.06798,0.92389 6.96019,2.77167 1.93749,1.84778 2.90581,4.06445 2.90581,6.65167 0,2.54028 -0.96832,4.73431 -2.90581,6.58209 -1.89221,1.80167 -4.212,2.70209 -6.96019,2.70209 z" style="fill:#ffffff;fill-rule:nonzero;stroke-width:0.838376" />
-    <path d="M 213.56111,280.08446 H 195.99044 L 149.69953,207.0544 c -1.17121,-1.84778 -2.14037,-3.76515 -2.90581,-5.75126 h -0.40578 c 0.36051,2.12528 0.54076,6.67515 0.54076,13.6496 v 65.13172 h -15.54349 v -99.36009 h 18.71925 l 44.7374,71.29798 c 1.89222,2.95695 3.1087,4.98917 3.64945,6.09751 h 0.26996 c -0.45021,-2.6325 -0.67573,-7.09015 -0.67573,-13.37293 v -64.02256 h 15.47557 z" style="fill:#ffffff;fill-rule:nonzero;stroke-width:0.838376" />
-    <path d="m 289.25134,280.08446 h -54.40052 v -99.36009 h 52.23835 v 13.99669 h -36.15411 v 28.13085 h 33.31621 v 13.9271 h -33.31621 v 29.37835 h 38.31628 z" style="fill:#ffffff;fill-rule:nonzero;stroke-width:0.838376" />
-    <path d="M 366.56466,194.72106 H 338.7222 v 85.3634 h -16.08423 v -85.3634 h -27.77455 v -13.99669 h 71.70124 z" style="fill:#ffffff;fill-rule:nonzero;stroke-width:0.838376" />
+<?xml version="1.0" encoding="UTF-8"?>
+<svg width="456" height="456" viewBox="0 0 456 456" xmlns="http://www.w3.org/2000/svg">
+    <g stroke-linecap="round" stroke-linejoin="round">
+        <path d="M105 150L183 119L273 151L351 120V307L273 338L183 306L105 337Z"
+              fill="#F7FAF5" stroke="#E1ECE5" stroke-width="10" />
+        <path d="M183 119V306M273 151V338" fill="none" stroke="#83B6A5" stroke-width="10" />
+        <path d="M125 190L162 175M124 274L160 260M293 196L330 181M295 282L330 268"
+              fill="none" stroke="#A9CDBE" stroke-width="9" />
+        <path d="M228 104C188 104 157 135 157 175C157 225 228 294 228 294C228 294 299 225 299 175C299 135 268 104 228 104Z"
+              fill="#F97316" stroke="#FFFFFF" stroke-width="12" />
+        <circle cx="228" cy="175" r="24" fill="#FFFFFF" />
+    </g>
 </svg>
@@ -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);
@@ -0,0 +1,53 @@
+using System.Text.Json;
+
+namespace LMEMappeCatastaliApp.Services;
+
+public sealed class AzureMapsService
+{
+    private const string TilesetEndpoint = "https://atlas.microsoft.com/map/tileset";
+    private readonly HttpClient _httpClient = new()
+    {
+        Timeout = TimeSpan.FromSeconds(20)
+    };
+    private string? _validatedKey;
+
+    public AzureMapsService()
+    {
+        _httpClient.DefaultRequestHeaders.UserAgent.ParseAdd("LMEMappeCatastali/0.2.22");
+        _httpClient.DefaultRequestHeaders.Accept.ParseAdd("application/json");
+    }
+
+    public async Task ValidateKeyAsync(string subscriptionKey, CancellationToken cancellationToken = default)
+    {
+        var key = subscriptionKey.Trim();
+        if (string.IsNullOrWhiteSpace(key))
+        {
+            throw new ArgumentException("Chiave Azure Maps mancante.", nameof(subscriptionKey));
+        }
+
+        if (string.Equals(_validatedKey, key, StringComparison.Ordinal))
+        {
+            return;
+        }
+
+        var url = $"{TilesetEndpoint}?api-version=2024-04-01&tilesetId=microsoft.base.road";
+        using var request = new HttpRequestMessage(HttpMethod.Get, url);
+        request.Headers.Add("subscription-key", key);
+        using var response = await _httpClient.SendAsync(request, cancellationToken);
+        if (!response.IsSuccessStatusCode)
+        {
+            throw new InvalidOperationException(response.StatusCode is System.Net.HttpStatusCode.Unauthorized or System.Net.HttpStatusCode.Forbidden
+                ? "Chiave Azure Maps non valida o priva dei permessi Render."
+                : $"Azure Maps ha risposto {((int)response.StatusCode)}.");
+        }
+
+        await using var content = await response.Content.ReadAsStreamAsync(cancellationToken);
+        using var payload = await JsonDocument.ParseAsync(content, cancellationToken: cancellationToken);
+        if (!payload.RootElement.TryGetProperty("tiles", out _))
+        {
+            throw new InvalidDataException("Azure Maps ha restituito una configurazione non valida.");
+        }
+
+        _validatedKey = key;
+    }
+}
@@ -128,25 +128,28 @@ public sealed class CadastralCatalogService

            var parcelValues = new string[count];
            var inspireIds = new string[count];
-            var longitudes = new long[count];
-            var latitudes = new long[count];
+            var longitudes = new long?[count];
+            var latitudes = new long?[count];
            await group.ReadAsync(parcelField, parcelValues, cancellationToken: cancellationToken);
            await group.ReadAsync(inspireIdField, inspireIds, cancellationToken: cancellationToken);
-            await group.ReadAsync<long>(longitudeField, longitudes, cancellationToken: cancellationToken);
-            await group.ReadAsync<long>(latitudeField, latitudes, cancellationToken: cancellationToken);
+            await group.ReadAsync<long>(longitudeField, longitudes.AsMemory(), cancellationToken: cancellationToken);
+            await group.ReadAsync<long>(latitudeField, latitudes.AsMemory(), cancellationToken: cancellationToken);

            foreach (var index in matchingIndexes)
            {
                var number = parcelValues[index];
-                if (string.IsNullOrWhiteSpace(number) || parcels.ContainsKey(number))
+                if (string.IsNullOrWhiteSpace(number)
+                    || parcels.ContainsKey(number)
+                    || !latitudes[index].HasValue
+                    || !longitudes[index].HasValue)
                {
                    continue;
                }

                parcels[number] = new ParcelOption(
                    number,
-                    latitudes[index] / 1_000_000d,
-                    longitudes[index] / 1_000_000d,
+                    latitudes[index]!.Value / 1_000_000d,
+                    longitudes[index]!.Value / 1_000_000d,
                    inspireIds[index] ?? string.Empty);
            }
        }
@@ -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);
+    }
+}
@@ -0,0 +1,20 @@
+using System.Collections.Concurrent;
+
+namespace LMEMappeCatastaliApp.Services;
+
+public sealed class IncomingFileService
+{
+    private readonly ConcurrentQueue<IncomingFile> _files = new();
+    public static IncomingFileService Shared { get; } = new();
+    public event Action? FileAvailable;
+
+    public void Enqueue(IncomingFile file)
+    {
+        _files.Enqueue(file);
+        MainThread.BeginInvokeOnMainThread(() => FileAvailable?.Invoke());
+    }
+
+    public bool TryDequeue(out IncomingFile? file) => _files.TryDequeue(out file);
+}
+
+public sealed record IncomingFile(string Path, string FileName, string? ContentType);
@@ -0,0 +1,185 @@
+using System.Globalization;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using Microsoft.Maui.Devices.Sensors;
+
+namespace LMEMappeCatastaliApp.Services;
+
+public sealed class LocationSearchService
+{
+    private const string NominatimEndpoint = "https://nominatim.openstreetmap.org/search";
+    private const string ArcGisEndpoint = "https://geocode.arcgis.com/arcgis/rest/services/World/GeocodeServer/findAddressCandidates";
+    private readonly HttpClient _httpClient = new()
+    {
+        Timeout = TimeSpan.FromSeconds(20)
+    };
+    private readonly SemaphoreSlim _requestLock = new(1, 1);
+    private readonly Dictionary<string, LocationSearchResult?> _cache = new(StringComparer.OrdinalIgnoreCase);
+    private DateTimeOffset _lastRemoteRequest = DateTimeOffset.MinValue;
+
+    public LocationSearchService()
+    {
+        _httpClient.DefaultRequestHeaders.UserAgent.ParseAdd("LMEMappeCatastali/0.2.2");
+        _httpClient.DefaultRequestHeaders.Accept.ParseAdd("application/json");
+        _httpClient.DefaultRequestHeaders.AcceptLanguage.ParseAdd("it-IT");
+    }
+
+    public async Task<LocationSearchResult?> SearchAsync(string text, CancellationToken cancellationToken = default)
+    {
+        var query = text.Trim();
+        if (string.IsNullOrWhiteSpace(query))
+        {
+            return null;
+        }
+
+        if (TryParseCoordinates(query, out var coordinates))
+        {
+            return coordinates;
+        }
+
+        if (_cache.TryGetValue(query, out var cached))
+        {
+            return cached;
+        }
+
+        var nativeResult = await TryNativeGeocodingAsync(query);
+        if (nativeResult is not null)
+        {
+            _cache[query] = nativeResult;
+            return nativeResult;
+        }
+
+        var arcGisResult = await SearchArcGisAsync(query, cancellationToken);
+        if (arcGisResult is not null)
+        {
+            return arcGisResult;
+        }
+
+        var remoteResult = await SearchNominatimAsync(query, cancellationToken);
+        _cache[query] = remoteResult;
+        return remoteResult;
+    }
+
+    private async Task<LocationSearchResult?> SearchArcGisAsync(string query, CancellationToken cancellationToken)
+    {
+        try
+        {
+            var url = $"{ArcGisEndpoint}?f=json&forStorage=false&sourceCountry=ITA&maxLocations=1&outFields=Match_addr,Addr_type,Score&SingleLine={Uri.EscapeDataString(query)}";
+            using var response = await _httpClient.GetAsync(url, cancellationToken);
+            if (!response.IsSuccessStatusCode)
+            {
+                return null;
+            }
+
+            await using var content = await response.Content.ReadAsStreamAsync(cancellationToken);
+            var payload = await JsonSerializer.DeserializeAsync<ArcGisResponse>(content, cancellationToken: cancellationToken);
+            var candidate = payload?.Candidates?.FirstOrDefault();
+            if (candidate?.Location is null || candidate.Score < 60)
+            {
+                return null;
+            }
+
+            return new LocationSearchResult(candidate.Location.Y, candidate.Location.X, candidate.Address ?? query);
+        }
+        catch (OperationCanceledException)
+        {
+            throw;
+        }
+        catch (Exception)
+        {
+            return null;
+        }
+    }
+
+    private static async Task<LocationSearchResult?> TryNativeGeocodingAsync(string query)
+    {
+        try
+        {
+            var locations = await Geocoding.Default.GetLocationsAsync(query);
+            var location = locations?.FirstOrDefault();
+            return location is null
+                ? null
+                : new LocationSearchResult(location.Latitude, location.Longitude, query);
+        }
+        catch (Exception)
+        {
+            return null;
+        }
+    }
+
+    private async Task<LocationSearchResult?> SearchNominatimAsync(string query, CancellationToken cancellationToken)
+    {
+        await _requestLock.WaitAsync(cancellationToken);
+        try
+        {
+            var wait = TimeSpan.FromSeconds(1) - (DateTimeOffset.UtcNow - _lastRemoteRequest);
+            if (wait > TimeSpan.Zero)
+            {
+                await Task.Delay(wait, cancellationToken);
+            }
+
+            var url = $"{NominatimEndpoint}?format=jsonv2&limit=1&accept-language=it&q={Uri.EscapeDataString(query)}";
+            _lastRemoteRequest = DateTimeOffset.UtcNow;
+            using var response = await _httpClient.GetAsync(url, cancellationToken);
+            if (!response.IsSuccessStatusCode)
+            {
+                throw new HttpRequestException($"Il servizio di ricerca ha risposto {((int)response.StatusCode)}.");
+            }
+
+            await using var content = await response.Content.ReadAsStreamAsync(cancellationToken);
+            var results = await JsonSerializer.DeserializeAsync<List<NominatimResult>>(content, cancellationToken: cancellationToken);
+            var result = results?.FirstOrDefault();
+            if (result is null
+                || !double.TryParse(result.Latitude, NumberStyles.Float, CultureInfo.InvariantCulture, out var latitude)
+                || !double.TryParse(result.Longitude, NumberStyles.Float, CultureInfo.InvariantCulture, out var longitude))
+            {
+                return null;
+            }
+
+            return new LocationSearchResult(latitude, longitude, result.DisplayName ?? query);
+        }
+        finally
+        {
+            _requestLock.Release();
+        }
+    }
+
+    private static bool TryParseCoordinates(string query, out LocationSearchResult? result)
+    {
+        result = null;
+        var parts = query.Split([' ', ',', ';'], StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries);
+        if (parts.Length != 2
+            || !double.TryParse(parts[0], NumberStyles.Float, CultureInfo.InvariantCulture, out var latitude)
+            || !double.TryParse(parts[1], NumberStyles.Float, CultureInfo.InvariantCulture, out var longitude)
+            || Math.Abs(latitude) > 90
+            || Math.Abs(longitude) > 180)
+        {
+            return false;
+        }
+
+        result = new LocationSearchResult(
+            latitude,
+            longitude,
+            $"Coordinate: {latitude:F6}, {longitude:F6}");
+        return true;
+    }
+
+    private sealed record NominatimResult(
+        [property: JsonPropertyName("lat")] string? Latitude,
+        [property: JsonPropertyName("lon")] string? Longitude,
+        [property: JsonPropertyName("display_name")] string? DisplayName);
+
+    private sealed record ArcGisResponse(
+        [property: JsonPropertyName("candidates")] List<ArcGisCandidate>? Candidates);
+
+    private sealed record ArcGisCandidate(
+        [property: JsonPropertyName("address")] string? Address,
+        [property: JsonPropertyName("score")] double Score,
+        [property: JsonPropertyName("location")] ArcGisLocation? Location);
+
+    private sealed record ArcGisLocation(
+        [property: JsonPropertyName("x")] double X,
+        [property: JsonPropertyName("y")] double Y);
+}
+
+public sealed record LocationSearchResult(double Latitude, double Longitude, string Label);
@@ -0,0 +1,475 @@
+using System.Globalization;
+using System.IO.Compression;
+using System.Text;
+using System.Text.Json;
+using System.Xml.Linq;
+
+namespace LMEMappeCatastaliApp.Services;
+
+public sealed class MapExportService
+{
+    private static readonly XNamespace Kml = "http://www.opengis.net/kml/2.2";
+
+    public async Task<MapExportFile> CreateAsync(
+        string requestedName,
+        string requestedFormat,
+        string geoJson,
+        CancellationToken cancellationToken = default)
+    {
+        using var document = JsonDocument.Parse(geoJson);
+        var root = document.RootElement;
+        if (!root.TryGetProperty("type", out var type) || type.GetString() != "FeatureCollection"
+            || !root.TryGetProperty("features", out var features)
+            || features.ValueKind != JsonValueKind.Array)
+        {
+            throw new InvalidDataException("I dati raccolti dalla mappa non sono validi.");
+        }
+
+        var featureCount = features.GetArrayLength();
+        if (featureCount == 0)
+        {
+            throw new InvalidOperationException("Nessun oggetto selezionato e disponibile da esportare.");
+        }
+
+        var format = requestedFormat.Trim().ToLowerInvariant() switch
+        {
+            "kml" => "kml",
+            "kmz" => "kmz",
+            "gpx" => "gpx",
+            "pdf" => "pdf",
+            _ => "geojson"
+        };
+        var baseName = NormalizeFileName(requestedName);
+        var exportDirectory = Path.Combine(FileSystem.CacheDirectory, "Exports");
+        Directory.CreateDirectory(exportDirectory);
+        var path = Path.Combine(exportDirectory, $"{baseName}.{format}");
+
+        if (format == "geojson")
+        {
+            using var output = File.Create(path);
+            await JsonSerializer.SerializeAsync(output, root, new JsonSerializerOptions { WriteIndented = true }, cancellationToken);
+            return new(path, "application/geo+json", featureCount, Path.GetFileName(path));
+        }
+
+        if (format == "gpx")
+        {
+            await File.WriteAllTextAsync(path, BuildGpx(features, baseName), new UTF8Encoding(false), cancellationToken);
+            return new(path, "application/gpx+xml", featureCount, Path.GetFileName(path));
+        }
+
+        if (format == "pdf")
+        {
+            await File.WriteAllBytesAsync(path, BuildPdfReport(features, baseName), cancellationToken);
+            return new(path, "application/pdf", featureCount, Path.GetFileName(path));
+        }
+
+        var kml = BuildKml(features, baseName);
+        if (format == "kml")
+        {
+            await File.WriteAllTextAsync(path, kml, new UTF8Encoding(false), cancellationToken);
+            return new(path, "application/vnd.google-earth.kml+xml", featureCount, Path.GetFileName(path));
+        }
+
+        await using (var output = File.Create(path))
+        using (var archive = new ZipArchive(output, ZipArchiveMode.Create))
+        {
+            var entry = archive.CreateEntry("doc.kml", CompressionLevel.Optimal);
+            await using var entryStream = entry.Open();
+            await using var writer = new StreamWriter(entryStream, new UTF8Encoding(false));
+            await writer.WriteAsync(kml.AsMemory(), cancellationToken);
+        }
+        return new(path, "application/vnd.google-earth.kmz", featureCount, Path.GetFileName(path));
+    }
+
+    private static string BuildGpx(JsonElement features, string name)
+    {
+        var root = new XElement("gpx",
+            new XAttribute("version", "1.1"),
+            new XAttribute("creator", "LME Mappe Catastali 0.4.7"),
+            new XAttribute(XNamespace.Xmlns + "xsi", "http://www.w3.org/2001/XMLSchema-instance"),
+            new XElement("metadata", new XElement("name", name)));
+        foreach (var feature in features.EnumerateArray())
+        {
+            if (!feature.TryGetProperty("geometry", out var geometry) || geometry.ValueKind != JsonValueKind.Object) continue;
+            var properties = feature.TryGetProperty("properties", out var value) ? value : default;
+            var featureName = FeatureName(properties, GetString(properties, "_lmeCategory") ?? "drawing");
+            var type = geometry.GetProperty("type").GetString();
+            var coordinates = geometry.GetProperty("coordinates");
+            if (type == "Point")
+            {
+                root.Add(GpxPoint("wpt", coordinates, featureName));
+            }
+            else
+            {
+                foreach (var line in EnumerateGpxLines(type, coordinates))
+                {
+                    root.Add(new XElement("trk", new XElement("name", featureName),
+                        new XElement("trkseg", line.Select(point => GpxPoint("trkpt", point, null)))));
+                }
+            }
+        }
+        return new XDocument(new XDeclaration("1.0", "utf-8", null), root).ToString();
+    }
+
+    private static XElement GpxPoint(string element, JsonElement coordinate, string? name)
+    {
+        var values = coordinate.EnumerateArray().ToArray();
+        var point = new XElement(element,
+            new XAttribute("lat", values[1].GetDouble().ToString("G17", CultureInfo.InvariantCulture)),
+            new XAttribute("lon", values[0].GetDouble().ToString("G17", CultureInfo.InvariantCulture)));
+        if (!string.IsNullOrWhiteSpace(name)) point.Add(new XElement("name", name));
+        return point;
+    }
+
+    private static IEnumerable<JsonElement[]> EnumerateGpxLines(string? type, JsonElement coordinates)
+    {
+        if (type == "LineString") yield return coordinates.EnumerateArray().ToArray();
+        else if (type == "Polygon")
+            foreach (var ring in coordinates.EnumerateArray()) yield return ring.EnumerateArray().ToArray();
+        else if (type == "MultiLineString")
+            foreach (var line in coordinates.EnumerateArray()) yield return line.EnumerateArray().ToArray();
+        else if (type == "MultiPolygon")
+            foreach (var polygon in coordinates.EnumerateArray())
+            foreach (var ring in polygon.EnumerateArray()) yield return ring.EnumerateArray().ToArray();
+    }
+
+    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;
+        foreach (var feature in features.EnumerateArray())
+        {
+            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() : "-";
+            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 = 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 -16 Td ");
+        }
+        content.Append("ET");
+        var stream = Encoding.Latin1.GetBytes(content.ToString());
+        var objects = new[]
+        {
+            "<< /Type /Catalog /Pages 2 0 R >>",
+            "<< /Type /Pages /Kids [3 0 R] /Count 1 >>",
+            "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 595 842] /Resources << /Font << /F1 5 0 R >> >> /Contents 4 0 R >>",
+            $"<< /Length {stream.Length} >>\nstream\n{Encoding.Latin1.GetString(stream)}\nendstream",
+            "<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>"
+        };
+        using var output = new MemoryStream();
+        using var writer = new StreamWriter(output, Encoding.Latin1, leaveOpen: true) { NewLine = "\n" };
+        writer.Write("%PDF-1.4\n"); writer.Flush();
+        var offsets = new List<long> { 0 };
+        for (var i = 0; i < objects.Length; i++)
+        {
+            offsets.Add(output.Position); writer.Write($"{i + 1} 0 obj\n{objects[i]}\nendobj\n"); writer.Flush();
+        }
+        var xref = output.Position;
+        writer.Write($"xref\n0 {objects.Length + 1}\n0000000000 65535 f \n");
+        foreach (var offset in offsets.Skip(1)) writer.Write($"{offset:0000000000} 00000 n \n");
+        writer.Write($"trailer << /Size {objects.Length + 1} /Root 1 0 R >>\nstartxref\n{xref}\n%%EOF");
+        writer.Flush();
+        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",
+            new XElement(Kml + "name", documentName),
+            BuildStyle("imported", "ff2ecc71", "402ecc71"),
+            BuildStyle("imported-sheet", "ff22803d", "1022803d"),
+            BuildStyle("cadastral", "ff4444ef", "4224bffb"),
+            BuildStyle("cadastral-gps", "ffff7a00", "337aff00"),
+            BuildStyle("drawing", "ff1679f9", "333c92fb"),
+            BuildStyle("poi", "ffff7a00", "33ff7a00"),
+            BuildStyle("gps-trail", "ff00a5ff", "2200a5ff"));
+        var categoryFolders = new Dictionary<string, XElement>(StringComparer.Ordinal);
+        var groupFolders = new Dictionary<(string Category, string Group), XElement>();
+
+        foreach (var feature in features.EnumerateArray())
+        {
+            if (!feature.TryGetProperty("geometry", out var geometry)
+                || geometry.ValueKind is JsonValueKind.Null or JsonValueKind.Undefined)
+            {
+                continue;
+            }
+
+            var properties = feature.TryGetProperty("properties", out var propertyElement)
+                && propertyElement.ValueKind == JsonValueKind.Object
+                ? propertyElement
+                : default;
+            var category = GetString(properties, "_lmeCategory") ?? "drawing";
+            var placemark = new XElement(Kml + "Placemark",
+                new XElement(Kml + "name", FeatureName(properties, category)),
+                new XElement(Kml + "styleUrl", $"#{NormalizeStyleId(category)}"));
+            var featureStyle = BuildFeatureStyle(properties);
+            if (featureStyle is not null)
+            {
+                placemark.Add(featureStyle);
+            }
+
+            var extendedData = BuildExtendedData(properties);
+            if (extendedData is not null)
+            {
+                placemark.Add(extendedData);
+            }
+            placemark.Add(BuildGeometry(geometry));
+            var categoryName = GetString(properties, "_lmeCategoryName")?.Trim();
+            var groupName = GetString(properties, "_lmeGroupName")?.Trim();
+            var parent = document;
+            if (!string.IsNullOrWhiteSpace(categoryName))
+            {
+                if (!categoryFolders.TryGetValue(categoryName, out var categoryFolder))
+                {
+                    categoryFolder = new XElement(Kml + "Folder", new XElement(Kml + "name", categoryName));
+                    categoryFolders[categoryName] = categoryFolder;
+                    document.Add(categoryFolder);
+                }
+                parent = categoryFolder;
+            }
+            if (!string.IsNullOrWhiteSpace(groupName))
+            {
+                var key = (categoryName ?? string.Empty, groupName);
+                if (!groupFolders.TryGetValue(key, out var groupFolder))
+                {
+                    groupFolder = new XElement(Kml + "Folder", new XElement(Kml + "name", groupName));
+                    groupFolders[key] = groupFolder;
+                    parent.Add(groupFolder);
+                }
+                parent = groupFolder;
+            }
+            parent.Add(placemark);
+        }
+
+        return new XDocument(new XDeclaration("1.0", "utf-8", null), new XElement(Kml + "kml", document)).ToString();
+    }
+
+    private static XElement BuildStyle(string id, string lineColor, string fillColor) =>
+        new(Kml + "Style",
+            new XAttribute("id", id),
+            new XElement(Kml + "LineStyle",
+                new XElement(Kml + "color", lineColor),
+                new XElement(Kml + "width", 3)),
+            new XElement(Kml + "PolyStyle", new XElement(Kml + "color", fillColor)));
+
+    private static XElement? BuildFeatureStyle(JsonElement properties)
+    {
+        var color = GetString(properties, "_lmeColor");
+        var fillColor = GetString(properties, "_lmeFillColor") ?? color;
+        if (string.IsNullOrWhiteSpace(color) && string.IsNullOrWhiteSpace(fillColor)) return null;
+        var weight = GetNumber(properties, "_lmeWeight", 3);
+        var opacity = GetNumber(properties, "_lmeOpacity", 1);
+        var fillOpacity = GetNumber(properties, "_lmeFillOpacity", 0.2);
+        return new XElement(Kml + "Style",
+            new XElement(Kml + "LineStyle",
+                new XElement(Kml + "color", ToKmlColor(color ?? "#f97316", opacity)),
+                new XElement(Kml + "width", weight.ToString("0.##", CultureInfo.InvariantCulture))),
+            new XElement(Kml + "PolyStyle",
+                new XElement(Kml + "color", ToKmlColor(fillColor ?? "#fb923c", fillOpacity))));
+    }
+
+    private static double GetNumber(JsonElement properties, string name, double fallback) =>
+        properties.ValueKind == JsonValueKind.Object
+        && properties.TryGetProperty(name, out var value)
+        && value.ValueKind == JsonValueKind.Number
+            ? value.GetDouble()
+            : fallback;
+
+    private static string ToKmlColor(string html, double opacity)
+    {
+        var value = html.TrimStart('#');
+        if (value.Length != 6) value = "f97316";
+        var alpha = (int)Math.Round(Math.Clamp(opacity, 0, 1) * 255);
+        return $"{alpha:x2}{value[4..6]}{value[2..4]}{value[0..2]}";
+    }
+
+    private static XElement? BuildExtendedData(JsonElement properties)
+    {
+        if (properties.ValueKind != JsonValueKind.Object)
+        {
+            return null;
+        }
+
+        var data = properties.EnumerateObject()
+            .Where(item => item.Name != "_lmeCategory"
+                && item.Value.ValueKind is JsonValueKind.String or JsonValueKind.Number or JsonValueKind.True or JsonValueKind.False)
+            .Select(item => new XElement(Kml + "Data",
+                new XAttribute("name", item.Name),
+                new XElement(Kml + "value", ScalarText(item.Value))))
+            .ToArray();
+        return data.Length == 0 ? null : new XElement(Kml + "ExtendedData", data);
+    }
+
+    private static XElement BuildGeometry(JsonElement geometry)
+    {
+        var type = geometry.GetProperty("type").GetString();
+        if (type == "GeometryCollection")
+        {
+            return new XElement(Kml + "MultiGeometry",
+                geometry.GetProperty("geometries").EnumerateArray().Select(BuildGeometry));
+        }
+
+        var coordinates = geometry.GetProperty("coordinates");
+        return type switch
+        {
+            "Point" => new XElement(Kml + "Point", CoordinatesElement([coordinates])),
+            "LineString" => new XElement(Kml + "LineString", CoordinatesElement(coordinates.EnumerateArray())),
+            "Polygon" => BuildPolygon(coordinates),
+            "MultiPoint" => new XElement(Kml + "MultiGeometry",
+                coordinates.EnumerateArray().Select(point => new XElement(Kml + "Point", CoordinatesElement([point])))),
+            "MultiLineString" => new XElement(Kml + "MultiGeometry",
+                coordinates.EnumerateArray().Select(line => new XElement(Kml + "LineString", CoordinatesElement(line.EnumerateArray())))),
+            "MultiPolygon" => new XElement(Kml + "MultiGeometry", coordinates.EnumerateArray().Select(BuildPolygon)),
+            _ => throw new InvalidDataException($"Geometria GeoJSON non supportata: {type}.")
+        };
+    }
+
+    private static XElement BuildPolygon(JsonElement rings)
+    {
+        var ringList = rings.EnumerateArray().ToArray();
+        var polygon = new XElement(Kml + "Polygon");
+        if (ringList.Length > 0)
+        {
+            polygon.Add(new XElement(Kml + "outerBoundaryIs",
+                new XElement(Kml + "LinearRing", CoordinatesElement(ringList[0].EnumerateArray()))));
+        }
+        foreach (var ring in ringList.Skip(1))
+        {
+            polygon.Add(new XElement(Kml + "innerBoundaryIs",
+                new XElement(Kml + "LinearRing", CoordinatesElement(ring.EnumerateArray()))));
+        }
+        return polygon;
+    }
+
+    private static XElement CoordinatesElement(IEnumerable<JsonElement> points) =>
+        new(Kml + "coordinates", string.Join(" ", points.Select(FormatCoordinate)));
+
+    private static string FormatCoordinate(JsonElement coordinate)
+    {
+        var values = coordinate.EnumerateArray().Take(3)
+            .Select(value => value.GetDouble().ToString("G17", CultureInfo.InvariantCulture));
+        return string.Join(",", values);
+    }
+
+    private static string FeatureName(JsonElement properties, string category) =>
+        GetString(properties, "_lmeDisplayName")
+        ?? GetString(properties, "name")
+        ?? GetString(properties, "Name")
+        ?? GetString(properties, "LABEL")
+        ?? GetString(properties, "NATIONALCADASTRALREFERENCE")
+        ?? category switch
+        {
+            "imported-sheet" => "Cornice o foglio importato",
+            "cadastral" => "Particella catastale",
+            "cadastral-gps" => "Particella GPS",
+            "poi" => "Punto di interesse",
+            "gps-trail" => "Traccia GPS",
+            _ => "Oggetto mappa"
+        };
+
+    private static string? GetString(JsonElement element, string name) =>
+        element.ValueKind == JsonValueKind.Object
+        && element.TryGetProperty(name, out var value)
+        && value.ValueKind == JsonValueKind.String
+            ? value.GetString()
+            : null;
+
+    private static string ScalarText(JsonElement value) => value.ValueKind == JsonValueKind.String
+        ? value.GetString() ?? string.Empty
+        : value.GetRawText();
+
+    private static string NormalizeStyleId(string category) => category switch
+    {
+        "imported" or "imported-sheet" or "cadastral" or "cadastral-gps" or "drawing" or "poi" or "gps-trail" => category,
+        _ => "drawing"
+    };
+
+    private static string NormalizeFileName(string requestedName)
+    {
+        var name = string.IsNullOrWhiteSpace(requestedName) ? "Mappa" : requestedName.Trim();
+        foreach (var invalid in Path.GetInvalidFileNameChars())
+        {
+            name = name.Replace(invalid, '_');
+        }
+        name = Path.GetFileNameWithoutExtension(name).Trim().TrimEnd('.');
+        return string.IsNullOrWhiteSpace(name) ? "Mappa" : name[..Math.Min(name.Length, 80)];
+    }
+}
+
+public sealed record MapExportFile(string Path, string MimeType, int FeatureCount, string FileName);
@@ -0,0 +1,74 @@
+using System.Net.Http.Json;
+using System.Text.Json.Serialization;
+using Microsoft.Maui.Networking;
+
+namespace LMEMappeCatastaliApp.Services;
+
+public sealed class NetworkLocationService
+{
+    private readonly HttpClient httpClient = new()
+    {
+        Timeout = TimeSpan.FromSeconds(6)
+    };
+
+    public NetworkLocationService()
+    {
+        httpClient.DefaultRequestHeaders.UserAgent.ParseAdd("LMEMappeCatastali/0.2.22");
+    }
+
+    public async Task<NetworkLocationSnapshot?> GetApproximateLocationAsync(
+        CancellationToken cancellationToken = default)
+    {
+        if (Connectivity.Current.NetworkAccess != NetworkAccess.Internet)
+        {
+            return null;
+        }
+
+        using var response = await httpClient.GetAsync("https://ipapi.co/json/", cancellationToken);
+        if (!response.IsSuccessStatusCode)
+        {
+            return null;
+        }
+
+        var result = await response.Content.ReadFromJsonAsync<IpLocationResponse>(cancellationToken);
+        if (result is null
+            || result.Error == true
+            || !result.Latitude.HasValue
+            || !result.Longitude.HasValue
+            || Math.Abs(result.Latitude.Value) > 90
+            || Math.Abs(result.Longitude.Value) > 180)
+        {
+            return null;
+        }
+
+        var labelParts = new[] { result.City, result.Region, result.CountryName }
+            .Where(value => !string.IsNullOrWhiteSpace(value));
+        return new NetworkLocationSnapshot(
+            result.Latitude.Value,
+            result.Longitude.Value,
+            string.Join(", ", labelParts));
+    }
+
+    private sealed class IpLocationResponse
+    {
+        [JsonPropertyName("latitude")]
+        public double? Latitude { get; init; }
+
+        [JsonPropertyName("longitude")]
+        public double? Longitude { get; init; }
+
+        [JsonPropertyName("city")]
+        public string? City { get; init; }
+
+        [JsonPropertyName("region")]
+        public string? Region { get; init; }
+
+        [JsonPropertyName("country_name")]
+        public string? CountryName { get; init; }
+
+        [JsonPropertyName("error")]
+        public bool? Error { get; init; }
+    }
+}
+
+public sealed record NetworkLocationSnapshot(double Latitude, double Longitude, string Label);
@@ -0,0 +1,113 @@
+using System.Globalization;
+using System.Xml.Linq;
+
+namespace LMEMappeCatastaliApp.Services;
+
+public sealed class OfficialCadastreService
+{
+    private const string WfsEndpoint = "https://wfs.cartografia.agenziaentrate.gov.it/inspire/wfs/owfs01.php";
+    private readonly HttpClient _httpClient = new()
+    {
+        Timeout = TimeSpan.FromSeconds(30)
+    };
+
+    public OfficialCadastreService()
+    {
+        _httpClient.DefaultRequestHeaders.UserAgent.ParseAdd("LMEMappeCatastali/0.2");
+        _httpClient.DefaultRequestHeaders.Accept.ParseAdd("application/gml+xml");
+    }
+
+    public async Task<string> GetParcelsNearAsync(
+        double latitude,
+        double longitude,
+        double radiusMeters,
+        CancellationToken cancellationToken = default)
+        => await GetFeaturesNearAsync(
+            latitude,
+            longitude,
+            radiusMeters,
+            "CP:CadastralParcel",
+            100,
+            cancellationToken);
+
+    public async Task<string> GetSheetsNearAsync(
+        double latitude,
+        double longitude,
+        double radiusMeters = 10,
+        CancellationToken cancellationToken = default)
+        => await GetFeaturesNearAsync(
+            latitude,
+            longitude,
+            radiusMeters,
+            "CP:CadastralZoning",
+            20,
+            cancellationToken);
+
+    private async Task<string> GetFeaturesNearAsync(
+        double latitude,
+        double longitude,
+        double radiusMeters,
+        string typeName,
+        int count,
+        CancellationToken cancellationToken)
+    {
+        var meters = Math.Clamp(radiusMeters, 2, 30);
+        var deltaLatitude = meters / 111_320d;
+        var longitudeScale = Math.Cos(latitude * Math.PI / 180d);
+        var deltaLongitude = meters / (111_320d * Math.Max(0.1, longitudeScale));
+        var bbox = string.Join(",",
+        [
+            Format(latitude - deltaLatitude),
+            Format(longitude - deltaLongitude),
+            Format(latitude + deltaLatitude),
+            Format(longitude + deltaLongitude)
+        ]);
+
+        var query = new Dictionary<string, string>
+        {
+            ["language"] = "ita",
+            ["SERVICE"] = "WFS",
+            ["VERSION"] = "2.0.0",
+            ["TYPENAMES"] = typeName,
+            ["SRSNAME"] = "urn:ogc:def:crs:EPSG::6706",
+            ["BBOX"] = bbox,
+            ["REQUEST"] = "GetFeature",
+            ["COUNT"] = count.ToString(CultureInfo.InvariantCulture)
+        };
+
+        var url = WfsEndpoint + "?" + string.Join("&", query.Select(item =>
+            $"{Uri.EscapeDataString(item.Key)}={Uri.EscapeDataString(item.Value)}"));
+
+        using var response = await _httpClient.GetAsync(url, HttpCompletionOption.ResponseContentRead, cancellationToken);
+        if (!response.IsSuccessStatusCode)
+        {
+            throw new HttpRequestException($"Il servizio WFS AdE ha risposto {((int)response.StatusCode)}.");
+        }
+
+        var xml = await response.Content.ReadAsStringAsync(cancellationToken);
+        ThrowIfExceptionReport(xml);
+        return xml;
+    }
+
+    private static string Format(double value) => value.ToString("R", CultureInfo.InvariantCulture);
+
+    private static void ThrowIfExceptionReport(string xml)
+    {
+        try
+        {
+            var document = XDocument.Parse(xml);
+            var exceptionText = document.Descendants()
+                .FirstOrDefault(element => element.Name.LocalName == "ExceptionText")
+                ?.Value
+                .Trim();
+            if (!string.IsNullOrWhiteSpace(exceptionText))
+            {
+                throw new InvalidOperationException($"Servizio WFS AdE: {exceptionText}");
+            }
+        }
+        catch (System.Xml.XmlException error)
+        {
+            throw new InvalidDataException("Il servizio WFS AdE ha restituito una risposta non valida.", error);
+        }
+    }
+}
@@ -20,6 +20,37 @@ public sealed class PreciseLocationService : IAsyncDisposable
        return status;
    }

+    public async Task<LocationSnapshot?> GetCurrentLocationAsync(CancellationToken cancellationToken = default)
+    {
+        var permission = await EnsurePermissionAsync();
+        if (permission != PermissionStatus.Granted)
+        {
+            return null;
+        }
+
+        Location? location = null;
+        try
+        {
+            var request = new GeolocationRequest(GeolocationAccuracy.Best, TimeSpan.FromSeconds(8));
+            location = await Geolocation.Default.GetLocationAsync(request, cancellationToken);
+        }
+        catch (FeatureNotSupportedException)
+        {
+            return null;
+        }
+
+        if (location is null)
+        {
+            var lastKnown = await Geolocation.Default.GetLastKnownLocationAsync();
+            if (lastKnown is not null && lastKnown.Timestamp >= DateTimeOffset.UtcNow.AddMinutes(-15))
+            {
+                location = lastKnown;
+            }
+        }
+
+        return location is null ? null : ToSnapshot(location);
+    }
+
    public async Task StartTrackingAsync(Func<LocationSnapshot, Task> onLocation, Func<string, Task> onError)
    {
        if (trackingCancellation is not null)
@@ -47,14 +78,7 @@ public sealed class PreciseLocationService : IAsyncDisposable
                    var location = await Geolocation.Default.GetLocationAsync(request, token);
                    if (location is not null)
                    {
-                        await onLocation(new LocationSnapshot(
-                            location.Latitude,
-                            location.Longitude,
-                            location.Accuracy,
-                            location.Altitude,
-                            location.Course,
-                            location.Speed,
-                            location.Timestamp));
+                        await onLocation(ToSnapshot(location));
                    }
                }
                catch (OperationCanceledException)
@@ -84,6 +108,15 @@ public sealed class PreciseLocationService : IAsyncDisposable
        StopTracking();
        return ValueTask.CompletedTask;
    }
+
+    private static LocationSnapshot ToSnapshot(Location location) => new(
+        location.Latitude,
+        location.Longitude,
+        location.Accuracy,
+        location.Altitude,
+        location.Course,
+        location.Speed,
+        location.Timestamp);
 }

 public sealed record LocationSnapshot(
@@ -0,0 +1,492 @@
+using System.Text;
+using System.Text.Json;
+using System.IO.Compression;
+
+namespace LMEMappeCatastaliApp.Services;
+
+public sealed class ProjectStorageService
+{
+    private const string ProjectExtension = ".lmeproject.json";
+    private readonly SemaphoreSlim _gate = new(1, 1);
+    private readonly JsonSerializerOptions _jsonOptions = new(JsonSerializerDefaults.Web)
+    {
+        WriteIndented = true
+    };
+
+    private string ProjectsDirectory => Path.Combine(FileSystem.AppDataDirectory, "Projects");
+    private string HistoryDirectory => Path.Combine(ProjectsDirectory, ".history");
+
+    public async Task<IReadOnlyList<MapProjectSummary>> GetProjectsAsync(bool includeArchived = true)
+    {
+        await _gate.WaitAsync();
+        try
+        {
+            var files = await ReadProjectFilesAsync();
+            return files
+                .Select(item => item.Document.ToSummary())
+                .Where(item => includeArchived || !item.IsArchived)
+                .OrderByDescending(item => item.UpdatedAt)
+                .ThenBy(item => item.Name, StringComparer.CurrentCultureIgnoreCase)
+                .ToArray();
+        }
+        finally
+        {
+            _gate.Release();
+        }
+    }
+
+    public async Task<MapProjectSummary> SaveAsync(
+        string name,
+        string snapshotJson,
+        bool includesCadastralParcels,
+        string? projectId = null)
+    {
+        var normalizedName = NormalizeName(name);
+        using var snapshotDocument = JsonDocument.Parse(snapshotJson);
+        if (snapshotDocument.RootElement.ValueKind != JsonValueKind.Object)
+        {
+            throw new InvalidDataException("I dati della mappa non sono validi.");
+        }
+
+        await _gate.WaitAsync();
+        try
+        {
+            Directory.CreateDirectory(ProjectsDirectory);
+            var files = await ReadProjectFilesAsync();
+            var existing = files.FirstOrDefault(item =>
+                (!string.IsNullOrWhiteSpace(projectId) && item.Document.Id == projectId)
+                || string.Equals(item.Document.Name, normalizedName, StringComparison.CurrentCultureIgnoreCase));
+
+            var now = DateTimeOffset.UtcNow;
+            var id = existing?.Document.Id ?? Guid.NewGuid().ToString("N");
+            if (existing is not null)
+            {
+                Directory.CreateDirectory(HistoryDirectory);
+                var revisionName = $"{id}--{existing.Document.UpdatedAt:yyyyMMddHHmmssfff}{ProjectExtension}";
+                File.Copy(existing.Path, Path.Combine(HistoryDirectory, revisionName), true);
+                PruneHistory(id, 15);
+            }
+            var document = new MapProjectDocument
+            {
+                SchemaVersion = 3,
+                Id = id,
+                Name = normalizedName,
+                CreatedAt = existing?.Document.CreatedAt ?? now,
+                UpdatedAt = now,
+                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
+            {
+                await File.WriteAllTextAsync(
+                    temporaryPath,
+                    JsonSerializer.Serialize(document, _jsonOptions),
+                    new UTF8Encoding(false));
+                File.Move(temporaryPath, path, true);
+            }
+            finally
+            {
+                if (File.Exists(temporaryPath))
+                {
+                    File.Delete(temporaryPath);
+                }
+            }
+
+            return document.ToSummary();
+        }
+        finally
+        {
+            _gate.Release();
+        }
+    }
+
+    public async Task<MapProjectSummary> DuplicateAsync(string projectId)
+    {
+        await _gate.WaitAsync();
+        try
+        {
+            var files = await ReadProjectFilesAsync();
+            var source = files.FirstOrDefault(item => item.Document.Id == projectId)
+                ?? throw new FileNotFoundException("Il progetto selezionato non esiste piu'.");
+            var usedNames = files.Select(item => item.Document.Name).ToHashSet(StringComparer.CurrentCultureIgnoreCase);
+            var baseName = $"{source.Document.Name} - copia";
+            var name = baseName;
+            for (var index = 2; usedNames.Contains(name); index++)
+            {
+                name = $"{baseName} {index}";
+            }
+            var now = DateTimeOffset.UtcNow;
+            var id = Guid.NewGuid().ToString("N");
+            var copy = new MapProjectDocument
+            {
+                SchemaVersion = 2,
+                Id = id,
+                Name = name,
+                CreatedAt = now,
+                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));
+            await File.WriteAllTextAsync(path, JsonSerializer.Serialize(copy, _jsonOptions), new UTF8Encoding(false));
+            return copy.ToSummary();
+        }
+        finally { _gate.Release(); }
+    }
+
+    public async Task<MapProjectSummary> RenameAsync(string projectId, string name)
+    {
+        var normalizedName = NormalizeName(name);
+        await _gate.WaitAsync();
+        try
+        {
+            var files = await ReadProjectFilesAsync();
+            var project = files.FirstOrDefault(item => item.Document.Id == projectId)
+                ?? throw new FileNotFoundException("Il progetto selezionato non esiste piu'.");
+            if (project.Document.AccessMode == "readonly")
+            {
+                throw new InvalidOperationException("Il progetto e' in sola lettura. Duplicalo per modificarlo.");
+            }
+            if (files.Any(item => item.Document.Id != projectId
+                && string.Equals(item.Document.Name, normalizedName, StringComparison.CurrentCultureIgnoreCase)))
+            {
+                throw new InvalidOperationException($"Esiste gia' un progetto chiamato '{normalizedName}'.");
+            }
+
+            project.Document.Name = normalizedName;
+            project.Document.UpdatedAt = DateTimeOffset.UtcNow;
+            await File.WriteAllTextAsync(
+                project.Path,
+                JsonSerializer.Serialize(project.Document, _jsonOptions),
+                new UTF8Encoding(false));
+            return project.Document.ToSummary();
+        }
+        finally { _gate.Release(); }
+    }
+
+    public async Task UpdateOrganizationAsync(string projectId, string? folder = null, bool? isArchived = null)
+    {
+        await _gate.WaitAsync();
+        try
+        {
+            var project = (await ReadProjectFilesAsync()).FirstOrDefault(item => item.Document.Id == projectId)
+                ?? throw new FileNotFoundException("Il progetto selezionato non esiste piu'.");
+            project.Document.Folder = NormalizeFolder(folder ?? project.Document.Folder);
+            project.Document.IsArchived = isArchived ?? project.Document.IsArchived;
+            project.Document.UpdatedAt = DateTimeOffset.UtcNow;
+            await File.WriteAllTextAsync(project.Path, JsonSerializer.Serialize(project.Document, _jsonOptions), new UTF8Encoding(false));
+        }
+        finally { _gate.Release(); }
+    }
+
+    public async Task<IReadOnlyList<MapProjectVersion>> GetVersionsAsync(string projectId)
+    {
+        await _gate.WaitAsync();
+        try
+        {
+            Directory.CreateDirectory(HistoryDirectory);
+            var versions = new List<MapProjectVersion>();
+            foreach (var path in Directory.EnumerateFiles(HistoryDirectory, $"{projectId}--*{ProjectExtension}"))
+            {
+                try
+                {
+                    await using var stream = File.OpenRead(path);
+                    var document = await JsonSerializer.DeserializeAsync<MapProjectDocument>(stream, _jsonOptions);
+                    if (document is not null)
+                    {
+                        versions.Add(new(Path.GetFileName(path), document.UpdatedAt));
+                    }
+                }
+                catch (JsonException) { }
+                catch (IOException) { }
+            }
+            return versions.OrderByDescending(item => item.UpdatedAt).ToArray();
+        }
+        finally { _gate.Release(); }
+    }
+
+    public async Task<string> LoadVersionAsync(string projectId, string versionId)
+    {
+        await _gate.WaitAsync();
+        try
+        {
+            if (!versionId.StartsWith($"{projectId}--", StringComparison.Ordinal)
+                || Path.GetFileName(versionId) != versionId)
+            {
+                throw new InvalidDataException("Revisione non valida.");
+            }
+            var path = Path.Combine(HistoryDirectory, versionId);
+            await using var stream = File.OpenRead(path);
+            var document = await JsonSerializer.DeserializeAsync<MapProjectDocument>(stream, _jsonOptions)
+                ?? throw new InvalidDataException("Revisione non leggibile.");
+            return document.Map.GetRawText();
+        }
+        finally { _gate.Release(); }
+    }
+
+    public async Task<string> CreateBackupAsync()
+    {
+        await _gate.WaitAsync();
+        try
+        {
+            Directory.CreateDirectory(ProjectsDirectory);
+            var directory = Path.Combine(FileSystem.CacheDirectory, "Backups");
+            Directory.CreateDirectory(directory);
+            var path = Path.Combine(directory, $"LMEMappeCatastali-backup-{DateTime.Now:yyyyMMdd-HHmmss}.lmebackup.zip");
+            if (File.Exists(path)) File.Delete(path);
+            ZipFile.CreateFromDirectory(ProjectsDirectory, path, CompressionLevel.Optimal, false);
+            return path;
+        }
+        finally { _gate.Release(); }
+    }
+
+    public async Task<int> RestoreBackupAsync(string backupPath)
+    {
+        await _gate.WaitAsync();
+        try
+        {
+            Directory.CreateDirectory(ProjectsDirectory);
+            using var archive = ZipFile.OpenRead(backupPath);
+            var restored = 0;
+            foreach (var entry in archive.Entries.Where(item => item.FullName.EndsWith(ProjectExtension, StringComparison.OrdinalIgnoreCase)))
+            {
+                var fileName = Path.GetFileName(entry.FullName);
+                if (string.IsNullOrWhiteSpace(fileName)) continue;
+                var targetDirectory = entry.FullName.Contains(".history/", StringComparison.OrdinalIgnoreCase)
+                    || entry.FullName.Contains(".history\\", StringComparison.OrdinalIgnoreCase)
+                    ? HistoryDirectory : ProjectsDirectory;
+                Directory.CreateDirectory(targetDirectory);
+                entry.ExtractToFile(Path.Combine(targetDirectory, fileName), true);
+                if (targetDirectory == ProjectsDirectory) restored++;
+            }
+            return restored;
+        }
+        finally { _gate.Release(); }
+    }
+
+    public async Task<string> CreateProjectPackageAsync(string projectId, bool readOnly = false)
+    {
+        await _gate.WaitAsync();
+        try
+        {
+            var project = (await ReadProjectFilesAsync()).FirstOrDefault(item => item.Document.Id == projectId)
+                ?? throw new FileNotFoundException("Il progetto selezionato non esiste piu'.");
+            var directory = Path.Combine(FileSystem.CacheDirectory, "Projects");
+            Directory.CreateDirectory(directory);
+            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(); }
+    }
+
+    public async Task<MapProjectSummary> ImportProjectAsync(string path)
+    {
+        await _gate.WaitAsync();
+        try
+        {
+            await using var stream = File.OpenRead(path);
+            var source = await JsonSerializer.DeserializeAsync<MapProjectDocument>(stream, _jsonOptions)
+                ?? throw new InvalidDataException("Progetto non leggibile.");
+            if (source.Map.ValueKind != JsonValueKind.Object) throw new InvalidDataException("Mappa del progetto non valida.");
+            source.Id = Guid.NewGuid().ToString("N");
+            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));
+            return source.ToSummary();
+        }
+        finally { _gate.Release(); }
+    }
+
+    public async Task<string> LoadAsync(string projectId)
+    {
+        await _gate.WaitAsync();
+        try
+        {
+            var project = (await ReadProjectFilesAsync())
+                .FirstOrDefault(item => item.Document.Id == projectId)
+                ?? throw new FileNotFoundException("Il progetto selezionato non esiste piu'.");
+            return project.Document.Map.GetRawText();
+        }
+        finally
+        {
+            _gate.Release();
+        }
+    }
+
+    public async Task DeleteAsync(string projectId)
+    {
+        await _gate.WaitAsync();
+        try
+        {
+            var project = (await ReadProjectFilesAsync())
+                .FirstOrDefault(item => item.Document.Id == projectId)
+                ?? throw new FileNotFoundException("Il progetto selezionato non esiste piu'.");
+            File.Delete(project.Path);
+            if (Directory.Exists(HistoryDirectory))
+            {
+                foreach (var path in Directory.EnumerateFiles(HistoryDirectory, $"{projectId}--*{ProjectExtension}"))
+                {
+                    File.Delete(path);
+                }
+            }
+        }
+        finally
+        {
+            _gate.Release();
+        }
+    }
+
+    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);
+        var projects = new List<ProjectFileEntry>();
+        foreach (var path in Directory.EnumerateFiles(ProjectsDirectory, $"*{ProjectExtension}"))
+        {
+            try
+            {
+                await using var stream = File.OpenRead(path);
+                var document = await JsonSerializer.DeserializeAsync<MapProjectDocument>(stream, _jsonOptions);
+                if (document is not null
+                    && !string.IsNullOrWhiteSpace(document.Id)
+                    && !string.IsNullOrWhiteSpace(document.Name)
+                    && document.Map.ValueKind == JsonValueKind.Object)
+                {
+                    projects.Add(new ProjectFileEntry(path, document));
+                }
+            }
+            catch (JsonException)
+            {
+                // A damaged project is ignored so the remaining archive stays usable.
+            }
+            catch (IOException)
+            {
+            }
+        }
+
+        return projects;
+    }
+
+    private static string NormalizeName(string name)
+    {
+        var normalized = string.Join(' ', (name ?? string.Empty).Split(
+            [' ', '\t', '\r', '\n'],
+            StringSplitOptions.RemoveEmptyEntries));
+        if (string.IsNullOrWhiteSpace(normalized))
+        {
+            throw new ArgumentException("Inserisci il nome del progetto.");
+        }
+
+        return normalized.Length <= 80 ? normalized : normalized[..80];
+    }
+
+    private static string BuildFileName(string name, string id)
+    {
+        var invalid = Path.GetInvalidFileNameChars().ToHashSet();
+        var safeName = new string(name
+            .Select(character => invalid.Contains(character) ? '-' : character)
+            .ToArray())
+            .Trim(' ', '.');
+        safeName = string.IsNullOrWhiteSpace(safeName) ? "Progetto" : safeName;
+        return $"{safeName}--{id[..8]}{ProjectExtension}";
+    }
+
+    private void PruneHistory(string projectId, int keep)
+    {
+        foreach (var path in Directory.EnumerateFiles(HistoryDirectory, $"{projectId}--*{ProjectExtension}")
+                     .OrderByDescending(File.GetLastWriteTimeUtc).Skip(keep))
+        {
+            File.Delete(path);
+        }
+    }
+
+    private static string NormalizeFolder(string value)
+    {
+        var normalized = string.Join(' ', (value ?? string.Empty).Split([' ', '\t', '\r', '\n'], StringSplitOptions.RemoveEmptyEntries));
+        return normalized[..Math.Min(normalized.Length, 60)];
+    }
+
+    private sealed record ProjectFileEntry(string Path, MapProjectDocument Document);
+
+    private sealed class MapProjectDocument
+    {
+        public int SchemaVersion { get; set; }
+        public string Id { get; set; } = string.Empty;
+        public string Name { get; set; } = string.Empty;
+        public DateTimeOffset CreatedAt { get; set; }
+        public DateTimeOffset UpdatedAt { get; set; }
+        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, AccessMode == "readonly");
+    }
+}
+
+public sealed record MapProjectSummary(
+    string Id,
+    string Name,
+    DateTimeOffset UpdatedAt,
+    bool IncludesCadastralParcels,
+    string Folder,
+    bool IsArchived,
+    bool IsReadOnly);
+
+public sealed record MapProjectVersion(string Id, DateTimeOffset UpdatedAt);
@@ -0,0 +1,6 @@
+{
+  "sdk": {
+    "version": "10.0.401",
+    "rollForward": "latestPatch"
+  }
+}
@@ -0,0 +1,52 @@
+param([string]$Configuration = "Release")
+
+$ErrorActionPreference = "Stop"
+$projectRoot = Split-Path -Parent $PSScriptRoot
+$dotnet = Join-Path $env:USERPROFILE ".dotnet10\dotnet.exe"
+$androidSdk = Join-Path $env:LOCALAPPDATA "Android\Sdk"
+$keyStore = Join-Path $env:LOCALAPPDATA "Xamarin\Mono for Android\debug.keystore"
+$outputDirectory = Join-Path $projectRoot "artifacts\android-test"
+$projectPath = Join-Path $projectRoot "LMEMappeCatastaliApp.csproj"
+[xml]$projectXml = Get-Content -Raw -LiteralPath $projectPath
+$appVersion = ($projectXml.Project.PropertyGroup | Where-Object ApplicationDisplayVersion | Select-Object -First 1).ApplicationDisplayVersion
+
+foreach ($requiredPath in @($dotnet, $androidSdk, $keyStore)) {
+    if (-not (Test-Path -LiteralPath $requiredPath)) { throw "Componente richiesto non trovato: $requiredPath" }
+}
+
+New-Item -ItemType Directory -Force -Path $outputDirectory | Out-Null
+$packages = [System.Collections.Generic.List[System.IO.FileInfo]]::new()
+foreach ($format in @("apk", "aab")) {
+    $publishArguments = @(
+        "publish", $projectPath,
+        "-f", "net10.0-android",
+        "-c", $Configuration,
+        "-p:AndroidSdkDirectory=$androidSdk",
+        "-p:AndroidPackageFormat=$format",
+        "-p:RunAOTCompilation=false",
+        "-p:AndroidKeyStore=true",
+        "-p:AndroidSigningKeyStore=$keyStore",
+        "-p:AndroidSigningKeyAlias=androiddebugkey",
+        "-p:AndroidSigningStorePass=android",
+        "-p:AndroidSigningKeyPass=android"
+    )
+    & $dotnet @publishArguments
+    if ($LASTEXITCODE -ne 0) { throw "Pubblicazione Android $format non riuscita." }
+
+    $publishDirectory = Join-Path $projectRoot "bin\$Configuration\net10.0-android\publish"
+    $package = Get-ChildItem -LiteralPath $publishDirectory -Filter "*-Signed.$format" -File |
+        Sort-Object LastWriteTime -Descending |
+        Select-Object -First 1
+    if ($null -eq $package) { throw "Nessun pacchetto $format firmato prodotto." }
+
+    $destination = Join-Path $outputDirectory "LME-Mappe-Catastali-$appVersion.$format"
+    Copy-Item -LiteralPath $package.FullName -Destination $destination -Force
+    $packages.Add((Get-Item -LiteralPath $destination))
+}
+
+$packages | ForEach-Object {
+    $hash = Get-FileHash -Algorithm SHA256 -LiteralPath $_.FullName
+    "$($hash.Hash.ToLowerInvariant())  $($_.Name)"
+} | Set-Content -LiteralPath (Join-Path $outputDirectory "SHA256SUMS.txt") -Encoding ascii
+
+$packages | Select-Object Name, Length, LastWriteTime
@@ -28,8 +28,10 @@
    <script src="_framework/blazor.webview.js" autostart="false"></script>
    <script src="lib/leaflet/leaflet.js"></script>
    <script src="lib/leaflet-draw/leaflet.draw.js"></script>
+    <script src="lib/googlemutant/Leaflet.GoogleMutant.js"></script>
    <script src="lib/jszip/jszip.min.js"></script>
    <script src="lib/togeojson/togeojson.umd.js"></script>
+    <script src="lib/turf/turf.min.js"></script>
    <script src="js/lme-map.js"></script>

 </body>
@@ -0,0 +1,787 @@
+this.L = this.L || {};
+this.L.GridLayer = this.L.GridLayer || {};
+this.L.GridLayer.GoogleMutant = (function (leaflet) {
+	"use strict";
+
+	/**
+	 * GoogleMutant by Iván Sánchez Ortega <ivan@sanchezortega.es> https://ivan.sanchezortega.es
+	 * Source and issue tracking: https://gitlab.com/IvanSanchez/Leaflet.GridLayer.GoogleMutant/
+	 *
+	 * Based on techniques from https://github.com/shramov/leaflet-plugins
+	 * and https://avinmathew.com/leaflet-and-google-maps/ , but relying on MutationObserver.
+	 *
+	 * "THE BEER-WARE LICENSE":
+	 * <ivan@sanchezortega.es> wrote this file. As long as you retain this notice you
+	 * can do whatever you want with this stuff. If we meet some day, and you think
+	 * this stuff is worth it, you can buy me a beer in return.
+	 *
+	 * Uses MIT-licensed code from https://github.com/rsms/js-lru/
+	 */
+
+	// This implementation of LRUMap is a copy of https://github.com/rsms/js-lru/ ,
+	// trivially adapted for ES6 exports.
+
+	/*
+	The MIT License
+
+	Copyright (c) 2010-2020 Rasmus Andersson <https://rsms.me/>
+
+	Permission is hereby granted, free of charge, to any person obtaining a copy
+	of this software and associated documentation files (the "Software"), to deal
+	in the Software without restriction, including without limitation the rights
+	to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+	copies of the Software, and to permit persons to whom the Software is
+	furnished to do so, subject to the following conditions:
+
+	The above copyright notice and this permission notice shall be included in
+	all copies or substantial portions of the Software.
+
+	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+	IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+	FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+	AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+	LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+	OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+	THE SOFTWARE.
+	*/
+
+	/**
+	 * A doubly linked list-based Least Recently Used (LRU) cache. Will keep most
+	 * recently used items while discarding least recently used items when its limit
+	 * is reached.
+	 *
+	 * Licensed under MIT. Copyright (c) 2010 Rasmus Andersson <http://hunch.se/>
+	 * See README.md for details.
+	 *
+	 * Illustration of the design:
+	 *
+	 *       entry             entry             entry             entry
+	 *       ______            ______            ______            ______
+	 *      | head |.newer => |      |.newer => |      |.newer => | tail |
+	 *      |  A   |          |  B   |          |  C   |          |  D   |
+	 *      |______| <= older.|______| <= older.|______| <= older.|______|
+	 *
+	 *  removed  <--  <--  <--  <--  <--  <--  <--  <--  <--  <--  <--  added
+	 */
+
+	const NEWER = Symbol("newer");
+	const OLDER = Symbol("older");
+
+	class LRUMap {
+		constructor(limit, entries) {
+			if (typeof limit !== "number") {
+				// called as (entries)
+				entries = limit;
+				limit = 0;
+			}
+
+			this.size = 0;
+			this.limit = limit;
+			this.oldest = this.newest = undefined;
+			this._keymap = new Map();
+
+			if (entries) {
+				this.assign(entries);
+				if (limit < 1) {
+					this.limit = this.size;
+				}
+			}
+		}
+
+		_markEntryAsUsed(entry) {
+			if (entry === this.newest) {
+				// Already the most recenlty used entry, so no need to update the list
+				return;
+			}
+			// HEAD--------------TAIL
+			//   <.older   .newer>
+			//  <--- add direction --
+			//   A  B  C  <D>  E
+			if (entry[NEWER]) {
+				if (entry === this.oldest) {
+					this.oldest = entry[NEWER];
+				}
+				entry[NEWER][OLDER] = entry[OLDER]; // C <-- E.
+			}
+			if (entry[OLDER]) {
+				entry[OLDER][NEWER] = entry[NEWER]; // C. --> E
+			}
+			entry[NEWER] = undefined; // D --x
+			entry[OLDER] = this.newest; // D. --> E
+			if (this.newest) {
+				this.newest[NEWER] = entry; // E. <-- D
+			}
+			this.newest = entry;
+		}
+
+		assign(entries) {
+			let entry,
+				limit = this.limit || Number.MAX_VALUE;
+			this._keymap.clear();
+			let it = entries[Symbol.iterator]();
+			for (let itv = it.next(); !itv.done; itv = it.next()) {
+				let e = new Entry(itv.value[0], itv.value[1]);
+				this._keymap.set(e.key, e);
+				if (!entry) {
+					this.oldest = e;
+				} else {
+					entry[NEWER] = e;
+					e[OLDER] = entry;
+				}
+				entry = e;
+				if (limit-- == 0) {
+					throw new Error("overflow");
+				}
+			}
+			this.newest = entry;
+			this.size = this._keymap.size;
+		}
+
+		get(key) {
+			// First, find our cache entry
+			var entry = this._keymap.get(key);
+			if (!entry) return; // Not cached. Sorry.
+			// As <key> was found in the cache, register it as being requested recently
+			this._markEntryAsUsed(entry);
+			return entry.value;
+		}
+
+		set(key, value) {
+			var entry = this._keymap.get(key);
+
+			if (entry) {
+				// update existing
+				entry.value = value;
+				this._markEntryAsUsed(entry);
+				return this;
+			}
+
+			// new entry
+			this._keymap.set(key, (entry = new Entry(key, value)));
+
+			if (this.newest) {
+				// link previous tail to the new tail (entry)
+				this.newest[NEWER] = entry;
+				entry[OLDER] = this.newest;
+			} else {
+				// we're first in -- yay
+				this.oldest = entry;
+			}
+
+			// add new entry to the end of the linked list -- it's now the freshest entry.
+			this.newest = entry;
+			++this.size;
+			if (this.size > this.limit) {
+				// we hit the limit -- remove the head
+				this.shift();
+			}
+
+			return this;
+		}
+
+		shift() {
+			// todo: handle special case when limit == 1
+			var entry = this.oldest;
+			if (entry) {
+				if (this.oldest[NEWER]) {
+					// advance the list
+					this.oldest = this.oldest[NEWER];
+					this.oldest[OLDER] = undefined;
+				} else {
+					// the cache is exhausted
+					this.oldest = undefined;
+					this.newest = undefined;
+				}
+				// Remove last strong reference to <entry> and remove links from the purged
+				// entry being returned:
+				entry[NEWER] = entry[OLDER] = undefined;
+				this._keymap.delete(entry.key);
+				--this.size;
+				return [entry.key, entry.value];
+			}
+		}
+
+		// -------------------------------------------------------------------------------------
+		// Following code (until end of class definition) is optional and can be removed without
+		// breaking the core functionality.
+
+		find(key) {
+			let e = this._keymap.get(key);
+			return e ? e.value : undefined;
+		}
+
+		has(key) {
+			return this._keymap.has(key);
+		}
+
+		delete(key) {
+			var entry = this._keymap.get(key);
+			if (!entry) return;
+			this._keymap.delete(entry.key);
+			if (entry[NEWER] && entry[OLDER]) {
+				// relink the older entry with the newer entry
+				entry[OLDER][NEWER] = entry[NEWER];
+				entry[NEWER][OLDER] = entry[OLDER];
+			} else if (entry[NEWER]) {
+				// remove the link to us
+				entry[NEWER][OLDER] = undefined;
+				// link the newer entry to head
+				this.oldest = entry[NEWER];
+			} else if (entry[OLDER]) {
+				// remove the link to us
+				entry[OLDER][NEWER] = undefined;
+				// link the newer entry to head
+				this.newest = entry[OLDER];
+			} else {
+				// if(entry[OLDER] === undefined && entry.newer === undefined) {
+				this.oldest = this.newest = undefined;
+			}
+
+			this.size--;
+			return entry.value;
+		}
+
+		clear() {
+			// Not clearing links should be safe, as we don't expose live links to user
+			this.oldest = this.newest = undefined;
+			this.size = 0;
+			this._keymap.clear();
+		}
+
+		keys() {
+			return new KeyIterator(this.oldest);
+		}
+
+		values() {
+			return new ValueIterator(this.oldest);
+		}
+
+		entries() {
+			return this;
+		}
+
+		[Symbol.iterator]() {
+			return new EntryIterator(this.oldest);
+		}
+
+		forEach(fun, thisObj) {
+			if (typeof thisObj !== "object") {
+				thisObj = this;
+			}
+			let entry = this.oldest;
+			while (entry) {
+				fun.call(thisObj, entry.value, entry.key, this);
+				entry = entry[NEWER];
+			}
+		}
+
+		/** Returns a JSON (array) representation */
+		toJSON() {
+			var s = new Array(this.size),
+				i = 0,
+				entry = this.oldest;
+			while (entry) {
+				s[i++] = { key: entry.key, value: entry.value };
+				entry = entry[NEWER];
+			}
+			return s;
+		}
+
+		/** Returns a String representation */
+		toString() {
+			var s = "",
+				entry = this.oldest;
+			while (entry) {
+				s += String(entry.key) + ":" + entry.value;
+				entry = entry[NEWER];
+				if (entry) {
+					s += " < ";
+				}
+			}
+			return s;
+		}
+	}
+
+	function Entry(key, value) {
+		this.key = key;
+		this.value = value;
+		this[NEWER] = undefined;
+		this[OLDER] = undefined;
+	}
+
+	function EntryIterator(oldestEntry) {
+		this.entry = oldestEntry;
+	}
+	EntryIterator.prototype[Symbol.iterator] = function () {
+		return this;
+	};
+	EntryIterator.prototype.next = function () {
+		let ent = this.entry;
+		if (ent) {
+			this.entry = ent[NEWER];
+			return { done: false, value: [ent.key, ent.value] };
+		} else {
+			return { done: true, value: undefined };
+		}
+	};
+
+	function KeyIterator(oldestEntry) {
+		this.entry = oldestEntry;
+	}
+	KeyIterator.prototype[Symbol.iterator] = function () {
+		return this;
+	};
+	KeyIterator.prototype.next = function () {
+		let ent = this.entry;
+		if (ent) {
+			this.entry = ent[NEWER];
+			return { done: false, value: ent.key };
+		} else {
+			return { done: true, value: undefined };
+		}
+	};
+
+	function ValueIterator(oldestEntry) {
+		this.entry = oldestEntry;
+	}
+	ValueIterator.prototype[Symbol.iterator] = function () {
+		return this;
+	};
+	ValueIterator.prototype.next = function () {
+		let ent = this.entry;
+		if (ent) {
+			this.entry = ent[NEWER];
+			return { done: false, value: ent.value };
+		} else {
+			return { done: true, value: undefined };
+		}
+	};
+
+	// GoogleMutant by Iván Sánchez Ortega <ivan@sanchezortega.es>
+
+	function waitForAPI(callback, context) {
+		let checkCounter = 0,
+			intervalId = null;
+
+		intervalId = setInterval(function () {
+			if (checkCounter >= 20) {
+				clearInterval(intervalId);
+				throw new Error("window.google not found after 10 seconds");
+			}
+			if (!!window.google && !!window.google.maps && !!window.google.maps.Map) {
+				clearInterval(intervalId);
+				callback.call(context);
+			}
+			++checkCounter;
+		}, 500);
+	}
+
+	// 🍂class GridLayer.GoogleMutant
+	// 🍂extends GridLayer
+	class GoogleMutant extends leaflet.GridLayer {
+		static {
+			// Try to set default option values the Leaflet 2 way
+			if (this.setDefaultOptions) {
+				this.setDefaultOptions({
+					maxZoom: 21, // can be 23, but ugly if more than maxNativeZoom
+					// 🍂option type: String = 'roadmap'
+					// Google's map type. Valid values are 'roadmap', 'satellite', 'terrain' or 'hybrid'.
+					type: "roadmap",
+					maxNativeZoom: 21,
+				});
+			} else {
+				// If Leaflet v2 is not available, fall back.
+				this.options ??= {};
+				this.options.maxZoom ??= 21;
+				this.options.type ??= "roadmap";
+				this.options.maxNativeZoom ??= 21;
+			}
+		}
+
+		constructor(options) {
+			super(options);
+
+			// Couple data structures indexed by tile key
+			this._tileCallbacks = {}; // Callbacks for promises for tiles that are expected
+			this._lru = new LRUMap(100); // Tile LRU cache
+
+			// Before 2024(ish), Google used two tiles for hybrid mode, reusing
+			// the aerial tiles. This seems to be no longer the case.
+			// this._imagesPerTile = this.options.type === "hybrid" ? 2 : 1;
+			this._imagesPerTile = 1;
+
+			this._boundOnMutatedImage = this._onMutatedImage.bind(this);
+		}
+
+		onAdd(map) {
+			super.onAdd(map);
+			this._initMutantContainer();
+
+			// Attribution and logo nodes are not mutated a second time if the
+			// mutant is removed and re-added to the map, hence they are
+			// not cleaned up on layer removal, so they can be added here.
+			if (this._logoContainer) {
+				map._controlCorners.bottomleft.appendChild(this._logoContainer);
+			}
+			if (this._attributionContainer) {
+				map._controlCorners.bottomright.appendChild(this._attributionContainer);
+			}
+
+			waitForAPI(() => {
+				if (!this._map) {
+					return;
+				}
+				this._initMutant();
+
+				//handle layer being added to a map for which there are no Google tiles at the given zoom
+				google.maps.event.addListenerOnce(this._mutant, "idle", () => {
+					if (!this._map) {
+						return;
+					}
+					this._checkZoomLevels();
+					this._mutantIsReady = true;
+				});
+			});
+		}
+
+		onRemove(map) {
+			super.onRemove(map);
+			this._observer.disconnect();
+			map._container.removeChild(this._mutantContainer);
+			this._logoContainer?.remove();
+			this._attributionContainer?.remove();
+			if (this._mutant) {
+				google.maps.event.clearListeners(this._mutant, "idle");
+			}
+		}
+
+		// 🍂method addGoogleLayer(name: String, options?: Object): this
+		// Adds layer with the given name and options to the google Map instance.
+		// `name`: one of the google maps API layers, with it's constructor available in `google.maps` object.
+		// currently following values supported: 'TrafficLayer', 'TransitLayer', 'BicyclingLayer'.
+		// `options`: see https://developers.google.com/maps/documentation/javascript/reference/map
+		addGoogleLayer(googleLayerName, options) {
+			if (!this._subLayers) this._subLayers = {};
+			this.whenReady(() => {
+				var Constructor = google.maps[googleLayerName];
+				var googleLayer = new Constructor(options);
+				googleLayer.setMap(this._mutant);
+				this._subLayers[googleLayerName] = googleLayer;
+			});
+			return this;
+		}
+
+		// 🍂method removeGoogleLayer(name: String): this
+		// Removes layer with the given name from the google Map instance.
+		removeGoogleLayer(googleLayerName) {
+			this.whenReady(() => {
+				var googleLayer = this._subLayers && this._subLayers[googleLayerName];
+				if (googleLayer) {
+					googleLayer.setMap(null);
+					delete this._subLayers[googleLayerName];
+				}
+			});
+			return this;
+		}
+
+		_initMutantContainer() {
+			if (!this._mutantContainer) {
+				this._mutantContainer = leaflet.DomUtil.create(
+					"div",
+					"leaflet-google-mutant leaflet-top leaflet-left"
+				);
+				this._mutantContainer.id =
+					"_MutantContainer_" + leaflet.Util.stamp(this._mutantContainer);
+				this._mutantContainer.style.pointerEvents = "none";
+				this._mutantContainer.style.visibility = "hidden";
+
+				leaflet.DomEvent.off(this._mutantContainer);
+			}
+			this._map.getContainer().appendChild(this._mutantContainer);
+
+			this.setOpacity(this.options.opacity);
+			const style = this._mutantContainer.style;
+			if (this._map.options.zoomSnap < 1) {
+				// Fractional zoom needs a bigger mutant container in order to load more (smaller) tiles
+				style.width = "180%";
+				style.height = "180%";
+			} else {
+				style.width = "100%";
+				style.height = "100%";
+			}
+			style.zIndex = -1;
+
+			this._attachObserver(this._mutantContainer);
+		}
+
+		_initMutant() {
+			if (this._mutant) {
+				return;
+			}
+
+			var options = {
+				center: { lat: 0, lng: 0 },
+				zoom: 0,
+				tilt: 0,
+				mapTypeId: this.options.type,
+				disableDefaultUI: true,
+				keyboardShortcuts: false,
+				draggable: false,
+				disableDoubleClickZoom: true,
+				scrollwheel: false,
+				styles: this.options.styles || [],
+				backgroundColor: "transparent",
+			};
+			if (this.options.mapId != null) {
+				options.mapId = this.options.mapId;
+			}
+			var map = new google.maps.Map(this._mutantContainer, options);
+
+			this._mutant = map;
+
+			this._update();
+
+			// 🍂event spawned
+			// Fired when the mutant has been created.
+			this.fire("spawned", { mapObject: map });
+
+			this._waitControls();
+			this.once("controls_ready", this._setupAttribution);
+		}
+
+		_attachObserver(node) {
+			if (!this._observer)
+				this._observer = new MutationObserver(this._onMutations.bind(this));
+
+			// pass in the target node, as well as the observer options
+			this._observer.observe(node, { childList: true, subtree: true });
+
+			// if we are reusing an old _mutantContainer, we must manually detect
+			// all existing tiles in it
+			Array.prototype.forEach.call(node.querySelectorAll("img"), this._boundOnMutatedImage);
+		}
+
+		_waitControls() {
+			const id = setInterval(() => {
+				const layoutManager = this._mutant.__gm.layoutManager;
+				if (!layoutManager) {
+					return;
+				}
+				clearInterval(id);
+				let positions;
+				// iterate through obfuscated key names to find positions set (atm: layoutManager.o)
+				Object.keys(layoutManager).forEach(function (key) {
+					const el = layoutManager[key];
+					if (el.get) {
+						if (el.get(1) instanceof Node) {
+							positions = el;
+						}
+					}
+				});
+				// 🍂event controls_ready
+				// Fired when controls positions get available (passed in `positions` property).
+				this.fire("controls_ready", { positions });
+			}, 50);
+		}
+
+		_setupAttribution(ev) {
+			if (!this._map) {
+				return;
+			}
+			// https://developers.google.com/maps/documentation/javascript/reference/control#ControlPosition
+			const pos = google.maps.ControlPosition;
+			const ctr = (this._attributionContainer = ev.positions.get(pos.BOTTOM_RIGHT));
+			ctr.classList.add("leaflet-control", "leaflet-control-attribution");
+			leaflet.DomEvent.disableClickPropagation(ctr);
+			ctr.style.height = "14px";
+			this._map._controlCorners.bottomright.appendChild(ctr);
+
+			this._logoContainer = ev.positions.get(pos.BOTTOM_LEFT);
+			this._logoContainer.style.pointerEvents = "auto";
+			this._map._controlCorners.bottomleft.appendChild(this._logoContainer);
+		}
+
+		_onMutations(mutations) {
+			for (var i = 0; i < mutations.length; ++i) {
+				var mutation = mutations[i];
+				for (var j = 0; j < mutation.addedNodes.length; ++j) {
+					var node = mutation.addedNodes[j];
+
+					if (node instanceof HTMLImageElement) {
+						this._onMutatedImage(node);
+					} else if (node instanceof HTMLElement) {
+						Array.prototype.forEach.call(
+							node.querySelectorAll("img"),
+							this._boundOnMutatedImage
+						);
+					}
+				}
+			}
+		}
+
+		// Only images which 'src' attrib match this will be considered for moving around.
+		// Looks like some kind of string-based protobuf, maybe??
+		// Only the roads (and terrain, and vector-based stuff) match this pattern
+		_roadRegexp = /!1i(\d+)!2i(\d+)!3i(\d+|VinaFnapurmBegrtn)!/;
+
+		// On the other hand, raster imagery matches this other pattern
+		_satRegexp = /x=(\d+)&y=(\d+)&z=(\d+|VinaFnapurmBegrtn)/;
+
+		_onMutatedImage(imgNode) {
+			let coords;
+			let match = imgNode.src.match(this._roadRegexp);
+			let sublayer = 0;
+
+			if (match) {
+				coords = {
+					z: match[1],
+					x: match[2],
+					y: match[3],
+				};
+				if (this._imagesPerTile > 1) {
+					imgNode.style.zIndex = 1;
+					sublayer = 1;
+				}
+			} else {
+				match = imgNode.src.match(this._satRegexp);
+				if (match) {
+					coords = {
+						x: match[1],
+						y: match[2],
+						z: match[3],
+					};
+				}
+				// imgNode.style.zIndex = 0;
+				sublayer = 0;
+			}
+
+			if (coords) {
+				var tileKey = this._tileCoordsToKey(coords);
+				imgNode.style.position = "absolute";
+
+				var key = tileKey + "/" + sublayer;
+				// Cache img so it can also be used in subsequent tile requests
+				this._lru.set(key, imgNode);
+
+				if (key in this._tileCallbacks && this._tileCallbacks[key]) {
+					// Use the tile for *all* pending callbacks. They'll be cloned anyway.
+					this._tileCallbacks[key].forEach((callback) => callback(imgNode));
+					delete this._tileCallbacks[key];
+				}
+			}
+		}
+
+		createTile(coords, done) {
+			const key = this._tileCoordsToKey(coords),
+				tileContainer = leaflet.DomUtil.create("div");
+
+			tileContainer.style.textAlign = "left";
+			tileContainer.dataset.pending = this._imagesPerTile;
+			done = done.bind(this, null, tileContainer);
+
+			for (var i = 0; i < this._imagesPerTile; ++i) {
+				const key2 = key + "/" + i,
+					imgNode = this._lru.get(key2);
+				if (imgNode) {
+					tileContainer.appendChild(this._clone(imgNode));
+					--tileContainer.dataset.pending;
+				} else {
+					this._tileCallbacks[key2] = this._tileCallbacks[key2] || [];
+					this._tileCallbacks[key2].push(
+						function (c /*, k2*/) {
+							return function (imgNode) {
+								c.appendChild(this._clone(imgNode));
+								--c.dataset.pending;
+								if (!parseInt(c.dataset.pending)) {
+									done();
+								}
+							}.bind(this);
+						}.bind(this)(tileContainer /*, key2*/)
+					);
+				}
+			}
+
+			if (!parseInt(tileContainer.dataset.pending)) {
+				leaflet.Util.requestAnimFrame(done);
+			}
+			return tileContainer;
+		}
+
+		_clone(imgNode) {
+			const clonedImgNode = imgNode.cloneNode(true);
+			clonedImgNode.style.visibility = "visible";
+			return clonedImgNode;
+		}
+
+		_checkZoomLevels() {
+			//setting the zoom level on the Google map may result in a different zoom level than the one requested
+			//(it won't go beyond the level for which they have data).
+			const zoomLevel = this._map.getZoom(),
+				gMapZoomLevel = this._mutant.getZoom();
+
+			if (!zoomLevel || !gMapZoomLevel) return;
+
+			if (
+				gMapZoomLevel !== zoomLevel || //zoom levels are out of sync, Google doesn't have data
+				gMapZoomLevel > this.options.maxNativeZoom
+			) {
+				//at current location, Google does have data (contrary to maxNativeZoom)
+				//Update maxNativeZoom
+				this._setMaxNativeZoom(gMapZoomLevel);
+			}
+		}
+
+		_setMaxNativeZoom(zoomLevel) {
+			if (zoomLevel !== this.options.maxNativeZoom) {
+				this.options.maxNativeZoom = zoomLevel;
+				this._resetView();
+			}
+		}
+
+		_update(center) {
+			// zoom level check needs to happen before super's implementation (tile addition/creation)
+			// otherwise tiles may be missed if maxNativeZoom is not yet correctly determined
+			if (this._mutant) {
+				center = center || this._map.getCenter();
+				const _center = new google.maps.LatLng(center.lat, center.lng),
+					zoom = Math.round(this._map.getZoom()),
+					mutantZoom = this._mutant.getZoom();
+
+				this._mutant.setCenter(_center);
+
+				//ignore fractional zoom levels
+				if (zoom !== mutantZoom) {
+					this._mutant.setZoom(zoom);
+
+					if (this._mutantIsReady) this._checkZoomLevels();
+					//else zoom level check will be done later by 'idle' handler
+				}
+			}
+
+			super._update(center);
+		}
+
+		// @method whenReady(fn: Function, context?: Object): this
+		// Runs the given function `fn` when the mutant gets initialized, or immediately
+		// if it's already initialized, optionally passing a function context.
+		whenReady(callback, context) {
+			if (this._mutant) {
+				callback.call(context || this, { target: this });
+			} else {
+				this.on("spawned", callback, context);
+			}
+			return this;
+		}
+	}
+
+	// 🍂factory gridLayer.googleMutant(options)
+	// Returns a new `GridLayer.GoogleMutant` given its options
+	if (L && L.gridLayer) {
+		L.gridLayer.googleMutant = function (options) {
+			return new L.GridLayer.GoogleMutant(options);
+		};
+	}
+
+	return GoogleMutant;
+})(L);
+//# sourceMappingURL=Leaflet.GoogleMutant.js.map
@@ -0,0 +1,156 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<svg
+   xmlns:dc="http://purl.org/dc/elements/1.1/"
+   xmlns:cc="http://creativecommons.org/ns#"
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:svg="http://www.w3.org/2000/svg"
+   xmlns="http://www.w3.org/2000/svg"
+   xmlns:xlink="http://www.w3.org/1999/xlink"
+   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
+   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
+   viewBox="0 0 600 60"
+   height="60"
+   width="600"
+   id="svg4225"
+   version="1.1"
+   inkscape:version="0.91 r13725"
+   sodipodi:docname="spritesheet.svg"
+   inkscape:export-filename="/home/fpuga/development/upstream/icarto.Leaflet.draw/src/images/spritesheet-2x.png"
+   inkscape:export-xdpi="90"
+   inkscape:export-ydpi="90">
+  <metadata
+     id="metadata4258">
+    <rdf:RDF>
+      <cc:Work
+         rdf:about="">
+        <dc:format>image/svg+xml</dc:format>
+        <dc:type
+           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
+        <dc:title />
+      </cc:Work>
+    </rdf:RDF>
+  </metadata>
+  <defs
+     id="defs4256" />
+  <sodipodi:namedview
+     pagecolor="#ffffff"
+     bordercolor="#666666"
+     borderopacity="1"
+     objecttolerance="10"
+     gridtolerance="10"
+     guidetolerance="10"
+     inkscape:pageopacity="0"
+     inkscape:pageshadow="2"
+     inkscape:window-width="1920"
+     inkscape:window-height="1056"
+     id="namedview4254"
+     showgrid="false"
+     inkscape:zoom="1.3101852"
+     inkscape:cx="237.56928"
+     inkscape:cy="7.2419621"
+     inkscape:window-x="1920"
+     inkscape:window-y="24"
+     inkscape:window-maximized="1"
+     inkscape:current-layer="svg4225" />
+  <g
+     id="enabled"
+     style="fill:#464646;fill-opacity:1">
+    <g
+       id="polyline"
+       style="fill:#464646;fill-opacity:1">
+      <path
+         d="m 18,36 0,6 6,0 0,-6 -6,0 z m 4,4 -2,0 0,-2 2,0 0,2 z"
+         id="path4229"
+         inkscape:connector-curvature="0"
+         style="fill:#464646;fill-opacity:1" />
+      <path
+         d="m 36,18 0,6 6,0 0,-6 -6,0 z m 4,4 -2,0 0,-2 2,0 0,2 z"
+         id="path4231"
+         inkscape:connector-curvature="0"
+         style="fill:#464646;fill-opacity:1" />
+      <path
+         d="m 23.142,39.145 -2.285,-2.29 16,-15.998 2.285,2.285 z"
+         id="path4233"
+         inkscape:connector-curvature="0"
+         style="fill:#464646;fill-opacity:1" />
+    </g>
+    <path
+       id="polygon"
+       d="M 100,24.565 97.904,39.395 83.07,42 76,28.773 86.463,18 Z"
+       inkscape:connector-curvature="0"
+       style="fill:#464646;fill-opacity:1" />
+    <path
+       id="rectangle"
+       d="m 140,20 20,0 0,20 -20,0 z"
+       inkscape:connector-curvature="0"
+       style="fill:#464646;fill-opacity:1" />
+    <path
+       id="circle"
+       d="m 221,30 c 0,6.078 -4.926,11 -11,11 -6.074,0 -11,-4.922 -11,-11 0,-6.074 4.926,-11 11,-11 6.074,0 11,4.926 11,11 z"
+       inkscape:connector-curvature="0"
+       style="fill:#464646;fill-opacity:1" />
+    <path
+       id="marker"
+       d="m 270,19 c -4.971,0 -9,4.029 -9,9 0,4.971 5.001,12 9,14 4.001,-2 9,-9.029 9,-14 0,-4.971 -4.029,-9 -9,-9 z m 0,12.5 c -2.484,0 -4.5,-2.014 -4.5,-4.5 0,-2.484 2.016,-4.5 4.5,-4.5 2.485,0 4.5,2.016 4.5,4.5 0,2.486 -2.015,4.5 -4.5,4.5 z"
+       inkscape:connector-curvature="0"
+       style="fill:#464646;fill-opacity:1" />
+    <g
+       id="edit"
+       style="fill:#464646;fill-opacity:1">
+      <path
+         d="m 337,30.156 0,0.407 0,5.604 c 0,1.658 -1.344,3 -3,3 l -10,0 c -1.655,0 -3,-1.342 -3,-3 l 0,-10 c 0,-1.657 1.345,-3 3,-3 l 6.345,0 3.19,-3.17 -9.535,0 c -3.313,0 -6,2.687 -6,6 l 0,10 c 0,3.313 2.687,6 6,6 l 10,0 c 3.314,0 6,-2.687 6,-6 l 0,-8.809 -3,2.968"
+         id="path4240"
+         inkscape:connector-curvature="0"
+         style="fill:#464646;fill-opacity:1" />
+      <path
+         d="m 338.72,24.637 -8.892,8.892 -2.828,0 0,-2.829 8.89,-8.89 z"
+         id="path4242"
+         inkscape:connector-curvature="0"
+         style="fill:#464646;fill-opacity:1" />
+      <path
+         d="m 338.697,17.826 4,0 0,4 -4,0 z"
+         transform="matrix(-0.70698336,-0.70723018,0.70723018,-0.70698336,567.55917,274.78273)"
+         id="path4244"
+         inkscape:connector-curvature="0"
+         style="fill:#464646;fill-opacity:1" />
+    </g>
+    <g
+       id="remove"
+       style="fill:#464646;fill-opacity:1">
+      <path
+         d="m 381,42 18,0 0,-18 -18,0 0,18 z m 14,-16 2,0 0,14 -2,0 0,-14 z m -4,0 2,0 0,14 -2,0 0,-14 z m -4,0 2,0 0,14 -2,0 0,-14 z m -4,0 2,0 0,14 -2,0 0,-14 z"
+         id="path4247"
+         inkscape:connector-curvature="0"
+         style="fill:#464646;fill-opacity:1" />
+      <path
+         d="m 395,20 0,-4 -10,0 0,4 -6,0 0,2 22,0 0,-2 -6,0 z m -2,0 -6,0 0,-2 6,0 0,2 z"
+         id="path4249"
+         inkscape:connector-curvature="0"
+         style="fill:#464646;fill-opacity:1" />
+    </g>
+  </g>
+  <g
+     id="disabled"
+     transform="translate(120,0)"
+     style="fill:#bbbbbb">
+    <use
+       xlink:href="#edit"
+       id="edit-disabled"
+       x="0"
+       y="0"
+       width="100%"
+       height="100%" />
+    <use
+       xlink:href="#remove"
+       id="remove-disabled"
+       x="0"
+       y="0"
+       width="100%"
+       height="100%" />
+  </g>
+  <path
+     style="fill:none;stroke:#464646;stroke-width:2;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
+     id="circle-3"
+     d="m 581.65725,30 c 0,6.078 -4.926,11 -11,11 -6.074,0 -11,-4.922 -11,-11 0,-6.074 4.926,-11 11,-11 6.074,0 11,4.926 11,11 z"
+     inkscape:connector-curvature="0" />
+</svg>
@@ -0,0 +1,37 @@
+!function(t,e){"object"==typeof exports&&"undefined"!=typeof module?e(exports):"function"==typeof define&&define.amd?define(["exports"],e):e((t="undefined"!=typeof globalThis?globalThis:t||self).turf={})}(this,(function(t){"use strict";function e(t,e){(null==e||e>t.length)&&(e=t.length);for(var n=0,r=Array(e);n<e;n++)r[n]=t[n];return r}function n(t){if(Array.isArray(t))return t}function r(t,e,n){return e=l(e),function(t,e){if(e&&("object"==typeof e||"function"==typeof e))return e;if(void 0!==e)throw new TypeError("Derived constructors may only return object or undefined");return function(t){if(void 0===t)throw new ReferenceError("this hasn't been initialised - super() hasn't been called");return t}(t)}(t,c()?Reflect.construct(e,n||[],l(t).constructor):e.apply(t,n))}function i(t,e){if(!(t instanceof e))throw new TypeError("Cannot call a class as a function")}function o(t,e){for(var n=0;n<e.length;n++){var r=e[n];r.enumerable=r.enumerable||!1,r.configurable=!0,"value"in r&&(r.writable=!0),Object.defineProperty(t,y(r.key),r)}}function s(t,e,n){return e&&o(t.prototype,e),n&&o(t,n),Object.defineProperty(t,"prototype",{writable:!1}),t}function a(t,e){var n="undefined"!=typeof Symbol&&t[Symbol.iterator]||t["@@iterator"];if(!n){if(Array.isArray(t)||(n=_(t))||e){n&&(t=n);var r=0,i=function(){};return{s:i,n:function(){return r>=t.length?{done:!0}:{done:!1,value:t[r++]}},e:function(t){throw t},f:i}}throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}var o,s=!0,a=!1;return{s:function(){n=n.call(t)},n:function(){var t=n.next();return s=t.done,t},e:function(t){a=!0,o=t},f:function(){try{s||null==n.return||n.return()}finally{if(a)throw o}}}}function u(t,e,n){return(e=y(e))in t?Object.defineProperty(t,e,{value:n,enumerable:!0,configurable:!0,writable:!0}):t[e]=n,t}function l(t){return l=Object.setPrototypeOf?Object.getPrototypeOf.bind():function(t){return t.__proto__||Object.getPrototypeOf(t)},l(t)}function h(t,e){if("function"!=typeof e&&null!==e)throw new TypeError("Super expression must either be null or a function");t.prototype=Object.create(e&&e.prototype,{constructor:{value:t,writable:!0,configurable:!0}}),Object.defineProperty(t,"prototype",{writable:!1}),e&&p(t,e)}function c(){try{var t=!Boolean.prototype.valueOf.call(Reflect.construct(Boolean,[],(function(){})))}catch(t){}return(c=function(){return!!t})()}function f(t){if("undefined"!=typeof Symbol&&null!=t[Symbol.iterator]||null!=t["@@iterator"])return Array.from(t)}function g(){throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}function p(t,e){return p=Object.setPrototypeOf?Object.setPrototypeOf.bind():function(t,e){return t.__proto__=e,t},p(t,e)}function v(t,e){return n(t)||function(t,e){var n=null==t?null:"undefined"!=typeof Symbol&&t[Symbol.iterator]||t["@@iterator"];if(null!=n){var r,i,o,s,a=[],u=!0,l=!1;try{if(o=(n=n.call(t)).next,0===e){if(Object(n)!==n)return;u=!1}else for(;!(u=(r=o.call(n)).done)&&(a.push(r.value),a.length!==e);u=!0);}catch(t){l=!0,i=t}finally{try{if(!u&&null!=n.return&&(s=n.return(),Object(s)!==s))return}finally{if(l)throw i}}return a}}(t,e)||_(t,e)||g()}function d(t){return function(t){if(Array.isArray(t))return e(t)}(t)||f(t)||_(t)||function(){throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.")}()}function y(t){var e=function(t,e){if("object"!=typeof t||!t)return t;var n=t[Symbol.toPrimitive];if(void 0!==n){var r=n.call(t,e||"default");if("object"!=typeof r)return r;throw new TypeError("@@toPrimitive must return a primitive value.")}return("string"===e?String:Number)(t)}(t,"string");return"symbol"==typeof e?e:e+""}function m(t){return m="function"==typeof Symbol&&"symbol"==typeof Symbol.iterator?function(t){return typeof t}:function(t){return t&&"function"==typeof Symbol&&t.constructor===Symbol&&t!==Symbol.prototype?"symbol":typeof t},m(t)}function _(t,n){if(t){if("string"==typeof t)return e(t,n);var r={}.toString.call(t).slice(8,-1);return"Object"===r&&t.constructor&&(r=t.constructor.name),"Map"===r||"Set"===r?Array.from(t):"Arguments"===r||/^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(r)?e(t,n):void 0}}var x=6371008.8,E={centimeters:100*x,centimetres:100*x,degrees:360/(2*Math.PI),feet:3.28084*x,inches:39.37*x,kilometers:x/1e3,kilometres:x/1e3,meters:x,metres:x,miles:x/1609.344,millimeters:1e3*x,millimetres:1e3*x,nauticalmiles:x/1852,radians:1,yards:1.0936*x},k={acres:247105e-9,centimeters:1e4,centimetres:1e4,feet:10.763910417,hectares:1e-4,inches:1550.003100006,kilometers:1e-6,kilometres:1e-6,meters:1,metres:1,miles:386e-9,nauticalmiles:2.9155334959812285e-7,millimeters:1e6,millimetres:1e6,yards:1.195990046};function b(t,e){var n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{},r={type:"Feature"};return(0===Line truncated
+/*!
+   * Copyright (c) 2019, Dane Springmeyer
+   *
+   * Redistribution and use in source and binary forms, with or without
+   * modification, are permitted provided that the following conditions are
+   * met:
+   *
+   *     * Redistributions of source code must retain the above copyright
+   *       notice, this list of conditions and the following disclaimer.
+   *     * Redistributions in binary form must reproduce the above copyright
+   *       notice, this list of conditions and the following disclaimer in
+   *       the documentation and/or other materials provided with the
+   *       distribution.
+   *
+   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
+   * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+   * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+   * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+   * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+   * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+   * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+   * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+   * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+   * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+   * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   */
+function ta(t){var e=arguments.length>1&&void 0!==arguments[1]?arguments[1]:{},n=[];if(mt(t,(function(t){n.push(t.coordinates)})),n.length<2)throw new Error("Must specify at least 2 geometries");var r=Rs.apply(Fs,[n[0]].concat(d(n.slice(1))));return 0===r.length?null:1===r.length?S(r[0],e.properties):R(r,e.properties)}function ea(t,e){var n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{},r=JSON.stringify(n.properties||{}),i=v(t,4),o=i[0],s=i[1],a=i[2],u=i[3],l=(s+u)/2,h=(o+a)/2,c=2*e/ut([o,l],[a,l],n)*(a-o),f=2*e/ut([h,s],[h,u],n)*(u-s),g=c/2,p=2*g,d=Math.sqrt(3)/2*f,y=a-o,m=u-s,_=3/4*p,x=d,E=(y-p)/(p-g/2),k=Math.floor(E),b=(k*_-g/2-y)/2-g/2+_/2,w=Math.floor((m-d)/d),I=(m-w*d)/2,N=w*d-m>d/2;N&&(I-=d/4);for(var S=[],M=[],L=0;L<6;L++){var P=2*Math.PI/6*L;S.push(Math.cos(P)),M.push(Math.sin(P))}for(var T=[],O=0;O<=k;O++)for(var R=0;R<=w;R++){var A=O%2==1;if((0!==R||!A)&&(0!==R||!N)){var D=O*_+o-b,F=R*x+s+I;if(A&&(F-=d/2),!0===n.triangles)ra([D,F],c/2,f/2,JSON.parse(r),S,M).forEach((function(t){n.mask?ta(C([n.mask,t]))&&T.push(t):T.push(t)}));else{var q=na([D,F],c/2,f/2,JSON.parse(r),S,M);n.mask?ta(C([n.mask,q]))&&T.push(q):T.push(q)}}}return C(T)}function na(t,e,n,r,i,o){for(var s=[],a=0;a<6;a++){var u=t[0]+e*i[a],l=t[1]+n*o[a];s.push([u,l])}return s.push(s[0].slice()),S([s],r)}function ra(t,e,n,r,i,o){for(var s=[],a=0;a<6;a++){var u=[];u.push(t),u.push([t[0]+e*i[a],t[1]+n*o[a]]),u.push([t[0]+e*i[(a+1)%6],t[1]+n*o[(a+1)%6]]),u.push(t),s.push(S([u],r))}return s}function ia(t,e){var n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{};n.mask&&!n.units&&(n.units="kilometers");for(var r=[],i=t[0],o=t[1],s=t[2],a=t[3],u=e/ut([i,o],[s,o],n)*(s-i),l=e/ut([i,o],[i,a],n)*(a-o),h=s-i,c=a-o,f=Math.floor(h/u),g=(c-Math.floor(c/l)*l)/2,p=i+(h-f*u)/2;p<=s;){for(var v=o+g;v<=a;){var d=I([p,v],n.properties);n.mask?Cn(d,n.mask)&&r.push(d):r.push(d),v+=l}p+=u}return C(r)}function oa(t,e,n){for(var r=arguments.length>3&&void 0!==arguments[3]?arguments[3]:{},i=[],o=t[0],s=t[1],a=t[2],u=t[3],l=a-o,h=j(e,r.units,"degrees"),c=u-s,f=j(n,r.units,"degrees"),g=Math.floor(Math.abs(l)/h),p=Math.floor(Math.abs(c)/f),v=(c-p*f)/2,d=o+(l-g*h)/2,y=0;y<g;y++){for(var m=s+v,_=0;_<p;_++){var x=S([[[d,m],[d,m+f],[d+h,m+f],[d+h,m],[d,m]]],r.properties);r.mask?Oe(r.mask,x)&&i.push(x):i.push(x),m+=f}d+=h}return C(i)}function sa(t,e){return oa(t,e,e,arguments.length>2&&void 0!==arguments[2]?arguments[2]:{})}function aa(t,e){for(var n=arguments.length>2&&void 0!==arguments[2]?arguments[2]:{},r=[],i=e/ut([t[0],t[1]],[t[2],t[1]],n)*(t[2]-t[0]),o=e/ut([t[0],t[1]],[t[0],t[3]],n)*(t[3]-t[1]),s=0,a=t[0];a<=t[2];){for(var u=0,l=t[1];l<=t[3];){var h=null,c=null;s%2==0&&u%2==0?(h=S([[[a,l],[a,l+o],[a+i,l],[a,l]]],n.properties),c=S([[[a,l+o],[a+i,l+o],[a+i,l],[a,l+o]]],n.properties)):s%2==0&&u%2==1?(h=S([[[a,l],[a+i,l+o],[a+i,l],[a,l]]],n.properties),c=S([[[a,l],[a,l+o],[a+i,l+o],[a,l]]],n.properties)):u%2==0&&s%2==1?(h=S([[[a,l],[a,l+o],[a+i,l+o],[a,l]]],n.properties),c=S([[[a,l],[a+i,l+o],[a+i,l],[a,l]]],n.properties)):u%2==1&&s%2==1&&(h=S([[[a,l],[a,l+o],[a+i,l],[a,l]]],n.properties),c=S([[[a,l+o],[a+i,l+o],[a+i,l],[a,l+o]]],n.properties)),n.mask?(ta(C([n.mask,h]))&&r.push(h),ta(C([n.mask,c]))&&r.push(c)):(r.push(h),r.push(c)),l+=o,u++}s++,a+=i}return C(r)}
+/*!
+  * MarchingSquaresJS
+  * version 1.3.3
+  * https://github.com/RaumZeit/MarchingSquares.js
+  *
+  * @license GNU Affero General Public License.
+  * Copyright (c) 2015-2019 Ronny Lorenz <ronny@tbi.univie.ac.at>
+  */
+function ua(t,e,n){return t<e?(n-t)/(e-t):(t-n)/(t-e)}function la(t,e,n,r){var i;return n>r&&(i=n,n=r,r=i),t<e?t<n?(n-t)/(e-t):(r-t)/(e-t):t>r?(t-r)/(t-e):(t-n)/(t-e)}function ha(t,e,n,r){return t<e?(n-t)/(e-t):(t-r)/(t-e)}function ca(t,e,n,r){return t<e?(r-t)/(e-t):(t-n)/(t-e)}function fa(){this.successCallback=null,this.verbose=!1,this.polygons=!1,this.polygons_full=!1,this.linearRing=!0,this.noQuadTree=!1,this.noFrame=!1}function ga(t,e,n,r){var i=[];return t.polygons.forEach((function(t){t.forEach((function(t){t[0]+=e,t[1]+=n})),r.linearRing&&t.push(t[0]),i.push(t)})),i}function pa(t,e,n,r){return 0===n?(t+=1,e+=r[0][1]):1===n?t+=r[0][0]:2===n?e+=r[0][1]:3===n&&(t+=r[0][0],e+=1),[t,e]}function va(t,e,n){return 0===n?t++:1===n||(2===n?e++:3===n&&(t++,e++)),[t,e]}function da(t,e,n,r,i){var o=r,s=i,a=0,u=0;if(this.x=e,this.y=n,this.lowerBound=null,this.upperBound=null,this.childA=null,this.childB=null,this.childC=null,this.childD=null,1===r&&1===i)this.lowerBound=Math.min(t[n][e],t[n][e+1],t[n+1][e+1],t[n+1][e]),this.upperBound=Math.max(t[n][e],t[n][e+1],t[n+1][e+1],t[n+1][e]);else{if(r>1){for(;0!==o;)o>>=1,a++;r===1<<a-1&&a--,o=1<<a-1}if(i>1){for(;0!==s;)s>>=1,u++;i===1<<u-1&&u--,s=1<<u-1}this.childA=new da(t,e,n,o,s),this.lowerBound=this.childA.lowerBound,this.upperBound=this.childA.upperBound,r-o>0&&(this.childB=new da(t,e+o,n,r-o,s),this.lowerBound=Math.min(this.lowerBound,this.childB.lowerBound),this.upperBound=Math.max(this.upperBound,this.childB.upperBound),i-s>0&&(this.childC=new da(t,e+o,n+s,r-o,i-s),this.lowerBound=Math.min(this.lowerBound,this.childC.lowerBound),this.upperBound=Math.max(this.upperBound,this.childC.upperBound))),i-s>0&&(this.childD=new da(t,e,n+s,o,i-s),this.lowerBound=Math.min(this.lowerBound,this.childD.lowerBound),this.upperBound=Math.max(this.upperBound,this.childD.upperBound))}}function ya(t){var e,n;if(!t)throw new Error("data is required");if(!Array.isArray(t)||!Array.isArray(t[0]))throw new Error("data must be scalar field, i.e. array of arrays");if(t.length<2)throw new Error("data must contain at least two rows");if((n=t[0].length)<2)throw new Error("data must contain at least two columns");for(e=1;e<t.length;e++){if(!Array.isArray(t[e]))throw new Error("Row "+e+" is not an array");if(t[e].length!=n)throw new Error("unequal row lengths detected, please provide a regular grid")}this.data=t,this.root=new da(t,0,0,t[0].length-1,t.length-1)}function ma(t,e,n){var r,i,o,s=!1,a=!1,u=null,l=null,h=null,c=null,f=null,g=[];if(!t)throw new Error("data is required");if(null==e)throw new Error("threshold is required");if(n&&"object"!==m(n))throw new Error("options must be an object");if(r=function(t){var e,n,r,i,o;for(i=new fa,t=t||{},o=Object.keys(i),e=0;e<o.length;e++)null!=(r=t[n=o[e]])&&(i[n]=r);return i.polygons_full=!i.polygons,i.interpolate=ua,i}(n),t instanceof ya)u=t,l=t.root,h=t.data,r.noQuadTree||(s=!0);else{if(!Array.isArray(t)||!Array.isArray(t[0]))throw new Error("input is neither array of arrays nor object retrieved from 'QuadTree()'");h=t}if(Array.isArray(e)){for(a=!0,r.noQuadTree||(s=!0),i=0;i<e.length;i++)if(isNaN(+e[i]))throw new Error("threshold["+i+"] is not a number")}else{if(isNaN(+e))throw new Error("threshold must be a number or array of numbers");e=[e]}return s&&!l&&(u=new ya(h),l=u.root,h=u.data),r.verbose&&(r.polygons?console.log("MarchingSquaresJS-isoLines: returning single lines (polygons) for each grid cell"):console.log("MarchingSquaresJS-isoLines: returning line paths (polygons) for entire data grid"),a&&console.log("MarchingSquaresJS-isoLines: multiple lines requested, returning array of line paths instead of lines for a single threshold")),e.forEach((function(t,e){if(f=[],r.threshold=t,r.verbose&&console.log("MarchingSquaresJS-isoLines: computing iso lines for threshold "+t),r.polygons)if(s)l.cellsBelowThreshold(r.threshold,!0).forEach((function(t){f=f.concat(ga(_a(h,t.x,t.y,r),t.x,t.y,r))}));else for(o=0;o<h.length-1;++o)for(e=0;e<h[0].length-1;++e)f=f.concat(ga(_a(h,e,o,r),e,o,r));else{for(c=[],e=0;e<h[0].length-1;++e)c[e]=[];if(s)l.cellsBelowThreshold(r.threshold,!1).forEach((function(t){c[t.x][t.y]=_a(h,t.x,t.y,r)}));else for(e=0;e<h[0].length-1;++e)for(o=0;o<h.length-1;++o)c[e][o]=_a(h,e,o,r);f=function(t,e,n){var r,i,o,s,a,u,l,h,c,f,g,p,v,d,y,_=[],x=t.length-1,E=t[0].length-1,k=["right","bottom","left","top"],b=[0,-1,0,1],w=[-1,0,1,0],I={bottom:1,left:2,top:3,right:0};return n.noFrame||function(t,e){var n,r,i,o,s;for(n=!0,r=t[0].length,i=t.length,s=0;s<i;s++)if(t[s][0]>=e||t[s][r-1]>=e){n=!1;break}if(n&&(t[i-1][0]>=e||t[i-1][r-1]>=e)&&(n=!1),n)for(o=0;o<r-1;o++)if(t[0][o]>=e||t[i-1][o]>e){n=!1;break}return n}(t,n.threshold)&&(n.linearRing?_.push([[0,0],[0,x],[E,x],[E,0],[0,0]]):_.push([[0,0],[0,x],[E,x],[E,0]])),e.forEach((function(t,N){t.forEach((function(t,S){for(r=null,i=0;i<4;i++)if(r=k[i],"object"===m(t.edges[r])){for(a=[],o=t.edges[r],u=r,l=N,h=S,c=!1,f=[N+o.path[0][0],S+o.path[0][1]],a.push(f);!c&&"object"===m((s=e[l][h]).edges[u]);)iLine truncated
Author	SHA1	Message	Date
livio	41405bcc4f	Speed up Android test packages	2026-09-28 20:29:51 +02:00
livio	9b4ff9e188	Always retain KML lines and points	2026-09-28 20:29:21 +02:00
livio	c0adc27cf5	Use existing Base signing certificate	2026-09-28 19:55:22 +02:00
livio	3dfeef54ea	Release 0.4.8 with Android file imports	2026-09-28 19:42:26 +02:00
livio	b600412285	Fix layer search cursor and refresh project revisions	2026-09-25 22:44:54 +02:00
livio	f65451c414	Load distinct official cadastral sheet boundaries	2026-09-25 21:33:53 +02:00
livio	f480ce23ca	Release 0.4.5 with metadata tools and responsive layers	2026-09-25 21:10:19 +02:00
livio	00053e4d5f	Fix layer actions and add reusable color editors	2026-09-25 15:40:20 +02:00
livio	cfba1b998b	Release 0.4.3 with contextual help and parcel deduplication	2026-09-25 14:13:37 +02:00
livio	f1224b21c4	Aggiunge spostamento tra gruppi 0.4.2	2026-09-25 08:59:38 +02:00
livio	eb5f51795b	Migliora layer e persistenza nomi 0.4.1	2026-09-25 08:25:25 +02:00
livio	205a520708	Rilascia gestione completa progetti e aggiornamenti 0.4.0	2026-09-24 17:21:25 +02:00
livio	620a4bec26	Rilascia strumenti avanzati e archivio 0.3.0	2026-09-24 16:15:23 +02:00
livio	b19afbce91	Scegli ambito per modifica ed eliminazione	2026-09-24 14:42:39 +02:00
livio	28a982abed	Modifica ed elimina il disegno selezionato	2026-09-24 14:20:46 +02:00
livio	0ffcc7ae31	Distingui visivamente la gerarchia dei layer	2026-09-24 09:21:08 +02:00
livio	bb30f23d67	Riorganizza verticalmente il pannello layer	2026-09-24 09:04:13 +02:00
livio	87304b1568	Rimuovi oggetti e gruppi dal progetto	2026-09-24 08:50:31 +02:00
livio	a23eff6124	Rinomina ed evidenzia i gruppi mappa	2026-09-24 08:38:07 +02:00
livio	4da47a8835	Consenti di rinominare gli oggetti mappa	2026-09-24 08:15:58 +02:00
livio	fc303e2555	Separa le misure per ogni oggetto	2026-09-22 16:56:17 +02:00
livio	49ed7d5f0e	Mantieni aperto il gestore livelli al refresh	2026-09-22 16:15:12 +02:00
livio	3856a9f675	Correggi deselezione oggetti mappa	2026-09-22 16:01:35 +02:00
livio	e1bb7d9320	Correggi visibilità oggetti durante refresh GPS	2026-09-22 15:47:54 +02:00
livio	f1bbd53634	Aggiungi gestore gerarchico livelli mappa	2026-09-22 15:26:56 +02:00
livio	708f539c64	Persist map flags and toggle selected parcels	2026-09-22 14:43:27 +02:00
livio	e93dd9b867	Generate missing imported sheet outline	2026-09-22 10:47:35 +02:00
livio	a9b1d74983	Fix imported sheet layer visibility	2026-09-22 10:25:51 +02:00
livio	c093d88677	Separate projects and export tabs	2026-09-22 08:56:59 +02:00
livio	78af860493	Fix KMZ overlays and add map export	2026-09-22 08:43:23 +02:00
livio	32a36c98ec	Persist project display options and toggle map tools	2026-09-21 14:27:45 +02:00
livio	06050b05f5	Improve map measurement tools and project layers	2026-09-21 12:01:35 +02:00
livio	0344227a1b	Center map on startup location	2026-09-21 11:24:22 +02:00
livio	7933b2e86a	Reorganize map tools and improve KML sheet filtering	2026-09-21 11:01:12 +02:00
livio	c8b8f21d8d	Improve GIS import and add measurement tools	2026-09-21 09:31:35 +02:00
livio	ff2d4bccb6	Add structured multi-project storage	2026-09-14 09:56:55 +02:00
livio	ab43c5ca30	Fix Agency cadastral WMS coordinate system	2026-09-11 20:57:15 +02:00
livio	abc9516a0d	Overlay selected parcels on WMS preview	2026-09-11 20:42:40 +02:00
livio	0c42349937	Fix cadastral layer controls and WMS preview	2026-09-11 20:31:04 +02:00
livio	9733137fdd	Add Azure Maps road and satellite layers	2026-09-11 19:53:28 +02:00
livio	3ea51a6842	Fix native map services and add provider selection	2026-09-11 19:25:09 +02:00
livio	56211e4b25	Fix parcel coordinates and map controls	2026-09-11 18:46:56 +02:00