diff --git a/CHANGELOG.md b/CHANGELOG.md
index d9ed1703e..6d9c9d58f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,6 +10,7 @@
       - CHANGED: Pass osm_node_ids by reference in osrm::updater::Updater class. [#6298](https://github.com/Project-OSRM/osrm-backend/pull/6298)
       - FIXED: Fix bug with reading Set values from Lua scripts. [#6285](https://github.com/Project-OSRM/osrm-backend/pull/6285)
       - FIXED: Bug in bicycle profile that caused exceptions if there is a highway=bicycle in the data. [#6296](https://github.com/Project-OSRM/osrm-backend/pull/6296)
+      - FIXED: Internal refactoring of identifier types used in data facade [#6044](https://github.com/Project-OSRM/osrm-backend/pull/6044)
     - Build:
       - CHANGED: Use the latest node on CI. [#6317](https://github.com/Project-OSRM/osrm-backend/pull/6317)
       - CHANGED: Migrate Windows CI to GitHub Actions. [#6312](https://github.com/Project-OSRM/osrm-backend/pull/6312)
diff --git a/include/engine/datafacade/algorithm_datafacade.hpp b/include/engine/datafacade/algorithm_datafacade.hpp
index 38030511c..4ccbf5af3 100644
--- a/include/engine/datafacade/algorithm_datafacade.hpp
+++ b/include/engine/datafacade/algorithm_datafacade.hpp
@@ -36,24 +36,27 @@ template <> class AlgorithmDataFacade<CH>
 
     virtual unsigned GetNumberOfEdges() const = 0;
 
-    virtual unsigned GetOutDegree(const NodeID n) const = 0;
+    virtual unsigned GetOutDegree(const NodeID edge_based_node_id) const = 0;
 
-    virtual NodeID GetTarget(const EdgeID e) const = 0;
+    virtual NodeID GetTarget(const EdgeID edge_based_edge_id) const = 0;
 
-    virtual const EdgeData &GetEdgeData(const EdgeID e) const = 0;
+    virtual const EdgeData &GetEdgeData(const EdgeID edge_based_edge_id) const = 0;
 
-    virtual EdgeRange GetAdjacentEdgeRange(const NodeID node) const = 0;
+    virtual EdgeRange GetAdjacentEdgeRange(const NodeID edge_based_node_id) const = 0;
 
     // searches for a specific edge
-    virtual EdgeID FindEdge(const NodeID from, const NodeID to) const = 0;
+    virtual EdgeID FindEdge(const NodeID edge_based_node_from,
+                            const NodeID edge_based_node_to) const = 0;
 
-    virtual EdgeID FindEdgeInEitherDirection(const NodeID from, const NodeID to) const = 0;
+    virtual EdgeID FindEdgeInEitherDirection(const NodeID edge_based_node_from,
+                                             const NodeID edge_based_node_to) const = 0;
 
-    virtual EdgeID
-    FindEdgeIndicateIfReverse(const NodeID from, const NodeID to, bool &result) const = 0;
+    virtual EdgeID FindEdgeIndicateIfReverse(const NodeID edge_based_node_from,
+                                             const NodeID edge_based_node_to,
+                                             bool &result) const = 0;
 
-    virtual EdgeID FindSmallestEdge(const NodeID from,
-                                    const NodeID to,
+    virtual EdgeID FindSmallestEdge(const NodeID edge_based_node_from,
+                                    const NodeID edge_based_node_to,
                                     const std::function<bool(EdgeData)> filter) const = 0;
 };
 
@@ -70,23 +73,24 @@ template <> class AlgorithmDataFacade<MLD>
 
     virtual unsigned GetNumberOfEdges() const = 0;
 
-    virtual unsigned GetOutDegree(const NodeID n) const = 0;
+    virtual unsigned GetOutDegree(const NodeID edge_based_node_id) const = 0;
 
-    virtual EdgeRange GetAdjacentEdgeRange(const NodeID node) const = 0;
+    virtual EdgeRange GetAdjacentEdgeRange(const NodeID edge_based_node_id) const = 0;
 
-    virtual EdgeWeight GetNodeWeight(const NodeID node) const = 0;
+    virtual EdgeWeight GetNodeWeight(const NodeID edge_based_node_id) const = 0;
 
-    virtual EdgeWeight GetNodeDuration(const NodeID node) const = 0; // TODO: to be removed
+    virtual EdgeWeight
+    GetNodeDuration(const NodeID edge_based_node_id) const = 0; // TODO: to be removed
 
-    virtual EdgeDistance GetNodeDistance(const NodeID node) const = 0;
+    virtual EdgeDistance GetNodeDistance(const NodeID edge_based_node_id) const = 0;
 
-    virtual bool IsForwardEdge(EdgeID edge) const = 0;
+    virtual bool IsForwardEdge(EdgeID edge_based_edge_id) const = 0;
 
-    virtual bool IsBackwardEdge(EdgeID edge) const = 0;
+    virtual bool IsBackwardEdge(EdgeID edge_based_edge_id) const = 0;
 
-    virtual NodeID GetTarget(const EdgeID e) const = 0;
+    virtual NodeID GetTarget(const EdgeID edge_based_edge_id) const = 0;
 
-    virtual const EdgeData &GetEdgeData(const EdgeID e) const = 0;
+    virtual const EdgeData &GetEdgeData(const EdgeID edge_based_edge_id) const = 0;
 
     virtual const partitioner::MultiLevelPartitionView &GetMultiLevelPartition() const = 0;
 
@@ -94,10 +98,12 @@ template <> class AlgorithmDataFacade<MLD>
 
     virtual const customizer::CellMetricView &GetCellMetric() const = 0;
 
-    virtual EdgeRange GetBorderEdgeRange(const LevelID level, const NodeID node) const = 0;
+    virtual EdgeRange GetBorderEdgeRange(const LevelID level,
+                                         const NodeID edge_based_node_id) const = 0;
 
     // searches for a specific edge
-    virtual EdgeID FindEdge(const NodeID from, const NodeID to) const = 0;
+    virtual EdgeID FindEdge(const NodeID edge_based_node_from,
+                            const NodeID edge_based_node_to) const = 0;
 };
 } // namespace datafacade
 } // namespace engine
diff --git a/include/engine/datafacade/contiguous_internalmem_datafacade.hpp b/include/engine/datafacade/contiguous_internalmem_datafacade.hpp
index e448a8f57..d426ed84f 100644
--- a/include/engine/datafacade/contiguous_internalmem_datafacade.hpp
+++ b/include/engine/datafacade/contiguous_internalmem_datafacade.hpp
@@ -73,45 +73,52 @@ class ContiguousInternalMemoryAlgorithmDataFacade<CH> : public datafacade::Algor
 
     unsigned GetNumberOfEdges() const override final { return m_query_graph.GetNumberOfEdges(); }
 
-    unsigned GetOutDegree(const NodeID n) const override final
+    unsigned GetOutDegree(const NodeID edge_based_node_id) const override final
     {
-        return m_query_graph.GetOutDegree(n);
+        return m_query_graph.GetOutDegree(edge_based_node_id);
     }
 
-    NodeID GetTarget(const EdgeID e) const override final { return m_query_graph.GetTarget(e); }
-
-    const EdgeData &GetEdgeData(const EdgeID e) const override final
+    NodeID GetTarget(const EdgeID edge_based_edge_id) const override final
     {
-        return m_query_graph.GetEdgeData(e);
+        return m_query_graph.GetTarget(edge_based_edge_id);
     }
 
-    EdgeRange GetAdjacentEdgeRange(const NodeID node) const override final
+    const EdgeData &GetEdgeData(const EdgeID edge_based_edge_id) const override final
     {
-        return m_query_graph.GetAdjacentEdgeRange(node);
+        return m_query_graph.GetEdgeData(edge_based_edge_id);
+    }
+
+    EdgeRange GetAdjacentEdgeRange(const NodeID edge_based_node_id) const override final
+    {
+        return m_query_graph.GetAdjacentEdgeRange(edge_based_node_id);
     }
 
     // searches for a specific edge
-    EdgeID FindEdge(const NodeID from, const NodeID to) const override final
+    EdgeID FindEdge(const NodeID edge_based_node_from,
+                    const NodeID edge_based_node_to) const override final
     {
-        return m_query_graph.FindEdge(from, to);
+        return m_query_graph.FindEdge(edge_based_node_from, edge_based_node_to);
     }
 
-    EdgeID FindEdgeInEitherDirection(const NodeID from, const NodeID to) const override final
+    EdgeID FindEdgeInEitherDirection(const NodeID edge_based_node_from,
+                                     const NodeID edge_based_node_to) const override final
     {
-        return m_query_graph.FindEdgeInEitherDirection(from, to);
+        return m_query_graph.FindEdgeInEitherDirection(edge_based_node_from, edge_based_node_to);
     }
 
-    EdgeID
-    FindEdgeIndicateIfReverse(const NodeID from, const NodeID to, bool &result) const override final
+    EdgeID FindEdgeIndicateIfReverse(const NodeID edge_based_node_from,
+                                     const NodeID edge_based_node_to,
+                                     bool &result) const override final
     {
-        return m_query_graph.FindEdgeIndicateIfReverse(from, to, result);
+        return m_query_graph.FindEdgeIndicateIfReverse(
+            edge_based_node_from, edge_based_node_to, result);
     }
 
-    EdgeID FindSmallestEdge(const NodeID from,
-                            const NodeID to,
+    EdgeID FindSmallestEdge(const NodeID edge_based_node_from,
+                            const NodeID edge_based_node_to,
                             std::function<bool(EdgeData)> filter) const override final
     {
-        return m_query_graph.FindSmallestEdge(from, to, filter);
+        return m_query_graph.FindSmallestEdge(edge_based_node_from, edge_based_node_to, filter);
     }
 };
 
@@ -126,11 +133,9 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
 {
   private:
     using super = BaseDataFacade;
-    using IndexBlock = util::RangeTable<16, storage::Ownership::View>::BlockT;
     using RTreeLeaf = super::RTreeLeaf;
     using SharedRTree = util::StaticRTree<RTreeLeaf, storage::Ownership::View>;
     using SharedGeospatialQuery = GeospatialQuery<SharedRTree, BaseDataFacade>;
-    using RTreeNode = SharedRTree::TreeNode;
 
     extractor::ClassData exclude_mask;
     extractor::ProfileProperties *m_profile_properties;
@@ -231,76 +236,80 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
     }
 
     // node and edge information access
-    util::Coordinate GetCoordinateOfNode(const NodeID id) const override final
+    util::Coordinate GetCoordinateOfNode(const NodeID node_based_node_id) const override final
     {
-        return m_coordinate_list[id];
+        return m_coordinate_list[node_based_node_id];
     }
 
-    OSMNodeID GetOSMNodeIDOfNode(const NodeID id) const override final
+    OSMNodeID GetOSMNodeIDOfNode(const NodeID node_based_node_id) const override final
     {
-        return m_osmnodeid_list[id];
+        return m_osmnodeid_list[node_based_node_id];
     }
 
-    NodeForwardRange GetUncompressedForwardGeometry(const EdgeID id) const override final
+    NodeForwardRange GetUncompressedForwardGeometry(const PackedGeometryID id) const override final
     {
         return segment_data.GetForwardGeometry(id);
     }
 
-    NodeReverseRange GetUncompressedReverseGeometry(const EdgeID id) const override final
+    NodeReverseRange GetUncompressedReverseGeometry(const PackedGeometryID id) const override final
     {
         return segment_data.GetReverseGeometry(id);
     }
 
-    DurationForwardRange GetUncompressedForwardDurations(const EdgeID id) const override final
+    DurationForwardRange
+    GetUncompressedForwardDurations(const PackedGeometryID id) const override final
     {
         return segment_data.GetForwardDurations(id);
     }
 
-    DurationReverseRange GetUncompressedReverseDurations(const EdgeID id) const override final
+    DurationReverseRange
+    GetUncompressedReverseDurations(const PackedGeometryID id) const override final
     {
         return segment_data.GetReverseDurations(id);
     }
 
-    WeightForwardRange GetUncompressedForwardWeights(const EdgeID id) const override final
+    WeightForwardRange GetUncompressedForwardWeights(const PackedGeometryID id) const override final
     {
         return segment_data.GetForwardWeights(id);
     }
 
-    WeightReverseRange GetUncompressedReverseWeights(const EdgeID id) const override final
+    WeightReverseRange GetUncompressedReverseWeights(const PackedGeometryID id) const override final
     {
         return segment_data.GetReverseWeights(id);
     }
 
     // Returns the data source ids that were used to supply the edge
     // weights.
-    DatasourceForwardRange GetUncompressedForwardDatasources(const EdgeID id) const override final
+    DatasourceForwardRange
+    GetUncompressedForwardDatasources(const PackedGeometryID id) const override final
     {
         return segment_data.GetForwardDatasources(id);
     }
 
     // Returns the data source ids that were used to supply the edge
     // weights.
-    DatasourceReverseRange GetUncompressedReverseDatasources(const EdgeID id) const override final
+    DatasourceReverseRange
+    GetUncompressedReverseDatasources(const PackedGeometryID id) const override final
     {
         return segment_data.GetReverseDatasources(id);
     }
 
-    TurnPenalty GetWeightPenaltyForEdgeID(const EdgeID id) const override final
+    TurnPenalty GetWeightPenaltyForEdgeID(const EdgeID edge_based_edge_id) const override final
     {
-        BOOST_ASSERT(m_turn_weight_penalties.size() > id);
-        return m_turn_weight_penalties[id];
+        BOOST_ASSERT(m_turn_weight_penalties.size() > edge_based_edge_id);
+        return m_turn_weight_penalties[edge_based_edge_id];
     }
 
-    TurnPenalty GetDurationPenaltyForEdgeID(const EdgeID id) const override final
+    TurnPenalty GetDurationPenaltyForEdgeID(const EdgeID edge_based_edge_id) const override final
     {
-        BOOST_ASSERT(m_turn_duration_penalties.size() > id);
-        return m_turn_duration_penalties[id];
+        BOOST_ASSERT(m_turn_duration_penalties.size() > edge_based_edge_id);
+        return m_turn_duration_penalties[edge_based_edge_id];
     }
 
     osrm::guidance::TurnInstruction
-    GetTurnInstructionForEdgeID(const EdgeID id) const override final
+    GetTurnInstructionForEdgeID(const EdgeID edge_based_edge_id) const override final
     {
-        return turn_data.GetTurnInstruction(id);
+        return turn_data.GetTurnInstruction(edge_based_edge_id);
     }
 
     std::vector<RTreeLeaf> GetEdgesInBox(const util::Coordinate south_west,
@@ -444,29 +453,29 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
         return std::string(m_data_timestamp.begin(), m_data_timestamp.end());
     }
 
-    GeometryID GetGeometryIndex(const NodeID id) const override final
+    GeometryID GetGeometryIndex(const NodeID edge_based_node_id) const override final
     {
-        return edge_based_node_data.GetGeometryID(id);
+        return edge_based_node_data.GetGeometryID(edge_based_node_id);
     }
 
-    ComponentID GetComponentID(const NodeID id) const override final
+    ComponentID GetComponentID(const NodeID edge_based_node_id) const override final
     {
-        return edge_based_node_data.GetComponentID(id);
+        return edge_based_node_data.GetComponentID(edge_based_node_id);
     }
 
-    extractor::TravelMode GetTravelMode(const NodeID id) const override final
+    extractor::TravelMode GetTravelMode(const NodeID edge_based_node_id) const override final
     {
-        return edge_based_node_data.GetTravelMode(id);
+        return edge_based_node_data.GetTravelMode(edge_based_node_id);
     }
 
-    extractor::ClassData GetClassData(const NodeID id) const override final
+    extractor::ClassData GetClassData(const NodeID edge_based_node_id) const override final
     {
-        return edge_based_node_data.GetClassData(id);
+        return edge_based_node_data.GetClassData(edge_based_node_id);
     }
 
-    bool ExcludeNode(const NodeID id) const override final
+    bool ExcludeNode(const NodeID edge_based_node_id) const override final
     {
-        return (edge_based_node_data.GetClassData(id) & exclude_mask) > 0;
+        return (edge_based_node_data.GetClassData(edge_based_node_id) & exclude_mask) > 0;
     }
 
     std::vector<std::string> GetClasses(const extractor::ClassData class_data) const override final
@@ -480,9 +489,9 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
         return classes;
     }
 
-    NameID GetNameIndex(const NodeID id) const override final
+    NameID GetNameIndex(const NodeID edge_based_node_id) const override final
     {
-        return edge_based_node_data.GetNameID(id);
+        return edge_based_node_data.GetNameID(edge_based_node_id);
     }
 
     StringView GetNameForID(const NameID id) const override final
@@ -537,32 +546,37 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
         return m_profile_properties->GetWeightMultiplier();
     }
 
-    util::guidance::BearingClass GetBearingClass(const NodeID node) const override final
+    util::guidance::BearingClass
+    GetBearingClass(const NodeID node_based_node_id) const override final
     {
-        return intersection_bearings_view.GetBearingClass(node);
+        return intersection_bearings_view.GetBearingClass(node_based_node_id);
     }
 
-    guidance::TurnBearing PreTurnBearing(const EdgeID eid) const override final
+    guidance::TurnBearing PreTurnBearing(const EdgeID edge_based_edge_id) const override final
     {
-        return turn_data.GetPreTurnBearing(eid);
+        return turn_data.GetPreTurnBearing(edge_based_edge_id);
     }
-    guidance::TurnBearing PostTurnBearing(const EdgeID eid) const override final
+    guidance::TurnBearing PostTurnBearing(const EdgeID edge_based_edge_id) const override final
     {
-        return turn_data.GetPostTurnBearing(eid);
+        return turn_data.GetPostTurnBearing(edge_based_edge_id);
     }
 
-    util::guidance::EntryClass GetEntryClass(const EdgeID turn_id) const override final
+    util::guidance::EntryClass GetEntryClass(const EdgeID edge_based_edge_id) const override final
     {
-        auto entry_class_id = turn_data.GetEntryClassID(turn_id);
+        auto entry_class_id = turn_data.GetEntryClassID(edge_based_edge_id);
         return m_entry_class_table.at(entry_class_id);
     }
 
-    bool HasLaneData(const EdgeID id) const override final { return turn_data.HasLaneData(id); }
-
-    util::guidance::LaneTupleIdPair GetLaneData(const EdgeID id) const override final
+    bool HasLaneData(const EdgeID edge_based_edge_id) const override final
     {
-        BOOST_ASSERT(HasLaneData(id));
-        return m_lane_tupel_id_pairs.at(turn_data.GetLaneDataID(id));
+        return turn_data.HasLaneData(edge_based_edge_id);
+    }
+
+    util::guidance::LaneTupleIdPair
+    GetLaneData(const EdgeID edge_based_edge_id) const override final
+    {
+        BOOST_ASSERT(HasLaneData(edge_based_edge_id));
+        return m_lane_tupel_id_pairs.at(turn_data.GetLaneDataID(edge_based_edge_id));
     }
 
     extractor::TurnLaneDescription
@@ -577,15 +591,15 @@ class ContiguousInternalMemoryDataFacadeBase : public BaseDataFacade
                     m_lane_description_offsets[lane_description_id + 1]);
     }
 
-    bool IsLeftHandDriving(const NodeID id) const override final
+    bool IsLeftHandDriving(const NodeID edge_based_node_id) const override final
     {
         // TODO: can be moved to a data block indexed by GeometryID
-        return edge_based_node_data.IsLeftHandDriving(id);
+        return edge_based_node_data.IsLeftHandDriving(edge_based_node_id);
     }
 
-    bool IsSegregated(const NodeID id) const override final
+    bool IsSegregated(const NodeID edge_based_node_id) const override final
     {
-        return edge_based_node_data.IsSegregated(id);
+        return edge_based_node_data.IsSegregated(edge_based_node_id);
     }
 
     std::vector<extractor::ManeuverOverride>
@@ -691,57 +705,62 @@ template <> class ContiguousInternalMemoryAlgorithmDataFacade<MLD> : public Algo
 
     unsigned GetNumberOfEdges() const override final { return query_graph.GetNumberOfEdges(); }
 
-    unsigned GetOutDegree(const NodeID n) const override final
+    unsigned GetOutDegree(const NodeID edge_based_node_id) const override final
     {
-        return query_graph.GetOutDegree(n);
+        return query_graph.GetOutDegree(edge_based_node_id);
     }
 
-    EdgeRange GetAdjacentEdgeRange(const NodeID node) const override final
+    EdgeRange GetAdjacentEdgeRange(const NodeID edge_based_node_id) const override final
     {
-        return query_graph.GetAdjacentEdgeRange(node);
+        return query_graph.GetAdjacentEdgeRange(edge_based_node_id);
     }
 
-    EdgeWeight GetNodeWeight(const NodeID node) const override final
+    EdgeWeight GetNodeWeight(const NodeID edge_based_node_id) const override final
     {
-        return query_graph.GetNodeWeight(node);
+        return query_graph.GetNodeWeight(edge_based_node_id);
     }
 
-    EdgeDuration GetNodeDuration(const NodeID node) const override final
+    EdgeDuration GetNodeDuration(const NodeID edge_based_node_id) const override final
     {
-        return query_graph.GetNodeDuration(node);
+        return query_graph.GetNodeDuration(edge_based_node_id);
     }
 
-    EdgeDistance GetNodeDistance(const NodeID node) const override final
+    EdgeDistance GetNodeDistance(const NodeID edge_based_node_id) const override final
     {
-        return query_graph.GetNodeDistance(node);
+        return query_graph.GetNodeDistance(edge_based_node_id);
     }
 
-    bool IsForwardEdge(const NodeID node) const override final
+    bool IsForwardEdge(const NodeID edge_based_node_id) const override final
     {
-        return query_graph.IsForwardEdge(node);
+        return query_graph.IsForwardEdge(edge_based_node_id);
     }
 
-    bool IsBackwardEdge(const NodeID node) const override final
+    bool IsBackwardEdge(const NodeID edge_based_node_id) const override final
     {
-        return query_graph.IsBackwardEdge(node);
+        return query_graph.IsBackwardEdge(edge_based_node_id);
     }
 
-    NodeID GetTarget(const EdgeID e) const override final { return query_graph.GetTarget(e); }
-
-    const EdgeData &GetEdgeData(const EdgeID e) const override final
+    NodeID GetTarget(const EdgeID edge_based_edge_id) const override final
     {
-        return query_graph.GetEdgeData(e);
+        return query_graph.GetTarget(edge_based_edge_id);
     }
 
-    EdgeRange GetBorderEdgeRange(const LevelID level, const NodeID node) const override final
+    const EdgeData &GetEdgeData(const EdgeID edge_based_edge_id) const override final
     {
-        return query_graph.GetBorderEdgeRange(level, node);
+        return query_graph.GetEdgeData(edge_based_edge_id);
+    }
+
+    EdgeRange GetBorderEdgeRange(const LevelID level,
+                                 const NodeID edge_based_node_id) const override final
+    {
+        return query_graph.GetBorderEdgeRange(level, edge_based_node_id);
     }
 
     // searches for a specific edge
-    EdgeID FindEdge(const NodeID from, const NodeID to) const override final
+    EdgeID FindEdge(const NodeID edge_based_node_from,
+                    const NodeID edge_based_node_to) const override final
     {
-        return query_graph.FindEdge(from, to);
+        return query_graph.FindEdge(edge_based_node_from, edge_based_node_to);
     }
 };
 
diff --git a/include/engine/datafacade/datafacade_base.hpp b/include/engine/datafacade/datafacade_base.hpp
index b80c93b18..153810fdd 100644
--- a/include/engine/datafacade/datafacade_base.hpp
+++ b/include/engine/datafacade/datafacade_base.hpp
@@ -77,46 +77,51 @@ class BaseDataFacade
     virtual std::string GetTimestamp() const = 0;
 
     // node and edge information access
-    virtual util::Coordinate GetCoordinateOfNode(const NodeID id) const = 0;
+    virtual util::Coordinate GetCoordinateOfNode(const NodeID node_based_node_id) const = 0;
 
-    virtual OSMNodeID GetOSMNodeIDOfNode(const NodeID id) const = 0;
+    virtual OSMNodeID GetOSMNodeIDOfNode(const NodeID node_based_node_id) const = 0;
 
-    virtual GeometryID GetGeometryIndex(const NodeID id) const = 0;
+    virtual GeometryID GetGeometryIndex(const NodeID edge_based_node_id) const = 0;
 
-    virtual ComponentID GetComponentID(const NodeID id) const = 0;
+    virtual ComponentID GetComponentID(const NodeID edge_based_node_id) const = 0;
 
-    virtual NodeForwardRange GetUncompressedForwardGeometry(const EdgeID id) const = 0;
-    virtual NodeReverseRange GetUncompressedReverseGeometry(const EdgeID id) const = 0;
+    virtual NodeForwardRange GetUncompressedForwardGeometry(const PackedGeometryID id) const = 0;
+    virtual NodeReverseRange GetUncompressedReverseGeometry(const PackedGeometryID id) const = 0;
 
-    virtual TurnPenalty GetWeightPenaltyForEdgeID(const EdgeID id) const = 0;
+    virtual TurnPenalty GetWeightPenaltyForEdgeID(const EdgeID edge_based_edge_id) const = 0;
 
-    virtual TurnPenalty GetDurationPenaltyForEdgeID(const EdgeID id) const = 0;
+    virtual TurnPenalty GetDurationPenaltyForEdgeID(const EdgeID edge_based_edge_id) const = 0;
 
     // Gets the weight values for each segment in an uncompressed geometry.
     // Should always be 1 shorter than GetUncompressedGeometry
-    virtual WeightForwardRange GetUncompressedForwardWeights(const EdgeID id) const = 0;
-    virtual WeightReverseRange GetUncompressedReverseWeights(const EdgeID id) const = 0;
+    virtual WeightForwardRange GetUncompressedForwardWeights(const PackedGeometryID id) const = 0;
+    virtual WeightReverseRange GetUncompressedReverseWeights(const PackedGeometryID id) const = 0;
 
     // Gets the duration values for each segment in an uncompressed geometry.
     // Should always be 1 shorter than GetUncompressedGeometry
-    virtual DurationForwardRange GetUncompressedForwardDurations(const EdgeID id) const = 0;
-    virtual DurationReverseRange GetUncompressedReverseDurations(const EdgeID id) const = 0;
+    virtual DurationForwardRange
+    GetUncompressedForwardDurations(const PackedGeometryID id) const = 0;
+    virtual DurationReverseRange
+    GetUncompressedReverseDurations(const PackedGeometryID id) const = 0;
 
     // Returns the data source ids that were used to supply the edge
     // weights.  Will return an empty array when only the base profile is used.
-    virtual DatasourceForwardRange GetUncompressedForwardDatasources(const EdgeID id) const = 0;
-    virtual DatasourceReverseRange GetUncompressedReverseDatasources(const EdgeID id) const = 0;
+    virtual DatasourceForwardRange
+    GetUncompressedForwardDatasources(const PackedGeometryID id) const = 0;
+    virtual DatasourceReverseRange
+    GetUncompressedReverseDatasources(const PackedGeometryID id) const = 0;
 
     // Gets the name of a datasource
     virtual StringView GetDatasourceName(const DatasourceID id) const = 0;
 
-    virtual osrm::guidance::TurnInstruction GetTurnInstructionForEdgeID(const EdgeID id) const = 0;
+    virtual osrm::guidance::TurnInstruction
+    GetTurnInstructionForEdgeID(const EdgeID edge_based_edge_id) const = 0;
 
-    virtual extractor::TravelMode GetTravelMode(const NodeID id) const = 0;
+    virtual extractor::TravelMode GetTravelMode(const NodeID edge_based_node_id) const = 0;
 
-    virtual extractor::ClassData GetClassData(const NodeID id) const = 0;
+    virtual extractor::ClassData GetClassData(const NodeID edge_based_node_id) const = 0;
 
-    virtual bool ExcludeNode(const NodeID id) const = 0;
+    virtual bool ExcludeNode(const NodeID edge_based_node_id) const = 0;
 
     virtual std::vector<std::string> GetClasses(const extractor::ClassData class_data) const = 0;
 
@@ -182,12 +187,12 @@ class BaseDataFacade
                                                       const Approach approach,
                                                       const bool use_all_edges = false) const = 0;
 
-    virtual bool HasLaneData(const EdgeID id) const = 0;
-    virtual util::guidance::LaneTupleIdPair GetLaneData(const EdgeID id) const = 0;
+    virtual bool HasLaneData(const EdgeID edge_based_edge_id) const = 0;
+    virtual util::guidance::LaneTupleIdPair GetLaneData(const EdgeID edge_based_edge_id) const = 0;
     virtual extractor::TurnLaneDescription
     GetTurnDescription(const LaneDescriptionID lane_description_id) const = 0;
 
-    virtual NameID GetNameIndex(const NodeID id) const = 0;
+    virtual NameID GetNameIndex(const NodeID edge_based_node_id) const = 0;
 
     virtual StringView GetNameForID(const NameID id) const = 0;
 
@@ -209,16 +214,16 @@ class BaseDataFacade
 
     virtual double GetWeightMultiplier() const = 0;
 
-    virtual osrm::guidance::TurnBearing PreTurnBearing(const EdgeID eid) const = 0;
-    virtual osrm::guidance::TurnBearing PostTurnBearing(const EdgeID eid) const = 0;
+    virtual osrm::guidance::TurnBearing PreTurnBearing(const EdgeID edge_based_edge_id) const = 0;
+    virtual osrm::guidance::TurnBearing PostTurnBearing(const EdgeID edge_based_edge_id) const = 0;
 
-    virtual util::guidance::BearingClass GetBearingClass(const NodeID node) const = 0;
+    virtual util::guidance::BearingClass GetBearingClass(const NodeID node_based_node_id) const = 0;
 
-    virtual util::guidance::EntryClass GetEntryClass(const EdgeID turn_id) const = 0;
+    virtual util::guidance::EntryClass GetEntryClass(const EdgeID edge_based_edge_id) const = 0;
 
-    virtual bool IsLeftHandDriving(const NodeID id) const = 0;
+    virtual bool IsLeftHandDriving(const NodeID edge_based_node_id) const = 0;
 
-    virtual bool IsSegregated(const NodeID) const = 0;
+    virtual bool IsSegregated(const NodeID edge_based_node_id) const = 0;
 
     virtual std::vector<extractor::ManeuverOverride>
     GetOverridesThatStartAt(const NodeID edge_based_node_id) const = 0;
diff --git a/include/util/typedefs.hpp b/include/util/typedefs.hpp
index 9868ee2ff..b1e962e2e 100644
--- a/include/util/typedefs.hpp
+++ b/include/util/typedefs.hpp
@@ -76,13 +76,13 @@ using NodeID = std::uint32_t;
 using EdgeID = std::uint32_t;
 using NameID = std::uint32_t;
 using AnnotationID = std::uint32_t;
+using PackedGeometryID = std::uint32_t;
 using EdgeWeight = std::int32_t;
 using EdgeDuration = std::int32_t;
 using EdgeDistance = float;
 using SegmentWeight = std::uint32_t;
 using SegmentDuration = std::uint32_t;
 using TurnPenalty = std::int16_t; // turn penalty in 100ms units
-using DataTimestamp = std::string;
 
 static const std::size_t INVALID_INDEX = std::numeric_limits<std::size_t>::max();
 
@@ -95,16 +95,13 @@ static const LaneDescriptionID INVALID_LANE_DESCRIPTIONID =
     std::numeric_limits<LaneDescriptionID>::max();
 
 using BearingClassID = std::uint32_t;
-static const BearingClassID INVALID_BEARING_CLASSID = std::numeric_limits<BearingClassID>::max();
-
 using DiscreteBearing = std::uint16_t;
-
 using EntryClassID = std::uint16_t;
-static const EntryClassID INVALID_ENTRY_CLASSID = std::numeric_limits<EntryClassID>::max();
 
 static const NodeID SPECIAL_NODEID = std::numeric_limits<NodeID>::max();
 static const NodeID SPECIAL_SEGMENTID = std::numeric_limits<NodeID>::max() >> 1;
-static const NodeID SPECIAL_GEOMETRYID = std::numeric_limits<NodeID>::max() >> 1;
+static const PackedGeometryID SPECIAL_GEOMETRYID =
+    std::numeric_limits<PackedGeometryID>::max() >> 1;
 static const EdgeID SPECIAL_EDGEID = std::numeric_limits<EdgeID>::max();
 static const RestrictionID SPECIAL_RESTRICTIONID = std::numeric_limits<RestrictionID>::max();
 static const NameID INVALID_NAMEID = std::numeric_limits<NameID>::max();
@@ -123,13 +120,6 @@ static const TurnPenalty INVALID_TURN_PENALTY = std::numeric_limits<TurnPenalty>
 static const EdgeDistance INVALID_EDGE_DISTANCE = std::numeric_limits<EdgeDistance>::max();
 static const EdgeDistance INVALID_FALLBACK_SPEED = std::numeric_limits<double>::max();
 
-// FIXME the bitfields we use require a reduced maximal duration, this should be kept consistent
-// within the code base. For now we have to ensure that we don't case 30 bit to -1 and break any
-// min() / operator< checks due to the invalid truncation. In addition, using signed and unsigned
-// weights produces problems. As a result we can only store 1 << 29 since the MSB is still reserved
-// for the sign bit. See https://github.com/Project-OSRM/osrm-backend/issues/3677
-static const EdgeWeight MAXIMAL_EDGE_DURATION_INT_30 = (1 << 29) - 1;
-
 using DatasourceID = std::uint8_t;
 
 using BisectionID = std::uint32_t;
@@ -158,11 +148,11 @@ struct SegmentID
  */
 struct GeometryID
 {
-    GeometryID(const NodeID id_, const bool forward_) : id{id_}, forward{forward_} {}
+    GeometryID(const PackedGeometryID id_, const bool forward_) : id{id_}, forward{forward_} {}
 
     GeometryID() : id(std::numeric_limits<unsigned>::max() >> 1), forward(false) {}
 
-    NodeID id : 31;
+    PackedGeometryID id : 31;
     std::uint32_t forward : 1;
 };