Rilascia strumenti avanzati e archivio 0.3.0

wwwroot/js/lme-map.js

@@ -70,6 +70,18 @@ const lmeState = {
     managerObjectOrder: {},
     managerCategoryNames: {},
     managerExpandedRows: new Set(),
+    managerSelectedObjectIds: new Set(),
+    managerSearchText: "",
+    permanentLabels: null,
+    undoStack: [],
+    redoStack: [],
+    historyBusy: false,
+    snapEnabled: true,
+    snapDistancePixels: 14,
+    autoSaveEnabled: true,
+    gpsProximityEnabled: true,
+    gpsBoundaryAlertEnabled: false,
+    lastBoundaryState: null,
     dotNetReference: null
 };
 
@@ -101,6 +113,11 @@ window.lmeMap = {
     startMeasurementDrawing,
     setDrawToolsVisible,
     clearDrawings,
+    undoMapChange,
+    redoMapChange,
+    restoreAutosave,
+    compareProjectSnapshots,
+    setAdvancedOptions,
     createMapExportGeoJson,
     createProjectSnapshot,
     loadProjectSnapshot,
@@ -119,6 +136,7 @@ window.lmeMap = {
     setNativeGpsPosition,
     setGpsPositionVisible,
     setGpsError,
+    saveGpsMeasurementPoint,
     resize,
     showInfo: setInfo
 };
@@ -173,6 +191,12 @@ function init(dotNetReference) {
         maxZoom: 22,
         attribution: "© OpenStreetMap contributors © CARTO"
     });
+    lmeState.baseLayers.offline = L.gridLayer({ attribution: "Sfondo offline" });
+    lmeState.baseLayers.offline.createTile = () => {
+        const tile = document.createElement("div");
+        tile.className = "lme-offline-tile";
+        return tile;
+    };
 
     lmeState.currentBase = lmeState.baseLayers.satellite.addTo(lmeState.map);
     restoreLayerOrder();
@@ -200,6 +224,7 @@ function init(dotNetReference) {
         opacity: 0.85
     }).addTo(lmeState.map);
     lmeState.managerHighlight = L.layerGroup().addTo(lmeState.map);
+    lmeState.permanentLabels = L.layerGroup().addTo(lmeState.map);
 
     refreshCadastreLayer();
     bindFileImport();
@@ -558,6 +583,7 @@ function bindFileImport() {
 
         try {
             const result = await readGisFile(file);
+            rememberMapChange();
             const geojson = result.geojson;
             const parcelLayer = addImportedFeatures(geojson);
             const sheetGeojson = result.sheetGeojson || emptyFeatureCollection();
@@ -577,6 +603,7 @@ function bindFileImport() {
             setInfo(`Caricato ${file.name}: ${featureCount} particelle/elementi${includedSheets}${ignored}${reprojected}.`);
             updateGpsInsideState();
             refreshLayerManager();
+            finishMapChange();
         } catch (error) {
             setInfo(`File non leggibile: ${error.message}`);
         } finally {
@@ -811,8 +838,14 @@ function kmlTextToGeoJson(text, sourceName) {
     const features = [];
     const visit = (node, folders) => {
         if (node?.type === "Feature") {
+            const sourceProperties = node.properties || {};
             node.properties = {
-                ...(node.properties || {}),
+                ...sourceProperties,
+                _lmeColor: sourceProperties._lmeColor || sourceProperties.stroke,
+                _lmeFillColor: sourceProperties._lmeFillColor || sourceProperties.fill,
+                _lmeWeight: sourceProperties._lmeWeight || sourceProperties["stroke-width"],
+                _lmeOpacity: sourceProperties._lmeOpacity || sourceProperties["stroke-opacity"],
+                _lmeFillOpacity: sourceProperties._lmeFillOpacity || sourceProperties["fill-opacity"],
                 _lmeFolder: folders.filter(Boolean).join(" / "),
                 _lmeSource: sourceName
             };
@@ -1196,6 +1229,7 @@ function renameManagedObject(record, index) {
         setInfo("Nome non modificato: inserisci un testo.");
         return;
     }
+    rememberMapChange();
     const properties = record.layer.feature.properties;
     properties.name = name;
     record.layer.lmeManagerLabel = record.categoryKey === "drawings" && record.layer instanceof L.Marker
@@ -1204,7 +1238,9 @@ function renameManagedObject(record, index) {
     updateStoredFeaturePopup(record.layer);
     refreshImportedMeasurements();
     refreshDrawingMeasurements();
+    refreshPermanentLabels();
     refreshLayerManager();
+    finishMapChange();
     setInfo(`Oggetto rinominato: ${name}.`);
 }
 
@@ -1235,6 +1271,7 @@ function renameManagedCategory(category, records) {
         setInfo("Nome non modificato: inserisci un testo.");
         return;
     }
+    rememberMapChange();
     lmeState.managerCategoryNames[category.key] = name;
     records.forEach(record => {
         if (record.layer?.feature?.properties) {
@@ -1242,6 +1279,7 @@ function renameManagedCategory(category, records) {
         }
     });
     refreshLayerManager();
+    finishMapChange();
     setInfo(`Gruppo rinominato: ${name}.`);
 }
 
@@ -1262,12 +1300,14 @@ function renameManagedBlock(category, source, records) {
         setInfo("Nome non modificato: inserisci un testo.");
         return;
     }
+    rememberMapChange();
     records.forEach(record => {
         if (record.layer?.feature?.properties) {
             record.layer.feature.properties._lmeGroupName = name;
         }
     });
     refreshLayerManager();
+    finishMapChange();
     setInfo(`Gruppo rinominato: ${name}.`);
 }
 
@@ -1322,12 +1362,17 @@ function removeManagedRecords(records, subject) {
     if (!records.length) {
         return;
     }
+    if (records.some(record => record.layer?.feature?.properties?._lmeLocked)) {
+        setInfo("Operazione annullata: sblocca prima tutti gli oggetti coinvolti.");
+        return;
+    }
     const message = records.length === 1
         ? `Rimuovere ${subject} dal progetto? Non verra incluso nel prossimo salvataggio.`
         : `Rimuovere ${subject} e tutti i suoi ${records.length} oggetti dal progetto? Non verranno inclusi nel prossimo salvataggio.`;
     if (!window.confirm(message)) {
         return;
     }
+    rememberMapChange();
     const removedIds = new Set(records.map(record => record.id));
     const categoryKeys = new Set(records.map(record => record.categoryKey));
     records.forEach(record => {
@@ -1350,6 +1395,7 @@ function removeManagedRecords(records, subject) {
     refreshDrawingMeasurements();
     updateGpsInsideState();
     refreshLayerManager();
+    finishMapChange();
     setInfo(`${records.length === 1 ? "Oggetto rimosso" : `${records.length} oggetti rimossi`} dal progetto.`);
 }
 
@@ -1401,6 +1447,7 @@ function refreshLayerManager() {
     applyStoredLayerManagerVisibility();
     container.innerHTML = "";
     lmeState.managerRecords = new Map();
+    container.appendChild(renderLayerSelectionToolbar());
     const categoriesByKey = new Map(layerManagerCategories().map(category => [category.key, category]));
     lmeState.layerOrder.forEach(categoryKey => {
         const category = categoriesByKey.get(categoryKey);
@@ -1418,7 +1465,13 @@ function refreshLayerManager() {
         records.sort((left, right) =>
             (positions.get(left.id) ?? Number.MAX_SAFE_INTEGER) - (positions.get(right.id) ?? Number.MAX_SAFE_INTEGER));
         records.forEach(record => lmeState.managerRecords.set(record.id, record));
-        container.appendChild(renderLayerManagerCategory(category, records));
+        const rendered = renderLayerManagerCategory(category, records);
+        const search = lmeState.managerSearchText.trim().toLocaleLowerCase("it");
+        if (search && !records.some((record, index) => `${managedObjectLabel(record, index)} ${record.source}`.toLocaleLowerCase("it").includes(search))
+            && !managedCategoryName(category, records).toLocaleLowerCase("it").includes(search)) {
+            rendered.hidden = true;
+        }
+        container.appendChild(rendered);
     });
     applyManagedVisualOrder(container);
     bindLayerManagerDrag(container);
@@ -1469,6 +1522,7 @@ function renderLayerManagerCategory(category, records) {
     });
     bindManagedParentHighlight(group, `category:${category.key}`, records);
     const children = group.querySelector(".layer-manager-children");
+    if (records.length) children.appendChild(renderManagedGroupTools(records));
     if (category.blocks) {
         const blocks = new Map();
         records.forEach(record => {
@@ -1519,6 +1573,7 @@ function renderLayerManagerBlock(category, source, records) {
     });
     bindManagedParentHighlight(block, `block:${category.key}:${source}`, records);
     const children = block.querySelector(".layer-manager-children");
+    children.appendChild(renderManagedGroupTools(records));
     records.forEach((record, index) => children.appendChild(renderLayerManagerObject(record, index)));
     return block;
 }
@@ -1585,9 +1640,423 @@ function renderLayerManagerObject(record, index) {
         ? rows.map(value => `<span>${escapeHtml(value)}</span>`).join("")
         : "<span>Nessuna misura disponibile</span>";
     details.appendChild(info);
+    details.appendChild(renderManagedObjectTools(record));
     return object;
 }
 
+function renderLayerSelectionToolbar() {
+    const selectedCount = lmeState.managerSelectedObjectIds.size;
+    const toolbar = document.createElement("section");
+    toolbar.className = "layer-selection-toolbar";
+    toolbar.innerHTML = `<label>Cerca oggetti<input type="search" value="${escapeHtml(lmeState.managerSearchText)}" placeholder="Nome o gruppo"></label>
+        <div class="layer-selection-summary"><strong>${selectedCount} selezionati</strong><button type="button" data-action="clear">Deseleziona</button></div>
+        <div class="layer-batch-actions">
+            <button type="button" data-action="duplicate">Duplica</button><button type="button" data-action="move">Sposta</button>
+            <button type="button" data-action="buffer">Buffer</button><button type="button" data-action="union">Unisci</button>
+            <button type="button" data-action="split">Dividi</button><button type="button" data-action="delete" class="danger-command">Rimuovi</button>
+        </div>`;
+    const search = toolbar.querySelector("input");
+    search.addEventListener("input", () => {
+        lmeState.managerSearchText = search.value;
+        refreshLayerManager();
+        requestAnimationFrame(() => document.querySelector(".layer-selection-toolbar input")?.focus());
+    });
+    toolbar.querySelectorAll("button").forEach(button => button.addEventListener("click", () => {
+        const records = [...lmeState.managerSelectedObjectIds]
+            .map(id => lmeState.managerRecords?.get(id)).filter(Boolean);
+        if (button.dataset.action === "clear") {
+            lmeState.managerSelectedObjectIds.clear();
+            refreshLayerManager();
+        } else if (!records.length) {
+            setInfo("Seleziona almeno un oggetto dalle sue opzioni.");
+        } else if (button.dataset.action === "duplicate") duplicateManagedRecords(records);
+        else if (button.dataset.action === "move") moveManagedRecords(records);
+        else if (button.dataset.action === "buffer") bufferManagedRecords(records);
+        else if (button.dataset.action === "union") unionManagedRecords(records);
+        else if (button.dataset.action === "split") splitManagedRecords(records);
+        else if (button.dataset.action === "delete") removeManagedRecords(records, "gli oggetti selezionati");
+    }));
+    return toolbar;
+}
+
+function renderManagedGroupTools(records) {
+    const tools = document.createElement("div");
+    tools.className = "layer-group-tools";
+    const properties = records[0]?.layer?.feature?.properties || {};
+    tools.innerHTML = `<strong>Azioni gruppo</strong><span class="layer-group-totals">${escapeHtml(managedGroupTotals(records))}</span><div class="layer-style-controls">
+        <label>Colore<input type="color" value="${normalizedColor(properties._lmeColor, "#16806a")}"></label>
+        <label>Spessore<input type="range" min="1" max="10" step="1" value="${Number(properties._lmeWeight) || 3}"></label>
+        <label>Opacita<input type="range" min="0.1" max="1" step="0.1" value="${Number(properties._lmeOpacity) || 1}"></label></div>
+        <div class="layer-compact-actions"><button type="button" data-group-action="select">Seleziona tutti</button><button type="button" data-group-action="lock">Blocca/sblocca</button><button type="button" data-group-action="labels">Etichette</button></div>`;
+    const inputs = tools.querySelectorAll("input");
+    inputs.forEach(input => input.addEventListener("change", () => {
+        applyManagedStyle(records, { color: inputs[0].value, weight: Number(inputs[1].value), opacity: Number(inputs[2].value) });
+    }));
+    tools.querySelector("[data-group-action='select']").addEventListener("click", () => {
+        records.forEach(record => lmeState.managerSelectedObjectIds.add(record.id)); refreshLayerManager();
+    });
+    tools.querySelector("[data-group-action='lock']").addEventListener("click", () => {
+        const lock = !records.every(record => Boolean(record.layer?.feature?.properties?._lmeLocked));
+        updateManagedProperties(records, properties => { properties._lmeLocked = lock; });
+        setInfo(lock ? "Gruppo bloccato." : "Gruppo sbloccato.");
+    });
+    tools.querySelector("[data-group-action='labels']").addEventListener("click", () => {
+        const visible = !records.every(record => Boolean(record.layer?.feature?.properties?._lmeLabelVisible));
+        updateManagedProperties(records, properties => { properties._lmeLabelVisible = visible; });
+    });
+    return tools;
+}
+
+function managedGroupTotals(records) {
+    let length = 0; let area = 0;
+    records.forEach(record => {
+        const layer = record.layer;
+        if (layer instanceof L.Circle) { area += Math.PI * layer.getRadius() ** 2; length += 2 * Math.PI * layer.getRadius(); }
+        else if (layer instanceof L.Polygon) polygonLatLngGroups(layer.getLatLngs()).forEach(polygon => {
+            area += Math.abs(polygon.reduce((sum, ring, index) => sum + (index ? -1 : 1) * Math.abs(L.GeometryUtil.geodesicArea(ring)), 0));
+            length += latLngPathLength(polygon[0] || [], true);
+        });
+        else if (layer instanceof L.Polyline) length += lineLatLngGroups(layer.getLatLngs()).reduce((sum, line) => sum + latLngPathLength(line, false), 0);
+    });
+    const values = []; if (area) values.push(`Area ${formatArea(area)}`); if (length) values.push(`Sviluppo ${formatDistance(length)}`);
+    return values.join(" | ") || `${records.length} oggetti`;
+}
+
+function renderManagedObjectTools(record) {
+    const properties = record.layer.feature?.properties || (record.layer.feature = { type: "Feature", properties: {} }).properties;
+    const selected = lmeState.managerSelectedObjectIds.has(record.id);
+    const locked = Boolean(properties._lmeLocked);
+    const tools = document.createElement("section");
+    tools.className = "layer-object-tools";
+    tools.innerHTML = `<label class="layer-manager-suboption"><input type="checkbox" data-field="selected" ${selected ? "checked" : ""}><span>Seleziona per azioni multiple</span></label>
+        <label class="layer-manager-suboption"><input type="checkbox" data-field="locked" ${locked ? "checked" : ""}><span>Blocca modifiche e rimozione</span></label>
+        <label class="layer-manager-suboption"><input type="checkbox" data-field="label" ${properties._lmeLabelVisible ? "checked" : ""}><span>Etichetta permanente sulla mappa</span></label>
+        <div class="layer-style-controls"><label>Linea<input type="color" data-field="color" value="${normalizedColor(properties._lmeColor, "#f97316")}"></label>
+        <label>Riempimento<input type="color" data-field="fillColor" value="${normalizedColor(properties._lmeFillColor, "#fb923c")}"></label>
+        <label>Spessore<input type="range" data-field="weight" min="1" max="10" step="1" value="${Number(properties._lmeWeight) || 3}"></label>
+        <label>Opacita<input type="range" data-field="opacity" min="0.1" max="1" step="0.1" value="${Number(properties._lmeOpacity) || 1}"></label>
+        <label>Riempimento %<input type="range" data-field="fillOpacity" min="0" max="0.8" step="0.05" value="${Number.isFinite(Number(properties._lmeFillOpacity)) ? Number(properties._lmeFillOpacity) : 0.2}"></label>
+        <label>Tratto<select data-field="dash"><option value="">Continuo</option><option value="8 6" ${properties._lmeDash === "8 6" ? "selected" : ""}>Tratteggiato</option><option value="2 6" ${properties._lmeDash === "2 6" ? "selected" : ""}>Puntinato</option></select></label></div>
+        <label>Note<textarea data-field="notes" rows="2" maxlength="1000" placeholder="Note tecniche">${escapeHtml(properties._lmeNotes || "")}</textarea></label>
+        <label class="layer-photo-picker">Foto<input type="file" data-field="photo" accept="image/*"></label>
+        ${properties._lmePhoto ? `<img class="layer-photo-preview" src="${properties._lmePhoto}" alt="Foto allegata"><button type="button" data-action="remove-photo">Rimuovi foto</button>` : ""}
+        <div class="layer-compact-actions"><button type="button" data-action="duplicate">Duplica</button><button type="button" data-action="numeric">Coordinate</button><button type="button" data-action="move">Sposta</button><button type="button" data-action="buffer">Buffer</button></div>`;
+    tools.querySelector("[data-field='selected']").addEventListener("change", event => {
+        if (event.target.checked) lmeState.managerSelectedObjectIds.add(record.id);
+        else lmeState.managerSelectedObjectIds.delete(record.id);
+        refreshLayerManager();
+    });
+    tools.querySelector("[data-field='locked']").addEventListener("change", event => updateManagedProperties([record], value => { value._lmeLocked = event.target.checked; }));
+    tools.querySelector("[data-field='label']").addEventListener("change", event => updateManagedProperties([record], value => { value._lmeLabelVisible = event.target.checked; }));
+    tools.querySelectorAll(".layer-style-controls input,.layer-style-controls select").forEach(input => input.addEventListener("change", () => applyManagedStyle([record], {
+        color: tools.querySelector("[data-field='color']").value,
+        fillColor: tools.querySelector("[data-field='fillColor']").value,
+        weight: Number(tools.querySelector("[data-field='weight']").value),
+        opacity: Number(tools.querySelector("[data-field='opacity']").value),
+        fillOpacity: Number(tools.querySelector("[data-field='fillOpacity']").value),
+        dash: tools.querySelector("[data-field='dash']").value
+    })));
+    tools.querySelector("[data-field='notes']").addEventListener("change", event => updateManagedProperties([record], value => { value._lmeNotes = event.target.value.trim(); }));
+    tools.querySelector("[data-field='photo']").addEventListener("change", async event => {
+        const file = event.target.files?.[0]; if (!file) return;
+        if (file.size > 2_500_000) { setInfo("Foto troppo grande: usa un file inferiore a 2,5 MB."); return; }
+        const dataUrl = await fileToDataUrl(file);
+        updateManagedProperties([record], value => { value._lmePhoto = dataUrl; });
+    });
+    tools.querySelector("[data-action='remove-photo']")?.addEventListener("click", () => updateManagedProperties([record], value => { delete value._lmePhoto; }));
+    tools.querySelector("[data-action='duplicate']").addEventListener("click", () => duplicateManagedRecords([record]));
+    tools.querySelector("[data-action='numeric']").addEventListener("click", () => numericEditManagedRecord(record));
+    tools.querySelector("[data-action='move']").addEventListener("click", () => moveManagedRecords([record]));
+    tools.querySelector("[data-action='buffer']").addEventListener("click", () => bufferManagedRecords([record]));
+    return tools;
+}
+
+function normalizedColor(value, fallback) {
+    return /^#[0-9a-f]{6}$/i.test(String(value || "")) ? value : fallback;
+}
+
+function updateManagedProperties(records, change) {
+    rememberMapChange();
+    records.forEach(record => {
+        record.layer.feature ||= { type: "Feature", properties: {} };
+        record.layer.feature.properties ||= {};
+        change(record.layer.feature.properties);
+        applyStyleFromProperties(record.layer);
+        updateStoredFeaturePopup(record.layer);
+    });
+    refreshPermanentLabels();
+    refreshLayerManager();
+    finishMapChange();
+}
+
+function applyManagedStyle(records, style) {
+    updateManagedProperties(records, properties => {
+        properties._lmeColor = style.color;
+        properties._lmeFillColor = style.fillColor || style.color;
+        properties._lmeWeight = style.weight;
+        properties._lmeOpacity = style.opacity;
+        if (style.fillOpacity !== undefined) properties._lmeFillOpacity = style.fillOpacity;
+        if (style.dash !== undefined) properties._lmeDash = style.dash;
+    });
+}
+
+function applyStyleFromProperties(layer) {
+    const properties = layer?.feature?.properties || {};
+    if (typeof layer?.setStyle === "function") {
+        layer.setStyle({
+            color: properties._lmeColor || layer.options.color,
+            fillColor: properties._lmeFillColor || layer.options.fillColor,
+            weight: Number(properties._lmeWeight) || layer.options.weight,
+            opacity: Number.isFinite(Number(properties._lmeOpacity)) ? Number(properties._lmeOpacity) : layer.options.opacity,
+            fillOpacity: Number.isFinite(Number(properties._lmeFillOpacity)) ? Number(properties._lmeFillOpacity) : layer.options.fillOpacity,
+            dashArray: properties._lmeDash || null
+        });
+    }
+}
+
+function refreshPermanentLabels() {
+    lmeState.permanentLabels?.clearLayers();
+    layerManagerCategories().forEach(category => managedRecordsForCategory(category).forEach((record, index) => {
+        const properties = record.layer?.feature?.properties || {};
+        if (!properties._lmeLabelVisible || lmeState.managerHiddenObjectIds.has(record.id)) return;
+        const center = layerLabelPosition(record.layer); if (!center) return;
+        L.marker(center, { pane: "tooltipPane", interactive: false, icon: L.divIcon({ className: "lme-permanent-label", html: `<span>${escapeHtml(managedObjectLabel(record, index))}</span>`, iconSize: null }) }).addTo(lmeState.permanentLabels);
+    }));
+}
+
+function layerLabelPosition(layer) {
+    if (typeof layer?.getBounds === "function" && layer.getBounds().isValid()) return layer.getBounds().getCenter();
+    if (typeof layer?.getLatLng === "function") return layer.getLatLng();
+    return null;
+}
+
+function fileToDataUrl(file) {
+    return new Promise((resolve, reject) => { const reader = new FileReader(); reader.onload = () => resolve(reader.result); reader.onerror = reject; reader.readAsDataURL(file); });
+}
+
+function addDrawingFeature(feature, select = false) {
+    let added = null;
+    L.geoJSON(feature, {
+        pane: "drawingsPane",
+        style: storedFeatureStyle,
+        pointToLayer: (item, latlng) => item?.properties?._lmeShape === "circle" && Number(item.properties._lmeRadius) > 0
+            ? L.circle(latlng, { pane: "drawingsPane", renderer: lmeState.drawingsRenderer, radius: Number(item.properties._lmeRadius) })
+            : L.marker(latlng, { pane: "drawingsPane", draggable: false }),
+        onEachFeature: (item, layer) => {
+            annotateDrawingLayer(layer, item?.properties?._lmeShape);
+            applyStyleFromProperties(layer);
+            updateStoredFeaturePopup(layer);
+            lmeState.drawings.addLayer(layer);
+            added = layer;
+        }
+    });
+    if (select && added) selectDrawingLayer(added);
+    return added;
+}
+
+function storedFeatureStyle(feature) {
+    const properties = feature?.properties || {};
+    return {
+        renderer: lmeState.drawingsRenderer,
+        color: properties._lmeColor || "#f97316",
+        fillColor: properties._lmeFillColor || "#fb923c",
+        weight: Number(properties._lmeWeight) || 3,
+        opacity: Number.isFinite(Number(properties._lmeOpacity)) ? Number(properties._lmeOpacity) : 1,
+        fillOpacity: Number.isFinite(Number(properties._lmeFillOpacity)) ? Number(properties._lmeFillOpacity) : 0.2,
+        dashArray: properties._lmeDash || null
+    };
+}
+
+function duplicateManagedRecords(records) {
+    if (records.some(record => record.layer?.feature?.properties?._lmeLocked)) { setInfo("Sblocca gli oggetti da duplicare."); return; }
+    rememberMapChange();
+    records.forEach((record, index) => {
+        const feature = record.layer.toGeoJSON();
+        feature.properties = { ...(feature.properties || {}), name: `${managedObjectLabel(record, index)} - copia`, _lmeManagerId: undefined };
+        if (record.layer instanceof L.Circle) {
+            const point = turf.transformTranslate(feature, 1.5, 45, { units: "meters" });
+            point.properties._lmeShape = "circle";
+            point.properties._lmeRadius = record.layer.getRadius();
+            addDrawingFeature(point);
+        } else {
+            addDrawingFeature(turf.transformTranslate(feature, 1.5, 45, { units: "meters" }));
+        }
+    });
+    refreshDrawingMeasurements(); refreshLayerManager(); finishMapChange();
+    setInfo(`${records.length} ${records.length === 1 ? "oggetto duplicato" : "oggetti duplicati"}.`);
+}
+
+function moveManagedRecords(records) {
+    if (records.some(record => record.layer?.feature?.properties?._lmeLocked)) { setInfo("Sblocca gli oggetti da spostare."); return; }
+    const north = Number(window.prompt("Spostamento verso nord in metri (negativo verso sud)", "0"));
+    if (!Number.isFinite(north)) return;
+    const east = Number(window.prompt("Spostamento verso est in metri (negativo verso ovest)", "0"));
+    if (!Number.isFinite(east) || (!north && !east)) return;
+    const distance = Math.hypot(north, east);
+    const bearing = Math.atan2(east, north) * 180 / Math.PI;
+    rememberMapChange();
+    records.forEach(record => {
+        const moved = turf.transformTranslate(record.layer.toGeoJSON(), distance, bearing, { units: "meters" });
+        replaceManagedLayer(record, moved);
+    });
+    finishManagedGeometryChange(`Spostati ${records.length} oggetti.`);
+}
+
+function bufferManagedRecords(records) {
+    const meters = Number(window.prompt("Distanza buffer in metri", "5"));
+    if (!Number.isFinite(meters) || meters <= 0) return;
+    rememberMapChange();
+    let count = 0;
+    records.forEach((record, index) => {
+        const buffered = turf.buffer(record.layer.toGeoJSON(), meters, { units: "meters" });
+        if (!buffered) return;
+        buffered.properties = { ...(record.layer.feature?.properties || {}), name: `Buffer ${meters} m - ${managedObjectLabel(record, index)}`, _lmeShape: "polygon", _lmeManagerId: undefined };
+        addDrawingFeature(buffered); count++;
+    });
+    finishManagedGeometryChange(`Creati ${count} buffer da ${formatDistance(meters)}.`);
+}
+
+function unionManagedRecords(records) {
+    const polygons = records.filter(record => record.layer instanceof L.Polygon).map(record => record.layer.toGeoJSON());
+    if (polygons.length < 2) { setInfo("Per unire seleziona almeno due aree o poligoni."); return; }
+    try {
+        const merged = turf.union(turf.featureCollection(polygons));
+        if (!merged) throw new Error("le aree non producono un risultato");
+        rememberMapChange();
+        merged.properties = { ...(polygons[0].properties || {}), name: "Unione aree", _lmeShape: "polygon", _lmeManagerId: undefined };
+        addDrawingFeature(merged, true);
+        polygons.forEach((_feature, index) => removeRecordWithoutPrompt(records.filter(record => record.layer instanceof L.Polygon)[index]));
+        lmeState.managerSelectedObjectIds.clear();
+        finishManagedGeometryChange("Aree unite in un nuovo oggetto.");
+    } catch (error) { setInfo(`Unione non riuscita: ${error.message}`); }
+}
+
+function splitManagedRecords(records) {
+    const polygonRecord = records.find(record => record.layer instanceof L.Polygon);
+    const lineRecord = records.find(record => record.layer instanceof L.Polyline && !(record.layer instanceof L.Polygon));
+    if (!polygonRecord || !lineRecord) { setInfo("Per dividere seleziona un poligono e una linea di taglio."); return; }
+    try {
+        const cutter = turf.buffer(lineRecord.layer.toGeoJSON(), 0.02, { units: "meters" });
+        const split = turf.difference(turf.featureCollection([polygonRecord.layer.toGeoJSON(), cutter]));
+        const parts = split ? turf.flatten(split).features : [];
+        if (parts.length < 2) throw new Error("la linea deve attraversare completamente il poligono");
+        rememberMapChange();
+        parts.forEach((part, index) => {
+            part.properties = { ...(polygonRecord.layer.feature?.properties || {}), name: `${managedObjectLabel(polygonRecord, 0)} - parte ${index + 1}`, _lmeManagerId: undefined };
+            addDrawingFeature(part);
+        });
+        removeRecordWithoutPrompt(polygonRecord);
+        lmeState.managerSelectedObjectIds.clear();
+        finishManagedGeometryChange(`Poligono diviso in ${parts.length} parti.`);
+    } catch (error) { setInfo(`Divisione non riuscita: ${error.message}`); }
+}
+
+function numericEditManagedRecord(record) {
+    if (record.layer?.feature?.properties?._lmeLocked) { setInfo("Sblocca prima l'oggetto."); return; }
+    if (record.layer instanceof L.Circle) {
+        const center = record.layer.getLatLng();
+        const value = window.prompt("Latitudine, longitudine, raggio in metri", `${center.lat.toFixed(7)}, ${center.lng.toFixed(7)}, ${record.layer.getRadius().toFixed(2)}`);
+        if (value === null) return;
+        const parts = value.split(/[;, ]+/).map(Number).filter(Number.isFinite);
+        if (parts.length < 3) { setInfo("Inserisci latitudine, longitudine e raggio validi."); return; }
+        rememberMapChange(); record.layer.setLatLng([parts[0], parts[1]]); record.layer.setRadius(parts[2]); annotateDrawingLayer(record.layer, "circle");
+    } else if (typeof record.layer?.getLatLng === "function") {
+        const point = record.layer.getLatLng();
+        const value = window.prompt("Latitudine, longitudine", `${point.lat.toFixed(7)}, ${point.lng.toFixed(7)}`);
+        if (value === null) return;
+        const parts = value.split(/[;, ]+/).map(Number).filter(Number.isFinite);
+        if (parts.length < 2) { setInfo("Inserisci coordinate valide."); return; }
+        rememberMapChange(); record.layer.setLatLng([parts[0], parts[1]]);
+    } else {
+        const lines = lineLatLngGroups(record.layer.getLatLngs());
+        const current = lines[0]?.map(point => `${point.lat.toFixed(7)},${point.lng.toFixed(7)}`).join("; ") || "";
+        const value = window.prompt("Vertici: coppie latitudine,longitudine separate da punto e virgola", current);
+        if (value === null) return;
+        const points = value.split(";").map(pair => pair.split(",").map(Number)).filter(pair => pair.length === 2 && pair.every(Number.isFinite));
+        if (points.length < 2) { setInfo("Servono almeno due vertici validi."); return; }
+        rememberMapChange(); record.layer.setLatLngs(points.map(point => L.latLng(point[0], point[1])));
+    }
+    finishManagedGeometryChange("Coordinate aggiornate.");
+}
+
+function replaceManagedLayer(record, feature) {
+    const parent = record.parent?.hasLayer?.(record.layer) ? record.parent : lmeState.drawings;
+    parent.removeLayer?.(record.layer);
+    clearManagedObjectState(record.id);
+    feature.properties = { ...(record.layer.feature?.properties || {}), ...(feature.properties || {}), _lmeManagerId: undefined };
+    addDrawingFeature(feature);
+}
+
+function removeRecordWithoutPrompt(record) {
+    record.parent?.removeLayer?.(record.layer); clearManagedObjectState(record.id);
+}
+
+function finishManagedGeometryChange(message) {
+    refreshImportedMeasurements(); refreshDrawingMeasurements(); refreshPermanentLabels(); updateGpsInsideState(); refreshLayerManager(); finishMapChange(); setInfo(message);
+}
+
+function rememberMapChange() {
+    if (lmeState.historyBusy || !lmeState.map) return;
+    const snapshot = createProjectSnapshot(true);
+    if (lmeState.undoStack.at(-1) !== snapshot) lmeState.undoStack.push(snapshot);
+    if (lmeState.undoStack.length > 30) lmeState.undoStack.shift();
+    lmeState.redoStack = [];
+}
+
+function finishMapChange() {
+    if (!lmeState.autoSaveEnabled || lmeState.historyBusy || !lmeState.map) return;
+    try { localStorage.setItem("lmeAutosaveV3", createProjectSnapshot(true)); } catch { }
+}
+
+function undoMapChange() {
+    if (!lmeState.undoStack.length) { setInfo("Nessuna operazione da annullare."); return; }
+    lmeState.redoStack.push(createProjectSnapshot(true));
+    restoreHistorySnapshot(lmeState.undoStack.pop(), "Operazione annullata.");
+}
+
+function redoMapChange() {
+    if (!lmeState.redoStack.length) { setInfo("Nessuna operazione da ripristinare."); return; }
+    lmeState.undoStack.push(createProjectSnapshot(true));
+    restoreHistorySnapshot(lmeState.redoStack.pop(), "Operazione ripristinata.");
+}
+
+function restoreHistorySnapshot(snapshot, message) {
+    lmeState.historyBusy = true;
+    try { loadProjectSnapshot(snapshot, "cronologia"); setInfo(message); } finally { lmeState.historyBusy = false; }
+}
+
+function restoreAutosave() {
+    const snapshot = localStorage.getItem("lmeAutosaveV3");
+    if (!snapshot) { setInfo("Nessun recupero automatico disponibile."); return false; }
+    rememberMapChange(); loadProjectSnapshot(snapshot, "recupero automatico"); return true;
+}
+
+function setAdvancedOptions(options) {
+    const value = options || {};
+    lmeState.snapEnabled = value.snapEnabled !== false;
+    lmeState.snapDistancePixels = Math.max(4, Math.min(40, Number(value.snapDistancePixels) || 14));
+    lmeState.autoSaveEnabled = value.autoSaveEnabled !== false;
+    lmeState.gpsProximityEnabled = value.gpsProximityEnabled !== false;
+    lmeState.gpsBoundaryAlertEnabled = Boolean(value.gpsBoundaryAlertEnabled);
+}
+
+function compareProjectSnapshots(currentRaw, previousRaw) {
+    const current = typeof currentRaw === "string" ? JSON.parse(currentRaw) : currentRaw;
+    const previous = typeof previousRaw === "string" ? JSON.parse(previousRaw) : previousRaw;
+    const collect = snapshot => ["drawings", "imported", "importedSheets", "selectedParcels"]
+        .flatMap(key => snapshot?.[key]?.features || []);
+    const keyFor = (feature, index) => feature?.properties?._lmeManagerId
+        || `${feature?.properties?.name || feature?.properties?.Name || "object"}:${index}`;
+    const currentMap = new Map(collect(current).map((feature, index) => [keyFor(feature, index), JSON.stringify(feature)]));
+    const previousMap = new Map(collect(previous).map((feature, index) => [keyFor(feature, index), JSON.stringify(feature)]));
+    let added = 0; let removed = 0; let changed = 0;
+    currentMap.forEach((value, key) => { if (!previousMap.has(key)) added++; else if (previousMap.get(key) !== value) changed++; });
+    previousMap.forEach((_value, key) => { if (!currentMap.has(key)) removed++; });
+    const message = `Confronto revisione: ${added} aggiunti, ${removed} rimossi, ${changed} modificati.`;
+    setInfo(message);
+    return message;
+}
+
 function renderLayerManagerVisibilityOption(label, checked, onChange) {
     const option = document.createElement("label");
     option.className = "layer-manager-suboption";
@@ -1753,6 +2222,7 @@ function setManagedObjectVisible(record, visible, refresh = true) {
     saveLayerManagerState();
     refreshImportedMeasurements();
     refreshDrawingMeasurements();
+    refreshPermanentLabels();
     if (refresh) {
         refreshLayerManager();
     }
@@ -2127,7 +2597,7 @@ function addImportedFeatures(geojson) {
             fillColor: "#ffffff",
             fillOpacity: 0.9
         }),
-        onEachFeature: bindStoredFeaturePopup
+        onEachFeature: (feature, layer) => { bindStoredFeaturePopup(feature, layer); applyStyleFromProperties(layer); }
     }).addTo(lmeState.imported);
     layer.lmeManagerLabel = managedGeoJsonLabel(geojson, "Dati importati");
     return layer;
@@ -2144,7 +2614,7 @@ function addImportedSheetFeatures(geojson) {
             fillColor: "#ffffff",
             fillOpacity: 0.85
         }),
-        onEachFeature: bindStoredFeaturePopup
+        onEachFeature: (feature, layer) => { bindStoredFeaturePopup(feature, layer); applyStyleFromProperties(layer); }
     }).addTo(lmeState.importedSheets);
     layer.lmeManagerLabel = managedGeoJsonLabel(geojson, "Cornice o foglio");
     return layer;
@@ -2193,6 +2663,7 @@ function fitImported() {
 }
 
 function clearImported() {
+    rememberMapChange();
     clearManagedCategoryState("imported");
     clearManagedCategoryState("importedSheets");
     lmeState.imported.clearLayers();
@@ -2203,9 +2674,11 @@ function clearImported() {
     setInfo("File GIS rimossi.");
     updateGpsInsideState();
     refreshLayerManager();
+    finishMapChange();
 }
 
 function addProjectMarker(name) {
+    rememberMapChange();
     const center = lmeState.map.getCenter();
     const label = (name || "Nuovo POI").trim();
     const marker = L.marker(center, { pane: "drawingsPane", draggable: false }).addTo(lmeState.drawings);
@@ -2219,6 +2692,7 @@ function addProjectMarker(name) {
     refreshDrawingMeasurements();
     refreshLayerManager();
     selectDrawingLayer(marker);
+    finishMapChange();
 }
 
 function configureDrawLabels() {
@@ -2243,6 +2717,7 @@ function bindDrawingEvents() {
         return;
     }
     lmeState.map.on(L.Draw.Event.CREATED, event => {
+        snapDrawingLayer(event.layer);
         annotateDrawingLayer(event.layer, event.layerType);
         lmeState.drawings.addLayer(event.layer);
         refreshDrawingMeasurements();
@@ -2257,12 +2732,16 @@ function bindDrawingEvents() {
         setInfo(completedLabels[event.layerType] || "Disegno completato.");
         refreshLayerManager();
         selectDrawingLayer(event.layer);
+        finishMapChange();
     });
+    lmeState.map.on(L.Draw.Event.DRAWSTART, rememberMapChange);
+    lmeState.map.on(L.Draw.Event.EDITSTART, rememberMapChange);
     lmeState.map.on(L.Draw.Event.EDITED, event => {
-        event.layers.eachLayer(layer => annotateDrawingLayer(layer));
+        event.layers.eachLayer(layer => { snapDrawingLayer(layer); annotateDrawingLayer(layer); });
         refreshDrawingMeasurements();
         updateGpsInsideState();
         refreshLayerManager();
+        finishMapChange();
     });
     lmeState.map.on(L.Draw.Event.DELETED, event => {
         event.layers?.eachLayer(layer => lmeState.drawings.removeLayer(layer));
@@ -2270,6 +2749,7 @@ function bindDrawingEvents() {
         refreshDrawingMeasurements();
         updateGpsInsideState();
         refreshLayerManager();
+        finishMapChange();
     });
     lmeState.map.on(L.Draw.Event.DRAWSTOP, () => {
         lmeState.activeDrawHandler = null;
@@ -2425,6 +2905,9 @@ function startScopedDrawingEdit(targetGroup, scope) {
     if (!mode?.handler) {
         return;
     }
+    const locked = targetGroup.getLayers().filter(layer => layer?.feature?.properties?._lmeLocked);
+    if (locked.length) { setInfo("Sblocca gli oggetti prima di modificarli."); return; }
+    rememberMapChange();
     mode.handler._featureGroup = targetGroup;
     mode.handler.options.featureGroup = targetGroup;
     mode.handler.enable();
@@ -2443,6 +2926,7 @@ function removeSelectedDrawing() {
         setInfo("Salva o annulla la modifica prima di eliminare il disegno.");
         return;
     }
+    if (layer.feature?.properties?._lmeLocked) { setInfo("Sblocca prima l'oggetto selezionato."); return; }
     const record = {
         id: managedLayerId(layer, "drawings"),
         categoryKey: "drawings",
@@ -2453,6 +2937,7 @@ function removeSelectedDrawing() {
     if (!window.confirm(`Eliminare solo '${name}' dal progetto?`)) {
         return;
     }
+    rememberMapChange();
     lmeState.drawingSelection.clearLayers();
     lmeState.drawings.removeLayer(layer);
     clearManagedObjectState(record.id);
@@ -2460,6 +2945,7 @@ function removeSelectedDrawing() {
     refreshDrawingMeasurements();
     updateGpsInsideState();
     refreshLayerManager();
+    finishMapChange();
     setInfo(`'${name}' eliminato dal progetto.`);
 }
 
@@ -2598,6 +3084,10 @@ function clearDrawings() {
         return;
     }
 
+    if (managedRecordsForCategory(layerManagerCategories().find(item => item.key === "drawings")).some(record => record.layer?.feature?.properties?._lmeLocked)) {
+        setInfo("Sblocca tutti i disegni prima di eliminarli."); return;
+    }
+    rememberMapChange();
     drawingEditToolbar()?.disable?.();
     lmeState.drawingSelection?.clearLayers();
     clearManagerHighlight();
@@ -2607,6 +3097,25 @@ function clearDrawings() {
     updateGpsInsideState();
     setInfo("Disegni e POI eliminati dalla mappa.");
     refreshLayerManager();
+    finishMapChange();
+}
+
+function snapDrawingLayer(layer) {
+    if (!lmeState.snapEnabled || !layer || layer instanceof L.Circle || layer instanceof L.Marker) return;
+    const candidates = [];
+    layerManagerCategories().forEach(category => managedRecordsForCategory(category).forEach(record => {
+        if (record.layer === layer) return;
+        lineLatLngGroups(record.layer?.getLatLngs?.() || []).forEach(line => line.forEach(point => candidates.push(point)));
+        const point = record.layer?.getLatLng?.(); if (point) candidates.push(point);
+    }));
+    const snapPoint = point => {
+        const pixel = lmeState.map.latLngToContainerPoint(point);
+        let nearest = null; let distance = lmeState.snapDistancePixels;
+        candidates.forEach(candidate => { const current = pixel.distanceTo(lmeState.map.latLngToContainerPoint(candidate)); if (current < distance) { distance = current; nearest = candidate; } });
+        return nearest ? L.latLng(nearest.lat, nearest.lng) : point;
+    };
+    const transform = value => Array.isArray(value) ? value.map(transform) : snapPoint(value);
+    layer.setLatLngs(transform(layer.getLatLngs()));
 }
 
 function scheduleMeasurementRefresh() {
@@ -2891,7 +3400,10 @@ function createMapExportGeoJson(options) {
         });
     }
 
-    return JSON.stringify({ type: "FeatureCollection", features });
+    const exported = requested.selectedOnly
+        ? features.filter(feature => lmeState.managerSelectedObjectIds.has(feature?.properties?._lmeManagerId))
+        : features;
+    return JSON.stringify({ type: "FeatureCollection", features: exported });
 }
 
 function appendExportFeatures(target, collection, category, predicate = () => true) {
@@ -2936,7 +3448,7 @@ function circleToPolygon(center, radiusMeters) {
 function createProjectSnapshot(includeCadastralParcels) {
     const center = lmeState.map.getCenter();
     return JSON.stringify({
-        schemaVersion: 3,
+        schemaVersion: 4,
         view: {
             latitude: center.lat,
             longitude: center.lng,
@@ -2983,12 +3495,7 @@ function loadProjectSnapshot(raw, projectName) {
 
         const restoredDrawings = L.geoJSON(data.drawings || emptyFeatureCollection(), {
             pane: "drawingsPane",
-            style: {
-                renderer: lmeState.drawingsRenderer,
-                color: "#f97316",
-                weight: 3,
-                fillOpacity: 0.16
-            },
+            style: storedFeatureStyle,
             pointToLayer: (feature, latlng) => {
                 const properties = feature?.properties || {};
                 if (properties._lmeShape === "circle" && Number(properties._lmeRadius) > 0) {
@@ -3007,6 +3514,7 @@ function loadProjectSnapshot(raw, projectName) {
             onEachFeature: (feature, layer) => {
                 bindStoredFeaturePopup(feature, layer);
                 annotateDrawingLayer(layer, feature?.properties?._lmeShape);
+                applyStyleFromProperties(layer);
             }
         });
         restoredDrawings.eachLayer(layer => lmeState.drawings.addLayer(layer));
@@ -3046,6 +3554,7 @@ function loadProjectSnapshot(raw, projectName) {
         }
         refreshImportedMeasurements();
         refreshDrawingMeasurements();
+        refreshPermanentLabels();
 
         const projectLayerList = [
             lmeState.drawings,
@@ -3247,6 +3756,8 @@ function resetLayerManagerProjectState() {
     lmeState.managerRemovedCategories.clear();
     lmeState.managerObjectOrder = {};
     lmeState.managerCategoryNames = {};
+    lmeState.managerSelectedObjectIds.clear();
+    lmeState.permanentLabels?.clearLayers();
     clearManagerHighlight();
 }
 
@@ -3275,8 +3786,11 @@ function bindStoredFeaturePopup(feature, layer) {
 function updateStoredFeaturePopup(layer, sourceProperties) {
     const properties = sourceProperties || layer?.feature?.properties || {};
     const label = properties.name || properties.Name || properties.label || properties.LABEL;
-    if (label) {
-        layer.bindPopup(`<strong>${escapeHtml(label)}</strong>`);
+    const notes = String(properties._lmeNotes || "").trim();
+    const photo = String(properties._lmePhoto || "");
+    if (label || notes || photo) {
+        const image = photo.startsWith("data:image/") ? `<img class="lme-popup-photo" src="${photo}" alt="Foto allegata">` : "";
+        layer.bindPopup(`${label ? `<strong>${escapeHtml(label)}</strong>` : ""}${notes ? `<p>${escapeHtml(notes)}</p>` : ""}${image}`);
         return;
     }
     if (typeof layer?.unbindPopup === "function") {
@@ -3299,6 +3813,7 @@ function setBaseLayer(name) {
         topographic: "Topografica Esri",
         terrain: "OpenTopoMap",
         carto: "CARTO Voyager",
+        offline: "Offline, solo dati vettoriali",
         "azure-road": "Strade Azure Maps",
         "azure-satellite": "Satellite Azure Maps",
         "google-satellite": "Satellite Google Maps",
@@ -3562,11 +4077,13 @@ function activeCadastreLayers() {
 
 function clearSelectedParcels() {
     const count = managedGroupGeoJson(lmeState.selectedParcelsLayer, "selectedParcels").features.length;
+    if (count) rememberMapChange();
     lmeState.selectedParcelsLayer.clearLayers();
     clearManagedCategoryState("selectedParcels");
     updateGpsInsideState();
     setInfo(count ? `${count} particelle selezionate rimosse.` : "Non ci sono particelle selezionate da rimuovere.");
     refreshLayerManager();
+    if (count) finishMapChange();
 }
 
 function setSelectedParcelsVisible(enabled) {
@@ -3608,6 +4125,7 @@ function clearMapElements() {
         return;
     }
 
+    rememberMapChange();
     resetLayerManagerProjectState();
     lmeState.selectedParcelsLayer.clearLayers();
     lmeState.gpsParcelLayer.clearLayers();
@@ -3621,6 +4139,7 @@ function clearMapElements() {
     updateGpsInsideState();
     setInfo("Elementi della mappa rimossi. Sfondo e layer catastali restano attivi.");
     refreshLayerManager();
+    finishMapChange();
 }
 
 function startGps() {
@@ -3721,6 +4240,7 @@ function onGpsPosition(position) {
     if (lmeState.gpsTrailEnabled) {
         lmeState.gpsTrailPoints.push(latlng);
         lmeState.gpsTrail.setLatLngs(lmeState.gpsTrailPoints);
+        if (lmeState.gpsTrailPoints.length % 10 === 0) finishMapChange();
     }
 
     setText("gpsState", `${latitude.toFixed(6)}, ${longitude.toFixed(6)} - precisione ${Math.round(lmeState.lastAccuracy)} m`);
@@ -3782,6 +4302,7 @@ function updateGpsInsideState() {
     }
 
     const point = [lmeState.lastPosition[1], lmeState.lastPosition[0]];
+    updateGpsProximity(point);
     const officialMatch = findContainingPolygon(point, lmeState.selectedParcelsLayer.toGeoJSON())
         || findContainingPolygon(point, lmeState.gpsParcelLayer.toGeoJSON());
     if (officialMatch) {
@@ -3808,6 +4329,52 @@ function updateGpsInsideState() {
             : "Fuori dai poligoni caricati");
 }
 
+function updateGpsProximity(coordinates) {
+    if (!lmeState.gpsProximityEnabled || !window.turf) return;
+    const record = lmeState.managerRecords?.get(lmeState.managerHighlightedObjectId)
+        || [...lmeState.managerSelectedObjectIds].map(id => lmeState.managerRecords?.get(id)).find(Boolean);
+    if (!record?.layer) return;
+    try {
+        const feature = record.layer.toGeoJSON();
+        const boundary = feature.geometry.type.includes("Polygon") ? turf.polygonToLine(feature) : feature;
+        const lines = boundary.type === "FeatureCollection" ? boundary.features : [boundary];
+        let nearest = null;
+        lines.forEach(line => {
+            const candidate = line.geometry.type.includes("Line") ? turf.nearestPointOnLine(line, turf.point(coordinates), { units: "meters" }) : null;
+            if (candidate && (!nearest || candidate.properties.dist < nearest.properties.dist)) nearest = candidate;
+        });
+        if (!nearest) return;
+        const distance = nearest.properties.dist;
+        const bearing = turf.bearing(turf.point(coordinates), nearest);
+        const direction = bearingToCardinal(bearing);
+        const inside = feature.geometry.type.includes("Polygon") && turf.booleanPointInPolygon(turf.point(coordinates), feature);
+        setText("gpsState", `${coordinates[1].toFixed(6)}, ${coordinates[0].toFixed(6)} - bordo ${formatDistance(distance)} ${direction}`);
+        if (lmeState.gpsBoundaryAlertEnabled && lmeState.lastBoundaryState !== null && inside !== lmeState.lastBoundaryState) {
+            navigator.vibrate?.([180, 100, 180]);
+            setInfo(inside ? "Ingresso nell'area selezionata." : "Uscita dall'area selezionata.");
+        }
+        lmeState.lastBoundaryState = inside;
+    } catch { }
+}
+
+function bearingToCardinal(value) {
+    const labels = ["N", "NE", "E", "SE", "S", "SO", "O", "NO"];
+    return labels[Math.round(((value % 360) + 360) % 360 / 45) % 8];
+}
+
+function saveGpsMeasurementPoint() {
+    if (!lmeState.lastPosition) { setInfo("Attendi una posizione GPS valida."); return; }
+    rememberMapChange();
+    const now = new Date();
+    addDrawingFeature({ type: "Feature", properties: {
+        name: `Rilievo GPS ${now.toLocaleString("it-IT")}`,
+        _lmeAccuracy: lmeState.lastAccuracy,
+        _lmeMeasuredAt: now.toISOString(),
+        _lmeNotes: `Precisione dichiarata: ${Math.round(lmeState.lastAccuracy)} m`
+    }, geometry: { type: "Point", coordinates: [lmeState.lastPosition[1], lmeState.lastPosition[0]] } }, true);
+    refreshLayerManager(); finishMapChange(); setInfo("Punto GPS salvato con precisione, data e ora.");
+}
+
 function gmlParcelsToGeoJson(xmlText) {
     const xml = new DOMParser().parseFromString(xmlText, "text/xml");
     const members = Array.from(xml.getElementsByTagNameNS("*", "member"));