diff --git a/crates/map/src/helpers/astar.cairo b/crates/map/src/finders/astar.cairo
similarity index 83%
rename from crates/map/src/helpers/astar.cairo
rename to crates/map/src/finders/astar.cairo
index f02669b..6fb0c44 100644
--- a/crates/map/src/helpers/astar.cairo
+++ b/crates/map/src/finders/astar.cairo
@@ -6,6 +6,7 @@ use core::dict::{Felt252Dict, Felt252DictTrait};
 
 // Internal imports
 
+use origami_map::finders::finder::Finder;
 use origami_map::helpers::heap::{Heap, HeapTrait};
 use origami_map::helpers::bitmap::Bitmap;
 use origami_map::helpers::seeder::Seeder;
@@ -70,7 +71,7 @@ pub impl Astar of AstarTrait {
         };
 
         // [Return] The path from the start to the target
-        Self::path(ref heap, start, target)
+        Finder::path_with_heap(ref heap, start, target)
     }
 
     /// Check if the position can be visited in the specified direction.
@@ -123,9 +124,9 @@ pub impl Astar of AstarTrait {
     fn assess(
         width: u8, neighbor_position: u8, current: Node, target: Node, ref heap: Heap<Node>,
     ) {
-        let distance = Self::heuristic(current.position, neighbor_position, width);
+        let distance = Finder::manhattan(current.position, neighbor_position, width);
         let neighbor_gcost = current.gcost + distance;
-        let neighbor_hcost = Self::heuristic(neighbor_position, target.position, width);
+        let neighbor_hcost = Finder::manhattan(neighbor_position, target.position, width);
         let mut neighbor = match heap.get(neighbor_position.into()) {
             Option::Some(node) => node,
             Option::None => NodeTrait::new(
@@ -141,58 +142,6 @@ pub impl Astar of AstarTrait {
             return heap.update(neighbor);
         }
     }
-
-    /// Compute the heuristic cost between two positions.
-    /// # Arguments
-    /// * `position` - The current position
-    /// * `target` - The target position
-    /// * `width` - The width of the grid
-    /// # Returns
-    /// * The heuristic cost between the two positions
-    #[inline]
-    fn heuristic(position: u8, target: u8, width: u8) -> u16 {
-        let (x1, y1) = (position % width, position / width);
-        let (x2, y2) = (target % width, target / width);
-        let dx = if x1 > x2 {
-            x1 - x2
-        } else {
-            x2 - x1
-        };
-        let dy = if y1 > y2 {
-            y1 - y2
-        } else {
-            y2 - y1
-        };
-        (dx + dy).into()
-    }
-
-    /// Reconstruct the path from the target to the start.
-    /// # Arguments
-    /// * `heap` - The heap of nodes
-    /// * `start` - The starting node
-    /// * `target` - The target node
-    /// # Returns
-    /// * The span of positions from the target to the start
-    #[inline]
-    fn path(ref heap: Heap<Node>, start: Node, target: Node) -> Span<u8> {
-        // [Check] The heap contains the target
-        let mut path: Array<u8> = array![];
-        match heap.get(target.position) {
-            Option::None => { path.span() },
-            Option::Some(mut current) => {
-                // [Compute] Reconstruct the path from the target to the start
-                loop {
-                    if current.position == start.position {
-                        break;
-                    }
-                    path.append(current.position);
-                    current = heap.at(current.source);
-                };
-                // [Return] The path from the start to the target
-                path.span()
-            },
-        }
-    }
 }
 
 #[cfg(test)]
diff --git a/crates/map/src/helpers/bfs.cairo b/crates/map/src/finders/bfs.cairo
similarity index 79%
rename from crates/map/src/helpers/bfs.cairo
rename to crates/map/src/finders/bfs.cairo
index df2ec89..67d89bd 100644
--- a/crates/map/src/helpers/bfs.cairo
+++ b/crates/map/src/finders/bfs.cairo
@@ -4,17 +4,17 @@
 use core::dict::{Felt252Dict, Felt252DictTrait};
 
 // Internal imports
-use origami_map::helpers::astar::Astar;
+use origami_map::finders::finder::Finder;
 use origami_map::helpers::bitmap::Bitmap;
 use origami_map::helpers::seeder::Seeder;
 use origami_map::types::node::{Node, NodeTrait};
 use origami_map::types::direction::{Direction, DirectionTrait};
 
 
-/// BFS implementation for pathfinding
+/// BreadthFirstSearch implementation for pathfinding
 #[generate_trait]
-pub impl BFS of BFSTrait {
-    /// Searches for a path from 'from' to 'to' on the given grid using BFS
+pub impl BreadthFirstSearch of BreadthFirstSearchTrait {
+    /// Searches for a path from 'from' to 'to' on the given grid using BreadthFirstSearch
     ///
     /// # Arguments
     /// * `grid` - The grid represented as a felt252
@@ -42,7 +42,7 @@ pub impl BFS of BFSTrait {
         let mut parents: Felt252Dict<u8> = Default::default();
         visited.insert(start.position.into(), true);
 
-        // [Compute] BFS until the target is reached or queue is empty
+        // [Compute] BreadthFirstSearch until the target is reached or queue is empty
         let mut path_found = false;
         while let Option::Some(current) = queue.pop_front() {
             // [Check] Stop if we reached the target
@@ -55,7 +55,7 @@ pub impl BFS of BFSTrait {
             let mut directions = DirectionTrait::compute_shuffled_directions(seed);
             while directions != 0 {
                 let direction = DirectionTrait::pop_front(ref directions);
-                if Astar::check(grid, width, height, current.position, direction, ref visited) {
+                if Finder::check(grid, width, height, current.position, direction, ref visited) {
                     let neighbor_position = direction.next(current.position, width);
                     parents.insert(neighbor_position.into(), current.position);
                     let neighbor = NodeTrait::new(neighbor_position, current.position, 0, 0);
@@ -69,31 +69,14 @@ pub impl BFS of BFSTrait {
         if !path_found {
             return array![].span();
         };
-        Self::path(parents, start, target)
-    }
-
-    /// Reconstructs the path from start to target using the parents dictionary
-    #[inline]
-    fn path(mut parents: Felt252Dict<u8>, start: Node, target: Node) -> Span<u8> {
-        let mut path: Array<u8> = array![];
-        let mut current = target.position;
-
-        loop {
-            if current == start.position {
-                break;
-            }
-            path.append(current);
-            current = parents.get(current.into());
-        };
-
-        path.span()
+        Finder::path_with_parents(ref parents, start, target)
     }
 }
 
 #[cfg(test)]
 mod test {
     // Local imports
-    use super::BFS;
+    use super::BreadthFirstSearch;
 
     #[test]
     fn test_bfs_search_small() {
@@ -105,7 +88,7 @@ mod test {
         let height = 3;
         let from = 0;
         let to = 8;
-        let path = BFS::search(grid, width, height, from, to);
+        let path = BreadthFirstSearch::search(grid, width, height, from, to);
         assert_eq!(path, array![8, 7, 6, 3].span());
     }
 
@@ -119,7 +102,7 @@ mod test {
         let height = 3;
         let from = 0;
         let to = 8;
-        let path = BFS::search(grid, width, height, from, to);
+        let path = BreadthFirstSearch::search(grid, width, height, from, to);
         assert_eq!(path, array![].span());
     }
 
@@ -134,7 +117,7 @@ mod test {
         let height = 4;
         let from = 0;
         let to = 14;
-        let path = BFS::search(grid, width, height, from, to);
+        let path = BreadthFirstSearch::search(grid, width, height, from, to);
         assert_eq!(path, array![14, 15, 11, 7, 6, 5, 4].span());
     }
 
@@ -148,7 +131,7 @@ mod test {
         let height = 2;
         let from = 0;
         let to = 1;
-        let path = BFS::search(grid, width, height, from, to);
+        let path = BreadthFirstSearch::search(grid, width, height, from, to);
         assert_eq!(path, array![1].span());
     }
 
@@ -164,7 +147,7 @@ mod test {
         let height = 4;
         let from = 0;
         let to = 19;
-        let path = BFS::search(grid, width, height, from, to);
+        let path = BreadthFirstSearch::search(grid, width, height, from, to);
         assert_eq!(path, array![19, 18, 13, 12, 11, 6, 1].span());
     }
 
@@ -177,7 +160,7 @@ mod test {
         let height = 1;
         let from = 0;
         let to = 5;
-        let path = BFS::search(grid, width, height, from, to);
+        let path = BreadthFirstSearch::search(grid, width, height, from, to);
         assert_eq!(path, array![5, 4, 3, 2, 1].span());
     }
 
@@ -192,7 +175,7 @@ mod test {
         let height = 3;
         let from = 0;
         let to = 8;
-        let path = BFS::search(grid, width, height, from, to);
+        let path = BreadthFirstSearch::search(grid, width, height, from, to);
         assert_eq!(path, array![].span());
     }
 }
diff --git a/crates/map/src/finders/finder.cairo b/crates/map/src/finders/finder.cairo
new file mode 100644
index 0000000..af2227b
--- /dev/null
+++ b/crates/map/src/finders/finder.cairo
@@ -0,0 +1,297 @@
+//! A* algorithm implementation for pathfinding.
+
+// Core imports
+
+use core::dict::{Felt252Dict, Felt252DictTrait};
+use core::num::traits::Sqrt;
+
+// Internal imports
+
+use origami_map::helpers::heap::{Heap, HeapTrait};
+use origami_map::helpers::bitmap::Bitmap;
+use origami_map::types::node::{Node, NodeTrait};
+use origami_map::types::direction::{Direction, DirectionTrait};
+
+#[generate_trait]
+pub impl Finder of FinderTrait {
+    /// Check if the position can be visited in the specified direction.
+    /// # Arguments
+    /// * `grid` - The grid to search (1 is walkable and 0 is not)
+    /// * `width` - The width of the grid
+    /// * `height` - The height of the grid
+    /// * `position` - The current position
+    /// * `direction` - The direction to check
+    /// * `visited` - The visited nodes
+    /// # Returns
+    /// * Whether the position can be visited in the specified direction
+    #[inline]
+    fn check(
+        grid: felt252,
+        width: u8,
+        height: u8,
+        position: u8,
+        direction: Direction,
+        ref visited: Felt252Dict<bool>
+    ) -> bool {
+        let (x, y) = (position % width, position / width);
+        match direction {
+            Direction::North => (y < height - 1)
+                && (Bitmap::get(grid, position + width) == 1)
+                && !visited.get((position + width).into()),
+            Direction::East => (x > 0)
+                && (Bitmap::get(grid, position - 1) == 1)
+                && !visited.get((position - 1).into()),
+            Direction::South => (y > 0)
+                && (Bitmap::get(grid, position - width) == 1)
+                && !visited.get((position - width).into()),
+            Direction::West => (x < width - 1)
+                && (Bitmap::get(grid, position + 1) == 1)
+                && !visited.get((position + 1).into()),
+            _ => false,
+        }
+    }
+
+    /// Compute the amplified euclidean distance between two positions.
+    /// # Arguments
+    /// * `position` - The current position
+    /// * `target` - The target position
+    /// * `width` - The width of the grid
+    /// # Returns
+    /// * The amplified euclidean distance between the two positions
+    #[inline]
+    fn euclidean(position: u8, target: u8, width: u8, multiplier: u32) -> u16 {
+        let (x1, y1) = (position % width, position / width);
+        let (x2, y2) = (target % width, target / width);
+        let dx = if x1 > x2 {
+            x1 - x2
+        } else {
+            x2 - x1
+        };
+        let dy = if y1 > y2 {
+            y1 - y2
+        } else {
+            y2 - y1
+        };
+        (multiplier * (dx.into() * dx.into() + dy.into() * dy.into())).sqrt()
+    }
+
+    /// Compute the manhattan distance between two positions.
+    /// # Arguments
+    /// * `position` - The current position
+    /// * `target` - The target position
+    /// * `width` - The width of the grid
+    /// # Returns
+    /// * The manhattan distance between the two positions
+    #[inline]
+    fn manhattan(position: u8, target: u8, width: u8) -> u16 {
+        let (x1, y1) = (position % width, position / width);
+        let (x2, y2) = (target % width, target / width);
+        let dx = if x1 > x2 {
+            x1 - x2
+        } else {
+            x2 - x1
+        };
+        let dy = if y1 > y2 {
+            y1 - y2
+        } else {
+            y2 - y1
+        };
+        (dx + dy).into()
+    }
+
+    /// Reconstructs the path from start to target using the parents dictionary.
+    /// # Arguments
+    /// * `parents` - The parents dictionary
+    /// * `start` - The starting node
+    /// * `target` - The target node
+    /// # Returns
+    /// * The span of positions from the target to the start
+    #[inline]
+    fn path_with_parents(ref parents: Felt252Dict<u8>, start: Node, target: Node) -> Span<u8> {
+        let mut path: Array<u8> = array![];
+        let mut current = target.position;
+        loop {
+            if current == start.position {
+                break;
+            }
+            path.append(current);
+            current = parents.get(current.into());
+        };
+        path.span()
+    }
+
+    /// Reconstruct the path from the target to the start using a heap.
+    /// # Arguments
+    /// * `heap` - The heap of nodes
+    /// * `start` - The starting node
+    /// * `target` - The target node
+    /// # Returns
+    /// * The span of positions from the target to the start
+    #[inline]
+    fn path_with_heap(ref heap: Heap<Node>, start: Node, target: Node) -> Span<u8> {
+        // [Check] The heap contains the target
+        let mut path: Array<u8> = array![];
+        match heap.get(target.position) {
+            Option::None => { path.span() },
+            Option::Some(mut current) => {
+                // [Compute] Reconstruct the path from the target to the start
+                loop {
+                    path.append(current.position);
+                    if current.source == start.position {
+                        break;
+                    }
+                    current = heap.at(current.source);
+                };
+                // [Return] The path from the start to the target
+                path.span()
+            },
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    // Local imports
+
+    use super::{Finder, Node, NodeTrait, Felt252Dict, Direction, Heap, HeapTrait};
+
+    #[test]
+    fn test_finder_euclidean() {
+        // x 0 0
+        // 0 0 0
+        // 0 0 s
+        let start = 0;
+        let target = 8;
+        let width = 3;
+        assert_eq!(Finder::euclidean(start, target, width, 1), 2);
+        assert_eq!(Finder::euclidean(start, target, width, 100), 28);
+        assert_eq!(Finder::euclidean(start, target, width, 10000), 282);
+    }
+
+    #[test]
+    fn test_finder_manhattan() {
+        // x 0 0
+        // 0 0 0
+        // 0 0 s
+        let start = 0;
+        let target = 8;
+        let width = 3;
+        assert_eq!(Finder::manhattan(start, target, width), 4);
+    }
+
+    #[test]
+    fn test_finder_check_corner() {
+        // 1 1 1
+        // 1 0 1
+        // 1 1 x
+        let grid: felt252 = 0x1EF;
+        let width = 3;
+        let height = 3;
+        let position = 0;
+        let mut visited: Felt252Dict<bool> = Default::default();
+        assert_eq!(
+            Finder::check(grid, width, height, position, Direction::North, ref visited), true
+        );
+        assert_eq!(
+            Finder::check(grid, width, height, position, Direction::East, ref visited), false
+        );
+        assert_eq!(
+            Finder::check(grid, width, height, position, Direction::South, ref visited), false
+        );
+        assert_eq!(
+            Finder::check(grid, width, height, position, Direction::West, ref visited), true
+        );
+    }
+
+    #[test]
+    fn test_finder_check_edge() {
+        // 1 1 1
+        // 1 0 1
+        // 1 x 1
+        let grid: felt252 = 0x1EF;
+        let width = 3;
+        let height = 3;
+        let position = 1;
+        let mut visited: Felt252Dict<bool> = Default::default();
+        assert_eq!(
+            Finder::check(grid, width, height, position, Direction::North, ref visited), false
+        );
+        assert_eq!(
+            Finder::check(grid, width, height, position, Direction::East, ref visited), true
+        );
+        assert_eq!(
+            Finder::check(grid, width, height, position, Direction::South, ref visited), false
+        );
+        assert_eq!(
+            Finder::check(grid, width, height, position, Direction::West, ref visited), true
+        );
+    }
+
+    #[test]
+    fn test_finder_check_inside() {
+        // 1 1 1
+        // 1 x 0
+        // 1 0 1
+        let grid: felt252 = 0x1F5;
+        let width = 3;
+        let height = 3;
+        let position = 4;
+        let mut visited: Felt252Dict<bool> = Default::default();
+        assert_eq!(
+            Finder::check(grid, width, height, position, Direction::North, ref visited), true
+        );
+        assert_eq!(
+            Finder::check(grid, width, height, position, Direction::East, ref visited), false
+        );
+        assert_eq!(
+            Finder::check(grid, width, height, position, Direction::South, ref visited), false
+        );
+        assert_eq!(
+            Finder::check(grid, width, height, position, Direction::West, ref visited), true
+        );
+    }
+
+    #[test]
+    fn test_finder_path_with_parents() {
+        // 1 < 1 < 1
+        //         ^
+        // 1 > 1 > 1
+        // ^
+        // 1 < 1 < 1
+        let start: Node = NodeTrait::new(0, 0, 0, 0);
+        let target: Node = NodeTrait::new(8, 7, 0, 0);
+        let mut parents: Felt252Dict<u8> = Default::default();
+        parents.insert(1, 0);
+        parents.insert(2, 1);
+        parents.insert(5, 2);
+        parents.insert(4, 5);
+        parents.insert(3, 4);
+        parents.insert(6, 3);
+        parents.insert(7, 6);
+        parents.insert(8, 7);
+        let path = Finder::path_with_parents(ref parents, start, target);
+        assert_eq!(path, array![8, 7, 6, 3, 4, 5, 2, 1].span());
+    }
+
+    #[test]
+    fn test_finder_path_with_heap() {
+        // 1 < 1 < 1
+        //         ^
+        // 1 > 1 > 1
+        // ^
+        // 1 < 1 < 1
+        let start: Node = NodeTrait::new(0, 0, 0, 0);
+        let target: Node = NodeTrait::new(8, 7, 0, 0);
+        let mut heap: Heap<Node> = HeapTrait::new();
+        heap.add(NodeTrait::new(1, 0, 0, 0));
+        heap.add(NodeTrait::new(2, 1, 0, 0));
+        heap.add(NodeTrait::new(5, 2, 0, 0));
+        heap.add(NodeTrait::new(4, 5, 0, 0));
+        heap.add(NodeTrait::new(3, 4, 0, 0));
+        heap.add(NodeTrait::new(6, 3, 0, 0));
+        heap.add(NodeTrait::new(7, 6, 0, 0));
+        heap.add(NodeTrait::new(8, 7, 0, 0));
+        let path = Finder::path_with_heap(ref heap, start, target);
+        assert_eq!(path, array![8, 7, 6, 3, 4, 5, 2, 1].span());
+    }
+}
diff --git a/crates/map/src/helpers/greedy.cairo b/crates/map/src/finders/greedy.cairo
similarity index 91%
rename from crates/map/src/helpers/greedy.cairo
rename to crates/map/src/finders/greedy.cairo
index da12269..f4b6161 100644
--- a/crates/map/src/helpers/greedy.cairo
+++ b/crates/map/src/finders/greedy.cairo
@@ -7,7 +7,7 @@ use core::dict::{Felt252Dict, Felt252DictTrait};
 // Internal imports
 
 use origami_map::helpers::heap::{Heap, HeapTrait};
-use origami_map::helpers::astar::Astar;
+use origami_map::finders::finder::Finder;
 use origami_map::helpers::bitmap::Bitmap;
 use origami_map::helpers::seeder::Seeder;
 use origami_map::types::node::{Node, NodeTrait};
@@ -49,29 +49,29 @@ pub impl Greedy of GreedyTrait {
             let seed = Seeder::shuffle(grid, current.position.into());
             let mut directions = DirectionTrait::compute_shuffled_directions(seed);
             let direction: Direction = DirectionTrait::pop_front(ref directions);
-            if Astar::check(grid, width, height, current.position, direction, ref visited) {
+            if Finder::check(grid, width, height, current.position, direction, ref visited) {
                 let neighbor_position = direction.next(current.position, width);
                 Self::assess(width, neighbor_position, current, target, ref heap);
             }
             let direction: Direction = DirectionTrait::pop_front(ref directions);
-            if Astar::check(grid, width, height, current.position, direction, ref visited) {
+            if Finder::check(grid, width, height, current.position, direction, ref visited) {
                 let neighbor_position = direction.next(current.position, width);
                 Self::assess(width, neighbor_position, current, target, ref heap);
             }
             let direction: Direction = DirectionTrait::pop_front(ref directions);
-            if Astar::check(grid, width, height, current.position, direction, ref visited) {
+            if Finder::check(grid, width, height, current.position, direction, ref visited) {
                 let neighbor_position = direction.next(current.position, width);
                 Self::assess(width, neighbor_position, current, target, ref heap);
             }
             let direction: Direction = DirectionTrait::pop_front(ref directions);
-            if Astar::check(grid, width, height, current.position, direction, ref visited) {
+            if Finder::check(grid, width, height, current.position, direction, ref visited) {
                 let neighbor_position = direction.next(current.position, width);
                 Self::assess(width, neighbor_position, current, target, ref heap);
             }
         };
 
         // [Return] The path from the start to the target
-        Astar::path(ref heap, start, target)
+        Finder::path_with_heap(ref heap, start, target)
     }
 
     /// Assess the neighbor node and update the heap.
@@ -87,7 +87,7 @@ pub impl Greedy of GreedyTrait {
     fn assess(
         width: u8, neighbor_position: u8, current: Node, target: Node, ref heap: Heap<Node>,
     ) {
-        let neighbor_hcost = Astar::heuristic(neighbor_position, target.position, width);
+        let neighbor_hcost = Finder::manhattan(neighbor_position, target.position, width);
         let mut neighbor = match heap.get(neighbor_position.into()) {
             Option::Some(node) => node,
             Option::None => NodeTrait::new(neighbor_position, current.position, 0, neighbor_hcost),
diff --git a/crates/map/src/helpers/caver.cairo b/crates/map/src/generators/caver.cairo
similarity index 100%
rename from crates/map/src/helpers/caver.cairo
rename to crates/map/src/generators/caver.cairo
diff --git a/crates/map/src/helpers/digger.cairo b/crates/map/src/generators/digger.cairo
similarity index 99%
rename from crates/map/src/helpers/digger.cairo
rename to crates/map/src/generators/digger.cairo
index 966dce8..381d789 100644
--- a/crates/map/src/helpers/digger.cairo
+++ b/crates/map/src/generators/digger.cairo
@@ -3,10 +3,10 @@
 // Internal imports
 
 use origami_map::helpers::bitmap::Bitmap;
-use origami_map::helpers::caver::Caver;
 use origami_map::helpers::seeder::Seeder;
-use origami_map::helpers::mazer::Mazer;
 use origami_map::helpers::asserter::Asserter;
+use origami_map::generators::caver::Caver;
+use origami_map::generators::mazer::Mazer;
 use origami_map::types::direction::{Direction, DirectionTrait};
 
 /// Implementation of the `DiggerTrait` trait.
diff --git a/crates/map/src/helpers/mazer.cairo b/crates/map/src/generators/mazer.cairo
similarity index 100%
rename from crates/map/src/helpers/mazer.cairo
rename to crates/map/src/generators/mazer.cairo
diff --git a/crates/map/src/helpers/spreader.cairo b/crates/map/src/generators/spreader.cairo
similarity index 100%
rename from crates/map/src/helpers/spreader.cairo
rename to crates/map/src/generators/spreader.cairo
diff --git a/crates/map/src/helpers/walker.cairo b/crates/map/src/generators/walker.cairo
similarity index 99%
rename from crates/map/src/helpers/walker.cairo
rename to crates/map/src/generators/walker.cairo
index 3051355..0606753 100644
--- a/crates/map/src/helpers/walker.cairo
+++ b/crates/map/src/generators/walker.cairo
@@ -4,8 +4,8 @@
 
 use origami_map::helpers::bitmap::Bitmap;
 use origami_map::helpers::seeder::Seeder;
-use origami_map::helpers::mazer::Mazer;
 use origami_map::helpers::asserter::Asserter;
+use origami_map::generators::mazer::Mazer;
 use origami_map::types::direction::{Direction, DirectionTrait};
 
 // Constants
diff --git a/crates/map/src/lib.cairo b/crates/map/src/lib.cairo
index 4d09365..da07c59 100644
--- a/crates/map/src/lib.cairo
+++ b/crates/map/src/lib.cairo
@@ -6,20 +6,27 @@ pub mod types {
     pub mod node;
 }
 
-pub mod helpers {
-    pub mod asserter;
-    pub mod bitmap;
-    pub mod power;
-    pub mod seeder;
+pub mod finders {
+    pub mod finder;
+    pub mod astar;
+    pub mod bfs;
+    pub mod greedy;
+}
+
+pub mod generators {
     pub mod digger;
     pub mod mazer;
     pub mod caver;
     pub mod walker;
     pub mod spreader;
-    pub mod astar;
+}
+
+pub mod helpers {
+    pub mod asserter;
+    pub mod bitmap;
+    pub mod power;
+    pub mod seeder;
     pub mod heap;
-    pub mod greedy;
-    pub mod bfs;
 
     #[cfg(target: "test")]
     pub mod printer;
diff --git a/crates/map/src/map.cairo b/crates/map/src/map.cairo
index c4fe78d..50d9a59 100644
--- a/crates/map/src/map.cairo
+++ b/crates/map/src/map.cairo
@@ -3,13 +3,13 @@
 // Internal imports
 
 use origami_map::helpers::power::TwoPower;
-use origami_map::helpers::mazer::Mazer;
 use origami_map::helpers::asserter::Asserter;
-use origami_map::helpers::walker::Walker;
-use origami_map::helpers::caver::Caver;
-use origami_map::helpers::digger::Digger;
-use origami_map::helpers::spreader::Spreader;
-use origami_map::helpers::astar::Astar;
+use origami_map::generators::mazer::Mazer;
+use origami_map::generators::walker::Walker;
+use origami_map::generators::caver::Caver;
+use origami_map::generators::digger::Digger;
+use origami_map::generators::spreader::Spreader;
+use origami_map::finders::astar::Astar;
 
 /// Types.
 #[derive(Copy, Drop)]