From d3dc68ebe6c71fb2b97611e5c2d7b9837dc36257 Mon Sep 17 00:00:00 2001
From: giswqs <giswqs@gmail.com>
Date: Wed, 29 Jul 2026 23:18:46 -0400
Subject: [PATCH 01/19] feat: import QGIS project files

---
 .../src/components/layout/TopToolbar.tsx      |   7 +
 .../components/layout/toolbar/ImportMenu.tsx  |  45 +++
 .../layout/toolbar/ProjectFileDialogs.tsx     |  36 ++
 .../src/hooks/useProjectFileActions.ts        |  34 ++
 .../geolibre-desktop/src/i18n/locales/en.json |  15 +
 .../src/lib/qgis-project-import.ts            | 375 ++++++++++++++++++
 apps/geolibre-desktop/src/lib/tauri-io.ts     |  14 +
 apps/geolibre-desktop/src/lib/ui-profile.ts   |   2 +
 8 files changed, 528 insertions(+)
 create mode 100644 apps/geolibre-desktop/src/components/layout/toolbar/ImportMenu.tsx
 create mode 100644 apps/geolibre-desktop/src/lib/qgis-project-import.ts

diff --git a/apps/geolibre-desktop/src/components/layout/TopToolbar.tsx b/apps/geolibre-desktop/src/components/layout/TopToolbar.tsx
index 4dc272558..675e2e9f5 100644
--- a/apps/geolibre-desktop/src/components/layout/TopToolbar.tsx
+++ b/apps/geolibre-desktop/src/components/layout/TopToolbar.tsx
@@ -123,6 +123,7 @@ import { ControlsMenu } from "./toolbar/ControlsMenu";
 import { EditMenu } from "./toolbar/EditMenu";
 import { ViewMenu } from "./toolbar/ViewMenu";
 import { HelpMenu } from "./toolbar/HelpMenu";
+import { ImportMenu } from "./toolbar/ImportMenu";
 import { OsmPbfDialogs } from "./toolbar/OsmPbfDialogs";
 import { PluginsMenu } from "./toolbar/PluginsMenu";
 import { PluginToolbarMenus } from "./toolbar/PluginToolbarMenus";
@@ -1440,6 +1441,12 @@ export function TopToolbar({
           onOpenOfflineBasemap={onOpenBasemapExtract}
         />
       )}
+      {isMenuVisible(uiProfile, "import") && (
+        <ImportMenu
+          chrome={chrome}
+          onImportQgisProject={() => void projectFiles.handleImportQgisProject()}
+        />
+      )}
       {isMenuVisible(uiProfile, "edit") && (
         <EditMenu chrome={chrome} mapControllerRef={mapControllerRef} />
       )}
diff --git a/apps/geolibre-desktop/src/components/layout/toolbar/ImportMenu.tsx b/apps/geolibre-desktop/src/components/layout/toolbar/ImportMenu.tsx
new file mode 100644
index 000000000..e4a6ed69e
--- /dev/null
+++ b/apps/geolibre-desktop/src/components/layout/toolbar/ImportMenu.tsx
@@ -0,0 +1,45 @@
+import {
+  Button,
+  DropdownMenu,
+  DropdownMenuContent,
+  DropdownMenuItem,
+  DropdownMenuLabel,
+  DropdownMenuSeparator,
+  DropdownMenuTrigger,
+} from "@geolibre/ui";
+import { FileInput, Import } from "lucide-react";
+import { useTranslation } from "react-i18next";
+import type { ToolbarChrome } from "./constants";
+
+interface ImportMenuProps {
+  chrome: ToolbarChrome;
+  onImportQgisProject: () => void;
+}
+
+/** Import workflows that translate third-party project formats into GeoLibre. */
+export function ImportMenu({ chrome, onImportQgisProject }: ImportMenuProps) {
+  const { t } = useTranslation();
+  return (
+    <DropdownMenu>
+      <DropdownMenuTrigger asChild>
+        <Button
+          className={chrome.buttonClass}
+          variant="ghost"
+          size={chrome.buttonSize}
+          aria-label={t("toolbar.menu.import")}
+        >
+          <Import className={chrome.iconClassName} />
+          {chrome.renderLabel(t("toolbar.menu.import"))}
+        </Button>
+      </DropdownMenuTrigger>
+      <DropdownMenuContent align="start" className="w-64">
+        <DropdownMenuLabel>{t("toolbar.menu.import")}</DropdownMenuLabel>
+        <DropdownMenuSeparator />
+        <DropdownMenuItem onSelect={onImportQgisProject}>
+          <FileInput className="me-2 h-3.5 w-3.5" />
+          {t("toolbar.item.importQgisProjectEllipsis")}
+        </DropdownMenuItem>
+      </DropdownMenuContent>
+    </DropdownMenu>
+  );
+}
diff --git a/apps/geolibre-desktop/src/components/layout/toolbar/ProjectFileDialogs.tsx b/apps/geolibre-desktop/src/components/layout/toolbar/ProjectFileDialogs.tsx
index 82c03c42c..abde58b05 100644
--- a/apps/geolibre-desktop/src/components/layout/toolbar/ProjectFileDialogs.tsx
+++ b/apps/geolibre-desktop/src/components/layout/toolbar/ProjectFileDialogs.tsx
@@ -94,6 +94,42 @@ export function ProjectFileDialogs({ projectFiles }: ProjectFileDialogsProps) {
           </div>
         </DialogContent>
       </Dialog>
+      <Dialog
+        open={projectFiles.qgisImportWarnings !== null}
+        onOpenChange={(open: boolean) => {
+          if (!open) projectFiles.setQgisImportWarnings(null);
+        }}
+      >
+        <DialogContent className="max-w-lg">
+          <DialogHeader>
+            <DialogTitle>{t("toolbar.item.qgisImportComplete")}</DialogTitle>
+            <DialogDescription>
+              {projectFiles.qgisImportWarnings?.length
+                ? t("toolbar.item.qgisImportWarnings", {
+                    count: projectFiles.qgisImportWarnings.length,
+                  })
+                : t("toolbar.item.qgisImportSuccess")}
+            </DialogDescription>
+          </DialogHeader>
+          {projectFiles.qgisImportWarnings?.length ? (
+            <ul className="max-h-64 space-y-2 overflow-y-auto text-sm">
+              {projectFiles.qgisImportWarnings.map((warning, index) => (
+                <li key={`${warning.layerName}-${index}`}>
+                  <strong>{warning.layerName}:</strong>{" "}
+                  {t(`toolbar.item.qgisImportReason.${warning.reason}`, {
+                    provider: warning.provider || t("toolbar.item.qgisUnknownProvider"),
+                  })}
+                </li>
+              ))}
+            </ul>
+          ) : null}
+          <div className="flex justify-end">
+            <Button onClick={() => projectFiles.setQgisImportWarnings(null)}>
+              {t("common.ok")}
+            </Button>
+          </div>
+        </DialogContent>
+      </Dialog>
       <Dialog
         open={projectFiles.saveNamePrompt !== null}
         onOpenChange={(open: boolean) => {
diff --git a/apps/geolibre-desktop/src/hooks/useProjectFileActions.ts b/apps/geolibre-desktop/src/hooks/useProjectFileActions.ts
index 6679c3201..54a224c6b 100644
--- a/apps/geolibre-desktop/src/hooks/useProjectFileActions.ts
+++ b/apps/geolibre-desktop/src/hooks/useProjectFileActions.ts
@@ -18,6 +18,7 @@ import {
   isHttpUrl,
   isTauri,
   openProjectFile,
+  openQgisProjectFile,
   openRecentProjectFile,
   RecentProjectGoneError,
   saveProjectFile,
@@ -33,6 +34,7 @@ import { resolveShareBaseUrl } from "../lib/share-geolibre";
 import { shareAuthorizedFetch } from "../lib/share-gallery";
 import { normalizeProjectUrl } from "../lib/urls";
 import { resolveProjectXyzLayers } from "../lib/xyz-url";
+import { importQgisProject, type QgisProjectImportWarning } from "../lib/qgis-project-import";
 import type { MapControllerRef } from "../components/layout/toolbar/constants";
 
 /** A pending "strip env vars before saving?" prompt. */
@@ -116,6 +118,9 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
   const markSaved = useAppStore((s) => s.markSaved);
 
   const [actionError, setActionError] = useState<string | null>(null);
+  const [qgisImportWarnings, setQgisImportWarnings] = useState<QgisProjectImportWarning[] | null>(
+    null,
+  );
   const [projectUrlDialogOpen, setProjectUrlDialogOpen] = useState(false);
   const [projectUrl, setProjectUrl] = useState("");
   const [projectUrlError, setProjectUrlError] = useState<string | null>(null);
@@ -152,6 +157,32 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
     }
   };
 
+  const handleImportQgisProject = async () => {
+    const result = await openQgisProjectFile();
+    if (!result) return;
+    try {
+      const imported = importQgisProject(result.data, result.path);
+      if (!isTauri()) {
+        for (const layer of imported.project.layers) {
+          if (layer.sourcePath && !isHttpUrl(layer.sourcePath)) {
+            imported.warnings.push({
+              layerName: layer.name,
+              reason: "browser-local-file",
+            });
+          }
+        }
+      }
+      loadProject(imported.project, null);
+      useAppStore.setState({ isDirty: true });
+      setQgisImportWarnings(imported.warnings);
+    } catch (error) {
+      console.error("Failed to import QGIS project", error);
+      setActionError(
+        error instanceof Error ? error.message : t("toolbar.error.couldNotImportQgisProject"),
+      );
+    }
+  };
+
   const handleOpenFromUrl = async (event: FormEvent<HTMLFormElement>) => {
     event.preventDefault();
     const normalizedUrl = normalizeProjectUrl(projectUrl);
@@ -703,6 +734,8 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
   return {
     actionError,
     setActionError,
+    qgisImportWarnings,
+    setQgisImportWarnings,
     projectUrlDialogOpen,
     setProjectUrlDialogOpen,
     handleProjectUrlDialogOpenChange,
@@ -725,6 +758,7 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
     submitSaveNamePrompt,
     cancelSaveNamePrompt,
     handleOpenFromFile,
+    handleImportQgisProject,
     handleOpenFromUrl,
     openProjectFromShareUrl,
     handleOpenRecent,
diff --git a/apps/geolibre-desktop/src/i18n/locales/en.json b/apps/geolibre-desktop/src/i18n/locales/en.json
index 742b4a04d..c72a61b5d 100644
--- a/apps/geolibre-desktop/src/i18n/locales/en.json
+++ b/apps/geolibre-desktop/src/i18n/locales/en.json
@@ -1825,6 +1825,7 @@
   "toolbar": {
     "menu": {
       "project": "Project",
+      "import": "Import",
       "edit": "Edit",
       "view": "View",
       "addData": "Add Data",
@@ -2396,6 +2397,19 @@
       "webServices": "Web Services",
       "commandPalette": "Command Palette",
       "openProjectFromUrl": "Open project from URL",
+      "importQgisProjectEllipsis": "Import QGIS Project…",
+      "qgisImportComplete": "QGIS project imported",
+      "qgisImportSuccess": "All supported project content was imported.",
+      "qgisImportWarnings_one": "The project was imported, but {{count}} layer could not be loaded.",
+      "qgisImportWarnings_other": "The project was imported, but {{count}} layers could not be loaded.",
+      "qgisUnknownProvider": "unknown",
+      "qgisImportReason": {
+        "non-vector": "Only file-based vector layers are supported in this first version.",
+        "provider": "The {{provider}} data provider is not supported.",
+        "missing-source": "The layer has no readable data source.",
+        "format": "The layer's file format is not supported.",
+        "browser-local-file": "The local file is referenced, but browsers cannot reopen QGIS data paths. Use GeoLibre Desktop to load it."
+      },
       "openProjectFromUrlDesc": "Load a `.geolibre.json` project and add it to recent projects.",
       "projectUrl": "Project URL",
       "opening": "Opening...",
@@ -2505,6 +2519,7 @@
     },
     "error": {
       "couldNotOpenProject": "Could not open project.",
+      "couldNotImportQgisProject": "Could not import QGIS project.",
       "invalidProjectUrl": "Enter a valid HTTP or HTTPS project URL.",
       "couldNotOpenProjectUrl": "Could not open project URL.",
       "couldNotOpenRecentProject": "Could not open the recent project.",
diff --git a/apps/geolibre-desktop/src/lib/qgis-project-import.ts b/apps/geolibre-desktop/src/lib/qgis-project-import.ts
new file mode 100644
index 000000000..279d35c37
--- /dev/null
+++ b/apps/geolibre-desktop/src/lib/qgis-project-import.ts
@@ -0,0 +1,375 @@
+import {
+  DEFAULT_LAYER_STYLE,
+  createEmptyProject,
+  type GeoLibreLayer,
+  type GeoLibreProject,
+  type LayerGroup,
+  type LayerStyle,
+  type MapViewState,
+} from "@geolibre/core";
+import { strFromU8, unzipSync } from "fflate";
+
+export interface QgisProjectImportWarning {
+  layerName: string;
+  reason: "non-vector" | "provider" | "missing-source" | "format" | "browser-local-file";
+  provider?: string;
+}
+
+export interface QgisProjectImportResult {
+  project: GeoLibreProject;
+  warnings: QgisProjectImportWarning[];
+}
+
+const SUPPORTED_VECTOR_EXTENSIONS = new Set([
+  "csv",
+  "dxf",
+  "fgb",
+  "flatgeobuf",
+  "geojson",
+  "geoparquet",
+  "gml",
+  "gpkg",
+  "gpx",
+  "json",
+  "kml",
+  "kmz",
+  "parquet",
+  "shp",
+  "tab",
+  "tsv",
+  "zip",
+]);
+
+/** Convert a QGIS project into a GeoLibre project without evaluating QGIS code. */
+export function importQgisProject(
+  data: ArrayBuffer | Uint8Array | string,
+  sourcePath: string,
+): QgisProjectImportResult {
+  const xml = qgisProjectXml(data, sourcePath);
+  const document = new DOMParser().parseFromString(xml, "application/xml");
+  if (document.querySelector("parsererror") || document.documentElement.tagName !== "qgis") {
+    throw new Error("This file is not a valid QGIS project.");
+  }
+
+  const projectName =
+    text(document.querySelector("title")) || fileStem(sourcePath) || "Imported QGIS Project";
+  const project = createEmptyProject(projectName, { mapView: parseMapView(document) });
+  const groups = parseLayerGroups(document);
+  const groupByLayerId = layerGroupAssignments(document, groups);
+  const visibilityByLayerId = layerVisibility(document);
+  const mapLayers = Array.from(document.querySelectorAll("projectlayers > maplayer"));
+  const byId = new Map(
+    mapLayers.map((element) => [text(element.querySelector(":scope > id")), element]),
+  );
+  const warnings: QgisProjectImportWarning[] = [];
+  const layers: GeoLibreLayer[] = [];
+
+  for (const id of layerOrder(document, mapLayers)) {
+    const element = byId.get(id);
+    if (!element) continue;
+    const name = text(element.querySelector(":scope > layername")) || id || "QGIS layer";
+    const provider = text(element.querySelector(":scope > provider")).toLowerCase();
+    const source = qgisVectorSource(text(element.querySelector(":scope > datasource")), sourcePath);
+
+    if (!isSupportedVectorLayer(element, provider, source)) {
+      warnings.push({
+        layerName: name,
+        reason: unsupportedReason(element, provider, source),
+        ...(provider ? { provider } : {}),
+      });
+      continue;
+    }
+
+    layers.push({
+      id: uniqueLayerId(id, layers),
+      name,
+      type: "geojson",
+      source: { type: "geojson" },
+      visible: visibilityByLayerId.get(id) ?? true,
+      opacity: parseOpacity(element),
+      style: parseLayerStyle(element),
+      metadata: {
+        localFileReloadable: true,
+        importedFrom: "qgis",
+        qgisLayerId: id,
+        qgisProvider: provider,
+      },
+      sourcePath: source,
+      ...(groupByLayerId.get(id) ? { groupId: groupByLayerId.get(id) } : {}),
+    });
+  }
+
+  project.layers = layers;
+  project.layerGroups = groups.filter((group) =>
+    layers.some((layer) => layer.groupId === group.id),
+  );
+  project.metadata = {
+    importedFrom: "qgis",
+    qgisProjectPath: sourcePath,
+    qgisVersion: document.documentElement.getAttribute("version") ?? "",
+  };
+  return { project, warnings };
+}
+
+function qgisProjectXml(data: ArrayBuffer | Uint8Array | string, sourcePath: string): string {
+  if (typeof data === "string") return data;
+  const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
+  if (sourcePath.toLowerCase().endsWith(".qgs")) return strFromU8(bytes);
+  let entries: Record<string, Uint8Array>;
+  try {
+    entries = unzipSync(bytes);
+  } catch {
+    throw new Error("Could not read the compressed QGIS project.");
+  }
+  const qgsName = Object.keys(entries).find((name) => name.toLowerCase().endsWith(".qgs"));
+  if (!qgsName) throw new Error("The QGZ archive does not contain a QGS project file.");
+  return strFromU8(entries[qgsName]);
+}
+
+function parseMapView(document: Document): MapViewState {
+  const extent =
+    document.querySelector("mapcanvas > extent") ??
+    document.querySelector("projectviewsettings extent");
+  const xmin = numberText(extent?.querySelector("xmin"));
+  const ymin = numberText(extent?.querySelector("ymin"));
+  const xmax = numberText(extent?.querySelector("xmax"));
+  const ymax = numberText(extent?.querySelector("ymax"));
+  const authId =
+    text(document.querySelector("mapcanvas > destinationsrs authid")) ||
+    text(document.querySelector("projectCrs authid"));
+  if ([xmin, ymin, xmax, ymax].every(Number.isFinite)) {
+    const [west, south] = toWgs84(xmin, ymin, authId);
+    const [east, north] = toWgs84(xmax, ymax, authId);
+    if ([west, south, east, north].every(Number.isFinite)) {
+      return {
+        center: [(west + east) / 2, (south + north) / 2],
+        zoom: zoomForBounds(west, south, east, north),
+        bearing: 0,
+        pitch: 0,
+        bbox: [west, south, east, north],
+      };
+    }
+  }
+  return { center: [-100, 40], zoom: 2, bearing: 0, pitch: 0 };
+}
+
+function toWgs84(x: number, y: number, authId: string): [number, number] {
+  if (authId.toUpperCase() !== "EPSG:3857") return [x, y];
+  return [
+    (x / 20037508.34) * 180,
+    (180 / Math.PI) * (2 * Math.atan(Math.exp((y / 20037508.34) * Math.PI)) - Math.PI / 2),
+  ];
+}
+
+function zoomForBounds(west: number, south: number, east: number, north: number): number {
+  const span = Math.max(Math.abs(east - west), Math.abs(north - south) * 2, 0.000001);
+  return Math.max(0, Math.min(20, Math.log2(360 / span) - 0.75));
+}
+
+function parseLayerGroups(document: Document): LayerGroup[] {
+  const root = document.querySelector("layer-tree-group");
+  if (!root) return [];
+  return Array.from(root.children)
+    .filter((element) => element.tagName === "layer-tree-group")
+    .map((element, index) => ({
+      id: `qgis-group-${index}-${slug(element.getAttribute("name") ?? "group")}`,
+      name: element.getAttribute("name") || "Group",
+      collapsed: element.getAttribute("expanded") === "0",
+      visible: element.getAttribute("checked") !== "Qt::Unchecked",
+      opacity: 1,
+    }));
+}
+
+function layerGroupAssignments(document: Document, groups: LayerGroup[]): Map<string, string> {
+  const assignments = new Map<string, string>();
+  const root = document.querySelector("layer-tree-group");
+  if (!root) return assignments;
+  Array.from(root.children)
+    .filter((element) => element.tagName === "layer-tree-group")
+    .forEach((element, index) => {
+      const group = groups[index];
+      if (!group) return;
+      element.querySelectorAll("layer-tree-layer[id]").forEach((layer) => {
+        const id = layer.getAttribute("id");
+        if (id) assignments.set(id, group.id);
+      });
+    });
+  return assignments;
+}
+
+function layerVisibility(document: Document): Map<string, boolean> {
+  const result = new Map<string, boolean>();
+  document.querySelectorAll("layer-tree-layer[id]").forEach((element) => {
+    const id = element.getAttribute("id");
+    if (id) result.set(id, element.getAttribute("checked") !== "Qt::Unchecked");
+  });
+  return result;
+}
+
+function layerOrder(document: Document, mapLayers: Element[]): string[] {
+  const ids = Array.from(document.querySelectorAll("layer-tree-layer[id]"))
+    .map((element) => element.getAttribute("id") ?? "")
+    .filter(Boolean);
+  if (ids.length > 0) return ids.reverse();
+  return mapLayers
+    .map((element) => text(element.querySelector(":scope > id")))
+    .filter(Boolean)
+    .reverse();
+}
+
+function qgisVectorSource(dataSource: string, projectPath: string): string {
+  let source = dataSource.split("|", 1)[0]?.trim() ?? "";
+  if (source.startsWith("file://")) {
+    try {
+      source = decodeURIComponent(new URL(source).pathname);
+    } catch {
+      source = source.slice("file://".length);
+    }
+  }
+  source = source.replace(/^['"]|['"]$/g, "");
+  if (!source || isAbsolutePath(source) || /^[a-z]+:\/\//i.test(source)) return source;
+  const directory = projectPath.replace(/[/\\][^/\\]*$/, "");
+  return normalizeJoinedPath(directory, source);
+}
+
+function normalizeJoinedPath(directory: string, relative: string): string {
+  const separator = directory.includes("\\") ? "\\" : "/";
+  const absolute = directory.startsWith("/");
+  const parts = [
+    ...directory.replace(/\\/g, "/").split("/"),
+    ...relative.replace(/\\/g, "/").split("/"),
+  ];
+  const normalized: string[] = [];
+  for (const part of parts) {
+    if (!part || part === ".") continue;
+    if (part === "..") normalized.pop();
+    else normalized.push(part);
+  }
+  return `${absolute ? "/" : ""}${normalized.join(separator)}`;
+}
+
+function isSupportedVectorLayer(element: Element, provider: string, source: string): boolean {
+  const extension = source.split(/[?#]/, 1)[0]?.split(".").pop()?.toLowerCase() ?? "";
+  return (
+    element.getAttribute("type")?.toLowerCase() === "vector" &&
+    (provider === "ogr" || provider === "delimitedtext") &&
+    SUPPORTED_VECTOR_EXTENSIONS.has(extension)
+  );
+}
+
+function unsupportedReason(
+  element: Element,
+  provider: string,
+  source: string,
+): QgisProjectImportWarning["reason"] {
+  if (element.getAttribute("type")?.toLowerCase() !== "vector") {
+    return "non-vector";
+  }
+  if (provider !== "ogr" && provider !== "delimitedtext") {
+    return "provider";
+  }
+  if (!source) return "missing-source";
+  return "format";
+}
+
+function parseLayerStyle(element: Element): LayerStyle {
+  const style: LayerStyle = structuredClone(DEFAULT_LAYER_STYLE);
+  const symbolLayer = element.querySelector("renderer-v2 symbols symbol layer");
+  const options = new Map<string, string>();
+  symbolLayer?.querySelectorAll("Option[name]").forEach((option) => {
+    options.set(option.getAttribute("name") ?? "", option.getAttribute("value") ?? "");
+  });
+  const fill = qgisColor(options.get("color"));
+  const stroke = qgisColor(options.get("outline_color") ?? options.get("line_color"));
+  if (fill) {
+    style.fillColor = fill.color;
+    style.fillOpacity = fill.opacity;
+    style.markerColor = fill.color;
+  }
+  if (stroke) {
+    style.strokeColor = stroke.color;
+  }
+  const width = optionalNumber(options.get("outline_width") ?? options.get("line_width"));
+  if (width !== null) style.strokeWidth = Math.max(0, width * 3.78);
+  const size = optionalNumber(options.get("size"));
+  if (symbolLayer?.getAttribute("class") === "SimpleMarker" && size !== null) {
+    style.circleRadius = Math.max(1, (size * 3.78) / 2);
+  }
+  const textStyle = element.querySelector("labeling[type='simple'] settings text-style");
+  const field = textStyle?.getAttribute("fieldName")?.trim();
+  if (field) {
+    style.labels.enabled = true;
+    style.labels.field = field;
+    const color = qgisColor(textStyle?.getAttribute("textColor") ?? undefined);
+    if (color) style.labels.color = color.color;
+    const sizeValue = optionalNumber(textStyle?.getAttribute("fontSize") ?? undefined);
+    if (sizeValue !== null) style.labels.size = sizeValue;
+  }
+  return style;
+}
+
+function qgisColor(value: string | undefined): { color: string; opacity: number } | null {
+  if (!value) return null;
+  const parts = value.split(",").map(Number);
+  if (parts.length < 3 || parts.slice(0, 3).some((part) => !Number.isFinite(part))) return null;
+  const [red, green, blue, alpha = 255] = parts;
+  return {
+    color: `#${[red, green, blue]
+      .map((part) =>
+        Math.max(0, Math.min(255, Math.round(part)))
+          .toString(16)
+          .padStart(2, "0"),
+      )
+      .join("")}`,
+    opacity: Math.max(0, Math.min(1, alpha / 255)),
+  };
+}
+
+function parseOpacity(element: Element): number {
+  const value = optionalNumber(text(element.querySelector(":scope > layerOpacity")));
+  return value !== null ? Math.max(0, Math.min(1, value)) : 1;
+}
+
+function optionalNumber(value: string | undefined): number | null {
+  if (value == null || value.trim() === "") return null;
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+
+function uniqueLayerId(candidate: string, layers: GeoLibreLayer[]): string {
+  const base = candidate.trim() || `qgis-layer-${layers.length + 1}`;
+  let id = base;
+  let suffix = 2;
+  while (layers.some((layer) => layer.id === id)) id = `${base}-${suffix++}`;
+  return id;
+}
+
+function numberText(element: Element | null | undefined): number {
+  return Number(text(element));
+}
+
+function text(element: Element | null | undefined): string {
+  return element?.textContent?.trim() ?? "";
+}
+
+function fileStem(path: string): string {
+  return (
+    path
+      .split(/[/\\]/)
+      .pop()
+      ?.replace(/\.(qgz|qgs)$/i, "") ?? ""
+  );
+}
+
+function isAbsolutePath(path: string): boolean {
+  return path.startsWith("/") || path.startsWith("\\\\") || /^[A-Za-z]:[/\\]/.test(path);
+}
+
+function slug(value: string): string {
+  return (
+    value
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, "-")
+      .replace(/^-|-$/g, "") || "group"
+  );
+}
diff --git a/apps/geolibre-desktop/src/lib/tauri-io.ts b/apps/geolibre-desktop/src/lib/tauri-io.ts
index 194390d0a..fe35078da 100644
--- a/apps/geolibre-desktop/src/lib/tauri-io.ts
+++ b/apps/geolibre-desktop/src/lib/tauri-io.ts
@@ -2116,6 +2116,20 @@ export async function openProjectFile(): Promise<{
   return { project, path: selected };
 }
 
+/** Pick a QGIS project and return its raw bytes for the import converter. */
+export async function openQgisProjectFile(): Promise<{
+  data: ArrayBuffer;
+  path: string;
+} | null> {
+  const result = await openLocalDataFileWithFallback({
+    filters: [{ name: "QGIS Project", extensions: ["qgz", "qgs"] }],
+    accept: ".qgz,.qgs",
+    readBinary: true,
+  });
+  if (!result?.data) return null;
+  return { data: result.data, path: result.path };
+}
+
 /**
  * Thrown when a recent project is permanently gone (HTTP 404/410 or a local
  * file that no longer exists), signalling the caller that the entry can be
diff --git a/apps/geolibre-desktop/src/lib/ui-profile.ts b/apps/geolibre-desktop/src/lib/ui-profile.ts
index db666f0c5..eda3805d8 100644
--- a/apps/geolibre-desktop/src/lib/ui-profile.ts
+++ b/apps/geolibre-desktop/src/lib/ui-profile.ts
@@ -197,6 +197,7 @@ export const PLUGIN_TIERS: Record<string, ComplexityTier> = {
  * so the profile UI can never be locked away). */
 export type TopLevelMenuId =
   | "project"
+  | "import"
   | "edit"
   | "view"
   | "addData"
@@ -214,6 +215,7 @@ export interface TopLevelMenuEntry {
 /** Hideable top-level menus, in toolbar order. */
 export const TOP_LEVEL_MENUS: readonly TopLevelMenuEntry[] = [
   { id: "project", labelKey: "toolbar.menu.project", tier: "basic" },
+  { id: "import", labelKey: "toolbar.menu.import", tier: "basic" },
   { id: "edit", labelKey: "toolbar.menu.edit", tier: "basic" },
   { id: "view", labelKey: "toolbar.menu.view", tier: "basic" },
   { id: "addData", labelKey: "toolbar.menu.addData", tier: "basic" },

From 18621b0880cbc70529eaa8b759b150e7de9480c4 Mon Sep 17 00:00:00 2001
From: giswqs <giswqs@gmail.com>
Date: Wed, 29 Jul 2026 23:34:34 -0400
Subject: [PATCH 02/19] fix: address QGIS import review feedback

---
 .../geolibre-desktop/src/i18n/locales/en.json |   2 +
 .../src/lib/qgis-project-import.ts            | 109 +++++--
 package-lock.json                             | 302 ++++++++++++++++++
 package.json                                  |   1 +
 tests/qgis-project-import.test.ts             | 135 ++++++++
 5 files changed, 514 insertions(+), 35 deletions(-)
 create mode 100644 tests/qgis-project-import.test.ts

diff --git a/apps/geolibre-desktop/src/i18n/locales/en.json b/apps/geolibre-desktop/src/i18n/locales/en.json
index c72a61b5d..246a5bbb6 100644
--- a/apps/geolibre-desktop/src/i18n/locales/en.json
+++ b/apps/geolibre-desktop/src/i18n/locales/en.json
@@ -2408,6 +2408,8 @@
         "provider": "The {{provider}} data provider is not supported.",
         "missing-source": "The layer has no readable data source.",
         "format": "The layer's file format is not supported.",
+        "remote-file": "Remote QGIS file sources are not supported yet.",
+        "network-path": "Network share paths are not loaded for security reasons.",
         "browser-local-file": "The local file is referenced, but browsers cannot reopen QGIS data paths. Use GeoLibre Desktop to load it."
       },
       "openProjectFromUrlDesc": "Load a `.geolibre.json` project and add it to recent projects.",
diff --git a/apps/geolibre-desktop/src/lib/qgis-project-import.ts b/apps/geolibre-desktop/src/lib/qgis-project-import.ts
index 279d35c37..3dc8065e6 100644
--- a/apps/geolibre-desktop/src/lib/qgis-project-import.ts
+++ b/apps/geolibre-desktop/src/lib/qgis-project-import.ts
@@ -11,7 +11,14 @@ import { strFromU8, unzipSync } from "fflate";
 
 export interface QgisProjectImportWarning {
   layerName: string;
-  reason: "non-vector" | "provider" | "missing-source" | "format" | "browser-local-file";
+  reason:
+    | "non-vector"
+    | "provider"
+    | "missing-source"
+    | "format"
+    | "remote-file"
+    | "network-path"
+    | "browser-local-file";
   provider?: string;
 }
 
@@ -54,8 +61,8 @@ export function importQgisProject(
   const projectName =
     text(document.querySelector("title")) || fileStem(sourcePath) || "Imported QGIS Project";
   const project = createEmptyProject(projectName, { mapView: parseMapView(document) });
-  const groups = parseLayerGroups(document);
-  const groupByLayerId = layerGroupAssignments(document, groups);
+  const parsedGroups = parseLayerGroups(document);
+  const groupByLayerId = layerGroupAssignments(document, parsedGroups.ids);
   const visibilityByLayerId = layerVisibility(document);
   const mapLayers = Array.from(document.querySelectorAll("projectlayers > maplayer"));
   const byId = new Map(
@@ -100,7 +107,7 @@ export function importQgisProject(
   }
 
   project.layers = layers;
-  project.layerGroups = groups.filter((group) =>
+  project.layerGroups = parsedGroups.groups.filter((group) =>
     layers.some((layer) => layer.groupId === group.id),
   );
   project.metadata = {
@@ -138,9 +145,11 @@ function parseMapView(document: Document): MapViewState {
     text(document.querySelector("mapcanvas > destinationsrs authid")) ||
     text(document.querySelector("projectCrs authid"));
   if ([xmin, ymin, xmax, ymax].every(Number.isFinite)) {
-    const [west, south] = toWgs84(xmin, ymin, authId);
-    const [east, north] = toWgs84(xmax, ymax, authId);
-    if ([west, south, east, north].every(Number.isFinite)) {
+    const southwest = toWgs84(xmin, ymin, authId);
+    const northeast = toWgs84(xmax, ymax, authId);
+    if (southwest && northeast) {
+      const [west, south] = southwest;
+      const [east, north] = northeast;
       return {
         center: [(west + east) / 2, (south + north) / 2],
         zoom: zoomForBounds(west, south, east, north),
@@ -153,12 +162,16 @@ function parseMapView(document: Document): MapViewState {
   return { center: [-100, 40], zoom: 2, bearing: 0, pitch: 0 };
 }
 
-function toWgs84(x: number, y: number, authId: string): [number, number] {
-  if (authId.toUpperCase() !== "EPSG:3857") return [x, y];
-  return [
-    (x / 20037508.34) * 180,
-    (180 / Math.PI) * (2 * Math.atan(Math.exp((y / 20037508.34) * Math.PI)) - Math.PI / 2),
-  ];
+function toWgs84(x: number, y: number, authId: string): [number, number] | null {
+  const normalized = authId.toUpperCase();
+  if (normalized === "EPSG:4326" || normalized === "CRS:84") return [x, y];
+  if (normalized === "EPSG:3857") {
+    return [
+      (x / 20037508.34) * 180,
+      (180 / Math.PI) * (2 * Math.atan(Math.exp((y / 20037508.34) * Math.PI)) - Math.PI / 2),
+    ];
+  }
+  return null;
 }
 
 function zoomForBounds(west: number, south: number, east: number, north: number): number {
@@ -166,34 +179,47 @@ function zoomForBounds(west: number, south: number, east: number, north: number)
   return Math.max(0, Math.min(20, Math.log2(360 / span) - 0.75));
 }
 
-function parseLayerGroups(document: Document): LayerGroup[] {
+function parseLayerGroups(document: Document): {
+  groups: LayerGroup[];
+  ids: Map<Element, string>;
+} {
   const root = document.querySelector("layer-tree-group");
-  if (!root) return [];
-  return Array.from(root.children)
-    .filter((element) => element.tagName === "layer-tree-group")
-    .map((element, index) => ({
-      id: `qgis-group-${index}-${slug(element.getAttribute("name") ?? "group")}`,
-      name: element.getAttribute("name") || "Group",
+  if (!root) return { groups: [], ids: new Map() };
+  const ids = new Map<Element, string>();
+  const groups = Array.from(root.querySelectorAll("layer-tree-group")).map((element, index) => {
+    const name = groupDisplayName(element, root);
+    const id = `qgis-group-${index}-${slug(name)}`;
+    ids.set(element, id);
+    return {
+      id,
+      name,
       collapsed: element.getAttribute("expanded") === "0",
       visible: element.getAttribute("checked") !== "Qt::Unchecked",
       opacity: 1,
-    }));
+    };
+  });
+  return { groups, ids };
 }
 
-function layerGroupAssignments(document: Document, groups: LayerGroup[]): Map<string, string> {
+function groupDisplayName(element: Element, root: Element): string {
+  const names: string[] = [];
+  let current: Element | null = element;
+  while (current && current !== root) {
+    const name = current.getAttribute("name")?.trim();
+    if (name) names.unshift(name);
+    current = current.parentElement?.closest("layer-tree-group") ?? null;
+  }
+  return names.join(" / ") || "Group";
+}
+
+function layerGroupAssignments(document: Document, ids: Map<Element, string>): Map<string, string> {
   const assignments = new Map<string, string>();
-  const root = document.querySelector("layer-tree-group");
-  if (!root) return assignments;
-  Array.from(root.children)
-    .filter((element) => element.tagName === "layer-tree-group")
-    .forEach((element, index) => {
-      const group = groups[index];
-      if (!group) return;
-      element.querySelectorAll("layer-tree-layer[id]").forEach((layer) => {
-        const id = layer.getAttribute("id");
-        if (id) assignments.set(id, group.id);
-      });
-    });
+  document.querySelectorAll("layer-tree-layer[id]").forEach((layer) => {
+    const layerId = layer.getAttribute("id");
+    const parentGroup = layer.parentElement?.closest("layer-tree-group");
+    const groupId = parentGroup ? ids.get(parentGroup) : undefined;
+    if (layerId && groupId) assignments.set(layerId, groupId);
+  });
   return assignments;
 }
 
@@ -253,6 +279,8 @@ function isSupportedVectorLayer(element: Element, provider: string, source: stri
   return (
     element.getAttribute("type")?.toLowerCase() === "vector" &&
     (provider === "ogr" || provider === "delimitedtext") &&
+    !isHttpSource(source) &&
+    !isUncPath(source) &&
     SUPPORTED_VECTOR_EXTENSIONS.has(extension)
   );
 }
@@ -269,6 +297,8 @@ function unsupportedReason(
     return "provider";
   }
   if (!source) return "missing-source";
+  if (isHttpSource(source)) return "remote-file";
+  if (isUncPath(source)) return "network-path";
   return "format";
 }
 
@@ -345,7 +375,8 @@ function uniqueLayerId(candidate: string, layers: GeoLibreLayer[]): string {
 }
 
 function numberText(element: Element | null | undefined): number {
-  return Number(text(element));
+  const value = text(element);
+  return value === "" ? Number.NaN : Number(value);
 }
 
 function text(element: Element | null | undefined): string {
@@ -365,6 +396,14 @@ function isAbsolutePath(path: string): boolean {
   return path.startsWith("/") || path.startsWith("\\\\") || /^[A-Za-z]:[/\\]/.test(path);
 }
 
+function isHttpSource(path: string): boolean {
+  return /^https?:\/\//i.test(path);
+}
+
+function isUncPath(path: string): boolean {
+  return path.startsWith("\\\\") || path.startsWith("//");
+}
+
 function slug(value: string): string {
   return (
     value
diff --git a/package-lock.json b/package-lock.json
index c8a8aa07c..bbc0dce1d 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -18,6 +18,7 @@
         "@types/node": "^26.1.2",
         "eslint": "^10.8.0",
         "eslint-plugin-react-hooks": "^7.1.1",
+        "linkedom": "^0.18.13",
         "tsx": "^4.23.1",
         "typescript-eslint": "^8.65.0"
       },
@@ -11979,6 +11980,20 @@
         "url": "https://opencollective.com/express"
       }
     },
+    "node_modules/boolbase": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/boolbase/-/boolbase-2.0.0.tgz",
+      "integrity": "sha512-DkVaaQHymRhpYEYo9x1oo7Q7B0Y6KJUsjm3c9eTyFDby4MHLBTwZ6ZDWBel5zrYxj1WsZgC5oLpiz+93MluXeA==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": ">=20.19.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/fb55"
+      }
+    },
     "node_modules/bowser": {
       "version": "2.14.1",
       "resolved": "https://registry.npmjs.org/bowser/-/bowser-2.14.1.tgz",
@@ -12616,6 +12631,48 @@
         "utrie": "^1.0.2"
       }
     },
+    "node_modules/css-select": {
+      "version": "7.0.0",
+      "resolved": "https://registry.npmjs.org/css-select/-/css-select-7.0.0.tgz",
+      "integrity": "sha512-snmjEVXy+1LnwXdxhYvTMj1d9tOh4HxkA1YmoayVBeeyR2C14Pum7fcxJIm4SswYspVy866eYNwlH6xC3/VH5g==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "boolbase": "^2.0.0",
+        "css-what": "^8.0.0",
+        "domhandler": "^6.0.1",
+        "domutils": "^4.0.2",
+        "nth-check": "^3.0.1"
+      },
+      "engines": {
+        "node": ">=20.19.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/fb55"
+      }
+    },
+    "node_modules/css-what": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/css-what/-/css-what-8.0.0.tgz",
+      "integrity": "sha512-DH0Bqq3DNp5tdOReuNyAA+Ev4Y2GS5FMbZpeTLP6C4CDi0h5nL0BmUPChXw3o/qbHLDWHl49sbNqQVY7bMSDdw==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=20.19.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/fb55"
+      }
+    },
+    "node_modules/cssom": {
+      "version": "0.5.0",
+      "resolved": "https://registry.npmjs.org/cssom/-/cssom-0.5.0.tgz",
+      "integrity": "sha512-iKuQcq+NdHqlAcwUY0o/HL69XQrUaQdMjmStJ8JFmUaiiQErlhrmuigkg/CU4E2J0IyUKUrMAgl36TvN67MqTw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/csstype": {
       "version": "3.2.3",
       "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz",
@@ -12871,11 +12928,63 @@
         "node": ">=8"
       }
     },
+    "node_modules/dom-serializer": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-3.1.1.tgz",
+      "integrity": "sha512-4MEa38/QexBob6gFNwu+EGdWvhJ1OKuNwdYY3Y3NyeWDQfnGeDYQUDfIRzWu5B5gsv03so2Uxd28YC6zrsx3Lw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "domelementtype": "^3.0.0",
+        "domhandler": "^6.0.0",
+        "entities": "^8.0.0"
+      },
+      "engines": {
+        "node": ">=20.19.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/cheeriojs/dom-serializer?sponsor=1"
+      }
+    },
     "node_modules/dom-walk": {
       "version": "0.1.2",
       "resolved": "https://registry.npmjs.org/dom-walk/-/dom-walk-0.1.2.tgz",
       "integrity": "sha512-6QvTW9mrGeIegrFXdtQi9pk7O/nSK6lSdXW2eqUspN5LWD7UTji2Fqw5V2YLjBpHEoU9Xl/eUWNpDeZvoyOv2w=="
     },
+    "node_modules/domelementtype": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/domelementtype/-/domelementtype-3.0.0.tgz",
+      "integrity": "sha512-umCQid3jKbDmVjx8jGaW7uUykm4DEUeyV21hPxNMo2nV955DhUThwqyOIDtreepP31hl84X7G5U9ZfsWvIB3Pg==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/fb55"
+        }
+      ],
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=20.19.0"
+      }
+    },
+    "node_modules/domhandler": {
+      "version": "6.0.1",
+      "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-6.0.1.tgz",
+      "integrity": "sha512-gYzvtM72ZtxQO0T048kd6HWSbbGCNOUwcnfQ01cqIJ4X2IYKFFHZ5mKvrQETcFXxsRObZulDaKmy//R7TPtsBg==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "domelementtype": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=20.19.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/fb55/domhandler?sponsor=1"
+      }
+    },
     "node_modules/dompurify": {
       "version": "3.4.12",
       "resolved": "https://registry.npmjs.org/dompurify/-/dompurify-3.4.12.tgz",
@@ -12885,6 +12994,25 @@
         "@types/trusted-types": "^2.0.7"
       }
     },
+    "node_modules/domutils": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/domutils/-/domutils-4.0.2.tgz",
+      "integrity": "sha512-qI4JLRKnSzqFqr7hAlS5xQDusBCjKSEG4t4+7aNrIQMHBcsC2TGEhuyABJdYkgSewL57PNLYEiibY2iPKhKpaA==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "dom-serializer": "^3.0.0",
+        "domelementtype": "^3.0.0",
+        "domhandler": "^6.0.0"
+      },
+      "engines": {
+        "node": ">=20.19.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/fb55/domutils?sponsor=1"
+      }
+    },
     "node_modules/dotenv": {
       "version": "17.4.2",
       "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-17.4.2.tgz",
@@ -12997,6 +13125,19 @@
         "node": ">=8.6"
       }
     },
+    "node_modules/entities": {
+      "version": "8.0.0",
+      "resolved": "https://registry.npmjs.org/entities/-/entities-8.0.0.tgz",
+      "integrity": "sha512-zwfzJecQ/Uej6tusMqwAqU/6KL2XaB2VZ2Jg54Je6ahNBGNH6Ek6g3jjNCF0fG9EWQKGZNddNjU5F1ZQn/sBnA==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=20.19.0"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/entities?sponsor=1"
+      }
+    },
     "node_modules/error": {
       "version": "4.4.0",
       "resolved": "https://registry.npmjs.org/error/-/error-4.4.0.tgz",
@@ -15052,6 +15193,13 @@
         "node": ">=16.9.0"
       }
     },
+    "node_modules/html-escaper": {
+      "version": "3.0.3",
+      "resolved": "https://registry.npmjs.org/html-escaper/-/html-escaper-3.0.3.tgz",
+      "integrity": "sha512-RuMffC89BOWQoY0WKGpIhn5gX3iI54O6nRA0yC124NYVtzjmFWBIiFd8M0x+ZdX0P9R4lADg1mgP8C7PxGOWuQ==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/html-parse-stringify": {
       "version": "4.0.1",
       "resolved": "https://registry.npmjs.org/html-parse-stringify/-/html-parse-stringify-4.0.1.tgz",
@@ -15088,6 +15236,111 @@
         "node": ">=16.0.0"
       }
     },
+    "node_modules/htmlparser2": {
+      "version": "10.1.0",
+      "resolved": "https://registry.npmjs.org/htmlparser2/-/htmlparser2-10.1.0.tgz",
+      "integrity": "sha512-VTZkM9GWRAtEpveh7MSF6SjjrpNVNNVJfFup7xTY3UpFtm67foy9HDVXneLtFVt4pMz5kZtgNcvCniNFb1hlEQ==",
+      "dev": true,
+      "funding": [
+        "https://github.com/fb55/htmlparser2?sponsor=1",
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/fb55"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "domelementtype": "^2.3.0",
+        "domhandler": "^5.0.3",
+        "domutils": "^3.2.2",
+        "entities": "^7.0.1"
+      }
+    },
+    "node_modules/htmlparser2/node_modules/dom-serializer": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-2.0.0.tgz",
+      "integrity": "sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "domelementtype": "^2.3.0",
+        "domhandler": "^5.0.2",
+        "entities": "^4.2.0"
+      },
+      "funding": {
+        "url": "https://github.com/cheeriojs/dom-serializer?sponsor=1"
+      }
+    },
+    "node_modules/htmlparser2/node_modules/dom-serializer/node_modules/entities": {
+      "version": "4.5.0",
+      "resolved": "https://registry.npmjs.org/entities/-/entities-4.5.0.tgz",
+      "integrity": "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=0.12"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/entities?sponsor=1"
+      }
+    },
+    "node_modules/htmlparser2/node_modules/domelementtype": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/domelementtype/-/domelementtype-2.3.0.tgz",
+      "integrity": "sha512-OLETBj6w0OsagBwdXnPdN0cnMfF9opN69co+7ZrbfPGrdpPVNBUj02spi6B1N7wChLQiPn4CSH/zJvXw56gmHw==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/fb55"
+        }
+      ],
+      "license": "BSD-2-Clause"
+    },
+    "node_modules/htmlparser2/node_modules/domhandler": {
+      "version": "5.0.3",
+      "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-5.0.3.tgz",
+      "integrity": "sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "domelementtype": "^2.3.0"
+      },
+      "engines": {
+        "node": ">= 4"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/domhandler?sponsor=1"
+      }
+    },
+    "node_modules/htmlparser2/node_modules/domutils": {
+      "version": "3.2.2",
+      "resolved": "https://registry.npmjs.org/domutils/-/domutils-3.2.2.tgz",
+      "integrity": "sha512-6kZKyUajlDuqlHKVX1w7gyslj9MPIXzIFiz/rGu35uC1wMi+kMhQwGhl4lt9unC9Vb9INnY9Z3/ZA3+FhASLaw==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "dom-serializer": "^2.0.0",
+        "domelementtype": "^2.3.0",
+        "domhandler": "^5.0.3"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/domutils?sponsor=1"
+      }
+    },
+    "node_modules/htmlparser2/node_modules/entities": {
+      "version": "7.0.1",
+      "resolved": "https://registry.npmjs.org/entities/-/entities-7.0.1.tgz",
+      "integrity": "sha512-TWrgLOFUQTH994YUyl1yT4uyavY5nNB5muff+RtWaqNVCAK408b5ZnnbNAUEWLTCpum9w6arT70i1XdQ4UeOPA==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=0.12"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/entities?sponsor=1"
+      }
+    },
     "node_modules/http-errors": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.1.tgz",
@@ -16431,6 +16684,31 @@
       "integrity": "sha512-PosanfyLckGXZbCX+aWmfmHWWhVPnLf9iKcUefaSGGw2IBOef5XdBdyl175LEqRy/sEOZ2SEz/l7K5S93BZlYQ==",
       "license": "ISC"
     },
+    "node_modules/linkedom": {
+      "version": "0.18.13",
+      "resolved": "https://registry.npmjs.org/linkedom/-/linkedom-0.18.13.tgz",
+      "integrity": "sha512-ES/o9qotMpzpN2MHs+Iq/JcVoOj8Fa5wiQYrTdFpvAnwXL0g66XHHUc9WUMk6nAlBtGsFQ24ne+SYnvnaQ2FSw==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "css-select": "^7.0.0",
+        "cssom": "^0.5.0",
+        "html-escaper": "^3.0.3",
+        "htmlparser2": "^10.1.0",
+        "uhyphen": "^0.2.0"
+      },
+      "engines": {
+        "node": ">=16"
+      },
+      "peerDependencies": {
+        "canvas": ">= 2"
+      },
+      "peerDependenciesMeta": {
+        "canvas": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/locate-path": {
       "version": "6.0.0",
       "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz",
@@ -17696,6 +17974,23 @@
       "integrity": "sha512-9d1HbpKLh3sdWlhXMhU6MMH+wQzKkrgfRkYV0EBdvt99YJfj0ilCJrWRDYG2130Tm4GXbEoTCx5b34JSaP+HhA==",
       "license": "MIT"
     },
+    "node_modules/nth-check": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/nth-check/-/nth-check-3.0.1.tgz",
+      "integrity": "sha512-GX0gsdbGVCgnRgbeGaubfjpBXyYRWOOCVeYh08bSQvDZqxz5ndXs1OTfAt/h36G1xvI94YIspsI0sVFqAV9+RQ==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "boolbase": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=20.19.0"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/fb55/nth-check?sponsor=1"
+      }
+    },
     "node_modules/numcodecs": {
       "version": "0.3.2",
       "resolved": "https://registry.npmjs.org/numcodecs/-/numcodecs-0.3.2.tgz",
@@ -20462,6 +20757,13 @@
         "node": ">=12.17"
       }
     },
+    "node_modules/uhyphen": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/uhyphen/-/uhyphen-0.2.0.tgz",
+      "integrity": "sha512-qz3o9CHXmJJPGBdqzab7qAYuW8kQGKNEuoHFYrBwV6hWIMcpAmxDLXojcHfFr9US1Pe6zUswEIJIbLI610fuqA==",
+      "dev": true,
+      "license": "ISC"
+    },
     "node_modules/unbox-primitive": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/unbox-primitive/-/unbox-primitive-1.1.0.tgz",
diff --git a/package.json b/package.json
index f358eca65..6a008fdbf 100644
--- a/package.json
+++ b/package.json
@@ -37,6 +37,7 @@
     "@types/node": "^26.1.2",
     "eslint": "^10.8.0",
     "eslint-plugin-react-hooks": "^7.1.1",
+    "linkedom": "^0.18.13",
     "tsx": "^4.23.1",
     "typescript-eslint": "^8.65.0"
   },
diff --git a/tests/qgis-project-import.test.ts b/tests/qgis-project-import.test.ts
new file mode 100644
index 000000000..2d2f210da
--- /dev/null
+++ b/tests/qgis-project-import.test.ts
@@ -0,0 +1,135 @@
+import assert from "node:assert/strict";
+import { describe, it } from "node:test";
+import { strToU8, zipSync } from "fflate";
+import { DOMParser } from "linkedom";
+import { importQgisProject } from "../apps/geolibre-desktop/src/lib/qgis-project-import";
+
+globalThis.DOMParser = DOMParser as unknown as typeof globalThis.DOMParser;
+
+function projectXml(
+  options: {
+    authId?: string;
+    extent?: string;
+    dataSources?: Array<{ id: string; name: string; source: string }>;
+  } = {},
+): string {
+  const dataSources = options.dataSources ?? [
+    { id: "roads", name: "Roads", source: "../data/roads.geojson" },
+    { id: "cities", name: "Cities", source: "../data/cities.gpkg|layername=cities" },
+  ];
+  const mapLayers = dataSources
+    .map(
+      ({ id, name, source }) => `
+        <maplayer type="vector">
+          <id>${id}</id>
+          <layername>${name}</layername>
+          <datasource>${source}</datasource>
+          <provider>ogr</provider>
+          <layerOpacity>0.75</layerOpacity>
+          <renderer-v2 type="singleSymbol">
+            <symbols><symbol><layer class="SimpleMarker">
+              <Option name="color" value="255,0,0,128"/>
+              <Option name="outline_color" value="0,0,0,255"/>
+              <Option name="size" value="4"/>
+            </layer></symbol></symbols>
+          </renderer-v2>
+          <labeling type="simple">
+            <settings><text-style fieldName="name" fontSize="12"/></settings>
+          </labeling>
+        </maplayer>`,
+    )
+    .join("");
+
+  return `<qgis version="3.40.0">
+    <title>Imported map</title>
+    <layer-tree-group name="" checked="Qt::Checked">
+      <layer-tree-group name="Transport" checked="Qt::Checked">
+        <layer-tree-layer id="roads" checked="Qt::Unchecked"/>
+        <layer-tree-group name="Places" checked="Qt::Checked">
+          <layer-tree-layer id="cities" checked="Qt::Checked"/>
+        </layer-tree-group>
+      </layer-tree-group>
+    </layer-tree-group>
+    <projectlayers>${mapLayers}</projectlayers>
+    <mapcanvas>
+      ${options.extent ?? "<extent><xmin>-125</xmin><ymin>24</ymin><xmax>-66</xmax><ymax>50</ymax></extent>"}
+      <destinationsrs><spatialrefsys><authid>${options.authId ?? "EPSG:4326"}</authid></spatialrefsys></destinationsrs>
+    </mapcanvas>
+  </qgis>`;
+}
+
+describe("QGIS project import", () => {
+  it("imports vector layers, styles, visibility, nested groups, extent, and relative paths", () => {
+    const result = importQgisProject(projectXml(), "/work/projects/example.qgs");
+
+    assert.equal(result.project.name, "Imported map");
+    assert.deepEqual(result.project.mapView.center, [-95.5, 37]);
+    assert.deepEqual(
+      result.project.layerGroups?.map((group) => group.name),
+      ["Transport", "Transport / Places"],
+    );
+    assert.deepEqual(
+      result.project.layers.map((layer) => layer.name),
+      ["Cities", "Roads"],
+    );
+
+    const cities = result.project.layers[0];
+    const roads = result.project.layers[1];
+    assert.equal(cities.sourcePath, "/work/data/cities.gpkg");
+    assert.equal(cities.groupId, result.project.layerGroups?.[1].id);
+    assert.equal(cities.opacity, 0.75);
+    assert.equal(cities.style.fillColor, "#ff0000");
+    assert.equal(cities.style.fillOpacity, 128 / 255);
+    assert.equal(cities.style.labels.enabled, true);
+    assert.equal(cities.style.labels.field, "name");
+    assert.equal(roads.visible, false);
+    assert.equal(roads.groupId, result.project.layerGroups?.[0].id);
+    assert.deepEqual(result.warnings, []);
+  });
+
+  it("reads the QGS document from a QGZ archive", () => {
+    const qgz = zipSync({ "nested/project.qgs": strToU8(projectXml()) });
+    const result = importQgisProject(qgz, "/work/projects/example.qgz");
+    assert.equal(result.project.name, "Imported map");
+    assert.equal(result.project.layers.length, 2);
+  });
+
+  it("falls back to the default view for a missing or unsupported-CRS extent", () => {
+    const missing = importQgisProject(projectXml({ extent: "" }), "/work/example.qgs");
+    assert.deepEqual(missing.project.mapView, {
+      center: [-100, 40],
+      zoom: 2,
+      bearing: 0,
+      pitch: 0,
+    });
+
+    const projected = importQgisProject(projectXml({ authId: "EPSG:32618" }), "/work/example.qgs");
+    assert.deepEqual(projected.project.mapView, {
+      center: [-100, 40],
+      zoom: 2,
+      bearing: 0,
+      pitch: 0,
+    });
+  });
+
+  it("warns and omits remote and UNC file sources that cannot be restored", () => {
+    const result = importQgisProject(
+      projectXml({
+        dataSources: [
+          { id: "roads", name: "Remote", source: "https://example.com/roads.geojson" },
+          { id: "cities", name: "Network", source: "\\\\server\\share\\cities.gpkg" },
+        ],
+      }),
+      "C:\\projects\\example.qgs",
+    );
+
+    assert.deepEqual(result.project.layers, []);
+    assert.deepEqual(
+      result.warnings.map((warning) => [warning.layerName, warning.reason]),
+      [
+        ["Network", "network-path"],
+        ["Remote", "remote-file"],
+      ],
+    );
+  });
+});

From 2329d72277925f002d9ea9d472f6188404fed24f Mon Sep 17 00:00:00 2001
From: giswqs <giswqs@gmail.com>
Date: Thu, 30 Jul 2026 22:05:08 -0400
Subject: [PATCH 03/19] fix: move import under project menu

---
 .../src/components/layout/TopToolbar.tsx      |  8 +---
 .../components/layout/toolbar/ImportMenu.tsx  | 45 -------------------
 .../components/layout/toolbar/ProjectMenu.tsx | 18 ++++++++
 apps/geolibre-desktop/src/lib/ui-profile.ts   |  8 +++-
 4 files changed, 25 insertions(+), 54 deletions(-)
 delete mode 100644 apps/geolibre-desktop/src/components/layout/toolbar/ImportMenu.tsx

diff --git a/apps/geolibre-desktop/src/components/layout/TopToolbar.tsx b/apps/geolibre-desktop/src/components/layout/TopToolbar.tsx
index 675e2e9f5..d56f576ca 100644
--- a/apps/geolibre-desktop/src/components/layout/TopToolbar.tsx
+++ b/apps/geolibre-desktop/src/components/layout/TopToolbar.tsx
@@ -123,7 +123,6 @@ import { ControlsMenu } from "./toolbar/ControlsMenu";
 import { EditMenu } from "./toolbar/EditMenu";
 import { ViewMenu } from "./toolbar/ViewMenu";
 import { HelpMenu } from "./toolbar/HelpMenu";
-import { ImportMenu } from "./toolbar/ImportMenu";
 import { OsmPbfDialogs } from "./toolbar/OsmPbfDialogs";
 import { PluginsMenu } from "./toolbar/PluginsMenu";
 import { PluginToolbarMenus } from "./toolbar/PluginToolbarMenus";
@@ -1425,6 +1424,7 @@ export function TopToolbar({
           onOpenFromFile={() => void projectFiles.handleOpenFromFile()}
           onOpenFromUrl={() => projectFiles.setProjectUrlDialogOpen(true)}
           onOpenGallery={() => setGalleryDialogOpen(true)}
+          onImportQgisProject={() => void projectFiles.handleImportQgisProject()}
           onOpenRecent={(path) => {
             void projectFiles.handleOpenRecent(path).then((error) => {
               if (error) projectFiles.setActionError(error);
@@ -1441,12 +1441,6 @@ export function TopToolbar({
           onOpenOfflineBasemap={onOpenBasemapExtract}
         />
       )}
-      {isMenuVisible(uiProfile, "import") && (
-        <ImportMenu
-          chrome={chrome}
-          onImportQgisProject={() => void projectFiles.handleImportQgisProject()}
-        />
-      )}
       {isMenuVisible(uiProfile, "edit") && (
         <EditMenu chrome={chrome} mapControllerRef={mapControllerRef} />
       )}
diff --git a/apps/geolibre-desktop/src/components/layout/toolbar/ImportMenu.tsx b/apps/geolibre-desktop/src/components/layout/toolbar/ImportMenu.tsx
deleted file mode 100644
index e4a6ed69e..000000000
--- a/apps/geolibre-desktop/src/components/layout/toolbar/ImportMenu.tsx
+++ /dev/null
@@ -1,45 +0,0 @@
-import {
-  Button,
-  DropdownMenu,
-  DropdownMenuContent,
-  DropdownMenuItem,
-  DropdownMenuLabel,
-  DropdownMenuSeparator,
-  DropdownMenuTrigger,
-} from "@geolibre/ui";
-import { FileInput, Import } from "lucide-react";
-import { useTranslation } from "react-i18next";
-import type { ToolbarChrome } from "./constants";
-
-interface ImportMenuProps {
-  chrome: ToolbarChrome;
-  onImportQgisProject: () => void;
-}
-
-/** Import workflows that translate third-party project formats into GeoLibre. */
-export function ImportMenu({ chrome, onImportQgisProject }: ImportMenuProps) {
-  const { t } = useTranslation();
-  return (
-    <DropdownMenu>
-      <DropdownMenuTrigger asChild>
-        <Button
-          className={chrome.buttonClass}
-          variant="ghost"
-          size={chrome.buttonSize}
-          aria-label={t("toolbar.menu.import")}
-        >
-          <Import className={chrome.iconClassName} />
-          {chrome.renderLabel(t("toolbar.menu.import"))}
-        </Button>
-      </DropdownMenuTrigger>
-      <DropdownMenuContent align="start" className="w-64">
-        <DropdownMenuLabel>{t("toolbar.menu.import")}</DropdownMenuLabel>
-        <DropdownMenuSeparator />
-        <DropdownMenuItem onSelect={onImportQgisProject}>
-          <FileInput className="me-2 h-3.5 w-3.5" />
-          {t("toolbar.item.importQgisProjectEllipsis")}
-        </DropdownMenuItem>
-      </DropdownMenuContent>
-    </DropdownMenu>
-  );
-}
diff --git a/apps/geolibre-desktop/src/components/layout/toolbar/ProjectMenu.tsx b/apps/geolibre-desktop/src/components/layout/toolbar/ProjectMenu.tsx
index 7b594a257..805e8f509 100644
--- a/apps/geolibre-desktop/src/components/layout/toolbar/ProjectMenu.tsx
+++ b/apps/geolibre-desktop/src/components/layout/toolbar/ProjectMenu.tsx
@@ -16,6 +16,7 @@ import {
   Bookmark,
   Copy,
   FileCode2,
+  FileInput,
   FilePen,
   FilePlus2,
   FileText,
@@ -23,6 +24,7 @@ import {
   FolderOpen,
   HardDriveDownload,
   History,
+  Import,
   LayoutGrid,
   Link2,
   Printer,
@@ -43,6 +45,7 @@ interface ProjectMenuProps {
   onOpenFromFile: () => void;
   onOpenFromUrl: () => void;
   onOpenGallery: () => void;
+  onImportQgisProject: () => void;
   onOpenRecent: (path: string) => void;
   onSave: () => void;
   onSaveAs: () => void;
@@ -63,6 +66,7 @@ export function ProjectMenu({
   onOpenFromFile,
   onOpenFromUrl,
   onOpenGallery,
+  onImportQgisProject,
   onOpenRecent,
   onSave,
   onSaveAs,
@@ -199,6 +203,20 @@ export function ProjectMenu({
             </DropdownMenuSubContent>
           </DropdownMenuSub>
         )}
+        {show("project.import") && (
+          <DropdownMenuSub>
+            <DropdownMenuSubTrigger>
+              <Import className="h-3.5 w-3.5" />
+              {t("toolbar.menu.import")}
+            </DropdownMenuSubTrigger>
+            <DropdownMenuSubContent>
+              <DropdownMenuItem onSelect={onImportQgisProject}>
+                <FileInput className="me-2 h-3.5 w-3.5" />
+                {t("toolbar.item.importQgisProjectEllipsis")}
+              </DropdownMenuItem>
+            </DropdownMenuSubContent>
+          </DropdownMenuSub>
+        )}
         {showSaveGroup && <DropdownMenuSeparator />}
         {show("project.save") && (
           <DropdownMenuItem onSelect={onSave}>
diff --git a/apps/geolibre-desktop/src/lib/ui-profile.ts b/apps/geolibre-desktop/src/lib/ui-profile.ts
index eda3805d8..74d0d9677 100644
--- a/apps/geolibre-desktop/src/lib/ui-profile.ts
+++ b/apps/geolibre-desktop/src/lib/ui-profile.ts
@@ -197,7 +197,6 @@ export const PLUGIN_TIERS: Record<string, ComplexityTier> = {
  * so the profile UI can never be locked away). */
 export type TopLevelMenuId =
   | "project"
-  | "import"
   | "edit"
   | "view"
   | "addData"
@@ -215,7 +214,6 @@ export interface TopLevelMenuEntry {
 /** Hideable top-level menus, in toolbar order. */
 export const TOP_LEVEL_MENUS: readonly TopLevelMenuEntry[] = [
   { id: "project", labelKey: "toolbar.menu.project", tier: "basic" },
-  { id: "import", labelKey: "toolbar.menu.import", tier: "basic" },
   { id: "edit", labelKey: "toolbar.menu.edit", tier: "basic" },
   { id: "view", labelKey: "toolbar.menu.view", tier: "basic" },
   { id: "addData", labelKey: "toolbar.menu.addData", tier: "basic" },
@@ -258,6 +256,12 @@ export const MENU_ITEM_CATALOG: readonly MenuItemCatalogEntry[] = [
     labelKey: "toolbar.item.openRecent",
     tier: "basic",
   },
+  {
+    id: "project.import",
+    menuId: "project",
+    labelKey: "toolbar.menu.import",
+    tier: "basic",
+  },
   { id: "project.save", menuId: "project", labelKey: "common.save", tier: "basic" },
   {
     id: "project.saveAs",

From 5b01d237052027e4fe7bebf1ade5e286d578ab25 Mon Sep 17 00:00:00 2001
From: giswqs <giswqs@gmail.com>
Date: Thu, 30 Jul 2026 22:22:52 -0400
Subject: [PATCH 04/19] fix: load remote QGIS vector sources

---
 .../src/hooks/useProjectFileActions.ts        | 10 ++-
 .../src/lib/qgis-project-import.ts            | 65 +++++++++++++++++--
 tests/qgis-project-import.test.ts             | 52 ++++++++++++---
 3 files changed, 113 insertions(+), 14 deletions(-)

diff --git a/apps/geolibre-desktop/src/hooks/useProjectFileActions.ts b/apps/geolibre-desktop/src/hooks/useProjectFileActions.ts
index 54a224c6b..af0518cbd 100644
--- a/apps/geolibre-desktop/src/hooks/useProjectFileActions.ts
+++ b/apps/geolibre-desktop/src/hooks/useProjectFileActions.ts
@@ -34,7 +34,11 @@ import { resolveShareBaseUrl } from "../lib/share-geolibre";
 import { shareAuthorizedFetch } from "../lib/share-gallery";
 import { normalizeProjectUrl } from "../lib/urls";
 import { resolveProjectXyzLayers } from "../lib/xyz-url";
-import { importQgisProject, type QgisProjectImportWarning } from "../lib/qgis-project-import";
+import {
+  importQgisProject,
+  materializeQgisRemoteLayers,
+  type QgisProjectImportWarning,
+} from "../lib/qgis-project-import";
 import type { MapControllerRef } from "../components/layout/toolbar/constants";
 
 /** A pending "strip env vars before saving?" prompt. */
@@ -161,7 +165,9 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
     const result = await openQgisProjectFile();
     if (!result) return;
     try {
-      const imported = importQgisProject(result.data, result.path);
+      const imported = await materializeQgisRemoteLayers(
+        importQgisProject(result.data, result.path),
+      );
       if (!isTauri()) {
         for (const layer of imported.project.layers) {
           if (layer.sourcePath && !isHttpUrl(layer.sourcePath)) {
diff --git a/apps/geolibre-desktop/src/lib/qgis-project-import.ts b/apps/geolibre-desktop/src/lib/qgis-project-import.ts
index 3dc8065e6..dab7b07ca 100644
--- a/apps/geolibre-desktop/src/lib/qgis-project-import.ts
+++ b/apps/geolibre-desktop/src/lib/qgis-project-import.ts
@@ -8,6 +8,7 @@ import {
   type MapViewState,
 } from "@geolibre/core";
 import { strFromU8, unzipSync } from "fflate";
+import type { FeatureCollection } from "geojson";
 
 export interface QgisProjectImportWarning {
   layerName: string;
@@ -27,6 +28,51 @@ export interface QgisProjectImportResult {
   warnings: QgisProjectImportWarning[];
 }
 
+/**
+ * Fetch remote GeoJSON sources referenced by a parsed QGIS project.
+ *
+ * QGIS commonly stores HTTP-backed OGR layers behind GDAL's `/vsicurl/`
+ * prefix. The synchronous parser normalizes that prefix to an HTTP URL; this
+ * step materializes those features before the project enters the store because
+ * GeoLibre's GeoJSON renderer consumes an in-memory FeatureCollection.
+ */
+export async function materializeQgisRemoteLayers(
+  result: QgisProjectImportResult,
+  fetcher: typeof fetch = fetch,
+): Promise<QgisProjectImportResult> {
+  const failedLayerIds = new Set<string>();
+  await Promise.all(
+    result.project.layers.map(async (layer) => {
+      const sourcePath = layer.sourcePath;
+      if (!sourcePath || !isHttpSource(sourcePath)) return;
+      try {
+        const response = await fetcher(sourcePath);
+        if (!response.ok) throw new Error(`HTTP ${response.status}`);
+        const data = (await response.json()) as unknown;
+        if (!isFeatureCollection(data))
+          throw new Error("Response is not a GeoJSON FeatureCollection");
+        layer.geojson = data;
+      } catch {
+        failedLayerIds.add(layer.id);
+        result.warnings.push({
+          layerName: layer.name,
+          reason: "remote-file",
+        });
+      }
+    }),
+  );
+  if (failedLayerIds.size > 0) {
+    result.project.layers = result.project.layers.filter((layer) => !failedLayerIds.has(layer.id));
+    const usedGroupIds = new Set(
+      result.project.layers.flatMap((layer) => (layer.groupId ? [layer.groupId] : [])),
+    );
+    result.project.layerGroups = result.project.layerGroups?.filter((group) =>
+      usedGroupIds.has(group.id),
+    );
+  }
+  return result;
+}
+
 const SUPPORTED_VECTOR_EXTENSIONS = new Set([
   "csv",
   "dxf",
@@ -91,12 +137,15 @@ export function importQgisProject(
       id: uniqueLayerId(id, layers),
       name,
       type: "geojson",
-      source: { type: "geojson" },
+      source: {
+        type: "geojson",
+        ...(isHttpSource(source) ? { url: source } : {}),
+      },
       visible: visibilityByLayerId.get(id) ?? true,
       opacity: parseOpacity(element),
       style: parseLayerStyle(element),
       metadata: {
-        localFileReloadable: true,
+        ...(!isHttpSource(source) ? { localFileReloadable: true } : {}),
         importedFrom: "qgis",
         qgisLayerId: id,
         qgisProvider: provider,
@@ -245,6 +294,7 @@ function layerOrder(document: Document, mapLayers: Element[]): string[] {
 
 function qgisVectorSource(dataSource: string, projectPath: string): string {
   let source = dataSource.split("|", 1)[0]?.trim() ?? "";
+  source = source.replace(/^\/vsicurl(?:_streaming)?\//i, "");
   if (source.startsWith("file://")) {
     try {
       source = decodeURIComponent(new URL(source).pathname);
@@ -279,7 +329,6 @@ function isSupportedVectorLayer(element: Element, provider: string, source: stri
   return (
     element.getAttribute("type")?.toLowerCase() === "vector" &&
     (provider === "ogr" || provider === "delimitedtext") &&
-    !isHttpSource(source) &&
     !isUncPath(source) &&
     SUPPORTED_VECTOR_EXTENSIONS.has(extension)
   );
@@ -297,7 +346,6 @@ function unsupportedReason(
     return "provider";
   }
   if (!source) return "missing-source";
-  if (isHttpSource(source)) return "remote-file";
   if (isUncPath(source)) return "network-path";
   return "format";
 }
@@ -400,6 +448,15 @@ function isHttpSource(path: string): boolean {
   return /^https?:\/\//i.test(path);
 }
 
+function isFeatureCollection(value: unknown): value is FeatureCollection {
+  return (
+    typeof value === "object" &&
+    value !== null &&
+    (value as { type?: unknown }).type === "FeatureCollection" &&
+    Array.isArray((value as { features?: unknown }).features)
+  );
+}
+
 function isUncPath(path: string): boolean {
   return path.startsWith("\\\\") || path.startsWith("//");
 }
diff --git a/tests/qgis-project-import.test.ts b/tests/qgis-project-import.test.ts
index 2d2f210da..4a1bea477 100644
--- a/tests/qgis-project-import.test.ts
+++ b/tests/qgis-project-import.test.ts
@@ -2,7 +2,10 @@ import assert from "node:assert/strict";
 import { describe, it } from "node:test";
 import { strToU8, zipSync } from "fflate";
 import { DOMParser } from "linkedom";
-import { importQgisProject } from "../apps/geolibre-desktop/src/lib/qgis-project-import";
+import {
+  importQgisProject,
+  materializeQgisRemoteLayers,
+} from "../apps/geolibre-desktop/src/lib/qgis-project-import";
 
 globalThis.DOMParser = DOMParser as unknown as typeof globalThis.DOMParser;
 
@@ -112,24 +115,57 @@ describe("QGIS project import", () => {
     });
   });
 
-  it("warns and omits remote and UNC file sources that cannot be restored", () => {
+  it("normalizes GDAL VSI URLs and still rejects UNC file sources", () => {
     const result = importQgisProject(
       projectXml({
         dataSources: [
-          { id: "roads", name: "Remote", source: "https://example.com/roads.geojson" },
+          {
+            id: "roads",
+            name: "Remote",
+            source: "/vsicurl/https://example.com/roads.geojson|layername=roads",
+          },
           { id: "cities", name: "Network", source: "\\\\server\\share\\cities.gpkg" },
         ],
       }),
       "C:\\projects\\example.qgs",
     );
 
-    assert.deepEqual(result.project.layers, []);
+    assert.equal(result.project.layers.length, 1);
+    assert.equal(result.project.layers[0].sourcePath, "https://example.com/roads.geojson");
+    assert.equal(result.project.layers[0].source.url, "https://example.com/roads.geojson");
+    assert.equal(result.project.layers[0].metadata.localFileReloadable, undefined);
     assert.deepEqual(
       result.warnings.map((warning) => [warning.layerName, warning.reason]),
-      [
-        ["Network", "network-path"],
-        ["Remote", "remote-file"],
-      ],
+      [["Network", "network-path"]],
+    );
+  });
+
+  it("materializes remote GeoJSON and warns when a remote response cannot be loaded", async () => {
+    const result = importQgisProject(
+      projectXml({
+        dataSources: [
+          { id: "roads", name: "Good", source: "https://example.com/good.geojson" },
+          { id: "cities", name: "Bad", source: "https://example.com/bad.geojson" },
+        ],
+      }),
+      "/work/example.qgs",
+    );
+
+    await materializeQgisRemoteLayers(result, async (input) => {
+      const url = String(input);
+      if (url.endsWith("/bad.geojson")) return new Response("no", { status: 404 });
+      return Response.json({
+        type: "FeatureCollection",
+        features: [{ type: "Feature", geometry: null, properties: { name: "Test" } }],
+      });
+    });
+
+    assert.equal(result.project.layers.length, 1);
+    assert.equal(result.project.layers[0].name, "Good");
+    assert.equal(result.project.layers[0].geojson?.features.length, 1);
+    assert.deepEqual(
+      result.warnings.map((warning) => [warning.layerName, warning.reason]),
+      [["Bad", "remote-file"]],
     );
   });
 });

From 8b7da4f654a4be91cd39d42978aec02e18044df4 Mon Sep 17 00:00:00 2001
From: giswqs <giswqs@gmail.com>
Date: Thu, 30 Jul 2026 22:38:34 -0400
Subject: [PATCH 05/19] feat: import QGIS GeoTIFF layers

---
 .../src/hooks/useProjectFileActions.ts        | 35 +++++++++++++-
 .../geolibre-desktop/src/i18n/locales/en.json |  3 +-
 .../src/lib/qgis-project-import.ts            | 48 ++++++++++++++++---
 .../plugins/src/plugins/maplibre-raster.ts    |  4 +-
 tests/qgis-project-import.test.ts             | 34 +++++++++++++
 5 files changed, 114 insertions(+), 10 deletions(-)

diff --git a/apps/geolibre-desktop/src/hooks/useProjectFileActions.ts b/apps/geolibre-desktop/src/hooks/useProjectFileActions.ts
index af0518cbd..0ff5da6b7 100644
--- a/apps/geolibre-desktop/src/hooks/useProjectFileActions.ts
+++ b/apps/geolibre-desktop/src/hooks/useProjectFileActions.ts
@@ -6,17 +6,18 @@ import {
   useAppStore,
   type GeoLibreLayer,
 } from "@geolibre/core";
-import { materializeEmbeddableVectorLayers } from "@geolibre/plugins";
+import { addRasterToMap, materializeEmbeddableVectorLayers } from "@geolibre/plugins";
 import type { FeatureCollection } from "geojson";
 import { type FormEvent, useRef, useState } from "react";
 import { useTranslation } from "react-i18next";
-import { getPluginManager } from "./usePlugins";
+import { createAppAPI, getPluginManager } from "./usePlugins";
 import { pluginManifestUrlsForIds } from "../lib/external-plugins";
 import {
   browserSaveFallsBackToDownload,
   isAbsoluteLocalPath,
   isHttpUrl,
   isTauri,
+  loadDroppedRasterPaths,
   openProjectFile,
   openQgisProjectFile,
   openRecentProjectFile,
@@ -177,8 +178,38 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
             });
           }
         }
+        for (const raster of imported.rasters) {
+          imported.warnings.push({
+            layerName: raster.name,
+            reason: "browser-local-raster",
+          });
+        }
       }
       loadProject(imported.project, null);
+      if (isTauri()) {
+        const app = createAppAPI(mapControllerRef);
+        for (const raster of imported.rasters) {
+          try {
+            const [loaded] = await loadDroppedRasterPaths([raster.sourcePath]);
+            if (!loaded) throw new Error("Unsupported raster path");
+            await addRasterToMap(app, loaded.source, {
+              name: raster.name,
+              localPath: raster.sourcePath,
+              state: {
+                visible: raster.visible,
+                opacity: raster.opacity,
+              },
+              zoomTo: false,
+            });
+          } catch (error) {
+            console.error(`Failed to import QGIS raster "${raster.name}"`, error);
+            imported.warnings.push({
+              layerName: raster.name,
+              reason: "format",
+            });
+          }
+        }
+      }
       useAppStore.setState({ isDirty: true });
       setQgisImportWarnings(imported.warnings);
     } catch (error) {
diff --git a/apps/geolibre-desktop/src/i18n/locales/en.json b/apps/geolibre-desktop/src/i18n/locales/en.json
index 246a5bbb6..4e63583ca 100644
--- a/apps/geolibre-desktop/src/i18n/locales/en.json
+++ b/apps/geolibre-desktop/src/i18n/locales/en.json
@@ -2410,7 +2410,8 @@
         "format": "The layer's file format is not supported.",
         "remote-file": "Remote QGIS file sources are not supported yet.",
         "network-path": "Network share paths are not loaded for security reasons.",
-        "browser-local-file": "The local file is referenced, but browsers cannot reopen QGIS data paths. Use GeoLibre Desktop to load it."
+        "browser-local-file": "The local file is referenced, but browsers cannot reopen QGIS data paths. Use GeoLibre Desktop to load it.",
+        "browser-local-raster": "The raster is referenced by a local path. Use GeoLibre Desktop to load it."
       },
       "openProjectFromUrlDesc": "Load a `.geolibre.json` project and add it to recent projects.",
       "projectUrl": "Project URL",
diff --git a/apps/geolibre-desktop/src/lib/qgis-project-import.ts b/apps/geolibre-desktop/src/lib/qgis-project-import.ts
index dab7b07ca..03e9c1df0 100644
--- a/apps/geolibre-desktop/src/lib/qgis-project-import.ts
+++ b/apps/geolibre-desktop/src/lib/qgis-project-import.ts
@@ -19,15 +19,25 @@ export interface QgisProjectImportWarning {
     | "format"
     | "remote-file"
     | "network-path"
-    | "browser-local-file";
+    | "browser-local-file"
+    | "browser-local-raster";
   provider?: string;
 }
 
 export interface QgisProjectImportResult {
   project: GeoLibreProject;
+  rasters: QgisRasterImport[];
   warnings: QgisProjectImportWarning[];
 }
 
+export interface QgisRasterImport {
+  id: string;
+  name: string;
+  sourcePath: string;
+  visible: boolean;
+  opacity: number;
+}
+
 /**
  * Fetch remote GeoJSON sources referenced by a parsed QGIS project.
  *
@@ -92,6 +102,7 @@ const SUPPORTED_VECTOR_EXTENSIONS = new Set([
   "tsv",
   "zip",
 ]);
+const SUPPORTED_RASTER_EXTENSIONS = new Set(["tif", "tiff"]);
 
 /** Convert a QGIS project into a GeoLibre project without evaluating QGIS code. */
 export function importQgisProject(
@@ -116,13 +127,25 @@ export function importQgisProject(
   );
   const warnings: QgisProjectImportWarning[] = [];
   const layers: GeoLibreLayer[] = [];
+  const rasters: QgisRasterImport[] = [];
 
   for (const id of layerOrder(document, mapLayers)) {
     const element = byId.get(id);
     if (!element) continue;
     const name = text(element.querySelector(":scope > layername")) || id || "QGIS layer";
     const provider = text(element.querySelector(":scope > provider")).toLowerCase();
-    const source = qgisVectorSource(text(element.querySelector(":scope > datasource")), sourcePath);
+    const source = qgisSourcePath(text(element.querySelector(":scope > datasource")), sourcePath);
+
+    if (isSupportedRasterLayer(element, provider, source)) {
+      rasters.push({
+        id,
+        name,
+        sourcePath: source,
+        visible: visibilityByLayerId.get(id) ?? true,
+        opacity: parseOpacity(element),
+      });
+      continue;
+    }
 
     if (!isSupportedVectorLayer(element, provider, source)) {
       warnings.push({
@@ -164,7 +187,7 @@ export function importQgisProject(
     qgisProjectPath: sourcePath,
     qgisVersion: document.documentElement.getAttribute("version") ?? "",
   };
-  return { project, warnings };
+  return { project, rasters, warnings };
 }
 
 function qgisProjectXml(data: ArrayBuffer | Uint8Array | string, sourcePath: string): string {
@@ -292,7 +315,7 @@ function layerOrder(document: Document, mapLayers: Element[]): string[] {
     .reverse();
 }
 
-function qgisVectorSource(dataSource: string, projectPath: string): string {
+function qgisSourcePath(dataSource: string, projectPath: string): string {
   let source = dataSource.split("|", 1)[0]?.trim() ?? "";
   source = source.replace(/^\/vsicurl(?:_streaming)?\//i, "");
   if (source.startsWith("file://")) {
@@ -308,6 +331,10 @@ function qgisVectorSource(dataSource: string, projectPath: string): string {
   return normalizeJoinedPath(directory, source);
 }
 
+function sourceExtension(source: string): string {
+  return source.split(/[?#]/, 1)[0]?.split(".").pop()?.toLowerCase() ?? "";
+}
+
 function normalizeJoinedPath(directory: string, relative: string): string {
   const separator = directory.includes("\\") ? "\\" : "/";
   const absolute = directory.startsWith("/");
@@ -325,12 +352,21 @@ function normalizeJoinedPath(directory: string, relative: string): string {
 }
 
 function isSupportedVectorLayer(element: Element, provider: string, source: string): boolean {
-  const extension = source.split(/[?#]/, 1)[0]?.split(".").pop()?.toLowerCase() ?? "";
   return (
     element.getAttribute("type")?.toLowerCase() === "vector" &&
     (provider === "ogr" || provider === "delimitedtext") &&
     !isUncPath(source) &&
-    SUPPORTED_VECTOR_EXTENSIONS.has(extension)
+    SUPPORTED_VECTOR_EXTENSIONS.has(sourceExtension(source))
+  );
+}
+
+function isSupportedRasterLayer(element: Element, provider: string, source: string): boolean {
+  return (
+    element.getAttribute("type")?.toLowerCase() === "raster" &&
+    provider === "gdal" &&
+    !isHttpSource(source) &&
+    !isUncPath(source) &&
+    SUPPORTED_RASTER_EXTENSIONS.has(sourceExtension(source))
   );
 }
 
diff --git a/packages/plugins/src/plugins/maplibre-raster.ts b/packages/plugins/src/plugins/maplibre-raster.ts
index 7877de93e..55f96caa6 100644
--- a/packages/plugins/src/plugins/maplibre-raster.ts
+++ b/packages/plugins/src/plugins/maplibre-raster.ts
@@ -333,6 +333,8 @@ export async function addRasterToMap(
     state?: Partial<RasterLayerState>;
     /** Existing map style layer beneath which the raster is inserted. */
     beforeId?: string;
+    /** Whether to fit the map to the raster after loading. Defaults to true. */
+    zoomTo?: boolean;
   } = {},
 ): Promise<string> {
   const control = await ensureRasterControl(app);
@@ -350,7 +352,7 @@ export async function addRasterToMap(
   }
   const id = await control.addRaster(source, {
     name: options.name,
-    zoomTo: true,
+    zoomTo: options.zoomTo ?? true,
     // Safe to pass before the band count is known: the renderer applies a
     // colormap only in single-band mode and ignores it otherwise.
     ...(options.state || options.defaults?.colormap
diff --git a/tests/qgis-project-import.test.ts b/tests/qgis-project-import.test.ts
index 4a1bea477..052050036 100644
--- a/tests/qgis-project-import.test.ts
+++ b/tests/qgis-project-import.test.ts
@@ -61,6 +61,23 @@ function projectXml(
   </qgis>`;
 }
 
+function rasterProjectXml(source = "../data/dem.tif"): string {
+  return `<qgis version="3.44.0">
+    <layer-tree-group>
+      <layer-tree-layer id="dem" checked="Qt::Unchecked"/>
+    </layer-tree-group>
+    <projectlayers>
+      <maplayer type="raster">
+        <id>dem</id>
+        <layername>Elevation</layername>
+        <datasource>${source}</datasource>
+        <provider>gdal</provider>
+        <layerOpacity>0.6</layerOpacity>
+      </maplayer>
+    </projectlayers>
+  </qgis>`;
+}
+
 describe("QGIS project import", () => {
   it("imports vector layers, styles, visibility, nested groups, extent, and relative paths", () => {
     const result = importQgisProject(projectXml(), "/work/projects/example.qgs");
@@ -95,6 +112,23 @@ describe("QGIS project import", () => {
     const result = importQgisProject(qgz, "/work/projects/example.qgz");
     assert.equal(result.project.name, "Imported map");
     assert.equal(result.project.layers.length, 2);
+    assert.deepEqual(result.rasters, []);
+  });
+
+  it("collects local GDAL GeoTIFFs for the desktop raster loader", () => {
+    const result = importQgisProject(rasterProjectXml(), "/work/projects/example.qgz");
+
+    assert.deepEqual(result.project.layers, []);
+    assert.deepEqual(result.rasters, [
+      {
+        id: "dem",
+        name: "Elevation",
+        sourcePath: "/work/data/dem.tif",
+        visible: false,
+        opacity: 0.6,
+      },
+    ]);
+    assert.deepEqual(result.warnings, []);
   });
 
   it("falls back to the default view for a missing or unsupported-CRS extent", () => {

From 0635120b06002c18c5c51f5ac7902ebe7a18391c Mon Sep 17 00:00:00 2001
From: giswqs <giswqs@gmail.com>
Date: Thu, 30 Jul 2026 22:49:12 -0400
Subject: [PATCH 06/19] fix: map QGIS OSM to built-in basemap

---
 .../src/lib/qgis-project-import.ts            | 28 ++++++++++++++++++-
 tests/qgis-project-import.test.ts             | 28 +++++++++++++++++++
 2 files changed, 55 insertions(+), 1 deletion(-)

diff --git a/apps/geolibre-desktop/src/lib/qgis-project-import.ts b/apps/geolibre-desktop/src/lib/qgis-project-import.ts
index 03e9c1df0..3353b71e4 100644
--- a/apps/geolibre-desktop/src/lib/qgis-project-import.ts
+++ b/apps/geolibre-desktop/src/lib/qgis-project-import.ts
@@ -1,4 +1,5 @@
 import {
+  DEFAULT_BASEMAP,
   DEFAULT_LAYER_STYLE,
   createEmptyProject,
   type GeoLibreLayer,
@@ -134,7 +135,16 @@ export function importQgisProject(
     if (!element) continue;
     const name = text(element.querySelector(":scope > layername")) || id || "QGIS layer";
     const provider = text(element.querySelector(":scope > provider")).toLowerCase();
-    const source = qgisSourcePath(text(element.querySelector(":scope > datasource")), sourcePath);
+    const dataSource = text(element.querySelector(":scope > datasource"));
+
+    if (isOpenStreetMapBasemap(element, provider, dataSource)) {
+      project.basemapStyleUrl = DEFAULT_BASEMAP;
+      project.basemapVisible = visibilityByLayerId.get(id) ?? true;
+      project.basemapOpacity = parseOpacity(element);
+      continue;
+    }
+
+    const source = qgisSourcePath(dataSource, sourcePath);
 
     if (isSupportedRasterLayer(element, provider, source)) {
       rasters.push({
@@ -370,6 +380,22 @@ function isSupportedRasterLayer(element: Element, provider: string, source: stri
   );
 }
 
+function isOpenStreetMapBasemap(element: Element, provider: string, dataSource: string): boolean {
+  if (element.getAttribute("type")?.toLowerCase() !== "raster" || provider !== "wms") {
+    return false;
+  }
+  const params = new URLSearchParams(dataSource);
+  if (params.get("type")?.toLowerCase() !== "xyz") return false;
+  const tileUrl = params.get("url");
+  if (!tileUrl) return false;
+  try {
+    const host = new URL(tileUrl).hostname.toLowerCase();
+    return host === "tile.openstreetmap.org" || /^[abc]\.tile\.openstreetmap\.org$/.test(host);
+  } catch {
+    return false;
+  }
+}
+
 function unsupportedReason(
   element: Element,
   provider: string,
diff --git a/tests/qgis-project-import.test.ts b/tests/qgis-project-import.test.ts
index 052050036..62a6e11a5 100644
--- a/tests/qgis-project-import.test.ts
+++ b/tests/qgis-project-import.test.ts
@@ -78,6 +78,23 @@ function rasterProjectXml(source = "../data/dem.tif"): string {
   </qgis>`;
 }
 
+function osmBasemapProjectXml(): string {
+  return `<qgis version="3.44.0">
+    <layer-tree-group>
+      <layer-tree-layer id="osm" checked="Qt::Unchecked"/>
+    </layer-tree-group>
+    <projectlayers>
+      <maplayer type="raster">
+        <id>osm</id>
+        <layername>OpenStreetMap</layername>
+        <datasource>crs=EPSG:3857&amp;type=xyz&amp;url=https://tile.openstreetmap.org/%7Bz%7D/%7Bx%7D/%7By%7D.png&amp;zmax=19</datasource>
+        <provider>wms</provider>
+        <layerOpacity>0.7</layerOpacity>
+      </maplayer>
+    </projectlayers>
+  </qgis>`;
+}
+
 describe("QGIS project import", () => {
   it("imports vector layers, styles, visibility, nested groups, extent, and relative paths", () => {
     const result = importQgisProject(projectXml(), "/work/projects/example.qgs");
@@ -131,6 +148,17 @@ describe("QGIS project import", () => {
     assert.deepEqual(result.warnings, []);
   });
 
+  it("maps QGIS OpenStreetMap XYZ layers to the built-in basemap", () => {
+    const result = importQgisProject(osmBasemapProjectXml(), "/work/example.qgs");
+
+    assert.equal(result.project.basemapStyleUrl, "https://tiles.openfreemap.org/styles/liberty");
+    assert.equal(result.project.basemapVisible, false);
+    assert.equal(result.project.basemapOpacity, 0.7);
+    assert.deepEqual(result.project.layers, []);
+    assert.deepEqual(result.rasters, []);
+    assert.deepEqual(result.warnings, []);
+  });
+
   it("falls back to the default view for a missing or unsupported-CRS extent", () => {
     const missing = importQgisProject(projectXml({ extent: "" }), "/work/example.qgs");
     assert.deepEqual(missing.project.mapView, {

From efed7612a82124979deda4ab1c8ed79900e13ac7 Mon Sep 17 00:00:00 2001
From: giswqs <giswqs@gmail.com>
Date: Thu, 30 Jul 2026 22:57:18 -0400
Subject: [PATCH 07/19] fix: authorize imported QGIS rasters

---
 apps/geolibre-desktop/src-tauri/src/lib.rs    | 24 +++++++++++----
 .../layout/toolbar/ProjectFileDialogs.tsx     | 30 ++++++++-----------
 .../src/hooks/useProjectFileActions.ts        |  6 ++--
 .../geolibre-desktop/src/i18n/locales/en.json |  1 -
 apps/geolibre-desktop/src/lib/tauri-io.ts     | 14 +++++++--
 5 files changed, 47 insertions(+), 28 deletions(-)

diff --git a/apps/geolibre-desktop/src-tauri/src/lib.rs b/apps/geolibre-desktop/src-tauri/src/lib.rs
index 709db49b9..d0b70d1aa 100644
--- a/apps/geolibre-desktop/src-tauri/src/lib.rs
+++ b/apps/geolibre-desktop/src-tauri/src/lib.rs
@@ -397,20 +397,32 @@ fn read_local_file(path: String) -> Result<tauri::ipc::Response, String> {
         .map_err(|error| format!("Could not read local file: {error}"))
 }
 
-/// Add one user-selected GeoTIFF to the asset-protocol scope. The filesystem
-/// and asset scopes are separate in Tauri; dialogs and native drops grant the
-/// former, but maplibre-gl-raster fetches through the latter for range reads.
+/// Add one GeoTIFF to the asset-protocol scope. The filesystem and asset scopes
+/// are separate in Tauri; dialogs and native drops grant the former, but
+/// maplibre-gl-raster fetches through the latter for range reads. A GeoTIFF
+/// referenced by an imported QGIS project is also accepted when that project
+/// file itself was explicitly selected by the user.
 #[tauri::command]
-fn allow_raster_asset(app: tauri::AppHandle, path: String) -> Result<(), String> {
+fn allow_raster_asset(
+    app: tauri::AppHandle,
+    path: String,
+    qgis_project_path: Option<String>,
+) -> Result<(), String> {
     let lower = path.to_ascii_lowercase();
     if !is_safe_absolute_path(&path) || !(lower.ends_with(".tif") || lower.ends_with(".tiff")) {
         return Err(format!(
             "Refusing to expose \"{path}\": not an absolute GeoTIFF path"
         ));
     }
-    if !app.fs_scope().is_allowed(&path) {
+    let selected_qgis_project = qgis_project_path.is_some_and(|project_path| {
+        let lower = project_path.to_ascii_lowercase();
+        is_safe_absolute_path(&project_path)
+            && (lower.ends_with(".qgs") || lower.ends_with(".qgz"))
+            && app.fs_scope().is_allowed(&project_path)
+    });
+    if !app.fs_scope().is_allowed(&path) && !selected_qgis_project {
         return Err(format!(
-            "Refusing to expose \"{path}\": the file was not selected or dropped by the user"
+            "Refusing to expose \"{path}\": neither the file nor its QGIS project was selected by the user"
         ));
     }
     app.asset_protocol_scope()
diff --git a/apps/geolibre-desktop/src/components/layout/toolbar/ProjectFileDialogs.tsx b/apps/geolibre-desktop/src/components/layout/toolbar/ProjectFileDialogs.tsx
index abde58b05..69047e848 100644
--- a/apps/geolibre-desktop/src/components/layout/toolbar/ProjectFileDialogs.tsx
+++ b/apps/geolibre-desktop/src/components/layout/toolbar/ProjectFileDialogs.tsx
@@ -104,25 +104,21 @@ export function ProjectFileDialogs({ projectFiles }: ProjectFileDialogsProps) {
           <DialogHeader>
             <DialogTitle>{t("toolbar.item.qgisImportComplete")}</DialogTitle>
             <DialogDescription>
-              {projectFiles.qgisImportWarnings?.length
-                ? t("toolbar.item.qgisImportWarnings", {
-                    count: projectFiles.qgisImportWarnings.length,
-                  })
-                : t("toolbar.item.qgisImportSuccess")}
+              {t("toolbar.item.qgisImportWarnings", {
+                count: projectFiles.qgisImportWarnings?.length ?? 0,
+              })}
             </DialogDescription>
           </DialogHeader>
-          {projectFiles.qgisImportWarnings?.length ? (
-            <ul className="max-h-64 space-y-2 overflow-y-auto text-sm">
-              {projectFiles.qgisImportWarnings.map((warning, index) => (
-                <li key={`${warning.layerName}-${index}`}>
-                  <strong>{warning.layerName}:</strong>{" "}
-                  {t(`toolbar.item.qgisImportReason.${warning.reason}`, {
-                    provider: warning.provider || t("toolbar.item.qgisUnknownProvider"),
-                  })}
-                </li>
-              ))}
-            </ul>
-          ) : null}
+          <ul className="max-h-64 space-y-2 overflow-y-auto text-sm">
+            {projectFiles.qgisImportWarnings?.map((warning, index) => (
+              <li key={`${warning.layerName}-${index}`}>
+                <strong>{warning.layerName}:</strong>{" "}
+                {t(`toolbar.item.qgisImportReason.${warning.reason}`, {
+                  provider: warning.provider || t("toolbar.item.qgisUnknownProvider"),
+                })}
+              </li>
+            ))}
+          </ul>
           <div className="flex justify-end">
             <Button onClick={() => projectFiles.setQgisImportWarnings(null)}>
               {t("common.ok")}
diff --git a/apps/geolibre-desktop/src/hooks/useProjectFileActions.ts b/apps/geolibre-desktop/src/hooks/useProjectFileActions.ts
index 0ff5da6b7..21f465392 100644
--- a/apps/geolibre-desktop/src/hooks/useProjectFileActions.ts
+++ b/apps/geolibre-desktop/src/hooks/useProjectFileActions.ts
@@ -190,7 +190,9 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
         const app = createAppAPI(mapControllerRef);
         for (const raster of imported.rasters) {
           try {
-            const [loaded] = await loadDroppedRasterPaths([raster.sourcePath]);
+            const [loaded] = await loadDroppedRasterPaths([raster.sourcePath], {
+              qgisProjectPath: result.path,
+            });
             if (!loaded) throw new Error("Unsupported raster path");
             await addRasterToMap(app, loaded.source, {
               name: raster.name,
@@ -211,7 +213,7 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
         }
       }
       useAppStore.setState({ isDirty: true });
-      setQgisImportWarnings(imported.warnings);
+      setQgisImportWarnings(imported.warnings.length > 0 ? imported.warnings : null);
     } catch (error) {
       console.error("Failed to import QGIS project", error);
       setActionError(
diff --git a/apps/geolibre-desktop/src/i18n/locales/en.json b/apps/geolibre-desktop/src/i18n/locales/en.json
index 4e63583ca..6eb6cbf94 100644
--- a/apps/geolibre-desktop/src/i18n/locales/en.json
+++ b/apps/geolibre-desktop/src/i18n/locales/en.json
@@ -2399,7 +2399,6 @@
       "openProjectFromUrl": "Open project from URL",
       "importQgisProjectEllipsis": "Import QGIS Project…",
       "qgisImportComplete": "QGIS project imported",
-      "qgisImportSuccess": "All supported project content was imported.",
       "qgisImportWarnings_one": "The project was imported, but {{count}} layer could not be loaded.",
       "qgisImportWarnings_other": "The project was imported, but {{count}} layers could not be loaded.",
       "qgisUnknownProvider": "unknown",
diff --git a/apps/geolibre-desktop/src/lib/tauri-io.ts b/apps/geolibre-desktop/src/lib/tauri-io.ts
index fe35078da..15ced90d6 100644
--- a/apps/geolibre-desktop/src/lib/tauri-io.ts
+++ b/apps/geolibre-desktop/src/lib/tauri-io.ts
@@ -2450,9 +2450,19 @@ export function loadDroppedRasterFiles(droppedFiles: FileList | File[]): Dropped
  * these with byte-range support, so a COG opens lazily instead of copying the
  * entire file over IPC and then copying it again into a browser File.
  */
-export async function loadDroppedRasterPaths(paths: string[]): Promise<DroppedRaster[]> {
+export async function loadDroppedRasterPaths(
+  paths: string[],
+  options?: { qgisProjectPath?: string },
+): Promise<DroppedRaster[]> {
   const rasterPaths = paths.filter(isRasterFileName);
-  await Promise.all(rasterPaths.map((path) => invoke("allow_raster_asset", { path })));
+  await Promise.all(
+    rasterPaths.map((path) =>
+      invoke("allow_raster_asset", {
+        path,
+        ...(options?.qgisProjectPath ? { qgisProjectPath: options.qgisProjectPath } : {}),
+      }),
+    ),
+  );
   return rasterPaths.map((path) => ({
     name: fileBaseName(path),
     source: convertFileSrc(path),

From 21e9258ae8a74c702c4bcca4a9ce64d62aae8869 Mon Sep 17 00:00:00 2001
From: giswqs <giswqs@gmail.com>
Date: Thu, 30 Jul 2026 23:09:06 -0400
Subject: [PATCH 08/19] fix(qgis): add imported rasters after project map
 settles

---
 .../src/hooks/useProjectFileActions.ts        | 24 +++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/apps/geolibre-desktop/src/hooks/useProjectFileActions.ts b/apps/geolibre-desktop/src/hooks/useProjectFileActions.ts
index 21f465392..6f1d3d757 100644
--- a/apps/geolibre-desktop/src/hooks/useProjectFileActions.ts
+++ b/apps/geolibre-desktop/src/hooks/useProjectFileActions.ts
@@ -106,6 +106,29 @@ function isReloadableLocalFileLayer(layer: GeoLibreLayer): boolean {
   );
 }
 
+/**
+ * Let React commit a newly loaded project before a plugin attaches native map
+ * sources. A project load can replace the MapLibre style (and always schedules
+ * a layer sync); adding a raster in the same tick can therefore attach it to
+ * the outgoing style. Its store entry survives, but the native raster source
+ * is removed by the pending style/layer update.
+ */
+async function waitForImportedProjectMap(mapControllerRef: MapControllerRef): Promise<void> {
+  await new Promise<void>((resolve) => requestAnimationFrame(() => resolve()));
+  await new Promise<void>((resolve) => requestAnimationFrame(() => resolve()));
+
+  const map = mapControllerRef.current?.getMap();
+  if (!map || map.isStyleLoaded()) return;
+
+  await new Promise<void>((resolve) => {
+    const timeout = window.setTimeout(resolve, 10_000);
+    map.once("style.load", () => {
+      window.clearTimeout(timeout);
+      resolve();
+    });
+  });
+}
+
 /**
  * Bundles every project file action (open from file/URL/recent, save, save as)
  * along with the related dialog state (Open-from-URL, env-var strip prompt, and
@@ -187,6 +210,7 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
       }
       loadProject(imported.project, null);
       if (isTauri()) {
+        await waitForImportedProjectMap(mapControllerRef);
         const app = createAppAPI(mapControllerRef);
         for (const raster of imported.rasters) {
           try {

From 46a56ddb10592a6c097de84bb9acff5733afd0aa Mon Sep 17 00:00:00 2001
From: giswqs <giswqs@gmail.com>
Date: Thu, 30 Jul 2026 23:36:12 -0400
Subject: [PATCH 09/19] fix(qgis): preserve raster color ramps without import
 delay

---
 .../src/hooks/useProjectFileActions.ts        | 190 ++++++++----
 .../src/lib/qgis-project-import.ts            | 287 ++++++++++++++----
 tests/qgis-project-import.test.ts             | 124 ++++++--
 3 files changed, 459 insertions(+), 142 deletions(-)

diff --git a/apps/geolibre-desktop/src/hooks/useProjectFileActions.ts b/apps/geolibre-desktop/src/hooks/useProjectFileActions.ts
index 6f1d3d757..cd83f0844 100644
--- a/apps/geolibre-desktop/src/hooks/useProjectFileActions.ts
+++ b/apps/geolibre-desktop/src/hooks/useProjectFileActions.ts
@@ -6,7 +6,10 @@ import {
   useAppStore,
   type GeoLibreLayer,
 } from "@geolibre/core";
-import { addRasterToMap, materializeEmbeddableVectorLayers } from "@geolibre/plugins";
+import {
+  addRasterToMap,
+  materializeEmbeddableVectorLayers,
+} from "@geolibre/plugins";
 import type { FeatureCollection } from "geojson";
 import { type FormEvent, useRef, useState } from "react";
 import { useTranslation } from "react-i18next";
@@ -113,20 +116,9 @@ function isReloadableLocalFileLayer(layer: GeoLibreLayer): boolean {
  * the outgoing style. Its store entry survives, but the native raster source
  * is removed by the pending style/layer update.
  */
-async function waitForImportedProjectMap(mapControllerRef: MapControllerRef): Promise<void> {
+async function waitForImportedProjectMap(): Promise<void> {
   await new Promise<void>((resolve) => requestAnimationFrame(() => resolve()));
   await new Promise<void>((resolve) => requestAnimationFrame(() => resolve()));
-
-  const map = mapControllerRef.current?.getMap();
-  if (!map || map.isStyleLoaded()) return;
-
-  await new Promise<void>((resolve) => {
-    const timeout = window.setTimeout(resolve, 10_000);
-    map.once("style.load", () => {
-      window.clearTimeout(timeout);
-      resolve();
-    });
-  });
 }
 
 /**
@@ -146,18 +138,21 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
   const markSaved = useAppStore((s) => s.markSaved);
 
   const [actionError, setActionError] = useState<string | null>(null);
-  const [qgisImportWarnings, setQgisImportWarnings] = useState<QgisProjectImportWarning[] | null>(
-    null,
-  );
+  const [qgisImportWarnings, setQgisImportWarnings] = useState<
+    QgisProjectImportWarning[] | null
+  >(null);
   const [projectUrlDialogOpen, setProjectUrlDialogOpen] = useState(false);
   const [projectUrl, setProjectUrl] = useState("");
   const [projectUrlError, setProjectUrlError] = useState<string | null>(null);
   const [projectUrlLoading, setProjectUrlLoading] = useState(false);
-  const [envStripPrompt, setEnvStripPrompt] = useState<EnvStripPrompt | null>(null);
-  const [embedVectorDataPrompt, setEmbedVectorDataPrompt] = useState<EmbedVectorDataPrompt | null>(
-    null,
+  const [envStripPrompt, setEnvStripPrompt] = useState<EnvStripPrompt | null>(
+    null
+  );
+  const [embedVectorDataPrompt, setEmbedVectorDataPrompt] =
+    useState<EmbedVectorDataPrompt | null>(null);
+  const [saveNamePrompt, setSaveNamePrompt] = useState<SaveNamePrompt | null>(
+    null
   );
-  const [saveNamePrompt, setSaveNamePrompt] = useState<SaveNamePrompt | null>(null);
   const [saveNameInput, setSaveNameInput] = useState("");
   const projectUrlAbortRef = useRef<AbortController | null>(null);
   const recentAbortRef = useRef<AbortController | null>(null);
@@ -173,13 +168,19 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
     const result = await openProjectFile();
     if (result) {
       try {
-        loadProject(await resolveProjectXyzLayers(result.project), result.path, {
-          rememberRecent: isTauri(),
-        });
+        loadProject(
+          await resolveProjectXyzLayers(result.project),
+          result.path,
+          {
+            rememberRecent: isTauri(),
+          }
+        );
       } catch (error) {
         console.error("Failed to open project", error);
         setActionError(
-          error instanceof Error ? error.message : t("toolbar.error.couldNotOpenProject"),
+          error instanceof Error
+            ? error.message
+            : t("toolbar.error.couldNotOpenProject")
         );
       }
     }
@@ -190,7 +191,7 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
     if (!result) return;
     try {
       const imported = await materializeQgisRemoteLayers(
-        importQgisProject(result.data, result.path),
+        importQgisProject(result.data, result.path)
       );
       if (!isTauri()) {
         for (const layer of imported.project.layers) {
@@ -210,7 +211,7 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
       }
       loadProject(imported.project, null);
       if (isTauri()) {
-        await waitForImportedProjectMap(mapControllerRef);
+        await waitForImportedProjectMap();
         const app = createAppAPI(mapControllerRef);
         for (const raster of imported.rasters) {
           try {
@@ -222,13 +223,17 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
               name: raster.name,
               localPath: raster.sourcePath,
               state: {
+                ...raster.state,
                 visible: raster.visible,
                 opacity: raster.opacity,
               },
               zoomTo: false,
             });
           } catch (error) {
-            console.error(`Failed to import QGIS raster "${raster.name}"`, error);
+            console.error(
+              `Failed to import QGIS raster "${raster.name}"`,
+              error
+            );
             imported.warnings.push({
               layerName: raster.name,
               reason: "format",
@@ -237,11 +242,15 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
         }
       }
       useAppStore.setState({ isDirty: true });
-      setQgisImportWarnings(imported.warnings.length > 0 ? imported.warnings : null);
+      setQgisImportWarnings(
+        imported.warnings.length > 0 ? imported.warnings : null
+      );
     } catch (error) {
       console.error("Failed to import QGIS project", error);
       setActionError(
-        error instanceof Error ? error.message : t("toolbar.error.couldNotImportQgisProject"),
+        error instanceof Error
+          ? error.message
+          : t("toolbar.error.couldNotImportQgisProject")
       );
     }
   };
@@ -262,8 +271,14 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
     setProjectUrlError(null);
 
     try {
-      const result = await openRecentProjectFile(normalizedUrl, controller.signal);
-      const project = await resolveProjectXyzLayers(result.project, controller.signal);
+      const result = await openRecentProjectFile(
+        normalizedUrl,
+        controller.signal
+      );
+      const project = await resolveProjectXyzLayers(
+        result.project,
+        controller.signal
+      );
       if (controller.signal.aborted) return;
       loadProject(project, result.path);
       setProjectUrl("");
@@ -272,7 +287,9 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
       if (controller.signal.aborted) return;
       console.error("Failed to open project URL", error);
       setProjectUrlError(
-        error instanceof Error ? error.message : t("toolbar.error.couldNotOpenProjectUrl"),
+        error instanceof Error
+          ? error.message
+          : t("toolbar.error.couldNotOpenProjectUrl")
       );
     } finally {
       if (projectUrlAbortRef.current === controller) {
@@ -299,7 +316,7 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
 
   const openProjectFromShareUrl = async (
     url: string,
-    options: { authToken?: string; asCopy?: boolean } = {},
+    options: { authToken?: string; asCopy?: boolean } = {}
   ): Promise<void> => {
     const normalizedUrl = normalizeProjectUrl(url);
     if (!normalizedUrl) {
@@ -318,13 +335,19 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
           fetchImpl: shareAuthorizedFetch(
             options.authToken,
             resolveShareBaseUrl(),
-            getShareFetch(),
+            getShareFetch()
           ),
         });
         project = await resolveProjectXyzLayers(fetched, controller.signal);
       } else {
-        const result = await openRecentProjectFile(normalizedUrl, controller.signal);
-        project = await resolveProjectXyzLayers(result.project, controller.signal);
+        const result = await openRecentProjectFile(
+          normalizedUrl,
+          controller.signal
+        );
+        project = await resolveProjectXyzLayers(
+          result.project,
+          controller.signal
+        );
       }
 
       if (controller.signal.aborted) return;
@@ -366,18 +389,25 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
         forgetRecentProject(path);
       }
       console.error("Failed to open recent project", error);
-      return error instanceof Error ? error.message : t("toolbar.error.couldNotOpenRecentProject");
+      return error instanceof Error
+        ? error.message
+        : t("toolbar.error.couldNotOpenRecentProject");
     }
 
     try {
-      const project = await resolveProjectXyzLayers(result.project, controller.signal);
+      const project = await resolveProjectXyzLayers(
+        result.project,
+        controller.signal
+      );
       if (controller.signal.aborted) return null;
       loadProject(project, result.path);
       return null;
     } catch (error) {
       if (controller.signal.aborted) return null;
       console.error("Failed to load recent project", error);
-      return error instanceof Error ? error.message : t("toolbar.error.couldNotLoadRecentProject");
+      return error instanceof Error
+        ? error.message
+        : t("toolbar.error.couldNotLoadRecentProject");
     } finally {
       if (recentAbortRef.current === controller) {
         recentAbortRef.current = null;
@@ -388,7 +418,10 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
   // Build the current project from live store + map state and serialize it.
   // Shared by Save/Save As and the Share action so they all capture identical
   // project content (including the current map view and plugin state).
-  const buildCurrentProject = (nameOverride?: string, layersOverride?: GeoLibreLayer[]) => {
+  const buildCurrentProject = (
+    nameOverride?: string,
+    layersOverride?: GeoLibreLayer[]
+  ) => {
     const state = useAppStore.getState();
     const defaultProjectName =
       nameOverride?.trim() || state.projectName.trim() || DEFAULT_PROJECT_NAME;
@@ -411,7 +444,7 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
     ]);
     const pluginManifestUrls = mergeStringLists(
       state.projectPlugins?.manifestUrls ?? [],
-      pluginManifestUrlsForIds(usedPluginIds),
+      pluginManifestUrlsForIds(usedPluginIds)
     );
     const project = projectFromStore({
       projectName: defaultProjectName,
@@ -469,7 +502,9 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
       setEmbedVectorDataPrompt({ count, bytes, desktop, resolve });
     });
 
-  const resolveEmbedVectorDataPrompt = (choice: "embed" | "noembed" | "cancel") => {
+  const resolveEmbedVectorDataPrompt = (
+    choice: "embed" | "noembed" | "cancel"
+  ) => {
     embedVectorDataPrompt?.resolve(choice);
     setEmbedVectorDataPrompt(null);
   };
@@ -483,16 +518,20 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
   // restores. Used by the save dialog's Embed choice and by Share (always).
   const buildEmbeddedLayers = async (
     layers: GeoLibreLayer[],
-    prebuilt?: Map<string, FeatureCollection>,
+    prebuilt?: Map<string, FeatureCollection>
   ): Promise<GeoLibreLayer[]> => {
     // Reuse a map the caller already materialized (the Embed save path) so each
     // layer's features aren't read from the control twice, but materialize any
     // layer it doesn't cover — e.g. one added while the save dialog was open —
     // so a late addition still gets its data instead of being dropped.
     const embeddable = new Map(prebuilt);
-    const uncovered = prebuilt ? layers.filter((layer) => !prebuilt.has(layer.id)) : layers;
+    const uncovered = prebuilt
+      ? layers.filter((layer) => !prebuilt.has(layer.id))
+      : layers;
     if (uncovered.length > 0) {
-      for (const [id, collection] of await materializeEmbeddableVectorLayers(uncovered)) {
+      for (const [id, collection] of await materializeEmbeddableVectorLayers(
+        uncovered
+      )) {
         embeddable.set(id, collection);
       }
     }
@@ -513,7 +552,7 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
   // GeoJSON layers use their `geojson`.
   const estimateEmbedBytes = (
     layers: GeoLibreLayer[],
-    embeddable: Map<string, FeatureCollection>,
+    embeddable: Map<string, FeatureCollection>
   ): number => {
     const encoder = new TextEncoder();
     let bytes = 0;
@@ -534,10 +573,14 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
   // reload from disk on reopen, so the prompt offers Embed or Save file
   // references. Returns the layers override to serialize, an empty result to use
   // the live layers as-is, or "cancel" to abort the save.
-  const resolveLayersForSave = async (): Promise<{ layers?: GeoLibreLayer[] } | "cancel"> => {
+  const resolveLayersForSave = async (): Promise<
+    { layers?: GeoLibreLayer[] } | "cancel"
+  > => {
     const state = useAppStore.getState();
     const embeddable = await materializeEmbeddableVectorLayers(state.layers);
-    const localFileLayers = isTauri() ? state.layers.filter(isReloadableLocalFileLayer) : [];
+    const localFileLayers = isTauri()
+      ? state.layers.filter(isReloadableLocalFileLayer)
+      : [];
     if (embeddable.size === 0 && localFileLayers.length === 0) return {};
 
     const count = embeddable.size + localFileLayers.length;
@@ -548,7 +591,10 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
     if (choice === "embed") {
       // Reuse the map already materialized for the size estimate.
       return {
-        layers: await buildEmbeddedLayers(useAppStore.getState().layers, embeddable),
+        layers: await buildEmbeddedLayers(
+          useAppStore.getState().layers,
+          embeddable
+        ),
       };
     }
 
@@ -597,7 +643,10 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
   // the user can control. The caller supplies the dialog copy so the same prompt
   // serves both project saves and HTML exports. Resolves with the name, or null
   // if cancelled.
-  const askSaveName = (defaultName: string, labels: Omit<SaveNamePrompt, "resolve">) =>
+  const askSaveName = (
+    defaultName: string,
+    labels: Omit<SaveNamePrompt, "resolve">
+  ) =>
     new Promise<string | null>((resolve) => {
       setSaveNameInput(defaultName);
       setSaveNamePrompt({ resolve, ...labels });
@@ -616,20 +665,20 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
     setSaveNameInput("");
   };
 
-  const runSaveProject = async (options?: { saveAs?: boolean }): Promise<boolean> => {
+  const runSaveProject = async (options?: {
+    saveAs?: boolean;
+  }): Promise<boolean> => {
     // Offer to embed local vector data (or, on desktop, save file references)
     // first, so the serialized content below reflects the user's choice.
     const layersForSave = await resolveLayersForSave();
     if (layersForSave === "cancel") return false;
-    const { project, defaultProjectName, content, projectPath } = buildCurrentProject(
-      undefined,
-      layersForSave.layers,
-    );
+    const { project, defaultProjectName, content, projectPath } =
+      buildCurrentProject(undefined, layersForSave.layers);
     // Env vars (possibly API keys) are serialized in plain text. If any are set,
     // offer to strip them from the saved file before writing.
     let contentToSave = content;
-    const envVarCount = (project.preferences.environmentVariables ?? []).filter((variable) =>
-      variable.key.trim(),
+    const envVarCount = (project.preferences.environmentVariables ?? []).filter(
+      (variable) => variable.key.trim()
     ).length;
     if (envVarCount > 0) {
       const choice = await askStripEnvVars(envVarCount);
@@ -643,14 +692,16 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
     }
     // Projects opened from a URL have no writable path, so both Save and
     // Save As fall back to the save dialog for them.
-    const existingLocalPath = projectPath && !isHttpUrl(projectPath) ? projectPath : null;
+    const existingLocalPath =
+      projectPath && !isHttpUrl(projectPath) ? projectPath : null;
     // Browsers without the File System Access picker (Firefox, Safari) can only
     // download under a fixed name, so Save As (and a first Save) would otherwise
     // reuse a default name — exactly the bug users hit. Prompt for the name so
     // they can choose it; later in-place Saves reuse the chosen name silently.
     let saveName = `${defaultProjectName}.geolibre.json`;
     const promptForName =
-      browserSaveFallsBackToDownload() && (options?.saveAs === true || !existingLocalPath);
+      browserSaveFallsBackToDownload() &&
+      (options?.saveAs === true || !existingLocalPath);
     if (promptForName) {
       const chosen = await askSaveName(saveName, {
         title: t("toolbar.item.saveProjectAsTitle"),
@@ -668,12 +719,14 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
           ? await saveProjectFileToPath(contentToSave, existingLocalPath)
           : await saveProjectFile(
               contentToSave,
-              promptForName ? saveName : (existingLocalPath ?? saveName),
+              promptForName ? saveName : existingLocalPath ?? saveName
             );
     } catch (error) {
       console.error("Failed to save project", error);
       setActionError(
-        error instanceof Error ? error.message : t("toolbar.error.couldNotSaveProject"),
+        error instanceof Error
+          ? error.message
+          : t("toolbar.error.couldNotSaveProject")
       );
       return false;
     }
@@ -689,7 +742,9 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
   };
 
   // Serialize saves so overlapping invocations cannot clobber a pending prompt.
-  const saveProject = async (options?: { saveAs?: boolean }): Promise<boolean> => {
+  const saveProject = async (options?: {
+    saveAs?: boolean;
+  }): Promise<boolean> => {
     if (isSavingRef.current) return false;
     isSavingRef.current = true;
     try {
@@ -714,7 +769,8 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
       // buildEmbeddedProject as the name override below, so the file-name slug
       // and the HTML title stay consistent even if the project is renamed while
       // the name prompt is open.
-      const projectName = useAppStore.getState().projectName.trim() || DEFAULT_PROJECT_NAME;
+      const projectName =
+        useAppStore.getState().projectName.trim() || DEFAULT_PROJECT_NAME;
       const slug =
         projectName
           .toLowerCase()
@@ -741,7 +797,9 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
       // costly on a project with many local layers, so it runs after the user
       // has committed to the export rather than before the prompt. Reuse the
       // name snapshot so the title matches the slug computed above.
-      const { project, defaultProjectName } = await buildEmbeddedProject(projectName);
+      const { project, defaultProjectName } = await buildEmbeddedProject(
+        projectName
+      );
       const safeProject = {
         ...project,
         preferences: { ...project.preferences, environmentVariables: [] },
@@ -766,7 +824,9 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
       return savedPath !== null;
     } catch (error) {
       setActionError(
-        error instanceof Error ? error.message : t("toolbar.error.couldNotExportHtml"),
+        error instanceof Error
+          ? error.message
+          : t("toolbar.error.couldNotExportHtml")
       );
       return false;
     } finally {
diff --git a/apps/geolibre-desktop/src/lib/qgis-project-import.ts b/apps/geolibre-desktop/src/lib/qgis-project-import.ts
index 3353b71e4..0882bf7a1 100644
--- a/apps/geolibre-desktop/src/lib/qgis-project-import.ts
+++ b/apps/geolibre-desktop/src/lib/qgis-project-import.ts
@@ -1,6 +1,7 @@
 import {
   DEFAULT_BASEMAP,
   DEFAULT_LAYER_STYLE,
+  VECTOR_COLOR_RAMPS,
   createEmptyProject,
   type GeoLibreLayer,
   type GeoLibreProject,
@@ -37,6 +38,13 @@ export interface QgisRasterImport {
   sourcePath: string;
   visible: boolean;
   opacity: number;
+  state?: {
+    bands: number[];
+    colormap: string;
+    gamma: number;
+    rescale: [number, number][] | null;
+    reversed: boolean;
+  };
 }
 
 /**
@@ -49,7 +57,7 @@ export interface QgisRasterImport {
  */
 export async function materializeQgisRemoteLayers(
   result: QgisProjectImportResult,
-  fetcher: typeof fetch = fetch,
+  fetcher: typeof fetch = fetch
 ): Promise<QgisProjectImportResult> {
   const failedLayerIds = new Set<string>();
   await Promise.all(
@@ -70,15 +78,19 @@ export async function materializeQgisRemoteLayers(
           reason: "remote-file",
         });
       }
-    }),
+    })
   );
   if (failedLayerIds.size > 0) {
-    result.project.layers = result.project.layers.filter((layer) => !failedLayerIds.has(layer.id));
+    result.project.layers = result.project.layers.filter(
+      (layer) => !failedLayerIds.has(layer.id)
+    );
     const usedGroupIds = new Set(
-      result.project.layers.flatMap((layer) => (layer.groupId ? [layer.groupId] : [])),
+      result.project.layers.flatMap((layer) =>
+        layer.groupId ? [layer.groupId] : []
+      )
     );
     result.project.layerGroups = result.project.layerGroups?.filter((group) =>
-      usedGroupIds.has(group.id),
+      usedGroupIds.has(group.id)
     );
   }
   return result;
@@ -108,23 +120,35 @@ const SUPPORTED_RASTER_EXTENSIONS = new Set(["tif", "tiff"]);
 /** Convert a QGIS project into a GeoLibre project without evaluating QGIS code. */
 export function importQgisProject(
   data: ArrayBuffer | Uint8Array | string,
-  sourcePath: string,
+  sourcePath: string
 ): QgisProjectImportResult {
   const xml = qgisProjectXml(data, sourcePath);
   const document = new DOMParser().parseFromString(xml, "application/xml");
-  if (document.querySelector("parsererror") || document.documentElement.tagName !== "qgis") {
+  if (
+    document.querySelector("parsererror") ||
+    document.documentElement.tagName !== "qgis"
+  ) {
     throw new Error("This file is not a valid QGIS project.");
   }
 
   const projectName =
-    text(document.querySelector("title")) || fileStem(sourcePath) || "Imported QGIS Project";
-  const project = createEmptyProject(projectName, { mapView: parseMapView(document) });
+    text(document.querySelector("title")) ||
+    fileStem(sourcePath) ||
+    "Imported QGIS Project";
+  const project = createEmptyProject(projectName, {
+    mapView: parseMapView(document),
+  });
   const parsedGroups = parseLayerGroups(document);
   const groupByLayerId = layerGroupAssignments(document, parsedGroups.ids);
   const visibilityByLayerId = layerVisibility(document);
-  const mapLayers = Array.from(document.querySelectorAll("projectlayers > maplayer"));
+  const mapLayers = Array.from(
+    document.querySelectorAll("projectlayers > maplayer")
+  );
   const byId = new Map(
-    mapLayers.map((element) => [text(element.querySelector(":scope > id")), element]),
+    mapLayers.map((element) => [
+      text(element.querySelector(":scope > id")),
+      element,
+    ])
   );
   const warnings: QgisProjectImportWarning[] = [];
   const layers: GeoLibreLayer[] = [];
@@ -133,8 +157,11 @@ export function importQgisProject(
   for (const id of layerOrder(document, mapLayers)) {
     const element = byId.get(id);
     if (!element) continue;
-    const name = text(element.querySelector(":scope > layername")) || id || "QGIS layer";
-    const provider = text(element.querySelector(":scope > provider")).toLowerCase();
+    const name =
+      text(element.querySelector(":scope > layername")) || id || "QGIS layer";
+    const provider = text(
+      element.querySelector(":scope > provider")
+    ).toLowerCase();
     const dataSource = text(element.querySelector(":scope > datasource"));
 
     if (isOpenStreetMapBasemap(element, provider, dataSource)) {
@@ -147,12 +174,14 @@ export function importQgisProject(
     const source = qgisSourcePath(dataSource, sourcePath);
 
     if (isSupportedRasterLayer(element, provider, source)) {
+      const state = parseRasterState(element);
       rasters.push({
         id,
         name,
         sourcePath: source,
         visible: visibilityByLayerId.get(id) ?? true,
         opacity: parseOpacity(element),
+        ...(state ? { state } : {}),
       });
       continue;
     }
@@ -190,7 +219,7 @@ export function importQgisProject(
 
   project.layers = layers;
   project.layerGroups = parsedGroups.groups.filter((group) =>
-    layers.some((layer) => layer.groupId === group.id),
+    layers.some((layer) => layer.groupId === group.id)
   );
   project.metadata = {
     importedFrom: "qgis",
@@ -200,7 +229,99 @@ export function importQgisProject(
   return { project, rasters, warnings };
 }
 
-function qgisProjectXml(data: ArrayBuffer | Uint8Array | string, sourcePath: string): string {
+function parseRasterState(element: Element): QgisRasterImport["state"] {
+  const renderer = element.querySelector(":scope > pipe > rasterrenderer");
+  if (!renderer) return undefined;
+  const type = renderer.getAttribute("type")?.toLowerCase();
+  if (type !== "singlebandpseudocolor" && type !== "singlebandgray")
+    return undefined;
+
+  const band = positiveInteger(renderer.getAttribute("band")) ?? 1;
+  const shader = renderer.querySelector("rastershader > colorrampshader");
+  const minimum = numberAttribute(shader, "minimumValue");
+  const maximum = numberAttribute(shader, "maximumValue");
+  const ramp = shader?.querySelector(":scope > colorramp");
+  const first = qgisRampColor(ramp, "color1");
+  const last = qgisRampColor(ramp, "color2");
+  const matched = matchBuiltInColorRamp(first, last);
+  const gamma =
+    numberAttribute(
+      element.querySelector(":scope > pipe > brightnesscontrast"),
+      "gamma"
+    ) ?? 1;
+
+  return {
+    bands: [band],
+    colormap:
+      type === "singlebandgray" ? "gray" : matched?.colormap ?? "viridis",
+    gamma: gamma > 0 ? gamma : 1,
+    rescale:
+      Number.isFinite(minimum) && Number.isFinite(maximum) && minimum < maximum
+        ? [[minimum, maximum]]
+        : null,
+    reversed: matched?.reversed ?? false,
+  };
+}
+
+function qgisRampColor(
+  ramp: Element | null | undefined,
+  name: string
+): string | null {
+  const option = Array.from(ramp?.querySelectorAll("Option") ?? []).find(
+    (candidate) => candidate.getAttribute("name") === name
+  );
+  const channels = option?.getAttribute("value")?.split(",", 3).map(Number);
+  if (
+    !channels ||
+    channels.length !== 3 ||
+    channels.some((value) => !Number.isFinite(value))
+  ) {
+    return null;
+  }
+  return `#${channels
+    .map((value) =>
+      Math.max(0, Math.min(255, Math.round(value)))
+        .toString(16)
+        .padStart(2, "0")
+    )
+    .join("")}`;
+}
+
+function matchBuiltInColorRamp(
+  first: string | null,
+  last: string | null
+): { colormap: string; reversed: boolean } | null {
+  if (!first || !last) return null;
+  for (const ramp of VECTOR_COLOR_RAMPS) {
+    const start = ramp.colors[0].toLowerCase();
+    const end = ramp.colors[ramp.colors.length - 1].toLowerCase();
+    if (first === start && last === end)
+      return { colormap: ramp.value, reversed: false };
+    if (first === end && last === start)
+      return { colormap: ramp.value, reversed: true };
+  }
+  return null;
+}
+
+function positiveInteger(value: string | null): number | null {
+  const parsed = Number(value);
+  return Number.isInteger(parsed) && parsed > 0 ? parsed : null;
+}
+
+function numberAttribute(
+  element: Element | null | undefined,
+  name: string
+): number {
+  const raw = element?.getAttribute(name);
+  if (raw == null || raw.trim() === "") return Number.NaN;
+  const value = Number(raw);
+  return Number.isFinite(value) ? value : Number.NaN;
+}
+
+function qgisProjectXml(
+  data: ArrayBuffer | Uint8Array | string,
+  sourcePath: string
+): string {
   if (typeof data === "string") return data;
   const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
   if (sourcePath.toLowerCase().endsWith(".qgs")) return strFromU8(bytes);
@@ -210,8 +331,11 @@ function qgisProjectXml(data: ArrayBuffer | Uint8Array | string, sourcePath: str
   } catch {
     throw new Error("Could not read the compressed QGIS project.");
   }
-  const qgsName = Object.keys(entries).find((name) => name.toLowerCase().endsWith(".qgs"));
-  if (!qgsName) throw new Error("The QGZ archive does not contain a QGS project file.");
+  const qgsName = Object.keys(entries).find((name) =>
+    name.toLowerCase().endsWith(".qgs")
+  );
+  if (!qgsName)
+    throw new Error("The QGZ archive does not contain a QGS project file.");
   return strFromU8(entries[qgsName]);
 }
 
@@ -244,20 +368,34 @@ function parseMapView(document: Document): MapViewState {
   return { center: [-100, 40], zoom: 2, bearing: 0, pitch: 0 };
 }
 
-function toWgs84(x: number, y: number, authId: string): [number, number] | null {
+function toWgs84(
+  x: number,
+  y: number,
+  authId: string
+): [number, number] | null {
   const normalized = authId.toUpperCase();
   if (normalized === "EPSG:4326" || normalized === "CRS:84") return [x, y];
   if (normalized === "EPSG:3857") {
     return [
       (x / 20037508.34) * 180,
-      (180 / Math.PI) * (2 * Math.atan(Math.exp((y / 20037508.34) * Math.PI)) - Math.PI / 2),
+      (180 / Math.PI) *
+        (2 * Math.atan(Math.exp((y / 20037508.34) * Math.PI)) - Math.PI / 2),
     ];
   }
   return null;
 }
 
-function zoomForBounds(west: number, south: number, east: number, north: number): number {
-  const span = Math.max(Math.abs(east - west), Math.abs(north - south) * 2, 0.000001);
+function zoomForBounds(
+  west: number,
+  south: number,
+  east: number,
+  north: number
+): number {
+  const span = Math.max(
+    Math.abs(east - west),
+    Math.abs(north - south) * 2,
+    0.000001
+  );
   return Math.max(0, Math.min(20, Math.log2(360 / span) - 0.75));
 }
 
@@ -268,18 +406,20 @@ function parseLayerGroups(document: Document): {
   const root = document.querySelector("layer-tree-group");
   if (!root) return { groups: [], ids: new Map() };
   const ids = new Map<Element, string>();
-  const groups = Array.from(root.querySelectorAll("layer-tree-group")).map((element, index) => {
-    const name = groupDisplayName(element, root);
-    const id = `qgis-group-${index}-${slug(name)}`;
-    ids.set(element, id);
-    return {
-      id,
-      name,
-      collapsed: element.getAttribute("expanded") === "0",
-      visible: element.getAttribute("checked") !== "Qt::Unchecked",
-      opacity: 1,
-    };
-  });
+  const groups = Array.from(root.querySelectorAll("layer-tree-group")).map(
+    (element, index) => {
+      const name = groupDisplayName(element, root);
+      const id = `qgis-group-${index}-${slug(name)}`;
+      ids.set(element, id);
+      return {
+        id,
+        name,
+        collapsed: element.getAttribute("expanded") === "0",
+        visible: element.getAttribute("checked") !== "Qt::Unchecked",
+        opacity: 1,
+      };
+    }
+  );
   return { groups, ids };
 }
 
@@ -294,7 +434,10 @@ function groupDisplayName(element: Element, root: Element): string {
   return names.join(" / ") || "Group";
 }
 
-function layerGroupAssignments(document: Document, ids: Map<Element, string>): Map<string, string> {
+function layerGroupAssignments(
+  document: Document,
+  ids: Map<Element, string>
+): Map<string, string> {
   const assignments = new Map<string, string>();
   document.querySelectorAll("layer-tree-layer[id]").forEach((layer) => {
     const layerId = layer.getAttribute("id");
@@ -336,7 +479,8 @@ function qgisSourcePath(dataSource: string, projectPath: string): string {
     }
   }
   source = source.replace(/^['"]|['"]$/g, "");
-  if (!source || isAbsolutePath(source) || /^[a-z]+:\/\//i.test(source)) return source;
+  if (!source || isAbsolutePath(source) || /^[a-z]+:\/\//i.test(source))
+    return source;
   const directory = projectPath.replace(/[/\\][^/\\]*$/, "");
   return normalizeJoinedPath(directory, source);
 }
@@ -361,7 +505,11 @@ function normalizeJoinedPath(directory: string, relative: string): string {
   return `${absolute ? "/" : ""}${normalized.join(separator)}`;
 }
 
-function isSupportedVectorLayer(element: Element, provider: string, source: string): boolean {
+function isSupportedVectorLayer(
+  element: Element,
+  provider: string,
+  source: string
+): boolean {
   return (
     element.getAttribute("type")?.toLowerCase() === "vector" &&
     (provider === "ogr" || provider === "delimitedtext") &&
@@ -370,7 +518,11 @@ function isSupportedVectorLayer(element: Element, provider: string, source: stri
   );
 }
 
-function isSupportedRasterLayer(element: Element, provider: string, source: string): boolean {
+function isSupportedRasterLayer(
+  element: Element,
+  provider: string,
+  source: string
+): boolean {
   return (
     element.getAttribute("type")?.toLowerCase() === "raster" &&
     provider === "gdal" &&
@@ -380,8 +532,15 @@ function isSupportedRasterLayer(element: Element, provider: string, source: stri
   );
 }
 
-function isOpenStreetMapBasemap(element: Element, provider: string, dataSource: string): boolean {
-  if (element.getAttribute("type")?.toLowerCase() !== "raster" || provider !== "wms") {
+function isOpenStreetMapBasemap(
+  element: Element,
+  provider: string,
+  dataSource: string
+): boolean {
+  if (
+    element.getAttribute("type")?.toLowerCase() !== "raster" ||
+    provider !== "wms"
+  ) {
     return false;
   }
   const params = new URLSearchParams(dataSource);
@@ -390,7 +549,10 @@ function isOpenStreetMapBasemap(element: Element, provider: string, dataSource:
   if (!tileUrl) return false;
   try {
     const host = new URL(tileUrl).hostname.toLowerCase();
-    return host === "tile.openstreetmap.org" || /^[abc]\.tile\.openstreetmap\.org$/.test(host);
+    return (
+      host === "tile.openstreetmap.org" ||
+      /^[abc]\.tile\.openstreetmap\.org$/.test(host)
+    );
   } catch {
     return false;
   }
@@ -399,7 +561,7 @@ function isOpenStreetMapBasemap(element: Element, provider: string, dataSource:
 function unsupportedReason(
   element: Element,
   provider: string,
-  source: string,
+  source: string
 ): QgisProjectImportWarning["reason"] {
   if (element.getAttribute("type")?.toLowerCase() !== "vector") {
     return "non-vector";
@@ -417,10 +579,15 @@ function parseLayerStyle(element: Element): LayerStyle {
   const symbolLayer = element.querySelector("renderer-v2 symbols symbol layer");
   const options = new Map<string, string>();
   symbolLayer?.querySelectorAll("Option[name]").forEach((option) => {
-    options.set(option.getAttribute("name") ?? "", option.getAttribute("value") ?? "");
+    options.set(
+      option.getAttribute("name") ?? "",
+      option.getAttribute("value") ?? ""
+    );
   });
   const fill = qgisColor(options.get("color"));
-  const stroke = qgisColor(options.get("outline_color") ?? options.get("line_color"));
+  const stroke = qgisColor(
+    options.get("outline_color") ?? options.get("line_color")
+  );
   if (fill) {
     style.fillColor = fill.color;
     style.fillOpacity = fill.opacity;
@@ -429,36 +596,48 @@ function parseLayerStyle(element: Element): LayerStyle {
   if (stroke) {
     style.strokeColor = stroke.color;
   }
-  const width = optionalNumber(options.get("outline_width") ?? options.get("line_width"));
+  const width = optionalNumber(
+    options.get("outline_width") ?? options.get("line_width")
+  );
   if (width !== null) style.strokeWidth = Math.max(0, width * 3.78);
   const size = optionalNumber(options.get("size"));
   if (symbolLayer?.getAttribute("class") === "SimpleMarker" && size !== null) {
     style.circleRadius = Math.max(1, (size * 3.78) / 2);
   }
-  const textStyle = element.querySelector("labeling[type='simple'] settings text-style");
+  const textStyle = element.querySelector(
+    "labeling[type='simple'] settings text-style"
+  );
   const field = textStyle?.getAttribute("fieldName")?.trim();
   if (field) {
     style.labels.enabled = true;
     style.labels.field = field;
     const color = qgisColor(textStyle?.getAttribute("textColor") ?? undefined);
     if (color) style.labels.color = color.color;
-    const sizeValue = optionalNumber(textStyle?.getAttribute("fontSize") ?? undefined);
+    const sizeValue = optionalNumber(
+      textStyle?.getAttribute("fontSize") ?? undefined
+    );
     if (sizeValue !== null) style.labels.size = sizeValue;
   }
   return style;
 }
 
-function qgisColor(value: string | undefined): { color: string; opacity: number } | null {
+function qgisColor(
+  value: string | undefined
+): { color: string; opacity: number } | null {
   if (!value) return null;
   const parts = value.split(",").map(Number);
-  if (parts.length < 3 || parts.slice(0, 3).some((part) => !Number.isFinite(part))) return null;
+  if (
+    parts.length < 3 ||
+    parts.slice(0, 3).some((part) => !Number.isFinite(part))
+  )
+    return null;
   const [red, green, blue, alpha = 255] = parts;
   return {
     color: `#${[red, green, blue]
       .map((part) =>
         Math.max(0, Math.min(255, Math.round(part)))
           .toString(16)
-          .padStart(2, "0"),
+          .padStart(2, "0")
       )
       .join("")}`,
     opacity: Math.max(0, Math.min(1, alpha / 255)),
@@ -466,7 +645,9 @@ function qgisColor(value: string | undefined): { color: string; opacity: number
 }
 
 function parseOpacity(element: Element): number {
-  const value = optionalNumber(text(element.querySelector(":scope > layerOpacity")));
+  const value = optionalNumber(
+    text(element.querySelector(":scope > layerOpacity"))
+  );
   return value !== null ? Math.max(0, Math.min(1, value)) : 1;
 }
 
@@ -503,7 +684,11 @@ function fileStem(path: string): string {
 }
 
 function isAbsolutePath(path: string): boolean {
-  return path.startsWith("/") || path.startsWith("\\\\") || /^[A-Za-z]:[/\\]/.test(path);
+  return (
+    path.startsWith("/") ||
+    path.startsWith("\\\\") ||
+    /^[A-Za-z]:[/\\]/.test(path)
+  );
 }
 
 function isHttpSource(path: string): boolean {
diff --git a/tests/qgis-project-import.test.ts b/tests/qgis-project-import.test.ts
index 62a6e11a5..03890cd02 100644
--- a/tests/qgis-project-import.test.ts
+++ b/tests/qgis-project-import.test.ts
@@ -14,11 +14,15 @@ function projectXml(
     authId?: string;
     extent?: string;
     dataSources?: Array<{ id: string; name: string; source: string }>;
-  } = {},
+  } = {}
 ): string {
   const dataSources = options.dataSources ?? [
     { id: "roads", name: "Roads", source: "../data/roads.geojson" },
-    { id: "cities", name: "Cities", source: "../data/cities.gpkg|layername=cities" },
+    {
+      id: "cities",
+      name: "Cities",
+      source: "../data/cities.gpkg|layername=cities",
+    },
   ];
   const mapLayers = dataSources
     .map(
@@ -39,7 +43,7 @@ function projectXml(
           <labeling type="simple">
             <settings><text-style fieldName="name" fontSize="12"/></settings>
           </labeling>
-        </maplayer>`,
+        </maplayer>`
     )
     .join("");
 
@@ -55,8 +59,13 @@ function projectXml(
     </layer-tree-group>
     <projectlayers>${mapLayers}</projectlayers>
     <mapcanvas>
-      ${options.extent ?? "<extent><xmin>-125</xmin><ymin>24</ymin><xmax>-66</xmax><ymax>50</ymax></extent>"}
-      <destinationsrs><spatialrefsys><authid>${options.authId ?? "EPSG:4326"}</authid></spatialrefsys></destinationsrs>
+      ${
+        options.extent ??
+        "<extent><xmin>-125</xmin><ymin>24</ymin><xmax>-66</xmax><ymax>50</ymax></extent>"
+      }
+      <destinationsrs><spatialrefsys><authid>${
+        options.authId ?? "EPSG:4326"
+      }</authid></spatialrefsys></destinationsrs>
     </mapcanvas>
   </qgis>`;
 }
@@ -73,6 +82,19 @@ function rasterProjectXml(source = "../data/dem.tif"): string {
         <datasource>${source}</datasource>
         <provider>gdal</provider>
         <layerOpacity>0.6</layerOpacity>
+        <pipe>
+          <rasterrenderer type="singlebandpseudocolor" band="1">
+            <rastershader>
+              <colorrampshader minimumValue="61.42" maximumValue="1524.33">
+                <colorramp type="gradient">
+                  <Option name="color1" value="48,18,59,255"/>
+                  <Option name="color2" value="122,4,3,255"/>
+                </colorramp>
+              </colorrampshader>
+            </rastershader>
+          </rasterrenderer>
+          <brightnesscontrast gamma="1.2"/>
+        </pipe>
       </maplayer>
     </projectlayers>
   </qgis>`;
@@ -97,17 +119,20 @@ function osmBasemapProjectXml(): string {
 
 describe("QGIS project import", () => {
   it("imports vector layers, styles, visibility, nested groups, extent, and relative paths", () => {
-    const result = importQgisProject(projectXml(), "/work/projects/example.qgs");
+    const result = importQgisProject(
+      projectXml(),
+      "/work/projects/example.qgs"
+    );
 
     assert.equal(result.project.name, "Imported map");
     assert.deepEqual(result.project.mapView.center, [-95.5, 37]);
     assert.deepEqual(
       result.project.layerGroups?.map((group) => group.name),
-      ["Transport", "Transport / Places"],
+      ["Transport", "Transport / Places"]
     );
     assert.deepEqual(
       result.project.layers.map((layer) => layer.name),
-      ["Cities", "Roads"],
+      ["Cities", "Roads"]
     );
 
     const cities = result.project.layers[0];
@@ -133,7 +158,10 @@ describe("QGIS project import", () => {
   });
 
   it("collects local GDAL GeoTIFFs for the desktop raster loader", () => {
-    const result = importQgisProject(rasterProjectXml(), "/work/projects/example.qgz");
+    const result = importQgisProject(
+      rasterProjectXml(),
+      "/work/projects/example.qgz"
+    );
 
     assert.deepEqual(result.project.layers, []);
     assert.deepEqual(result.rasters, [
@@ -143,15 +171,28 @@ describe("QGIS project import", () => {
         sourcePath: "/work/data/dem.tif",
         visible: false,
         opacity: 0.6,
+        state: {
+          bands: [1],
+          colormap: "turbo",
+          gamma: 1.2,
+          rescale: [[61.42, 1524.33]],
+          reversed: false,
+        },
       },
     ]);
     assert.deepEqual(result.warnings, []);
   });
 
   it("maps QGIS OpenStreetMap XYZ layers to the built-in basemap", () => {
-    const result = importQgisProject(osmBasemapProjectXml(), "/work/example.qgs");
+    const result = importQgisProject(
+      osmBasemapProjectXml(),
+      "/work/example.qgs"
+    );
 
-    assert.equal(result.project.basemapStyleUrl, "https://tiles.openfreemap.org/styles/liberty");
+    assert.equal(
+      result.project.basemapStyleUrl,
+      "https://tiles.openfreemap.org/styles/liberty"
+    );
     assert.equal(result.project.basemapVisible, false);
     assert.equal(result.project.basemapOpacity, 0.7);
     assert.deepEqual(result.project.layers, []);
@@ -160,7 +201,10 @@ describe("QGIS project import", () => {
   });
 
   it("falls back to the default view for a missing or unsupported-CRS extent", () => {
-    const missing = importQgisProject(projectXml({ extent: "" }), "/work/example.qgs");
+    const missing = importQgisProject(
+      projectXml({ extent: "" }),
+      "/work/example.qgs"
+    );
     assert.deepEqual(missing.project.mapView, {
       center: [-100, 40],
       zoom: 2,
@@ -168,7 +212,10 @@ describe("QGIS project import", () => {
       pitch: 0,
     });
 
-    const projected = importQgisProject(projectXml({ authId: "EPSG:32618" }), "/work/example.qgs");
+    const projected = importQgisProject(
+      projectXml({ authId: "EPSG:32618" }),
+      "/work/example.qgs"
+    );
     assert.deepEqual(projected.project.mapView, {
       center: [-100, 40],
       zoom: 2,
@@ -184,21 +231,35 @@ describe("QGIS project import", () => {
           {
             id: "roads",
             name: "Remote",
-            source: "/vsicurl/https://example.com/roads.geojson|layername=roads",
+            source:
+              "/vsicurl/https://example.com/roads.geojson|layername=roads",
+          },
+          {
+            id: "cities",
+            name: "Network",
+            source: "\\\\server\\share\\cities.gpkg",
           },
-          { id: "cities", name: "Network", source: "\\\\server\\share\\cities.gpkg" },
         ],
       }),
-      "C:\\projects\\example.qgs",
+      "C:\\projects\\example.qgs"
     );
 
     assert.equal(result.project.layers.length, 1);
-    assert.equal(result.project.layers[0].sourcePath, "https://example.com/roads.geojson");
-    assert.equal(result.project.layers[0].source.url, "https://example.com/roads.geojson");
-    assert.equal(result.project.layers[0].metadata.localFileReloadable, undefined);
+    assert.equal(
+      result.project.layers[0].sourcePath,
+      "https://example.com/roads.geojson"
+    );
+    assert.equal(
+      result.project.layers[0].source.url,
+      "https://example.com/roads.geojson"
+    );
+    assert.equal(
+      result.project.layers[0].metadata.localFileReloadable,
+      undefined
+    );
     assert.deepEqual(
       result.warnings.map((warning) => [warning.layerName, warning.reason]),
-      [["Network", "network-path"]],
+      [["Network", "network-path"]]
     );
   });
 
@@ -206,19 +267,30 @@ describe("QGIS project import", () => {
     const result = importQgisProject(
       projectXml({
         dataSources: [
-          { id: "roads", name: "Good", source: "https://example.com/good.geojson" },
-          { id: "cities", name: "Bad", source: "https://example.com/bad.geojson" },
+          {
+            id: "roads",
+            name: "Good",
+            source: "https://example.com/good.geojson",
+          },
+          {
+            id: "cities",
+            name: "Bad",
+            source: "https://example.com/bad.geojson",
+          },
         ],
       }),
-      "/work/example.qgs",
+      "/work/example.qgs"
     );
 
     await materializeQgisRemoteLayers(result, async (input) => {
       const url = String(input);
-      if (url.endsWith("/bad.geojson")) return new Response("no", { status: 404 });
+      if (url.endsWith("/bad.geojson"))
+        return new Response("no", { status: 404 });
       return Response.json({
         type: "FeatureCollection",
-        features: [{ type: "Feature", geometry: null, properties: { name: "Test" } }],
+        features: [
+          { type: "Feature", geometry: null, properties: { name: "Test" } },
+        ],
       });
     });
 
@@ -227,7 +299,7 @@ describe("QGIS project import", () => {
     assert.equal(result.project.layers[0].geojson?.features.length, 1);
     assert.deepEqual(
       result.warnings.map((warning) => [warning.layerName, warning.reason]),
-      [["Bad", "remote-file"]],
+      [["Bad", "remote-file"]]
     );
   });
 });

From c37e0480f2eabf4a7ec05f269782467896117419 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Fri, 31 Jul 2026 03:36:27 +0000
Subject: [PATCH 10/19] style: auto-format (ruff + oxfmt) [pre-commit.ci]

---
 .../src/hooks/useProjectFileActions.ts        | 174 ++++----------
 .../src/lib/qgis-project-import.ts            | 223 +++++-------------
 tests/qgis-project-import.test.ts             |  71 ++----
 3 files changed, 133 insertions(+), 335 deletions(-)

diff --git a/apps/geolibre-desktop/src/hooks/useProjectFileActions.ts b/apps/geolibre-desktop/src/hooks/useProjectFileActions.ts
index cd83f0844..6795e77b9 100644
--- a/apps/geolibre-desktop/src/hooks/useProjectFileActions.ts
+++ b/apps/geolibre-desktop/src/hooks/useProjectFileActions.ts
@@ -6,10 +6,7 @@ import {
   useAppStore,
   type GeoLibreLayer,
 } from "@geolibre/core";
-import {
-  addRasterToMap,
-  materializeEmbeddableVectorLayers,
-} from "@geolibre/plugins";
+import { addRasterToMap, materializeEmbeddableVectorLayers } from "@geolibre/plugins";
 import type { FeatureCollection } from "geojson";
 import { type FormEvent, useRef, useState } from "react";
 import { useTranslation } from "react-i18next";
@@ -138,21 +135,18 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
   const markSaved = useAppStore((s) => s.markSaved);
 
   const [actionError, setActionError] = useState<string | null>(null);
-  const [qgisImportWarnings, setQgisImportWarnings] = useState<
-    QgisProjectImportWarning[] | null
-  >(null);
+  const [qgisImportWarnings, setQgisImportWarnings] = useState<QgisProjectImportWarning[] | null>(
+    null,
+  );
   const [projectUrlDialogOpen, setProjectUrlDialogOpen] = useState(false);
   const [projectUrl, setProjectUrl] = useState("");
   const [projectUrlError, setProjectUrlError] = useState<string | null>(null);
   const [projectUrlLoading, setProjectUrlLoading] = useState(false);
-  const [envStripPrompt, setEnvStripPrompt] = useState<EnvStripPrompt | null>(
-    null
-  );
-  const [embedVectorDataPrompt, setEmbedVectorDataPrompt] =
-    useState<EmbedVectorDataPrompt | null>(null);
-  const [saveNamePrompt, setSaveNamePrompt] = useState<SaveNamePrompt | null>(
-    null
+  const [envStripPrompt, setEnvStripPrompt] = useState<EnvStripPrompt | null>(null);
+  const [embedVectorDataPrompt, setEmbedVectorDataPrompt] = useState<EmbedVectorDataPrompt | null>(
+    null,
   );
+  const [saveNamePrompt, setSaveNamePrompt] = useState<SaveNamePrompt | null>(null);
   const [saveNameInput, setSaveNameInput] = useState("");
   const projectUrlAbortRef = useRef<AbortController | null>(null);
   const recentAbortRef = useRef<AbortController | null>(null);
@@ -168,19 +162,13 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
     const result = await openProjectFile();
     if (result) {
       try {
-        loadProject(
-          await resolveProjectXyzLayers(result.project),
-          result.path,
-          {
-            rememberRecent: isTauri(),
-          }
-        );
+        loadProject(await resolveProjectXyzLayers(result.project), result.path, {
+          rememberRecent: isTauri(),
+        });
       } catch (error) {
         console.error("Failed to open project", error);
         setActionError(
-          error instanceof Error
-            ? error.message
-            : t("toolbar.error.couldNotOpenProject")
+          error instanceof Error ? error.message : t("toolbar.error.couldNotOpenProject"),
         );
       }
     }
@@ -191,7 +179,7 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
     if (!result) return;
     try {
       const imported = await materializeQgisRemoteLayers(
-        importQgisProject(result.data, result.path)
+        importQgisProject(result.data, result.path),
       );
       if (!isTauri()) {
         for (const layer of imported.project.layers) {
@@ -230,10 +218,7 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
               zoomTo: false,
             });
           } catch (error) {
-            console.error(
-              `Failed to import QGIS raster "${raster.name}"`,
-              error
-            );
+            console.error(`Failed to import QGIS raster "${raster.name}"`, error);
             imported.warnings.push({
               layerName: raster.name,
               reason: "format",
@@ -242,15 +227,11 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
         }
       }
       useAppStore.setState({ isDirty: true });
-      setQgisImportWarnings(
-        imported.warnings.length > 0 ? imported.warnings : null
-      );
+      setQgisImportWarnings(imported.warnings.length > 0 ? imported.warnings : null);
     } catch (error) {
       console.error("Failed to import QGIS project", error);
       setActionError(
-        error instanceof Error
-          ? error.message
-          : t("toolbar.error.couldNotImportQgisProject")
+        error instanceof Error ? error.message : t("toolbar.error.couldNotImportQgisProject"),
       );
     }
   };
@@ -271,14 +252,8 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
     setProjectUrlError(null);
 
     try {
-      const result = await openRecentProjectFile(
-        normalizedUrl,
-        controller.signal
-      );
-      const project = await resolveProjectXyzLayers(
-        result.project,
-        controller.signal
-      );
+      const result = await openRecentProjectFile(normalizedUrl, controller.signal);
+      const project = await resolveProjectXyzLayers(result.project, controller.signal);
       if (controller.signal.aborted) return;
       loadProject(project, result.path);
       setProjectUrl("");
@@ -287,9 +262,7 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
       if (controller.signal.aborted) return;
       console.error("Failed to open project URL", error);
       setProjectUrlError(
-        error instanceof Error
-          ? error.message
-          : t("toolbar.error.couldNotOpenProjectUrl")
+        error instanceof Error ? error.message : t("toolbar.error.couldNotOpenProjectUrl"),
       );
     } finally {
       if (projectUrlAbortRef.current === controller) {
@@ -316,7 +289,7 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
 
   const openProjectFromShareUrl = async (
     url: string,
-    options: { authToken?: string; asCopy?: boolean } = {}
+    options: { authToken?: string; asCopy?: boolean } = {},
   ): Promise<void> => {
     const normalizedUrl = normalizeProjectUrl(url);
     if (!normalizedUrl) {
@@ -335,19 +308,13 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
           fetchImpl: shareAuthorizedFetch(
             options.authToken,
             resolveShareBaseUrl(),
-            getShareFetch()
+            getShareFetch(),
           ),
         });
         project = await resolveProjectXyzLayers(fetched, controller.signal);
       } else {
-        const result = await openRecentProjectFile(
-          normalizedUrl,
-          controller.signal
-        );
-        project = await resolveProjectXyzLayers(
-          result.project,
-          controller.signal
-        );
+        const result = await openRecentProjectFile(normalizedUrl, controller.signal);
+        project = await resolveProjectXyzLayers(result.project, controller.signal);
       }
 
       if (controller.signal.aborted) return;
@@ -389,25 +356,18 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
         forgetRecentProject(path);
       }
       console.error("Failed to open recent project", error);
-      return error instanceof Error
-        ? error.message
-        : t("toolbar.error.couldNotOpenRecentProject");
+      return error instanceof Error ? error.message : t("toolbar.error.couldNotOpenRecentProject");
     }
 
     try {
-      const project = await resolveProjectXyzLayers(
-        result.project,
-        controller.signal
-      );
+      const project = await resolveProjectXyzLayers(result.project, controller.signal);
       if (controller.signal.aborted) return null;
       loadProject(project, result.path);
       return null;
     } catch (error) {
       if (controller.signal.aborted) return null;
       console.error("Failed to load recent project", error);
-      return error instanceof Error
-        ? error.message
-        : t("toolbar.error.couldNotLoadRecentProject");
+      return error instanceof Error ? error.message : t("toolbar.error.couldNotLoadRecentProject");
     } finally {
       if (recentAbortRef.current === controller) {
         recentAbortRef.current = null;
@@ -418,10 +378,7 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
   // Build the current project from live store + map state and serialize it.
   // Shared by Save/Save As and the Share action so they all capture identical
   // project content (including the current map view and plugin state).
-  const buildCurrentProject = (
-    nameOverride?: string,
-    layersOverride?: GeoLibreLayer[]
-  ) => {
+  const buildCurrentProject = (nameOverride?: string, layersOverride?: GeoLibreLayer[]) => {
     const state = useAppStore.getState();
     const defaultProjectName =
       nameOverride?.trim() || state.projectName.trim() || DEFAULT_PROJECT_NAME;
@@ -444,7 +401,7 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
     ]);
     const pluginManifestUrls = mergeStringLists(
       state.projectPlugins?.manifestUrls ?? [],
-      pluginManifestUrlsForIds(usedPluginIds)
+      pluginManifestUrlsForIds(usedPluginIds),
     );
     const project = projectFromStore({
       projectName: defaultProjectName,
@@ -502,9 +459,7 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
       setEmbedVectorDataPrompt({ count, bytes, desktop, resolve });
     });
 
-  const resolveEmbedVectorDataPrompt = (
-    choice: "embed" | "noembed" | "cancel"
-  ) => {
+  const resolveEmbedVectorDataPrompt = (choice: "embed" | "noembed" | "cancel") => {
     embedVectorDataPrompt?.resolve(choice);
     setEmbedVectorDataPrompt(null);
   };
@@ -518,20 +473,16 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
   // restores. Used by the save dialog's Embed choice and by Share (always).
   const buildEmbeddedLayers = async (
     layers: GeoLibreLayer[],
-    prebuilt?: Map<string, FeatureCollection>
+    prebuilt?: Map<string, FeatureCollection>,
   ): Promise<GeoLibreLayer[]> => {
     // Reuse a map the caller already materialized (the Embed save path) so each
     // layer's features aren't read from the control twice, but materialize any
     // layer it doesn't cover — e.g. one added while the save dialog was open —
     // so a late addition still gets its data instead of being dropped.
     const embeddable = new Map(prebuilt);
-    const uncovered = prebuilt
-      ? layers.filter((layer) => !prebuilt.has(layer.id))
-      : layers;
+    const uncovered = prebuilt ? layers.filter((layer) => !prebuilt.has(layer.id)) : layers;
     if (uncovered.length > 0) {
-      for (const [id, collection] of await materializeEmbeddableVectorLayers(
-        uncovered
-      )) {
+      for (const [id, collection] of await materializeEmbeddableVectorLayers(uncovered)) {
         embeddable.set(id, collection);
       }
     }
@@ -552,7 +503,7 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
   // GeoJSON layers use their `geojson`.
   const estimateEmbedBytes = (
     layers: GeoLibreLayer[],
-    embeddable: Map<string, FeatureCollection>
+    embeddable: Map<string, FeatureCollection>,
   ): number => {
     const encoder = new TextEncoder();
     let bytes = 0;
@@ -573,14 +524,10 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
   // reload from disk on reopen, so the prompt offers Embed or Save file
   // references. Returns the layers override to serialize, an empty result to use
   // the live layers as-is, or "cancel" to abort the save.
-  const resolveLayersForSave = async (): Promise<
-    { layers?: GeoLibreLayer[] } | "cancel"
-  > => {
+  const resolveLayersForSave = async (): Promise<{ layers?: GeoLibreLayer[] } | "cancel"> => {
     const state = useAppStore.getState();
     const embeddable = await materializeEmbeddableVectorLayers(state.layers);
-    const localFileLayers = isTauri()
-      ? state.layers.filter(isReloadableLocalFileLayer)
-      : [];
+    const localFileLayers = isTauri() ? state.layers.filter(isReloadableLocalFileLayer) : [];
     if (embeddable.size === 0 && localFileLayers.length === 0) return {};
 
     const count = embeddable.size + localFileLayers.length;
@@ -591,10 +538,7 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
     if (choice === "embed") {
       // Reuse the map already materialized for the size estimate.
       return {
-        layers: await buildEmbeddedLayers(
-          useAppStore.getState().layers,
-          embeddable
-        ),
+        layers: await buildEmbeddedLayers(useAppStore.getState().layers, embeddable),
       };
     }
 
@@ -643,10 +587,7 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
   // the user can control. The caller supplies the dialog copy so the same prompt
   // serves both project saves and HTML exports. Resolves with the name, or null
   // if cancelled.
-  const askSaveName = (
-    defaultName: string,
-    labels: Omit<SaveNamePrompt, "resolve">
-  ) =>
+  const askSaveName = (defaultName: string, labels: Omit<SaveNamePrompt, "resolve">) =>
     new Promise<string | null>((resolve) => {
       setSaveNameInput(defaultName);
       setSaveNamePrompt({ resolve, ...labels });
@@ -665,20 +606,20 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
     setSaveNameInput("");
   };
 
-  const runSaveProject = async (options?: {
-    saveAs?: boolean;
-  }): Promise<boolean> => {
+  const runSaveProject = async (options?: { saveAs?: boolean }): Promise<boolean> => {
     // Offer to embed local vector data (or, on desktop, save file references)
     // first, so the serialized content below reflects the user's choice.
     const layersForSave = await resolveLayersForSave();
     if (layersForSave === "cancel") return false;
-    const { project, defaultProjectName, content, projectPath } =
-      buildCurrentProject(undefined, layersForSave.layers);
+    const { project, defaultProjectName, content, projectPath } = buildCurrentProject(
+      undefined,
+      layersForSave.layers,
+    );
     // Env vars (possibly API keys) are serialized in plain text. If any are set,
     // offer to strip them from the saved file before writing.
     let contentToSave = content;
-    const envVarCount = (project.preferences.environmentVariables ?? []).filter(
-      (variable) => variable.key.trim()
+    const envVarCount = (project.preferences.environmentVariables ?? []).filter((variable) =>
+      variable.key.trim(),
     ).length;
     if (envVarCount > 0) {
       const choice = await askStripEnvVars(envVarCount);
@@ -692,16 +633,14 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
     }
     // Projects opened from a URL have no writable path, so both Save and
     // Save As fall back to the save dialog for them.
-    const existingLocalPath =
-      projectPath && !isHttpUrl(projectPath) ? projectPath : null;
+    const existingLocalPath = projectPath && !isHttpUrl(projectPath) ? projectPath : null;
     // Browsers without the File System Access picker (Firefox, Safari) can only
     // download under a fixed name, so Save As (and a first Save) would otherwise
     // reuse a default name — exactly the bug users hit. Prompt for the name so
     // they can choose it; later in-place Saves reuse the chosen name silently.
     let saveName = `${defaultProjectName}.geolibre.json`;
     const promptForName =
-      browserSaveFallsBackToDownload() &&
-      (options?.saveAs === true || !existingLocalPath);
+      browserSaveFallsBackToDownload() && (options?.saveAs === true || !existingLocalPath);
     if (promptForName) {
       const chosen = await askSaveName(saveName, {
         title: t("toolbar.item.saveProjectAsTitle"),
@@ -719,14 +658,12 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
           ? await saveProjectFileToPath(contentToSave, existingLocalPath)
           : await saveProjectFile(
               contentToSave,
-              promptForName ? saveName : existingLocalPath ?? saveName
+              promptForName ? saveName : (existingLocalPath ?? saveName),
             );
     } catch (error) {
       console.error("Failed to save project", error);
       setActionError(
-        error instanceof Error
-          ? error.message
-          : t("toolbar.error.couldNotSaveProject")
+        error instanceof Error ? error.message : t("toolbar.error.couldNotSaveProject"),
       );
       return false;
     }
@@ -742,9 +679,7 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
   };
 
   // Serialize saves so overlapping invocations cannot clobber a pending prompt.
-  const saveProject = async (options?: {
-    saveAs?: boolean;
-  }): Promise<boolean> => {
+  const saveProject = async (options?: { saveAs?: boolean }): Promise<boolean> => {
     if (isSavingRef.current) return false;
     isSavingRef.current = true;
     try {
@@ -769,8 +704,7 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
       // buildEmbeddedProject as the name override below, so the file-name slug
       // and the HTML title stay consistent even if the project is renamed while
       // the name prompt is open.
-      const projectName =
-        useAppStore.getState().projectName.trim() || DEFAULT_PROJECT_NAME;
+      const projectName = useAppStore.getState().projectName.trim() || DEFAULT_PROJECT_NAME;
       const slug =
         projectName
           .toLowerCase()
@@ -797,9 +731,7 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
       // costly on a project with many local layers, so it runs after the user
       // has committed to the export rather than before the prompt. Reuse the
       // name snapshot so the title matches the slug computed above.
-      const { project, defaultProjectName } = await buildEmbeddedProject(
-        projectName
-      );
+      const { project, defaultProjectName } = await buildEmbeddedProject(projectName);
       const safeProject = {
         ...project,
         preferences: { ...project.preferences, environmentVariables: [] },
@@ -824,9 +756,7 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
       return savedPath !== null;
     } catch (error) {
       setActionError(
-        error instanceof Error
-          ? error.message
-          : t("toolbar.error.couldNotExportHtml")
+        error instanceof Error ? error.message : t("toolbar.error.couldNotExportHtml"),
       );
       return false;
     } finally {
diff --git a/apps/geolibre-desktop/src/lib/qgis-project-import.ts b/apps/geolibre-desktop/src/lib/qgis-project-import.ts
index 0882bf7a1..0b815bccf 100644
--- a/apps/geolibre-desktop/src/lib/qgis-project-import.ts
+++ b/apps/geolibre-desktop/src/lib/qgis-project-import.ts
@@ -57,7 +57,7 @@ export interface QgisRasterImport {
  */
 export async function materializeQgisRemoteLayers(
   result: QgisProjectImportResult,
-  fetcher: typeof fetch = fetch
+  fetcher: typeof fetch = fetch,
 ): Promise<QgisProjectImportResult> {
   const failedLayerIds = new Set<string>();
   await Promise.all(
@@ -78,19 +78,15 @@ export async function materializeQgisRemoteLayers(
           reason: "remote-file",
         });
       }
-    })
+    }),
   );
   if (failedLayerIds.size > 0) {
-    result.project.layers = result.project.layers.filter(
-      (layer) => !failedLayerIds.has(layer.id)
-    );
+    result.project.layers = result.project.layers.filter((layer) => !failedLayerIds.has(layer.id));
     const usedGroupIds = new Set(
-      result.project.layers.flatMap((layer) =>
-        layer.groupId ? [layer.groupId] : []
-      )
+      result.project.layers.flatMap((layer) => (layer.groupId ? [layer.groupId] : [])),
     );
     result.project.layerGroups = result.project.layerGroups?.filter((group) =>
-      usedGroupIds.has(group.id)
+      usedGroupIds.has(group.id),
     );
   }
   return result;
@@ -120,35 +116,25 @@ const SUPPORTED_RASTER_EXTENSIONS = new Set(["tif", "tiff"]);
 /** Convert a QGIS project into a GeoLibre project without evaluating QGIS code. */
 export function importQgisProject(
   data: ArrayBuffer | Uint8Array | string,
-  sourcePath: string
+  sourcePath: string,
 ): QgisProjectImportResult {
   const xml = qgisProjectXml(data, sourcePath);
   const document = new DOMParser().parseFromString(xml, "application/xml");
-  if (
-    document.querySelector("parsererror") ||
-    document.documentElement.tagName !== "qgis"
-  ) {
+  if (document.querySelector("parsererror") || document.documentElement.tagName !== "qgis") {
     throw new Error("This file is not a valid QGIS project.");
   }
 
   const projectName =
-    text(document.querySelector("title")) ||
-    fileStem(sourcePath) ||
-    "Imported QGIS Project";
+    text(document.querySelector("title")) || fileStem(sourcePath) || "Imported QGIS Project";
   const project = createEmptyProject(projectName, {
     mapView: parseMapView(document),
   });
   const parsedGroups = parseLayerGroups(document);
   const groupByLayerId = layerGroupAssignments(document, parsedGroups.ids);
   const visibilityByLayerId = layerVisibility(document);
-  const mapLayers = Array.from(
-    document.querySelectorAll("projectlayers > maplayer")
-  );
+  const mapLayers = Array.from(document.querySelectorAll("projectlayers > maplayer"));
   const byId = new Map(
-    mapLayers.map((element) => [
-      text(element.querySelector(":scope > id")),
-      element,
-    ])
+    mapLayers.map((element) => [text(element.querySelector(":scope > id")), element]),
   );
   const warnings: QgisProjectImportWarning[] = [];
   const layers: GeoLibreLayer[] = [];
@@ -157,11 +143,8 @@ export function importQgisProject(
   for (const id of layerOrder(document, mapLayers)) {
     const element = byId.get(id);
     if (!element) continue;
-    const name =
-      text(element.querySelector(":scope > layername")) || id || "QGIS layer";
-    const provider = text(
-      element.querySelector(":scope > provider")
-    ).toLowerCase();
+    const name = text(element.querySelector(":scope > layername")) || id || "QGIS layer";
+    const provider = text(element.querySelector(":scope > provider")).toLowerCase();
     const dataSource = text(element.querySelector(":scope > datasource"));
 
     if (isOpenStreetMapBasemap(element, provider, dataSource)) {
@@ -219,7 +202,7 @@ export function importQgisProject(
 
   project.layers = layers;
   project.layerGroups = parsedGroups.groups.filter((group) =>
-    layers.some((layer) => layer.groupId === group.id)
+    layers.some((layer) => layer.groupId === group.id),
   );
   project.metadata = {
     importedFrom: "qgis",
@@ -233,8 +216,7 @@ function parseRasterState(element: Element): QgisRasterImport["state"] {
   const renderer = element.querySelector(":scope > pipe > rasterrenderer");
   if (!renderer) return undefined;
   const type = renderer.getAttribute("type")?.toLowerCase();
-  if (type !== "singlebandpseudocolor" && type !== "singlebandgray")
-    return undefined;
+  if (type !== "singlebandpseudocolor" && type !== "singlebandgray") return undefined;
 
   const band = positiveInteger(renderer.getAttribute("band")) ?? 1;
   const shader = renderer.querySelector("rastershader > colorrampshader");
@@ -245,15 +227,11 @@ function parseRasterState(element: Element): QgisRasterImport["state"] {
   const last = qgisRampColor(ramp, "color2");
   const matched = matchBuiltInColorRamp(first, last);
   const gamma =
-    numberAttribute(
-      element.querySelector(":scope > pipe > brightnesscontrast"),
-      "gamma"
-    ) ?? 1;
+    numberAttribute(element.querySelector(":scope > pipe > brightnesscontrast"), "gamma") ?? 1;
 
   return {
     bands: [band],
-    colormap:
-      type === "singlebandgray" ? "gray" : matched?.colormap ?? "viridis",
+    colormap: type === "singlebandgray" ? "gray" : (matched?.colormap ?? "viridis"),
     gamma: gamma > 0 ? gamma : 1,
     rescale:
       Number.isFinite(minimum) && Number.isFinite(maximum) && minimum < maximum
@@ -263,42 +241,33 @@ function parseRasterState(element: Element): QgisRasterImport["state"] {
   };
 }
 
-function qgisRampColor(
-  ramp: Element | null | undefined,
-  name: string
-): string | null {
+function qgisRampColor(ramp: Element | null | undefined, name: string): string | null {
   const option = Array.from(ramp?.querySelectorAll("Option") ?? []).find(
-    (candidate) => candidate.getAttribute("name") === name
+    (candidate) => candidate.getAttribute("name") === name,
   );
   const channels = option?.getAttribute("value")?.split(",", 3).map(Number);
-  if (
-    !channels ||
-    channels.length !== 3 ||
-    channels.some((value) => !Number.isFinite(value))
-  ) {
+  if (!channels || channels.length !== 3 || channels.some((value) => !Number.isFinite(value))) {
     return null;
   }
   return `#${channels
     .map((value) =>
       Math.max(0, Math.min(255, Math.round(value)))
         .toString(16)
-        .padStart(2, "0")
+        .padStart(2, "0"),
     )
     .join("")}`;
 }
 
 function matchBuiltInColorRamp(
   first: string | null,
-  last: string | null
+  last: string | null,
 ): { colormap: string; reversed: boolean } | null {
   if (!first || !last) return null;
   for (const ramp of VECTOR_COLOR_RAMPS) {
     const start = ramp.colors[0].toLowerCase();
     const end = ramp.colors[ramp.colors.length - 1].toLowerCase();
-    if (first === start && last === end)
-      return { colormap: ramp.value, reversed: false };
-    if (first === end && last === start)
-      return { colormap: ramp.value, reversed: true };
+    if (first === start && last === end) return { colormap: ramp.value, reversed: false };
+    if (first === end && last === start) return { colormap: ramp.value, reversed: true };
   }
   return null;
 }
@@ -308,20 +277,14 @@ function positiveInteger(value: string | null): number | null {
   return Number.isInteger(parsed) && parsed > 0 ? parsed : null;
 }
 
-function numberAttribute(
-  element: Element | null | undefined,
-  name: string
-): number {
+function numberAttribute(element: Element | null | undefined, name: string): number {
   const raw = element?.getAttribute(name);
   if (raw == null || raw.trim() === "") return Number.NaN;
   const value = Number(raw);
   return Number.isFinite(value) ? value : Number.NaN;
 }
 
-function qgisProjectXml(
-  data: ArrayBuffer | Uint8Array | string,
-  sourcePath: string
-): string {
+function qgisProjectXml(data: ArrayBuffer | Uint8Array | string, sourcePath: string): string {
   if (typeof data === "string") return data;
   const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
   if (sourcePath.toLowerCase().endsWith(".qgs")) return strFromU8(bytes);
@@ -331,11 +294,8 @@ function qgisProjectXml(
   } catch {
     throw new Error("Could not read the compressed QGIS project.");
   }
-  const qgsName = Object.keys(entries).find((name) =>
-    name.toLowerCase().endsWith(".qgs")
-  );
-  if (!qgsName)
-    throw new Error("The QGZ archive does not contain a QGS project file.");
+  const qgsName = Object.keys(entries).find((name) => name.toLowerCase().endsWith(".qgs"));
+  if (!qgsName) throw new Error("The QGZ archive does not contain a QGS project file.");
   return strFromU8(entries[qgsName]);
 }
 
@@ -368,34 +328,20 @@ function parseMapView(document: Document): MapViewState {
   return { center: [-100, 40], zoom: 2, bearing: 0, pitch: 0 };
 }
 
-function toWgs84(
-  x: number,
-  y: number,
-  authId: string
-): [number, number] | null {
+function toWgs84(x: number, y: number, authId: string): [number, number] | null {
   const normalized = authId.toUpperCase();
   if (normalized === "EPSG:4326" || normalized === "CRS:84") return [x, y];
   if (normalized === "EPSG:3857") {
     return [
       (x / 20037508.34) * 180,
-      (180 / Math.PI) *
-        (2 * Math.atan(Math.exp((y / 20037508.34) * Math.PI)) - Math.PI / 2),
+      (180 / Math.PI) * (2 * Math.atan(Math.exp((y / 20037508.34) * Math.PI)) - Math.PI / 2),
     ];
   }
   return null;
 }
 
-function zoomForBounds(
-  west: number,
-  south: number,
-  east: number,
-  north: number
-): number {
-  const span = Math.max(
-    Math.abs(east - west),
-    Math.abs(north - south) * 2,
-    0.000001
-  );
+function zoomForBounds(west: number, south: number, east: number, north: number): number {
+  const span = Math.max(Math.abs(east - west), Math.abs(north - south) * 2, 0.000001);
   return Math.max(0, Math.min(20, Math.log2(360 / span) - 0.75));
 }
 
@@ -406,20 +352,18 @@ function parseLayerGroups(document: Document): {
   const root = document.querySelector("layer-tree-group");
   if (!root) return { groups: [], ids: new Map() };
   const ids = new Map<Element, string>();
-  const groups = Array.from(root.querySelectorAll("layer-tree-group")).map(
-    (element, index) => {
-      const name = groupDisplayName(element, root);
-      const id = `qgis-group-${index}-${slug(name)}`;
-      ids.set(element, id);
-      return {
-        id,
-        name,
-        collapsed: element.getAttribute("expanded") === "0",
-        visible: element.getAttribute("checked") !== "Qt::Unchecked",
-        opacity: 1,
-      };
-    }
-  );
+  const groups = Array.from(root.querySelectorAll("layer-tree-group")).map((element, index) => {
+    const name = groupDisplayName(element, root);
+    const id = `qgis-group-${index}-${slug(name)}`;
+    ids.set(element, id);
+    return {
+      id,
+      name,
+      collapsed: element.getAttribute("expanded") === "0",
+      visible: element.getAttribute("checked") !== "Qt::Unchecked",
+      opacity: 1,
+    };
+  });
   return { groups, ids };
 }
 
@@ -434,10 +378,7 @@ function groupDisplayName(element: Element, root: Element): string {
   return names.join(" / ") || "Group";
 }
 
-function layerGroupAssignments(
-  document: Document,
-  ids: Map<Element, string>
-): Map<string, string> {
+function layerGroupAssignments(document: Document, ids: Map<Element, string>): Map<string, string> {
   const assignments = new Map<string, string>();
   document.querySelectorAll("layer-tree-layer[id]").forEach((layer) => {
     const layerId = layer.getAttribute("id");
@@ -479,8 +420,7 @@ function qgisSourcePath(dataSource: string, projectPath: string): string {
     }
   }
   source = source.replace(/^['"]|['"]$/g, "");
-  if (!source || isAbsolutePath(source) || /^[a-z]+:\/\//i.test(source))
-    return source;
+  if (!source || isAbsolutePath(source) || /^[a-z]+:\/\//i.test(source)) return source;
   const directory = projectPath.replace(/[/\\][^/\\]*$/, "");
   return normalizeJoinedPath(directory, source);
 }
@@ -505,11 +445,7 @@ function normalizeJoinedPath(directory: string, relative: string): string {
   return `${absolute ? "/" : ""}${normalized.join(separator)}`;
 }
 
-function isSupportedVectorLayer(
-  element: Element,
-  provider: string,
-  source: string
-): boolean {
+function isSupportedVectorLayer(element: Element, provider: string, source: string): boolean {
   return (
     element.getAttribute("type")?.toLowerCase() === "vector" &&
     (provider === "ogr" || provider === "delimitedtext") &&
@@ -518,11 +454,7 @@ function isSupportedVectorLayer(
   );
 }
 
-function isSupportedRasterLayer(
-  element: Element,
-  provider: string,
-  source: string
-): boolean {
+function isSupportedRasterLayer(element: Element, provider: string, source: string): boolean {
   return (
     element.getAttribute("type")?.toLowerCase() === "raster" &&
     provider === "gdal" &&
@@ -532,15 +464,8 @@ function isSupportedRasterLayer(
   );
 }
 
-function isOpenStreetMapBasemap(
-  element: Element,
-  provider: string,
-  dataSource: string
-): boolean {
-  if (
-    element.getAttribute("type")?.toLowerCase() !== "raster" ||
-    provider !== "wms"
-  ) {
+function isOpenStreetMapBasemap(element: Element, provider: string, dataSource: string): boolean {
+  if (element.getAttribute("type")?.toLowerCase() !== "raster" || provider !== "wms") {
     return false;
   }
   const params = new URLSearchParams(dataSource);
@@ -549,10 +474,7 @@ function isOpenStreetMapBasemap(
   if (!tileUrl) return false;
   try {
     const host = new URL(tileUrl).hostname.toLowerCase();
-    return (
-      host === "tile.openstreetmap.org" ||
-      /^[abc]\.tile\.openstreetmap\.org$/.test(host)
-    );
+    return host === "tile.openstreetmap.org" || /^[abc]\.tile\.openstreetmap\.org$/.test(host);
   } catch {
     return false;
   }
@@ -561,7 +483,7 @@ function isOpenStreetMapBasemap(
 function unsupportedReason(
   element: Element,
   provider: string,
-  source: string
+  source: string,
 ): QgisProjectImportWarning["reason"] {
   if (element.getAttribute("type")?.toLowerCase() !== "vector") {
     return "non-vector";
@@ -579,15 +501,10 @@ function parseLayerStyle(element: Element): LayerStyle {
   const symbolLayer = element.querySelector("renderer-v2 symbols symbol layer");
   const options = new Map<string, string>();
   symbolLayer?.querySelectorAll("Option[name]").forEach((option) => {
-    options.set(
-      option.getAttribute("name") ?? "",
-      option.getAttribute("value") ?? ""
-    );
+    options.set(option.getAttribute("name") ?? "", option.getAttribute("value") ?? "");
   });
   const fill = qgisColor(options.get("color"));
-  const stroke = qgisColor(
-    options.get("outline_color") ?? options.get("line_color")
-  );
+  const stroke = qgisColor(options.get("outline_color") ?? options.get("line_color"));
   if (fill) {
     style.fillColor = fill.color;
     style.fillOpacity = fill.opacity;
@@ -596,48 +513,36 @@ function parseLayerStyle(element: Element): LayerStyle {
   if (stroke) {
     style.strokeColor = stroke.color;
   }
-  const width = optionalNumber(
-    options.get("outline_width") ?? options.get("line_width")
-  );
+  const width = optionalNumber(options.get("outline_width") ?? options.get("line_width"));
   if (width !== null) style.strokeWidth = Math.max(0, width * 3.78);
   const size = optionalNumber(options.get("size"));
   if (symbolLayer?.getAttribute("class") === "SimpleMarker" && size !== null) {
     style.circleRadius = Math.max(1, (size * 3.78) / 2);
   }
-  const textStyle = element.querySelector(
-    "labeling[type='simple'] settings text-style"
-  );
+  const textStyle = element.querySelector("labeling[type='simple'] settings text-style");
   const field = textStyle?.getAttribute("fieldName")?.trim();
   if (field) {
     style.labels.enabled = true;
     style.labels.field = field;
     const color = qgisColor(textStyle?.getAttribute("textColor") ?? undefined);
     if (color) style.labels.color = color.color;
-    const sizeValue = optionalNumber(
-      textStyle?.getAttribute("fontSize") ?? undefined
-    );
+    const sizeValue = optionalNumber(textStyle?.getAttribute("fontSize") ?? undefined);
     if (sizeValue !== null) style.labels.size = sizeValue;
   }
   return style;
 }
 
-function qgisColor(
-  value: string | undefined
-): { color: string; opacity: number } | null {
+function qgisColor(value: string | undefined): { color: string; opacity: number } | null {
   if (!value) return null;
   const parts = value.split(",").map(Number);
-  if (
-    parts.length < 3 ||
-    parts.slice(0, 3).some((part) => !Number.isFinite(part))
-  )
-    return null;
+  if (parts.length < 3 || parts.slice(0, 3).some((part) => !Number.isFinite(part))) return null;
   const [red, green, blue, alpha = 255] = parts;
   return {
     color: `#${[red, green, blue]
       .map((part) =>
         Math.max(0, Math.min(255, Math.round(part)))
           .toString(16)
-          .padStart(2, "0")
+          .padStart(2, "0"),
       )
       .join("")}`,
     opacity: Math.max(0, Math.min(1, alpha / 255)),
@@ -645,9 +550,7 @@ function qgisColor(
 }
 
 function parseOpacity(element: Element): number {
-  const value = optionalNumber(
-    text(element.querySelector(":scope > layerOpacity"))
-  );
+  const value = optionalNumber(text(element.querySelector(":scope > layerOpacity")));
   return value !== null ? Math.max(0, Math.min(1, value)) : 1;
 }
 
@@ -684,11 +587,7 @@ function fileStem(path: string): string {
 }
 
 function isAbsolutePath(path: string): boolean {
-  return (
-    path.startsWith("/") ||
-    path.startsWith("\\\\") ||
-    /^[A-Za-z]:[/\\]/.test(path)
-  );
+  return path.startsWith("/") || path.startsWith("\\\\") || /^[A-Za-z]:[/\\]/.test(path);
 }
 
 function isHttpSource(path: string): boolean {
diff --git a/tests/qgis-project-import.test.ts b/tests/qgis-project-import.test.ts
index 03890cd02..50645870c 100644
--- a/tests/qgis-project-import.test.ts
+++ b/tests/qgis-project-import.test.ts
@@ -14,7 +14,7 @@ function projectXml(
     authId?: string;
     extent?: string;
     dataSources?: Array<{ id: string; name: string; source: string }>;
-  } = {}
+  } = {},
 ): string {
   const dataSources = options.dataSources ?? [
     { id: "roads", name: "Roads", source: "../data/roads.geojson" },
@@ -43,7 +43,7 @@ function projectXml(
           <labeling type="simple">
             <settings><text-style fieldName="name" fontSize="12"/></settings>
           </labeling>
-        </maplayer>`
+        </maplayer>`,
     )
     .join("");
 
@@ -119,20 +119,17 @@ function osmBasemapProjectXml(): string {
 
 describe("QGIS project import", () => {
   it("imports vector layers, styles, visibility, nested groups, extent, and relative paths", () => {
-    const result = importQgisProject(
-      projectXml(),
-      "/work/projects/example.qgs"
-    );
+    const result = importQgisProject(projectXml(), "/work/projects/example.qgs");
 
     assert.equal(result.project.name, "Imported map");
     assert.deepEqual(result.project.mapView.center, [-95.5, 37]);
     assert.deepEqual(
       result.project.layerGroups?.map((group) => group.name),
-      ["Transport", "Transport / Places"]
+      ["Transport", "Transport / Places"],
     );
     assert.deepEqual(
       result.project.layers.map((layer) => layer.name),
-      ["Cities", "Roads"]
+      ["Cities", "Roads"],
     );
 
     const cities = result.project.layers[0];
@@ -158,10 +155,7 @@ describe("QGIS project import", () => {
   });
 
   it("collects local GDAL GeoTIFFs for the desktop raster loader", () => {
-    const result = importQgisProject(
-      rasterProjectXml(),
-      "/work/projects/example.qgz"
-    );
+    const result = importQgisProject(rasterProjectXml(), "/work/projects/example.qgz");
 
     assert.deepEqual(result.project.layers, []);
     assert.deepEqual(result.rasters, [
@@ -184,15 +178,9 @@ describe("QGIS project import", () => {
   });
 
   it("maps QGIS OpenStreetMap XYZ layers to the built-in basemap", () => {
-    const result = importQgisProject(
-      osmBasemapProjectXml(),
-      "/work/example.qgs"
-    );
+    const result = importQgisProject(osmBasemapProjectXml(), "/work/example.qgs");
 
-    assert.equal(
-      result.project.basemapStyleUrl,
-      "https://tiles.openfreemap.org/styles/liberty"
-    );
+    assert.equal(result.project.basemapStyleUrl, "https://tiles.openfreemap.org/styles/liberty");
     assert.equal(result.project.basemapVisible, false);
     assert.equal(result.project.basemapOpacity, 0.7);
     assert.deepEqual(result.project.layers, []);
@@ -201,10 +189,7 @@ describe("QGIS project import", () => {
   });
 
   it("falls back to the default view for a missing or unsupported-CRS extent", () => {
-    const missing = importQgisProject(
-      projectXml({ extent: "" }),
-      "/work/example.qgs"
-    );
+    const missing = importQgisProject(projectXml({ extent: "" }), "/work/example.qgs");
     assert.deepEqual(missing.project.mapView, {
       center: [-100, 40],
       zoom: 2,
@@ -212,10 +197,7 @@ describe("QGIS project import", () => {
       pitch: 0,
     });
 
-    const projected = importQgisProject(
-      projectXml({ authId: "EPSG:32618" }),
-      "/work/example.qgs"
-    );
+    const projected = importQgisProject(projectXml({ authId: "EPSG:32618" }), "/work/example.qgs");
     assert.deepEqual(projected.project.mapView, {
       center: [-100, 40],
       zoom: 2,
@@ -231,8 +213,7 @@ describe("QGIS project import", () => {
           {
             id: "roads",
             name: "Remote",
-            source:
-              "/vsicurl/https://example.com/roads.geojson|layername=roads",
+            source: "/vsicurl/https://example.com/roads.geojson|layername=roads",
           },
           {
             id: "cities",
@@ -241,25 +222,16 @@ describe("QGIS project import", () => {
           },
         ],
       }),
-      "C:\\projects\\example.qgs"
+      "C:\\projects\\example.qgs",
     );
 
     assert.equal(result.project.layers.length, 1);
-    assert.equal(
-      result.project.layers[0].sourcePath,
-      "https://example.com/roads.geojson"
-    );
-    assert.equal(
-      result.project.layers[0].source.url,
-      "https://example.com/roads.geojson"
-    );
-    assert.equal(
-      result.project.layers[0].metadata.localFileReloadable,
-      undefined
-    );
+    assert.equal(result.project.layers[0].sourcePath, "https://example.com/roads.geojson");
+    assert.equal(result.project.layers[0].source.url, "https://example.com/roads.geojson");
+    assert.equal(result.project.layers[0].metadata.localFileReloadable, undefined);
     assert.deepEqual(
       result.warnings.map((warning) => [warning.layerName, warning.reason]),
-      [["Network", "network-path"]]
+      [["Network", "network-path"]],
     );
   });
 
@@ -279,18 +251,15 @@ describe("QGIS project import", () => {
           },
         ],
       }),
-      "/work/example.qgs"
+      "/work/example.qgs",
     );
 
     await materializeQgisRemoteLayers(result, async (input) => {
       const url = String(input);
-      if (url.endsWith("/bad.geojson"))
-        return new Response("no", { status: 404 });
+      if (url.endsWith("/bad.geojson")) return new Response("no", { status: 404 });
       return Response.json({
         type: "FeatureCollection",
-        features: [
-          { type: "Feature", geometry: null, properties: { name: "Test" } },
-        ],
+        features: [{ type: "Feature", geometry: null, properties: { name: "Test" } }],
       });
     });
 
@@ -299,7 +268,7 @@ describe("QGIS project import", () => {
     assert.equal(result.project.layers[0].geojson?.features.length, 1);
     assert.deepEqual(
       result.warnings.map((warning) => [warning.layerName, warning.reason]),
-      [["Bad", "remote-file"]]
+      [["Bad", "remote-file"]],
     );
   });
 });

From 5cf2bea8c457ad99326c92d369ab6c05025450af Mon Sep 17 00:00:00 2001
From: giswqs <giswqs@gmail.com>
Date: Thu, 30 Jul 2026 23:45:07 -0400
Subject: [PATCH 11/19] fix(qgis): await imported basemap before raster attach

---
 .../src/hooks/useProjectFileActions.ts        | 27 ++++++++++++++++---
 1 file changed, 23 insertions(+), 4 deletions(-)

diff --git a/apps/geolibre-desktop/src/hooks/useProjectFileActions.ts b/apps/geolibre-desktop/src/hooks/useProjectFileActions.ts
index 6795e77b9..2d9462c71 100644
--- a/apps/geolibre-desktop/src/hooks/useProjectFileActions.ts
+++ b/apps/geolibre-desktop/src/hooks/useProjectFileActions.ts
@@ -113,9 +113,24 @@ function isReloadableLocalFileLayer(layer: GeoLibreLayer): boolean {
  * the outgoing style. Its store entry survives, but the native raster source
  * is removed by the pending style/layer update.
  */
-async function waitForImportedProjectMap(): Promise<void> {
-  await new Promise<void>((resolve) => requestAnimationFrame(() => resolve()));
-  await new Promise<void>((resolve) => requestAnimationFrame(() => resolve()));
+function importedProjectMapReady(
+  mapControllerRef: MapControllerRef,
+  basemapWillChange: boolean
+): Promise<void> {
+  const map = mapControllerRef.current?.getMap();
+  const styleReady =
+    map && basemapWillChange
+      ? new Promise<void>((resolve) => map.once("style.load", () => resolve()))
+      : Promise.resolve();
+
+  return (async () => {
+    // Let the project store update commit and its MapCanvas effects run first.
+    // Register the style listener above (before loadProject) so a fast inline
+    // style cannot finish between the store update and this wait.
+    await new Promise<void>((resolve) => requestAnimationFrame(() => resolve()));
+    await new Promise<void>((resolve) => requestAnimationFrame(() => resolve()));
+    await styleReady;
+  })();
 }
 
 /**
@@ -197,9 +212,13 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
           });
         }
       }
+      const mapReady = importedProjectMapReady(
+        mapControllerRef,
+        useAppStore.getState().basemapStyleUrl !== imported.project.basemapStyleUrl
+      );
       loadProject(imported.project, null);
       if (isTauri()) {
-        await waitForImportedProjectMap();
+        await mapReady;
         const app = createAppAPI(mapControllerRef);
         for (const raster of imported.rasters) {
           try {

From 2ddcc03af18e78ec39c97c02d0050423ff8aa4e2 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Fri, 31 Jul 2026 03:45:57 +0000
Subject: [PATCH 12/19] style: auto-format (ruff + oxfmt) [pre-commit.ci]

---
 apps/geolibre-desktop/src/hooks/useProjectFileActions.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/apps/geolibre-desktop/src/hooks/useProjectFileActions.ts b/apps/geolibre-desktop/src/hooks/useProjectFileActions.ts
index 2d9462c71..ccdf4fcfb 100644
--- a/apps/geolibre-desktop/src/hooks/useProjectFileActions.ts
+++ b/apps/geolibre-desktop/src/hooks/useProjectFileActions.ts
@@ -115,7 +115,7 @@ function isReloadableLocalFileLayer(layer: GeoLibreLayer): boolean {
  */
 function importedProjectMapReady(
   mapControllerRef: MapControllerRef,
-  basemapWillChange: boolean
+  basemapWillChange: boolean,
 ): Promise<void> {
   const map = mapControllerRef.current?.getMap();
   const styleReady =
@@ -214,7 +214,7 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
       }
       const mapReady = importedProjectMapReady(
         mapControllerRef,
-        useAppStore.getState().basemapStyleUrl !== imported.project.basemapStyleUrl
+        useAppStore.getState().basemapStyleUrl !== imported.project.basemapStyleUrl,
       );
       loadProject(imported.project, null);
       if (isTauri()) {

From 4583574e7834e211cee928f010e9d4d799c997a8 Mon Sep 17 00:00:00 2001
From: giswqs <giswqs@gmail.com>
Date: Thu, 30 Jul 2026 23:48:49 -0400
Subject: [PATCH 13/19] fix(raster): warm Tauri WASM engine before each add

---
 packages/plugins/src/plugins/maplibre-raster.ts | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/packages/plugins/src/plugins/maplibre-raster.ts b/packages/plugins/src/plugins/maplibre-raster.ts
index 55f96caa6..7bc806395 100644
--- a/packages/plugins/src/plugins/maplibre-raster.ts
+++ b/packages/plugins/src/plugins/maplibre-raster.ts
@@ -350,6 +350,12 @@ export async function addRasterToMap(
   if (options.defaults?.engine && control.getEngine() !== options.defaults.engine) {
     control.setEngine(options.defaults.engine);
   }
+  // A project/basemap load can replace the MapLibre style after the control's
+  // one-time mount warm-up. On Tauri/WebKitGTK that leaves the WASM backend
+  // waiting for an accelerated canvas until the user manually switches to the
+  // GPU engine and back. Repeat that inexpensive toggle at the add boundary,
+  // against the current style, before the COG source starts opening.
+  await warmTauriWasmEngine(control);
   const id = await control.addRaster(source, {
     name: options.name,
     zoomTo: options.zoomTo ?? true,

From fae6e14fdc52ef3cd307e000e6642ac9be227e7b Mon Sep 17 00:00:00 2001
From: giswqs <giswqs@gmail.com>
Date: Thu, 30 Jul 2026 23:50:50 -0400
Subject: [PATCH 14/19] fix(raster): reset Tauri WASM after layer registration

---
 .../plugins/src/plugins/maplibre-raster.ts     | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

diff --git a/packages/plugins/src/plugins/maplibre-raster.ts b/packages/plugins/src/plugins/maplibre-raster.ts
index 7bc806395..466e5e34e 100644
--- a/packages/plugins/src/plugins/maplibre-raster.ts
+++ b/packages/plugins/src/plugins/maplibre-raster.ts
@@ -350,12 +350,6 @@ export async function addRasterToMap(
   if (options.defaults?.engine && control.getEngine() !== options.defaults.engine) {
     control.setEngine(options.defaults.engine);
   }
-  // A project/basemap load can replace the MapLibre style after the control's
-  // one-time mount warm-up. On Tauri/WebKitGTK that leaves the WASM backend
-  // waiting for an accelerated canvas until the user manually switches to the
-  // GPU engine and back. Repeat that inexpensive toggle at the add boundary,
-  // against the current style, before the COG source starts opening.
-  await warmTauriWasmEngine(control);
   const id = await control.addRaster(source, {
     name: options.name,
     zoomTo: options.zoomTo ?? true,
@@ -371,6 +365,12 @@ export async function addRasterToMap(
       : {}),
     ...(options.beforeId ? { beforeId: options.beforeId } : {}),
   });
+  // A project/basemap load can replace the MapLibre style after the control's
+  // one-time mount warm-up. On Tauri/WebKitGTK the newly registered WASM source
+  // can then remain pending until the user switches to the GPU engine and back.
+  // Do that reset only after addRaster has created the layer, so switching back
+  // rebuilds the real source rather than an empty renderer.
+  await warmTauriWasmEngine(control);
   applyRgbBandDefaults(control, id, options.defaults?.rgbBands);
   if (options.localPath) {
     // The id only exists once addRaster resolves, which is after the rasteradd
@@ -946,6 +946,12 @@ async function warmTauriWasmEngine(control: RasterControl): Promise<void> {
 
   try {
     control.setEngine("maplibre-gl-raster");
+    // `_device` may still point at the canvas created for the outgoing style.
+    // Give the GPU engine a paint against the current style even when that
+    // field is already populated; switching back in the same task is too early
+    // to reproduce the user-visible engine toggle that releases WebKitGTK.
+    await new Promise<void>((resolve) => requestAnimationFrame(() => resolve()));
+    await new Promise<void>((resolve) => requestAnimationFrame(() => resolve()));
     const deadline = performance.now() + 2_000;
     while (!manager._device && performance.now() < deadline) {
       await new Promise<void>((resolve) => window.setTimeout(resolve, 16));

From 8d7ca4a4b8b168fb5c38e69d2afdaf9319fa59e9 Mon Sep 17 00:00:00 2001
From: giswqs <giswqs@gmail.com>
Date: Thu, 30 Jul 2026 23:54:22 -0400
Subject: [PATCH 15/19] fix(raster): reset WASM after source registration

---
 .../plugins/src/plugins/maplibre-raster.ts    | 26 +++++++++++++++++++
 1 file changed, 26 insertions(+)

diff --git a/packages/plugins/src/plugins/maplibre-raster.ts b/packages/plugins/src/plugins/maplibre-raster.ts
index 466e5e34e..7a8a50aeb 100644
--- a/packages/plugins/src/plugins/maplibre-raster.ts
+++ b/packages/plugins/src/plugins/maplibre-raster.ts
@@ -126,6 +126,9 @@ type RasterLayerManagerInternals = {
   /** The currently selected raster id (read to restore it after inspect). */
   selectedId?: string | null;
   _device?: unknown;
+  _cogEngine?: {
+    _sources?: Map<string, { source?: unknown }>;
+  } | null;
   _deps?: {
     createOverlay?: (map: MapControlHost, options: OverlayFactoryOptions) => OverlayLike;
     removeOverlay?: (map: MapControlHost, overlay: OverlayLike) => void;
@@ -370,6 +373,7 @@ export async function addRasterToMap(
   // can then remain pending until the user switches to the GPU engine and back.
   // Do that reset only after addRaster has created the layer, so switching back
   // rebuilds the real source rather than an empty renderer.
+  await waitForTauriWasmLayerRegistration(control, id);
   await warmTauriWasmEngine(control);
   applyRgbBandDefaults(control, id, options.defaults?.rgbBands);
   if (options.localPath) {
@@ -961,6 +965,28 @@ async function warmTauriWasmEngine(control: RasterControl): Promise<void> {
   }
 }
 
+/**
+ * Wait until the lazy WASM engine has received the newly added raster.
+ *
+ * `RasterControl.addRaster()` resolves when the GeoTIFF header is available,
+ * before `cog-tiler-wasm` necessarily finishes loading and creates its source
+ * entry. Resetting engines before that point only rebuilds an empty WASM
+ * renderer; the later source can still stall until the user toggles the panel.
+ */
+async function waitForTauriWasmLayerRegistration(
+  control: RasterControl,
+  layerId: string,
+): Promise<void> {
+  if (!isTauriRuntime() || control.getEngine() !== "cog-tiler-wasm") return;
+
+  const manager = (control as unknown as RasterControlInternals)._layerManager;
+  const deadline = performance.now() + 2_000;
+  while (performance.now() < deadline) {
+    if (manager?._cogEngine?._sources?.has(layerId)) return;
+    await new Promise<void>((resolve) => window.setTimeout(resolve, 16));
+  }
+}
+
 /**
  * On web the raster control renders interleaved, so its deck.gl overlay reuses
  * deck.gl's single per-map Deck (`map.__deck`) -- and each interleaved overlay's

From 7f12817c788dd5afb2edea2a080db93d69f54200 Mon Sep 17 00:00:00 2001
From: giswqs <giswqs@gmail.com>
Date: Fri, 31 Jul 2026 00:15:43 -0400
Subject: [PATCH 16/19] fix(qgis): render imported rasters with GPU backend

---
 .../src/hooks/useProjectFileActions.ts        |  5 +++
 .../src/lib/qgis-project-import.ts            |  2 +
 .../plugins/src/plugins/maplibre-raster.ts    | 38 -------------------
 tests/qgis-project-import.test.ts             |  1 +
 4 files changed, 8 insertions(+), 38 deletions(-)

diff --git a/apps/geolibre-desktop/src/hooks/useProjectFileActions.ts b/apps/geolibre-desktop/src/hooks/useProjectFileActions.ts
index ccdf4fcfb..9f54bc5b7 100644
--- a/apps/geolibre-desktop/src/hooks/useProjectFileActions.ts
+++ b/apps/geolibre-desktop/src/hooks/useProjectFileActions.ts
@@ -229,6 +229,11 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
             await addRasterToMap(app, loaded.source, {
               name: raster.name,
               localPath: raster.sourcePath,
+              // The Tauri/WebKitGTK WASM backend can stall when its first
+              // source is created immediately after a project style load.
+              // GPU renders this local COG directly and preserves the imported
+              // QGIS ramp, so use the verified backend for project imports.
+              defaults: { engine: "maplibre-gl-raster" },
               state: {
                 ...raster.state,
                 visible: raster.visible,
diff --git a/apps/geolibre-desktop/src/lib/qgis-project-import.ts b/apps/geolibre-desktop/src/lib/qgis-project-import.ts
index 0b815bccf..b5859f986 100644
--- a/apps/geolibre-desktop/src/lib/qgis-project-import.ts
+++ b/apps/geolibre-desktop/src/lib/qgis-project-import.ts
@@ -39,6 +39,7 @@ export interface QgisRasterImport {
   visible: boolean;
   opacity: number;
   state?: {
+    mode: "single";
     bands: number[];
     colormap: string;
     gamma: number;
@@ -230,6 +231,7 @@ function parseRasterState(element: Element): QgisRasterImport["state"] {
     numberAttribute(element.querySelector(":scope > pipe > brightnesscontrast"), "gamma") ?? 1;
 
   return {
+    mode: "single",
     bands: [band],
     colormap: type === "singlebandgray" ? "gray" : (matched?.colormap ?? "viridis"),
     gamma: gamma > 0 ? gamma : 1,
diff --git a/packages/plugins/src/plugins/maplibre-raster.ts b/packages/plugins/src/plugins/maplibre-raster.ts
index 7a8a50aeb..55f96caa6 100644
--- a/packages/plugins/src/plugins/maplibre-raster.ts
+++ b/packages/plugins/src/plugins/maplibre-raster.ts
@@ -126,9 +126,6 @@ type RasterLayerManagerInternals = {
   /** The currently selected raster id (read to restore it after inspect). */
   selectedId?: string | null;
   _device?: unknown;
-  _cogEngine?: {
-    _sources?: Map<string, { source?: unknown }>;
-  } | null;
   _deps?: {
     createOverlay?: (map: MapControlHost, options: OverlayFactoryOptions) => OverlayLike;
     removeOverlay?: (map: MapControlHost, overlay: OverlayLike) => void;
@@ -368,13 +365,6 @@ export async function addRasterToMap(
       : {}),
     ...(options.beforeId ? { beforeId: options.beforeId } : {}),
   });
-  // A project/basemap load can replace the MapLibre style after the control's
-  // one-time mount warm-up. On Tauri/WebKitGTK the newly registered WASM source
-  // can then remain pending until the user switches to the GPU engine and back.
-  // Do that reset only after addRaster has created the layer, so switching back
-  // rebuilds the real source rather than an empty renderer.
-  await waitForTauriWasmLayerRegistration(control, id);
-  await warmTauriWasmEngine(control);
   applyRgbBandDefaults(control, id, options.defaults?.rgbBands);
   if (options.localPath) {
     // The id only exists once addRaster resolves, which is after the rasteradd
@@ -950,12 +940,6 @@ async function warmTauriWasmEngine(control: RasterControl): Promise<void> {
 
   try {
     control.setEngine("maplibre-gl-raster");
-    // `_device` may still point at the canvas created for the outgoing style.
-    // Give the GPU engine a paint against the current style even when that
-    // field is already populated; switching back in the same task is too early
-    // to reproduce the user-visible engine toggle that releases WebKitGTK.
-    await new Promise<void>((resolve) => requestAnimationFrame(() => resolve()));
-    await new Promise<void>((resolve) => requestAnimationFrame(() => resolve()));
     const deadline = performance.now() + 2_000;
     while (!manager._device && performance.now() < deadline) {
       await new Promise<void>((resolve) => window.setTimeout(resolve, 16));
@@ -965,28 +949,6 @@ async function warmTauriWasmEngine(control: RasterControl): Promise<void> {
   }
 }
 
-/**
- * Wait until the lazy WASM engine has received the newly added raster.
- *
- * `RasterControl.addRaster()` resolves when the GeoTIFF header is available,
- * before `cog-tiler-wasm` necessarily finishes loading and creates its source
- * entry. Resetting engines before that point only rebuilds an empty WASM
- * renderer; the later source can still stall until the user toggles the panel.
- */
-async function waitForTauriWasmLayerRegistration(
-  control: RasterControl,
-  layerId: string,
-): Promise<void> {
-  if (!isTauriRuntime() || control.getEngine() !== "cog-tiler-wasm") return;
-
-  const manager = (control as unknown as RasterControlInternals)._layerManager;
-  const deadline = performance.now() + 2_000;
-  while (performance.now() < deadline) {
-    if (manager?._cogEngine?._sources?.has(layerId)) return;
-    await new Promise<void>((resolve) => window.setTimeout(resolve, 16));
-  }
-}
-
 /**
  * On web the raster control renders interleaved, so its deck.gl overlay reuses
  * deck.gl's single per-map Deck (`map.__deck`) -- and each interleaved overlay's
diff --git a/tests/qgis-project-import.test.ts b/tests/qgis-project-import.test.ts
index 50645870c..852152e47 100644
--- a/tests/qgis-project-import.test.ts
+++ b/tests/qgis-project-import.test.ts
@@ -166,6 +166,7 @@ describe("QGIS project import", () => {
         visible: false,
         opacity: 0.6,
         state: {
+          mode: "single",
           bands: [1],
           colormap: "turbo",
           gamma: 1.2,

From 296871519449bb0f6de406d7fcf20c1da4f7ed38 Mon Sep 17 00:00:00 2001
From: giswqs <giswqs@gmail.com>
Date: Fri, 31 Jul 2026 00:24:50 -0400
Subject: [PATCH 17/19] fix(qgis): address import review feedback

---
 .../src/hooks/useProjectFileActions.ts        |  17 ++-
 .../src/lib/qgis-project-import.ts            | 103 +++++++++++++++---
 tests/qgis-project-import.test.ts             |  48 ++++++++
 3 files changed, 149 insertions(+), 19 deletions(-)

diff --git a/apps/geolibre-desktop/src/hooks/useProjectFileActions.ts b/apps/geolibre-desktop/src/hooks/useProjectFileActions.ts
index 9f54bc5b7..be785b5fd 100644
--- a/apps/geolibre-desktop/src/hooks/useProjectFileActions.ts
+++ b/apps/geolibre-desktop/src/hooks/useProjectFileActions.ts
@@ -197,14 +197,25 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
         importQgisProject(result.data, result.path),
       );
       if (!isTauri()) {
+        const unavailableLayerIds = new Set<string>();
         for (const layer of imported.project.layers) {
           if (layer.sourcePath && !isHttpUrl(layer.sourcePath)) {
+            unavailableLayerIds.add(layer.id);
             imported.warnings.push({
               layerName: layer.name,
               reason: "browser-local-file",
             });
           }
         }
+        imported.project.layers = imported.project.layers.filter(
+          (layer) => !unavailableLayerIds.has(layer.id),
+        );
+        const usedGroupIds = new Set(
+          imported.project.layers.flatMap((layer) => (layer.groupId ? [layer.groupId] : [])),
+        );
+        imported.project.layerGroups = imported.project.layerGroups?.filter((group) =>
+          usedGroupIds.has(group.id),
+        );
         for (const raster of imported.rasters) {
           imported.warnings.push({
             layerName: raster.name,
@@ -226,7 +237,7 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
               qgisProjectPath: result.path,
             });
             if (!loaded) throw new Error("Unsupported raster path");
-            await addRasterToMap(app, loaded.source, {
+            const rasterLayerId = await addRasterToMap(app, loaded.source, {
               name: raster.name,
               localPath: raster.sourcePath,
               // The Tauri/WebKitGTK WASM backend can stall when its first
@@ -239,8 +250,12 @@ export function useProjectFileActions(mapControllerRef: MapControllerRef) {
                 visible: raster.visible,
                 opacity: raster.opacity,
               },
+              beforeId: raster.beforeId,
               zoomTo: false,
             });
+            if (raster.groupId) {
+              useAppStore.getState().moveLayerToGroup(rasterLayerId, raster.groupId);
+            }
           } catch (error) {
             console.error(`Failed to import QGIS raster "${raster.name}"`, error);
             imported.warnings.push({
diff --git a/apps/geolibre-desktop/src/lib/qgis-project-import.ts b/apps/geolibre-desktop/src/lib/qgis-project-import.ts
index b5859f986..4665d7fd2 100644
--- a/apps/geolibre-desktop/src/lib/qgis-project-import.ts
+++ b/apps/geolibre-desktop/src/lib/qgis-project-import.ts
@@ -38,6 +38,8 @@ export interface QgisRasterImport {
   sourcePath: string;
   visible: boolean;
   opacity: number;
+  groupId?: string;
+  beforeId?: string;
   state?: {
     mode: "single";
     bands: number[];
@@ -48,6 +50,10 @@ export interface QgisRasterImport {
   };
 }
 
+const MAX_QGS_BYTES = 25 * 1024 * 1024;
+const REMOTE_FETCH_CONCURRENCY = 4;
+const REMOTE_FETCH_TIMEOUT_MS = 10_000;
+
 /**
  * Fetch remote GeoJSON sources referenced by a parsed QGIS project.
  *
@@ -61,12 +67,19 @@ export async function materializeQgisRemoteLayers(
   fetcher: typeof fetch = fetch,
 ): Promise<QgisProjectImportResult> {
   const failedLayerIds = new Set<string>();
-  await Promise.all(
-    result.project.layers.map(async (layer) => {
+  const remoteLayers = result.project.layers.filter(
+    (layer) => layer.sourcePath && isHttpSource(layer.sourcePath),
+  );
+  let nextIndex = 0;
+  async function worker(): Promise<void> {
+    while (nextIndex < remoteLayers.length) {
+      const layer = remoteLayers[nextIndex++];
       const sourcePath = layer.sourcePath;
-      if (!sourcePath || !isHttpSource(sourcePath)) return;
+      if (!sourcePath) continue;
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), REMOTE_FETCH_TIMEOUT_MS);
       try {
-        const response = await fetcher(sourcePath);
+        const response = await fetcher(sourcePath, { signal: controller.signal });
         if (!response.ok) throw new Error(`HTTP ${response.status}`);
         const data = (await response.json()) as unknown;
         if (!isFeatureCollection(data))
@@ -78,8 +91,13 @@ export async function materializeQgisRemoteLayers(
           layerName: layer.name,
           reason: "remote-file",
         });
+      } finally {
+        clearTimeout(timeout);
       }
-    }),
+    }
+  }
+  await Promise.all(
+    Array.from({ length: Math.min(REMOTE_FETCH_CONCURRENCY, remoteLayers.length) }, () => worker()),
   );
   if (failedLayerIds.size > 0) {
     result.project.layers = result.project.layers.filter((layer) => !failedLayerIds.has(layer.id));
@@ -93,6 +111,8 @@ export async function materializeQgisRemoteLayers(
   return result;
 }
 
+// SYNC: VECTOR_FILE_DIALOG_EXTENSIONS in tauri-io.ts and
+// RESTORABLE_VECTOR_EXTENSIONS in src-tauri/src/lib.rs.
 const SUPPORTED_VECTOR_EXTENSIONS = new Set([
   "csv",
   "dxf",
@@ -148,7 +168,11 @@ export function importQgisProject(
     const provider = text(element.querySelector(":scope > provider")).toLowerCase();
     const dataSource = text(element.querySelector(":scope > datasource"));
 
-    if (isOpenStreetMapBasemap(element, provider, dataSource)) {
+    if (
+      isOpenStreetMapBasemap(element, provider, dataSource) &&
+      !groupByLayerId.has(id) &&
+      id === layerOrder(document, mapLayers)[0]
+    ) {
       project.basemapStyleUrl = DEFAULT_BASEMAP;
       project.basemapVisible = visibilityByLayerId.get(id) ?? true;
       project.basemapOpacity = parseOpacity(element);
@@ -165,6 +189,10 @@ export function importQgisProject(
         sourcePath: source,
         visible: visibilityByLayerId.get(id) ?? true,
         opacity: parseOpacity(element),
+        ...(groupByLayerId.get(id) ? { groupId: groupByLayerId.get(id) } : {}),
+        ...(nextLayerId(id, layerOrder(document, mapLayers))
+          ? { beforeId: nextLayerId(id, layerOrder(document, mapLayers)) }
+          : {}),
         ...(state ? { state } : {}),
       });
       continue;
@@ -202,8 +230,10 @@ export function importQgisProject(
   }
 
   project.layers = layers;
-  project.layerGroups = parsedGroups.groups.filter((group) =>
-    layers.some((layer) => layer.groupId === group.id),
+  project.layerGroups = parsedGroups.groups.filter(
+    (group) =>
+      layers.some((layer) => layer.groupId === group.id) ||
+      rasters.some((raster) => raster.groupId === group.id),
   );
   project.metadata = {
     importedFrom: "qgis",
@@ -287,13 +317,26 @@ function numberAttribute(element: Element | null | undefined, name: string): num
 }
 
 function qgisProjectXml(data: ArrayBuffer | Uint8Array | string, sourcePath: string): string {
-  if (typeof data === "string") return data;
+  if (typeof data === "string") {
+    if (new TextEncoder().encode(data).byteLength > MAX_QGS_BYTES) {
+      throw new Error("The QGIS project is too large to import safely.");
+    }
+    return data;
+  }
   const bytes = data instanceof Uint8Array ? data : new Uint8Array(data);
   if (sourcePath.toLowerCase().endsWith(".qgs")) return strFromU8(bytes);
   let entries: Record<string, Uint8Array>;
   try {
-    entries = unzipSync(bytes);
-  } catch {
+    entries = unzipSync(bytes, {
+      filter: (entry) => {
+        if (entry.originalSize > MAX_QGS_BYTES) {
+          throw new Error("The QGIS project is too large to import safely.");
+        }
+        return entry.name.toLowerCase().endsWith(".qgs");
+      },
+    });
+  } catch (error) {
+    if (error instanceof Error && error.message.includes("too large to import safely")) throw error;
     throw new Error("Could not read the compressed QGIS project.");
   }
   const qgsName = Object.keys(entries).find((name) => name.toLowerCase().endsWith(".qgs"));
@@ -414,16 +457,21 @@ function layerOrder(document: Document, mapLayers: Element[]): string[] {
 function qgisSourcePath(dataSource: string, projectPath: string): string {
   let source = dataSource.split("|", 1)[0]?.trim() ?? "";
   source = source.replace(/^\/vsicurl(?:_streaming)?\//i, "");
+  if (/^\/?vsizip\//i.test(source)) return "";
   if (source.startsWith("file://")) {
     try {
-      source = decodeURIComponent(new URL(source).pathname);
+      source = decodeURIComponent(new URL(source).pathname).replace(/^\/([A-Za-z]:)/, "$1");
     } catch {
       source = source.slice("file://".length);
     }
   }
+  source = source.replace(/^file:(?:\/\/)?/i, "");
+  source = source.replace(/[?#].*$/, "");
   source = source.replace(/^['"]|['"]$/g, "");
   if (!source || isAbsolutePath(source) || /^[a-z]+:\/\//i.test(source)) return source;
-  const directory = projectPath.replace(/[/\\][^/\\]*$/, "");
+  const directory = /[/\\]/.test(projectPath)
+    ? projectPath.replace(/[/\\][^/\\]*$/, "")
+    : "";
   return normalizeJoinedPath(directory, source);
 }
 
@@ -487,6 +535,10 @@ function unsupportedReason(
   provider: string,
   source: string,
 ): QgisProjectImportWarning["reason"] {
+  if (element.getAttribute("type")?.toLowerCase() === "raster") {
+    if (isHttpSource(source)) return "remote-file";
+    return "format";
+  }
   if (element.getAttribute("type")?.toLowerCase() !== "vector") {
     return "non-vector";
   }
@@ -500,7 +552,9 @@ function unsupportedReason(
 
 function parseLayerStyle(element: Element): LayerStyle {
   const style: LayerStyle = structuredClone(DEFAULT_LAYER_STYLE);
-  const symbolLayer = element.querySelector("renderer-v2 symbols symbol layer");
+  const renderer = element.querySelector(":scope > renderer-v2");
+  if (renderer?.getAttribute("type") !== "singleSymbol") return style;
+  const symbolLayer = renderer.querySelector("symbols symbol layer");
   const options = new Map<string, string>();
   symbolLayer?.querySelectorAll("Option[name]").forEach((option) => {
     options.set(option.getAttribute("name") ?? "", option.getAttribute("value") ?? "");
@@ -516,10 +570,18 @@ function parseLayerStyle(element: Element): LayerStyle {
     style.strokeColor = stroke.color;
   }
   const width = optionalNumber(options.get("outline_width") ?? options.get("line_width"));
-  if (width !== null) style.strokeWidth = Math.max(0, width * 3.78);
+  const widthUnit = options.get("outline_width_unit") ?? options.get("line_width_unit") ?? "MM";
+  if (width !== null && (widthUnit === "MM" || widthUnit === "Pixel")) {
+    style.strokeWidth = Math.max(0, width * (widthUnit === "MM" ? 3.78 : 1));
+  }
   const size = optionalNumber(options.get("size"));
-  if (symbolLayer?.getAttribute("class") === "SimpleMarker" && size !== null) {
-    style.circleRadius = Math.max(1, (size * 3.78) / 2);
+  const sizeUnit = options.get("size_unit") ?? "MM";
+  if (
+    symbolLayer?.getAttribute("class") === "SimpleMarker" &&
+    size !== null &&
+    (sizeUnit === "MM" || sizeUnit === "Pixel")
+  ) {
+    style.circleRadius = Math.max(1, (size * (sizeUnit === "MM" ? 3.78 : 1)) / 2);
   }
   const textStyle = element.querySelector("labeling[type='simple'] settings text-style");
   const field = textStyle?.getAttribute("fieldName")?.trim();
@@ -537,7 +599,7 @@ function parseLayerStyle(element: Element): LayerStyle {
 function qgisColor(value: string | undefined): { color: string; opacity: number } | null {
   if (!value) return null;
   const parts = value.split(",").map(Number);
-  if (parts.length < 3 || parts.slice(0, 3).some((part) => !Number.isFinite(part))) return null;
+  if (parts.length < 3 || parts.slice(0, 4).some((part) => !Number.isFinite(part))) return null;
   const [red, green, blue, alpha = 255] = parts;
   return {
     color: `#${[red, green, blue]
@@ -570,6 +632,11 @@ function uniqueLayerId(candidate: string, layers: GeoLibreLayer[]): string {
   return id;
 }
 
+function nextLayerId(id: string, orderedIds: string[]): string | undefined {
+  const index = orderedIds.indexOf(id);
+  return index >= 0 ? orderedIds[index + 1] : undefined;
+}
+
 function numberText(element: Element | null | undefined): number {
   const value = text(element);
   return value === "" ? Number.NaN : Number(value);
diff --git a/tests/qgis-project-import.test.ts b/tests/qgis-project-import.test.ts
index 852152e47..1823f9f24 100644
--- a/tests/qgis-project-import.test.ts
+++ b/tests/qgis-project-import.test.ts
@@ -236,6 +236,54 @@ describe("QGIS project import", () => {
     );
   });
 
+  it("normalizes Windows file URLs, query strings, and bare project names", () => {
+    const windows = importQgisProject(
+      projectXml({
+        dataSources: [
+          {
+            id: "roads",
+            name: "CSV",
+            source: "file:///C:/data/points.csv?delimiter=%2C",
+          },
+        ],
+      }),
+      "C:\\projects\\example.qgs",
+    );
+    assert.equal(windows.project.layers[0].sourcePath, "C:/data/points.csv");
+
+    const browser = importQgisProject(
+      projectXml({
+        dataSources: [{ id: "roads", name: "Roads", source: "data/roads.geojson" }],
+      }),
+      "example.qgs",
+    );
+    assert.equal(browser.project.layers[0].sourcePath, "data/roads.geojson");
+  });
+
+  it("does not silently flatten categorized styling or mis-scale pixel units", () => {
+    const xml = projectXml().replaceAll(
+      '<renderer-v2 type="singleSymbol">',
+      '<renderer-v2 type="categorizedSymbol">',
+    );
+    const categorized = importQgisProject(xml, "/work/example.qgs");
+    assert.notEqual(categorized.project.layers[0].style.fillColor, "#ff0000");
+
+    const pixelXml = projectXml().replaceAll(
+      '<Option name="size" value="4"/>',
+      '<Option name="size" value="4"/><Option name="size_unit" value="Pixel"/>',
+    );
+    const pixel = importQgisProject(pixelXml, "/work/example.qgs");
+    assert.equal(pixel.project.layers[0].style.circleRadius, 2);
+  });
+
+  it("rejects oversized QGS members before decompressing them", () => {
+    const oversized = zipSync({ "project.qgs": new Uint8Array(25 * 1024 * 1024 + 1) });
+    assert.throws(
+      () => importQgisProject(oversized, "/work/example.qgz"),
+      /too large to import safely/,
+    );
+  });
+
   it("materializes remote GeoJSON and warns when a remote response cannot be loaded", async () => {
     const result = importQgisProject(
       projectXml({

From 517084c605c6c0db03dc8fd145151ecfd4696861 Mon Sep 17 00:00:00 2001
From: giswqs <giswqs@gmail.com>
Date: Fri, 31 Jul 2026 00:25:22 -0400
Subject: [PATCH 18/19] test(qgis): cover failed remote group cleanup

---
 tests/qgis-project-import.test.ts | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/tests/qgis-project-import.test.ts b/tests/qgis-project-import.test.ts
index 1823f9f24..2779b5aef 100644
--- a/tests/qgis-project-import.test.ts
+++ b/tests/qgis-project-import.test.ts
@@ -315,6 +315,10 @@ describe("QGIS project import", () => {
     assert.equal(result.project.layers.length, 1);
     assert.equal(result.project.layers[0].name, "Good");
     assert.equal(result.project.layers[0].geojson?.features.length, 1);
+    assert.deepEqual(
+      result.project.layerGroups?.map((group) => group.name),
+      ["Transport"],
+    );
     assert.deepEqual(
       result.warnings.map((warning) => [warning.layerName, warning.reason]),
       [["Bad", "remote-file"]],

From 287a319acd7662539ed750d5a8213d6501b21aad Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Fri, 31 Jul 2026 04:28:33 +0000
Subject: [PATCH 19/19] style: auto-format (ruff + oxfmt) [pre-commit.ci]

---
 apps/geolibre-desktop/src/lib/qgis-project-import.ts | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/apps/geolibre-desktop/src/lib/qgis-project-import.ts b/apps/geolibre-desktop/src/lib/qgis-project-import.ts
index 4665d7fd2..09ad9f790 100644
--- a/apps/geolibre-desktop/src/lib/qgis-project-import.ts
+++ b/apps/geolibre-desktop/src/lib/qgis-project-import.ts
@@ -469,9 +469,7 @@ function qgisSourcePath(dataSource: string, projectPath: string): string {
   source = source.replace(/[?#].*$/, "");
   source = source.replace(/^['"]|['"]$/g, "");
   if (!source || isAbsolutePath(source) || /^[a-z]+:\/\//i.test(source)) return source;
-  const directory = /[/\\]/.test(projectPath)
-    ? projectPath.replace(/[/\\][^/\\]*$/, "")
-    : "";
+  const directory = /[/\\]/.test(projectPath) ? projectPath.replace(/[/\\][^/\\]*$/, "") : "";
   return normalizeJoinedPath(directory, source);
 }