diff --git a/app/components/CrsSelector.vue b/app/components/CrsSelector.vue
index 5d35f627..1bf34f31 100644
--- a/app/components/CrsSelector.vue
+++ b/app/components/CrsSelector.vue
@@ -70,7 +70,7 @@
     toggle_loading()
     await geodeStore.request(schema, params, {
       response_function: (response) => {
-        crs_list.value = response._data.crs_list
+        crs_list.value = response.crs_list
       },
     })
     toggle_loading()
diff --git a/app/components/ExtensionSelector.vue b/app/components/ExtensionSelector.vue
index e324e9af..64efabe8 100644
--- a/app/components/ExtensionSelector.vue
+++ b/app/components/ExtensionSelector.vue
@@ -90,7 +90,7 @@
         geodeStore.request(schema, params, {
           request_error_function: () => reject(),
           response_function: (response) => {
-            resolve(response._data.geode_objects_and_output_extensions)
+            resolve(response.geode_objects_and_output_extensions)
           },
           response_error_function: () => reject(),
         })
diff --git a/app/components/FileSelector.vue b/app/components/FileSelector.vue
index 081eeaeb..d3e206ff 100644
--- a/app/components/FileSelector.vue
+++ b/app/components/FileSelector.vue
@@ -58,7 +58,7 @@
     toggle_loading()
     const geodeStore = useGeodeStore()
     const response = await geodeStore.request(schema, {})
-    accept.value = response.data.value.extensions
+    accept.value = response.extensions
       .map((extension) => "." + extension)
       .join(",")
     toggle_loading()
diff --git a/app/components/Inspector/InspectionButton.vue b/app/components/Inspector/InspectionButton.vue
index 00a20435..73c15376 100644
--- a/app/components/Inspector/InspectionButton.vue
+++ b/app/components/Inspector/InspectionButton.vue
@@ -39,7 +39,7 @@
     await geodeStore.request(schema, params, {
       response_function: (response) => {
         emit("update_values", {
-          inspection_result: [response._data.inspection_result],
+          inspection_result: [response.inspection_result],
         })
         emit("increment_step")
       },
diff --git a/app/components/MissingFilesSelector.vue b/app/components/MissingFilesSelector.vue
index de3a3cad..a7ebfe22 100644
--- a/app/components/MissingFilesSelector.vue
+++ b/app/components/MissingFilesSelector.vue
@@ -89,7 +89,7 @@
       return new Promise((resolve, reject) => {
         geodeStore.request(schema, params, {
           request_error_function: () => reject(),
-          response_function: (response) => resolve(response._data),
+          response_function: (response) => resolve(response),
           response_error_function: () => reject(),
         })
       })
diff --git a/app/components/ObjectSelector.vue b/app/components/ObjectSelector.vue
index e419ae43..27c020f6 100644
--- a/app/components/ObjectSelector.vue
+++ b/app/components/ObjectSelector.vue
@@ -115,9 +115,7 @@
       return geodeStore.request(schema, { filename })
     })
     const responses = await Promise.all(promise_array)
-    const allowed_objects_list = responses.map(
-      (r) => r.data.value.allowed_objects,
-    )
+    const allowed_objects_list = responses.map((r) => r.allowed_objects)
     const all_keys = [...new Set(allowed_objects_list.flatMap(Object.keys))]
     const common_keys = all_keys.filter((key) =>
       allowed_objects_list.every((obj) => key in obj),
diff --git a/app/components/PackagesVersions.vue b/app/components/PackagesVersions.vue
index 6d2b1440..8a98839e 100644
--- a/app/components/PackagesVersions.vue
+++ b/app/components/PackagesVersions.vue
@@ -35,7 +35,7 @@
       {},
       {
         response_function: (response) => {
-          packages_versions.value = response._data.versions
+          packages_versions.value = response.versions
         },
       },
     )
diff --git a/app/components/Viewer/Options/CellAttributeSelector.vue b/app/components/Viewer/Options/CellAttributeSelector.vue
index 19a49234..cd0c3153 100644
--- a/app/components/Viewer/Options/CellAttributeSelector.vue
+++ b/app/components/Viewer/Options/CellAttributeSelector.vue
@@ -44,7 +44,7 @@
       },
       {
         response_function: (response) => {
-          cell_attribute_names.value = response._data.cell_attribute_names
+          cell_attribute_names.value = response.cell_attribute_names
         },
       },
     )
diff --git a/app/components/Viewer/Options/PolygonAttributeSelector.vue b/app/components/Viewer/Options/PolygonAttributeSelector.vue
index efd930c8..0c24c1b6 100644
--- a/app/components/Viewer/Options/PolygonAttributeSelector.vue
+++ b/app/components/Viewer/Options/PolygonAttributeSelector.vue
@@ -44,7 +44,7 @@
       },
       {
         response_function: (response) => {
-          polygon_attribute_names.value = response._data.polygon_attribute_names
+          polygon_attribute_names.value = response.polygon_attribute_names
         },
       },
     )
diff --git a/app/components/Viewer/Options/PolyhedronAttributeSelector.vue b/app/components/Viewer/Options/PolyhedronAttributeSelector.vue
index 6bf2cd27..b4e86a39 100644
--- a/app/components/Viewer/Options/PolyhedronAttributeSelector.vue
+++ b/app/components/Viewer/Options/PolyhedronAttributeSelector.vue
@@ -46,8 +46,7 @@
       { id: props.id },
       {
         response_function: (response) => {
-          polyhedron_attribute_names.value =
-            response._data.polyhedron_attribute_names
+          polyhedron_attribute_names.value = response.polyhedron_attribute_names
         },
       },
     )
diff --git a/app/components/Viewer/Options/TextureItem.vue b/app/components/Viewer/Options/TextureItem.vue
index 3cd558aa..a1d77878 100644
--- a/app/components/Viewer/Options/TextureItem.vue
+++ b/app/components/Viewer/Options/TextureItem.vue
@@ -67,7 +67,7 @@
       { id: props.id },
       {
         response_function: (response) => {
-          texture_coordinates.value = response._data.texture_coordinates
+          texture_coordinates.value = response.texture_coordinates
         },
       },
     )
@@ -86,7 +86,7 @@
         },
         {
           response_function: async (response) => {
-            texture_id.value = response._data.id
+            texture_id.value = response.id
           },
         },
       )
diff --git a/app/components/Viewer/Options/VertexAttributeSelector.vue b/app/components/Viewer/Options/VertexAttributeSelector.vue
index 39cb021b..3dcc5036 100644
--- a/app/components/Viewer/Options/VertexAttributeSelector.vue
+++ b/app/components/Viewer/Options/VertexAttributeSelector.vue
@@ -41,7 +41,7 @@
       { id: props.id },
       {
         response_function: (response) => {
-          vertex_attribute_names.value = response._data.vertex_attribute_names
+          vertex_attribute_names.value = response.vertex_attribute_names
         },
       },
     )
diff --git a/app/components/Viewer/TreeComponent.vue b/app/components/Viewer/TreeComponent.vue
index b339d67a..a4d721b5 100644
--- a/app/components/Viewer/TreeComponent.vue
+++ b/app/components/Viewer/TreeComponent.vue
@@ -26,9 +26,9 @@
 
   const props = defineProps({ id: { type: String, required: true } })
 
-  const items = dataStore.formatedMeshComponents(props.id)
-  const mesh_components_selection = ref(
-    dataStyleStore.visibleMeshComponents(props.id),
+  const items = await dataStore.formatedMeshComponents(props.id)
+  const mesh_components_selection = dataStyleStore.visibleMeshComponents(
+    props.id,
   )
 
   watch(
@@ -37,79 +37,23 @@
       if (!previous) previous = []
       else {
         const { added, removed } = compareSelections(current, previous)
-
-        const [added_corners, added_lines, added_surfaces, added_blocks] =
-          sortMeshComponents(added)
-        const [
-          removed_corners,
-          removed_lines,
-          removed_surfaces,
-          removed_blocks,
-        ] = sortMeshComponents(removed)
-        if (added_corners.length > 0) {
-          dataStyleStore.setModelCornersVisibility(
-            props.id,
-            added_corners,
-            true,
-          )
-        }
-        if (added_lines.length > 0) {
-          dataStyleStore.setModelLinesVisibility(props.id, added_lines, true)
-        }
-        if (added_surfaces.length > 0) {
-          dataStyleStore.setModelSurfacesVisibility(
-            props.id,
-            added_surfaces,
-            true,
-          )
-        }
-        if (added_blocks.length > 0) {
-          dataStyleStore.setModelBlocksVisibility(props.id, added_blocks, true)
-        }
-        if (removed_corners.length > 0) {
-          dataStyleStore.setModelCornersVisibility(
-            props.id,
-            removed_corners,
-            false,
-          )
+        if (added.length > 0) {
+          dataStyleStore
+            .setModelMeshComponentVisibility(props.id, added, true)
+            .then(() => {
+              hybridViewerStore.remoteRender()
+            })
+        } else if (removed.length > 0) {
+          dataStyleStore
+            .setModelMeshComponentVisibility(props.id, removed, false)
+            .then(() => {
+              hybridViewerStore.remoteRender()
+            })
         }
-        if (removed_lines.length > 0) {
-          dataStyleStore.setModelLinesVisibility(props.id, removed_lines, false)
-        }
-        if (removed_surfaces.length > 0) {
-          dataStyleStore.setModelSurfacesVisibility(
-            props.id,
-            removed_surfaces,
-            false,
-          )
-        }
-        if (removed_blocks.length > 0) {
-          dataStyleStore.setModelBlocksVisibility(
-            props.id,
-            removed_blocks,
-            false,
-          )
-        }
-        hybridViewerStore.remoteRender()
       }
     },
     { immediate: true, deep: true },
   )
-
-  function sortMeshComponents(items) {
-    var corner_ids = [],
-      line_ids = [],
-      surface_ids = [],
-      block_ids = []
-    for (const item of items) {
-      const item_type = dataStore.meshComponentType(props.id, item)
-      if (item_type === "corner") corner_ids.push(item)
-      else if (item_type === "line") line_ids.push(item)
-      else if (item_type === "surface") surface_ids.push(item)
-      else if (item_type === "block") block_ids.push(item)
-    }
-    return [corner_ids, line_ids, surface_ids, block_ids]
-  }
 </script>
 
 <style scoped>
diff --git a/app/stores/data.js b/app/stores/data.js
index 8f196b64..f6e6de4c 100644
--- a/app/stores/data.js
+++ b/app/stores/data.js
@@ -38,36 +38,33 @@ export const useDataStore = defineStore("data", () => {
     return observable
   }
 
-  function formatedMeshComponents(id) {
-    const item = getItem(id).value
-    if (!item || !item.mesh_components) return []
-    const { mesh_components } = item
+  async function formatedMeshComponents(id) {
+    const items = await database.model_components.where({ id }).toArray()
+    const distinctTypes = [...new Set(items.map((item) => item.type))]
     const formated_mesh_components = []
+    for (const type of distinctTypes) {
+      const meshComponents = await database.model_components
+        .where({ id, type })
+        .toArray()
 
-    for (const [category, uuids] of Object.entries(mesh_components)) {
       formated_mesh_components.push({
-        id: category,
-        title: category,
-        children: uuids.map((uuid) => ({
-          id: uuid,
-          title: uuid,
-          category,
+        id: type,
+        title: type,
+        children: meshComponents.map((meshComponent) => ({
+          id: meshComponent.geode_id,
+          title: meshComponent.name,
+          category: meshComponent.type,
         })),
       })
     }
+
     return formated_mesh_components
   }
 
-  function meshComponentType(id, uuid) {
-    const item = getItem(id).value
-    if (!item || !item.mesh_components) return null
-    const { mesh_components } = item
-
-    if (mesh_components["Corner"]?.includes(uuid)) return "corner"
-    else if (mesh_components["Line"]?.includes(uuid)) return "line"
-    else if (mesh_components["Surface"]?.includes(uuid)) return "surface"
-    else if (mesh_components["Block"]?.includes(uuid)) return "block"
-    return null
+  async function meshComponentType(id, geode_id) {
+    return (
+      await database.model_components.where({ id, geode_id }).toArray()
+    ).map((component) => component.type)[0]
   }
 
   async function registerObject(id) {
@@ -91,15 +88,26 @@ export const useDataStore = defineStore("data", () => {
     const serializedData = JSON.parse(JSON.stringify(itemData))
     await database.data.put(serializedData)
   }
-
   async function deleteItem(id) {
     await database.data.delete(id)
+    await deleteModelComponents(id)
   }
-
   async function updateItem(id, changes) {
     await database.data.update(id, changes)
   }
 
+  async function addModelComponents(values) {
+    values.map((value) => {
+      value.created_at = new Date().toISOString()
+    })
+    const serializedData = JSON.parse(JSON.stringify(values))
+    await database.model_components.bulkAdd(serializedData)
+  }
+
+  async function deleteModelComponents(id) {
+    await database.model_components.where({ id }).delete()
+  }
+
   async function fetchMeshComponents(id) {
     const geodeStore = useGeodeStore()
     return geodeStore.request(
@@ -107,66 +115,45 @@ export const useDataStore = defineStore("data", () => {
       { id },
       {
         response_function: async (response) => {
-          const mesh_components = response._data.uuid_dict
-          await updateItem(id, { mesh_components })
+          const { mesh_components } = response
+          await addModelComponents(mesh_components)
         },
       },
     )
   }
 
-  async function fetchUuidToFlatIndexDict(id) {
-    const geodeStore = useGeodeStore()
-    return geodeStore.request(
-      back_model_schemas.vtm_component_indices,
-      { id },
-      {
-        response_function: async (response) => {
-          const uuid_to_flat_index = response._data.uuid_to_flat_index
-          await updateItem(id, { uuid_to_flat_index })
-        },
-      },
-    )
+  async function getMeshComponentGeodeIds(id, meshComponentType) {
+    return (
+      await database.model_components
+        .where({ id, type: meshComponentType })
+        .toArray()
+    ).map((component) => component.geode_id)
   }
 
-  async function getCornersUuids(id) {
-    const item = await getItem(id).fetch()
-    if (!item || !item.mesh_components) return []
-    const { mesh_components } = item
-    return Object.values(mesh_components["Corner"] || {})
+  async function getCornersGeodeIds(id) {
+    return getMeshComponentGeodeIds(id, "Corner")
   }
 
-  async function getLinesUuids(id) {
-    const item = await getItem(id).fetch()
-    if (!item || !item.mesh_components) return []
-    const { mesh_components } = item
-    return Object.values(mesh_components["Line"] || {})
+  async function getLinesGeodeIds(id) {
+    return getMeshComponentGeodeIds(id, "Line")
   }
 
-  async function getSurfacesUuids(id) {
-    const item = await getItem(id).fetch()
-    if (!item || !item.mesh_components) return []
-    const { mesh_components } = item
-    return Object.values(mesh_components["Surface"] || {})
+  async function getSurfacesGeodeIds(id) {
+    return getMeshComponentGeodeIds(id, "Surface")
   }
 
-  async function getBlocksUuids(id) {
-    const item = await getItem(id).fetch()
-    if (!item || !item.mesh_components) return []
-    const { mesh_components } = item
-    return Object.values(mesh_components["Block"] || {})
+  async function getBlocksGeodeIds(id) {
+    return getMeshComponentGeodeIds(id, "Block")
   }
 
-  async function getFlatIndexes(id, mesh_component_ids) {
-    const item = await getItem(id).fetch()
-    if (!item || !item.uuid_to_flat_index) return []
-    const { uuid_to_flat_index } = item
-    const flat_indexes = []
-    for (const mesh_component_id of mesh_component_ids) {
-      if (uuid_to_flat_index[mesh_component_id] !== undefined) {
-        flat_indexes.push(uuid_to_flat_index[mesh_component_id])
-      }
-    }
-    return flat_indexes
+  async function getMeshComponentsViewerIds(id, meshComponentGeodeIds) {
+    return (
+      await database.model_components
+        .where("id")
+        .equals(id)
+        .and((component) => meshComponentGeodeIds.includes(component.geode_id))
+        .toArray()
+    ).map((component) => component.viewer_id)
   }
 
   async function exportStores() {
@@ -192,13 +179,12 @@ export const useDataStore = defineStore("data", () => {
     addItem,
     deleteItem,
     updateItem,
-    fetchUuidToFlatIndexDict,
     fetchMeshComponents,
-    getCornersUuids,
-    getLinesUuids,
-    getSurfacesUuids,
-    getBlocksUuids,
-    getFlatIndexes,
+    getCornersGeodeIds,
+    getLinesGeodeIds,
+    getSurfacesGeodeIds,
+    getBlocksGeodeIds,
+    getMeshComponentsViewerIds,
     exportStores,
     importStores,
     clear,
diff --git a/app/stores/geode.js b/app/stores/geode.js
index 3fb12f48..1d1a975c 100644
--- a/app/stores/geode.js
+++ b/app/stores/geode.js
@@ -44,33 +44,33 @@ export const useGeodeStore = defineStore("geode", {
     },
   },
   actions: {
-    ping_task() {
+    set_ping() {
+      this.ping()
       setInterval(() => {
-        this.do_ping()
+        this.ping()
       }, 10 * 1000)
     },
-    do_ping() {
+    ping() {
       const geodeStore = this
       const feedbackStore = useFeedbackStore()
-      return useFetch(back_schemas.opengeodeweb_back.ping.$id, {
-        baseURL: this.base_url,
-        method: back_schemas.opengeodeweb_back.ping.methods[0],
-        body: {},
-        onRequestError({ error }) {
-          feedbackStore.$patch({ server_error: true })
-          geodeStore.status = Status.NOT_CONNECTED
-        },
-        onResponse({ response }) {
-          if (response.ok) {
+      return this.request(
+        back_schemas.opengeodeweb_back.ping,
+        {},
+        {
+          request_error_function: () => {
+            feedbackStore.$patch({ server_error: true })
+            geodeStore.status = Status.NOT_CONNECTED
+          },
+          response_function: () => {
             feedbackStore.$patch({ server_error: false })
             geodeStore.status = Status.CONNECTED
-          }
-        },
-        onResponseError({ response }) {
-          feedbackStore.$patch({ server_error: true })
-          geodeStore.status = Status.NOT_CONNECTED
+          },
+          response_error_function: () => {
+            feedbackStore.$patch({ server_error: true })
+            geodeStore.status = Status.NOT_CONNECTED
+          },
         },
-      })
+      )
     },
     start_request() {
       this.request_counter++
@@ -84,7 +84,8 @@ export const useGeodeStore = defineStore("geode", {
     },
     connect() {
       console.log("[GEODE] Connecting to geode microservice...")
-      return this.ping_task()
+      this.set_ping()
+      return Promise.resolve()
     },
     request(schema, params, callbacks = {}) {
       console.log("[GEODE] Request:", schema.$id)
diff --git a/app/utils/file_import_workflow.js b/app/utils/file_import_workflow.js
index 72de3c7b..09a64e1e 100644
--- a/app/utils/file_import_workflow.js
+++ b/app/utils/file_import_workflow.js
@@ -50,10 +50,7 @@ async function importItem(item) {
   await dataStyleStore.addDataStyle(item.id, item.geode_object_type)
 
   if (item.viewer_type === "model") {
-    await Promise.all([
-      dataStore.fetchMeshComponents(item.id),
-      dataStore.fetchUuidToFlatIndexDict(item.id),
-    ])
+    await dataStore.fetchMeshComponents(item.id)
   }
 
   await dataStyleStore.applyDefaultStyle(item.id)
@@ -70,10 +67,7 @@ async function importFile(filename, geode_object_type) {
     },
   )
 
-  const item = buildImportItemFromPayloadApi(
-    response.data.value,
-    geode_object_type,
-  )
+  const item = buildImportItemFromPayloadApi(response, geode_object_type)
   return importItem(item)
 }
 
diff --git a/app/utils/local.js b/app/utils/local.js
index ce34bfc0..54d29628 100644
--- a/app/utils/local.js
+++ b/app/utils/local.js
@@ -143,7 +143,7 @@ async function run_back(
       "--allowed_origin http://localhost:*",
       "--timeout " + 0,
     ]
-    if (process.env.NODE_ENV === "development") {
+    if (process.env.NODE_ENV === "development" || !process.env.NODE_ENV) {
       back_args.push("--debug")
     }
     console.log("run_back", executable_name, executable_path, back_args)
diff --git a/app/utils/upload_file.js b/app/utils/upload_file.js
index 28e04518..38f30bc3 100644
--- a/app/utils/upload_file.js
+++ b/app/utils/upload_file.js
@@ -43,8 +43,8 @@ export async function upload_file(
       feedbackStore.add_error(
         response.status,
         route,
-        response._data.name,
-        response._data.description,
+        response.name,
+        response.description,
       )
       if (response_error_function) {
         response_error_function(response)
diff --git a/internal/database/database.js b/internal/database/database.js
index 8aa65378..a8666e73 100644
--- a/internal/database/database.js
+++ b/internal/database/database.js
@@ -1,5 +1,6 @@
 import Dexie from "dexie"
-import { dataTable } from "./tables/data_table.js"
+import { dataTable } from "./tables/data_table"
+import { modelComponentsTable } from "./tables/model_components"
 
 export class Database extends Dexie {
   constructor() {
@@ -7,6 +8,7 @@ export class Database extends Dexie {
 
     this.version(1).stores({
       [dataTable.name]: dataTable.schema,
+      [modelComponentsTable.name]: modelComponentsTable.schema,
     })
   }
 
@@ -15,7 +17,7 @@ export class Database extends Dexie {
     await tempDb.open()
 
     if (tempDb.tables.some((t) => t.name === tableName)) {
-      console.warn(`Table "${tableName}" existe déjà`)
+      console.warn(`Table "${tableName}" already exists`)
       tempDb.close()
       return tempDb
     }
@@ -39,6 +41,7 @@ export class Database extends Dexie {
           if (v === 1) {
             this.version(1).stores({
               [dataTable.name]: dataTable.schema,
+              [modelComponentsTable.name]: modelComponentsTable.schema,
             })
           } else {
             this.version(v).stores(currentStores)
diff --git a/internal/database/tables/model_components.js b/internal/database/tables/model_components.js
new file mode 100644
index 00000000..a260bf5c
--- /dev/null
+++ b/internal/database/tables/model_components.js
@@ -0,0 +1,4 @@
+export const modelComponentsTable = {
+  name: "model_components",
+  schema: "[id+geode_id], viewer_id, type, name, created_at",
+}
diff --git a/internal/stores/model/blocks.js b/internal/stores/model/blocks.js
index 28f9be1f..bc1b92ae 100644
--- a/internal/stores/model/blocks.js
+++ b/internal/stores/model/blocks.js
@@ -32,13 +32,13 @@ export function useModelBlocksStyle() {
     modelBlockStyle(id, block_id).visibility = visibility
   }
   async function setModelBlocksVisibility(id, block_ids, visibility) {
-    const blocks_flat_indexes = await dataStore.getFlatIndexes(id, block_ids)
-    if (blocks_flat_indexes.length === 0) {
-      return Promise.resolve()
-    }
+    const blocks_viewer_ids = await dataStore.getMeshComponentsViewerIds(
+      id,
+      block_ids,
+    )
     return viewerStore.request(
       model_blocks_schemas.visibility,
-      { id, block_ids: blocks_flat_indexes, visibility },
+      { id, block_ids: blocks_viewer_ids, visibility },
       {
         response_function: () => {
           for (const block_id of block_ids) {
@@ -63,13 +63,13 @@ export function useModelBlocksStyle() {
   }
 
   async function setModelBlocksColor(id, block_ids, color) {
-    const blocks_flat_indexes = await dataStore.getFlatIndexes(id, block_ids)
-    if (blocks_flat_indexes.length === 0) {
-      return Promise.resolve()
-    }
+    const blocks_viewer_ids = await dataStore.getMeshComponentsViewerIds(
+      id,
+      block_ids,
+    )
     return viewerStore.request(
       model_blocks_schemas.color,
-      { id, block_ids: blocks_flat_indexes, color },
+      { id, block_ids: blocks_viewer_ids, color },
       {
         response_function: () => {
           for (const block_id of block_ids) {
@@ -89,7 +89,7 @@ export function useModelBlocksStyle() {
 
   async function applyModelBlocksStyle(id) {
     const style = modelBlocksStyle(id)
-    const blocks_ids = await dataStore.getBlocksUuids(id)
+    const blocks_ids = await dataStore.getBlocksGeodeIds(id)
     return Promise.all([
       setModelBlocksVisibility(id, blocks_ids, style.visibility),
       setModelBlocksColor(id, blocks_ids, style.color),
diff --git a/internal/stores/model/corners.js b/internal/stores/model/corners.js
index c6e402f6..e1323f79 100644
--- a/internal/stores/model/corners.js
+++ b/internal/stores/model/corners.js
@@ -32,13 +32,13 @@ export function useModelCornersStyle() {
     modelCornerStyle(id, corner_id).visibility = visibility
   }
   async function setModelCornersVisibility(id, corner_ids, visibility) {
-    const corner_flat_indexes = await dataStore.getFlatIndexes(id, corner_ids)
-    if (corner_flat_indexes.length === 0) {
-      return Promise.resolve()
-    }
+    const corner_viewer_ids = await dataStore.getMeshComponentsViewerIds(
+      id,
+      corner_ids,
+    )
     return viewerStore.request(
       model_corners_schemas.visibility,
-      { id, block_ids: corner_flat_indexes, visibility },
+      { id, block_ids: corner_viewer_ids, visibility },
       {
         response_function: () => {
           for (const corner_id of corner_ids) {
@@ -64,13 +64,13 @@ export function useModelCornersStyle() {
   }
 
   async function setModelCornersColor(id, corner_ids, color) {
-    const corner_flat_indexes = await dataStore.getFlatIndexes(id, corner_ids)
-    if (corner_flat_indexes.length === 0) {
-      return Promise.resolve()
-    }
+    const corner_viewer_ids = await dataStore.getMeshComponentsViewerIds(
+      id,
+      corner_ids,
+    )
     return viewerStore.request(
       model_corners_schemas.color,
-      { id, block_ids: corner_flat_indexes, color },
+      { id, block_ids: corner_viewer_ids, color },
       {
         response_function: () => {
           for (const corner_id of corner_ids) {
@@ -89,7 +89,8 @@ export function useModelCornersStyle() {
 
   async function applyModelCornersStyle(id) {
     const style = modelCornersStyle(id)
-    const corner_ids = await dataStore.getCornersUuids(id)
+    const corner_ids = await dataStore.getCornersGeodeIds(id)
+    console.log(applyModelCornersStyle.name, { id }, { corner_ids })
     return Promise.all([
       setModelCornersVisibility(id, corner_ids, style.visibility),
       setModelCornersColor(id, corner_ids, style.color),
diff --git a/internal/stores/model/index.js b/internal/stores/model/index.js
index a2d38a22..7d83cfa8 100644
--- a/internal/stores/model/index.js
+++ b/internal/stores/model/index.js
@@ -98,34 +98,37 @@ export default function useModelStyle() {
     )
   }
 
-  function setModelMeshComponentVisibility(
+  async function setModelMeshComponentVisibility(
     id,
-    component_type,
-    component_id,
+    component_geode_ids,
     visibility,
   ) {
+    const component_type = await dataStore.meshComponentType(
+      id,
+      component_geode_ids[0],
+    )
     if (component_type === "Corner") {
       return modelCornersStyleStore.setModelCornersVisibility(
         id,
-        [component_id],
+        component_geode_ids,
         visibility,
       )
     } else if (component_type === "Line") {
       return modelLinesStyleStore.setModelLinesVisibility(
         id,
-        [component_id],
+        component_geode_ids,
         visibility,
       )
     } else if (component_type === "Surface") {
       return modelSurfacesStyleStore.setModelSurfacesVisibility(
         id,
-        [component_id],
+        component_geode_ids,
         visibility,
       )
     } else if (component_type === "Block") {
       return modelBlocksStyleStore.setModelBlocksVisibility(
         id,
-        [component_id],
+        component_geode_ids,
         visibility,
       )
     } else {
diff --git a/internal/stores/model/lines.js b/internal/stores/model/lines.js
index fb302ff4..a8b61ca6 100644
--- a/internal/stores/model/lines.js
+++ b/internal/stores/model/lines.js
@@ -32,13 +32,13 @@ export function useModelLinesStyle() {
     modelLineStyle(id, line_id).visibility = visibility
   }
   async function setModelLinesVisibility(id, line_ids, visibility) {
-    const line_flat_indexes = await dataStore.getFlatIndexes(id, line_ids)
-    if (line_flat_indexes.length === 0) {
-      return Promise.resolve()
-    }
+    const line_viewer_ids = await dataStore.getMeshComponentsViewerIds(
+      id,
+      line_ids,
+    )
     return viewerStore.request(
       model_lines_schemas.visibility,
-      { id, block_ids: line_flat_indexes, visibility },
+      { id, block_ids: line_viewer_ids, visibility },
       {
         response_function: () => {
           for (const line_id of line_ids) {
@@ -62,13 +62,13 @@ export function useModelLinesStyle() {
     modelLineStyle(id, line_id).color = color
   }
   async function setModelLinesColor(id, line_ids, color) {
-    const line_flat_indexes = await dataStore.getFlatIndexes(id, line_ids)
-    if (line_flat_indexes.length === 0) {
-      return Promise.resolve()
-    }
+    const line_viewer_ids = await dataStore.getMeshComponentsViewerIds(
+      id,
+      line_ids,
+    )
     return viewerStore.request(
       model_lines_schemas.color,
-      { id, block_ids: line_flat_indexes, color },
+      { id, block_ids: line_viewer_ids, color },
       {
         response_function: () => {
           for (const line_id of line_ids) {
@@ -87,7 +87,7 @@ export function useModelLinesStyle() {
 
   async function applyModelLinesStyle(id) {
     const style = modelLinesStyle(id)
-    const line_ids = await dataStore.getLinesUuids(id)
+    const line_ids = await dataStore.getLinesGeodeIds(id)
     return Promise.all([
       setModelLinesVisibility(id, line_ids, style.visibility),
       setModelLinesColor(id, line_ids, style.color),
diff --git a/internal/stores/model/surfaces.js b/internal/stores/model/surfaces.js
index f50d48fc..ee555bf3 100644
--- a/internal/stores/model/surfaces.js
+++ b/internal/stores/model/surfaces.js
@@ -31,13 +31,13 @@ export function useModelSurfacesStyle() {
     modelSurfaceStyle(id, surface_id).visibility = visibility
   }
   async function setModelSurfacesVisibility(id, surface_ids, visibility) {
-    const surface_flat_indexes = await dataStore.getFlatIndexes(id, surface_ids)
-    if (surface_flat_indexes.length === 0) {
-      return Promise.resolve()
-    }
+    const surface_viewer_ids = await dataStore.getMeshComponentsViewerIds(
+      id,
+      surface_ids,
+    )
     return viewerStore.request(
       model_surfaces_schemas.visibility,
-      { id, block_ids: surface_flat_indexes, visibility },
+      { id, block_ids: surface_viewer_ids, visibility },
       {
         response_function: () => {
           for (const surface_id of surface_ids) {
@@ -61,13 +61,13 @@ export function useModelSurfacesStyle() {
   }
 
   async function setModelSurfacesColor(id, surface_ids, color) {
-    const surface_flat_indexes = await dataStore.getFlatIndexes(id, surface_ids)
-    if (surface_flat_indexes.length === 0) {
-      return Promise.resolve()
-    }
+    const surface_viewer_ids = await dataStore.getMeshComponentsViewerIds(
+      id,
+      surface_ids,
+    )
     return viewerStore.request(
       model_surfaces_schemas.color,
-      { id, block_ids: surface_flat_indexes, color },
+      { id, block_ids: surface_viewer_ids, color },
       {
         response_function: () => {
           for (const surface_id of surface_ids) {
@@ -86,7 +86,7 @@ export function useModelSurfacesStyle() {
 
   async function applyModelSurfacesStyle(id) {
     const style = modelSurfacesStyle(id)
-    const surface_ids = await dataStore.getSurfacesUuids(id)
+    const surface_ids = await dataStore.getSurfacesGeodeIds(id)
     return Promise.all([
       setModelSurfacesVisibility(id, surface_ids, style.visibility),
       setModelSurfacesColor(id, surface_ids, style.color),
diff --git a/internal/utils/api_fetch.js b/internal/utils/api_fetch.js
index caa4ba53..c9f43c8d 100644
--- a/internal/utils/api_fetch.js
+++ b/internal/utils/api_fetch.js
@@ -34,39 +34,39 @@ export function api_fetch(
   if (schema.max_retry) {
     request_options.max_retry = schema.max_retry
   }
-  return useFetch(schema.$id, {
+  return $fetch(schema.$id, {
     baseURL: microservice.base_url,
     ...request_options,
-    async onRequestError({ error }) {
-      await microservice.stop_request()
-      await feedbackStore.add_error(
+    onRequestError({ error }) {
+      microservice.stop_request()
+      feedbackStore.add_error(
         error.code,
         schema.$id,
         error.message,
         error.stack,
       )
       if (request_error_function) {
-        await request_error_function(error)
+        request_error_function(error)
       }
     },
-    async onResponse({ response }) {
+    onResponse({ response }) {
       if (response.ok) {
-        await microservice.stop_request()
+        microservice.stop_request()
         if (response_function) {
-          await response_function(response)
+          response_function(response._data)
         }
       }
     },
-    async onResponseError({ response }) {
-      await microservice.stop_request()
-      await feedbackStore.add_error(
+    onResponseError({ response }) {
+      microservice.stop_request()
+      feedbackStore.add_error(
         response.status,
         schema.$id,
-        response._data.name,
-        response._data.description,
+        response.name,
+        response.description,
       )
       if (response_error_function) {
-        await response_error_function(response)
+        response_error_function(response)
       }
     },
   })
diff --git a/package.json b/package.json
index dc5cf654..01bd5c53 100644
--- a/package.json
+++ b/package.json
@@ -24,7 +24,7 @@
     "@vueuse/nuxt": "13.1.0",
     "@vueuse/rxjs": "^14.1.0",
     "ajv": "8.17.1",
-    "dexie": "3.2.4",
+    "dexie": "4.2.1",
     "get-port-please": "3.2.0",
     "is-electron": "2.2.2",
     "js-file-download": "0.4.12",
diff --git a/tests/integration/microservices/back/requirements.txt b/tests/integration/microservices/back/requirements.txt
index 46c3cb58..bd3a3ef5 100644
--- a/tests/integration/microservices/back/requirements.txt
+++ b/tests/integration/microservices/back/requirements.txt
@@ -5,4 +5,3 @@
 #    pip-compile --output-file=tests/integration/microservices/back/requirements.txt tests/integration/microservices/back/requirements.in
 #
 
-opengeodeweb-back==5.*,>=5.15.0
diff --git a/tests/integration/microservices/viewer/requirements.txt b/tests/integration/microservices/viewer/requirements.txt
index 8293def3..4d097394 100644
--- a/tests/integration/microservices/viewer/requirements.txt
+++ b/tests/integration/microservices/viewer/requirements.txt
@@ -5,4 +5,3 @@
 #    pip-compile --output-file=tests/integration/microservices/viewer/requirements.txt tests/integration/microservices/viewer/requirements.in
 #
 
-opengeodeweb-viewer==1.*,>=1.14.0
diff --git a/tests/integration/stores/data_style/model/blocks.nuxt.test.js b/tests/integration/stores/data_style/model/blocks.nuxt.test.js
index 547f307c..965a47ab 100644
--- a/tests/integration/stores/data_style/model/blocks.nuxt.test.js
+++ b/tests/integration/stores/data_style/model/blocks.nuxt.test.js
@@ -43,15 +43,18 @@ describe("Model blocks", () => {
       const dataStyleStore = useDataStyleStore()
       const viewerStore = useViewerStore()
       const dataStore = useDataStore()
-      const block_ids = await dataStore.getBlocksUuids(id)
-      const block_flat_indexes = await dataStore.getFlatIndexes(id, block_ids)
+      const block_ids = await dataStore.getBlocksGeodeIds(id)
+      const block_viewer_ids = await dataStore.getMeshComponentsViewerIds(
+        id,
+        block_ids,
+      )
       const visibility = false
       const spy = vi.spyOn(viewerStore, "request")
       spy.mockClear()
       await dataStyleStore.setModelBlocksVisibility(id, block_ids, visibility)
       expect(spy).toHaveBeenCalledWith(
         model_blocks_schemas.visibility,
-        { id, block_ids: block_flat_indexes, visibility },
+        { id, block_ids: block_viewer_ids, visibility },
         {
           response_function: expect.any(Function),
         },
@@ -70,14 +73,14 @@ describe("Model blocks", () => {
   //     const dataStyleStore = useDataStyleStore()
   //     const viewerStore = useViewerStore()
   //     const dataStore = useDataStore()
-  //     const block_ids = await dataStore.getBlocksUuids(id)
-  //     const block_flat_indexes = dataStore.getFlatIndexes(id, block_ids)
+  //     const block_ids = await dataStore.getBlocksGeodeIds(id)
+  //     const block_viewer_ids = dataStore.getMeshComponentsViewerIds(id, block_ids)
   //     const color = { r: 255, g: 0, b: 0 }
   //     const spy = vi.spyOn(viewerStore, "request")
   //     await dataStyleStore.setModelBlocksColor(id, block_ids, color)
   //     expect(spy).toHaveBeenCalledWith(
   //       model_blocks_schemas.color,
-  //       { id, block_ids: block_flat_indexes, color },
+  //       { id, block_ids: block_viewer_ids, color },
   //       {
   //         response_function: expect.any(Function),
   //       },
diff --git a/tests/integration/stores/data_style/model/corners.nuxt.test.js b/tests/integration/stores/data_style/model/corners.nuxt.test.js
index 112454ba..edb97840 100644
--- a/tests/integration/stores/data_style/model/corners.nuxt.test.js
+++ b/tests/integration/stores/data_style/model/corners.nuxt.test.js
@@ -43,15 +43,18 @@ describe("Model corners", () => {
       const dataStyleStore = useDataStyleStore()
       const viewerStore = useViewerStore()
       const dataStore = useDataStore()
-      const corner_ids = await dataStore.getCornersUuids(id)
-      const corner_flat_indexes = await dataStore.getFlatIndexes(id, corner_ids)
+      const corner_ids = await dataStore.getCornersGeodeIds(id)
+      const corner_viewer_ids = await dataStore.getMeshComponentsViewerIds(
+        id,
+        corner_ids,
+      )
       const visibility = false
       const spy = vi.spyOn(viewerStore, "request")
       spy.mockClear()
       await dataStyleStore.setModelCornersVisibility(id, corner_ids, visibility)
       expect(spy).toHaveBeenCalledWith(
         model_corners_schemas.visibility,
-        { id, block_ids: corner_flat_indexes, visibility },
+        { id, block_ids: corner_viewer_ids, visibility },
         {
           response_function: expect.any(Function),
         },
@@ -70,15 +73,18 @@ describe("Model corners", () => {
       const dataStyleStore = useDataStyleStore()
       const viewerStore = useViewerStore()
       const dataStore = useDataStore()
-      const corner_ids = await dataStore.getCornersUuids(id)
-      const corner_flat_indexes = await dataStore.getFlatIndexes(id, corner_ids)
+      const corner_ids = await dataStore.getCornersGeodeIds(id)
+      const corner_viewer_ids = await dataStore.getMeshComponentsViewerIds(
+        id,
+        corner_ids,
+      )
       const color = { r: 255, g: 0, b: 0 }
       const spy = vi.spyOn(viewerStore, "request")
       spy.mockClear()
       await dataStyleStore.setModelCornersColor(id, corner_ids, color)
       expect(spy).toHaveBeenCalledWith(
         model_corners_schemas.color,
-        { id, block_ids: corner_flat_indexes, color },
+        { id, block_ids: corner_viewer_ids, color },
         {
           response_function: expect.any(Function),
         },
diff --git a/tests/integration/stores/data_style/model/lines.nuxt.test.js b/tests/integration/stores/data_style/model/lines.nuxt.test.js
index e7cbc465..346d0235 100644
--- a/tests/integration/stores/data_style/model/lines.nuxt.test.js
+++ b/tests/integration/stores/data_style/model/lines.nuxt.test.js
@@ -39,15 +39,18 @@ describe("Model lines", () => {
       const dataStyleStore = useDataStyleStore()
       const viewerStore = useViewerStore()
       const dataStore = useDataStore()
-      const line_ids = await dataStore.getLinesUuids(id)
-      const lines_flat_indexes = await dataStore.getFlatIndexes(id, line_ids)
+      const line_ids = await dataStore.getLinesGeodeIds(id)
+      const lines_viewer_ids = await dataStore.getMeshComponentsViewerIds(
+        id,
+        line_ids,
+      )
       const visibility = false
       const spy = vi.spyOn(viewerStore, "request")
       spy.mockClear()
       await dataStyleStore.setModelLinesVisibility(id, line_ids, visibility)
       expect(spy).toHaveBeenCalledWith(
         model_lines_schemas.visibility,
-        { id, block_ids: lines_flat_indexes, visibility },
+        { id, block_ids: lines_viewer_ids, visibility },
         {
           response_function: expect.any(Function),
         },
@@ -64,15 +67,18 @@ describe("Model lines", () => {
       const dataStyleStore = useDataStyleStore()
       const viewerStore = useViewerStore()
       const dataStore = useDataStore()
-      const line_ids = await dataStore.getLinesUuids(id)
-      const lines_flat_indexes = await dataStore.getFlatIndexes(id, line_ids)
+      const line_ids = await dataStore.getLinesGeodeIds(id)
+      const lines_viewer_ids = await dataStore.getMeshComponentsViewerIds(
+        id,
+        line_ids,
+      )
       const color = { r: 255, g: 0, b: 0 }
       const spy = vi.spyOn(viewerStore, "request")
       spy.mockClear()
       await dataStyleStore.setModelLinesColor(id, line_ids, color)
       expect(spy).toHaveBeenCalledWith(
         model_lines_schemas.color,
-        { id, block_ids: lines_flat_indexes, color },
+        { id, block_ids: lines_viewer_ids, color },
         {
           response_function: expect.any(Function),
         },
diff --git a/tests/integration/stores/data_style/model/surfaces.nuxt.test.js b/tests/integration/stores/data_style/model/surfaces.nuxt.test.js
index c45afcf8..f1effe97 100644
--- a/tests/integration/stores/data_style/model/surfaces.nuxt.test.js
+++ b/tests/integration/stores/data_style/model/surfaces.nuxt.test.js
@@ -43,8 +43,8 @@ describe("Model surfaces", () => {
       const dataStyleStore = useDataStyleStore()
       const viewerStore = useViewerStore()
       const dataStore = useDataStore()
-      const surface_ids = await dataStore.getSurfacesUuids(id)
-      const surface_flat_indexes = await dataStore.getFlatIndexes(
+      const surface_ids = await dataStore.getSurfacesGeodeIds(id)
+      const surface_viewer_ids = await dataStore.getMeshComponentsViewerIds(
         id,
         surface_ids,
       )
@@ -58,7 +58,7 @@ describe("Model surfaces", () => {
       )
       expect(spy).toHaveBeenCalledWith(
         model_surfaces_schemas.visibility,
-        { id, block_ids: surface_flat_indexes, visibility },
+        { id, block_ids: surface_viewer_ids, visibility },
         {
           response_function: expect.any(Function),
         },
@@ -77,8 +77,8 @@ describe("Model surfaces", () => {
       const dataStyleStore = useDataStyleStore()
       const viewerStore = useViewerStore()
       const dataStore = useDataStore()
-      const surface_ids = await dataStore.getSurfacesUuids(id)
-      const surface_flat_indexes = await dataStore.getFlatIndexes(
+      const surface_ids = await dataStore.getSurfacesGeodeIds(id)
+      const surface_viewer_ids = await dataStore.getMeshComponentsViewerIds(
         id,
         surface_ids,
       )
@@ -88,7 +88,7 @@ describe("Model surfaces", () => {
       await dataStyleStore.setModelSurfacesColor(id, surface_ids, color)
       expect(spy).toHaveBeenCalledWith(
         model_surfaces_schemas.color,
-        { id, block_ids: surface_flat_indexes, color },
+        { id, block_ids: surface_viewer_ids, color },
         {
           response_function: expect.any(Function),
         },
diff --git a/tests/unit/components/CrsSelector.nuxt.test.js b/tests/unit/components/CrsSelector.nuxt.test.js
index 7e665c33..2abec900 100644
--- a/tests/unit/components/CrsSelector.nuxt.test.js
+++ b/tests/unit/components/CrsSelector.nuxt.test.js
@@ -33,9 +33,9 @@ describe("CrsSelector", () => {
     // Mock geodeStore.request instead of registerEndpoint
     geodeStore.request = vi.fn((schema, params, callbacks) => {
       if (callbacks?.response_function) {
-        callbacks.response_function({ _data: { crs_list } })
+        callbacks.response_function({ crs_list })
       }
-      return Promise.resolve({ _data: { crs_list } })
+      return Promise.resolve({ crs_list })
     })
 
     const key_to_update = "key"
diff --git a/tests/unit/components/ExtensionSelector.nuxt.test.js b/tests/unit/components/ExtensionSelector.nuxt.test.js
index 702dec5b..0b47caa0 100644
--- a/tests/unit/components/ExtensionSelector.nuxt.test.js
+++ b/tests/unit/components/ExtensionSelector.nuxt.test.js
@@ -23,10 +23,8 @@ describe("ExtensionSelector", async () => {
   // Mock the request method to simulate API call
   geodeStore.request = vi.fn((schema, params, callbacks) => {
     const response = {
-      _data: {
-        geode_objects_and_output_extensions: {
-          BRep: { msh: { is_saveable: true } },
-        },
+      geode_objects_and_output_extensions: {
+        BRep: { msh: { is_saveable: true } },
       },
     }
     if (callbacks?.response_function) {
diff --git a/tests/unit/components/Inspector/InspectionButton.nuxt.test.js b/tests/unit/components/Inspector/InspectionButton.nuxt.test.js
index 7150517d..1a9fff74 100644
--- a/tests/unit/components/Inspector/InspectionButton.nuxt.test.js
+++ b/tests/unit/components/Inspector/InspectionButton.nuxt.test.js
@@ -42,11 +42,11 @@ describe("Inspector/InspectionButton", async () => {
     geodeStore.request = vi.fn((schema, params, callbacks) => {
       if (callbacks?.response_function) {
         callbacks.response_function({
-          _data: { inspection_result },
+          inspection_result,
         })
       }
       return Promise.resolve({
-        _data: { inspection_result },
+        inspection_result,
       })
     })
 
diff --git a/tests/unit/components/MissingFilesSelector.nuxt.test.js b/tests/unit/components/MissingFilesSelector.nuxt.test.js
index 37cc5700..9859c6c0 100644
--- a/tests/unit/components/MissingFilesSelector.nuxt.test.js
+++ b/tests/unit/components/MissingFilesSelector.nuxt.test.js
@@ -29,19 +29,15 @@ describe("MissingFilesSelector", async () => {
     geodeStore.request = vi.fn((schema, params, callbacks) => {
       if (callbacks?.response_function) {
         callbacks.response_function({
-          _data: {
-            has_missing_files: true,
-            mandatory_files: ["fake_file.txt"],
-            additional_files: ["fake_file_2.txt"],
-          },
-        })
-      }
-      return Promise.resolve({
-        _data: {
           has_missing_files: true,
           mandatory_files: ["fake_file.txt"],
           additional_files: ["fake_file_2.txt"],
-        },
+        })
+      }
+      return Promise.resolve({
+        has_missing_files: true,
+        mandatory_files: ["fake_file.txt"],
+        additional_files: ["fake_file_2.txt"],
       })
     })
 
diff --git a/tests/unit/stores/Geode.nuxt.test.js b/tests/unit/stores/Geode.nuxt.test.js
index 0735151a..d0053be9 100644
--- a/tests/unit/stores/Geode.nuxt.test.js
+++ b/tests/unit/stores/Geode.nuxt.test.js
@@ -120,7 +120,7 @@ describe("Geode store", () => {
   })
 
   describe("actions", () => {
-    describe("do_ping", () => {
+    describe("ping", () => {
       const getFakeCall = vi.fn()
       registerEndpoint(back_schemas.opengeodeweb_back.ping.$id, getFakeCall)
 
@@ -128,7 +128,7 @@ describe("Geode store", () => {
         const geodeStore = useGeodeStore()
         geodeStore.base_url = ""
         getFakeCall.mockImplementation(() => ({}))
-        await geodeStore.do_ping()
+        await geodeStore.ping()
         expect(geodeStore.status).toBe(Status.CONNECTED)
       })
       test("response_error", async () => {
@@ -139,8 +139,7 @@ describe("Geode store", () => {
             status: 500,
           })
         })
-
-        await geodeStore.do_ping()
+        await expect(geodeStore.ping()).rejects.toThrow()
         expect(geodeStore.status).toBe(Status.NOT_CONNECTED)
       })
     })