From 34bbaf7cea3b6c98f209eff38c5c4e9156ef2e0a Mon Sep 17 00:00:00 2001
From: MaxNumerique <maximilienlandois@gmail.com>
Date: Thu, 22 Oct 2026 14:47:44 +0200
Subject: [PATCH 01/29] feat(CrsSelector): v-model API, authority:code
 selection key, non-blocking load [skip ci]

---
 app/components/CrsSelector.vue                | 45 ++++++--------
 .../unit/components/CrsSelector.nuxt.test.ts  | 60 +++++++++++++++++--
 2 files changed, 72 insertions(+), 33 deletions(-)

diff --git a/app/components/CrsSelector.vue b/app/components/CrsSelector.vue
index 023c5b11b..552907cc6 100644
--- a/app/components/CrsSelector.vue
+++ b/app/components/CrsSelector.vue
@@ -2,22 +2,14 @@
 import schemas, { type CRSList } from "@geode/opengeodeweb-back/opengeodeweb_back_typed_schemas.js";
 import { useBackStore } from "@ogw_front/stores/back";
 
-const schema = schemas.opengeodeweb_back.geographic_coordinate_systems;
-
-interface Emits {
-  update_values: [values: Record<string, unknown>];
-  increment_step: [];
-  decrement_step: [];
-}
-
-const emit = defineEmits<Emits>();
+const schema = schemas.opengeodeweb_back.crs.geographic_list;
 
 interface Props {
   geodeObjectType: string;
-  keyToUpdate: string;
 }
 
-const { geodeObjectType, keyToUpdate } = defineProps<Props>();
+const { geodeObjectType } = defineProps<Props>();
+const selectedCrs = defineModel<CRSList | undefined>();
 
 const search = ref<string>("");
 const data_table_loading = ref<boolean>(false);
@@ -26,24 +18,20 @@ const selected_crs = ref<unknown[]>([]);
 const toggle_loading = useToggle(data_table_loading);
 const backStore = useBackStore();
 
-function get_selected_crs(crs_code: unknown): unknown {
-  for (const crs of crs_list.value) {
-    if (crs.code === crs_code) {
-      return crs;
-    }
-  }
+// Codes are only unique within an authority (e.g. EPSG:4812 and ESRI:4812)
+function crs_key(crs: CRSList): string {
+  return `${crs.authority}:${crs.code}`;
+}
+
+function get_selected_crs(key: unknown): CRSList | undefined {
+  return crs_list.value.find((crs) => crs_key(crs) === key);
 }
 
 watch(selected_crs, (new_value) => {
-  const crs = get_selected_crs(new_value[0]);
-  const keys_values_object = {
-    [keyToUpdate]: crs,
-  };
-  emit("update_values", keys_values_object);
-  emit("increment_step");
+  selectedCrs.value = get_selected_crs(new_value[0]);
 });
 
-async function get_crs_table(): void {
+async function get_crs_table(): Promise<void> {
   const params = { geode_object_type: geodeObjectType };
   toggle_loading();
   await backStore.request(
@@ -68,13 +56,16 @@ const headers = [
   { title: "Name", align: "end", key: "name" },
 ] as const;
 
-// oxlint-disable-next-line no-top-level-await
-await get_crs_table();
+// Not awaited in setup: the table renders right away with its loader
+onMounted(async () => {
+  await get_crs_table();
+});
 </script>
 
 <template>
   <v-text-field
     v-model="search"
+    data-testid="crsSearchInput"
     append-icon="mdi-magnify"
     label="Search"
     single-line
@@ -85,7 +76,7 @@ await get_crs_table();
     :v-model:items-per-page="10"
     :headers="headers"
     :items="crs_list"
-    item-value="code"
+    :item-value="crs_key"
     class="elevation-1"
     density="compact"
     fixed-header
diff --git a/tests/unit/components/CrsSelector.nuxt.test.ts b/tests/unit/components/CrsSelector.nuxt.test.ts
index 94ac6b8cc..0690ca4af 100644
--- a/tests/unit/components/CrsSelector.nuxt.test.ts
+++ b/tests/unit/components/CrsSelector.nuxt.test.ts
@@ -9,8 +9,11 @@ import { mockAs, setupActivePinia, vuetify } from "@ogw_tests/utils";
 import CrsSelector from "@ogw_front/components/CrsSelector.vue";
 import { useBackStore } from "@ogw_front/stores/back";
 
+vi.setConfig({ testTimeout: 10_000 });
+
 const EXPECTED_LENGTH = 1;
 const FIRST_INDEX = 0;
+const ESRI_INDEX = 1;
 
 // These are assigned in beforeEach (a real defined value by the time any test runs) rather than at declaration, so a `| undefined` type would just force needless narrowing at every call site below.
 // oxlint-disable-next-line eslint/init-declarations
@@ -48,21 +51,66 @@ describe("crs selector", () => {
       ),
     );
 
-    const key_to_update = "key";
     const wrapper = await mountSuspended(CrsSelector, {
       global: {
         plugins: [vuetify, pinia],
       },
-      props: { geodeObjectType: "BRep", keyToUpdate: key_to_update },
+      props: { geodeObjectType: "BRep" },
     });
     const td_wrapper = wrapper.find("td");
     await wrapper.vm.$nextTick();
     const input = td_wrapper.find("input");
     await input.trigger("click");
-    expect(wrapper.emitted()).toHaveProperty("update_values");
-    expect(wrapper.emitted<unknown[]>().update_values).toHaveLength(EXPECTED_LENGTH);
-    expect(wrapper.emitted<unknown[]>().update_values?.[FIRST_INDEX]?.[FIRST_INDEX]).toStrictEqual({
-      [key_to_update]: crs_list[FIRST_INDEX],
+    expect(wrapper.emitted()).toHaveProperty("update:modelValue");
+    expect(wrapper.emitted<unknown[]>()["update:modelValue"]).toHaveLength(EXPECTED_LENGTH);
+    expect(
+      wrapper.emitted<unknown[]>()["update:modelValue"]?.[FIRST_INDEX]?.[FIRST_INDEX],
+    ).toStrictEqual(crs_list[FIRST_INDEX]);
+  });
+
+  test("selects the clicked crs when codes collide across authorities", async () => {
+    const crs_list = [
+      { authority: "EPSG", code: "4812", name: "New Beijing / 3-degree Gauss-Kruger CM 132E" },
+      { authority: "ESRI", code: "4812", name: "GCS_Voirol_Unifie_1960_Paris" },
+    ];
+    backStore.request = mockAs<typeof backStore.request>(
+      vi.fn(
+        async (
+          _request: unknown,
+          callbacks: { response_function?: (response: unknown) => void },
+        ) => {
+          callbacks.response_function?.({ crs_list });
+          await Promise.resolve();
+          return { crs_list };
+        },
+      ),
+    );
+
+    const wrapper = await mountSuspended(CrsSelector, {
+      global: {
+        plugins: [vuetify, pinia],
+      },
+      props: { geodeObjectType: "BRep" },
+    });
+    await wrapper.vm.$nextTick();
+    const esri_input = wrapper.findAll("tbody tr")[ESRI_INDEX]?.find("input");
+    await esri_input?.trigger("click");
+    expect(
+      wrapper.emitted<unknown[]>()["update:modelValue"]?.[FIRST_INDEX]?.[FIRST_INDEX],
+    ).toStrictEqual(crs_list[ESRI_INDEX]);
+  });
+
+  test("shows the table loader while the crs list loads", async () => {
+    backStore.request = mockAs<typeof backStore.request>(
+      vi.fn().mockReturnValue(Promise.withResolvers<never>().promise),
+    );
+
+    const wrapper = await mountSuspended(CrsSelector, {
+      global: {
+        plugins: [vuetify, pinia],
+      },
+      props: { geodeObjectType: "BRep" },
     });
+    expect(wrapper.text()).toContain("Loading... Please wait");
   });
 });

From b9fea1a16cc4bf8fdb85b62d3f9a991190ca37ed Mon Sep 17 00:00:00 2001
From: MaxNumerique <maximilienlandois@gmail.com>
Date: Thu, 22 Oct 2026 15:39:10 +0200
Subject: [PATCH 02/29] refacto from import_workflow [skip ci]

---
 app/utils/import_workflow.ts                  | 20 ++++++++++------
 tests/unit/utils/import_workflow.nuxt.test.ts | 23 ++++++++++++++++++-
 2 files changed, 35 insertions(+), 8 deletions(-)

diff --git a/app/utils/import_workflow.ts b/app/utils/import_workflow.ts
index d2f5936d5..7c393bc06 100644
--- a/app/utils/import_workflow.ts
+++ b/app/utils/import_workflow.ts
@@ -162,21 +162,26 @@ async function importWorkflowFromSnapshot(items: readonly NewDataItem[]): Promis
   return ids;
 }
 
-// The time series only adds attributes to the model, so the viewer object is reloaded under the same id with its stored style.
-async function applyTimeSeriesWorkflow(filename: string, id: string): Promise<string> {
-  const backStore = useBackStore();
+// Reloads the viewer object under the same id with its stored style, after the back rewrote its files.
+async function reloadObject(id: string): Promise<void> {
   const dataStore = useDataStore();
   const dataStyleStore = useDataStyleStore();
   const hybridViewerStore = useHybridViewerStore();
-  await backStore.request({
-    schema: back_schemas.opengeodeweb_back.apply_time_series,
-    params: { id, filename },
-  });
   const item = await dataStore.item(id);
   await dataStore.deregisterObject(id);
   await dataStore.registerObject(id, item.name ?? id);
   await dataStyleStore.applyDefaultStyle(id);
   await hybridViewerStore.remoteRender();
+}
+
+// The time series only adds attributes to the model, so the viewer object is reloaded.
+async function applyTimeSeriesWorkflow(filename: string, id: string): Promise<string> {
+  const backStore = useBackStore();
+  await backStore.request({
+    schema: back_schemas.opengeodeweb_back.apply_time_series,
+    params: { id, filename },
+  });
+  await reloadObject(id);
   return id;
 }
 
@@ -186,4 +191,5 @@ export {
   importWorkflowFromSnapshot,
   importItem,
   applyTimeSeriesWorkflow,
+  reloadObject,
 };
diff --git a/tests/unit/utils/import_workflow.nuxt.test.ts b/tests/unit/utils/import_workflow.nuxt.test.ts
index 95452915a..cc0325be5 100644
--- a/tests/unit/utils/import_workflow.nuxt.test.ts
+++ b/tests/unit/utils/import_workflow.nuxt.test.ts
@@ -3,13 +3,19 @@
 import { type Mock, describe, expect, test, vi } from "vitest";
 
 // Local imports
-import { applyTimeSeriesWorkflow, importWorkflow } from "@ogw_front/utils/import_workflow";
+import {
+  applyTimeSeriesWorkflow,
+  importWorkflow,
+  reloadObject,
+} from "@ogw_front/utils/import_workflow";
 import { mockAs, setupActivePinia } from "@ogw_tests/utils";
 import { useBackStore } from "@ogw_front/stores/back";
 import { useDataStore } from "@ogw_front/stores/data";
 import { useDataStyleStore } from "@ogw_front/stores/data_style";
 import { useHybridViewerStore } from "@ogw_front/stores/hybrid_viewer";
 
+vi.setConfig({ testTimeout: 10_000 });
+
 function setup(): {
   calls: string[];
   request: Mock;
@@ -76,6 +82,21 @@ describe("apply time series workflow", () => {
   });
 });
 
+describe("reload object", () => {
+  setupActivePinia();
+
+  test("re-registers the object with its stored style", async () => {
+    const { calls, request, applyDefaultStyle, remoteRender } = setup();
+
+    await reloadObject("brep_id");
+
+    expect(request).not.toHaveBeenCalled();
+    expect(calls).toStrictEqual(["deregister", "register", "style"]);
+    expect(applyDefaultStyle).toHaveBeenCalledWith("brep_id");
+    expect(remoteRender).toHaveBeenCalledWith();
+  });
+});
+
 describe("import workflow", () => {
   setupActivePinia();
 

From 4556cc2f603751784100398f77b33b8fe79c419d Mon Sep 17 00:00:00 2001
From: MaxNumerique <maximilienlandois@gmail.com>
Date: Thu, 22 Oct 2026 16:38:21 +0200
Subject: [PATCH 03/29] fix(import_workflow): reloadObject rebuilds the hybrid
 viewer actor

---
 app/utils/import_workflow.ts                  |  2 ++
 tests/unit/utils/import_workflow.nuxt.test.ts | 12 +++++++++---
 2 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/app/utils/import_workflow.ts b/app/utils/import_workflow.ts
index 7c393bc06..b880c032d 100644
--- a/app/utils/import_workflow.ts
+++ b/app/utils/import_workflow.ts
@@ -170,6 +170,8 @@ async function reloadObject(id: string): Promise<void> {
   const item = await dataStore.item(id);
   await dataStore.deregisterObject(id);
   await dataStore.registerObject(id, item.name ?? id);
+  // The local actor is rebuilt from the stored light viewable, which may have moved
+  await hybridViewerStore.addItem(id);
   await dataStyleStore.applyDefaultStyle(id);
   await hybridViewerStore.remoteRender();
 }
diff --git a/tests/unit/utils/import_workflow.nuxt.test.ts b/tests/unit/utils/import_workflow.nuxt.test.ts
index cc0325be5..e2e434734 100644
--- a/tests/unit/utils/import_workflow.nuxt.test.ts
+++ b/tests/unit/utils/import_workflow.nuxt.test.ts
@@ -22,6 +22,7 @@ function setup(): {
   applyDefaultStyle: Mock;
   addDataStyle: Mock;
   remoteRender: Mock;
+  addHybridItem: Mock;
 } {
   const calls: string[] = [];
   const backStore = useBackStore();
@@ -35,6 +36,9 @@ function setup(): {
   });
   const addDataStyle = vi.fn();
   const remoteRender = vi.fn();
+  const addHybridItem = vi.fn().mockImplementation(() => {
+    calls.push("hybrid");
+  });
   backStore.request = mockAs<typeof backStore.request>(request);
   dataStore.item = mockAs<typeof dataStore.item>(
     vi.fn().mockResolvedValue({ id: "brep_id", name: "cube" }),
@@ -53,7 +57,8 @@ function setup(): {
     mockAs<typeof dataStyleStore.applyDefaultStyle>(applyDefaultStyle);
   dataStyleStore.addDataStyle = mockAs<typeof dataStyleStore.addDataStyle>(addDataStyle);
   hybridViewerStore.remoteRender = mockAs<typeof hybridViewerStore.remoteRender>(remoteRender);
-  return { calls, request, applyDefaultStyle, addDataStyle, remoteRender };
+  hybridViewerStore.addItem = mockAs<typeof hybridViewerStore.addItem>(addHybridItem);
+  return { calls, request, applyDefaultStyle, addDataStyle, remoteRender, addHybridItem };
 }
 
 describe("apply time series workflow", () => {
@@ -68,7 +73,7 @@ describe("apply time series workflow", () => {
     expect(request).toHaveBeenCalledWith(
       expect.objectContaining({ params: { id: "brep_id", filename: "time_series.pvd" } }),
     );
-    expect(calls).toStrictEqual(["deregister", "register", "style"]);
+    expect(calls).toStrictEqual(["deregister", "register", "hybrid", "style"]);
     expect(applyDefaultStyle).toHaveBeenCalledWith("brep_id");
     expect(remoteRender).toHaveBeenCalledWith();
   });
@@ -91,7 +96,8 @@ describe("reload object", () => {
     await reloadObject("brep_id");
 
     expect(request).not.toHaveBeenCalled();
-    expect(calls).toStrictEqual(["deregister", "register", "style"]);
+    // The local actor is rebuilt too: the light viewable may have moved
+    expect(calls).toStrictEqual(["deregister", "register", "hybrid", "style"]);
     expect(applyDefaultStyle).toHaveBeenCalledWith("brep_id");
     expect(remoteRender).toHaveBeenCalledWith();
   });

From 79c762ea115c9310533c65655e4da707617909d1 Mon Sep 17 00:00:00 2001
From: MaxNumerique <144453705+MaxNumerique@users.noreply.github.com>
Date: Fri, 23 Oct 2026 09:35:16 +0000
Subject: [PATCH 04/29] Apply prepare changes

---
 .releaserc | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.releaserc b/.releaserc
index bf47fdf5a..30a901b9b 100644
--- a/.releaserc
+++ b/.releaserc
@@ -6,6 +6,6 @@
   plugins: [
     '@semantic-release/commit-analyzer', 
     '@semantic-release/release-notes-generator', 
-    '@semantic-release/github'
+    ['@semantic-release/github', { successCommentCondition: false, failCommentCondition: false }]
   ]
 }

From 9db9e206fda018e2980d8ae89d2634b1233268c5 Mon Sep 17 00:00:00 2001
From: MaxNumerique <maximilienlandois@gmail.com>
Date: Fri, 23 Oct 2026 11:37:22 +0200
Subject: [PATCH 05/29] feat(crs): store data CRS and cache the available CRS
 list

---
 app/components/CrsSelector.vue                | 18 ++---
 app/stores/crs.ts                             | 59 ++++++++++++++++
 app/stores/data.ts                            |  6 ++
 app/utils/crs.ts                              | 12 ++++
 .../unit/components/CrsSelector.nuxt.test.ts  | 33 +++------
 tests/unit/stores/crs.nuxt.test.ts            | 70 +++++++++++++++++++
 tests/unit/stores/data.nuxt.test.ts           | 20 +++++-
 tests/unit/utils/crs.nuxt.test.ts             | 23 ++++++
 8 files changed, 202 insertions(+), 39 deletions(-)
 create mode 100644 app/stores/crs.ts
 create mode 100644 app/utils/crs.ts
 create mode 100644 tests/unit/stores/crs.nuxt.test.ts
 create mode 100644 tests/unit/utils/crs.nuxt.test.ts

diff --git a/app/components/CrsSelector.vue b/app/components/CrsSelector.vue
index 552907cc6..310c19a59 100644
--- a/app/components/CrsSelector.vue
+++ b/app/components/CrsSelector.vue
@@ -1,8 +1,6 @@
 <script setup lang="ts">
-import schemas, { type CRSList } from "@geode/opengeodeweb-back/opengeodeweb_back_typed_schemas.js";
-import { useBackStore } from "@ogw_front/stores/back";
-
-const schema = schemas.opengeodeweb_back.crs.geographic_list;
+import type { CRSList } from "@geode/opengeodeweb-back/opengeodeweb_back_typed_schemas.js";
+import { useCrsStore } from "@ogw_front/stores/crs";
 
 interface Props {
   geodeObjectType: string;
@@ -16,7 +14,7 @@ const data_table_loading = ref<boolean>(false);
 const crs_list = ref<CRSList[]>([]);
 const selected_crs = ref<unknown[]>([]);
 const toggle_loading = useToggle(data_table_loading);
-const backStore = useBackStore();
+const crsStore = useCrsStore();
 
 // Codes are only unique within an authority (e.g. EPSG:4812 and ESRI:4812)
 function crs_key(crs: CRSList): string {
@@ -32,16 +30,8 @@ watch(selected_crs, (new_value) => {
 });
 
 async function get_crs_table(): Promise<void> {
-  const params = { geode_object_type: geodeObjectType };
   toggle_loading();
-  await backStore.request(
-    { schema, params },
-    {
-      response_function: (response) => {
-        crs_list.value = response.crs_list;
-      },
-    },
-  );
+  crs_list.value = await crsStore.geographicList(geodeObjectType);
   toggle_loading();
 }
 
diff --git a/app/stores/crs.ts b/app/stores/crs.ts
new file mode 100644
index 000000000..efe532035
--- /dev/null
+++ b/app/stores/crs.ts
@@ -0,0 +1,59 @@
+import back_schemas, {
+  type CRSList,
+} from "@geode/opengeodeweb-back/opengeodeweb_back_typed_schemas.js";
+import { useBackStore } from "@ogw_front/stores/back";
+
+// Session cache of the available CRS, and the channel the shared components use to ask the host app for a CRS edit
+export const useCrsStore = defineStore("crs", () => {
+  const backStore = useBackStore();
+  const geographicLists = new Map<string, Promise<CRSList[]>>();
+  const crsEditEnabled = ref(false);
+  const crsEditRequest = ref<string | undefined>(undefined);
+
+  async function fetchGeographicList(geodeObjectType: string): Promise<CRSList[]> {
+    try {
+      const response = await backStore.request({
+        schema: back_schemas.opengeodeweb_back.crs.geographic_list,
+        params: { geode_object_type: geodeObjectType },
+      });
+      if (response?.crs_list !== undefined) {
+        return response.crs_list;
+      }
+    } catch {
+      // The back store already reports the error to the user
+    }
+    // A failed request is not cached: the next call retries
+    geographicLists.delete(geodeObjectType);
+    return [];
+  }
+
+  async function geographicList(geodeObjectType: string): Promise<CRSList[]> {
+    // The promise is cached, so dialogs opened together share a single request
+    if (!geographicLists.has(geodeObjectType)) {
+      geographicLists.set(geodeObjectType, fetchGeographicList(geodeObjectType));
+    }
+    const list = await geographicLists.get(geodeObjectType);
+    return list ?? [];
+  }
+
+  function enableCrsEdit(): void {
+    crsEditEnabled.value = true;
+  }
+
+  function requestCrsEdit(id: string): void {
+    crsEditRequest.value = id;
+  }
+
+  function clearCrsEditRequest(): void {
+    crsEditRequest.value = undefined;
+  }
+
+  return {
+    geographicList,
+    crsEditEnabled,
+    enableCrsEdit,
+    crsEditRequest,
+    requestCrsEdit,
+    clearCrsEditRequest,
+  };
+});
diff --git a/app/stores/data.ts b/app/stores/data.ts
index 68481bf21..c30e724a9 100644
--- a/app/stores/data.ts
+++ b/app/stores/data.ts
@@ -1,5 +1,6 @@
 // oxlint-disable eslint/max-lines
 // Third party imports
+import type { CRSList } from "@geode/opengeodeweb-back/opengeodeweb_back_typed_schemas.js";
 import type { Table } from "dexie";
 import { useObservable } from "@vueuse/rxjs";
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_typed_schemas.js";
@@ -21,6 +22,7 @@ interface DataItem {
   created_at: string;
   is_viewable?: boolean;
   binary_light_viewable?: string;
+  crs?: CRSList;
 }
 
 interface ModelComponentInput {
@@ -42,6 +44,7 @@ interface NewDataItem {
   geode_object_type: string;
   is_viewable?: boolean;
   binary_light_viewable?: string;
+  crs?: CRSList;
   mesh_components?: ModelComponentInput[];
   collection_components?: ModelComponentInput[];
   nb_vertices?: number;
@@ -206,6 +209,9 @@ export const useDataStore = defineStore("data", () => {
     if (new_item.binary_light_viewable !== undefined && new_item.binary_light_viewable !== null) {
       itemData.binary_light_viewable = new_item.binary_light_viewable;
     }
+    if (new_item.crs !== undefined) {
+      itemData.crs = new_item.crs;
+    }
     const id = await data_db.put(itemData);
     return id;
   }
diff --git a/app/utils/crs.ts b/app/utils/crs.ts
new file mode 100644
index 000000000..97e0da960
--- /dev/null
+++ b/app/utils/crs.ts
@@ -0,0 +1,12 @@
+import type { CRSList } from "@geode/opengeodeweb-back/opengeodeweb_back_typed_schemas.js";
+
+function formatCrs(crs: CRSList | undefined): string {
+  return crs ? `${crs.authority}:${crs.code} — ${crs.name}` : "None";
+}
+
+// Code alone, for narrow places: the full name goes in a tooltip
+function formatCrsCode(crs: CRSList | undefined): string {
+  return crs ? `${crs.authority}:${crs.code}` : "None";
+}
+
+export { formatCrs, formatCrsCode };
diff --git a/tests/unit/components/CrsSelector.nuxt.test.ts b/tests/unit/components/CrsSelector.nuxt.test.ts
index 0690ca4af..93cfec49f 100644
--- a/tests/unit/components/CrsSelector.nuxt.test.ts
+++ b/tests/unit/components/CrsSelector.nuxt.test.ts
@@ -8,6 +8,7 @@ import { mountSuspended } from "@nuxt/test-utils/runtime";
 import { mockAs, setupActivePinia, vuetify } from "@ogw_tests/utils";
 import CrsSelector from "@ogw_front/components/CrsSelector.vue";
 import { useBackStore } from "@ogw_front/stores/back";
+import { useCrsStore } from "@ogw_front/stores/crs";
 
 vi.setConfig({ testTimeout: 10_000 });
 
@@ -37,18 +38,9 @@ describe("crs selector", () => {
       },
     ];
 
-    // Mock backStore.request instead of registerEndpoint
-    backStore.request = mockAs<typeof backStore.request>(
-      vi.fn(
-        async (
-          _request: unknown,
-          callbacks: { response_function?: (response: unknown) => void },
-        ) => {
-          callbacks.response_function?.({ crs_list });
-          await Promise.resolve();
-          return { crs_list };
-        },
-      ),
+    const crsStore = useCrsStore();
+    crsStore.geographicList = mockAs<typeof crsStore.geographicList>(
+      vi.fn().mockResolvedValue(crs_list),
     );
 
     const wrapper = await mountSuspended(CrsSelector, {
@@ -73,17 +65,9 @@ describe("crs selector", () => {
       { authority: "EPSG", code: "4812", name: "New Beijing / 3-degree Gauss-Kruger CM 132E" },
       { authority: "ESRI", code: "4812", name: "GCS_Voirol_Unifie_1960_Paris" },
     ];
-    backStore.request = mockAs<typeof backStore.request>(
-      vi.fn(
-        async (
-          _request: unknown,
-          callbacks: { response_function?: (response: unknown) => void },
-        ) => {
-          callbacks.response_function?.({ crs_list });
-          await Promise.resolve();
-          return { crs_list };
-        },
-      ),
+    const crsStore = useCrsStore();
+    crsStore.geographicList = mockAs<typeof crsStore.geographicList>(
+      vi.fn().mockResolvedValue(crs_list),
     );
 
     const wrapper = await mountSuspended(CrsSelector, {
@@ -101,7 +85,8 @@ describe("crs selector", () => {
   });
 
   test("shows the table loader while the crs list loads", async () => {
-    backStore.request = mockAs<typeof backStore.request>(
+    const crsStore = useCrsStore();
+    crsStore.geographicList = mockAs<typeof crsStore.geographicList>(
       vi.fn().mockReturnValue(Promise.withResolvers<never>().promise),
     );
 
diff --git a/tests/unit/stores/crs.nuxt.test.ts b/tests/unit/stores/crs.nuxt.test.ts
new file mode 100644
index 000000000..c49998d51
--- /dev/null
+++ b/tests/unit/stores/crs.nuxt.test.ts
@@ -0,0 +1,70 @@
+// oxlint-disable vitest/require-mock-type-parameters
+import { beforeEach, describe, expect, test, vi } from "vitest";
+import { mockAs, setupActivePinia } from "@ogw_tests/utils";
+import { useBackStore } from "@ogw_front/stores/back";
+import { useCrsStore } from "@ogw_front/stores/crs";
+
+vi.setConfig({ testTimeout: 10_000 });
+
+const EXPECTED_REQUESTS = 1;
+const CRS_LIST = [{ authority: "EPSG", code: "2154", name: "RGF93 v1 / Lambert-93" }];
+
+describe("crs store", () => {
+  beforeEach(() => {
+    setupActivePinia();
+  });
+
+  test("loads the geographic list once per object type", async () => {
+    const request = vi.fn().mockResolvedValue({ crs_list: CRS_LIST });
+    const backStore = useBackStore();
+    backStore.request = mockAs<typeof backStore.request>(request);
+    const crsStore = useCrsStore();
+
+    const [first, second] = await Promise.all([
+      crsStore.geographicList("PointSet3D"),
+      crsStore.geographicList("PointSet3D"),
+    ]);
+    await crsStore.geographicList("PointSet3D");
+
+    expect(first).toStrictEqual(CRS_LIST);
+    expect(second).toStrictEqual(CRS_LIST);
+    expect(request).toHaveBeenCalledTimes(EXPECTED_REQUESTS);
+  });
+
+  test("does not cache a failed request", async () => {
+    const request = vi
+      .fn()
+      .mockResolvedValueOnce(undefined)
+      .mockResolvedValueOnce({ crs_list: CRS_LIST });
+    const backStore = useBackStore();
+    backStore.request = mockAs<typeof backStore.request>(request);
+    const crsStore = useCrsStore();
+
+    await expect(crsStore.geographicList("BRep")).resolves.toStrictEqual([]);
+    await expect(crsStore.geographicList("BRep")).resolves.toStrictEqual(CRS_LIST);
+  });
+
+  test("does not cache a rejected request", async () => {
+    const request = vi
+      .fn()
+      .mockRejectedValueOnce(new Error("back disconnected"))
+      .mockResolvedValueOnce({ crs_list: CRS_LIST });
+    const backStore = useBackStore();
+    backStore.request = mockAs<typeof backStore.request>(request);
+    const crsStore = useCrsStore();
+
+    await expect(crsStore.geographicList("Section")).resolves.toStrictEqual([]);
+    await expect(crsStore.geographicList("Section")).resolves.toStrictEqual(CRS_LIST);
+  });
+
+  test("forwards an edit request until it is cleared", () => {
+    const crsStore = useCrsStore();
+    expect(crsStore.crsEditEnabled).toBe(false);
+    crsStore.enableCrsEdit();
+    crsStore.requestCrsEdit("data-1");
+    expect(crsStore.crsEditEnabled).toBe(true);
+    expect(crsStore.crsEditRequest).toBe("data-1");
+    crsStore.clearCrsEditRequest();
+    expect(crsStore.crsEditRequest).toBeUndefined();
+  });
+});
diff --git a/tests/unit/stores/data.nuxt.test.ts b/tests/unit/stores/data.nuxt.test.ts
index 3ae82bf89..903f975c6 100644
--- a/tests/unit/stores/data.nuxt.test.ts
+++ b/tests/unit/stores/data.nuxt.test.ts
@@ -1,5 +1,5 @@
 // Third party imports
-import { beforeEach, describe, expect, test } from "vitest";
+import { beforeEach, describe, expect, test, vi } from "vitest";
 
 // Local imports
 import { setupActivePinia } from "@ogw_tests/utils";
@@ -7,6 +7,8 @@ import { useDataStore } from "@ogw_front/stores/data";
 
 const DATA_ID_LENGTH = 32;
 
+vi.setConfig({ testTimeout: 10_000 });
+
 describe("useDataStore - collections", () => {
   setupActivePinia();
 
@@ -30,6 +32,22 @@ describe("useDataStore - collections", () => {
     expect(stored.geode_id).toBe(geodeId);
   });
 
+  test("addItem stores crs", async () => {
+    const dataStore = useDataStore();
+    const dataId = "b".repeat(DATA_ID_LENGTH);
+    const crs = { authority: "EPSG", code: "2154", name: "RGF93 v1 / Lambert-93" };
+    await dataStore.addItem({
+      id: dataId,
+      geode_id: "01a08187-2c4c-7e64-85c5-52c3439f0627",
+      name: "points",
+      viewer_type: "mesh",
+      geode_object_type: "PointSet3D",
+      crs,
+    });
+    const stored = await dataStore.item(dataId);
+    expect(stored.crs).toStrictEqual(crs);
+  });
+
   test("correctly recognizes, formats, and pluralizes any collection component type not in MESH_COMPONENT_TYPES", async () => {
     const dataStore = useDataStore();
     const modelId = "test_model_id";
diff --git a/tests/unit/utils/crs.nuxt.test.ts b/tests/unit/utils/crs.nuxt.test.ts
new file mode 100644
index 000000000..bc6b06fce
--- /dev/null
+++ b/tests/unit/utils/crs.nuxt.test.ts
@@ -0,0 +1,23 @@
+import { describe, expect, test, vi } from "vitest";
+import { formatCrs, formatCrsCode } from "@ogw_front/utils/crs";
+
+vi.setConfig({ testTimeout: 10_000 });
+
+describe("format crs", () => {
+  test("formats authority, code and name", () => {
+    expect(formatCrs({ authority: "EPSG", code: "2154", name: "RGF93 v1 / Lambert-93" })).toBe(
+      "EPSG:2154 — RGF93 v1 / Lambert-93",
+    );
+  });
+
+  test("shows None without crs", () => {
+    expect(formatCrs(undefined)).toBe("None");
+  });
+
+  test("formats the code alone", () => {
+    expect(formatCrsCode({ authority: "EPSG", code: "2154", name: "RGF93 v1 / Lambert-93" })).toBe(
+      "EPSG:2154",
+    );
+    expect(formatCrsCode(undefined)).toBe("None");
+  });
+});

From 57e155c2d554237f904b406a508c0130e3204047 Mon Sep 17 00:00:00 2001
From: MaxNumerique <maximilienlandois@gmail.com>
Date: Fri, 23 Oct 2026 11:37:50 +0200
Subject: [PATCH 06/29] feat(crs): show and edit the CRS from the object tree
 and the info card

---
 .../Viewer/ContextMenu/InfoCard.vue           | 33 ++++++++++
 .../Viewer/ObjectTree/Base/ItemLabel.vue      | 35 ++++++++++-
 .../Viewer/ObjectTree/Views/GlobalObjects.vue |  1 +
 app/composables/live_data_item.ts             | 39 ++++++++++++
 tests/unit/components/InfoCard.nuxt.test.ts   | 63 +++++++++++++++++++
 tests/unit/components/ItemLabel.nuxt.test.ts  | 62 +++++++++++++++++-
 6 files changed, 230 insertions(+), 3 deletions(-)
 create mode 100644 app/composables/live_data_item.ts
 create mode 100644 tests/unit/components/InfoCard.nuxt.test.ts

diff --git a/app/components/Viewer/ContextMenu/InfoCard.vue b/app/components/Viewer/ContextMenu/InfoCard.vue
index fb88aaf55..f31d98197 100644
--- a/app/components/Viewer/ContextMenu/InfoCard.vue
+++ b/app/components/Viewer/ContextMenu/InfoCard.vue
@@ -1,9 +1,12 @@
 <script setup lang="ts">
+import { formatCrs, formatCrsCode } from "@ogw_front/utils/crs";
 import GlassCard from "@ogw_front/components/GlassCard.vue";
 import { consola } from "consola";
 import { middleTruncate } from "@ogw_front/utils/string";
 import { useCopyToClipboard } from "@ogw_front/composables/copy_to_clipboard";
+import { useCrsStore } from "@ogw_front/stores/crs";
 import { useDataStore } from "@ogw_front/stores/data";
+import { useLiveDataItem } from "@ogw_front/composables/live_data_item";
 import { useMenuStore } from "@ogw_front/stores/menu";
 
 interface Props {
@@ -126,6 +129,13 @@ function formatId(id: string | undefined): string {
 }
 
 const formattedId = computed<string>(() => formatId(metaData.id));
+
+const crsStore = useCrsStore();
+// A model component shares the model CRS: the CRS row is only shown for a data
+const isData = computed<boolean>(() => metaData.id !== undefined && metaData.modelId === undefined);
+// The menu metadata is a snapshot taken when it opened: read the item live so a CRS edit shows at once
+const liveItem = useLiveDataItem(() => (isData.value ? metaData.id : undefined));
+const liveCrs = computed(() => liveItem.value?.crs ?? metaData.crs);
 </script>
 
 <template>
@@ -168,6 +178,23 @@ const formattedId = computed<string>(() => formatId(metaData.id));
               class="ml-1"
             />
           </v-col>
+          <v-col
+            v-if="isData"
+            class="id-badge-container crs-badge mt-1 d-inline-flex align-center px-2 py-0.5"
+          >
+            <span class="crs-label mr-1">CRS</span>
+            <span class="id-text" data-testid="infoCrsValue">{{ formatCrsCode(liveCrs) }}</span>
+            <v-tooltip activator="parent" location="top">{{ formatCrs(liveCrs) }}</v-tooltip>
+            <v-icon
+              v-if="crsStore.crsEditEnabled"
+              data-testid="infoEditCrsBtn"
+              icon="mdi-pencil"
+              size="10"
+              color="white"
+              class="ml-1"
+              @click.stop="crsStore.requestCrsEdit(metaData.id)"
+            />
+          </v-col>
 
           <template v-if="componentItem">
             <v-divider class="w-100 my-2" opacity="0.2" />
@@ -229,6 +256,12 @@ const formattedId = computed<string>(() => formatId(metaData.id));
   transform: scale(0.97);
 }
 
+.crs-label {
+  font-weight: 900;
+  letter-spacing: 0.5px;
+  color: rgb(var(--v-theme-secondary));
+}
+
 .id-text {
   letter-spacing: 0.5px;
   color: rgba(255, 255, 255, 0.85);
diff --git a/app/components/Viewer/ObjectTree/Base/ItemLabel.vue b/app/components/Viewer/ObjectTree/Base/ItemLabel.vue
index b22ae4c07..c0e15ae3a 100644
--- a/app/components/Viewer/ObjectTree/Base/ItemLabel.vue
+++ b/app/components/Viewer/ObjectTree/Base/ItemLabel.vue
@@ -1,8 +1,11 @@
 <script setup lang="ts">
 import type { DisplayItem } from "@ogw_front/composables/virtual_tree";
+import { formatCrs } from "@ogw_front/utils/crs";
 import { middleTruncate } from "@ogw_front/utils/string";
 import { useClipboard } from "@vueuse/core";
+import { useCrsStore } from "@ogw_front/stores/crs";
 import { useFeedbackStore } from "@ogw_front/stores/feedback";
+import { useLiveDataItem } from "@ogw_front/composables/live_data_item";
 import { useResponsiveMiddleTruncate } from "@ogw_front/composables/responsive_middle_truncate";
 
 const feedbackStore = useFeedbackStore();
@@ -11,9 +14,10 @@ const { copy } = useClipboard();
 interface Props {
   item: DisplayItem;
   isLeaf?: boolean;
+  showCrs?: boolean;
 }
 
-const { item, isLeaf } = defineProps<Props>();
+const { item, isLeaf, showCrs = false } = defineProps<Props>();
 
 interface Emits {
   contextmenu: [event: MouseEvent];
@@ -53,6 +57,19 @@ const tooltipTitle = computed<string>(() =>
   ),
 );
 
+const crsStore = useCrsStore();
+// Only top-level data carry a CRS: their stored item is read live so edits show at once
+const dataItem = useLiveDataItem(() => (showCrs ? actualItem.value.id : undefined));
+const crsLabel = computed<string>(
+  () =>
+    middleTruncate(
+      formatCrs(dataItem.value?.crs),
+      TOOLTIP_NAME_MAX_LENGTH,
+      TOOLTIP_NAME_START_CHARS,
+      TOOLTIP_NAME_END_CHARS,
+    ) ?? "",
+);
+
 const tooltipDisabled = computed<boolean>(() => {
   if (actualItem.value.category !== undefined) {
     return false;
@@ -127,6 +144,22 @@ async function copyToClipboard(text: string, label: string): Promise<void> {
             <v-icon size="12">mdi-content-copy</v-icon>
           </v-btn>
         </span>
+        <span v-if="showCrs" class="text-caption d-flex align-center">
+          <strong class="text-white mr-1">CRS:</strong>
+          <span data-testid="tooltipCrsValue">{{ crsLabel }}</span>
+          <v-btn
+            v-if="crsStore.crsEditEnabled"
+            data-testid="editCrsBtn"
+            icon
+            variant="text"
+            density="compact"
+            class="ml-1 text-white"
+            style="width: 18px; height: 18px; min-width: 18px; min-height: 18px"
+            @click.stop="crsStore.requestCrsEdit(actualItem.id)"
+          >
+            <v-icon size="12">mdi-pencil</v-icon>
+          </v-btn>
+        </span>
         <span v-if="actualItem.is_active !== undefined" class="text-caption d-flex align-center">
           <strong class="text-white mr-1">Status:</strong>
           <i class="ml-1">{{ actualItem.is_active ? "Active" : "Inactive" }}</i>
diff --git a/app/components/Viewer/ObjectTree/Views/GlobalObjects.vue b/app/components/Viewer/ObjectTree/Views/GlobalObjects.vue
index 0c5e6fb00..d64494b80 100644
--- a/app/components/Viewer/ObjectTree/Views/GlobalObjects.vue
+++ b/app/components/Viewer/ObjectTree/Views/GlobalObjects.vue
@@ -190,6 +190,7 @@ function expandAll(): void {
         <ObjectTreeItemLabel
           :item="item as unknown as DisplayItem"
           :is-leaf="isLeaf"
+          :show-crs="isLeaf"
           @contextmenu="showMenu($event, item as unknown as TreeGroupItem)"
         />
       </template>
diff --git a/app/composables/live_data_item.ts b/app/composables/live_data_item.ts
new file mode 100644
index 000000000..d9c44b4c9
--- /dev/null
+++ b/app/composables/live_data_item.ts
@@ -0,0 +1,39 @@
+import { type DataItem, useDataStore } from "@ogw_front/stores/data";
+import type { EffectScope, MaybeRefOrGetter, ShallowRef } from "vue";
+
+// Live view of a data item whose id can change: tree labels are reused by the virtual list,
+// And the info card shows whichever object the menu was last opened on.
+export function useLiveDataItem(
+  id: MaybeRefOrGetter<string | undefined>,
+): ShallowRef<DataItem | undefined> {
+  const dataStore = useDataStore();
+  const item = shallowRef<DataItem | undefined>(undefined);
+  let itemScope: EffectScope | undefined = undefined;
+
+  watch(
+    () => toValue(id),
+    (newId) => {
+      itemScope?.stop();
+      itemScope = undefined;
+      item.value = undefined;
+      if (newId === undefined) {
+        return;
+      }
+      itemScope = effectScope();
+      itemScope.run(() => {
+        const liveItem = dataStore.refItem(newId);
+        watch(
+          liveItem,
+          (value) => {
+            item.value = value;
+          },
+          { immediate: true },
+        );
+      });
+    },
+    { immediate: true },
+  );
+  onScopeDispose(() => itemScope?.stop());
+
+  return item;
+}
diff --git a/tests/unit/components/InfoCard.nuxt.test.ts b/tests/unit/components/InfoCard.nuxt.test.ts
new file mode 100644
index 000000000..15685fd73
--- /dev/null
+++ b/tests/unit/components/InfoCard.nuxt.test.ts
@@ -0,0 +1,63 @@
+import { beforeEach, describe, expect, test, vi } from "vitest";
+import { mockAs, setupActivePinia, vuetify } from "@ogw_tests/utils";
+import InfoCard from "@ogw_front/components/Viewer/ContextMenu/InfoCard.vue";
+import { mountSuspended } from "@nuxt/test-utils/runtime";
+import { ref } from "vue";
+import { useCrsStore } from "@ogw_front/stores/crs";
+import { useDataStore } from "@ogw_front/stores/data";
+
+vi.setConfig({ testTimeout: 10_000 });
+
+const LAMBERT = { authority: "EPSG", code: "2154", name: "RGF93 v1 / Lambert-93" };
+const UTM = { authority: "EPSG", code: "32631", name: "WGS 84 / UTM zone 31N" };
+
+describe("info card crs", () => {
+  // oxlint-disable-next-line eslint/init-declarations -- assigned in beforeEach before any test runs
+  let pinia: ReturnType<typeof setupActivePinia>;
+
+  beforeEach(() => {
+    pinia = setupActivePinia();
+  });
+
+  test("shows the data crs and asks for an edit", async () => {
+    const crsStore = useCrsStore();
+    crsStore.enableCrsEdit();
+    const wrapper = await mountSuspended(InfoCard, {
+      global: { plugins: [vuetify, pinia] },
+      props: { show: true, metaData: { id: "data-1", name: "cube", crs: LAMBERT } },
+    });
+    // The card is narrow: the code alone, the full name is in the tooltip
+    expect(wrapper.get('[data-testid="infoCrsValue"]').text()).toBe("EPSG:2154");
+    await wrapper.get('[data-testid="infoEditCrsBtn"]').trigger("click");
+    expect(crsStore.crsEditRequest).toBe("data-1");
+  });
+
+  test("hides the edit button when the host app cannot edit", async () => {
+    const wrapper = await mountSuspended(InfoCard, {
+      global: { plugins: [vuetify, pinia] },
+      props: { show: true, metaData: { id: "data-2", name: "cube" } },
+    });
+    expect(wrapper.get('[data-testid="infoCrsValue"]').text()).toBe("None");
+    expect(wrapper.find('[data-testid="infoEditCrsBtn"]').exists()).toBe(false);
+  });
+
+  test("has no crs row for a model component", async () => {
+    const wrapper = await mountSuspended(InfoCard, {
+      global: { plugins: [vuetify, pinia] },
+      props: { show: true, metaData: { id: "comp-1", modelId: "model-1", name: "Block" } },
+    });
+    expect(wrapper.find('[data-testid="infoCrsValue"]').exists()).toBe(false);
+  });
+
+  test("shows the crs stored after an edit, not the one captured when the menu opened", async () => {
+    const dataStore = useDataStore();
+    dataStore.refItem = mockAs<typeof dataStore.refItem>(
+      vi.fn<() => unknown>().mockReturnValue(ref({ id: "data-3", crs: UTM })),
+    );
+    const wrapper = await mountSuspended(InfoCard, {
+      global: { plugins: [vuetify, pinia] },
+      props: { show: true, metaData: { id: "data-3", name: "cube", crs: LAMBERT } },
+    });
+    expect(wrapper.get('[data-testid="infoCrsValue"]').text()).toBe("EPSG:32631");
+  });
+});
diff --git a/tests/unit/components/ItemLabel.nuxt.test.ts b/tests/unit/components/ItemLabel.nuxt.test.ts
index 2983b3fef..6b91cf846 100644
--- a/tests/unit/components/ItemLabel.nuxt.test.ts
+++ b/tests/unit/components/ItemLabel.nuxt.test.ts
@@ -1,11 +1,16 @@
 // Third party imports
-import { describe, expect, test } from "vitest";
+import { describe, expect, test, vi } from "vitest";
 import { mountSuspended } from "@nuxt/test-utils/runtime";
 
 // Local imports
-import { setupActivePinia, vuetify } from "@ogw_tests/utils";
+import { mockAs, setupActivePinia, vuetify } from "@ogw_tests/utils";
 import type { DisplayItem } from "@ogw_front/composables/virtual_tree";
 import ItemLabel from "@ogw_front/components/Viewer/ObjectTree/Base/ItemLabel.vue";
+import { ref } from "vue";
+import { useCrsStore } from "@ogw_front/stores/crs";
+import { useDataStore } from "@ogw_front/stores/data";
+
+vi.setConfig({ testTimeout: 10_000 });
 
 const DATA_ID_LENGTH = 32;
 const DATA_ID = "a".repeat(DATA_ID_LENGTH);
@@ -41,4 +46,57 @@ describe("item label tooltip", () => {
     });
     expect(wrapper.find('[data-testid="tooltipIdValue"]').exists()).toBe(false);
   });
+
+  test("shows the crs and asks for an edit when enabled", async () => {
+    const LAMBERT = { authority: "EPSG", code: "2154", name: "RGF93 v1 / Lambert-93" };
+    const dataStore = useDataStore();
+    dataStore.refItem = mockAs<typeof dataStore.refItem>(
+      vi.fn<() => unknown>().mockReturnValue(ref({ id: DATA_ID, crs: LAMBERT })),
+    );
+    const crsStore = useCrsStore();
+    crsStore.enableCrsEdit();
+    const wrapper = await mountSuspended(ItemLabel, {
+      global: { plugins: [vuetify, pinia], stubs: { VTooltip: VTooltipStub } },
+      props: {
+        item: leaf({ id: DATA_ID, geode_id: GEODE_ID, title: "cube" }),
+        isLeaf: true,
+        showCrs: true,
+      },
+    });
+    expect(wrapper.get('[data-testid="tooltipCrsValue"]').text()).toContain("EPSG:2154");
+    await wrapper.get('[data-testid="editCrsBtn"]').trigger("click");
+    expect(crsStore.crsEditRequest).toBe(DATA_ID);
+  });
+
+  test("has no crs row without showCrs", async () => {
+    const wrapper = await mountSuspended(ItemLabel, {
+      global: { plugins: [vuetify, pinia], stubs: { VTooltip: VTooltipStub } },
+      props: { item: leaf({ id: DATA_ID, geode_id: GEODE_ID, title: "cube" }), isLeaf: true },
+    });
+    expect(wrapper.find('[data-testid="tooltipCrsValue"]').exists()).toBe(false);
+  });
+
+  test("follows the item when the row is reused for another data", async () => {
+    const LAMBERT = { authority: "EPSG", code: "2154", name: "RGF93 v1 / Lambert-93" };
+    const OTHER_ID = "b".repeat(DATA_ID_LENGTH);
+    const items: Record<string, unknown> = {
+      [DATA_ID]: { id: DATA_ID },
+      [OTHER_ID]: { id: OTHER_ID, crs: LAMBERT },
+    };
+    const dataStore = useDataStore();
+    dataStore.refItem = mockAs<typeof dataStore.refItem>(
+      vi.fn<(id: string) => unknown>().mockImplementation((id) => ref(items[id])),
+    );
+    const wrapper = await mountSuspended(ItemLabel, {
+      global: { plugins: [vuetify, pinia], stubs: { VTooltip: VTooltipStub } },
+      props: { item: leaf({ id: DATA_ID, title: "group" }), isLeaf: false, showCrs: false },
+    });
+    // The virtual tree reuses this label for another row
+    await wrapper.setProps({
+      item: leaf({ id: OTHER_ID, geode_id: GEODE_ID, title: "points" }),
+      isLeaf: true,
+      showCrs: true,
+    });
+    expect(wrapper.get('[data-testid="tooltipCrsValue"]').text()).toContain("EPSG:2154");
+  });
 });

From 7d63fb73ca564015e1a74cec6ba4cddbc17b5ef9 Mon Sep 17 00:00:00 2001
From: MaxNumerique <maximilienlandois@gmail.com>
Date: Fri, 23 Oct 2026 13:27:21 +0200
Subject: [PATCH 07/29] feat(feedback): optional action button on snackbars

---
 app/components/FeedBack/Snackers.vue          | 23 ++++++
 app/stores/feedback.ts                        | 14 +++-
 .../components/FeedBack/Snackers.nuxt.test.ts | 76 +++++++++++++++----
 tests/unit/stores/feedback.nuxt.test.ts       | 19 +++++
 4 files changed, 116 insertions(+), 16 deletions(-)

diff --git a/app/components/FeedBack/Snackers.vue b/app/components/FeedBack/Snackers.vue
index d132da425..16b96ef28 100644
--- a/app/components/FeedBack/Snackers.vue
+++ b/app/components/FeedBack/Snackers.vue
@@ -10,6 +10,11 @@ const show = ref<boolean>(true);
 function calc_margin(index: number): string {
   return `${index * MARGIN_BETWEEN_SNACKERS + FIRST_SNACKER_MARGIN}px`;
 }
+
+function runAction(feedback: (typeof feedbackStore.feedbacks)[number]): void {
+  feedback.action?.onClick();
+  feedbackStore.delete_feedback(feedback.id);
+}
 </script>
 
 <template>
@@ -62,9 +67,27 @@ function calc_margin(index: number): string {
         </v-tooltip>
       </v-col>
       <v-spacer />
+      <v-col v-if="feedback.action" cols="auto">
+        <v-tooltip location="top" :text="feedback.action.label">
+          <template #activator="{ props }">
+            <v-btn
+              v-bind="props"
+              icon
+              variant="flat"
+              size="20"
+              :color="feedback.type"
+              data-testid="feedbackActionBtn"
+              @click.stop="runAction(feedback)"
+            >
+              <v-icon icon="mdi-pencil" size="20" color="white" />
+            </v-btn>
+          </template>
+        </v-tooltip>
+      </v-col>
       <v-col cols="auto">
         <v-btn
           icon
+          data-testid="feedbackCloseBtn"
           variant="flat"
           size="20"
           :color="feedback.type"
diff --git a/app/stores/feedback.ts b/app/stores/feedback.ts
index 1ca36c684..880279033 100644
--- a/app/stores/feedback.ts
+++ b/app/stores/feedback.ts
@@ -5,6 +5,11 @@ const DEFAULT_FEEDBACKS_TIMEOUT_SECONDS = 10;
 
 type FeedbackType = "error" | "success" | "warning";
 
+interface FeedbackAction {
+  label: string;
+  onClick: () => void;
+}
+
 interface Feedback {
   id: string;
   type: FeedbackType;
@@ -12,6 +17,7 @@ interface Feedback {
   route?: string;
   name?: string;
   description?: string;
+  action?: FeedbackAction;
 }
 
 export const useFeedbackStore = defineStore("feedback", {
@@ -35,23 +41,25 @@ export const useFeedbackStore = defineStore("feedback", {
         this.delete_feedback(feedbackId);
       }, this.feedbacks_timeout_miliseconds);
     },
-    add_success(description: string) {
+    add_success(description: string, action?: FeedbackAction) {
       const feedbackId = uuidv4();
       this.feedbacks.push({
         id: feedbackId,
         type: "success",
         description,
+        ...(action === undefined ? {} : { action }),
       });
       setTimeout(() => {
         this.delete_feedback(feedbackId);
       }, this.feedbacks_timeout_miliseconds);
     },
-    add_warning(description: string) {
+    add_warning(description: string, action?: FeedbackAction) {
       const feedbackId = uuidv4();
       this.feedbacks.push({
         id: feedbackId,
         type: "warning",
         description,
+        ...(action === undefined ? {} : { action }),
       });
       setTimeout(() => {
         this.delete_feedback(feedbackId);
@@ -65,3 +73,5 @@ export const useFeedbackStore = defineStore("feedback", {
     },
   },
 });
+
+export type { FeedbackAction };
diff --git a/tests/unit/components/FeedBack/Snackers.nuxt.test.ts b/tests/unit/components/FeedBack/Snackers.nuxt.test.ts
index 08295dfc2..5910e8f98 100644
--- a/tests/unit/components/FeedBack/Snackers.nuxt.test.ts
+++ b/tests/unit/components/FeedBack/Snackers.nuxt.test.ts
@@ -10,6 +10,33 @@ import { useFeedbackStore } from "@ogw_front/stores/feedback";
 
 vi.stubGlobal("visualViewport", new EventTarget());
 
+function mountSnackers(pinia: ReturnType<typeof setupActivePinia>): ReturnType<typeof mount> {
+  return mount(
+    {
+      template: "<v-layout><FeedBackSnackers/></v-layout>",
+    },
+    {
+      props: {},
+      global: {
+        components: {
+          FeedBackSnackers,
+        },
+        plugins: [vuetify, pinia],
+      },
+    },
+  );
+}
+
+// The snackbar is teleported out of the wrapper: buttons are found as components
+function findButton(
+  wrapper: ReturnType<typeof mount>,
+  testId: string,
+): ReturnType<typeof wrapper.findComponent> | undefined {
+  return wrapper
+    .findAllComponents(components.VBtn)
+    .find((button) => button.attributes("data-testid") === testId);
+}
+
 describe("feedback snackers", () => {
   test("delete feedback", async () => {
     const pinia = setupActivePinia();
@@ -26,24 +53,45 @@ describe("feedback snackers", () => {
       ],
     });
 
-    const wrapper = mount(
-      {
-        template: "<v-layout><FeedBackSnackers/></v-layout>",
-      },
-      {
-        props: {},
-        global: {
-          components: {
-            FeedBackSnackers,
-          },
-          plugins: [vuetify, pinia],
-        },
-      },
-    );
+    const wrapper = mountSnackers(pinia);
 
     expect(feedbackStore.feedbacks).toHaveLength(1);
     const v_btn = wrapper.findComponent(components.VBtn);
     await v_btn.trigger("click");
     expect(feedbackStore.feedbacks).toHaveLength(0);
   });
+
+  test("no action button without action", () => {
+    const pinia = setupActivePinia();
+    useFeedbackStore().$patch({
+      feedbacks: [{ id: "1", type: "warning", description: "test description" }],
+    });
+
+    const wrapper = mountSnackers(pinia);
+
+    expect(findButton(wrapper, "feedbackCloseBtn")).toBeDefined();
+    expect(findButton(wrapper, "feedbackActionBtn")).toBeUndefined();
+  });
+
+  test("action button runs the action then removes the feedback", async () => {
+    const pinia = setupActivePinia();
+    const feedbackStore = useFeedbackStore();
+    const onClick = vi.fn<() => void>();
+    feedbackStore.$patch({
+      feedbacks: [
+        {
+          id: "1",
+          type: "warning",
+          description: "test description",
+          action: { label: "Edit CRS", onClick },
+        },
+      ],
+    });
+
+    const wrapper = mountSnackers(pinia);
+    await findButton(wrapper, "feedbackActionBtn")?.trigger("click");
+
+    expect(onClick).toHaveBeenCalledExactlyOnceWith();
+    expect(feedbackStore.feedbacks).toHaveLength(0);
+  });
 });
diff --git a/tests/unit/stores/feedback.nuxt.test.ts b/tests/unit/stores/feedback.nuxt.test.ts
index a12bf8e9a..0c860f330 100644
--- a/tests/unit/stores/feedback.nuxt.test.ts
+++ b/tests/unit/stores/feedback.nuxt.test.ts
@@ -77,6 +77,25 @@ describe("feedback store", () => {
         vi.runAllTimers();
         expect(feedbackStore.feedbacks).toHaveLength(0);
       });
+
+      test("stores the action when given", () => {
+        const feedbackStore = useFeedbackStore();
+        const onClick = vi.fn<() => void>();
+        feedbackStore.add_warning("test description", { label: "Edit CRS", onClick });
+        const [feedback] = feedbackStore.feedbacks;
+        assertIsDefined(feedback);
+        expect(feedback.action?.label).toBe("Edit CRS");
+        feedback.action?.onClick();
+        expect(onClick).toHaveBeenCalledExactlyOnceWith();
+      });
+
+      test("has no action by default", () => {
+        const feedbackStore = useFeedbackStore();
+        feedbackStore.add_warning("test description");
+        const [feedback] = feedbackStore.feedbacks;
+        assertIsDefined(feedback);
+        expect(feedback).not.toHaveProperty("action");
+      });
     });
 
     describe("delete_feedback", () => {

From 24f6f18a62d0e7ad9a8cb29d02db7f2b6de3ff4b Mon Sep 17 00:00:00 2001
From: MaxNumerique <maximilienlandois@gmail.com>
Date: Fri, 23 Oct 2026 15:01:21 +0200
Subject: [PATCH 08/29] compact

---
 app/components/CrsSelector.vue                | 28 ++++++++++++++++---
 .../unit/components/CrsSelector.nuxt.test.ts  | 20 +++++++++++++
 2 files changed, 44 insertions(+), 4 deletions(-)

diff --git a/app/components/CrsSelector.vue b/app/components/CrsSelector.vue
index 310c19a59..68df06704 100644
--- a/app/components/CrsSelector.vue
+++ b/app/components/CrsSelector.vue
@@ -4,9 +4,11 @@ import { useCrsStore } from "@ogw_front/stores/crs";
 
 interface Props {
   geodeObjectType: string;
+  // Narrow containers: one "AUTHORITY:CODE" column and a truncated name
+  compact?: boolean;
 }
 
-const { geodeObjectType } = defineProps<Props>();
+const { geodeObjectType, compact = false } = defineProps<Props>();
 const selectedCrs = defineModel<CRSList | undefined>();
 
 const search = ref<string>("");
@@ -35,7 +37,7 @@ async function get_crs_table(): Promise<void> {
   toggle_loading();
 }
 
-const headers = [
+const full_headers = [
   {
     title: "Authority",
     align: "start",
@@ -46,6 +48,14 @@ const headers = [
   { title: "Name", align: "end", key: "name" },
 ] as const;
 
+// A max width of 0 lets the name take the remaining space and truncate instead of wrapping
+const compact_headers = [
+  { title: "Code", align: "start", key: "code", value: crs_key, width: 110, nowrap: true },
+  { title: "Name", align: "start", key: "name", maxWidth: 0, nowrap: true },
+] as const;
+
+const headers = computed(() => (compact ? compact_headers : full_headers));
+
 // Not awaited in setup: the table renders right away with its loader
 onMounted(async () => {
   await get_crs_table();
@@ -56,7 +66,8 @@ onMounted(async () => {
   <v-text-field
     v-model="search"
     data-testid="crsSearchInput"
-    append-icon="mdi-magnify"
+    :append-icon="compact ? undefined : 'mdi-magnify'"
+    :prepend-inner-icon="compact ? 'mdi-magnify' : undefined"
     label="Search"
     single-line
     hide-details
@@ -75,5 +86,14 @@ onMounted(async () => {
     :search="search"
     :loading="data_table_loading"
     loading-text="Loading... Please wait"
-  ></v-data-table>
+  >
+    <template v-if="compact" #[`item.name`]="{ value }">
+      <v-tooltip :text="value" location="top">
+        <template #activator="{ props: tooltipProps }">
+          <span v-bind="tooltipProps">{{ value }}</span>
+        </template>
+      </v-tooltip>
+    </template>
+  </v-data-table>
 </template>
+
diff --git a/tests/unit/components/CrsSelector.nuxt.test.ts b/tests/unit/components/CrsSelector.nuxt.test.ts
index 93cfec49f..3c99b7105 100644
--- a/tests/unit/components/CrsSelector.nuxt.test.ts
+++ b/tests/unit/components/CrsSelector.nuxt.test.ts
@@ -84,6 +84,26 @@ describe("crs selector", () => {
     ).toStrictEqual(crs_list[ESRI_INDEX]);
   });
 
+  test("compact mode shows the authority code and the name only", async () => {
+    const crs_list = [{ authority: "EPSG", code: "2154", name: "RGF93 v1 / Lambert-93" }];
+    const crsStore = useCrsStore();
+    crsStore.geographicList = mockAs<typeof crsStore.geographicList>(
+      vi.fn().mockResolvedValue(crs_list),
+    );
+
+    const wrapper = await mountSuspended(CrsSelector, {
+      global: {
+        plugins: [vuetify, pinia],
+      },
+      props: { geodeObjectType: "BRep", compact: true },
+    });
+    await wrapper.vm.$nextTick();
+    const headers = wrapper.findAll("th").map((header) => header.text());
+    expect(headers).toStrictEqual(["", "Code", "Name"]);
+    const cells = wrapper.findAll("tbody td").map((cell) => cell.text());
+    expect(cells).toStrictEqual(["", "EPSG:2154", "RGF93 v1 / Lambert-93"]);
+  });
+
   test("shows the table loader while the crs list loads", async () => {
     const crsStore = useCrsStore();
     crsStore.geographicList = mockAs<typeof crsStore.geographicList>(

From 70b69af8f11482556025e62bee1c3d56cc5ebeaf Mon Sep 17 00:00:00 2001
From: MaxNumerique <144453705+MaxNumerique@users.noreply.github.com>
Date: Fri, 23 Oct 2026 13:02:19 +0000
Subject: [PATCH 09/29] Apply prepare changes

---
 app/components/CrsSelector.vue | 1 -
 1 file changed, 1 deletion(-)

diff --git a/app/components/CrsSelector.vue b/app/components/CrsSelector.vue
index 68df06704..cd47d0772 100644
--- a/app/components/CrsSelector.vue
+++ b/app/components/CrsSelector.vue
@@ -96,4 +96,3 @@ onMounted(async () => {
     </template>
   </v-data-table>
 </template>
-

From 075af2d4795846e1ef6d404b2bce5437fdc36962 Mon Sep 17 00:00:00 2001
From: MaxNumerique <maximilienlandois@gmail.com>
Date: Fri, 23 Oct 2026 15:47:19 +0200
Subject: [PATCH 10/29] fix(viewer): rebuild the actor only when the geometry
 moved, keep camera and z-scale [skip ci]

---
 app/utils/import_workflow.ts                  | 11 ++++++++---
 internal/stores/hybrid_viewer/scene.ts        |  6 ++++--
 tests/unit/utils/import_workflow.nuxt.test.ts | 14 +++++++++++---
 3 files changed, 23 insertions(+), 8 deletions(-)

diff --git a/app/utils/import_workflow.ts b/app/utils/import_workflow.ts
index b880c032d..675fc7ced 100644
--- a/app/utils/import_workflow.ts
+++ b/app/utils/import_workflow.ts
@@ -163,15 +163,20 @@ async function importWorkflowFromSnapshot(items: readonly NewDataItem[]): Promis
 }
 
 // Reloads the viewer object under the same id with its stored style, after the back rewrote its files.
-async function reloadObject(id: string): Promise<void> {
+async function reloadObject(
+  id: string,
+  { rebuildActor = false }: { rebuildActor?: boolean } = {},
+): Promise<void> {
   const dataStore = useDataStore();
   const dataStyleStore = useDataStyleStore();
   const hybridViewerStore = useHybridViewerStore();
   const item = await dataStore.item(id);
   await dataStore.deregisterObject(id);
   await dataStore.registerObject(id, item.name ?? id);
-  // The local actor is rebuilt from the stored light viewable, which may have moved
-  await hybridViewerStore.addItem(id);
+  // Only when the geometry moved: the local actor is rebuilt from the stored light viewable
+  if (rebuildActor) {
+    await hybridViewerStore.addItem(id);
+  }
   await dataStyleStore.applyDefaultStyle(id);
   await hybridViewerStore.remoteRender();
 }
diff --git a/internal/stores/hybrid_viewer/scene.ts b/internal/stores/hybrid_viewer/scene.ts
index 91de92a54..d0144735d 100644
--- a/internal/stores/hybrid_viewer/scene.ts
+++ b/internal/stores/hybrid_viewer/scene.ts
@@ -39,12 +39,14 @@ const useHybridViewerScene = createSharedComposable(() => {
     const property = actor.getProperty();
     property.setColor(ACTOR_COLOR);
     actor.setMapper(mapper);
+    // The scene z-scaling also applies to actors added after it was set
+    actor.setScale(1, 1, zScale.value);
     const renderer = genericRenderWindow.value.getRenderer();
+    // Replacing an actor keeps the camera where the user left it
+    const isFirst = !hybridDb[id] && renderer.getActors().length === 0;
     if (hybridDb[id]) {
       renderer.removeActor(hybridDb[id].actor);
     }
-    const actors = renderer.getActors();
-    const isFirst = actors.length === 0;
     renderer.addActor(actor);
     if (isFirst) {
       renderer.resetCamera();
diff --git a/tests/unit/utils/import_workflow.nuxt.test.ts b/tests/unit/utils/import_workflow.nuxt.test.ts
index e2e434734..8cc4d3419 100644
--- a/tests/unit/utils/import_workflow.nuxt.test.ts
+++ b/tests/unit/utils/import_workflow.nuxt.test.ts
@@ -73,7 +73,8 @@ describe("apply time series workflow", () => {
     expect(request).toHaveBeenCalledWith(
       expect.objectContaining({ params: { id: "brep_id", filename: "time_series.pvd" } }),
     );
-    expect(calls).toStrictEqual(["deregister", "register", "hybrid", "style"]);
+    // The geometry is unchanged: the local actor (and the camera) are kept
+    expect(calls).toStrictEqual(["deregister", "register", "style"]);
     expect(applyDefaultStyle).toHaveBeenCalledWith("brep_id");
     expect(remoteRender).toHaveBeenCalledWith();
   });
@@ -96,11 +97,18 @@ describe("reload object", () => {
     await reloadObject("brep_id");
 
     expect(request).not.toHaveBeenCalled();
-    // The local actor is rebuilt too: the light viewable may have moved
-    expect(calls).toStrictEqual(["deregister", "register", "hybrid", "style"]);
+    expect(calls).toStrictEqual(["deregister", "register", "style"]);
     expect(applyDefaultStyle).toHaveBeenCalledWith("brep_id");
     expect(remoteRender).toHaveBeenCalledWith();
   });
+
+  test("rebuilds the local actor when the geometry moved", async () => {
+    const { calls } = setup();
+
+    await reloadObject("brep_id", { rebuildActor: true });
+
+    expect(calls).toStrictEqual(["deregister", "register", "hybrid", "style"]);
+  });
 });
 
 describe("import workflow", () => {

From 9dfbfd79a74b08f08c12d07370d4ea70f8c8ea73 Mon Sep 17 00:00:00 2001
From: MaxNumerique <maximilienlandois@gmail.com>
Date: Fri, 23 Oct 2026 15:49:38 +0200
Subject: [PATCH 11/29] read the data only while the tooltip is open [skip ci]

---
 .../Viewer/ObjectTree/Base/ItemLabel.vue      |  9 ++++--
 tests/unit/components/ItemLabel.nuxt.test.ts  | 28 +++++++++++++++++--
 2 files changed, 33 insertions(+), 4 deletions(-)

diff --git a/app/components/Viewer/ObjectTree/Base/ItemLabel.vue b/app/components/Viewer/ObjectTree/Base/ItemLabel.vue
index c0e15ae3a..d9d0889c2 100644
--- a/app/components/Viewer/ObjectTree/Base/ItemLabel.vue
+++ b/app/components/Viewer/ObjectTree/Base/ItemLabel.vue
@@ -58,8 +58,12 @@ const tooltipTitle = computed<string>(() =>
 );
 
 const crsStore = useCrsStore();
-// Only top-level data carry a CRS: their stored item is read live so edits show at once
-const dataItem = useLiveDataItem(() => (showCrs ? actualItem.value.id : undefined));
+const tooltipOpen = ref(false);
+// Only top-level data carry a CRS: their stored item is read live, and only while the
+// Tooltip is open, so the rows of a long tree do not each keep a database query
+const dataItem = useLiveDataItem(() =>
+  showCrs && tooltipOpen.value ? actualItem.value.id : undefined,
+);
 const crsLabel = computed<string>(
   () =>
     middleTruncate(
@@ -93,6 +97,7 @@ async function copyToClipboard(text: string, label: string): Promise<void> {
     class="tree-item-label-container w-100"
   >
     <v-tooltip
+      v-model="tooltipOpen"
       :disabled="tooltipDisabled"
       location="right"
       open-delay="400"
diff --git a/tests/unit/components/ItemLabel.nuxt.test.ts b/tests/unit/components/ItemLabel.nuxt.test.ts
index 6b91cf846..20242d42a 100644
--- a/tests/unit/components/ItemLabel.nuxt.test.ts
+++ b/tests/unit/components/ItemLabel.nuxt.test.ts
@@ -24,6 +24,15 @@ const VTooltipStub = {
   template: '<div><slot name="activator" :props="{}" /><slot /></div>',
 };
 
+// The stored item is only read once the tooltip opens
+const OpenTooltipStub = {
+  emits: ["update:modelValue"],
+  mounted(this: { $emit: (event: "update:modelValue", value: boolean) => void }): void {
+    this.$emit("update:modelValue", true);
+  },
+  template: VTooltipStub.template,
+};
+
 describe("item label tooltip", () => {
   const pinia = setupActivePinia();
 
@@ -56,7 +65,7 @@ describe("item label tooltip", () => {
     const crsStore = useCrsStore();
     crsStore.enableCrsEdit();
     const wrapper = await mountSuspended(ItemLabel, {
-      global: { plugins: [vuetify, pinia], stubs: { VTooltip: VTooltipStub } },
+      global: { plugins: [vuetify, pinia], stubs: { VTooltip: OpenTooltipStub } },
       props: {
         item: leaf({ id: DATA_ID, geode_id: GEODE_ID, title: "cube" }),
         isLeaf: true,
@@ -68,6 +77,21 @@ describe("item label tooltip", () => {
     expect(crsStore.crsEditRequest).toBe(DATA_ID);
   });
 
+  test("does not read the stored item while the tooltip is closed", async () => {
+    const dataStore = useDataStore();
+    const refItem = vi.fn<() => unknown>().mockReturnValue(ref({ id: DATA_ID }));
+    dataStore.refItem = mockAs<typeof dataStore.refItem>(refItem);
+    await mountSuspended(ItemLabel, {
+      global: { plugins: [vuetify, pinia], stubs: { VTooltip: VTooltipStub } },
+      props: {
+        item: leaf({ id: DATA_ID, geode_id: GEODE_ID, title: "cube" }),
+        isLeaf: true,
+        showCrs: true,
+      },
+    });
+    expect(refItem).not.toHaveBeenCalled();
+  });
+
   test("has no crs row without showCrs", async () => {
     const wrapper = await mountSuspended(ItemLabel, {
       global: { plugins: [vuetify, pinia], stubs: { VTooltip: VTooltipStub } },
@@ -88,7 +112,7 @@ describe("item label tooltip", () => {
       vi.fn<(id: string) => unknown>().mockImplementation((id) => ref(items[id])),
     );
     const wrapper = await mountSuspended(ItemLabel, {
-      global: { plugins: [vuetify, pinia], stubs: { VTooltip: VTooltipStub } },
+      global: { plugins: [vuetify, pinia], stubs: { VTooltip: OpenTooltipStub } },
       props: { item: leaf({ id: DATA_ID, title: "group" }), isLeaf: false, showCrs: false },
     });
     // The virtual tree reuses this label for another row

From 94b9c4643d12ab150f02d9eead9f0edf6822c297 Mon Sep 17 00:00:00 2001
From: MaxNumerique <maximilienlandois@gmail.com>
Date: Fri, 23 Oct 2026 15:51:15 +0200
Subject: [PATCH 12/29] fix(feedback): close the snackbar when its action fails
 [skip ci]

---
 app/components/FeedBack/Snackers.vue          |  8 +++-
 .../components/FeedBack/Snackers.nuxt.test.ts | 38 +++++++++++++++++++
 2 files changed, 44 insertions(+), 2 deletions(-)

diff --git a/app/components/FeedBack/Snackers.vue b/app/components/FeedBack/Snackers.vue
index 16b96ef28..ca42955ae 100644
--- a/app/components/FeedBack/Snackers.vue
+++ b/app/components/FeedBack/Snackers.vue
@@ -12,8 +12,12 @@ function calc_margin(index: number): string {
 }
 
 function runAction(feedback: (typeof feedbackStore.feedbacks)[number]): void {
-  feedback.action?.onClick();
-  feedbackStore.delete_feedback(feedback.id);
+  try {
+    feedback.action?.onClick();
+  } finally {
+    // The snackbar closes even when the action fails
+    feedbackStore.delete_feedback(feedback.id);
+  }
 }
 </script>
 
diff --git a/tests/unit/components/FeedBack/Snackers.nuxt.test.ts b/tests/unit/components/FeedBack/Snackers.nuxt.test.ts
index 5910e8f98..29d5aa518 100644
--- a/tests/unit/components/FeedBack/Snackers.nuxt.test.ts
+++ b/tests/unit/components/FeedBack/Snackers.nuxt.test.ts
@@ -94,4 +94,42 @@ describe("feedback snackers", () => {
     expect(onClick).toHaveBeenCalledExactlyOnceWith();
     expect(feedbackStore.feedbacks).toHaveLength(0);
   });
+
+  test("a failing action still removes the feedback", async () => {
+    const pinia = setupActivePinia();
+    const feedbackStore = useFeedbackStore();
+    const onClick = vi.fn<() => void>().mockImplementation(() => {
+      throw new Error("action failed");
+    });
+    feedbackStore.$patch({
+      feedbacks: [
+        {
+          id: "1",
+          type: "warning",
+          description: "test description",
+          action: { label: "Edit CRS", onClick },
+        },
+      ],
+    });
+    const errorHandler = vi.fn<() => void>();
+
+    const wrapper = mount(
+      { template: "<v-layout><FeedBackSnackers/></v-layout>" },
+      {
+        global: {
+          components: { FeedBackSnackers },
+          plugins: [vuetify, pinia],
+          config: { errorHandler },
+        },
+      },
+    );
+    await findButton(wrapper, "feedbackActionBtn")?.trigger("click");
+
+    expect(errorHandler).toHaveBeenCalledExactlyOnceWith(
+      expect.any(Error),
+      expect.anything(),
+      expect.any(String),
+    );
+    expect(feedbackStore.feedbacks).toHaveLength(0);
+  });
 });

From 223c6db209d1ba247e8d3c5b07a7866ce73ad959 Mon Sep 17 00:00:00 2001
From: MaxNumerique <maximilienlandois@gmail.com>
Date: Fri, 23 Oct 2026 15:52:05 +0200
Subject: [PATCH 13/29] fix(InfoCard): Vuetify classes and keyboard-reachable
 CRS edit button [skip ci]

---
 app/components/Viewer/ContextMenu/InfoCard.vue | 17 +++++++----------
 tests/unit/components/InfoCard.nuxt.test.ts    |  5 ++++-
 2 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/app/components/Viewer/ContextMenu/InfoCard.vue b/app/components/Viewer/ContextMenu/InfoCard.vue
index f31d98197..d4f9751c8 100644
--- a/app/components/Viewer/ContextMenu/InfoCard.vue
+++ b/app/components/Viewer/ContextMenu/InfoCard.vue
@@ -180,16 +180,19 @@ const liveCrs = computed(() => liveItem.value?.crs ?? metaData.crs);
           </v-col>
           <v-col
             v-if="isData"
-            class="id-badge-container crs-badge mt-1 d-inline-flex align-center px-2 py-0.5"
+            class="mt-1 d-inline-flex align-center px-2 py-0.5 text-caption"
+            style="font-size: 0.6rem"
           >
-            <span class="crs-label mr-1">CRS</span>
+            <span class="font-weight-black text-secondary mr-1">CRS</span>
             <span class="id-text" data-testid="infoCrsValue">{{ formatCrsCode(liveCrs) }}</span>
             <v-tooltip activator="parent" location="top">{{ formatCrs(liveCrs) }}</v-tooltip>
-            <v-icon
+            <v-btn
               v-if="crsStore.crsEditEnabled"
               data-testid="infoEditCrsBtn"
               icon="mdi-pencil"
-              size="10"
+              variant="text"
+              density="compact"
+              size="x-small"
               color="white"
               class="ml-1"
               @click.stop="crsStore.requestCrsEdit(metaData.id)"
@@ -256,12 +259,6 @@ const liveCrs = computed(() => liveItem.value?.crs ?? metaData.crs);
   transform: scale(0.97);
 }
 
-.crs-label {
-  font-weight: 900;
-  letter-spacing: 0.5px;
-  color: rgb(var(--v-theme-secondary));
-}
-
 .id-text {
   letter-spacing: 0.5px;
   color: rgba(255, 255, 255, 0.85);
diff --git a/tests/unit/components/InfoCard.nuxt.test.ts b/tests/unit/components/InfoCard.nuxt.test.ts
index 15685fd73..0532520c1 100644
--- a/tests/unit/components/InfoCard.nuxt.test.ts
+++ b/tests/unit/components/InfoCard.nuxt.test.ts
@@ -28,7 +28,10 @@ describe("info card crs", () => {
     });
     // The card is narrow: the code alone, the full name is in the tooltip
     expect(wrapper.get('[data-testid="infoCrsValue"]').text()).toBe("EPSG:2154");
-    await wrapper.get('[data-testid="infoEditCrsBtn"]').trigger("click");
+    const editButton = wrapper.get('[data-testid="infoEditCrsBtn"]');
+    // A real button: reachable with the keyboard
+    expect(editButton.element.tagName).toBe("BUTTON");
+    await editButton.trigger("click");
     expect(crsStore.crsEditRequest).toBe("data-1");
   });
 

From e8a84b249274965df38fbae55a96f7f9724173c8 Mon Sep 17 00:00:00 2001
From: MaxNumerique <maximilienlandois@gmail.com>
Date: Fri, 23 Oct 2026 15:52:45 +0200
Subject: [PATCH 14/29] perf(CrsSelector): shallow CRS list, no "All" page size

---
 app/components/CrsSelector.vue                 | 10 ++++++++--
 tests/unit/components/CrsSelector.nuxt.test.ts | 17 +++++++++++++++++
 2 files changed, 25 insertions(+), 2 deletions(-)

diff --git a/app/components/CrsSelector.vue b/app/components/CrsSelector.vue
index cd47d0772..99b650833 100644
--- a/app/components/CrsSelector.vue
+++ b/app/components/CrsSelector.vue
@@ -13,7 +13,8 @@ const selectedCrs = defineModel<CRSList | undefined>();
 
 const search = ref<string>("");
 const data_table_loading = ref<boolean>(false);
-const crs_list = ref<CRSList[]>([]);
+// Thousands of rows that are never mutated: no deep reactivity
+const crs_list = shallowRef<CRSList[]>([]);
 const selected_crs = ref<unknown[]>([]);
 const toggle_loading = useToggle(data_table_loading);
 const crsStore = useCrsStore();
@@ -54,6 +55,10 @@ const compact_headers = [
   { title: "Name", align: "start", key: "name", maxWidth: 0, nowrap: true },
 ] as const;
 
+// "All" would render the whole list (thousands of rows) at once
+// oxlint-disable-next-line no-magic-numbers -- the page sizes Vuetify offers by default, "All" aside
+const items_per_page_options = [10, 25, 50, 100];
+
 const headers = computed(() => (compact ? compact_headers : full_headers));
 
 // Not awaited in setup: the table renders right away with its loader
@@ -74,7 +79,8 @@ onMounted(async () => {
   ></v-text-field>
   <v-data-table
     v-model="selected_crs"
-    :v-model:items-per-page="10"
+    :items-per-page="10"
+    :items-per-page-options="items_per_page_options"
     :headers="headers"
     :items="crs_list"
     :item-value="crs_key"
diff --git a/tests/unit/components/CrsSelector.nuxt.test.ts b/tests/unit/components/CrsSelector.nuxt.test.ts
index 3c99b7105..b6f4b89f5 100644
--- a/tests/unit/components/CrsSelector.nuxt.test.ts
+++ b/tests/unit/components/CrsSelector.nuxt.test.ts
@@ -104,6 +104,23 @@ describe("crs selector", () => {
     expect(cells).toStrictEqual(["", "EPSG:2154", "RGF93 v1 / Lambert-93"]);
   });
 
+  test("does not offer to show all the crs at once", async () => {
+    const crsStore = useCrsStore();
+    crsStore.geographicList = mockAs<typeof crsStore.geographicList>(
+      vi.fn().mockResolvedValue([]),
+    );
+
+    const wrapper = await mountSuspended(CrsSelector, {
+      global: {
+        plugins: [vuetify, pinia],
+      },
+      props: { geodeObjectType: "BRep" },
+    });
+    const options = wrapper.findComponent({ name: "VDataTable" }).props("itemsPerPageOptions");
+    expect(options).not.toContainEqual(expect.objectContaining({ value: -1 }));
+    expect(options).not.toContain(-1);
+  });
+
   test("shows the table loader while the crs list loads", async () => {
     const crsStore = useCrsStore();
     crsStore.geographicList = mockAs<typeof crsStore.geographicList>(

From 40c51bafbc4bbef26cb35eec0b190cb90472029f Mon Sep 17 00:00:00 2001
From: MaxNumerique <144453705+MaxNumerique@users.noreply.github.com>
Date: Fri, 23 Oct 2026 13:53:38 +0000
Subject: [PATCH 15/29] Apply prepare changes

---
 tests/unit/components/CrsSelector.nuxt.test.ts | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/tests/unit/components/CrsSelector.nuxt.test.ts b/tests/unit/components/CrsSelector.nuxt.test.ts
index b6f4b89f5..1de3cb192 100644
--- a/tests/unit/components/CrsSelector.nuxt.test.ts
+++ b/tests/unit/components/CrsSelector.nuxt.test.ts
@@ -106,9 +106,7 @@ describe("crs selector", () => {
 
   test("does not offer to show all the crs at once", async () => {
     const crsStore = useCrsStore();
-    crsStore.geographicList = mockAs<typeof crsStore.geographicList>(
-      vi.fn().mockResolvedValue([]),
-    );
+    crsStore.geographicList = mockAs<typeof crsStore.geographicList>(vi.fn().mockResolvedValue([]));
 
     const wrapper = await mountSuspended(CrsSelector, {
       global: {

From a76c7a34fc63dbb850eef3d3c52af065f55f4c3c Mon Sep 17 00:00:00 2001
From: MaxNumerique <maximilienlandois@gmail.com>
Date: Fri, 23 Oct 2026 16:00:35 +0200
Subject: [PATCH 16/29] oxlint

---
 tests/unit/components/CrsSelector.nuxt.test.ts | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/unit/components/CrsSelector.nuxt.test.ts b/tests/unit/components/CrsSelector.nuxt.test.ts
index 1de3cb192..ba4e4c3a9 100644
--- a/tests/unit/components/CrsSelector.nuxt.test.ts
+++ b/tests/unit/components/CrsSelector.nuxt.test.ts
@@ -2,6 +2,7 @@
 // oxlint-disable vitest/require-mock-type-parameters
 // Third party imports
 import { beforeEach, describe, expect, test, vi } from "vitest";
+import { VDataTable } from "vuetify/components";
 import { mountSuspended } from "@nuxt/test-utils/runtime";
 
 // Local imports
@@ -114,7 +115,7 @@ describe("crs selector", () => {
       },
       props: { geodeObjectType: "BRep" },
     });
-    const options = wrapper.findComponent({ name: "VDataTable" }).props("itemsPerPageOptions");
+    const options = wrapper.findComponent(VDataTable).props("itemsPerPageOptions");
     expect(options).not.toContainEqual(expect.objectContaining({ value: -1 }));
     expect(options).not.toContain(-1);
   });

From facde66b8d54a5e5823307d8c75e869874487199 Mon Sep 17 00:00:00 2001
From: MaxNumerique <maximilienlandois@gmail.com>
Date: Tue, 27 Oct 2026 14:05:27 +0100
Subject: [PATCH 17/29] trigger


From 0432c8fbcb35ee4d0a193a2969c47a77d2754873 Mon Sep 17 00:00:00 2001
From: MaxNumerique <maximilienlandois@gmail.com>
Date: Tue, 27 Oct 2026 16:20:02 +0100
Subject: [PATCH 18/29] trigger


From e4668b4824c7dedf6b6345507d4deb2dc2411b47 Mon Sep 17 00:00:00 2001
From: MaxNumerique <maximilienlandois@gmail.com>
Date: Tue, 27 Oct 2026 16:32:49 +0100
Subject: [PATCH 19/29] perf(crs): load the geographic CRS list once per
 session

OpenGeode geosciences lists the same geographic CRS for 2D and 3D data:
the list is cached once, whatever the object type, instead of once per
type. It is still only requested when a CRS selector is shown, and a
failed request is not cached. The back keeps checking each CRS against
the list of the data dimension.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 app/stores/crs.ts                  | 16 ++++++++--------
 tests/unit/stores/crs.nuxt.test.ts |  6 ++++--
 2 files changed, 12 insertions(+), 10 deletions(-)

diff --git a/app/stores/crs.ts b/app/stores/crs.ts
index efe532035..92812cdae 100644
--- a/app/stores/crs.ts
+++ b/app/stores/crs.ts
@@ -6,7 +6,8 @@ import { useBackStore } from "@ogw_front/stores/back";
 // Session cache of the available CRS, and the channel the shared components use to ask the host app for a CRS edit
 export const useCrsStore = defineStore("crs", () => {
   const backStore = useBackStore();
-  const geographicLists = new Map<string, Promise<CRSList[]>>();
+  // OpenGeode geosciences lists the same geographic CRS for 2D and 3D data: one list for all types
+  let geographicListPromise: Promise<CRSList[]> | undefined = undefined;
   const crsEditEnabled = ref(false);
   const crsEditRequest = ref<string | undefined>(undefined);
 
@@ -23,17 +24,16 @@ export const useCrsStore = defineStore("crs", () => {
       // The back store already reports the error to the user
     }
     // A failed request is not cached: the next call retries
-    geographicLists.delete(geodeObjectType);
+    geographicListPromise = undefined;
     return [];
   }
 
   async function geographicList(geodeObjectType: string): Promise<CRSList[]> {
-    // The promise is cached, so dialogs opened together share a single request
-    if (!geographicLists.has(geodeObjectType)) {
-      geographicLists.set(geodeObjectType, fetchGeographicList(geodeObjectType));
-    }
-    const list = await geographicLists.get(geodeObjectType);
-    return list ?? [];
+    // The promise is cached, so dialogs opened together share a single request.
+    // The back still checks each CRS against the list of the data dimension
+    geographicListPromise ??= fetchGeographicList(geodeObjectType);
+    const list = await geographicListPromise;
+    return list;
   }
 
   function enableCrsEdit(): void {
diff --git a/tests/unit/stores/crs.nuxt.test.ts b/tests/unit/stores/crs.nuxt.test.ts
index c49998d51..f9dee3aad 100644
--- a/tests/unit/stores/crs.nuxt.test.ts
+++ b/tests/unit/stores/crs.nuxt.test.ts
@@ -14,7 +14,7 @@ describe("crs store", () => {
     setupActivePinia();
   });
 
-  test("loads the geographic list once per object type", async () => {
+  test("loads the geographic list once, whatever the object type", async () => {
     const request = vi.fn().mockResolvedValue({ crs_list: CRS_LIST });
     const backStore = useBackStore();
     backStore.request = mockAs<typeof backStore.request>(request);
@@ -24,7 +24,9 @@ describe("crs store", () => {
       crsStore.geographicList("PointSet3D"),
       crsStore.geographicList("PointSet3D"),
     ]);
-    await crsStore.geographicList("PointSet3D");
+    // The same list for 2D and 3D data: another type does not request it again
+    await crsStore.geographicList("BRep");
+    await crsStore.geographicList("PointSet2D");
 
     expect(first).toStrictEqual(CRS_LIST);
     expect(second).toStrictEqual(CRS_LIST);

From f71396b8a7ab0b290e57431043971dcd9e8bac9b Mon Sep 17 00:00:00 2001
From: MaxNumerique <maximilienlandois@gmail.com>
Date: Mon, 2 Nov 2026 14:33:44 +0100
Subject: [PATCH 20/29] feat(crs): store the project crs

The project CRS was deduced on the fly from the oldest georeferenced
data. It is now a state of the crs store: the first georeferenced data
sets it, then only an explicit project CRS change does. It is exported
with the project and restored on import; a project saved before falls
back to the CRS of its oldest data. The store also lists the data whose
CRS differs from the project one (data without CRS are not listed).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 app/composables/project_manager.ts            | 10 ++-
 app/stores/crs.ts                             | 67 +++++++++++++++-
 app/utils/crs.ts                              | 20 ++++-
 .../composables/project_manager.nuxt.test.ts  | 24 ++++++
 tests/unit/stores/crs.nuxt.test.ts            | 79 +++++++++++++++++++
 tests/unit/utils/crs.nuxt.test.ts             | 28 ++++++-
 6 files changed, 224 insertions(+), 4 deletions(-)

diff --git a/app/composables/project_manager.ts b/app/composables/project_manager.ts
index 56b87ca12..a0655dc95 100644
--- a/app/composables/project_manager.ts
+++ b/app/composables/project_manager.ts
@@ -1,4 +1,6 @@
-import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_typed_schemas.js";
+import back_schemas, {
+  type CRSList,
+} from "@geode/opengeodeweb-back/opengeodeweb_back_typed_schemas.js";
 import fileDownload from "js-file-download";
 import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_typed_schemas.js";
 
@@ -12,6 +14,7 @@ import { fetchRaw } from "@ogw_shared/utils/fetch_raw";
 import { importWorkflowFromSnapshot } from "@ogw_front/utils/import_workflow";
 import { useAppStore } from "@ogw_front/stores/app";
 import { useBackStore } from "@ogw_front/stores/back";
+import { useCrsStore } from "@ogw_front/stores/crs";
 import { useFeedbackStore } from "@ogw_front/stores/feedback";
 import { useHybridViewerStore } from "@ogw_front/stores/hybrid_viewer";
 import { useViewerStore } from "@ogw_front/stores/viewer";
@@ -27,6 +30,7 @@ interface ProjectSnapshot {
   data?: ProjectDataSnapshot;
   hybridViewer?: CameraSnapshot;
   dataStyle?: DataStyleSnapshot;
+  crs?: { projectCrs?: CRSList };
 }
 
 // The backend response is an untyped network payload; this is the one place its shape is asserted.
@@ -99,6 +103,7 @@ async function importProject(file: File): Promise<void> {
   const dataStore = useDataStore();
   const treeviewStore = useTreeviewStore();
   const hybridViewerStore = useHybridViewerStore();
+  const crsStore = useCrsStore();
 
   await viewerStore.ws_connect();
 
@@ -110,6 +115,7 @@ async function importProject(file: File): Promise<void> {
   treeviewStore.clear();
   await dataStore.clear();
   hybridViewerStore.clear();
+  crsStore.reset();
 
   const importProjectSchema = back_schemas.opengeodeweb_back.import_project;
   const form = new FormData();
@@ -135,6 +141,8 @@ async function importProject(file: File): Promise<void> {
   if (snapshot.data !== undefined) {
     await dataStore.importStores(snapshot.data);
   }
+  // After the data: a project saved without a project CRS takes the one of its oldest data
+  crsStore.importStores(snapshot.crs);
   await hybridViewerStore.initHybridViewer();
 
   const items = snapshot.data?.items ?? [];
diff --git a/app/stores/crs.ts b/app/stores/crs.ts
index 92812cdae..b7589b402 100644
--- a/app/stores/crs.ts
+++ b/app/stores/crs.ts
@@ -1,15 +1,45 @@
 import back_schemas, {
   type CRSList,
 } from "@geode/opengeodeweb-back/opengeodeweb_back_typed_schemas.js";
+import { oldestCrs, sameCrs } from "@ogw_front/utils/crs";
 import { useBackStore } from "@ogw_front/stores/back";
+import { useDataStore } from "@ogw_front/stores/data";
 
-// Session cache of the available CRS, and the channel the shared components use to ask the host app for a CRS edit
+// Session cache of the available CRS, the project CRS, and the channel the shared components use to ask the host app for a CRS edit
+// oxlint-disable-next-line max-lines-per-function, max-statements
 export const useCrsStore = defineStore("crs", () => {
   const backStore = useBackStore();
   // OpenGeode geosciences lists the same geographic CRS for 2D and 3D data: one list for all types
   let geographicListPromise: Promise<CRSList[]> | undefined = undefined;
   const crsEditEnabled = ref(false);
   const crsEditRequest = ref<string | undefined>(undefined);
+  const dataStore = useDataStore();
+  const items = dataStore.refAllItems();
+  const projectCrs = ref<CRSList | undefined>(undefined);
+  const projectCrsEditRequest = ref(false);
+
+  // The first georeferenced data sets the project CRS; then only a project CRS change does
+  watch(
+    () => oldestCrs(items.value ?? []),
+    (crs) => {
+      if (projectCrs.value === undefined && crs !== undefined) {
+        projectCrs.value = crs;
+      }
+    },
+    { immediate: true },
+  );
+
+  // Data without a CRS are not listed: they are not in another CRS, they have none
+  const mismatchedCrs = computed(() => {
+    const project = projectCrs.value;
+    const mismatched = new Map<string, CRSList>();
+    for (const item of items.value ?? []) {
+      if (project !== undefined && item.crs !== undefined && !sameCrs(item.crs, project)) {
+        mismatched.set(item.id, item.crs);
+      }
+    }
+    return mismatched;
+  });
 
   async function fetchGeographicList(geodeObjectType: string): Promise<CRSList[]> {
     try {
@@ -48,6 +78,32 @@ export const useCrsStore = defineStore("crs", () => {
     crsEditRequest.value = undefined;
   }
 
+  function setProjectCrs(crs: CRSList): void {
+    projectCrs.value = crs;
+  }
+
+  function requestProjectCrsEdit(): void {
+    projectCrsEditRequest.value = true;
+  }
+
+  function clearProjectCrsEditRequest(): void {
+    projectCrsEditRequest.value = false;
+  }
+
+  // A new project: its data set the project CRS again
+  function reset(): void {
+    projectCrs.value = undefined;
+  }
+
+  function exportStores(): { projectCrs?: CRSList } {
+    return { projectCrs: projectCrs.value };
+  }
+
+  // Called once the project data is imported: a project saved without it falls back to its oldest data
+  function importStores(snapshot: { projectCrs?: CRSList } | undefined): void {
+    projectCrs.value = snapshot?.projectCrs ?? oldestCrs(items.value ?? []);
+  }
+
   return {
     geographicList,
     crsEditEnabled,
@@ -55,5 +111,14 @@ export const useCrsStore = defineStore("crs", () => {
     crsEditRequest,
     requestCrsEdit,
     clearCrsEditRequest,
+    projectCrs,
+    mismatchedCrs,
+    setProjectCrs,
+    projectCrsEditRequest,
+    requestProjectCrsEdit,
+    clearProjectCrsEditRequest,
+    reset,
+    exportStores,
+    importStores,
   };
 });
diff --git a/app/utils/crs.ts b/app/utils/crs.ts
index 97e0da960..4573f6fd8 100644
--- a/app/utils/crs.ts
+++ b/app/utils/crs.ts
@@ -1,4 +1,5 @@
 import type { CRSList } from "@geode/opengeodeweb-back/opengeodeweb_back_typed_schemas.js";
+import type { DataItem } from "@ogw_front/stores/data";
 
 function formatCrs(crs: CRSList | undefined): string {
   return crs ? `${crs.authority}:${crs.code} — ${crs.name}` : "None";
@@ -9,4 +10,21 @@ function formatCrsCode(crs: CRSList | undefined): string {
   return crs ? `${crs.authority}:${crs.code}` : "None";
 }
 
-export { formatCrs, formatCrsCode };
+// The name is only a label: two CRS are the same when their authority code is
+function sameCrs(left: CRSList | undefined, right: CRSList | undefined): boolean {
+  return (
+    left !== undefined &&
+    right !== undefined &&
+    left.authority === right.authority &&
+    left.code === right.code
+  );
+}
+
+// The CRS of the oldest georeferenced data: the project CRS of a project saved before it was stored
+function oldestCrs(items: readonly DataItem[]): CRSList | undefined {
+  return items
+    .filter((item) => item.crs !== undefined)
+    .toSorted((left, right) => left.created_at.localeCompare(right.created_at))[0]?.crs;
+}
+
+export { formatCrs, formatCrsCode, oldestCrs, sameCrs };
diff --git a/tests/unit/composables/project_manager.nuxt.test.ts b/tests/unit/composables/project_manager.nuxt.test.ts
index 771b6a394..4f7b93382 100644
--- a/tests/unit/composables/project_manager.nuxt.test.ts
+++ b/tests/unit/composables/project_manager.nuxt.test.ts
@@ -53,6 +53,7 @@ const VIEWER_CALL_COUNT = 1;
 
 // Snapshot
 const snapshotMock = {
+  crs: { projectCrs: { authority: "EPSG", code: "32631", name: "WGS 84 / UTM zone 31N" } },
   data: {
     items: [
       {
@@ -249,6 +250,13 @@ vi.mock(import("@ogw_front/stores/back") as Promise<unknown>, () => ({
 vi.mock(import("@ogw_front/stores/feedback") as Promise<unknown>, () => ({
   useFeedbackStore: (): typeof feedbackStoreMock => feedbackStoreMock,
 }));
+const crsStoreMock = {
+  reset: vi.fn(),
+  importStores: vi.fn(),
+};
+vi.mock(import("@ogw_front/stores/crs") as Promise<unknown>, () => ({
+  useCrsStore: (): typeof crsStoreMock => crsStoreMock,
+}));
 const appStoreMock = {
   exportStores: vi.fn(() => ({ projectName: "mockedProject" })),
 };
@@ -326,6 +334,7 @@ describe("projectManager composable (compact)", () => {
       dataStyleStoreMock,
       hybridViewerStoreMock,
       feedbackStoreMock,
+      crsStoreMock,
     ];
     for (const store of storesList) {
       const values = Object.values(store);
@@ -368,4 +377,19 @@ describe("projectManager composable (compact)", () => {
     verifyDataManagement();
     verifyRemaining();
   });
+
+  test("importProjectFile restores the project crs once the data are imported", async () => {
+    const file = new File(['{"dataBase":{"db":{}}}'], "project.vease", {
+      type: "application/json",
+    });
+
+    await importProject(file);
+
+    expect(crsStoreMock.importStores).toHaveBeenCalledWith(snapshotMock.crs);
+    const dataOrder = Math.min(...dataStoreMock.importStores.mock.invocationCallOrder);
+    expect(Math.min(...crsStoreMock.reset.mock.invocationCallOrder)).toBeLessThan(dataOrder);
+    expect(Math.min(...crsStoreMock.importStores.mock.invocationCallOrder)).toBeGreaterThan(
+      dataOrder,
+    );
+  });
 });
diff --git a/tests/unit/stores/crs.nuxt.test.ts b/tests/unit/stores/crs.nuxt.test.ts
index f9dee3aad..067c99070 100644
--- a/tests/unit/stores/crs.nuxt.test.ts
+++ b/tests/unit/stores/crs.nuxt.test.ts
@@ -1,4 +1,6 @@
 // oxlint-disable vitest/require-mock-type-parameters
+import { type DataItem, useDataStore } from "@ogw_front/stores/data";
+import { type Ref, nextTick, ref } from "vue";
 import { beforeEach, describe, expect, test, vi } from "vitest";
 import { mockAs, setupActivePinia } from "@ogw_tests/utils";
 import { useBackStore } from "@ogw_front/stores/back";
@@ -9,9 +11,17 @@ vi.setConfig({ testTimeout: 10_000 });
 const EXPECTED_REQUESTS = 1;
 const CRS_LIST = [{ authority: "EPSG", code: "2154", name: "RGF93 v1 / Lambert-93" }];
 
+function mockItems(items: DataItem[]): Ref<DataItem[]> {
+  const data = ref(items);
+  const dataStore = useDataStore();
+  dataStore.refAllItems = mockAs<typeof dataStore.refAllItems>(() => data);
+  return data;
+}
+
 describe("crs store", () => {
   beforeEach(() => {
     setupActivePinia();
+    mockItems([]);
   });
 
   test("loads the geographic list once, whatever the object type", async () => {
@@ -70,3 +80,72 @@ describe("crs store", () => {
     expect(crsStore.crsEditRequest).toBeUndefined();
   });
 });
+
+const LAMBERT = { authority: "EPSG", code: "2154", name: "RGF93 v1 / Lambert-93" };
+const UTM = { authority: "EPSG", code: "32631", name: "WGS 84 / UTM zone 31N" };
+
+describe("project crs", () => {
+  beforeEach(() => {
+    setupActivePinia();
+  });
+
+  test("the first georeferenced data sets it, later data do not change it", async () => {
+    const data = mockItems([]);
+    const crsStore = useCrsStore();
+    expect(crsStore.projectCrs).toBeUndefined();
+    data.value = mockAs<DataItem[]>([{ id: "a", created_at: "1", crs: LAMBERT }]);
+    await nextTick();
+    expect(crsStore.projectCrs).toStrictEqual(LAMBERT);
+    data.value = mockAs<DataItem[]>([
+      { id: "a", created_at: "1", crs: UTM },
+      { id: "b", created_at: "2", crs: UTM },
+    ]);
+    await nextTick();
+    expect(crsStore.projectCrs).toStrictEqual(LAMBERT);
+  });
+
+  test("lists the data in another crs than the project", () => {
+    mockItems(
+      mockAs<DataItem[]>([
+        { id: "a", created_at: "1", crs: LAMBERT },
+        { id: "b", created_at: "2", crs: UTM },
+        { id: "local", created_at: "3" },
+      ]),
+    );
+    const crsStore = useCrsStore();
+    expect([...crsStore.mismatchedCrs.entries()]).toStrictEqual([["b", UTM]]);
+  });
+
+  test("is exported and imported with the project", () => {
+    mockItems(mockAs<DataItem[]>([{ id: "a", created_at: "1", crs: LAMBERT }]));
+    const crsStore = useCrsStore();
+    crsStore.setProjectCrs(UTM);
+    expect(crsStore.exportStores()).toStrictEqual({ projectCrs: UTM });
+    crsStore.reset();
+    expect(crsStore.projectCrs).toBeUndefined();
+    crsStore.importStores({ projectCrs: UTM });
+    expect(crsStore.projectCrs).toStrictEqual(UTM);
+  });
+
+  test("a project saved without it takes the crs of its oldest georeferenced data", () => {
+    mockItems(
+      mockAs<DataItem[]>([
+        { id: "b", created_at: "2", crs: UTM },
+        { id: "a", created_at: "1", crs: LAMBERT },
+      ]),
+    );
+    const crsStore = useCrsStore();
+    crsStore.reset();
+    crsStore.importStores(undefined);
+    expect(crsStore.projectCrs).toStrictEqual(LAMBERT);
+  });
+
+  test("forwards a project crs edit request until it is cleared", () => {
+    mockItems([]);
+    const crsStore = useCrsStore();
+    crsStore.requestProjectCrsEdit();
+    expect(crsStore.projectCrsEditRequest).toBe(true);
+    crsStore.clearProjectCrsEditRequest();
+    expect(crsStore.projectCrsEditRequest).toBe(false);
+  });
+});
diff --git a/tests/unit/utils/crs.nuxt.test.ts b/tests/unit/utils/crs.nuxt.test.ts
index bc6b06fce..b81e279e2 100644
--- a/tests/unit/utils/crs.nuxt.test.ts
+++ b/tests/unit/utils/crs.nuxt.test.ts
@@ -1,5 +1,7 @@
 import { describe, expect, test, vi } from "vitest";
-import { formatCrs, formatCrsCode } from "@ogw_front/utils/crs";
+import { formatCrs, formatCrsCode, oldestCrs, sameCrs } from "@ogw_front/utils/crs";
+import type { DataItem } from "@ogw_front/stores/data";
+import { mockAs } from "@ogw_tests/utils";
 
 vi.setConfig({ testTimeout: 10_000 });
 
@@ -21,3 +23,27 @@ describe("format crs", () => {
     expect(formatCrsCode(undefined)).toBe("None");
   });
 });
+
+const LAMBERT = { authority: "EPSG", code: "2154", name: "RGF93 v1 / Lambert-93" };
+const UTM = { authority: "EPSG", code: "32631", name: "WGS 84 / UTM zone 31N" };
+
+describe("same crs", () => {
+  test("compares the authority and the code only", () => {
+    expect(sameCrs(LAMBERT, { ...LAMBERT, name: "renamed" })).toBe(true);
+    expect(sameCrs(LAMBERT, UTM)).toBe(false);
+    expect(sameCrs(LAMBERT, undefined)).toBe(false);
+    expect(sameCrs(undefined, undefined)).toBe(false);
+  });
+});
+
+describe("oldest crs", () => {
+  test("is the crs of the oldest georeferenced data", () => {
+    const items = mockAs<DataItem[]>([
+      { id: "local", created_at: "1" },
+      { id: "utm", created_at: "3", crs: UTM },
+      { id: "lambert", created_at: "2", crs: LAMBERT },
+    ]);
+    expect(oldestCrs(items)).toStrictEqual(LAMBERT);
+    expect(oldestCrs([])).toBeUndefined();
+  });
+});

From d7494e583d6f86f0f53c388cab144110d623ac79 Mon Sep 17 00:00:00 2001
From: MaxNumerique <maximilienlandois@gmail.com>
Date: Mon, 2 Nov 2026 14:33:44 +0100
Subject: [PATCH 21/29] feat(crs): warn about data in another crs in the object
 tree

A warning icon follows the name of a data whose CRS differs from the
project one, with a tooltip naming both CRS. The rows read the store
list, so the whole tree costs a single database query.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../Viewer/ObjectTree/Base/ItemLabel.vue      | 24 +++++++++-
 tests/unit/components/ItemLabel.nuxt.test.ts  | 47 +++++++++++++++++++
 2 files changed, 70 insertions(+), 1 deletion(-)

diff --git a/app/components/Viewer/ObjectTree/Base/ItemLabel.vue b/app/components/Viewer/ObjectTree/Base/ItemLabel.vue
index d9d0889c2..ec4f837a4 100644
--- a/app/components/Viewer/ObjectTree/Base/ItemLabel.vue
+++ b/app/components/Viewer/ObjectTree/Base/ItemLabel.vue
@@ -1,6 +1,6 @@
 <script setup lang="ts">
+import { formatCrs, formatCrsCode } from "@ogw_front/utils/crs";
 import type { DisplayItem } from "@ogw_front/composables/virtual_tree";
-import { formatCrs } from "@ogw_front/utils/crs";
 import { middleTruncate } from "@ogw_front/utils/string";
 import { useClipboard } from "@vueuse/core";
 import { useCrsStore } from "@ogw_front/stores/crs";
@@ -74,6 +74,15 @@ const crsLabel = computed<string>(
     ) ?? "",
 );
 
+// Read from the store map: one database query for the whole tree, not one per row
+const mismatchedCrs = computed(() =>
+  showCrs ? crsStore.mismatchedCrs.get(actualItem.value.id) : undefined,
+);
+const mismatchTooltip = computed<string>(
+  () =>
+    `In ${formatCrsCode(mismatchedCrs.value)}, project in ${formatCrsCode(crsStore.projectCrs)}. Convert it to show it on the map.`,
+);
+
 const tooltipDisabled = computed<boolean>(() => {
   if (actualItem.value.category !== undefined) {
     return false;
@@ -171,6 +180,19 @@ async function copyToClipboard(text: string, label: string): Promise<void> {
         </span>
       </div>
     </v-tooltip>
+    <v-tooltip v-if="mismatchedCrs" location="right">
+      <template #activator="{ props: warningProps }">
+        <v-icon
+          v-bind="warningProps"
+          data-testid="crsMismatchIcon"
+          icon="mdi-alert"
+          color="warning"
+          size="14"
+          class="ml-1 flex-shrink-0"
+        />
+      </template>
+      {{ mismatchTooltip }}
+    </v-tooltip>
   </div>
 </template>
 
diff --git a/tests/unit/components/ItemLabel.nuxt.test.ts b/tests/unit/components/ItemLabel.nuxt.test.ts
index 20242d42a..4ef5f430f 100644
--- a/tests/unit/components/ItemLabel.nuxt.test.ts
+++ b/tests/unit/components/ItemLabel.nuxt.test.ts
@@ -1,5 +1,6 @@
 // Third party imports
 import { describe, expect, test, vi } from "vitest";
+import type { VueWrapper } from "@vue/test-utils";
 import { mountSuspended } from "@nuxt/test-utils/runtime";
 
 // Local imports
@@ -124,3 +125,49 @@ describe("item label tooltip", () => {
     expect(wrapper.get('[data-testid="tooltipCrsValue"]').text()).toContain("EPSG:2154");
   });
 });
+
+describe("item label crs mismatch", () => {
+  const LAMBERT = { authority: "EPSG", code: "2154", name: "RGF93 v1 / Lambert-93" };
+  const UTM = { authority: "EPSG", code: "32631", name: "WGS 84 / UTM zone 31N" };
+
+  // A pinia per row: the crs store reads the data when it is created
+  async function mountRow(id: string, showCrs = true): Promise<VueWrapper> {
+    const pinia = setupActivePinia();
+    const dataStore = useDataStore();
+    dataStore.refAllItems = mockAs<typeof dataStore.refAllItems>(() =>
+      ref([
+        { id: "a", created_at: "1", crs: LAMBERT },
+        { id: "b", created_at: "2", crs: UTM },
+        { id: "local", created_at: "3" },
+      ]),
+    );
+    useCrsStore();
+    const wrapper = await mountSuspended(ItemLabel, {
+      global: { plugins: [vuetify, pinia], stubs: { VTooltip: VTooltipStub } },
+      props: { item: leaf({ id, title: id }), isLeaf: true, showCrs },
+    });
+    return wrapper;
+  }
+
+  test("warns about data in another crs than the project", async () => {
+    const wrapper = await mountRow("b");
+    expect(wrapper.find('[data-testid="crsMismatchIcon"]').exists()).toBe(true);
+    expect(wrapper.text()).toContain(
+      "In EPSG:32631, project in EPSG:2154. Convert it to show it on the map.",
+    );
+  });
+
+  test("no warning for data in the project crs, without crs, or outside data rows", async () => {
+    const rows: [string, boolean][] = [
+      ["a", true],
+      ["local", true],
+      ["b", false],
+    ];
+    // oxlint-disable no-await-in-loop
+    for (const [id, showCrs] of rows) {
+      const wrapper = await mountRow(id, showCrs);
+      expect(wrapper.find('[data-testid="crsMismatchIcon"]').exists()).toBe(false);
+    }
+    // oxlint-enable no-await-in-loop
+  });
+});

From 27795cd0d76064be2d6f647a0456124cbdfeff90 Mon Sep 17 00:00:00 2001
From: MaxNumerique <maximilienlandois@gmail.com>
Date: Mon, 2 Nov 2026 14:33:44 +0100
Subject: [PATCH 22/29] feat(crs): show the project crs under the axes

A compact button in the bottom right corner of the scene, under the XYZ
axes, shows the project CRS ("No CRS" before the first georeferenced
data). A click asks the host app for a project CRS edit; it is disabled
when no app hosts the dialog.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 app/components/ProjectCrs.vue                 | 37 +++++++++++++
 app/components/Viewer/Ui.vue                  |  4 ++
 tests/unit/components/ProjectCrs.nuxt.test.ts | 53 +++++++++++++++++++
 3 files changed, 94 insertions(+)
 create mode 100644 app/components/ProjectCrs.vue
 create mode 100644 tests/unit/components/ProjectCrs.nuxt.test.ts

diff --git a/app/components/ProjectCrs.vue b/app/components/ProjectCrs.vue
new file mode 100644
index 000000000..fd844a727
--- /dev/null
+++ b/app/components/ProjectCrs.vue
@@ -0,0 +1,37 @@
+<script setup lang="ts">
+import { formatCrs, formatCrsCode } from "@ogw_front/utils/crs";
+import { useCrsStore } from "@ogw_front/stores/crs";
+
+const crsStore = useCrsStore();
+const label = computed<string>(() =>
+  crsStore.projectCrs
+    ? `CRS: ${formatCrsCode(crsStore.projectCrs)} · ${crsStore.projectCrs.name}`
+    : "No CRS",
+);
+</script>
+
+<template>
+  <!-- Under the XYZ axes, drawn by the viewer in the bottom right corner -->
+  <v-btn
+    data-testid="projectCrs"
+    class="project-crs text-none"
+    size="x-small"
+    variant="tonal"
+    prepend-icon="mdi-earth"
+    :disabled="!crsStore.crsEditEnabled"
+    v-tooltip="formatCrs(crsStore.projectCrs)"
+    @click="crsStore.requestProjectCrsEdit()"
+  >
+    <span class="text-truncate">{{ label }}</span>
+  </v-btn>
+</template>
+
+<style scoped>
+.project-crs {
+  position: absolute;
+  right: 8px;
+  bottom: 4px;
+  z-index: 1;
+  max-width: 20%;
+}
+</style>
diff --git a/app/components/Viewer/Ui.vue b/app/components/Viewer/Ui.vue
index f22bdb2b0..56e9ad8d4 100644
--- a/app/components/Viewer/Ui.vue
+++ b/app/components/Viewer/Ui.vue
@@ -1,9 +1,11 @@
 <script setup lang="ts">
+// oxlint-disable max-dependencies
 import {
   type ViewerIdResult,
   useOverlappingPicker,
 } from "@ogw_front/composables/use_overlapping_picker";
 import OverlappingObjectsPicker from "@ogw_front/components/Viewer/OverlappingObjectsPicker.vue";
+import ProjectCrs from "@ogw_front/components/ProjectCrs.vue";
 import ToolActiveChip from "@ogw_front/components/Viewer/ToolActiveChip.vue";
 import type { TreeMenuPayload } from "@ogw_front/utils/treeview";
 import ViewerContextMenu from "@ogw_front/components/Viewer/ContextMenu/ContextMenu.vue";
@@ -106,6 +108,8 @@ defineExpose({ get_viewer_id });
     :container-height="containerHeight"
   />
 
+  <ProjectCrs />
+
   <OverlappingObjectsPicker
     :display-intermediate="displayIntermediate"
     :intermediate-items="intermediateItems"
diff --git a/tests/unit/components/ProjectCrs.nuxt.test.ts b/tests/unit/components/ProjectCrs.nuxt.test.ts
new file mode 100644
index 000000000..29a5e2b40
--- /dev/null
+++ b/tests/unit/components/ProjectCrs.nuxt.test.ts
@@ -0,0 +1,53 @@
+// Third party imports
+import { describe, expect, test, vi } from "vitest";
+import type { VueWrapper } from "@vue/test-utils";
+import { mountSuspended } from "@nuxt/test-utils/runtime";
+import { ref } from "vue";
+
+// Local imports
+import { mockAs, setupActivePinia, vuetify } from "@ogw_tests/utils";
+import ProjectCrs from "@ogw_front/components/ProjectCrs.vue";
+import { useCrsStore } from "@ogw_front/stores/crs";
+import { useDataStore } from "@ogw_front/stores/data";
+
+const LAMBERT = { authority: "EPSG", code: "2154", name: "RGF93 v1 / Lambert-93" };
+const WIDGET = '[data-testid="projectCrs"]';
+
+vi.setConfig({ testTimeout: 10_000 });
+
+async function mountWidget(
+  setup: (store: ReturnType<typeof useCrsStore>) => void,
+): Promise<VueWrapper> {
+  const pinia = setupActivePinia();
+  const dataStore = useDataStore();
+  dataStore.refAllItems = mockAs<typeof dataStore.refAllItems>(() => ref([]));
+  setup(useCrsStore());
+  const wrapper = await mountSuspended(ProjectCrs, { global: { plugins: [vuetify, pinia] } });
+  return wrapper;
+}
+
+describe("project crs widget", () => {
+  test("shows no crs before the first georeferenced data", async () => {
+    const wrapper = await mountWidget(() => {
+      // No data: no project CRS
+    });
+    expect(wrapper.get(WIDGET).text()).toContain("No CRS");
+  });
+
+  test("shows the project crs and asks for its edit", async () => {
+    const wrapper = await mountWidget((store) => {
+      store.enableCrsEdit();
+      store.setProjectCrs(LAMBERT);
+    });
+    expect(wrapper.get(WIDGET).text()).toContain("CRS: EPSG:2154 · RGF93 v1 / Lambert-93");
+    await wrapper.get(WIDGET).trigger("click");
+    expect(useCrsStore().projectCrsEditRequest).toBe(true);
+  });
+
+  test("cannot be edited when no app hosts the dialog", async () => {
+    const wrapper = await mountWidget((store) => {
+      store.setProjectCrs(LAMBERT);
+    });
+    expect(wrapper.get(WIDGET).attributes("disabled")).toBeDefined();
+  });
+});

From c92cbc39fc8135452c4a46dc8157f3ec6635a576 Mon Sep 17 00:00:00 2001
From: MaxNumerique <maximilienlandois@gmail.com>
Date: Mon, 2 Nov 2026 14:53:46 +0100
Subject: [PATCH 23/29] fix(crs): old project takes the crs of its oldest saved
 data

A project saved without a project CRS fell back on the stored items, but
they are added after the store imports, with the import time as creation
date: the project CRS ended up random. The fallback now reads the
snapshot items, which keep their original creation date.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 app/composables/project_manager.ts            | 10 +++++--
 app/stores/data.ts                            |  2 ++
 app/utils/crs.ts                              |  9 ++++---
 .../composables/project_manager.nuxt.test.ts  | 26 ++++++++++++++++++-
 4 files changed, 41 insertions(+), 6 deletions(-)

diff --git a/app/composables/project_manager.ts b/app/composables/project_manager.ts
index a0655dc95..2eb8086b8 100644
--- a/app/composables/project_manager.ts
+++ b/app/composables/project_manager.ts
@@ -12,6 +12,7 @@ import type { ModelComponentRecord } from "@ogw_front/stores/data_helpers/mesh.j
 import type { ModelComponentRelationRecord } from "@ogw_front/stores/data.js";
 import { fetchRaw } from "@ogw_shared/utils/fetch_raw";
 import { importWorkflowFromSnapshot } from "@ogw_front/utils/import_workflow";
+import { oldestCrs } from "@ogw_front/utils/crs";
 import { useAppStore } from "@ogw_front/stores/app";
 import { useBackStore } from "@ogw_front/stores/back";
 import { useCrsStore } from "@ogw_front/stores/crs";
@@ -141,8 +142,13 @@ async function importProject(file: File): Promise<void> {
   if (snapshot.data !== undefined) {
     await dataStore.importStores(snapshot.data);
   }
-  // After the data: a project saved without a project CRS takes the one of its oldest data
-  crsStore.importStores(snapshot.crs);
+  // A project saved without a project CRS takes the one of its oldest data. The snapshot is
+  // Read, not the stored items: they are added later, with the import time as creation date
+  crsStore.importStores(
+    snapshot.crs?.projectCrs === undefined
+      ? { projectCrs: oldestCrs(snapshot.data?.items ?? []) }
+      : snapshot.crs,
+  );
   await hybridViewerStore.initHybridViewer();
 
   const items = snapshot.data?.items ?? [];
diff --git a/app/stores/data.ts b/app/stores/data.ts
index c30e724a9..15e06bf37 100644
--- a/app/stores/data.ts
+++ b/app/stores/data.ts
@@ -45,6 +45,8 @@ interface NewDataItem {
   is_viewable?: boolean;
   binary_light_viewable?: string;
   crs?: CRSList;
+  // Set on saved data: kept by the project snapshot
+  created_at?: string;
   mesh_components?: ModelComponentInput[];
   collection_components?: ModelComponentInput[];
   nb_vertices?: number;
diff --git a/app/utils/crs.ts b/app/utils/crs.ts
index 4573f6fd8..98a75c425 100644
--- a/app/utils/crs.ts
+++ b/app/utils/crs.ts
@@ -1,5 +1,5 @@
+import type { DataItem, NewDataItem } from "@ogw_front/stores/data";
 import type { CRSList } from "@geode/opengeodeweb-back/opengeodeweb_back_typed_schemas.js";
-import type { DataItem } from "@ogw_front/stores/data";
 
 function formatCrs(crs: CRSList | undefined): string {
   return crs ? `${crs.authority}:${crs.code} — ${crs.name}` : "None";
@@ -21,10 +21,13 @@ function sameCrs(left: CRSList | undefined, right: CRSList | undefined): boolean
 }
 
 // The CRS of the oldest georeferenced data: the project CRS of a project saved before it was stored
-function oldestCrs(items: readonly DataItem[]): CRSList | undefined {
+function oldestCrs(
+  items: readonly Pick<DataItem, "crs" | "created_at">[] | readonly NewDataItem[],
+): CRSList | undefined {
   return items
     .filter((item) => item.crs !== undefined)
-    .toSorted((left, right) => left.created_at.localeCompare(right.created_at))[0]?.crs;
+    .toSorted((left, right) => (left.created_at ?? "").localeCompare(right.created_at ?? ""))[0]
+    ?.crs;
 }
 
 export { formatCrs, formatCrsCode, oldestCrs, sameCrs };
diff --git a/tests/unit/composables/project_manager.nuxt.test.ts b/tests/unit/composables/project_manager.nuxt.test.ts
index 4f7b93382..4b269bb0f 100644
--- a/tests/unit/composables/project_manager.nuxt.test.ts
+++ b/tests/unit/composables/project_manager.nuxt.test.ts
@@ -14,10 +14,10 @@ import {
 import { beforeEach, describe, expect, test, vi } from "vitest";
 
 import { exportProject, importProject } from "@ogw_front/composables/project_manager";
+import { mockAs, setupActivePinia } from "@ogw_tests/utils";
 import type { api_fetch as apiFetchType } from "@ogw_internal/utils/api_fetch";
 import { appMode } from "@ogw_shared/app_mode";
 import backSchemas from "@geode/opengeodeweb-back/opengeodeweb_back_typed_schemas.js";
-import { setupActivePinia } from "@ogw_tests/utils";
 
 vi.mock(import("ofetch"), () => ({
   $fetch: Object.assign(vi.fn(), {
@@ -392,4 +392,28 @@ describe("projectManager composable (compact)", () => {
       dataOrder,
     );
   });
+
+  // Data items are added after the store imports: the snapshot keeps their original dates
+  test("importProjectFile without project crs takes the one of the oldest saved data", async () => {
+    const file = new File(['{"dataBase":{"db":{}}}'], "project.vease", {
+      type: "application/json",
+    });
+    const { crs, data } = snapshotMock;
+    const savedItems = data.items;
+    const utm = { authority: "EPSG", code: "32631", name: "WGS 84 / UTM zone 31N" };
+    const lambert = { authority: "EPSG", code: "2154", name: "RGF93 v1 / Lambert-93" };
+    Reflect.deleteProperty(snapshotMock, "crs");
+    data.items = mockAs<typeof savedItems>([
+      { ...savedItems[0], crs: utm, created_at: "2026-01-02T00:00:00.000Z" },
+      { ...savedItems[0], id: "older", crs: lambert, created_at: "2026-01-01T00:00:00.000Z" },
+    ]);
+    try {
+      await importProject(file);
+    } finally {
+      Object.assign(snapshotMock, { crs });
+      data.items = savedItems;
+    }
+
+    expect(crsStoreMock.importStores).toHaveBeenCalledWith({ projectCrs: lambert });
+  });
 });

From a1b4bb900156c694c953f320f4a81a3289cf1524 Mon Sep 17 00:00:00 2001
From: MaxNumerique <maximilienlandois@gmail.com>
Date: Mon, 2 Nov 2026 15:32:41 +0100
Subject: [PATCH 24/29] feat(crs): the project crs follows its data, light
 shared read

The project CRS follows its data: as soon as every georeferenced data is
in one CRS, that CRS becomes the project one; mixed data keep the
current project CRS. Data without CRS are now listed as not in the
project CRS. The CRS features read the data once, through a light query
that keeps only id, name, crs and creation date, instead of copying
every item with its geometry on each change. sameCrsState also treats
two data without CRS as in the same state.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 app/stores/crs.ts                  | 34 +++++++++++++++++++----------
 app/stores/data.ts                 | 17 ++++++++++++++-
 app/utils/crs.ts                   | 11 +++++++---
 tests/unit/stores/crs.nuxt.test.ts | 35 +++++++++++++++++++++++++-----
 tests/unit/utils/crs.nuxt.test.ts  | 11 +++++++++-
 5 files changed, 87 insertions(+), 21 deletions(-)

diff --git a/app/stores/crs.ts b/app/stores/crs.ts
index b7589b402..955406fe5 100644
--- a/app/stores/crs.ts
+++ b/app/stores/crs.ts
@@ -14,27 +14,38 @@ export const useCrsStore = defineStore("crs", () => {
   const crsEditEnabled = ref(false);
   const crsEditRequest = ref<string | undefined>(undefined);
   const dataStore = useDataStore();
-  const items = dataStore.refAllItems();
+  const crsItems = dataStore.refCrsItems();
   const projectCrs = ref<CRSList | undefined>(undefined);
   const projectCrsEditRequest = ref(false);
 
-  // The first georeferenced data sets the project CRS; then only a project CRS change does
+  // The project follows its data: once every georeferenced data is in one CRS, it is the project
+  // CRS. Data already mixed before any project CRS: the oldest one is the reference
   watch(
-    () => oldestCrs(items.value ?? []),
-    (crs) => {
-      if (projectCrs.value === undefined && crs !== undefined) {
-        projectCrs.value = crs;
+    () => {
+      const georeferenced = crsItems.value.filter((item) => item.crs !== undefined);
+      const [first] = georeferenced;
+      if (first === undefined) {
+        return undefined;
+      }
+      if (georeferenced.every((item) => sameCrs(item.crs, first.crs))) {
+        return first.crs;
+      }
+      return projectCrs.value ?? oldestCrs(georeferenced);
+    },
+    (reference) => {
+      if (reference !== undefined && !sameCrs(reference, projectCrs.value)) {
+        projectCrs.value = reference;
       }
     },
     { immediate: true },
   );
 
-  // Data without a CRS are not listed: they are not in another CRS, they have none
+  // Data without CRS are listed too (value undefined): they could not follow the project
   const mismatchedCrs = computed(() => {
     const project = projectCrs.value;
-    const mismatched = new Map<string, CRSList>();
-    for (const item of items.value ?? []) {
-      if (project !== undefined && item.crs !== undefined && !sameCrs(item.crs, project)) {
+    const mismatched = new Map<string, CRSList | undefined>();
+    for (const item of crsItems.value) {
+      if (project !== undefined && !sameCrs(item.crs, project)) {
         mismatched.set(item.id, item.crs);
       }
     }
@@ -101,10 +112,11 @@ export const useCrsStore = defineStore("crs", () => {
 
   // Called once the project data is imported: a project saved without it falls back to its oldest data
   function importStores(snapshot: { projectCrs?: CRSList } | undefined): void {
-    projectCrs.value = snapshot?.projectCrs ?? oldestCrs(items.value ?? []);
+    projectCrs.value = snapshot?.projectCrs ?? oldestCrs(crsItems.value);
   }
 
   return {
+    crsItems,
     geographicList,
     crsEditEnabled,
     enableCrsEdit,
diff --git a/app/stores/data.ts b/app/stores/data.ts
index 15e06bf37..5c66a00c7 100644
--- a/app/stores/data.ts
+++ b/app/stores/data.ts
@@ -25,6 +25,9 @@ interface DataItem {
   crs?: CRSList;
 }
 
+// What the CRS features read of a data: light to copy on each change
+type CrsItem = Pick<DataItem, "id" | "name" | "crs" | "created_at">;
+
 interface ModelComponentInput {
   geode_id: string;
   type: string;
@@ -153,6 +156,17 @@ export const useDataStore = defineStore("data", () => {
       },
     );
   }
+  // The CRS features only need these fields: the geometry stays out of the copies made on each change
+  function refCrsItems(): Ref<CrsItem[]> {
+    return useObservable(
+      liveObservable(async () => {
+        const items = await data_db.toArray();
+        return items.map(({ id, name, crs, created_at }) => ({ id, name, crs, created_at }));
+      }),
+      { initialValue: [] as CrsItem[] },
+    );
+  }
+
   function refAllItems(): Ref<DataItem[]> {
     return useObservable(
       liveObservable(async () => {
@@ -369,6 +383,7 @@ export const useDataStore = defineStore("data", () => {
   }
   return {
     refAllItems,
+    refCrsItems,
     item,
     allItems,
     refItem,
@@ -406,4 +421,4 @@ export const useDataStore = defineStore("data", () => {
   };
 });
 
-export type { DataItem, NewDataItem, ModelComponentInput, ModelComponentRelationRecord };
+export type { CrsItem, DataItem, NewDataItem, ModelComponentInput, ModelComponentRelationRecord };
diff --git a/app/utils/crs.ts b/app/utils/crs.ts
index 98a75c425..2682a3abf 100644
--- a/app/utils/crs.ts
+++ b/app/utils/crs.ts
@@ -1,4 +1,4 @@
-import type { DataItem, NewDataItem } from "@ogw_front/stores/data";
+import type { CrsItem, NewDataItem } from "@ogw_front/stores/data";
 import type { CRSList } from "@geode/opengeodeweb-back/opengeodeweb_back_typed_schemas.js";
 
 function formatCrs(crs: CRSList | undefined): string {
@@ -20,9 +20,14 @@ function sameCrs(left: CRSList | undefined, right: CRSList | undefined): boolean
   );
 }
 
+// Same CRS, or both still in local coordinates
+function sameCrsState(left: CRSList | undefined, right: CRSList | undefined): boolean {
+  return (left === undefined && right === undefined) || sameCrs(left, right);
+}
+
 // The CRS of the oldest georeferenced data: the project CRS of a project saved before it was stored
 function oldestCrs(
-  items: readonly Pick<DataItem, "crs" | "created_at">[] | readonly NewDataItem[],
+  items: readonly Pick<CrsItem, "crs" | "created_at">[] | readonly NewDataItem[],
 ): CRSList | undefined {
   return items
     .filter((item) => item.crs !== undefined)
@@ -30,4 +35,4 @@ function oldestCrs(
     ?.crs;
 }
 
-export { formatCrs, formatCrsCode, oldestCrs, sameCrs };
+export { formatCrs, formatCrsCode, oldestCrs, sameCrs, sameCrsState };
diff --git a/tests/unit/stores/crs.nuxt.test.ts b/tests/unit/stores/crs.nuxt.test.ts
index 067c99070..9ee6dfce3 100644
--- a/tests/unit/stores/crs.nuxt.test.ts
+++ b/tests/unit/stores/crs.nuxt.test.ts
@@ -14,7 +14,7 @@ const CRS_LIST = [{ authority: "EPSG", code: "2154", name: "RGF93 v1 / Lambert-9
 function mockItems(items: DataItem[]): Ref<DataItem[]> {
   const data = ref(items);
   const dataStore = useDataStore();
-  dataStore.refAllItems = mockAs<typeof dataStore.refAllItems>(() => data);
+  dataStore.refCrsItems = mockAs<typeof dataStore.refCrsItems>(() => data);
   return data;
 }
 
@@ -89,19 +89,40 @@ describe("project crs", () => {
     setupActivePinia();
   });
 
-  test("the first georeferenced data sets it, later data do not change it", async () => {
+  test("follows when every georeferenced data is in one crs", async () => {
     const data = mockItems([]);
     const crsStore = useCrsStore();
-    expect(crsStore.projectCrs).toBeUndefined();
     data.value = mockAs<DataItem[]>([{ id: "a", created_at: "1", crs: LAMBERT }]);
     await nextTick();
     expect(crsStore.projectCrs).toStrictEqual(LAMBERT);
+    // One data converted alone: mixed, the project keeps its crs
     data.value = mockAs<DataItem[]>([
       { id: "a", created_at: "1", crs: UTM },
-      { id: "b", created_at: "2", crs: UTM },
+      { id: "b", created_at: "2", crs: LAMBERT },
+      { id: "local", created_at: "3" },
     ]);
     await nextTick();
     expect(crsStore.projectCrs).toStrictEqual(LAMBERT);
+    data.value = mockAs<DataItem[]>([
+      { id: "a", created_at: "1", crs: UTM },
+      { id: "b", created_at: "2", crs: UTM },
+      { id: "local", created_at: "3" },
+    ]);
+    await nextTick();
+    expect(crsStore.projectCrs).toStrictEqual(UTM);
+  });
+
+  test("an imported project crs is kept while the data are mixed", async () => {
+    mockItems(
+      mockAs<DataItem[]>([
+        { id: "a", created_at: "1", crs: LAMBERT },
+        { id: "b", created_at: "2", crs: UTM },
+      ]),
+    );
+    const crsStore = useCrsStore();
+    crsStore.importStores({ projectCrs: UTM });
+    await nextTick();
+    expect(crsStore.projectCrs).toStrictEqual(UTM);
   });
 
   test("lists the data in another crs than the project", () => {
@@ -113,7 +134,11 @@ describe("project crs", () => {
       ]),
     );
     const crsStore = useCrsStore();
-    expect([...crsStore.mismatchedCrs.entries()]).toStrictEqual([["b", UTM]]);
+    // Data without CRS too: they could not follow the project
+    expect([...crsStore.mismatchedCrs.entries()]).toStrictEqual([
+      ["b", UTM],
+      ["local", undefined],
+    ]);
   });
 
   test("is exported and imported with the project", () => {
diff --git a/tests/unit/utils/crs.nuxt.test.ts b/tests/unit/utils/crs.nuxt.test.ts
index b81e279e2..19e6d11c4 100644
--- a/tests/unit/utils/crs.nuxt.test.ts
+++ b/tests/unit/utils/crs.nuxt.test.ts
@@ -1,5 +1,5 @@
 import { describe, expect, test, vi } from "vitest";
-import { formatCrs, formatCrsCode, oldestCrs, sameCrs } from "@ogw_front/utils/crs";
+import { formatCrs, formatCrsCode, oldestCrs, sameCrs, sameCrsState } from "@ogw_front/utils/crs";
 import type { DataItem } from "@ogw_front/stores/data";
 import { mockAs } from "@ogw_tests/utils";
 
@@ -47,3 +47,12 @@ describe("oldest crs", () => {
     expect(oldestCrs([])).toBeUndefined();
   });
 });
+
+describe("same crs state", () => {
+  test("two data without crs share the same state", () => {
+    expect(sameCrsState(undefined, undefined)).toBe(true);
+    expect(sameCrsState(LAMBERT, { ...LAMBERT, name: "renamed" })).toBe(true);
+    expect(sameCrsState(LAMBERT, undefined)).toBe(false);
+    expect(sameCrsState(LAMBERT, UTM)).toBe(false);
+  });
+});

From fa63f5e198a22f02560089c059a45b0a11788eb0 Mon Sep 17 00:00:00 2001
From: MaxNumerique <maximilienlandois@gmail.com>
Date: Mon, 2 Nov 2026 15:32:41 +0100
Subject: [PATCH 25/29] feat(crs): warn about data without crs, larger project
 crs widget

Data left without CRS while the project has one get the warning icon,
with a tooltip asking to georeference them. The project CRS widget is
larger and moved away from the corner.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 app/components/ProjectCrs.vue                   |  8 ++++----
 .../Viewer/ObjectTree/Base/ItemLabel.vue        | 17 +++++++++--------
 tests/unit/components/ItemLabel.nuxt.test.ts    | 13 ++++++++++---
 tests/unit/components/ProjectCrs.nuxt.test.ts   |  2 +-
 4 files changed, 24 insertions(+), 16 deletions(-)

diff --git a/app/components/ProjectCrs.vue b/app/components/ProjectCrs.vue
index fd844a727..8538766c1 100644
--- a/app/components/ProjectCrs.vue
+++ b/app/components/ProjectCrs.vue
@@ -15,7 +15,7 @@ const label = computed<string>(() =>
   <v-btn
     data-testid="projectCrs"
     class="project-crs text-none"
-    size="x-small"
+    size="small"
     variant="tonal"
     prepend-icon="mdi-earth"
     :disabled="!crsStore.crsEditEnabled"
@@ -29,9 +29,9 @@ const label = computed<string>(() =>
 <style scoped>
 .project-crs {
   position: absolute;
-  right: 8px;
-  bottom: 4px;
+  right: 16px;
+  bottom: 12px;
   z-index: 1;
-  max-width: 20%;
+  max-width: 360px;
 }
 </style>
diff --git a/app/components/Viewer/ObjectTree/Base/ItemLabel.vue b/app/components/Viewer/ObjectTree/Base/ItemLabel.vue
index ec4f837a4..aba00f8f9 100644
--- a/app/components/Viewer/ObjectTree/Base/ItemLabel.vue
+++ b/app/components/Viewer/ObjectTree/Base/ItemLabel.vue
@@ -75,13 +75,14 @@ const crsLabel = computed<string>(
 );
 
 // Read from the store map: one database query for the whole tree, not one per row
-const mismatchedCrs = computed(() =>
-  showCrs ? crsStore.mismatchedCrs.get(actualItem.value.id) : undefined,
-);
-const mismatchTooltip = computed<string>(
-  () =>
-    `In ${formatCrsCode(mismatchedCrs.value)}, project in ${formatCrsCode(crsStore.projectCrs)}. Convert it to show it on the map.`,
-);
+const mismatched = computed(() => showCrs && crsStore.mismatchedCrs.has(actualItem.value.id));
+const mismatchTooltip = computed<string>(() => {
+  const project = formatCrsCode(crsStore.projectCrs);
+  const crs = crsStore.mismatchedCrs.get(actualItem.value.id);
+  return crs === undefined
+    ? `No CRS, project in ${project}. Georeference it to show it on the map.`
+    : `In ${formatCrsCode(crs)}, project in ${project}. Convert it to show it on the map.`;
+});
 
 const tooltipDisabled = computed<boolean>(() => {
   if (actualItem.value.category !== undefined) {
@@ -180,7 +181,7 @@ async function copyToClipboard(text: string, label: string): Promise<void> {
         </span>
       </div>
     </v-tooltip>
-    <v-tooltip v-if="mismatchedCrs" location="right">
+    <v-tooltip v-if="mismatched" location="right">
       <template #activator="{ props: warningProps }">
         <v-icon
           v-bind="warningProps"
diff --git a/tests/unit/components/ItemLabel.nuxt.test.ts b/tests/unit/components/ItemLabel.nuxt.test.ts
index 4ef5f430f..e4d302194 100644
--- a/tests/unit/components/ItemLabel.nuxt.test.ts
+++ b/tests/unit/components/ItemLabel.nuxt.test.ts
@@ -134,7 +134,7 @@ describe("item label crs mismatch", () => {
   async function mountRow(id: string, showCrs = true): Promise<VueWrapper> {
     const pinia = setupActivePinia();
     const dataStore = useDataStore();
-    dataStore.refAllItems = mockAs<typeof dataStore.refAllItems>(() =>
+    dataStore.refCrsItems = mockAs<typeof dataStore.refCrsItems>(() =>
       ref([
         { id: "a", created_at: "1", crs: LAMBERT },
         { id: "b", created_at: "2", crs: UTM },
@@ -157,10 +157,17 @@ describe("item label crs mismatch", () => {
     );
   });
 
-  test("no warning for data in the project crs, without crs, or outside data rows", async () => {
+  test("warns about data without crs once the project has one", async () => {
+    const wrapper = await mountRow("local");
+    expect(wrapper.find('[data-testid="crsMismatchIcon"]').exists()).toBe(true);
+    expect(wrapper.text()).toContain(
+      "No CRS, project in EPSG:2154. Georeference it to show it on the map.",
+    );
+  });
+
+  test("no warning for data in the project crs, or outside data rows", async () => {
     const rows: [string, boolean][] = [
       ["a", true],
-      ["local", true],
       ["b", false],
     ];
     // oxlint-disable no-await-in-loop
diff --git a/tests/unit/components/ProjectCrs.nuxt.test.ts b/tests/unit/components/ProjectCrs.nuxt.test.ts
index 29a5e2b40..a7da6185b 100644
--- a/tests/unit/components/ProjectCrs.nuxt.test.ts
+++ b/tests/unit/components/ProjectCrs.nuxt.test.ts
@@ -20,7 +20,7 @@ async function mountWidget(
 ): Promise<VueWrapper> {
   const pinia = setupActivePinia();
   const dataStore = useDataStore();
-  dataStore.refAllItems = mockAs<typeof dataStore.refAllItems>(() => ref([]));
+  dataStore.refCrsItems = mockAs<typeof dataStore.refCrsItems>(() => ref([]));
   setup(useCrsStore());
   const wrapper = await mountSuspended(ProjectCrs, { global: { plugins: [vuetify, pinia] } });
   return wrapper;

From 5503a0f74f49fdfac6b746b7c4478b83bf260b72 Mon Sep 17 00:00:00 2001
From: MaxNumerique <maximilienlandois@gmail.com>
Date: Mon, 2 Nov 2026 15:41:38 +0100
Subject: [PATCH 26/29] fix(crs): restore the project crs once every data is
 imported

Loading a project added its data one chunk at a time after the project
CRS was restored: on the first data alone, the project CRS followed
them and the saved one was lost. The project CRS is now restored once
every data item is added.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 app/composables/project_manager.ts                  | 13 +++++++------
 tests/unit/composables/project_manager.nuxt.test.ts |  3 ++-
 2 files changed, 9 insertions(+), 7 deletions(-)

diff --git a/app/composables/project_manager.ts b/app/composables/project_manager.ts
index 2eb8086b8..1114a9a1f 100644
--- a/app/composables/project_manager.ts
+++ b/app/composables/project_manager.ts
@@ -142,17 +142,18 @@ async function importProject(file: File): Promise<void> {
   if (snapshot.data !== undefined) {
     await dataStore.importStores(snapshot.data);
   }
-  // A project saved without a project CRS takes the one of its oldest data. The snapshot is
-  // Read, not the stored items: they are added later, with the import time as creation date
+  await hybridViewerStore.initHybridViewer();
+
+  const items = snapshot.data?.items ?? [];
+  await importWorkflowFromSnapshot(items);
+  // After every data item is added: on partial data the project CRS would follow them.
+  // A project saved without a project CRS takes the one of its oldest data, read in the
+  // Snapshot: the stored items carry the import time as creation date
   crsStore.importStores(
     snapshot.crs?.projectCrs === undefined
       ? { projectCrs: oldestCrs(snapshot.data?.items ?? []) }
       : snapshot.crs,
   );
-  await hybridViewerStore.initHybridViewer();
-
-  const items = snapshot.data?.items ?? [];
-  await importWorkflowFromSnapshot(items);
   await hybridViewerStore.importStores(snapshot.hybridViewer);
   if (snapshot.dataStyle !== undefined) {
     await dataStyleStore.importStores(snapshot.dataStyle);
diff --git a/tests/unit/composables/project_manager.nuxt.test.ts b/tests/unit/composables/project_manager.nuxt.test.ts
index 4b269bb0f..6285f9c54 100644
--- a/tests/unit/composables/project_manager.nuxt.test.ts
+++ b/tests/unit/composables/project_manager.nuxt.test.ts
@@ -388,8 +388,9 @@ describe("projectManager composable (compact)", () => {
     expect(crsStoreMock.importStores).toHaveBeenCalledWith(snapshotMock.crs);
     const dataOrder = Math.min(...dataStoreMock.importStores.mock.invocationCallOrder);
     expect(Math.min(...crsStoreMock.reset.mock.invocationCallOrder)).toBeLessThan(dataOrder);
+    // Once every data item is added: partial data would make the project crs follow them
     expect(Math.min(...crsStoreMock.importStores.mock.invocationCallOrder)).toBeGreaterThan(
-      dataOrder,
+      Math.max(...dataStoreMock.addItem.mock.invocationCallOrder),
     );
   });
 

From d0fc3c4658c219667e18b4569f4da2a7e062e2aa Mon Sep 17 00:00:00 2001
From: MaxNumerique <maximilienlandois@gmail.com>
Date: Mon, 2 Nov 2026 16:27:39 +0100
Subject: [PATCH 27/29] feat(crs): open the crs dialog from the tree warning

A click on the warning icon of a data opens its CRS dialog, when the app
hosts it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 app/components/Viewer/ObjectTree/Base/ItemLabel.vue |  9 +++++++++
 tests/unit/components/ItemLabel.nuxt.test.ts        | 11 +++++++++++
 2 files changed, 20 insertions(+)

diff --git a/app/components/Viewer/ObjectTree/Base/ItemLabel.vue b/app/components/Viewer/ObjectTree/Base/ItemLabel.vue
index aba00f8f9..ae1034bb5 100644
--- a/app/components/Viewer/ObjectTree/Base/ItemLabel.vue
+++ b/app/components/Viewer/ObjectTree/Base/ItemLabel.vue
@@ -84,6 +84,13 @@ const mismatchTooltip = computed<string>(() => {
     : `In ${formatCrsCode(crs)}, project in ${project}. Convert it to show it on the map.`;
 });
 
+// The warning opens the CRS dialog of the data, when the app hosts it
+function editCrs(): void {
+  if (crsStore.crsEditEnabled) {
+    crsStore.requestCrsEdit(actualItem.value.id);
+  }
+}
+
 const tooltipDisabled = computed<boolean>(() => {
   if (actualItem.value.category !== undefined) {
     return false;
@@ -190,6 +197,8 @@ async function copyToClipboard(text: string, label: string): Promise<void> {
           color="warning"
           size="14"
           class="ml-1 flex-shrink-0"
+          :class="{ 'cursor-pointer': crsStore.crsEditEnabled }"
+          @click.stop="editCrs"
         />
       </template>
       {{ mismatchTooltip }}
diff --git a/tests/unit/components/ItemLabel.nuxt.test.ts b/tests/unit/components/ItemLabel.nuxt.test.ts
index e4d302194..202a5215e 100644
--- a/tests/unit/components/ItemLabel.nuxt.test.ts
+++ b/tests/unit/components/ItemLabel.nuxt.test.ts
@@ -157,6 +157,17 @@ describe("item label crs mismatch", () => {
     );
   });
 
+  test("a click on the warning asks for the crs edit of the data", async () => {
+    const wrapper = await mountRow("b");
+    const crsStore = useCrsStore();
+    await wrapper.find('[data-testid="crsMismatchIcon"]').trigger("click");
+    // No app hosts the dialog yet: nothing is asked
+    expect(crsStore.crsEditRequest).toBeUndefined();
+    crsStore.enableCrsEdit();
+    await wrapper.find('[data-testid="crsMismatchIcon"]').trigger("click");
+    expect(crsStore.crsEditRequest).toBe("b");
+  });
+
   test("warns about data without crs once the project has one", async () => {
     const wrapper = await mountRow("local");
     expect(wrapper.find('[data-testid="crsMismatchIcon"]').exists()).toBe(true);

From 4ea3d9618dc2d7e26da6b70ef0b28431bd3ede07 Mon Sep 17 00:00:00 2001
From: MaxNumerique <maximilienlandois@gmail.com>
Date: Tue, 3 Nov 2026 09:27:05 +0100
Subject: [PATCH 28/29] refactor(CrsSelector): type the selected rows as CRS
 keys

The table selection holds the "AUTHORITY:CODE" keys given by item-value:
it is typed as strings, and the selected CRS as a CRSList.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 app/components/CrsSelector.vue | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/app/components/CrsSelector.vue b/app/components/CrsSelector.vue
index 99b650833..9e4de11ef 100644
--- a/app/components/CrsSelector.vue
+++ b/app/components/CrsSelector.vue
@@ -15,7 +15,8 @@ const search = ref<string>("");
 const data_table_loading = ref<boolean>(false);
 // Thousands of rows that are never mutated: no deep reactivity
 const crs_list = shallowRef<CRSList[]>([]);
-const selected_crs = ref<unknown[]>([]);
+// Keys of the selected rows: the item-value of the table, "AUTHORITY:CODE"
+const selected_crs = ref<string[]>([]);
 const toggle_loading = useToggle(data_table_loading);
 const crsStore = useCrsStore();
 
@@ -24,7 +25,7 @@ function crs_key(crs: CRSList): string {
   return `${crs.authority}:${crs.code}`;
 }
 
-function get_selected_crs(key: unknown): CRSList | undefined {
+function get_selected_crs(key: string | undefined): CRSList | undefined {
   return crs_list.value.find((crs) => crs_key(crs) === key);
 }
 

From 1dc594c679580921851f0a26202d106fb7c4a90b Mon Sep 17 00:00:00 2001
From: MaxNumerique <maximilienlandois@gmail.com>
Date: Tue, 3 Nov 2026 10:31:34 +0100
Subject: [PATCH 29/29] trigger