diff --git a/app/components/CrsSelector.vue b/app/components/CrsSelector.vue
index 023c5b11b..9e4de11ef 100644
--- a/app/components/CrsSelector.vue
+++ b/app/components/CrsSelector.vue
@@ -1,63 +1,45 @@
 <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.geographic_coordinate_systems;
-
-interface Emits {
-  update_values: [values: Record<string, unknown>];
-  increment_step: [];
-  decrement_step: [];
-}
-
-const emit = defineEmits<Emits>();
+import type { CRSList } from "@geode/opengeodeweb-back/opengeodeweb_back_typed_schemas.js";
+import { useCrsStore } from "@ogw_front/stores/crs";
 
 interface Props {
   geodeObjectType: string;
-  keyToUpdate: string;
+  // Narrow containers: one "AUTHORITY:CODE" column and a truncated name
+  compact?: boolean;
 }
 
-const { geodeObjectType, keyToUpdate } = defineProps<Props>();
+const { geodeObjectType, compact = false } = defineProps<Props>();
+const selectedCrs = defineModel<CRSList | undefined>();
 
 const search = ref<string>("");
 const data_table_loading = ref<boolean>(false);
-const crs_list = ref<CRSList[]>([]);
-const selected_crs = ref<unknown[]>([]);
+// Thousands of rows that are never mutated: no deep reactivity
+const crs_list = shallowRef<CRSList[]>([]);
+// 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 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 {
+  return `${crs.authority}:${crs.code}`;
+}
 
-function get_selected_crs(crs_code: unknown): unknown {
-  for (const crs of crs_list.value) {
-    if (crs.code === crs_code) {
-      return crs;
-    }
-  }
+function get_selected_crs(key: string | undefined): 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 {
-  const params = { geode_object_type: geodeObjectType };
+async function get_crs_table(): Promise<void> {
   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();
 }
 
-const headers = [
+const full_headers = [
   {
     title: "Authority",
     align: "start",
@@ -68,24 +50,41 @@ const headers = [
   { title: "Name", align: "end", key: "name" },
 ] as const;
 
-// oxlint-disable-next-line no-top-level-await
-await get_crs_table();
+// 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;
+
+// "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
+onMounted(async () => {
+  await get_crs_table();
+});
 </script>
 
 <template>
   <v-text-field
     v-model="search"
-    append-icon="mdi-magnify"
+    data-testid="crsSearchInput"
+    :append-icon="compact ? undefined : 'mdi-magnify'"
+    :prepend-inner-icon="compact ? 'mdi-magnify' : undefined"
     label="Search"
     single-line
     hide-details
   ></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="code"
+    :item-value="crs_key"
     class="elevation-1"
     density="compact"
     fixed-header
@@ -94,5 +93,13 @@ await get_crs_table();
     :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/app/components/FeedBack/Snackers.vue b/app/components/FeedBack/Snackers.vue
index d132da425..ca42955ae 100644
--- a/app/components/FeedBack/Snackers.vue
+++ b/app/components/FeedBack/Snackers.vue
@@ -10,6 +10,15 @@ 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 {
+  try {
+    feedback.action?.onClick();
+  } finally {
+    // The snackbar closes even when the action fails
+    feedbackStore.delete_feedback(feedback.id);
+  }
+}
 </script>
 
 <template>
@@ -62,9 +71,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/components/ProjectCrs.vue b/app/components/ProjectCrs.vue
new file mode 100644
index 000000000..8538766c1
--- /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="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: 16px;
+  bottom: 12px;
+  z-index: 1;
+  max-width: 360px;
+}
+</style>
diff --git a/app/components/Viewer/ContextMenu/InfoCard.vue b/app/components/Viewer/ContextMenu/InfoCard.vue
index fb88aaf55..d4f9751c8 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,26 @@ const formattedId = computed<string>(() => formatId(metaData.id));
               class="ml-1"
             />
           </v-col>
+          <v-col
+            v-if="isData"
+            class="mt-1 d-inline-flex align-center px-2 py-0.5 text-caption"
+            style="font-size: 0.6rem"
+          >
+            <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-btn
+              v-if="crsStore.crsEditEnabled"
+              data-testid="infoEditCrsBtn"
+              icon="mdi-pencil"
+              variant="text"
+              density="compact"
+              size="x-small"
+              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" />
diff --git a/app/components/Viewer/ObjectTree/Base/ItemLabel.vue b/app/components/Viewer/ObjectTree/Base/ItemLabel.vue
index 246a93ca7..b27dbc6c9 100644
--- a/app/components/Viewer/ObjectTree/Base/ItemLabel.vue
+++ b/app/components/Viewer/ObjectTree/Base/ItemLabel.vue
@@ -1,9 +1,12 @@
 <script setup lang="ts">
+import { formatCrs, formatCrsCode } from "@ogw_front/utils/crs";
 import ComponentRelations from "@ogw_front/components/Viewer/ObjectTree/Base/ComponentRelations.vue";
 import type { DisplayItem } from "@ogw_front/composables/virtual_tree";
 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();
@@ -12,10 +15,11 @@ const { copy } = useClipboard();
 interface Props {
   item: DisplayItem;
   isLeaf?: boolean;
+  showCrs?: boolean;
   modelId?: string;
 }
 
-const { item, isLeaf, modelId = "" } = defineProps<Props>();
+const { item, isLeaf, showCrs = false, modelId = "" } = defineProps<Props>();
 
 interface Emits {
   contextmenu: [event: MouseEvent];
@@ -55,6 +59,40 @@ const tooltipTitle = computed<string>(() =>
   ),
 );
 
+const crsStore = useCrsStore();
+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(
+      formatCrs(dataItem.value?.crs),
+      TOOLTIP_NAME_MAX_LENGTH,
+      TOOLTIP_NAME_START_CHARS,
+      TOOLTIP_NAME_END_CHARS,
+    ) ?? "",
+);
+
+// Read from the store map: one database query for the whole tree, not one per row
+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.`;
+});
+
+// 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;
@@ -78,6 +116,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"
@@ -129,6 +168,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>
@@ -140,6 +195,21 @@ async function copyToClipboard(text: string, label: string): Promise<void> {
         />
       </div>
     </v-tooltip>
+    <v-tooltip v-if="mismatched" 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"
+          :class="{ 'cursor-pointer': crsStore.crsEditEnabled }"
+          @click.stop="editCrs"
+        />
+      </template>
+      {{ mismatchTooltip }}
+    </v-tooltip>
   </div>
 </template>
 
diff --git a/app/components/Viewer/ObjectTree/Views/GlobalObjects.vue b/app/components/Viewer/ObjectTree/Views/GlobalObjects.vue
index e6fb805aa..276b05b0c 100644
--- a/app/components/Viewer/ObjectTree/Views/GlobalObjects.vue
+++ b/app/components/Viewer/ObjectTree/Views/GlobalObjects.vue
@@ -193,6 +193,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/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/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/app/composables/project_manager.ts b/app/composables/project_manager.ts
index ed6627fca..91f279a40 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";
 
@@ -9,8 +11,10 @@ import type { CameraSnapshot } from "@ogw_internal/stores/hybrid_viewer/camera";
 import type { ModelComponentRecord } from "@ogw_front/stores/data_helpers/mesh.js";
 import type { ModelComponentRelationRecord } from "@ogw_front/stores/data.js";
 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";
 import { useFeedbackStore } from "@ogw_front/stores/feedback";
 import { useHybridViewerStore } from "@ogw_front/stores/hybrid_viewer";
 import { useViewerStore } from "@ogw_front/stores/viewer";
@@ -26,6 +30,7 @@ interface ProjectSnapshot {
   data?: ProjectDataSnapshot;
   hybridViewer?: CameraSnapshot;
   dataStyle?: DataStyleSnapshot;
+  crs?: { projectCrs?: CRSList };
 }
 
 async function exportProject(): Promise<{ result: Blob }> {
@@ -73,6 +78,7 @@ async function importProject(file: File): Promise<void> {
   const dataStore = useDataStore();
   const treeviewStore = useTreeviewStore();
   const hybridViewerStore = useHybridViewerStore();
+  const crsStore = useCrsStore();
 
   await viewerStore.ws_connect();
 
@@ -84,6 +90,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();
@@ -108,6 +115,14 @@ async function importProject(file: File): Promise<void> {
 
   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.importStores(snapshot.hybridViewer);
   if (snapshot.dataStyle !== undefined) {
     await dataStyleStore.importStores(snapshot.dataStyle);
diff --git a/app/stores/crs.ts b/app/stores/crs.ts
new file mode 100644
index 000000000..955406fe5
--- /dev/null
+++ b/app/stores/crs.ts
@@ -0,0 +1,136 @@
+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, 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 crsItems = dataStore.refCrsItems();
+  const projectCrs = ref<CRSList | undefined>(undefined);
+  const projectCrsEditRequest = ref(false);
+
+  // 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(
+    () => {
+      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 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 | undefined>();
+    for (const item of crsItems.value) {
+      if (project !== undefined && !sameCrs(item.crs, project)) {
+        mismatched.set(item.id, item.crs);
+      }
+    }
+    return mismatched;
+  });
+
+  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
+    geographicListPromise = undefined;
+    return [];
+  }
+
+  async function geographicList(geodeObjectType: string): Promise<CRSList[]> {
+    // 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 {
+    crsEditEnabled.value = true;
+  }
+
+  function requestCrsEdit(id: string): void {
+    crsEditRequest.value = id;
+  }
+
+  function clearCrsEditRequest(): void {
+    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(crsItems.value);
+  }
+
+  return {
+    crsItems,
+    geographicList,
+    crsEditEnabled,
+    enableCrsEdit,
+    crsEditRequest,
+    requestCrsEdit,
+    clearCrsEditRequest,
+    projectCrs,
+    mismatchedCrs,
+    setProjectCrs,
+    projectCrsEditRequest,
+    requestProjectCrsEdit,
+    clearProjectCrsEditRequest,
+    reset,
+    exportStores,
+    importStores,
+  };
+});
diff --git a/app/stores/data.ts b/app/stores/data.ts
index 19b146f1b..ca1738946 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";
@@ -22,8 +23,12 @@ interface DataItem {
   created_at: string;
   is_viewable?: boolean;
   binary_light_viewable?: string;
+  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;
@@ -43,6 +48,9 @@ interface NewDataItem {
   geode_object_type: string;
   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;
@@ -152,6 +160,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 () => {
@@ -219,6 +238,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;
   }
@@ -375,6 +397,7 @@ export const useDataStore = defineStore("data", () => {
   }
   return {
     refAllItems,
+    refCrsItems,
     refRegisteredItems,
     isRegistered,
     item,
@@ -415,4 +438,4 @@ export const useDataStore = defineStore("data", () => {
   };
 });
 
-export type { DataItem, NewDataItem, ModelComponentInput, ModelComponentRelationRecord };
+export type { CrsItem, DataItem, NewDataItem, ModelComponentInput, ModelComponentRelationRecord };
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/app/utils/crs.ts b/app/utils/crs.ts
new file mode 100644
index 000000000..2682a3abf
--- /dev/null
+++ b/app/utils/crs.ts
@@ -0,0 +1,38 @@
+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 {
+  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";
+}
+
+// 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
+  );
+}
+
+// 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<CrsItem, "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;
+}
+
+export { formatCrs, formatCrsCode, oldestCrs, sameCrs, sameCrsState };
diff --git a/app/utils/import_workflow.ts b/app/utils/import_workflow.ts
index d2f5936d5..675fc7ced 100644
--- a/app/utils/import_workflow.ts
+++ b/app/utils/import_workflow.ts
@@ -162,21 +162,33 @@ 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,
+  { rebuildActor = false }: { rebuildActor?: boolean } = {},
+): 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);
+  // 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();
+}
+
+// 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 +198,5 @@ export {
   importWorkflowFromSnapshot,
   importItem,
   applyTimeSeriesWorkflow,
+  reloadObject,
 };
diff --git a/internal/stores/hybrid_viewer/scene.ts b/internal/stores/hybrid_viewer/scene.ts
index 8eed733e3..c43301e38 100644
--- a/internal/stores/hybrid_viewer/scene.ts
+++ b/internal/stores/hybrid_viewer/scene.ts
@@ -69,12 +69,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/components/CrsSelector.nuxt.test.ts b/tests/unit/components/CrsSelector.nuxt.test.ts
index 94ac6b8cc..ba4e4c3a9 100644
--- a/tests/unit/components/CrsSelector.nuxt.test.ts
+++ b/tests/unit/components/CrsSelector.nuxt.test.ts
@@ -2,15 +2,20 @@
 // 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
 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 });
 
 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
@@ -34,35 +39,99 @@ 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 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" },
+    ];
+    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" },
+    });
+    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("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("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(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>(
+      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");
   });
 });
diff --git a/tests/unit/components/FeedBack/Snackers.nuxt.test.ts b/tests/unit/components/FeedBack/Snackers.nuxt.test.ts
index 08295dfc2..29d5aa518 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,83 @@ describe("feedback snackers", () => {
       ],
     });
 
+    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);
+  });
+
+  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>" },
       {
-        template: "<v-layout><FeedBackSnackers/></v-layout>",
-      },
-      {
-        props: {},
         global: {
-          components: {
-            FeedBackSnackers,
-          },
+          components: { FeedBackSnackers },
           plugins: [vuetify, pinia],
+          config: { errorHandler },
         },
       },
     );
+    await findButton(wrapper, "feedbackActionBtn")?.trigger("click");
 
-    expect(feedbackStore.feedbacks).toHaveLength(1);
-    const v_btn = wrapper.findComponent(components.VBtn);
-    await v_btn.trigger("click");
+    expect(errorHandler).toHaveBeenCalledExactlyOnceWith(
+      expect.any(Error),
+      expect.anything(),
+      expect.any(String),
+    );
     expect(feedbackStore.feedbacks).toHaveLength(0);
   });
 });
diff --git a/tests/unit/components/InfoCard.nuxt.test.ts b/tests/unit/components/InfoCard.nuxt.test.ts
new file mode 100644
index 000000000..0532520c1
--- /dev/null
+++ b/tests/unit/components/InfoCard.nuxt.test.ts
@@ -0,0 +1,66 @@
+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");
+    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");
+  });
+
+  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..202a5215e 100644
--- a/tests/unit/components/ItemLabel.nuxt.test.ts
+++ b/tests/unit/components/ItemLabel.nuxt.test.ts
@@ -1,11 +1,17 @@
 // Third party imports
-import { describe, expect, test } from "vitest";
+import { describe, expect, test, vi } from "vitest";
+import type { VueWrapper } from "@vue/test-utils";
 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);
@@ -19,6 +25,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();
 
@@ -41,4 +56,136 @@ 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: OpenTooltipStub } },
+      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("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 } },
+      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: OpenTooltipStub } },
+      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");
+  });
+});
+
+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.refCrsItems = mockAs<typeof dataStore.refCrsItems>(() =>
+      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("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);
+    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],
+      ["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
+  });
 });
diff --git a/tests/unit/components/ProjectCrs.nuxt.test.ts b/tests/unit/components/ProjectCrs.nuxt.test.ts
new file mode 100644
index 000000000..a7da6185b
--- /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.refCrsItems = mockAs<typeof dataStore.refCrsItems>(() => 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();
+  });
+});
diff --git a/tests/unit/composables/project_manager.nuxt.test.ts b/tests/unit/composables/project_manager.nuxt.test.ts
index 33391cf08..d8dffe420 100644
--- a/tests/unit/composables/project_manager.nuxt.test.ts
+++ b/tests/unit/composables/project_manager.nuxt.test.ts
@@ -7,9 +7,9 @@
 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 { appMode } from "@ogw_shared/app_mode";
 import backSchemas from "@geode/opengeodeweb-back/opengeodeweb_back_typed_schemas.js";
-import { setupActivePinia } from "@ogw_tests/utils";
 
 // Constants
 const PANEL_WIDTH = 300;
@@ -35,6 +35,7 @@ const VIEWER_CALL_COUNT = 1;
 
 // Snapshot
 const snapshotMock = {
+  crs: { projectCrs: { authority: "EPSG", code: "32631", name: "WGS 84 / UTM zone 31N" } },
   data: {
     items: [
       {
@@ -185,6 +186,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" })),
 };
@@ -263,6 +271,7 @@ describe("projectManager composable (compact)", () => {
       dataStyleStoreMock,
       hybridViewerStoreMock,
       feedbackStoreMock,
+      crsStoreMock,
     ];
     for (const store of storesList) {
       const values = Object.values(store);
@@ -314,4 +323,44 @@ 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);
+    // Once every data item is added: partial data would make the project crs follow them
+    expect(Math.min(...crsStoreMock.importStores.mock.invocationCallOrder)).toBeGreaterThan(
+      Math.max(...dataStoreMock.addItem.mock.invocationCallOrder),
+    );
+  });
+
+  // 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 });
+  });
 });
diff --git a/tests/unit/stores/crs.nuxt.test.ts b/tests/unit/stores/crs.nuxt.test.ts
new file mode 100644
index 000000000..9ee6dfce3
--- /dev/null
+++ b/tests/unit/stores/crs.nuxt.test.ts
@@ -0,0 +1,176 @@
+// 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";
+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" }];
+
+function mockItems(items: DataItem[]): Ref<DataItem[]> {
+  const data = ref(items);
+  const dataStore = useDataStore();
+  dataStore.refCrsItems = mockAs<typeof dataStore.refCrsItems>(() => data);
+  return data;
+}
+
+describe("crs store", () => {
+  beforeEach(() => {
+    setupActivePinia();
+    mockItems([]);
+  });
+
+  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);
+    const crsStore = useCrsStore();
+
+    const [first, second] = await Promise.all([
+      crsStore.geographicList("PointSet3D"),
+      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);
+    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();
+  });
+});
+
+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("follows when every georeferenced data is in one crs", async () => {
+    const data = mockItems([]);
+    const crsStore = useCrsStore();
+    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: 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", () => {
+    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();
+    // 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", () => {
+    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/stores/data.nuxt.test.ts b/tests/unit/stores/data.nuxt.test.ts
index 50b80253f..784a5e9bf 100644
--- a/tests/unit/stores/data.nuxt.test.ts
+++ b/tests/unit/stores/data.nuxt.test.ts
@@ -8,6 +8,8 @@ import { useViewerStore } from "@ogw_front/stores/viewer";
 
 const DATA_ID_LENGTH = 32;
 
+vi.setConfig({ testTimeout: 10_000 });
+
 function component(geode_id: string, type: string, viewer_id: number): ModelComponentInput {
   return { geode_id, name: geode_id, type, viewer_id, is_active: true };
 }
@@ -53,6 +55,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/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", () => {
diff --git a/tests/unit/utils/crs.nuxt.test.ts b/tests/unit/utils/crs.nuxt.test.ts
new file mode 100644
index 000000000..19e6d11c4
--- /dev/null
+++ b/tests/unit/utils/crs.nuxt.test.ts
@@ -0,0 +1,58 @@
+import { describe, expect, test, vi } from "vitest";
+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";
+
+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");
+  });
+});
+
+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();
+  });
+});
+
+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);
+  });
+});
diff --git a/tests/unit/utils/import_workflow.nuxt.test.ts b/tests/unit/utils/import_workflow.nuxt.test.ts
index 95452915a..8cc4d3419 100644
--- a/tests/unit/utils/import_workflow.nuxt.test.ts
+++ b/tests/unit/utils/import_workflow.nuxt.test.ts
@@ -3,19 +3,26 @@
 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;
   applyDefaultStyle: Mock;
   addDataStyle: Mock;
   remoteRender: Mock;
+  addHybridItem: Mock;
 } {
   const calls: string[] = [];
   const backStore = useBackStore();
@@ -29,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" }),
@@ -47,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", () => {
@@ -62,6 +73,7 @@ describe("apply time series workflow", () => {
     expect(request).toHaveBeenCalledWith(
       expect.objectContaining({ params: { id: "brep_id", filename: "time_series.pvd" } }),
     );
+    // 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();
@@ -76,6 +88,29 @@ 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();
+  });
+
+  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", () => {
   setupActivePinia();