diff --git a/docs/user-guide/adjacency-lists.md b/docs/user-guide/adjacency-lists.md
index 3ae9062..466a648 100644
--- a/docs/user-guide/adjacency-lists.md
+++ b/docs/user-guide/adjacency-lists.md
@@ -256,7 +256,7 @@ Extracts the per-vertex value type from a property map container:
 
 // Works with any adjacency_list graph — index or mapped
 auto distances    = make_vertex_property_map<G, int>(g,
-    shortest_path_infinite_distance<int>());
+    infinite_distance<int>());
 auto predecessors = make_vertex_property_map<G, vertex_id_t<G>>(g,
     vertex_id_t<G>{});
 
diff --git a/docs/user-guide/algorithms.md b/docs/user-guide/algorithms.md
index ac81eaf..35e19e4 100644
--- a/docs/user-guide/algorithms.md
+++ b/docs/user-guide/algorithms.md
@@ -73,7 +73,7 @@ dijkstra_shortest_paths(g, 0, distance, predecessor,
 
 // Map-based graph: use vertex property maps
 using G = /* some mapped_adjacency_list graph */;
-auto distances    = make_vertex_property_map<G, int>(g, shortest_path_infinite_distance<int>());
+auto distances    = make_vertex_property_map<G, int>(g, infinite_distance<int>());
 auto predecessors = make_vertex_property_map<G, vertex_id_t<G>>(g, vertex_id_t<G>{});
 for (auto&& [uid, u] : views::vertexlist(g))
     predecessors[uid] = uid;
@@ -299,8 +299,8 @@ All shortest-path algorithms share utilities from `traversal_common.hpp`:
 |---------|---------|
 | `init_shortest_paths(distances)` | Set all distances to infinity |
 | `init_shortest_paths(distances, predecessors)` | Set distances to infinity, predecessors to self |
-| `shortest_path_infinite_distance<T>()` | Returns the "infinity" sentinel for type `T` |
-| `shortest_path_zero<T>()` | Returns the additive identity for type `T` |
+| `infinite_distance<T>()` | Returns the "infinity" sentinel for type `T` |
+| `zero_distance<T>()` | Returns the additive identity for type `T` |
 
 ### Visitors
 
diff --git a/docs/user-guide/algorithms/bellman_ford.md b/docs/user-guide/algorithms/bellman_ford.md
index 5bc8238..7ee0d65 100644
--- a/docs/user-guide/algorithms/bellman_ford.md
+++ b/docs/user-guide/algorithms/bellman_ford.md
@@ -80,7 +80,7 @@ from the predecessor array.
 // Multi-source, distances + predecessors
 [[nodiscard]] constexpr optional<vertex_id_t<G>>
 bellman_ford_shortest_paths(G&& g, const Sources& sources,
-    Distances& distances, Predecessors& predecessors,
+    DistanceFn&& distance, PredecessorFn&& predecessor,
     WF&& weight = /* default returns 1 */,
     Visitor&& visitor = empty_visitor(),
     Compare&& compare = less<>{},
@@ -89,7 +89,7 @@ bellman_ford_shortest_paths(G&& g, const Sources& sources,
 // Single-source, distances + predecessors
 [[nodiscard]] constexpr optional<vertex_id_t<G>>
 bellman_ford_shortest_paths(G&& g, const vertex_id_t<G>& source,
-    Distances& distances, Predecessors& predecessors,
+    DistanceFn&& distance, PredecessorFn&& predecessor,
     WF&& weight,
     Visitor&& visitor = empty_visitor(),
     Compare&& compare = less<>{},
@@ -98,7 +98,7 @@ bellman_ford_shortest_paths(G&& g, const vertex_id_t<G>& source,
 // Multi-source, distances only
 [[nodiscard]] constexpr optional<vertex_id_t<G>>
 bellman_ford_shortest_distances(G&& g, const Sources& sources,
-    Distances& distances,
+    DistanceFn&& distance,
     WF&& weight,
     Visitor&& visitor = empty_visitor(),
     Compare&& compare = less<>{},
@@ -107,7 +107,7 @@ bellman_ford_shortest_distances(G&& g, const Sources& sources,
 // Single-source, distances only
 [[nodiscard]] constexpr optional<vertex_id_t<G>>
 bellman_ford_shortest_distances(G&& g, const vertex_id_t<G>& source,
-    Distances& distances,
+    DistanceFn&& distance,
     WF&& weight,
     Visitor&& visitor = empty_visitor(),
     Compare&& compare = less<>{},
@@ -125,8 +125,8 @@ void find_negative_cycle(G& g, const Predecessors& predecessor,
 |-----------|-------------|
 | `g` | Graph satisfying `adjacency_list` |
 | `source` / `sources` | Source vertex ID or range of source vertex IDs |
-| `distances` | Subscriptable by `vertex_id_t<G>`. For index graphs, a pre-sized `std::vector`; for mapped graphs, use `make_vertex_property_map<G, T>(g, init)`. Must satisfy `vertex_property_map_for<Distances, G>`. |
-| `predecessors` | Subscriptable by `vertex_id_t<G>`. For index graphs, a pre-sized `std::vector`; for mapped graphs, use `make_vertex_property_map<G, T>(g, init)`. Must satisfy `vertex_property_map_for<Predecessors, G>`. |
+| `distance` | Callable `(const G&, vertex_id_t<G>) -> Distance&` returning a mutable reference to the per-vertex distance. For containers: wrap with `container_value_fn(dist)`. Must satisfy `distance_fn_for<DistanceFn, G>`. |
+| `predecessor` | Callable `(const G&, vertex_id_t<G>) -> Predecessor&` returning a mutable reference to the per-vertex predecessor. For containers: wrap with `container_value_fn(pred)`. Must satisfy `predecessor_fn_for<PredecessorFn, G>`. Use `_null_predecessor` when path reconstruction is not needed. |
 | `weight` | Callable `WF(g, uv)` returning edge weight (may be negative). Must satisfy `basic_edge_weight_function`. |
 | `visitor` | Optional visitor struct with callback methods (see below). Default: `empty_visitor{}`. |
 | `compare` | Comparison function for distance values. Default: `std::less<>{}`. |
@@ -176,11 +176,12 @@ each edge satisfies the triangle inequality.
 - ✅ DAGs (works correctly, though topological-order relaxation is faster)
 - ⚠️ Negative-weight cycles — detected and reported; distances undefined for affected vertices
 
-**Container Requirements:**
+**Property Function Requirements:**
 - Required: `adjacency_list<G>`
-- `distances` must satisfy `vertex_property_map_for<Distances, G>`
-- `predecessors` must satisfy `vertex_property_map_for<Predecessors, G>`
+- `distance` must satisfy `distance_fn_for<DistanceFn, G>`
+- `predecessor` must satisfy `predecessor_fn_for<PredecessorFn, G>`
 - `weight` must satisfy `basic_edge_weight_function`
+- Use `container_value_fn(vec)` to adapt a `std::vector` or similar container
 
 ## Examples
 
@@ -205,12 +206,13 @@ std::vector<uint32_t> pred(num_vertices(g));
 
 init_shortest_paths(dist, pred);
 
-auto cycle = bellman_ford_shortest_paths(g, 0u, dist, pred,
+auto cycle = bellman_ford_shortest_paths(g, 0u, container_value_fn(dist), container_value_fn(pred),
     [](const auto& g, const auto& uv) { return edge_value(g, uv); });
 
 if (!cycle) {
     // No negative cycle — dist[v] is the shortest distance from source 0
     // dist[0] = 0, dist[1] = 6, dist[2] = 7, dist[3] = 2, dist[4] = 4
+    // Unreachable vertices retain infinite_distance<int>()
 }
 ```
 
@@ -228,7 +230,7 @@ std::vector<uint32_t> pred(num_vertices(g));
 
 init_shortest_paths(dist, pred);
 
-auto cycle = bellman_ford_shortest_paths(g, 0u, dist, pred,
+auto cycle = bellman_ford_shortest_paths(g, 0u, container_value_fn(dist), container_value_fn(pred),
     [](const auto& g, const auto& uv) { return edge_value(g, uv); });
 
 if (cycle) {
@@ -245,7 +247,7 @@ if (cycle) {
 Use `find_negative_cycle` to obtain the full cycle from the predecessor array.
 
 ```cpp
-auto cycle = bellman_ford_shortest_paths(g, 0u, dist, pred,
+auto cycle = bellman_ford_shortest_paths(g, 0u, container_value_fn(dist), container_value_fn(pred),
     [](const auto& g, const auto& uv) { return edge_value(g, uv); });
 
 if (cycle) {
@@ -272,7 +274,7 @@ std::vector<uint32_t> pred(num_vertices(g));
 init_shortest_paths(dist, pred);
 
 std::array sources{0u, 3u};
-auto cycle = bellman_ford_shortest_paths(g, sources, dist, pred,
+auto cycle = bellman_ford_shortest_paths(g, sources, container_value_fn(dist), container_value_fn(pred),
     [](const auto& g, const auto& uv) { return edge_value(g, uv); });
 
 // dist[v] = shortest distance from nearest source to v
@@ -287,11 +289,12 @@ When you don't need predecessors (and can't reconstruct paths), use
 std::vector<int> dist(num_vertices(g));
 init_shortest_paths(dist);
 
-auto cycle = bellman_ford_shortest_distances(g, 0u, dist,
+auto cycle = bellman_ford_shortest_distances(g, 0u, container_value_fn(dist),
     [](const auto& g, const auto& uv) { return edge_value(g, uv); });
 
 if (!cycle) {
     // dist[v] = shortest distance from source 0 to v
+    // Unreachable vertices retain infinite_distance<int>()
     // No path reconstruction available (no predecessors)
 }
 ```
@@ -320,7 +323,7 @@ struct NegativeCycleInspector {
 };
 
 NegativeCycleInspector inspector;
-auto cycle = bellman_ford_shortest_paths(g, 0u, dist, pred,
+auto cycle = bellman_ford_shortest_paths(g, 0u, container_value_fn(dist), container_value_fn(pred),
     [](const auto& g, const auto& uv) { return edge_value(g, uv); },
     inspector);
 
@@ -330,24 +333,24 @@ auto cycle = bellman_ford_shortest_paths(g, 0u, dist, pred,
 ## Mandates
 
 - `G` must satisfy `adjacency_list<G>`
-- `Distances` must satisfy `vertex_property_map_for<Distances, G>`
-- `Predecessors` must satisfy `vertex_property_map_for<Predecessors, G>`
+- `DistanceFn` must satisfy `distance_fn_for<DistanceFn, G>`
+- `PredecessorFn` must satisfy `predecessor_fn_for<PredecessorFn, G>` (or use `_null_predecessor`)
 - `WF` must satisfy `basic_edge_weight_function`
 - All overloads are `[[nodiscard]]` — the compiler warns if the return value is discarded
 
 ## Preconditions
 
-- `distances` and `predecessors` must be pre-sized for all vertex IDs in `g`
-- Call `init_shortest_paths(distances, predecessors)` before invoking the algorithm
+- `distance(g, uid)` must be valid for all vertex IDs in `g`
+- Call `init_shortest_paths(dist, pred)` on the underlying containers before invoking the algorithm
 - All source vertex IDs must be valid vertex IDs in `g`
 - **Always check the return value** — if a negative cycle exists, distances are
   undefined for affected vertices
 
 ## Effects
 
-- Writes shortest-path distances to `distances[v]` for all reachable vertices
+- Writes shortest-path distances via `distance(g, v)` for all reachable vertices
   (when no negative cycle exists)
-- Writes predecessor vertex IDs to `predecessors[v]` for path reconstruction
+- Writes predecessor vertex IDs via `predecessor(g, v)` for path reconstruction
   (`bellman_ford_shortest_paths` only)
 - Does not modify the graph `g`
 - Invokes visitor callbacks during relaxation and verification passes
diff --git a/docs/user-guide/algorithms/connected_components.md b/docs/user-guide/algorithms/connected_components.md
index a36d36a..4120427 100644
--- a/docs/user-guide/algorithms/connected_components.md
+++ b/docs/user-guide/algorithms/connected_components.md
@@ -77,21 +77,24 @@ vertex v.
 ### `connected_components` — undirected
 
 ```cpp
-size_t connected_components(G&& g, Component& component);
+size_t connected_components(G&& g, ComponentFn&& component);
 ```
 
 DFS-based algorithm for undirected graphs. Returns the number of connected
-components. Assigns `component[v]` = component ID (0-based).
+components. `component(g, uid)` is called with each vertex ID to assign its
+component ID (0-based).
 
 ### `kosaraju` — strongly connected components
 
 ```cpp
-void kosaraju(G&& g, GT&& g_transpose, Component& component);
+void kosaraju(G&& g, GT&& g_transpose, ComponentFn&& component);
+
+// Bidirectional overload — no transpose graph needed
+void kosaraju(G&& g, ComponentFn&& component);
 ```
 
-Kosaraju's two-pass DFS algorithm for directed graphs. Requires both the
-original graph `g` and its transpose `g_transpose` (edges reversed). Fills
-`component[v]` with the SCC ID.
+Kosaraju's two-pass DFS algorithm for directed graphs. Fills
+`component(g, uid)` with the SCC ID for each vertex.
 
 ### `afforest` — union-find with neighbor sampling
 
@@ -105,19 +108,19 @@ void afforest(G&& g, GT&& g_transpose, Component& component,
 Union-find-based algorithm with neighbor sampling for large or parallel-friendly
 workloads. The `neighbor_rounds` parameter controls how many initial sampling
 rounds are performed before falling back to full edge iteration. Call
-`compress(component)` afterwards for canonical (root) component IDs on a
-single-machine.
+`compress(component)` afterwards for canonical (root) component IDs.
 
-The two-graph variant accepts a transpose `g_transpose` for directed-graph
-support. The transpose must also satisfy `adjacency_list`.
+> **Note:** `afforest` retains a container-based `Component&` interface (not the
+> function-based API) because its internal union-find helpers (`link`, `compress`,
+> `sample_frequent_element`) require direct subscript access to the component array.
 
 ## Parameters
 
 | Parameter | Description |
 |-----------|-------------|
 | `g` | Graph satisfying `adjacency_list` |
-| `g_transpose` | Transpose graph (for `kosaraju` and `afforest` with transpose). `kosaraju` requires `adjacency_list`; `afforest` requires `adjacency_list`. |
-| `component` | Subscriptable by `vertex_id_t<G>`. For index graphs, a pre-sized `std::vector`; for mapped graphs, use `make_vertex_property_map<G, T>(g, init)`. Must satisfy `vertex_property_map_for<Component, G>`. |
+| `g_transpose` | Transpose graph (for `kosaraju` and `afforest` with transpose). Must satisfy `adjacency_list`. |
+| `component` | For `connected_components` and `kosaraju`: callable `(const G&, vertex_id_t<G>) -> ComponentID&` returning a mutable reference. For containers: wrap with `container_value_fn(comp)`. Must satisfy `vertex_property_fn_for<ComponentFn, G>`. For `afforest`: a subscriptable container (`vector` or `unordered_map`), still using the container API. |
 | `neighbor_rounds` | Number of neighbor-sampling rounds for `afforest` (default: 2) |
 
 **Return value (`connected_components` only):** `size_t` — number of connected
@@ -143,7 +146,8 @@ components. `kosaraju` and `afforest` return `void`.
 
 **Container Requirements:**
 - Required: `adjacency_list<G>`
-- `component` must satisfy `vertex_property_map_for<Component, G>`
+- `component` (`connected_components` and `kosaraju`) must satisfy `vertex_property_fn_for<ComponentFn, G>`
+- `component` (`afforest`) must satisfy `vertex_property_map_for<Component, G>`
 - `kosaraju`: transpose graph must also satisfy `adjacency_list`
 
 ## Examples
@@ -167,7 +171,7 @@ using Graph = container::dynamic_graph<void, void, void, uint32_t, false,
 Graph g({{0, 1}, {1, 0}, {1, 2}, {2, 1}, {3, 4}, {4, 3}});
 
 std::vector<uint32_t> comp(num_vertices(g));
-size_t num_cc = connected_components(g, comp);
+size_t num_cc = connected_components(g, container_value_fn(comp));
 
 // num_cc == 2
 // comp[0] == comp[1] == comp[2]  (same component)
@@ -188,7 +192,7 @@ Graph g({{0, 1}, {1, 2}, {2, 0}, {2, 3}});
 Graph g_t({{1, 0}, {2, 1}, {0, 2}, {3, 2}});
 
 std::vector<uint32_t> comp(num_vertices(g));
-kosaraju(g, g_t, comp);
+kosaraju(g, g_t, container_value_fn(comp));
 
 // comp[0] == comp[1] == comp[2]  (cycle forms an SCC)
 // comp[3] != comp[0]             (3 is its own SCC — not on any cycle)
@@ -217,7 +221,7 @@ bidirectional edge pairs.
 undirected_adjacency_list<int, int> g({{0, 1, 1}, {1, 2, 1}, {3, 4, 1}});
 
 std::vector<uint32_t> comp(num_vertices(g));
-size_t num_cc = connected_components(g, comp);
+size_t num_cc = connected_components(g, container_value_fn(comp));
 
 // num_cc == 2
 // Same results as vov with bidirectional edges, but simpler construction
@@ -270,19 +274,22 @@ compress(comp);
 ## Mandates
 
 - `G` must satisfy `adjacency_list<G>`
-- `Component` must satisfy `vertex_property_map_for<Component, G>`
+- `connected_components` and `kosaraju`: `ComponentFn` must satisfy `vertex_property_fn_for<ComponentFn, G>`
+- `afforest`: `Component` must satisfy `vertex_property_map_for<Component, G>`
 - For `kosaraju`: `GT` must satisfy `adjacency_list<GT>`
 
 ## Preconditions
 
-- `component` must be pre-sized for all vertex IDs in `g`
+- `component(g, uid)` must be valid for all vertex IDs in `g` (`connected_components`, `kosaraju`)
+- `component` must be pre-sized for all vertex IDs in `g` (`afforest`)
 - For `connected_components`: undirected graphs must store both directions of
   each edge (or use `undirected_adjacency_list`)
 - For `kosaraju`: the transpose graph must contain all edges reversed
 
 ## Effects
 
-- Writes component IDs to `component[v]` for all vertices
+- Writes component IDs via `component(g, uid)` for all vertices (`connected_components`, `kosaraju`)
+- Writes component IDs to `component[uid]` for all vertices (`afforest`)
 - Does not modify the graph `g` (or `g_transpose`)
 - For `afforest`: call `compress(component)` afterwards for canonical root IDs
 
diff --git a/docs/user-guide/algorithms/dijkstra.md b/docs/user-guide/algorithms/dijkstra.md
index 2067210..e4db6cc 100644
--- a/docs/user-guide/algorithms/dijkstra.md
+++ b/docs/user-guide/algorithms/dijkstra.md
@@ -82,7 +82,7 @@ function, an optional visitor, and optional comparator/combiner functors.
 ```cpp
 // Multi-source, distances + predecessors
 constexpr void dijkstra_shortest_paths(G&& g, const Sources& sources,
-    Distances& distances, Predecessors& predecessors,
+    DistanceFn&& distance, PredecessorFn&& predecessor,
     WF&& weight = /* default returns 1 */,
     Visitor&& visitor = empty_visitor(),
     Compare&& compare = less<>{},
@@ -90,7 +90,7 @@ constexpr void dijkstra_shortest_paths(G&& g, const Sources& sources,
 
 // Single-source, distances + predecessors
 constexpr void dijkstra_shortest_paths(G&& g, const vertex_id_t<G>& source,
-    Distances& distances, Predecessors& predecessors,
+    DistanceFn&& distance, PredecessorFn&& predecessor,
     WF&& weight = /* default returns 1 */,
     Visitor&& visitor = empty_visitor(),
     Compare&& compare = less<>{},
@@ -98,7 +98,7 @@ constexpr void dijkstra_shortest_paths(G&& g, const vertex_id_t<G>& source,
 
 // Multi-source, distances only
 constexpr void dijkstra_shortest_distances(G&& g, const Sources& sources,
-    Distances& distances,
+    DistanceFn&& distance,
     WF&& weight = /* default returns 1 */,
     Visitor&& visitor = empty_visitor(),
     Compare&& compare = less<>{},
@@ -106,7 +106,7 @@ constexpr void dijkstra_shortest_distances(G&& g, const Sources& sources,
 
 // Single-source, distances only
 constexpr void dijkstra_shortest_distances(G&& g, const vertex_id_t<G>& source,
-    Distances& distances,
+    DistanceFn&& distance,
     WF&& weight = /* default returns 1 */,
     Visitor&& visitor = empty_visitor(),
     Compare&& compare = less<>{},
@@ -119,8 +119,8 @@ constexpr void dijkstra_shortest_distances(G&& g, const vertex_id_t<G>& source,
 |-----------|-------------|
 | `g` | Graph satisfying `adjacency_list` |
 | `source` / `sources` | Source vertex ID or range of source vertex IDs |
-| `distances` | Subscriptable by `vertex_id_t<G>`. For index graphs, a pre-sized `std::vector`; for mapped graphs, use `make_vertex_property_map<G, T>(g, init)`. Must satisfy `vertex_property_map_for<Distances, G>`. |
-| `predecessors` | Subscriptable by `vertex_id_t<G>`. For index graphs, a pre-sized `std::vector`; for mapped graphs, use `make_vertex_property_map<G, T>(g, init)`. Must satisfy `vertex_property_map_for<Predecessors, G>`. |
+| `distance` | Callable `(const G&, vertex_id_t<G>) -> Distance&` returning a mutable reference to the per-vertex distance. For containers: wrap with `container_value_fn(dist)`. Must satisfy `distance_fn_for<DistanceFn, G>`. |
+| `predecessor` | Callable `(const G&, vertex_id_t<G>) -> Predecessor&` returning a mutable reference to the per-vertex predecessor. For containers: wrap with `container_value_fn(pred)`. Must satisfy `predecessor_fn_for<PredecessorFn, G>`. Use `_null_predecessor` when path reconstruction is not needed. |
 | `weight` | Callable `WF(g, uv)` returning edge weight. Must satisfy `basic_edge_weight_function`. Default: returns `1` for every edge (unweighted). |
 | `visitor` | Optional visitor struct with callback methods (see below). Default: `empty_visitor{}`. |
 | `compare` | Comparison function for distance values. Default: `std::less<>{}`. |
@@ -160,11 +160,12 @@ need to define the events you care about — missing methods are silently skippe
 - ✅ Disconnected graphs (unreachable vertices retain infinity distance)
 - ✅ Empty graphs (no-op)
 
-**Container Requirements:**
+**Property Function Requirements:**
 - Required: `adjacency_list<G>`
-- `distances` must satisfy `vertex_property_map_for<Distances, G>`
-- `predecessors` must satisfy `vertex_property_map_for<Predecessors, G>`
+- `distance` must satisfy `distance_fn_for<DistanceFn, G>`
+- `predecessor` must satisfy `predecessor_fn_for<PredecessorFn, G>`
 - `weight` must satisfy `basic_edge_weight_function`
+- Use `container_value_fn(vec)` to adapt a `std::vector` or similar container
 
 ## Examples
 
@@ -201,7 +202,7 @@ std::vector<unsigned> pred(num_vertices(g));
 // Initialize distances to infinity, predecessors to self
 init_shortest_paths(dist, pred);
 
-dijkstra_shortest_paths(g, 0u, dist, pred,
+dijkstra_shortest_paths(g, 0u, container_value_fn(dist), container_value_fn(pred),
     [](const auto& g, const auto& uv) { return edge_value(g, uv); });
 
 // dist[0] = 0, dist[1] = 8, dist[2] = 5, dist[3] = 6, dist[4] = 2
@@ -217,11 +218,11 @@ When you only need distances and don't need to reconstruct paths, use
 std::vector<double> dist(num_vertices(g));
 init_shortest_paths(dist);  // one-argument form: distances only
 
-dijkstra_shortest_distances(g, 0u, dist,
+dijkstra_shortest_distances(g, 0u, container_value_fn(dist),
     [](const auto& g, const auto& uv) { return edge_value(g, uv); });
 
 // dist[v] = shortest distance from source 0 to v
-// Unreachable vertices remain at numeric_limits<double>::max()
+// Unreachable vertices remain at infinite_distance<double>()
 ```
 
 ### Example 3: Multi-Source Shortest Paths
@@ -237,7 +238,7 @@ init_shortest_paths(dist, pred);
 
 // Sources can be any range: vector, array, initializer_list
 std::array sources{0u, 2u};
-dijkstra_shortest_paths(g, sources, dist, pred,
+dijkstra_shortest_paths(g, sources, container_value_fn(dist), container_value_fn(pred),
     [](const auto& g, const auto& uv) { return edge_value(g, uv); });
 
 // dist[v] = shortest distance from the nearest source to v
@@ -250,12 +251,12 @@ After running `dijkstra_shortest_paths`, reconstruct the shortest path from
 source to any target by walking the predecessor array backwards.
 
 ```cpp
-// After running dijkstra_shortest_paths(g, source, dist, pred, weight) ...
+// After running dijkstra_shortest_paths(g, source, container_value_fn(dist), container_value_fn(pred), weight) ...
 
 unsigned target = 3;
 unsigned source = 0;
 
-if (dist[target] == std::numeric_limits<double>::max()) {
+if (dist[target] == infinite_distance<double>()) {
     // target is unreachable from source
 } else {
     // Build path in reverse
@@ -289,7 +290,7 @@ std::vector<uint32_t> pred(num_vertices(g));
 init_shortest_paths(dist, pred);
 
 // No weight function — default returns 1 per edge
-dijkstra_shortest_paths(g, 0u, dist, pred);
+dijkstra_shortest_paths(g, 0u, container_value_fn(dist), container_value_fn(pred));
 
 // dist[0] = 0, dist[1] = 1, dist[2] = 1, dist[3] = 2, dist[4] = 3
 // These are hop counts — same as BFS distances
@@ -324,7 +325,7 @@ std::vector<unsigned> pred(num_vertices(g));
 init_shortest_paths(dist, pred);
 
 RelaxationTracker tracker;
-dijkstra_shortest_paths(g, 0u, dist, pred,
+dijkstra_shortest_paths(g, 0u, container_value_fn(dist), container_value_fn(pred),
     [](const auto& g, const auto& uv) { return edge_value(g, uv); },
     tracker);
 
@@ -348,8 +349,8 @@ struct IdVisitor {
 ## Mandates
 
 - `G` must satisfy `adjacency_list<G>`
-- `Distances` must satisfy `vertex_property_map_for<Distances, G>`
-- `Predecessors` must satisfy `vertex_property_map_for<Predecessors, G>`
+- `DistanceFn` must satisfy `distance_fn_for<DistanceFn, G>`
+- `PredecessorFn` must satisfy `predecessor_fn_for<PredecessorFn, G>` (or use `_null_predecessor`)
 - `WF` must satisfy `basic_edge_weight_function`
 - Visitor callbacks (if present) must accept appropriate graph and vertex/edge parameters
 
@@ -357,14 +358,14 @@ struct IdVisitor {
 
 - All edge weights must be **non-negative**. For signed weight types, a negative
   weight throws `std::out_of_range` at runtime.
-- `distances` and `predecessors` must be pre-sized for all vertex IDs in `g`
-- Call `init_shortest_paths(distances, predecessors)` before invoking the algorithm
+- `distance(g, uid)` must be valid for all vertex IDs in `g`
+- Call `init_shortest_paths(distances, predecessors)` on the underlying containers before invoking the algorithm
 - All source vertex IDs must be valid vertex IDs in `g`
 
 ## Effects
 
-- Writes shortest-path distances to `distances[v]` for all reachable vertices
-- Writes predecessor vertex IDs to `predecessors[v]` for path reconstruction
+- Writes shortest-path distances via `distance(g, v)` for all reachable vertices
+- Writes predecessor vertex IDs via `predecessor(g, v)` for path reconstruction
   (`dijkstra_shortest_paths` only)
 - Does not modify the graph `g`
 - Invokes visitor callbacks in Dijkstra traversal order
diff --git a/docs/user-guide/algorithms/label_propagation.md b/docs/user-guide/algorithms/label_propagation.md
index c124226..e469339 100644
--- a/docs/user-guide/algorithms/label_propagation.md
+++ b/docs/user-guide/algorithms/label_propagation.md
@@ -83,13 +83,13 @@ Key behaviors:
 
 ```cpp
 // Basic: all vertices start with labels
-void label_propagation(G&& g, Label& label,
+void label_propagation(G&& g, LabelFn&& label,
     Gen&& rng = /* default */,
     T max_iters = std::numeric_limits<T>::max());
 
 // With empty-label sentinel: unlabeled vertices don't participate
-void label_propagation(G&& g, Label& label,
-    range_value_t<Label> empty_label,
+void label_propagation(G&& g, LabelFn&& label,
+    vertex_fn_value_t<LabelFn, G> empty_label,
     Gen&& rng = /* default */,
     T max_iters = std::numeric_limits<T>::max());
 ```
@@ -99,7 +99,7 @@ void label_propagation(G&& g, Label& label,
 | Parameter | Description |
 |-----------|-------------|
 | `g` | Graph satisfying `adjacency_list` |
-| `label` | Subscriptable by `vertex_id_t<G>`. For index graphs, a pre-sized `std::vector`; for mapped graphs, use `make_vertex_property_map<G, T>(g, init)`. Must satisfy `vertex_property_map_for<Label, G>`. Initial labels in, community labels out. Modified in-place. |
+| `label` | Callable `(const G&, vertex_id_t<G>) -> LabelValue&` returning a mutable reference to the per-vertex label. Initial labels in, community labels out. For containers: wrap with `container_value_fn(lbl)`. Must satisfy `vertex_property_fn_for<LabelFn, G>`. |
 | `empty_label` | Sentinel value for unlabeled vertices (they don't vote until labeled) |
 | `rng` | Random number generator for tie-breaking and shuffle (e.g., `std::mt19937`) |
 | `max_iters` | Maximum number of iterations. Default: unlimited (run until convergence). |
@@ -124,7 +124,7 @@ void label_propagation(G&& g, Label& label,
 
 **Container Requirements:**
 - Required: `adjacency_list<G>`
-- `label` must satisfy `vertex_property_map_for<Label, G>`
+- `label` must satisfy `vertex_property_fn_for<LabelFn, G>`
 - `rng` must satisfy `UniformRandomBitGenerator`
 
 ## Examples
@@ -153,7 +153,7 @@ std::vector<uint32_t> label(num_vertices(g));
 std::iota(label.begin(), label.end(), 0u);  // label[v] = v initially
 
 std::mt19937 rng{42};
-label_propagation(g, label, rng);
+label_propagation(g, container_value_fn(label), rng);
 
 // After convergence:
 //   label[0] == label[1] == label[2]  (community A)
@@ -175,7 +175,7 @@ Graph k4({{0,1},{1,0}, {0,2},{2,0}, {0,3},{3,0},
 std::vector<int> label = {99, 99, 99, 42};
 
 std::mt19937 rng{42};
-label_propagation(k4, label, rng);
+label_propagation(k4, container_value_fn(label), rng);
 
 // All converge to 99 — majority wins
 // label = {99, 99, 99, 99}
@@ -193,7 +193,7 @@ don't vote until they receive a label from a neighbor. This enables
 std::vector<int> label = {42, -1, -1, -1, -1, 99};
 
 std::mt19937 rng{42};
-label_propagation(g, label, -1, rng);
+label_propagation(g, container_value_fn(label), -1, rng);
 
 // Labels propagate outward from initially-labeled vertices:
 //   42 spreads to vertices 1, 2 (close to vertex 0)
@@ -210,7 +210,7 @@ std::vector<uint32_t> label(num_vertices(g));
 std::iota(label.begin(), label.end(), 0u);
 
 std::mt19937 rng{42};
-label_propagation(g, label, rng, 1);  // single iteration
+label_propagation(g, container_value_fn(label), rng, 1);  // single iteration
 
 // After just 1 iteration, some vertices may not have converged yet.
 // Useful for:
@@ -219,7 +219,7 @@ label_propagation(g, label, rng, 1);  // single iteration
 //   - Monitoring convergence behavior
 
 // Re-running continues from current labels:
-label_propagation(g, label, rng, 5);  // 5 more iterations
+label_propagation(g, container_value_fn(label), rng, 5);  // 5 more iterations
 // Labels refine further; often converges within these additional rounds
 ```
 
@@ -239,7 +239,7 @@ std::vector<uint32_t> label(num_vertices(g));
 std::iota(label.begin(), label.end(), 0u);
 
 std::mt19937 rng{42};
-label_propagation(g, label, rng);
+label_propagation(g, container_value_fn(label), rng);
 
 // label[0] == label[1] == label[2]  (one community)
 // label[3] == label[4] == label[5]  (another community)
@@ -257,7 +257,7 @@ auto run_lp = [&](unsigned seed) {
     std::vector<uint32_t> label(num_vertices(g));
     std::iota(label.begin(), label.end(), 0u);
     std::mt19937 rng{seed};
-    label_propagation(g, label, rng);
+    label_propagation(g, container_value_fn(label), rng);
     return label;
 };
 
@@ -275,19 +275,20 @@ auto labels_c = run_lp(123);
 ## Mandates
 
 - `G` must satisfy `adjacency_list<G>`
-- `Label` must satisfy `vertex_property_map_for<Label, G>`
+- `LabelFn` must satisfy `vertex_property_fn_for<LabelFn, G>`
 - `Gen` must satisfy `UniformRandomBitGenerator`
-- Label values must be equality-comparable and hashable
+- Label values (returned by `LabelFn`) must be equality-comparable and hashable
 
 ## Preconditions
 
-- `label` must be pre-initialized (e.g., with `std::iota` for one-label-per-vertex)
+- `label(g, uid)` must be valid for all vertex IDs in `g` and initialized
+  (e.g., via `std::iota` on the underlying container for one-label-per-vertex)
 - With `empty_label` sentinel: vertices with the sentinel label don't vote.
   If all vertices start with the sentinel, no propagation occurs.
 
 ## Effects
 
-- Modifies `label[v]` in-place for all vertices
+- Writes community labels via `label(g, uid)` in-place for all vertices
 - Does not modify the graph `g`
 - Vertex processing order is shuffled each iteration
 - Iterates until convergence or `max_iters` is reached
diff --git a/docs/user-guide/algorithms/mst.md b/docs/user-guide/algorithms/mst.md
index 53a7655..bc2d5ec 100644
--- a/docs/user-guide/algorithms/mst.md
+++ b/docs/user-guide/algorithms/mst.md
@@ -123,7 +123,7 @@ lightest edge crossing the cut between tree and non-tree vertices.
 // weight_fn and compare are optional
 auto prim(G&& g,
     const vertex_id_t<G>& seed,
-    Predecessor& predecessor, Weight& weight,
+    WeightFn&& weight, PredecessorFn&& predecessor,
     WF weight_fn = edge_value(g, uv),
     Compare compare = std::less<>{});
 ```
@@ -136,8 +136,8 @@ auto prim(G&& g,
 |-----------|-------------|
 | `g` | Graph satisfying `adjacency_list` with weighted edges |
 | `seed` | Starting vertex for MST growth. Must be a valid vertex ID. |
-| `predecessor` | Subscriptable by `vertex_id_t<G>`. For index graphs, a pre-sized `std::vector`; for mapped graphs, use `make_vertex_property_map<G, T>(g, init)`. Must satisfy `vertex_property_map_for<Predecessor, G>`. |
-| `weight` | Subscriptable by `vertex_id_t<G>`. For index graphs, a pre-sized `std::vector`; for mapped graphs, use `make_vertex_property_map<G, T>(g, init)`. Must satisfy `vertex_property_map_for<Weight, G>`. |
+| `weight` | Callable `(const G&, vertex_id_t<G>) -> W&` returning a mutable reference to the per-vertex edge weight. For containers: wrap with `container_value_fn(wt)`. Must satisfy `distance_fn_for<WeightFn, G>`. |
+| `predecessor` | Callable `(const G&, vertex_id_t<G>) -> P&` returning a mutable reference to the per-vertex predecessor. For containers: wrap with `container_value_fn(pred)`. Must satisfy `predecessor_fn_for<PredecessorFn, G>`. |
 | `weight_fn` | Callable `WF(g, uv)` returning edge weight. Default: `edge_value(g, uv)`. |
 | `compare` | Comparator for weight values (default: `std::less<>{}`) |
 
@@ -175,7 +175,9 @@ using Edge = graph::edge_descriptor<uint32_t, int>;
 **Container Requirements:**
 - **Kruskal:** edge descriptors with `source_id`, `target_id`, `value` members
 - **Prim:** `adjacency_list<G>` with weighted edges;
-  `predecessor` and `weight` must satisfy `vertex_property_map_for`
+  `weight` must satisfy `distance_fn_for<WeightFn, G>`;
+  `predecessor` must satisfy `predecessor_fn_for<PredecessorFn, G>`;
+  use `container_value_fn(vec)` to adapt a `std::vector`
 
 ## Examples
 
@@ -288,7 +290,7 @@ std::vector<uint32_t> pred(n);
 std::vector<int>      wt(n);
 
 init_shortest_paths(g, wt, pred);
-auto total = prim(g, 0u, pred, wt);
+auto total = prim(g, 0u, container_value_fn(wt), container_value_fn(pred));
 
 // total = 6  (edges: 0-2:2 + 0-1:4)
 // pred[0] = 0  (seed — self)
@@ -318,7 +320,7 @@ auto neg_weight = [](const auto& g_ref, const auto& uv) {
 };
 
 init_shortest_paths(g, wt, pred);
-auto total = prim(g, 0u, pred, wt,
+auto total = prim(g, 0u, container_value_fn(wt), container_value_fn(pred),
     neg_weight,        // negated weight function
     std::less<int>{}); // comparator (still min-heap)
 
@@ -350,7 +352,7 @@ size_t                n = num_vertices(g);
 std::vector<uint32_t> pred(n);
 std::vector<int>      wt(n);
 init_shortest_paths(g, wt, pred);
-auto pw = prim(g, 0u, pred, wt);
+auto pw = prim(g, 0u, container_value_fn(wt), container_value_fn(pred));
 
 assert(kw == pw);  // Both produce the same total MST weight
 ```
@@ -359,13 +361,15 @@ assert(kw == pw);  // Both produce the same total MST weight
 
 - **Kruskal:** edge descriptors must have `source_id`, `target_id`, and `value`
   members (or use `edge_descriptor<VId, EV>`)
-- **Prim:** `G` must satisfy `adjacency_list<G>`; `Predecessor` and `Weight`
-  must satisfy `vertex_property_map_for`; `WF` must satisfy
+- **Prim:** `G` must satisfy `adjacency_list<G>`; `WeightFn` must satisfy
+  `distance_fn_for<WeightFn, G>`; `PredecessorFn` must satisfy
+  `predecessor_fn_for<PredecessorFn, G>`; `WF` must satisfy
   `basic_edge_weight_function`
 
 ## Preconditions
 
-- **Prim:** `predecessor` and `weight` must be pre-sized for all vertex IDs.
+- **Prim:** `weight(g, uid)` and `predecessor(g, uid)` must be valid for all vertex IDs.
+  Call `init_shortest_paths(wt, pred)` on the underlying containers first.
   Invalid seed vertex throws `std::out_of_range`.
 - For undirected graphs with Prim, both directions of each edge must be stored.
 
@@ -373,8 +377,8 @@ assert(kw == pw);  // Both produce the same total MST weight
 
 - **Kruskal:** writes MST edges to the output iterator; `inplace_kruskal`
   sorts the input edge list in-place
-- **Prim:** writes predecessor and weight arrays for path reconstruction;
-  does not modify the graph `g`
+- **Prim:** writes weight and predecessor values via `weight(g, v)` and
+  `predecessor(g, v)`; does not modify the graph `g`
 
 ## Returns
 
diff --git a/include/graph/adj_list/detail/graph_cpo.hpp b/include/graph/adj_list/detail/graph_cpo.hpp
index d3ce56f..2bef7ec 100644
--- a/include/graph/adj_list/detail/graph_cpo.hpp
+++ b/include/graph/adj_list/detail/graph_cpo.hpp
@@ -402,7 +402,7 @@ using vertex_id_t = std::remove_cvref_t<
  *
  * For vector-based graphs this is a prvalue (e.g. size_t).
  * For map-based graphs this is an lvalue reference to the stable key (e.g. const std::string&).
- * Used primarily by vertex_id_store_t to select the optimal internal storage strategy.
+ * Allows algorithms to distinguish value-type IDs (integral) from reference IDs (map-based keys).
  */
 template <typename G>
 using raw_vertex_id_t = decltype(vertex_id(std::declval<G&>(), std::declval<vertex_t<G>>()));
diff --git a/include/graph/adj_list/vertex_property_map.hpp b/include/graph/adj_list/vertex_property_map.hpp
index 22b4a3d..61d68aa 100644
--- a/include/graph/adj_list/vertex_property_map.hpp
+++ b/include/graph/adj_list/vertex_property_map.hpp
@@ -168,11 +168,13 @@ template <class Container, bool HasMapped = has_mapped_type_v<Container>>
 struct vertex_property_map_value_impl;
 
 template <class Container>
+requires forward_range<Container>
 struct vertex_property_map_value_impl<Container, true> {
   using type = typename Container::mapped_type;
 };
 
 template <class Container>
+requires random_access_range<Container>
 struct vertex_property_map_value_impl<Container, false> {
   using type = typename Container::value_type;
 };
@@ -204,7 +206,7 @@ using vertex_property_map_value_t = typename detail::vertex_property_map_value_i
  * it never iterates the map as a range.
  *
  * Satisfied by:
- * - vector<T> for index graphs (VId is integral)
+ * - vector<T> / deque<T> for index graphs (VId is integral)
  * - unordered_map<VId, T> / map<VId, T> for mapped graphs
  *
  * @tparam M Container type (e.g. vector<T>, unordered_map<VId, T>)
diff --git a/include/graph/algorithm/bellman_ford_shortest_paths.hpp b/include/graph/algorithm/bellman_ford_shortest_paths.hpp
index fa7730c..8b911c5 100644
--- a/include/graph/algorithm/bellman_ford_shortest_paths.hpp
+++ b/include/graph/algorithm/bellman_ford_shortest_paths.hpp
@@ -85,8 +85,10 @@ void find_negative_cycle(G&                              g,
  * 
  * @tparam G            The graph type. Must satisfy adjacency_list concept (index or mapped).
  * @tparam Sources      Input range of source vertex IDs.
- * @tparam Distances    Vertex property map satisfying vertex_property_map_for<Distances,G>. Value type must be arithmetic.
- * @tparam Predecessors Vertex property map satisfying vertex_property_map_for<Predecessors,G>. Can use null_predecessors
+ * @tparam DistanceFn   Function returning a mutable reference to a per-vertex distance value:
+ *                      (const G&, vertex_id_t<G>) -> Distance&.
+ * @tparam PredecessorFn Function returning a mutable reference to a per-vertex predecessor value:
+ *                      (const G&, vertex_id_t<G>) -> PredecessorValue&. Can use _null_predecessor
  *                      if path reconstruction is not needed.
  * @tparam WF           Edge weight function. Defaults to returning 1 for all edges (unweighted).
  * @tparam Visitor      Visitor type with callbacks for algorithm events. Defaults to empty_visitor.
@@ -96,8 +98,8 @@ void find_negative_cycle(G&                              g,
  * 
  * @param g            The graph to process.
  * @param sources      Range of source vertex IDs to start from.
- * @param distances    [out] Shortest distances from sources. Must be a vertex property map for G.
- * @param predecessor  [out] Predecessor information for path reconstruction. Must be a vertex property map for G.
+ * @param distance     Function to access per-vertex distance: distance(g, uid) -> Distance&.
+ * @param predecessor  Function to access per-vertex predecessor: predecessor(g, uid) -> Predecessor&.
  * @param weight       Edge weight function: (const edge_t<G>&) -> Distance.
  * @param visitor      Visitor for algorithm events (examine, relax, not_relaxed, minimized, not_minimized).
  * @param compare      Distance comparison function: (Distance, Distance) -> bool.
@@ -109,27 +111,27 @@ void find_negative_cycle(G&                              g,
  * **Mandates:**
  * - G must satisfy adjacency_list (index or mapped graphs supported)
  * - Sources must be input_range with values convertible to vertex_id_t<G>
- * - Distances must satisfy vertex_property_map_for<Distances,G> with arithmetic value type
- * - Predecessors must satisfy vertex_property_map_for<Predecessors,G> (or null_predecessors)
+ * - DistanceFn must satisfy distance_fn_for<DistanceFn, G>
+ * - PredecessorFn must satisfy predecessor_fn_for<PredecessorFn, G> (or be _null_predecessor_fn)
  * - WF must satisfy basic_edge_weight_function
  * 
  * **Preconditions:**
- * - All source vertices must be valid vertex IDs in vertices(g)
- * - distances must contain an entry for each vertex of g
- * - predecessor must contain an entry for each vertex of g (unless using null_predecessors)
+ * - All source vertices must be valid vertex IDs in the graph
+ * - distance(g, uid) must be valid for all vertex IDs in the graph
+ * - predecessor(g, uid) must be valid for all vertex IDs in the graph (unless using _null_predecessor)
  * - Weight function must not throw or modify graph state
  * 
  * **Effects:**
- * - Modifies distances: Sets distances[v] for all vertices v
- * - Modifies predecessor: Sets predecessor[v] for all processed edges
+ * - Sets distance(g, v) for all vertices v via the distance function
+ * - Sets predecessor(g, v) for all processed edges via the predecessor function
  * - Does not modify the graph g
  * 
  * **Postconditions:**
- * - distances[s] == 0 for all sources s
- * - If no negative cycle: For reachable v, distances[v] contains shortest distance from nearest source
- * - If no negative cycle: For reachable v, predecessor[v] contains predecessor in shortest path tree
- * - If negative cycle detected: distances and predecessor may contain intermediate values
- * - For unreachable vertices v: distances[v] == numeric_limits<Distance>::max()
+ * - distance(g, s) == 0 for all sources s
+ * - If no negative cycle: For reachable v, distance(g, v) contains shortest distance from nearest source
+ * - If no negative cycle: For reachable v, predecessor(g, v) contains predecessor in shortest path tree
+ * - If negative cycle detected: distance and predecessor values may be intermediate (indeterminate)
+ * - For unreachable vertices v: distance(g, v) == infinite_distance<Distance>()
  * 
  * **Returns:**
  * - optional<vertex_id_t<G>>: empty if no negative cycle detected; contains a vertex ID in the
@@ -189,7 +191,7 @@ void find_negative_cycle(G&                              g,
  *     // Weighted directed graph with a negative edge: 0 --(4.0)--> 1 --(-2.0)--> 2 --(3.0)--> 3
  *     Graph g({{0,1,4.0},{1,2,-2.0},{2,3,3.0}});
  *
- *     constexpr auto INF = std::numeric_limits<double>::max();
+ *     constexpr auto INF = infinite_distance<double>();
  *     std::vector<double>   dist(num_vertices(g), INF);
  *     std::vector<uint32_t> pred(num_vertices(g), 0);
  *
@@ -212,74 +214,56 @@ void find_negative_cycle(G&                              g,
 template <
       adjacency_list G,
       input_range    Sources,
-      class Distances,
-      class Predecessors,
-      class WF = function<vertex_property_map_value_t<Distances>(const std::remove_reference_t<G>&, const edge_t<G>&)>,
+      class DistanceFn,
+      class PredecessorFn,
+      class WF = function<distance_fn_value_t<DistanceFn, G>(const std::remove_reference_t<G>&, const edge_t<G>&)>,
       class Visitor = empty_visitor,
-      class Compare = less<vertex_property_map_value_t<Distances>>,
-      class Combine = plus<vertex_property_map_value_t<Distances>>>
-requires vertex_property_map_for<Distances, G> &&                                       //
-         (is_null_range_v<Predecessors> || vertex_property_map_for<Predecessors, G>) && //
-         convertible_to<range_value_t<Sources>, vertex_id_t<G>> &&                      //
-         is_arithmetic_v<vertex_property_map_value_t<Distances>> &&                     //
-         basic_edge_weight_function<G, WF, vertex_property_map_value_t<Distances>, Compare, Combine>
+      class Compare = less<distance_fn_value_t<DistanceFn, G>>,
+      class Combine = plus<distance_fn_value_t<DistanceFn, G>>>
+requires distance_fn_for<DistanceFn, G> &&                                //
+         predecessor_fn_for<PredecessorFn, G> &&                          //
+         convertible_to<range_value_t<Sources>, vertex_id_t<G>> &&              //
+         basic_edge_weight_function<G, WF, distance_fn_value_t<DistanceFn, G>, Compare, Combine>
 [[nodiscard]] constexpr optional<vertex_id_t<G>> bellman_ford_shortest_paths(
-      G&&            g,
-      const Sources& sources,
-      Distances&     distances,
-      Predecessors&  predecessor,
-      WF&&           weight =
+      G&&             g,
+      const Sources&  sources,
+      DistanceFn&&    distance,
+      PredecessorFn&& predecessor,
+      WF&&            weight =
             [](const auto&, const edge_t<G>& uv) {
-              return vertex_property_map_value_t<Distances>(1);
+              return distance_fn_value_t<DistanceFn, G>(1);
             }, // default weight(g, uv) -> 1
       Visitor&& visitor = empty_visitor(),
-      Compare&& compare = less<vertex_property_map_value_t<Distances>>(),
-      Combine&& combine = plus<vertex_property_map_value_t<Distances>>()) {
+      Compare&& compare = less<distance_fn_value_t<DistanceFn, G>>(),
+      Combine&& combine = plus<distance_fn_value_t<DistanceFn, G>>()) {
   using graph_type    = std::remove_reference_t<G>;
   using id_type       = vertex_id_t<graph_type>;
-  using DistanceValue = vertex_property_map_value_t<Distances>;
+  using DistanceValue = distance_fn_value_t<DistanceFn, G>;
   using weight_type   = invoke_result_t<WF, const graph_type&, edge_t<graph_type>>;
   using return_type   = optional<vertex_id_t<graph_type>>;
 
-  constexpr auto zero     = shortest_path_zero<DistanceValue>();
-  constexpr auto infinite = shortest_path_infinite_distance<DistanceValue>();
+  constexpr auto zero     = zero_distance<DistanceValue>();
+  constexpr auto infinite = infinite_distance<DistanceValue>();
 
   // relaxing the target is the function of reducing the distance from the source to the target
-  auto relax_target = [&g, &predecessor, &distances, &compare, &combine] //
+  auto relax_target = [&g, &predecessor, &distance, &compare, &combine] //
         (const edge_t<graph_type>& e, const vertex_id_t<graph_type>& uid, const weight_type& w_e) -> bool {
     const id_type       vid = target_id(g, e);
-    const DistanceValue d_u = distances[uid];
+    const DistanceValue d_u = distance(g, uid);
     if (d_u == infinite)
       return false; // Cannot relax via unreachable vertex (also guards against overflow)
-    const DistanceValue d_v = distances[vid];
+    const DistanceValue d_v = distance(g, vid);
 
     if (compare(combine(d_u, w_e), d_v)) {
-      distances[vid] = combine(d_u, w_e);
-      if constexpr (!is_null_range_v<Predecessors>) {
-        predecessor[vid] = uid;
+      distance(g, vid) = combine(d_u, w_e);
+      if constexpr (!is_null_predecessor_fn_v<PredecessorFn>) {
+        predecessor(g, vid) = uid;
       }
       return true;
     }
     return false;
   };
 
-  // Validate preconditions: source vertices must be valid, distances and predecessor must be sized appropriately
-  if constexpr (index_vertex_range<graph_type>) {
-    if (size(distances) < num_vertices(g)) {
-      throw std::out_of_range(
-            std::format("bellman_ford_shortest_paths: size of distances of {} is less than the number of vertices {}",
-                        size(distances), num_vertices(g)));
-    }
-
-    if constexpr (!is_null_range_v<Predecessors>) {
-      if (size(predecessor) < num_vertices(g)) {
-        throw std::out_of_range(std::format(
-              "bellman_ford_shortest_paths: size of predecessor of {} is less than the number of vertices {}",
-              size(predecessor), num_vertices(g)));
-      }
-    }
-  }
-
   // Seed the queue with the initial vertices
   for (auto&& seed_id : sources) {
     auto seed_it = find_vertex(g, seed_id);
@@ -288,7 +272,7 @@ requires vertex_property_map_for<Distances, G> &&
             std::format("bellman_ford_shortest_paths: source vertex id '{}' is out of range", seed_id));
     }
 
-    distances[seed_id] = zero; // mark source as discovered
+    distance(g, seed_id) = zero; // mark source as discovered
     if constexpr (has_on_discover_vertex<graph_type, Visitor>) {
       visitor.on_discover_vertex(g, *seed_it);
     } else if constexpr (has_on_discover_vertex_id<graph_type, Visitor>) {
@@ -321,9 +305,9 @@ requires vertex_property_map_for<Distances, G> &&
   // Check for negative weight cycles
   if (at_least_one_edge_relaxed) {
     for (auto&& [uid, vid, uv, uv_w] : views::edgelist(g, weight)) {
-      if (compare(combine(distances[uid], uv_w), distances[vid])) {
-        if constexpr (!is_null_range_v<Predecessors>) {
-          predecessor[vid] = uid; // close the cycle
+      if (compare(combine(distance(g, uid), uv_w), distance(g, vid))) {
+        if constexpr (!is_null_predecessor_fn_v<PredecessorFn>) {
+          predecessor(g, vid) = uid; // close the cycle
         }
         if constexpr (has_on_edge_not_minimized<graph_type, Visitor>) {
           visitor.on_edge_not_minimized(g, uv);
@@ -353,29 +337,28 @@ requires vertex_property_map_for<Distances, G> &&
  */
 template <
       adjacency_list G,
-      class Distances,
-      class Predecessors,
-      class WF = function<vertex_property_map_value_t<Distances>(const std::remove_reference_t<G>&, const edge_t<G>&)>,
+      class DistanceFn,
+      class PredecessorFn,
+      class WF = function<distance_fn_value_t<DistanceFn, G>(const std::remove_reference_t<G>&, const edge_t<G>&)>,
       class Visitor = empty_visitor,
-      class Compare = less<vertex_property_map_value_t<Distances>>,
-      class Combine = plus<vertex_property_map_value_t<Distances>>>
-requires vertex_property_map_for<Distances, G> &&                                       //
-         (is_null_range_v<Predecessors> || vertex_property_map_for<Predecessors, G>) && //
-         is_arithmetic_v<vertex_property_map_value_t<Distances>> &&                     //
-         basic_edge_weight_function<G, WF, vertex_property_map_value_t<Distances>, Compare, Combine>
+      class Compare = less<distance_fn_value_t<DistanceFn, G>>,
+      class Combine = plus<distance_fn_value_t<DistanceFn, G>>>
+requires distance_fn_for<DistanceFn, G> &&                                //
+         predecessor_fn_for<PredecessorFn, G> &&                          //
+         basic_edge_weight_function<G, WF, distance_fn_value_t<DistanceFn, G>, Compare, Combine>
 [[nodiscard]] constexpr optional<vertex_id_t<G>> bellman_ford_shortest_paths(
       G&&                   g,
       const vertex_id_t<G>& source,
-      Distances&            distances,
-      Predecessors&         predecessor,
+      DistanceFn&&          distance,
+      PredecessorFn&&       predecessor,
       WF&&                  weight =
             [](const auto&, const edge_t<G>& uv) {
-              return vertex_property_map_value_t<Distances>(1);
+              return distance_fn_value_t<DistanceFn, G>(1);
             }, // default weight(g, uv) -> 1
       Visitor&& visitor = empty_visitor(),
-      Compare&& compare = less<vertex_property_map_value_t<Distances>>(),
-      Combine&& combine = plus<vertex_property_map_value_t<Distances>>()) {
-  return bellman_ford_shortest_paths(g, subrange(&source, (&source + 1)), distances, predecessor, weight,
+      Compare&& compare = less<distance_fn_value_t<DistanceFn, G>>(),
+      Combine&& combine = plus<distance_fn_value_t<DistanceFn, G>>()) {
+  return bellman_ford_shortest_paths(g, subrange(&source, (&source + 1)), distance, predecessor, weight,
                                      forward<Visitor>(visitor), forward<Compare>(compare), forward<Combine>(combine));
 }
 
@@ -415,27 +398,26 @@ requires vertex_property_map_for<Distances, G> &&
 template <
       adjacency_list G,
       input_range    Sources,
-      class Distances,
-      class WF = function<vertex_property_map_value_t<Distances>(const std::remove_reference_t<G>&, const edge_t<G>&)>,
+      class DistanceFn,
+      class WF = function<distance_fn_value_t<DistanceFn, G>(const std::remove_reference_t<G>&, const edge_t<G>&)>,
       class Visitor = empty_visitor,
-      class Compare = less<vertex_property_map_value_t<Distances>>,
-      class Combine = plus<vertex_property_map_value_t<Distances>>>
-requires vertex_property_map_for<Distances, G> &&                   //
-         convertible_to<range_value_t<Sources>, vertex_id_t<G>> &&  //
-         is_arithmetic_v<vertex_property_map_value_t<Distances>> && //
-         basic_edge_weight_function<G, WF, vertex_property_map_value_t<Distances>, Compare, Combine>
+      class Compare = less<distance_fn_value_t<DistanceFn, G>>,
+      class Combine = plus<distance_fn_value_t<DistanceFn, G>>>
+requires distance_fn_for<DistanceFn, G> &&                                //
+         convertible_to<range_value_t<Sources>, vertex_id_t<G>> &&              //
+         basic_edge_weight_function<G, WF, distance_fn_value_t<DistanceFn, G>, Compare, Combine>
 [[nodiscard]] constexpr optional<vertex_id_t<G>> bellman_ford_shortest_distances(
       G&&            g,
       const Sources& sources,
-      Distances&     distances,
+      DistanceFn&&   distance,
       WF&&           weight =
             [](const auto&, const edge_t<G>& uv) {
-              return vertex_property_map_value_t<Distances>(1);
+              return distance_fn_value_t<DistanceFn, G>(1);
             }, // default weight(g, uv) -> 1
       Visitor&& visitor = empty_visitor(),
-      Compare&& compare = less<vertex_property_map_value_t<Distances>>(),
-      Combine&& combine = plus<vertex_property_map_value_t<Distances>>()) {
-  return bellman_ford_shortest_paths(g, sources, distances, _null_predecessors, forward<WF>(weight),
+      Compare&& compare = less<distance_fn_value_t<DistanceFn, G>>(),
+      Combine&& combine = plus<distance_fn_value_t<DistanceFn, G>>()) {
+  return bellman_ford_shortest_paths(g, sources, distance, _null_predecessor, forward<WF>(weight),
                                      forward<Visitor>(visitor), forward<Compare>(compare), forward<Combine>(combine));
 }
 
@@ -452,26 +434,25 @@ requires vertex_property_map_for<Distances, G> &&                   //
  */
 template <
       adjacency_list G,
-      class Distances,
-      class WF = function<vertex_property_map_value_t<Distances>(const std::remove_reference_t<G>&, const edge_t<G>&)>,
+      class DistanceFn,
+      class WF = function<distance_fn_value_t<DistanceFn, G>(const std::remove_reference_t<G>&, const edge_t<G>&)>,
       class Visitor = empty_visitor,
-      class Compare = less<vertex_property_map_value_t<Distances>>,
-      class Combine = plus<vertex_property_map_value_t<Distances>>>
-requires vertex_property_map_for<Distances, G> &&                   //
-         is_arithmetic_v<vertex_property_map_value_t<Distances>> && //
-         basic_edge_weight_function<G, WF, vertex_property_map_value_t<Distances>, Compare, Combine>
+      class Compare = less<distance_fn_value_t<DistanceFn, G>>,
+      class Combine = plus<distance_fn_value_t<DistanceFn, G>>>
+requires distance_fn_for<DistanceFn, G> &&                                //
+         basic_edge_weight_function<G, WF, distance_fn_value_t<DistanceFn, G>, Compare, Combine>
 [[nodiscard]] constexpr optional<vertex_id_t<G>> bellman_ford_shortest_distances(
       G&&                   g,
       const vertex_id_t<G>& source,
-      Distances&            distances,
+      DistanceFn&&          distance,
       WF&&                  weight =
             [](const auto&, const edge_t<G>& uv) {
-              return vertex_property_map_value_t<Distances>(1);
+              return distance_fn_value_t<DistanceFn, G>(1);
             }, // default weight(g, uv) -> 1
       Visitor&& visitor = empty_visitor(),
-      Compare&& compare = less<vertex_property_map_value_t<Distances>>(),
-      Combine&& combine = plus<vertex_property_map_value_t<Distances>>()) {
-  return bellman_ford_shortest_paths(g, subrange(&source, (&source + 1)), distances, _null_predecessors,
+      Compare&& compare = less<distance_fn_value_t<DistanceFn, G>>(),
+      Combine&& combine = plus<distance_fn_value_t<DistanceFn, G>>()) {
+  return bellman_ford_shortest_paths(g, subrange(&source, (&source + 1)), distance, _null_predecessor,
                                      forward<WF>(weight), forward<Visitor>(visitor), forward<Compare>(compare),
                                      forward<Combine>(combine));
 }
diff --git a/include/graph/algorithm/connected_components.hpp b/include/graph/algorithm/connected_components.hpp
index fb0b504..c629c45 100644
--- a/include/graph/algorithm/connected_components.hpp
+++ b/include/graph/algorithm/connected_components.hpp
@@ -26,6 +26,7 @@
 #include <stack>
 #include <random>
 #include <numeric>
+#include "graph/algorithm/traversal_common.hpp"
 
 #ifndef GRAPH_CC_HPP
 #  define GRAPH_CC_HPP
@@ -59,18 +60,21 @@ using adj_list::target_id;
  * 
  * @tparam G Graph type (must satisfy index_adjacency_list concept)
  * @tparam GT Graph transpose type (must satisfy index_adjacency_list concept)
- * @tparam Component Random access range for component IDs
+ * @tparam ComponentFn Callable providing per-vertex component ID access:
+ *                     (const G&, vertex_id_t<G>) -> ComponentID&. Must satisfy
+ *                     vertex_property_fn_for<ComponentFn, G>.
  * 
  * @param g The directed graph to analyze
  * @param g_t The transpose of graph g (edges reversed)
- * @param component Output: component[v] = component ID for vertex v
+ * @param component Callable providing per-vertex component access: component(g, uid) -> ComponentID&.
+ *                  For containers: wrap with container_value_fn(c).
  * 
  * @return void. Results are stored in the component output parameter.
  * 
  * **Mandates:**
  * - G must satisfy adjacency_list
  * - GT must satisfy adjacency_list
- * - Component must satisfy vertex_property_map_for<Component, G>
+ * - ComponentFn must satisfy vertex_property_fn_for<ComponentFn, G>
  * 
  * **Preconditions:**
  * - component must contain an entry for each vertex of g
@@ -78,11 +82,11 @@ using adj_list::target_id;
  * - g_t is the transpose of g (all edges reversed)
  * 
  * **Effects:**
- * - Modifies component: Sets component[v] for all vertices v
+ * - Sets component(g, uid) for all vertices via the component function
  * - Does not modify graphs g or g_t
  * 
  * **Postconditions:**
- * - component[v] contains the SCC ID for vertex v
+ * - component(g, uid) contains the SCC ID for vertex uid
  * - Component IDs are assigned 0, 1, 2, ..., num_components-1
  * - Vertices in the same SCC have the same component ID
  * 
@@ -125,7 +129,7 @@ using adj_list::target_id;
  * Graph g_t = transpose(g);
  *
  * std::vector<size_t> component(num_vertices(g));
- * kosaraju(g, g_t, component);
+ * kosaraju(g, g_t, container_value_fn(component));
  * // component = {0, 0, 0, 1}
  * ```
  *
@@ -134,18 +138,17 @@ using adj_list::target_id;
  */
 template <adjacency_list G,
           adjacency_list GT,
-          class           Component>
-requires vertex_property_map_for<Component, G>
-void kosaraju(G&&        g,        // graph
-              GT&&       g_t,      // graph transpose
-              Component& component // out: strongly connected component assignment
-
+          class          ComponentFn>
+requires vertex_property_fn_for<ComponentFn, G>
+void kosaraju(G&&           g,         // graph
+              GT&&          g_t,       // graph transpose
+              ComponentFn&& component  // out: strongly connected component assignment
 ) {
-  using CT = vertex_property_map_value_t<Component>;
+  using CT = vertex_fn_value_t<ComponentFn, G>;
   auto visited = make_vertex_property_map<std::remove_reference_t<G>, bool>(g, false);
   // Initialize all components as unvisited
   for (auto&& [uid, u] : views::vertexlist(g)) {
-    component[uid] = std::numeric_limits<CT>::max();
+    component(g, uid) = std::numeric_limits<CT>::max();
   }
   // Order stores vertex IDs (not descriptors) because the second pass
   // operates on g_t which has different descriptors than g.
@@ -199,19 +202,19 @@ void kosaraju(G&&        g,        // graph
   size_t                    cid = 0;
   std::ranges::reverse_view reverse{order};
   for (auto& uid : reverse) {
-    if (component[uid] == std::numeric_limits<CT>::max()) {
+    if (component(g, uid) == std::numeric_limits<CT>::max()) {
       // Manual iterative DFS on transpose graph using descriptors
       std::stack<gt_vertex_desc> dfs_stack;
       dfs_stack.push(*find_vertex(g_t, uid));
-      component[uid] = cid;
+      component(g, uid) = cid;
 
       while (!dfs_stack.empty()) {
         auto current = dfs_stack.top();
         dfs_stack.pop();
 
         for (auto&& [vid, e] : views::incidence(g_t, current)) {
-          if (component[vid] == std::numeric_limits<CT>::max()) {
-            component[vid] = cid; // Assign to current SCC
+          if (component(g, vid) == std::numeric_limits<CT>::max()) {
+            component(g, vid) = cid; // Assign to current SCC
             dfs_stack.push(*find_vertex(g_t, vid));
           }
         }
@@ -234,26 +237,29 @@ void kosaraju(G&&        g,        // graph
  * storing the transpose.  Works with both index and mapped bidirectional graphs.
  * 
  * @tparam G Graph type (must satisfy bidirectional_adjacency_list concept)
- * @tparam Component Vertex property map satisfying vertex_property_map_for<Component,G>
+ * @tparam ComponentFn Callable providing per-vertex component ID access:
+ *                     (const G&, vertex_id_t<G>) -> ComponentID&. Must satisfy
+ *                     vertex_property_fn_for<ComponentFn, G>.
  * 
  * @param g The directed bidirectional graph to analyze
- * @param component Output: component[v] = component ID for vertex v
+ * @param component Callable providing per-vertex component access: component(g, uid) -> ComponentID&.
+ *                  For containers: wrap with container_value_fn(c).
  * 
  * @return void. Results are stored in the component output parameter.
  * 
  * **Mandates:**
  * - G must satisfy bidirectional_adjacency_list
- * - Component must satisfy vertex_property_map_for<Component, G>
+ * - ComponentFn must satisfy vertex_property_fn_for<ComponentFn, G>
  * 
  * **Preconditions:**
  * - component must contain an entry for each vertex of g
  * 
  * **Effects:**
- * - Modifies component: Sets component[v] for all vertices v
+ * - Sets component(g, uid) for all vertices via the component function
  * - Does not modify the graph g
  * 
  * **Postconditions:**
- * - component[v] contains the SCC ID for vertex v
+ * - component(g, uid) contains the SCC ID for vertex uid
  * - Component IDs are assigned 0, 1, 2, ..., num_components-1
  * - Vertices in the same SCC have the same component ID
  * 
@@ -272,22 +278,22 @@ void kosaraju(G&&        g,        // graph
  * container::dynamic_graph<Traits> g({{0,1}, {1,2}, {2,0}, {2,3}});
  *
  * std::vector<size_t> component(num_vertices(g));
- * kosaraju(g, component);  // No transpose needed!
+ * kosaraju(g, container_value_fn(component));  // No transpose needed!
  * ```
  *
  * @see kosaraju(G&&, GT&&, Component&) For non-bidirectional graphs
  */
 template <bidirectional_adjacency_list G,
-          class                         Component>
-requires vertex_property_map_for<Component, G>
-void kosaraju(G&&        g,        // bidirectional graph
-              Component& component // out: strongly connected component assignment
+          class                        ComponentFn>
+requires vertex_property_fn_for<ComponentFn, G>
+void kosaraju(G&&           g,         // bidirectional graph
+              ComponentFn&& component  // out: strongly connected component assignment
 ) {
-  using CT = vertex_property_map_value_t<Component>;
+  using CT = vertex_fn_value_t<ComponentFn, G>;
   auto visited = make_vertex_property_map<std::remove_reference_t<G>, bool>(g, false);
   // Initialize all components as unvisited
   for (auto&& [uid, u] : views::vertexlist(g)) {
-    component[uid] = std::numeric_limits<CT>::max();
+    component(g, uid) = std::numeric_limits<CT>::max();
   }
   // Both passes use the same graph, so descriptors are valid throughout.
   using vertex_desc = vertex_t<std::remove_reference_t<G>>;
@@ -333,11 +339,11 @@ void kosaraju(G&&        g,        // bidirectional graph
   std::ranges::reverse_view reverse{order};
   for (auto& u : reverse) {
     auto uid = vertex_id(g_ref, u);
-    if (component[uid] == std::numeric_limits<CT>::max()) {
+    if (component(g, uid) == std::numeric_limits<CT>::max()) {
       // Manual iterative DFS using in_edges + source_id, storing descriptors
       std::stack<vertex_desc> dfs_stack;
       dfs_stack.push(u);
-      component[uid] = cid;
+      component(g, uid) = cid;
 
       while (!dfs_stack.empty()) {
         auto current = dfs_stack.top();
@@ -345,8 +351,8 @@ void kosaraju(G&&        g,        // bidirectional graph
 
         for (auto&& ie : adj_list::in_edges(g_ref, current)) {
           auto src = adj_list::source_id(g_ref, ie);
-          if (component[src] == std::numeric_limits<CT>::max()) {
-            component[src] = cid;
+          if (component(g, src) == std::numeric_limits<CT>::max()) {
+            component(g, src) = cid;
             dfs_stack.push(*adj_list::find_vertex(g_ref, src));
           }
         }
@@ -368,26 +374,29 @@ void kosaraju(G&&        g,        // bidirectional graph
  * with an explicit stack to identify all connected components in the graph.
  * 
  * @tparam G Graph type (must satisfy index_adjacency_list concept)
- * @tparam Component Random access range for component IDs
+ * @tparam ComponentFn Callable providing per-vertex component ID access:
+ *                     (const G&, vertex_id_t<G>) -> ComponentID&. Must satisfy
+ *                     vertex_property_fn_for<ComponentFn, G>.
  * 
  * @param g The graph to analyze (treated as undirected)
- * @param component Output: component[v] = component ID for vertex v
+ * @param component Callable providing per-vertex component access: component(g, uid) -> ComponentID&.
+ *                  For containers: wrap with container_value_fn(c).
  * 
  * @return Number of connected components found
  * 
  * **Mandates:**
  * - G must satisfy adjacency_list
- * - Component must satisfy vertex_property_map_for<Component, G>
+ * - ComponentFn must satisfy vertex_property_fn_for<ComponentFn, G>
  * 
  * **Preconditions:**
  * - component must contain an entry for each vertex of g
  * 
  * **Effects:**
- * - Modifies component: Sets component[v] for all vertices v
+ * - Modifies component: Sets component(g, uid) for all vertices
  * - Does not modify the graph g
  * 
  * **Postconditions:**
- * - component[v] contains the component ID for vertex v
+ * - component(g, uid) contains the component ID for vertex uid
  * - Component IDs are assigned 0, 1, 2, ..., num_components-1
  * - Vertices in the same component have the same component ID
  * - Return value equals the number of distinct component IDs
@@ -435,7 +444,7 @@ void kosaraju(G&&        g,        // bidirectional graph
  * g.add_edge(3, 4);                     // Component 2: {3,4}
  *
  * std::vector<size_t> component(num_vertices(g));
- * size_t num = connected_components(g, component);
+ * size_t num = connected_components(g, container_value_fn(component));
  * // num = 2, component = {0, 0, 0, 1, 1}
  * ```
  *
@@ -443,15 +452,15 @@ void kosaraju(G&&        g,        // bidirectional graph
  * @see afforest For faster parallel-friendly alternative
  */
 template <adjacency_list G,
-          class          Component>
-requires vertex_property_map_for<Component, G>
-size_t connected_components(G&&        g,        // graph
-                            Component& component // out: connected component assignment
+          class          ComponentFn>
+requires vertex_property_fn_for<ComponentFn, G>
+size_t connected_components(G&&           g,         // graph
+                            ComponentFn&& component  // out: connected component assignment
 ) {
-  using CT = vertex_property_map_value_t<Component>;
+  using CT = vertex_fn_value_t<ComponentFn, G>;
   // Initialize all components as unvisited
   for (auto&& [uid, u] : views::vertexlist(g)) {
-    component[uid] = std::numeric_limits<CT>::max();
+    component(g, uid) = std::numeric_limits<CT>::max();
   }
 
   // Stack of vertex descriptors — lightweight (8 bytes), avoids string copies,
@@ -460,26 +469,26 @@ size_t connected_components(G&&        g,        // graph
   std::stack<vertex_desc> S;
   CT                      cid = 0; // Current component ID
   for (auto&& [uid, u] : views::vertexlist(g)) {
-    if (component[uid] < std::numeric_limits<CT>::max()) {
+    if (component(g, uid) < std::numeric_limits<CT>::max()) {
       continue; // Already assigned to a component
     }
 
     // Handle isolated vertices (no edges)
     if (!num_edges(g, uid)) {
-      component[uid] = cid++;
+      component(g, uid) = cid++;
       continue;
     }
 
     // Start DFS for new component
-    component[uid] = cid;
+    component(g, uid) = cid;
     S.push(u);
     while (!S.empty()) {
       auto v = S.top();
       S.pop();
       // Visit all unvisited neighbors and add to same component
       for (auto&& [wid, e] : views::incidence(g, v)) {
-        if (component[wid] == std::numeric_limits<CT>::max()) {
-          component[wid] = cid; // Same component as parent
+        if (component(g, wid) == std::numeric_limits<CT>::max()) {
+          component(g, wid) = cid; // Same component as parent
           S.push(*find_vertex(g, wid));
         }
       }
diff --git a/include/graph/algorithm/dijkstra_shortest_paths.hpp b/include/graph/algorithm/dijkstra_shortest_paths.hpp
index 2a395da..4bdf3e8 100644
--- a/include/graph/algorithm/dijkstra_shortest_paths.hpp
+++ b/include/graph/algorithm/dijkstra_shortest_paths.hpp
@@ -44,10 +44,15 @@ using adj_list::index_vertex_range;
  * with non-negative edge weights. Supports custom weight functions, comparison operators, and 
  * visitor callbacks for algorithm events.
  * 
+ * Distance and predecessor are accessed through functions distance(g, uid) and predecessor(g, uid)
+ * respectively, enabling the values to reside on vertex properties or in external containers.
+ * 
  * @tparam G            The graph type. Must satisfy adjacency_list concept.
  * @tparam Sources      Input range of source vertex IDs.
- * @tparam Distances    Container for storing distances (vector for index graphs, unordered_map for mapped).
- * @tparam Predecessors Container for storing predecessor information. Can use _null_predecessors
+ * @tparam DistanceFn   Function returning a mutable reference to a per-vertex distance value:
+ *                      (const G&, vertex_id_t<G>) -> Distance&. Must return an arithmetic type.
+ * @tparam PredecessorFn Function returning a mutable reference to a per-vertex predecessor value:
+ *                      (const G&, vertex_id_t<G>) -> PredecessorValue&. Can use _null_predecessor
  *                      if path reconstruction is not needed.
  * @tparam WF           Edge weight function. Defaults to returning 1 for all edges (unweighted).
  * @tparam Visitor      Visitor type with callbacks for algorithm events. Defaults to empty_visitor.
@@ -57,48 +62,46 @@ using adj_list::index_vertex_range;
  * 
  * @param g            The graph to process.
  * @param sources      Range of source vertex IDs to start from.
- * @param distances    [out] Shortest distances from sources. Must be sized >= num_vertices(g).
- * @param predecessor  [out] Predecessor information for path reconstruction. Must be sized >= num_vertices(g).
- * @param weight       Edge weight function: (const edge_t<G>&) -> Distance.
+ * @param distance     Function to access per-vertex distance: distance(g, uid) -> Distance&.
+ * @param predecessor  Function to access per-vertex predecessor: predecessor(g, uid) -> Predecessor&.
+ * @param weight       Edge weight function: (const G&, const edge_t<G>&) -> Distance.
  * @param visitor      Visitor for algorithm events (discover, examine, relax, finish).
  * @param compare      Distance comparison function: (Distance, Distance) -> bool.
  * @param combine      Distance combination function: (Distance, Weight) -> Distance.
  * 
- * @return void. Results are stored in the distances and predecessor output parameters.
+ * @return void. Results are stored via the distance and predecessor functions.
  * 
  * **Mandates:**
  * - G must satisfy adjacency_list (index or mapped vertex containers)
  * - Sources must be input_range with values convertible to vertex_id_t<G>
- * - Distances must satisfy vertex_property_map_for<Distances, G> (subscriptable by vertex_id_t<G>) with arithmetic value type
- * - Predecessors must satisfy vertex_property_map_for<Predecessors, G> (or be _null_predecessors)
+ * - DistanceFn must satisfy distance_fn_for<DistanceFn, G>
+ * - PredecessorFn must satisfy predecessor_fn_for<PredecessorFn, G> (or be _null_predecessor_fn)
  * - WF must satisfy basic_edge_weight_function
  * 
  * **Preconditions:**
  * - All source vertices must be valid vertex IDs in the graph
- * - For index graphs: distances.size() >= num_vertices(g)
- * - For index graphs: predecessor.size() >= num_vertices(g) (unless using _null_predecessors)
- * - For mapped graphs: distances and predecessors must be eagerly initialized for all vertices
+ * - distance(g, uid) must be valid for all vertex IDs in the graph
+ * - predecessor(g, uid) must be valid for all vertex IDs in the graph (unless using _null_predecessor)
  * - All edge weights must be non-negative
  * - Weight function must not throw or modify graph state
  * 
  * **Effects:**
- * - Modifies distances: Sets distances[v] for all vertices v
- * - Modifies predecessor: Sets predecessor[v] for all reachable vertices
+ * - Sets distance(g, v) for all vertices v via the distance function
+ * - Sets predecessor(g, v) for all reachable vertices via the predecessor function
  * - Does not modify the graph g
  * 
  * **Postconditions:**
- * - distances[s] == 0 for all sources s
- * - For reachable vertices v: distances[v] contains shortest distance from nearest source
- * - For reachable vertices v: predecessor[v] contains predecessor in shortest path tree
- * - For unreachable vertices v: distances[v] == numeric_limits<Distance>::max()
+ * - distance(g, s) == 0 for all sources s
+ * - For reachable vertices v: distance(g, v) contains shortest distance from nearest source
+ * - For reachable vertices v: predecessor(g, v) contains predecessor in shortest path tree
+ * - For unreachable vertices v: distance(g, v) == infinite_distance<Distance>()
  * 
  * **Throws:**
  * - std::out_of_range if a source vertex ID is out of range
- * - std::out_of_range if distances or predecessor are undersized
  * - std::out_of_range if a negative edge weight is encountered (for signed weight types)
  * - std::logic_error if internal invariant violation detected
  * - Exception guarantee: Basic. If an exception is thrown, graph g remains unchanged;
- *   distances and predecessor may be partially modified (indeterminate state).
+ *   distance and predecessor values may be partially modified (indeterminate state).
  * 
  * **Complexity:**
  * - Time: O((V + E) log V) using binary heap priority queue
@@ -145,11 +148,13 @@ using adj_list::index_vertex_range;
  *     // Weighted directed graph: 0 --(1.0)--> 1 --(2.0)--> 2 --(3.0)--> 3
  *     Graph g({{0,1,1.0},{1,2,2.0},{2,3,3.0}});
  *
- *     constexpr auto INF = std::numeric_limits<double>::max();
+ *     constexpr auto INF = infinite_distance<double>();
  *     std::vector<double>   dist(num_vertices(g), INF);
  *     std::vector<uint32_t> pred(num_vertices(g), 0);
  *
- *     dijkstra_shortest_paths(g, 0u, dist, pred);
+ *     dijkstra_shortest_paths(g, 0u,
+ *         [&dist](const auto&, auto uid) -> double& { return dist[uid]; },
+ *         [&pred](const auto&, auto uid) -> uint32_t& { return pred[uid]; });
  *     // dist == {0.0, 1.0, 3.0, 6.0}
  * }
  * ```
@@ -164,43 +169,42 @@ using adj_list::index_vertex_range;
 template <
       adjacency_list G,
       input_range    Sources,
-      class Distances,
-      class Predecessors,
-      class WF = function<vertex_property_map_value_t<Distances>(const std::remove_reference_t<G>&, const edge_t<G>&)>,
+      class DistanceFn,
+      class PredecessorFn,
+      class WF = function<distance_fn_value_t<DistanceFn, G>(const std::remove_reference_t<G>&, const edge_t<G>&)>,
       class Visitor = empty_visitor,
-      class Compare = less<vertex_property_map_value_t<Distances>>,
-      class Combine = plus<vertex_property_map_value_t<Distances>>>
-requires vertex_property_map_for<Distances, G> &&                                       //
-         (is_null_range_v<Predecessors> || vertex_property_map_for<Predecessors, G>) && //
-         convertible_to<range_value_t<Sources>, vertex_id_t<G>> &&                      //
-         is_arithmetic_v<vertex_property_map_value_t<Distances>> &&                     //
-         basic_edge_weight_function<G, WF, vertex_property_map_value_t<Distances>, Compare, Combine>
+      class Compare = less<distance_fn_value_t<DistanceFn, G>>,
+      class Combine = plus<distance_fn_value_t<DistanceFn, G>>>
+requires distance_fn_for<DistanceFn, G> &&                                //
+         predecessor_fn_for<PredecessorFn, G> &&                          //
+         convertible_to<range_value_t<Sources>, vertex_id_t<G>> &&              //
+         basic_edge_weight_function<G, WF, distance_fn_value_t<DistanceFn, G>, Compare, Combine>
 constexpr void dijkstra_shortest_paths(
-      G&&            g,
-      const Sources& sources,
-      Distances&     distances,
-      Predecessors&  predecessor,
-      WF&&           weight =
+      G&&             g,
+      const Sources&  sources,
+      DistanceFn&&    distance,
+      PredecessorFn&& predecessor,
+      WF&&            weight =
             [](const auto&, const edge_t<G>& uv) {
-              return vertex_property_map_value_t<Distances>(1);
+              return distance_fn_value_t<DistanceFn, G>(1);
             }, // default weight(g, uv) -> 1
       Visitor&& visitor = empty_visitor(),
-      Compare&& compare = less<vertex_property_map_value_t<Distances>>(),
-      Combine&& combine = plus<vertex_property_map_value_t<Distances>>()) {
+      Compare&& compare = less<distance_fn_value_t<DistanceFn, G>>(),
+      Combine&& combine = plus<distance_fn_value_t<DistanceFn, G>>()) {
   using graph_type    = std::remove_reference_t<G>;
   using id_type       = vertex_id_t<graph_type>;
-  using distance_type = vertex_property_map_value_t<Distances>;
+  using distance_type = distance_fn_value_t<DistanceFn, G>;
   using weight_type   = invoke_result_t<WF, const graph_type&, edge_t<graph_type>>;
 
-  constexpr auto zero     = shortest_path_zero<distance_type>();
-  constexpr auto infinite = shortest_path_infinite_distance<distance_type>();
+  constexpr auto zero     = zero_distance<distance_type>();
+  constexpr auto infinite = infinite_distance<distance_type>();
 
   // relaxing the target is the function of reducing the distance from the source to the target
-  auto relax_target = [&g, &predecessor, &distances, &compare, &combine, &weight] //
+  auto relax_target = [&g, &predecessor, &distance, &compare, &combine, &weight] //
         (const edge_t<graph_type>& uv, const vertex_id_t<graph_type>& uid) -> bool {
     const id_type       vid  = target_id(g, uv);
-    const distance_type d_u  = distances[uid];
-    const distance_type d_v  = distances[vid];
+    const distance_type d_u  = distance(g, uid);
+    const distance_type d_v  = distance(g, vid);
     const weight_type   w_uv = weight(g, uv);
 
     // Negative weights are not allowed for Dijkstra's algorithm
@@ -212,31 +216,15 @@ constexpr void dijkstra_shortest_paths(
     }
 
     if (compare(combine(d_u, w_uv), d_v)) {
-      distances[vid] = combine(d_u, w_uv);
-      if constexpr (!is_null_range_v<Predecessors>) {
-        predecessor[vid] = uid;
+      distance(g, vid) = combine(d_u, w_uv);
+      if constexpr (!is_null_predecessor_fn_v<PredecessorFn>) {
+        predecessor(g, vid) = uid;
       }
       return true;
     }
     return false;
   };
 
-  // Validate preconditions: source vertices must be valid, distances and predecessor must be sized appropriately
-  if constexpr (index_vertex_range<graph_type>) {
-    if (size(distances) < num_vertices(g)) {
-      throw std::out_of_range(
-            std::format("dijkstra_shortest_paths: size of distances of {} is less than the number of vertices {}",
-                        size(distances), num_vertices(g)));
-    }
-    if constexpr (!is_null_range_v<Predecessors>) {
-      if (size(predecessor) < num_vertices(g)) {
-        throw std::out_of_range(
-              std::format("dijkstra_shortest_paths: size of predecessor of {} is less than the number of vertices {}",
-                          size(predecessor), num_vertices(g)));
-      }
-    }
-  }
-
   // Define and initialize the priority queue for Dijkstra's algorithm. We use a min-heap based on distance.
   struct weighted_vertex {
     vertex_t<graph_type> vertex_desc = {};
@@ -267,7 +255,7 @@ constexpr void dijkstra_shortest_paths(
     }
     vertex_t<graph_type> seed = *seed_it;
 
-    distances[seed_id] = zero; // mark seed_id as discovered
+    distance(g, seed_id) = zero; // mark seed_id as discovered
     queue.push({seed, zero});
     if constexpr (has_on_discover_vertex<graph_type, Visitor>) {
       visitor.on_discover_vertex(g, seed);
@@ -293,7 +281,7 @@ constexpr void dijkstra_shortest_paths(
         visitor.on_examine_edge(g, uv);
       }
 
-      const bool is_neighbor_undiscovered = (distances[vid] == infinite);
+      const bool is_neighbor_undiscovered = (distance(g, vid) == infinite);
       const bool was_edge_relaxed         = relax_target(uv, uid);
 
       if (is_neighbor_undiscovered) {
@@ -308,7 +296,7 @@ constexpr void dijkstra_shortest_paths(
           } else if constexpr (has_on_discover_vertex_id<graph_type, Visitor>) {
             visitor.on_discover_vertex(g, vid);
           }
-          queue.push({v, distances[vid]});
+          queue.push({v, distance(g, vid)});
         } else {
           // This is an indicator of a bug in the algorithm and should be investigated.
           throw std::logic_error(
@@ -321,7 +309,7 @@ constexpr void dijkstra_shortest_paths(
           if constexpr (has_on_edge_relaxed<graph_type, Visitor>) {
             visitor.on_edge_relaxed(g, uv);
           }
-          queue.push({v, distances[vid]}); // re-enqueue with updated distance
+          queue.push({v, distance(g, vid)}); // re-enqueue with updated distance
         } else {
           if constexpr (has_on_edge_not_relaxed<graph_type, Visitor>) {
             visitor.on_edge_not_relaxed(g, uv);
@@ -348,33 +336,32 @@ constexpr void dijkstra_shortest_paths(
  * 
  * @param source Single source vertex ID instead of range.
  * 
- * @see dijkstra_shortest_paths(G&&, const Sources&, Distances&, Predecessors&, WF&&, Visitor&&, Compare&&, Combine&&)
+ * @see dijkstra_shortest_paths (multi-source overload)
  */
 template <
       adjacency_list G,
-      class Distances,
-      class Predecessors,
-      class WF = function<vertex_property_map_value_t<Distances>(const std::remove_reference_t<G>&, const edge_t<G>&)>,
+      class DistanceFn,
+      class PredecessorFn,
+      class WF = function<distance_fn_value_t<DistanceFn, G>(const std::remove_reference_t<G>&, const edge_t<G>&)>,
       class Visitor = empty_visitor,
-      class Compare = less<vertex_property_map_value_t<Distances>>,
-      class Combine = plus<vertex_property_map_value_t<Distances>>>
-requires vertex_property_map_for<Distances, G> &&                                       //
-         (is_null_range_v<Predecessors> || vertex_property_map_for<Predecessors, G>) && //
-         is_arithmetic_v<vertex_property_map_value_t<Distances>> &&                     //
-         basic_edge_weight_function<G, WF, vertex_property_map_value_t<Distances>, Compare, Combine>
+      class Compare = less<distance_fn_value_t<DistanceFn, G>>,
+      class Combine = plus<distance_fn_value_t<DistanceFn, G>>>
+requires distance_fn_for<DistanceFn, G> &&                                //
+         predecessor_fn_for<PredecessorFn, G> &&                          //
+         basic_edge_weight_function<G, WF, distance_fn_value_t<DistanceFn, G>, Compare, Combine>
 constexpr void dijkstra_shortest_paths(
       G&&                   g,
       const vertex_id_t<G>& source,
-      Distances&            distances,
-      Predecessors&         predecessor,
+      DistanceFn&&          distance,
+      PredecessorFn&&       predecessor,
       WF&&                  weight =
             [](const auto&, const edge_t<G>& uv) {
-              return vertex_property_map_value_t<Distances>(1);
+              return distance_fn_value_t<DistanceFn, G>(1);
             }, // default weight(g, uv) -> 1
       Visitor&& visitor = empty_visitor(),
-      Compare&& compare = less<vertex_property_map_value_t<Distances>>(),
-      Combine&& combine = plus<vertex_property_map_value_t<Distances>>()) {
-  dijkstra_shortest_paths(g, subrange(&source, (&source + 1)), distances, predecessor, weight,
+      Compare&& compare = less<distance_fn_value_t<DistanceFn, G>>(),
+      Combine&& combine = plus<distance_fn_value_t<DistanceFn, G>>()) {
+  dijkstra_shortest_paths(g, subrange(&source, (&source + 1)), distance, predecessor, weight,
                           forward<Visitor>(visitor), forward<Compare>(compare), forward<Combine>(combine));
 }
 
@@ -386,7 +373,7 @@ constexpr void dijkstra_shortest_paths(
  * 
  * @tparam G            The graph type. Must satisfy adjacency_list concept.
  * @tparam Sources      Input range of source vertex IDs.
- * @tparam Distances    Container for storing distances. Value type must be arithmetic.
+ * @tparam DistanceFn   Function returning a mutable reference to a per-vertex distance value.
  * @tparam WF           Edge weight function. Defaults to returning 1 for all edges (unweighted).
  * @tparam Visitor      Visitor type with callbacks for algorithm events. Defaults to empty_visitor.
  * @tparam Compare      Comparison function for distance values. Defaults to less<>.
@@ -394,45 +381,44 @@ constexpr void dijkstra_shortest_paths(
  * 
  * @param g            The graph to process.
  * @param sources      Range of source vertex IDs to start from.
- * @param distances    [out] Shortest distances from sources. Must be sized >= num_vertices(g).
- * @param weight       Edge weight function: (const edge_t<G>&) -> Distance.
+ * @param distance     Function to access per-vertex distance: distance(g, uid) -> Distance&.
+ * @param weight       Edge weight function: (const G&, const edge_t<G>&) -> Distance.
  * @param visitor      Visitor for algorithm events (discover, examine, relax, finish).
  * @param compare      Distance comparison function: (Distance, Distance) -> bool.
  * @param combine      Distance combination function: (Distance, Weight) -> Distance.
  * 
- * @return void. Results are stored in the distances output parameter.
+ * @return void. Results are stored via the distance function.
  * 
  * **Effects:**
- * - Modifies distances: Sets distances[v] for all vertices v
+ * - Sets distance(g, v) for all vertices v via the distance function
  * - Does not modify the graph g
- * - Internally uses _null_predecessors to skip predecessor tracking
+ * - Internally uses _null_predecessor to skip predecessor tracking
  * 
  * @see dijkstra_shortest_paths() for full documentation and complexity analysis.
  */
 template <
       adjacency_list G,
       input_range    Sources,
-      class Distances,
-      class WF = function<vertex_property_map_value_t<Distances>(const std::remove_reference_t<G>&, const edge_t<G>&)>,
+      class DistanceFn,
+      class WF = function<distance_fn_value_t<DistanceFn, G>(const std::remove_reference_t<G>&, const edge_t<G>&)>,
       class Visitor = empty_visitor,
-      class Compare = less<vertex_property_map_value_t<Distances>>,
-      class Combine = plus<vertex_property_map_value_t<Distances>>>
-requires vertex_property_map_for<Distances, G> &&                   //
-         convertible_to<range_value_t<Sources>, vertex_id_t<G>> &&  //
-         is_arithmetic_v<vertex_property_map_value_t<Distances>> && //
-         basic_edge_weight_function<G, WF, vertex_property_map_value_t<Distances>, Compare, Combine>
+      class Compare = less<distance_fn_value_t<DistanceFn, G>>,
+      class Combine = plus<distance_fn_value_t<DistanceFn, G>>>
+requires distance_fn_for<DistanceFn, G> &&                                                //
+         convertible_to<range_value_t<Sources>, vertex_id_t<G>> &&                              //
+         basic_edge_weight_function<G, WF, distance_fn_value_t<DistanceFn, G>, Compare, Combine>
 constexpr void dijkstra_shortest_distances(
       G&&            g,
       const Sources& sources,
-      Distances&     distances,
+      DistanceFn&&   distance,
       WF&&           weight =
             [](const auto&, const edge_t<G>& uv) {
-              return vertex_property_map_value_t<Distances>(1);
+              return distance_fn_value_t<DistanceFn, G>(1);
             }, // default weight(g, uv) -> 1
       Visitor&& visitor = empty_visitor(),
-      Compare&& compare = less<vertex_property_map_value_t<Distances>>(),
-      Combine&& combine = plus<vertex_property_map_value_t<Distances>>()) {
-  dijkstra_shortest_paths(g, sources, distances, _null_predecessors, forward<WF>(weight), forward<Visitor>(visitor),
+      Compare&& compare = less<distance_fn_value_t<DistanceFn, G>>(),
+      Combine&& combine = plus<distance_fn_value_t<DistanceFn, G>>()) {
+  dijkstra_shortest_paths(g, sources, distance, _null_predecessor, forward<WF>(weight), forward<Visitor>(visitor),
                           forward<Compare>(compare), forward<Combine>(combine));
 }
 
@@ -447,26 +433,25 @@ constexpr void dijkstra_shortest_distances(
  */
 template <
       adjacency_list G,
-      class Distances,
-      class WF = function<vertex_property_map_value_t<Distances>(const std::remove_reference_t<G>&, const edge_t<G>&)>,
+      class DistanceFn,
+      class WF = function<distance_fn_value_t<DistanceFn, G>(const std::remove_reference_t<G>&, const edge_t<G>&)>,
       class Visitor = empty_visitor,
-      class Compare = less<vertex_property_map_value_t<Distances>>,
-      class Combine = plus<vertex_property_map_value_t<Distances>>>
-requires vertex_property_map_for<Distances, G> &&                   //
-         is_arithmetic_v<vertex_property_map_value_t<Distances>> && //
-         basic_edge_weight_function<G, WF, vertex_property_map_value_t<Distances>, Compare, Combine>
+      class Compare = less<distance_fn_value_t<DistanceFn, G>>,
+      class Combine = plus<distance_fn_value_t<DistanceFn, G>>>
+requires distance_fn_for<DistanceFn, G> &&                                                //
+         basic_edge_weight_function<G, WF, distance_fn_value_t<DistanceFn, G>, Compare, Combine>
 constexpr void dijkstra_shortest_distances(
       G&&                   g,
       const vertex_id_t<G>& source,
-      Distances&            distances,
+      DistanceFn&&          distance,
       WF&&                  weight =
             [](const auto&, const edge_t<G>& uv) {
-              return vertex_property_map_value_t<Distances>(1);
+              return distance_fn_value_t<DistanceFn, G>(1);
             }, // default weight(g, uv) -> 1
       Visitor&& visitor = empty_visitor(),
-      Compare&& compare = less<vertex_property_map_value_t<Distances>>(),
-      Combine&& combine = plus<vertex_property_map_value_t<Distances>>()) {
-  dijkstra_shortest_paths(g, subrange(&source, (&source + 1)), distances, _null_predecessors, forward<WF>(weight),
+      Compare&& compare = less<distance_fn_value_t<DistanceFn, G>>(),
+      Combine&& combine = plus<distance_fn_value_t<DistanceFn, G>>()) {
+  dijkstra_shortest_paths(g, subrange(&source, (&source + 1)), distance, _null_predecessor, forward<WF>(weight),
                           forward<Visitor>(visitor), forward<Compare>(compare), forward<Combine>(combine));
 }
 
diff --git a/include/graph/algorithm/label_propagation.hpp b/include/graph/algorithm/label_propagation.hpp
index 7168ebd..c886750 100644
--- a/include/graph/algorithm/label_propagation.hpp
+++ b/include/graph/algorithm/label_propagation.hpp
@@ -14,6 +14,7 @@
 
 #include "graph/graph.hpp"
 #include "graph/adj_list/vertex_property_map.hpp"
+#include "graph/algorithm/traversal_common.hpp"
 
 #ifndef GRAPH_LABEL_PROPAGATION_HPP
 #  define GRAPH_LABEL_PROPAGATION_HPP
@@ -42,18 +43,18 @@ using adj_list::num_vertices;
 namespace detail {
 
 template <adjacency_list G,
-          class Label,
+          class LabelFn,
           class Gen,
           class T>
-requires vertex_property_map_for<Label, G> &&
-         std::equality_comparable<vertex_property_map_value_t<Label>> &&
+requires vertex_property_fn_for<LabelFn, G> &&
+         std::equality_comparable<vertex_fn_value_t<LabelFn, G>> &&
          std::uniform_random_bit_generator<std::remove_cvref_t<Gen>>
-void label_propagation_impl(G&&                                                     g,
-                            Label&                                                   label,
-                            std::optional<vertex_property_map_value_t<Label>> const&  empty_label,
-                            Gen&&                                                     rng,
-                            T                                                         max_iters) {
-  using label_type = vertex_property_map_value_t<Label>;
+void label_propagation_impl(G&&                                                  g,
+                            LabelFn&&                                            label,
+                            std::optional<vertex_fn_value_t<LabelFn, G>> const& empty_label,
+                            Gen&&                                                rng,
+                            T                                                    max_iters) {
+  using label_type = vertex_fn_value_t<LabelFn, G>;
 
   const size_t N = num_vertices(g);
   if (N == 0) {
@@ -77,8 +78,8 @@ void label_propagation_impl(G&&
       std::unordered_map<label_type, size_t> freq;
       for (auto&& uv : edges(g, *find_vertex(g, uid))) {
         auto tid = target_id(g, uv);
-        if (!empty_label || !(label[tid] == *empty_label)) {
-          ++freq[label[tid]];
+        if (!empty_label || !(label(g, tid) == *empty_label)) {
+          ++freq[label(g, tid)];
         }
       }
 
@@ -111,8 +112,8 @@ void label_propagation_impl(G&&
         best = candidates[dist(rng)];
       }
 
-      if (!(label[uid] == best)) {
-        label[uid] = best;
+      if (!(label(g, uid) == best)) {
+        label(g, uid) = best;
         changed    = true;
       }
     }
@@ -134,14 +135,16 @@ void label_propagation_impl(G&&
  * (convergence) or until @p max_iters iterations have been performed.
  *
  * @tparam G          The graph type. Must satisfy adjacency_list concept.
- * @tparam Label      Vertex property map whose vertex_property_map_value_t is the label type.
- *                    For index graphs: std::vector<T>. For mapped graphs: std::unordered_map<VId, T>.
+ * @tparam LabelFn    Callable providing per-vertex label access:
+ *                    (const G&, vertex_id_t<G>) -> LabelValue&. Must satisfy
+ *                    vertex_property_fn_for<LabelFn, G>.
  * @tparam Gen        Uniform random bit generator type (default std::default_random_engine).
  * @tparam T          Integral type for the iteration limit (default size_t).
  *
  * @param g           The graph to process.
- * @param label       [in,out] Vertex property map holding initial labels for every vertex.
- *                    Modified in place to hold final labels on return.
+ * @param label       Callable providing per-vertex label access: label(g, uid) -> LabelValue&.
+ *                    Initial labels in (e.g., iota via container); community labels out.
+ *                    For containers: wrap with container_value_fn(c).
  * @param rng         Random-number generator used for shuffle and tie-breaking.
  * @param max_iters   Maximum number of iterations (default: unlimited).
  *
@@ -149,20 +152,20 @@ void label_propagation_impl(G&&
  *
  * **Mandates:**
  * - G must satisfy adjacency_list (index or mapped vertex containers)
- * - Label must satisfy vertex_property_map_for<Label, G> (subscriptable by vertex_id_t<G>)
- * - vertex_property_map_value_t<Label> must satisfy std::equality_comparable
+ * - LabelFn must satisfy vertex_property_fn_for<LabelFn, G>
+ * - vertex_fn_value_t<LabelFn, G> must satisfy std::equality_comparable
  * - Gen must satisfy std::uniform_random_bit_generator
  *
  * **Preconditions:**
- * - label contains a meaningful initial label for every vertex in g
- * - For index graphs: label.size() >= num_vertices(g)
+ * - label(g, uid) returns a valid reference for every vertex in g
+ * - label has been initialized (e.g., iota: label(g, uid) = uid initially)
  *
  * **Effects:**
- * - Modifies label: Sets label[v] for all vertices v
+ * - Sets label(g, uid) for all vertices via the label function
  * - Does not modify the graph g
  *
  * **Postconditions:**
- * - label[uid] holds the discovered community label for vertex uid
+ * - label(g, uid) holds the discovered community label for vertex uid
  * - Neighbouring vertices in the same dense community share a common label
  *
  * **Throws:**
@@ -192,16 +195,16 @@ void label_propagation_impl(G&&
  * - ✅ Cycles
  */
 template <adjacency_list G,
-          class Label,
+          class LabelFn,
           class Gen = std::default_random_engine,
           class T   = size_t>
-requires vertex_property_map_for<Label, G> &&
-         std::equality_comparable<vertex_property_map_value_t<Label>> &&
+requires vertex_property_fn_for<LabelFn, G> &&
+         std::equality_comparable<vertex_fn_value_t<LabelFn, G>> &&
          std::uniform_random_bit_generator<std::remove_cvref_t<Gen>>
-void label_propagation(G&&    g,
-                       Label& label,
-                       Gen&&  rng       = std::default_random_engine{},
-                       T      max_iters = std::numeric_limits<T>::max()) {
+void label_propagation(G&&      g,
+                       LabelFn&& label,
+                       Gen&&    rng       = std::default_random_engine{},
+                       T        max_iters = std::numeric_limits<T>::max()) {
   detail::label_propagation_impl(g, label, std::nullopt, std::forward<Gen>(rng), max_iters);
 }
 
@@ -214,13 +217,16 @@ void label_propagation(G&&    g,
  * as a change for convergence purposes.
  *
  * @tparam G          The graph type. Must satisfy adjacency_list concept.
- * @tparam Label      Vertex property map whose vertex_property_map_value_t is the label type.
+ * @tparam LabelFn    Callable providing per-vertex label access:
+ *                    (const G&, vertex_id_t<G>) -> LabelValue&. Must satisfy
+ *                    vertex_property_fn_for<LabelFn, G>.
  * @tparam Gen        Uniform random bit generator type (default std::default_random_engine).
  * @tparam T          Integral type for the iteration limit (default size_t).
  *
  * @param g           The graph to process.
- * @param label       [in,out] Vertex property map holding initial labels for every vertex.
- *                    Modified in place to hold final labels on return.
+ * @param label       Callable providing per-vertex label access: label(g, uid) -> LabelValue&.
+ *                    Initial labels in; community labels out.
+ *                    For containers: wrap with container_value_fn(c).
  * @param empty_label Sentinel value representing an unlabelled vertex. Passed by value.
  * @param rng         Random-number generator used for shuffle and tie-breaking.
  * @param max_iters   Maximum number of iterations (default: unlimited).
@@ -229,16 +235,17 @@ void label_propagation(G&&    g,
  *
  * **Mandates:**
  * - G must satisfy adjacency_list (index or mapped vertex containers)
- * - Label must satisfy vertex_property_map_for<Label, G> (subscriptable by vertex_id_t<G>)
- * - vertex_property_map_value_t<Label> must satisfy std::equality_comparable
+ * - LabelFn must satisfy vertex_property_fn_for<LabelFn, G>
+ * - vertex_fn_value_t<LabelFn, G> must satisfy std::equality_comparable
  * - Gen must satisfy std::uniform_random_bit_generator
  *
  * **Preconditions:**
- * - label contains an initial label (or empty_label) for every vertex in g
- * - For index graphs: label.size() >= num_vertices(g)
+ * - label(g, uid) returns a valid reference for every vertex in g
+ * - label has been initialized (vertices with empty_label are treated as unlabelled)
+ * - If all vertices start with empty_label, no propagation occurs
  *
  * **Effects:**
- * - Modifies label: Sets label[v] for all vertices v that acquire a label
+ * - Sets label(g, uid) for vertices that acquire a label via the label function
  * - Does not modify the graph g
  *
  * **Postconditions:**
@@ -274,17 +281,17 @@ void label_propagation(G&&    g,
  * - ✅ Cycles
  */
 template <adjacency_list G,
-          class Label,
+          class LabelFn,
           class Gen = std::default_random_engine,
           class T   = size_t>
-requires vertex_property_map_for<Label, G> &&
-         std::equality_comparable<vertex_property_map_value_t<Label>> &&
+requires vertex_property_fn_for<LabelFn, G> &&
+         std::equality_comparable<vertex_fn_value_t<LabelFn, G>> &&
          std::uniform_random_bit_generator<std::remove_cvref_t<Gen>>
-void label_propagation(G&&                                            g,
-                       Label&                                         label,
-                       vertex_property_map_value_t<Label>              empty_label,
-                       Gen&&                                           rng       = std::default_random_engine{},
-                       T                                               max_iters = std::numeric_limits<T>::max()) {
+void label_propagation(G&&                           g,
+                       LabelFn&&                     label,
+                       vertex_fn_value_t<LabelFn, G> empty_label,
+                       Gen&&                         rng       = std::default_random_engine{},
+                       T                             max_iters = std::numeric_limits<T>::max()) {
   detail::label_propagation_impl(g, label, std::optional(std::move(empty_label)),
                                  std::forward<Gen>(rng), max_iters);
 }
diff --git a/include/graph/algorithm/mst.hpp b/include/graph/algorithm/mst.hpp
index 0e82ce6..26c3c20 100644
--- a/include/graph/algorithm/mst.hpp
+++ b/include/graph/algorithm/mst.hpp
@@ -802,16 +802,16 @@ auto inplace_kruskal(IELR&&    e,      // graph
  * edge connecting a tree vertex to a non-tree vertex. Delegates to dijkstra_shortest_paths
  * with a projecting combine function.
  * 
- * @tparam G           Graph type satisfying adjacency_list.
- * @tparam Predecessor Vertex property map for predecessor output.
- * @tparam Weight      Vertex property map for edge weight output.
- * @tparam WF          Edge weight function type. Defaults to edge_value(g, uv).
- * @tparam CompareOp   Comparison operator type. Defaults to less<>.
+ * @tparam G             Graph type satisfying adjacency_list.
+ * @tparam PredecessorFn Function type returning lvalue ref to predecessor for a vertex.
+ * @tparam WeightFn      Function type returning lvalue ref to edge weight for a vertex.
+ * @tparam WF            Edge weight function type. Defaults to edge_value(g, uv).
+ * @tparam CompareOp     Comparison operator type. Defaults to less<>.
  * 
  * @param g           The graph to process.
  * @param seed        Starting vertex for MST growth.
- * @param predecessor Output: predecessor[v] = parent of v in MST, predecessor[seed] = seed.
- * @param weight      Output: weight[v] = edge weight from predecessor[v] to v.
+ * @param weight      Function weight(g, uid) -> edge_weight&: returns lvalue ref to edge weight for vertex uid.
+ * @param predecessor Function predecessor(g, uid) -> vertex_id&: returns lvalue ref to predecessor for vertex uid.
  * @param weight_fn   Edge weight function (default: edge_value).
  * @param compare     Comparison for edge weights (default: less<>).
  * 
@@ -819,25 +819,24 @@ auto inplace_kruskal(IELR&&    e,      // graph
  * 
  * **Mandates:**
  * - G must satisfy adjacency_list
- * - Predecessor must satisfy vertex_property_map_for<Predecessor, G>
- * - Weight must satisfy vertex_property_map_for<Weight, G>
+ * - WeightFn must satisfy distance_fn_for<WeightFn, G>
+ * - PredecessorFn must satisfy predecessor_fn_for<PredecessorFn, G>
  * - WF must satisfy basic_edge_weight_function
  * 
  * **Preconditions:**
  * - seed must be a valid vertex in the graph
  * - predecessor and weight must be initialized (use init_shortest_paths)
- * - For index graphs: predecessor.size() >= num_vertices(g) and weight.size() >= num_vertices(g)
  * - compare must define a strict weak ordering
  * 
  * **Effects:**
- * - Writes MST structure to predecessor and weight arrays
+ * - Writes MST structure via predecessor and weight functions
  * - Does not modify graph g
  * 
  * **Postconditions:**
- * - predecessor[seed] == seed
- * - For reachable vertices: predecessor[v] points to parent in MST
- * - For unreachable vertices: predecessor[v] is unchanged
- * - weight[v] contains edge weight from predecessor[v] to v
+ * - predecessor(g, seed) == seed
+ * - For reachable vertices: predecessor(g, v) points to parent in MST
+ * - For unreachable vertices: predecessor(g, v) is unchanged
+ * - weight(g, v) contains edge weight from predecessor(g, v) to v
  * 
  * **Returns:**
  * - Total weight of the spanning tree (edge_value_type)
@@ -845,7 +844,6 @@ auto inplace_kruskal(IELR&&    e,      // graph
  * 
  * **Throws:**
  * - std::out_of_range if seed vertex ID is out of range
- * - std::out_of_range if predecessor or weight are undersized
  * - Exception guarantee: Basic. Graph g unchanged; predecessor/weight may be partial.
  * 
  * **Complexity:**
@@ -862,43 +860,48 @@ auto inplace_kruskal(IELR&&    e,      // graph
  * std::vector<uint32_t> pred(num_vertices(g));
  * std::vector<int> wt(num_vertices(g));
  * init_shortest_paths(g, wt, pred);
- * auto total_weight = prim(g, 0, pred, wt);
+ * auto total_weight = prim(g, 0,
+ *   [&wt](const auto& g, auto uid) -> auto& { return wt[uid]; },
+ *   [&pred](const auto& g, auto uid) -> auto& { return pred[uid]; });
  * ```
  */
 template <adjacency_list G,
-          class          Predecessor,
-          class          Weight,
-          class WF = function<vertex_property_map_value_t<Weight>(const std::remove_reference_t<G>&, const edge_t<G>&)>,
-          class CompareOp = less<vertex_property_map_value_t<Weight>>>
-requires vertex_property_map_for<Predecessor, G> &&
-         vertex_property_map_for<Weight, G> &&
-         basic_edge_weight_function<G, WF, vertex_property_map_value_t<Weight>, CompareOp, plus<vertex_property_map_value_t<Weight>>>
+          class          WeightFn,
+          class          PredecessorFn,
+          class WF = function<distance_fn_value_t<WeightFn, G>(const std::remove_reference_t<G>&, const edge_t<G>&)>,
+          class CompareOp = less<distance_fn_value_t<WeightFn, G>>>
+requires distance_fn_for<WeightFn, G> &&
+         is_arithmetic_v<distance_fn_value_t<WeightFn, G>> &&
+         predecessor_fn_for<PredecessorFn, G> &&
+         basic_edge_weight_function<G, WF, distance_fn_value_t<WeightFn, G>, CompareOp, plus<distance_fn_value_t<WeightFn, G>>>
 auto prim(G&&                   g,           // graph
           const vertex_id_t<G>& seed,        // seed vtx
-          Predecessor&          predecessor, // out: predecessor[uid] of uid in tree
-          Weight&               weight,      // out: edge value weight[uid] from tree edge uid to predecessor[uid]
+          WeightFn&&            weight,      // out: weight(g, uid) -> edge weight& from tree edge uid to predecessor
+          PredecessorFn&&       predecessor, // out: predecessor(g, uid) -> predecessor& of uid in tree
           WF&&                  weight_fn =
                 [](const auto& gr, const edge_t<G>& uv) {
                   return edge_value(gr, uv);
                 }, // default weight_fn(g, uv) -> edge_value(g, uv)
-          CompareOp             compare = less<vertex_property_map_value_t<Weight>>() // edge value comparator
+          CompareOp             compare = less<distance_fn_value_t<WeightFn, G>>() // edge value comparator
 ) {
-  using edge_value_type = vertex_property_map_value_t<Weight>;
+  using edge_value_type = distance_fn_value_t<WeightFn, G>;
 
   // Prim's combine: ignore accumulated distance, use edge weight directly.
   // This transforms Dijkstra's relaxation check from compare(d_u + w, d_v)
   // to compare(w, d_v), which is exactly Prim's criterion.
   auto prim_combine = [](edge_value_type /*d_u*/, edge_value_type w_uv) -> edge_value_type { return w_uv; };
 
-  dijkstra_shortest_paths(g, seed, weight, predecessor,
+  dijkstra_shortest_paths(g, seed,
+                          std::forward<WeightFn>(weight),
+                          std::forward<PredecessorFn>(predecessor),
                           std::forward<WF>(weight_fn), empty_visitor(),
                           std::forward<CompareOp>(compare), prim_combine);
 
   // Calculate total MST weight by summing edge weights
   edge_value_type total_weight = edge_value_type{};
   for (auto [vid] : views::basic_vertexlist(g)) {
-    if (vid != seed && predecessor[vid] != vid) {
-      total_weight += weight[vid];
+    if (vid != seed && predecessor(g, vid) != vid) {
+      total_weight += weight(g, vid);
     }
   }
 
diff --git a/include/graph/algorithm/traversal_common.hpp b/include/graph/algorithm/traversal_common.hpp
index 3e5ed53..2d6c343 100644
--- a/include/graph/algorithm/traversal_common.hpp
+++ b/include/graph/algorithm/traversal_common.hpp
@@ -30,26 +30,6 @@
 
 namespace graph {
 
-//
-// vertex_id_store_t<G> — efficient storage type for vertex IDs in algorithm internals
-//
-
-/**
- * @brief Efficient storage type for vertex IDs in algorithm-internal containers.
- *
- * For integral IDs (vector-based graphs): same as vertex_id_t<G> (zero overhead).
- * For non-trivial IDs (e.g., std::string from map-based graphs): reference_wrapper
- * to the stable key in the graph's map node (8 bytes, trivially copyable).
- *
- * @note Requires: the graph must not be mutated while values of this type are alive.
- * This is already an implicit precondition for all traversal algorithms.
- */
-template <typename G>
-using vertex_id_store_t = std::conditional_t<
-    std::is_reference_v<adj_list::raw_vertex_id_t<G>>,
-    std::reference_wrapper<std::remove_reference_t<adj_list::raw_vertex_id_t<G>>>,
-    adj_list::vertex_id_t<G>>;
-
 //
 // Edge weight function concepts
 //
@@ -113,10 +93,10 @@ concept edge_weight_function =
  * 
  * @tparam DistanceValue The arithmetic type used for distances.
  * 
- * @return A sentinel value representing infinite distance (typically std::numeric_limits<T>::max()).
+ * @return A sentinel value representing infinite distance (std::numeric_limits<T>::max()).
  */
 template <class DistanceValue>
-constexpr auto shortest_path_infinite_distance() {
+constexpr auto infinite_distance() {
   return std::numeric_limits<DistanceValue>::max();
 }
 
@@ -131,10 +111,90 @@ constexpr auto shortest_path_infinite_distance() {
  * @return A zero-initialized distance value.
  */
 template <class DistanceValue>
-constexpr auto shortest_path_zero() {
+constexpr auto zero_distance() {
   return DistanceValue();
 }
 
+//
+// Distance and predecessor function concepts
+//
+// These concepts enable algorithms to accept functions for per-vertex distance and
+// predecessor access: distance(g, uid) and predecessor(g, uid). This is more flexible
+// than requiring a specific container, because the values can reside on a vertex property
+// or in an external container.
+//
+
+/// Type alias: extracts the distance value type from a distance function's return type
+template <class DF, class G>
+using distance_fn_value_t = std::remove_cvref_t<
+    std::invoke_result_t<DF&, const std::remove_reference_t<G>&, const vertex_id_t<G>&>>;
+
+/// Concept: a callable returning a mutable reference to a per-vertex distance value
+template <class DF, class G>
+concept distance_fn_for =
+      std::invocable<DF&, const std::remove_reference_t<G>&, const vertex_id_t<G>&> &&
+      std::is_lvalue_reference_v<
+            std::invoke_result_t<DF&, const std::remove_reference_t<G>&, const vertex_id_t<G>&>>;
+
+/// Concept: a callable returning a mutable reference to a per-vertex predecessor value
+template <class PF, class G>
+concept predecessor_fn_for =
+      std::invocable<PF&, const std::remove_reference_t<G>&, const vertex_id_t<G>&> &&
+      std::is_lvalue_reference_v<
+            std::invoke_result_t<PF&, const std::remove_reference_t<G>&, const vertex_id_t<G>&>>;
+
+/// General concept: a callable returning a mutable lvalue reference to any per-vertex property value.
+/// Used by connected_components, label_propagation, and similar algorithms with per-vertex
+/// property output parameters.
+template <class VF, class G>
+concept vertex_property_fn_for =
+      std::invocable<VF&, const std::remove_reference_t<G>&, const vertex_id_t<G>&> &&
+      std::is_lvalue_reference_v<
+            std::invoke_result_t<VF&, const std::remove_reference_t<G>&, const vertex_id_t<G>&>>;
+
+/// Type alias: extracts the value type from a vertex property function's return type
+template <class VF, class G>
+using vertex_fn_value_t = std::remove_cvref_t<
+    std::invoke_result_t<VF&, const std::remove_reference_t<G>&, const vertex_id_t<G>&>>;
+
+/// Null predecessor function — used when predecessor tracking is not needed.
+/// Detected at compile time via is_null_predecessor_fn_v to skip predecessor writes.
+struct _null_predecessor_fn {
+  template <class G, class VId>
+  size_t& operator()(const G&, const VId&) {
+    static size_t dummy = 0;
+    return dummy;
+  }
+};
+
+/// Global instance of the null predecessor function
+inline _null_predecessor_fn _null_predecessor;
+
+/// Type trait to detect _null_predecessor_fn at compile time
+template <class T>
+inline constexpr bool is_null_predecessor_fn_v = std::is_same_v<std::remove_cvref_t<T>, _null_predecessor_fn>;
+
+/// Function object that adapts a subscriptable container into a property function.
+/// Wraps container[uid] into fn(g, uid) -> auto&, satisfying distance_fn_for
+/// and predecessor_fn_for concepts.
+///
+/// Usage:
+///   std::vector<int> distances(num_vertices(g));
+///   dijkstra_shortest_paths(g, source, container_value_fn(distances), ...);
+///
+template <class Container>
+struct container_value_fn {
+  Container& c;
+
+  template <class G, class VId>
+  constexpr auto& operator()(const G&, const VId& uid) const {
+    return c[uid];
+  }
+};
+
+template <class Container>
+container_value_fn(Container&) -> container_value_fn<Container>;
+
 //
 // Visitor concepts
 //
@@ -331,7 +391,7 @@ inline constexpr bool is_null_range_v = std::is_same_v<std::remove_cvref_t<T>, _
  * @ingroup graph_algorithms
  * @brief Initialize distances for shortest path algorithms (graph-aware).
  *
- * Sets every vertex's distance to shortest_path_infinite_distance().
+ * Sets every vertex's distance to infinite_distance().
  *
  * For index graphs (Distances is a random_access_range):
  *   std::ranges::fill(distances, infinite).
@@ -348,7 +408,7 @@ template <class G, class Distances>
   requires adjacency_list<G> && vertex_property_map_for<Distances, G>
 constexpr void init_shortest_paths(const G& g, Distances& distances) {
   using dist_value = vertex_property_map_value_t<Distances>;
-  constexpr auto infinite = shortest_path_infinite_distance<dist_value>();
+  constexpr auto infinite = infinite_distance<dist_value>();
 
   if constexpr (std::ranges::random_access_range<Distances>) {
     // Index graph: fill the pre-sized vector
@@ -373,7 +433,7 @@ constexpr void init_shortest_paths(const G& g, Distances& distances) {
  * @ingroup graph_algorithms
  * @brief Initialize distances and predecessors for shortest path algorithms (graph-aware).
  *
- * Sets every vertex's distance to shortest_path_infinite_distance() and
+ * Sets every vertex's distance to infinite_distance() and
  * every vertex's predecessor to itself.
  *
  * For index graphs: distances are filled, predecessors are iota'd from 0.
@@ -392,7 +452,7 @@ template <class G, class Distances, class Predecessors>
            (vertex_property_map_for<Predecessors, G> || is_null_range_v<Predecessors>)
 constexpr void init_shortest_paths(const G& g, Distances& distances, Predecessors& predecessors) {
   using dist_value = vertex_property_map_value_t<Distances>;
-  constexpr auto infinite = shortest_path_infinite_distance<dist_value>();
+  constexpr auto infinite = infinite_distance<dist_value>();
 
   if constexpr (std::ranges::random_access_range<Distances>) {
     // Index graph: fill distances, iota predecessors
diff --git a/tests/algorithms/test_bellman_ford_shortest_paths.cpp b/tests/algorithms/test_bellman_ford_shortest_paths.cpp
index 6df7521..ddc9027 100644
--- a/tests/algorithms/test_bellman_ford_shortest_paths.cpp
+++ b/tests/algorithms/test_bellman_ford_shortest_paths.cpp
@@ -55,7 +55,7 @@ TEST_CASE("bellman_ford_shortest_paths - CLRS example", "[algorithm][bellman_for
 
   init_shortest_paths(g, distance, predecessor);
 
-  auto result = bellman_ford_shortest_paths(g, vertex_id_t<Graph>(0), distance, predecessor,
+  auto result = bellman_ford_shortest_paths(g, vertex_id_t<Graph>(0), container_value_fn(distance), container_value_fn(predecessor),
                                             [](const auto& g, const auto& uv) { return edge_value(g, uv); });
 
   // No negative cycle should be detected
@@ -78,7 +78,7 @@ TEST_CASE("bellman_ford_shortest_paths - path graph", "[algorithm][bellman_ford_
 
   init_shortest_paths(g, distance, predecessor);
 
-  auto result = bellman_ford_shortest_paths(g, vertex_id_t<Graph>(0), distance, predecessor,
+  auto result = bellman_ford_shortest_paths(g, vertex_id_t<Graph>(0), container_value_fn(distance), container_value_fn(predecessor),
                                             [](const auto& g, const auto& uv) { return edge_value(g, uv); });
 
   // No negative cycle
@@ -99,7 +99,7 @@ TEST_CASE("bellman_ford_shortest_distances - no predecessors", "[algorithm][bell
   init_shortest_paths(g, distance);
 
   // Test distances-only variant (no predecessor tracking)
-  auto result = bellman_ford_shortest_distances(g, vertex_id_t<Graph>(0), distance,
+  auto result = bellman_ford_shortest_distances(g, vertex_id_t<Graph>(0), container_value_fn(distance),
                                                 [](const auto& g, const auto& uv) { return edge_value(g, uv); });
 
   // No negative cycle
@@ -125,7 +125,7 @@ TEST_CASE("bellman_ford_shortest_paths - multi-source", "[algorithm][bellman_for
   // Start from vertices 0 and 3
   std::vector<vertex_id_t<Graph>> sources = {0, 3};
 
-  auto result = bellman_ford_shortest_paths(g, sources, distance, predecessor,
+  auto result = bellman_ford_shortest_paths(g, sources, container_value_fn(distance), container_value_fn(predecessor),
                                             [](const auto& g, const auto& uv) { return edge_value(g, uv); });
 
   // No negative cycle
@@ -151,7 +151,7 @@ TEST_CASE("bellman_ford_shortest_distances - multi-source", "[algorithm][bellman
   // Start from vertices 0 and 3
   std::vector<vertex_id_t<Graph>> sources = {0, 3};
 
-  auto result = bellman_ford_shortest_distances(g, sources, distance,
+  auto result = bellman_ford_shortest_distances(g, sources, container_value_fn(distance),
                                                 [](const auto& g, const auto& uv) { return edge_value(g, uv); });
 
   // No negative cycle
@@ -174,7 +174,7 @@ TEST_CASE("bellman_ford_shortest_paths - with visitor", "[algorithm][bellman_for
   BellmanCountingVisitor visitor;
 
   auto result = bellman_ford_shortest_paths(
-        g, vertex_id_t<Graph>(0), distance, predecessor,
+        g, vertex_id_t<Graph>(0), container_value_fn(distance), container_value_fn(predecessor),
         [](const auto& g, const auto& uv) { return edge_value(g, uv); }, visitor);
 
   // No negative cycle
@@ -201,7 +201,7 @@ TEST_CASE("bellman_ford_shortest_paths - unweighted graph (default weight)",
   init_shortest_paths(g, distance, predecessor);
 
   // Use default weight function (returns 1 for all edges)
-  auto result = bellman_ford_shortest_paths(g, vertex_id_t<Graph>(0), distance, predecessor);
+  auto result = bellman_ford_shortest_paths(g, vertex_id_t<Graph>(0), container_value_fn(distance), container_value_fn(predecessor));
 
   // No negative cycle
   REQUIRE(!result.has_value());
@@ -221,7 +221,7 @@ TEST_CASE("bellman_ford_shortest_paths - predecessor path reconstruction", "[alg
 
   init_shortest_paths(g, distance, predecessor);
 
-  auto result = bellman_ford_shortest_paths(g, vertex_id_t<Graph>(0), distance, predecessor,
+  auto result = bellman_ford_shortest_paths(g, vertex_id_t<Graph>(0), container_value_fn(distance), container_value_fn(predecessor),
                                             [](const auto& g, const auto& uv) { return edge_value(g, uv); });
 
   // No negative cycle
@@ -260,7 +260,7 @@ TEST_CASE("bellman_ford_shortest_paths - unreachable vertices", "[algorithm][bel
 
   init_shortest_paths(g, distance, predecessor);
 
-  auto result = bellman_ford_shortest_paths(g, vertex_id_t<Graph>(0), distance, predecessor);
+  auto result = bellman_ford_shortest_paths(g, vertex_id_t<Graph>(0), container_value_fn(distance), container_value_fn(predecessor));
 
   // No negative cycle
   REQUIRE(!result.has_value());
@@ -292,7 +292,7 @@ TEST_CASE("bellman_ford_shortest_paths - negative weight cycle detection", "[alg
   BellmanCountingVisitor visitor;
 
   auto result = bellman_ford_shortest_paths(
-        g, vertex_id_t<Graph>(0), distance, predecessor,
+        g, vertex_id_t<Graph>(0), container_value_fn(distance), container_value_fn(predecessor),
         [](const auto& g, const auto& uv) { return edge_value(g, uv); }, visitor);
 
   // Negative cycle should be detected
@@ -316,7 +316,7 @@ TEST_CASE("bellman_ford_shortest_paths - find negative cycle vertices", "[algori
 
   init_shortest_paths(g, distance, predecessor);
 
-  auto cycle_vertex = bellman_ford_shortest_paths(g, vertex_id_t<Graph>(0), distance, predecessor,
+  auto cycle_vertex = bellman_ford_shortest_paths(g, vertex_id_t<Graph>(0), container_value_fn(distance), container_value_fn(predecessor),
                                                   [](const auto& g, const auto& uv) { return edge_value(g, uv); });
 
   REQUIRE(cycle_vertex.has_value());
@@ -353,7 +353,7 @@ TEST_CASE("bellman_ford_shortest_paths - single vertex", "[algorithm][bellman_fo
 
   init_shortest_paths(g, distance, predecessor);
 
-  auto result = bellman_ford_shortest_paths(g, vertex_id_t<Graph>(0), distance, predecessor);
+  auto result = bellman_ford_shortest_paths(g, vertex_id_t<Graph>(0), container_value_fn(distance), container_value_fn(predecessor));
 
   // No negative cycle
   REQUIRE(!result.has_value());
@@ -379,13 +379,13 @@ TEMPLATE_TEST_CASE("bellman_ford_shortest_paths - sparse CLRS example",
   const auto& exp = clrs_dijkstra_sparse_expected{};
 
   auto g            = map_fixtures::clrs_dijkstra_graph<Graph>();
-  auto distances    = make_vertex_property_map<Graph, int>(g, shortest_path_infinite_distance<int>());
+  auto distances    = make_vertex_property_map<Graph, int>(g, infinite_distance<int>());
   auto predecessors = make_vertex_property_map<Graph, id_type>(g, id_type{});
   // Initialize predecessors: each vertex points to itself
   for (auto&& [uid, u] : views::vertexlist(g))
     predecessors[uid] = uid;
 
-  auto result = bellman_ford_shortest_paths(g, id_type(exp.s), distances, predecessors,
+  auto result = bellman_ford_shortest_paths(g, id_type(exp.s), container_value_fn(distances), container_value_fn(predecessors),
                                             [](const auto& g, const auto& uv) { return edge_value(g, uv); });
 
   // No negative cycle should be detected
@@ -408,9 +408,9 @@ TEMPLATE_TEST_CASE("bellman_ford_shortest_distances - sparse CLRS example",
   const auto& exp = clrs_dijkstra_sparse_expected{};
 
   auto g         = map_fixtures::clrs_dijkstra_graph<Graph>();
-  auto distances = make_vertex_property_map<Graph, int>(g, shortest_path_infinite_distance<int>());
+  auto distances = make_vertex_property_map<Graph, int>(g, infinite_distance<int>());
 
-  auto result = bellman_ford_shortest_distances(g, id_type(exp.s), distances,
+  auto result = bellman_ford_shortest_distances(g, id_type(exp.s), container_value_fn(distances),
                                                 [](const auto& g, const auto& uv) { return edge_value(g, uv); });
 
   // No negative cycle
@@ -429,14 +429,14 @@ TEMPLATE_TEST_CASE("bellman_ford_shortest_paths - sparse multi-source",
   const auto& exp = clrs_dijkstra_sparse_expected{};
 
   auto g            = map_fixtures::clrs_dijkstra_graph<Graph>();
-  auto distances    = make_vertex_property_map<Graph, int>(g, shortest_path_infinite_distance<int>());
+  auto distances    = make_vertex_property_map<Graph, int>(g, infinite_distance<int>());
   auto predecessors = make_vertex_property_map<Graph, id_type>(g, id_type{});
   for (auto&& [uid, u] : views::vertexlist(g))
     predecessors[uid] = uid;
 
   // Start from s (10) and y (40)
   std::vector<id_type> sources = {exp.s, exp.y};
-  auto result = bellman_ford_shortest_paths(g, sources, distances, predecessors,
+  auto result = bellman_ford_shortest_paths(g, sources, container_value_fn(distances), container_value_fn(predecessors),
                                             [](const auto& g, const auto& uv) { return edge_value(g, uv); });
 
   // No negative cycle
@@ -448,7 +448,7 @@ TEMPLATE_TEST_CASE("bellman_ford_shortest_paths - sparse multi-source",
 
   // All vertices should be reachable
   for (size_t i = 0; i < exp.num_vertices; ++i) {
-    REQUIRE(distances[exp.vertex_ids[i]] < shortest_path_infinite_distance<int>());
+    REQUIRE(distances[exp.vertex_ids[i]] < infinite_distance<int>());
   }
 }
 
@@ -460,14 +460,14 @@ TEMPLATE_TEST_CASE("bellman_ford_shortest_paths - sparse with visitor",
   const auto& exp = clrs_dijkstra_sparse_expected{};
 
   auto g            = map_fixtures::clrs_dijkstra_graph<Graph>();
-  auto distances    = make_vertex_property_map<Graph, int>(g, shortest_path_infinite_distance<int>());
+  auto distances    = make_vertex_property_map<Graph, int>(g, infinite_distance<int>());
   auto predecessors = make_vertex_property_map<Graph, id_type>(g, id_type{});
   for (auto&& [uid, u] : views::vertexlist(g))
     predecessors[uid] = uid;
 
   BellmanCountingVisitor visitor;
   auto result = bellman_ford_shortest_paths(
-        g, id_type(exp.s), distances, predecessors,
+        g, id_type(exp.s), container_value_fn(distances), container_value_fn(predecessors),
         [](const auto& g, const auto& uv) { return edge_value(g, uv); }, visitor);
 
   REQUIRE(!result.has_value());
@@ -485,13 +485,13 @@ TEMPLATE_TEST_CASE("bellman_ford_shortest_paths - sparse negative cycle detectio
   // Total cycle weight: 1 + 1 + (-3) = -1 (negative!)
   Graph g({{10, 20, 1}, {20, 30, 1}, {30, 10, -3}});
 
-  auto distances    = make_vertex_property_map<Graph, int>(g, shortest_path_infinite_distance<int>());
+  auto distances    = make_vertex_property_map<Graph, int>(g, infinite_distance<int>());
   auto predecessors = make_vertex_property_map<Graph, id_type>(g, id_type{});
   for (auto&& [uid, u] : views::vertexlist(g))
     predecessors[uid] = uid;
 
   auto result = bellman_ford_shortest_paths(
-        g, id_type(10), distances, predecessors,
+        g, id_type(10), container_value_fn(distances), container_value_fn(predecessors),
         [](const auto& g, const auto& uv) { return edge_value(g, uv); });
 
   // Negative cycle should be detected
@@ -510,13 +510,13 @@ TEMPLATE_TEST_CASE("bellman_ford_shortest_paths - sparse find negative cycle ver
   // Same negative cycle graph
   Graph g({{10, 20, 1}, {20, 30, 1}, {30, 10, -3}});
 
-  auto distances    = make_vertex_property_map<Graph, int>(g, shortest_path_infinite_distance<int>());
+  auto distances    = make_vertex_property_map<Graph, int>(g, infinite_distance<int>());
   auto predecessors = make_vertex_property_map<Graph, id_type>(g, id_type{});
   for (auto&& [uid, u] : views::vertexlist(g))
     predecessors[uid] = uid;
 
   auto cycle_vertex = bellman_ford_shortest_paths(
-        g, id_type(10), distances, predecessors,
+        g, id_type(10), container_value_fn(distances), container_value_fn(predecessors),
         [](const auto& g, const auto& uv) { return edge_value(g, uv); });
 
   REQUIRE(cycle_vertex.has_value());
@@ -540,13 +540,13 @@ TEMPLATE_TEST_CASE("bellman_ford_shortest_paths - sparse source not in graph thr
   using id_type = vertex_id_t<Graph>;
 
   auto g            = map_fixtures::clrs_dijkstra_graph<Graph>();
-  auto distances    = make_vertex_property_map<Graph, int>(g, shortest_path_infinite_distance<int>());
+  auto distances    = make_vertex_property_map<Graph, int>(g, infinite_distance<int>());
   auto predecessors = make_vertex_property_map<Graph, id_type>(g, id_type{});
   for (auto&& [uid, u] : views::vertexlist(g))
     predecessors[uid] = uid;
 
   // Vertex ID 999 does not exist in the sparse graph
-  CHECK_THROWS_AS(bellman_ford_shortest_paths(g, id_type(999), distances, predecessors,
+  CHECK_THROWS_AS(bellman_ford_shortest_paths(g, id_type(999), container_value_fn(distances), container_value_fn(predecessors),
                                               [](const auto& g, const auto& uv) { return edge_value(g, uv); }),
                   std::out_of_range);
 }
diff --git a/tests/algorithms/test_connected_components.cpp b/tests/algorithms/test_connected_components.cpp
index 623f761..45ba739 100644
--- a/tests/algorithms/test_connected_components.cpp
+++ b/tests/algorithms/test_connected_components.cpp
@@ -62,7 +62,7 @@ TEST_CASE("connected_components - single vertex", "[algorithm][connected_compone
   auto                  g = single_vertex<Graph>();
   std::vector<uint32_t> component(num_vertices(g));
 
-  size_t num_components = connected_components(g, component);
+  size_t num_components = connected_components(g, container_value_fn(component));
 
   REQUIRE(num_components == 1);
   REQUIRE(component[0] == 0);
@@ -74,7 +74,7 @@ TEST_CASE("connected_components - single edge", "[algorithm][connected_component
   auto                  g = single_edge<Graph>();
   std::vector<uint32_t> component(num_vertices(g));
 
-  size_t num_components = connected_components(g, component);
+  size_t num_components = connected_components(g, container_value_fn(component));
 
   REQUIRE(num_components == 1);
   REQUIRE(all_same_component(component, {0, 1}));
@@ -87,7 +87,7 @@ TEST_CASE("connected_components - path graph", "[algorithm][connected_components
   auto                  g = path_graph_4<Graph>();
   std::vector<uint32_t> component(num_vertices(g));
 
-  size_t num_components = connected_components(g, component);
+  size_t num_components = connected_components(g, container_value_fn(component));
 
   REQUIRE(num_components == 1);
   REQUIRE(all_same_component(component, {0, 1, 2, 3}));
@@ -100,7 +100,7 @@ TEST_CASE("connected_components - cycle graph", "[algorithm][connected_component
   auto                  g = cycle_graph_5<Graph>();
   std::vector<uint32_t> component(num_vertices(g));
 
-  size_t num_components = connected_components(g, component);
+  size_t num_components = connected_components(g, container_value_fn(component));
 
   REQUIRE(num_components == 1);
   REQUIRE(all_same_component(component, {0, 1, 2, 3, 4}));
@@ -113,7 +113,7 @@ TEST_CASE("connected_components - disconnected graph", "[algorithm][connected_co
   Graph                 g({{0, 1}, {1, 0}, {2, 3}, {3, 2}});
   std::vector<uint32_t> component(num_vertices(g));
 
-  size_t num_components = connected_components(g, component);
+  size_t num_components = connected_components(g, container_value_fn(component));
 
   REQUIRE(num_components == 2);
   REQUIRE(all_same_component(component, {0, 1}));
@@ -129,7 +129,7 @@ TEST_CASE("connected_components - multiple isolated vertices", "[algorithm][conn
   g.resize_vertices(5);
   std::vector<uint32_t> component(num_vertices(g));
 
-  size_t num_components = connected_components(g, component);
+  size_t num_components = connected_components(g, container_value_fn(component));
 
   REQUIRE(num_components == 5);
   for (size_t i = 0; i < 5; ++i) {
@@ -146,7 +146,7 @@ TEST_CASE("connected_components - star graph", "[algorithm][connected_components
   Graph                 g({{0, 1}, {0, 2}, {0, 3}, {0, 4}, {1, 0}, {2, 0}, {3, 0}, {4, 0}});
   std::vector<uint32_t> component(num_vertices(g));
 
-  size_t num_components = connected_components(g, component);
+  size_t num_components = connected_components(g, container_value_fn(component));
 
   REQUIRE(num_components == 1);
   REQUIRE(all_same_component(component, {0, 1, 2, 3, 4}));
@@ -159,7 +159,7 @@ TEST_CASE("connected_components - complete graph", "[algorithm][connected_compon
   Graph g({{0, 1}, {0, 2}, {0, 3}, {1, 0}, {1, 2}, {1, 3}, {2, 0}, {2, 1}, {2, 3}, {3, 0}, {3, 1}, {3, 2}});
   std::vector<uint32_t> component(num_vertices(g));
 
-  size_t num_components = connected_components(g, component);
+  size_t num_components = connected_components(g, container_value_fn(component));
 
   REQUIRE(num_components == 1);
   REQUIRE(all_same_component(component, {0, 1, 2, 3}));
@@ -172,7 +172,7 @@ TEST_CASE("connected_components - tree structure", "[algorithm][connected_compon
   Graph g({{0, 1}, {0, 2}, {1, 0}, {1, 3}, {1, 4}, {2, 0}, {2, 5}, {2, 6}, {3, 1}, {4, 1}, {5, 2}, {6, 2}});
   std::vector<uint32_t> component(num_vertices(g));
 
-  size_t num_components = connected_components(g, component);
+  size_t num_components = connected_components(g, container_value_fn(component));
 
   REQUIRE(num_components == 1);
   REQUIRE(all_same_component(component, {0, 1, 2, 3, 4, 5, 6}));
@@ -188,7 +188,7 @@ TEST_CASE("connected_components - multiple components of different sizes", "[alg
   g.resize_vertices(6); // Add isolated vertex 5
   std::vector<uint32_t> component(num_vertices(g));
 
-  size_t num_components = connected_components(g, component);
+  size_t num_components = connected_components(g, container_value_fn(component));
 
   REQUIRE(num_components == 3);
   REQUIRE(all_same_component(component, {0, 1, 2}));
@@ -225,7 +225,7 @@ TEST_CASE("connected_components - undirected single edge (vov vs UAL)",
     vov_void              g({{0, 1}, {1, 0}});
     std::vector<uint32_t> component(2);
 
-    size_t num = connected_components(g, component);
+    size_t num = connected_components(g, container_value_fn(component));
 
     REQUIRE(num == 1);
     REQUIRE(all_same_component(component, {0, 1}));
@@ -236,7 +236,7 @@ TEST_CASE("connected_components - undirected single edge (vov vs UAL)",
     undirected_adjacency_list<int, int> g({{0, 1, 1}});
     std::vector<uint32_t>               component(2);
 
-    size_t num = connected_components(g, component);
+    size_t num = connected_components(g, container_value_fn(component));
 
     REQUIRE(num == 1);
     REQUIRE(all_same_component(component, {0, 1}));
@@ -256,7 +256,7 @@ TEST_CASE("connected_components - undirected path (vov vs UAL)", "[algorithm][co
     });
     std::vector<uint32_t> component(4);
 
-    size_t num = connected_components(g, component);
+    size_t num = connected_components(g, container_value_fn(component));
 
     REQUIRE(num == 1);
     REQUIRE(all_same_component(component, {0, 1, 2, 3}));
@@ -266,7 +266,7 @@ TEST_CASE("connected_components - undirected path (vov vs UAL)", "[algorithm][co
     undirected_adjacency_list<int, int> g({{0, 1, 1}, {1, 2, 1}, {2, 3, 1}});
     std::vector<uint32_t>               component(4);
 
-    size_t num = connected_components(g, component);
+    size_t num = connected_components(g, container_value_fn(component));
 
     REQUIRE(num == 1);
     REQUIRE(all_same_component(component, {0, 1, 2, 3}));
@@ -284,7 +284,7 @@ TEST_CASE("connected_components - undirected disconnected (vov vs UAL)",
     });
     std::vector<uint32_t> component(4);
 
-    size_t num = connected_components(g, component);
+    size_t num = connected_components(g, container_value_fn(component));
 
     REQUIRE(num == 2);
     REQUIRE(all_same_component(component, {0, 1}));
@@ -296,7 +296,7 @@ TEST_CASE("connected_components - undirected disconnected (vov vs UAL)",
     undirected_adjacency_list<int, int> g({{0, 1, 1}, {2, 3, 1}});
     std::vector<uint32_t>               component(4);
 
-    size_t num = connected_components(g, component);
+    size_t num = connected_components(g, container_value_fn(component));
 
     REQUIRE(num == 2);
     REQUIRE(all_same_component(component, {0, 1}));
@@ -310,7 +310,7 @@ TEST_CASE("connected_components - undirected cycle (vov vs UAL)", "[algorithm][c
     vov_void              g({{0, 1}, {1, 0}, {1, 2}, {2, 1}, {2, 3}, {3, 2}, {3, 4}, {4, 3}, {4, 0}, {0, 4}});
     std::vector<uint32_t> component(5);
 
-    size_t num = connected_components(g, component);
+    size_t num = connected_components(g, container_value_fn(component));
 
     REQUIRE(num == 1);
     REQUIRE(all_same_component(component, {0, 1, 2, 3, 4}));
@@ -320,7 +320,7 @@ TEST_CASE("connected_components - undirected cycle (vov vs UAL)", "[algorithm][c
     undirected_adjacency_list<int, int> g({{0, 1, 1}, {1, 2, 1}, {2, 3, 1}, {3, 4, 1}, {4, 0, 1}});
     std::vector<uint32_t>               component(5);
 
-    size_t num = connected_components(g, component);
+    size_t num = connected_components(g, container_value_fn(component));
 
     REQUIRE(num == 1);
     REQUIRE(all_same_component(component, {0, 1, 2, 3, 4}));
@@ -332,7 +332,7 @@ TEST_CASE("connected_components - undirected triangle (vov vs UAL)", "[algorithm
     vov_void              g({{0, 1}, {1, 0}, {1, 2}, {2, 1}, {2, 0}, {0, 2}});
     std::vector<uint32_t> component(3);
 
-    size_t num = connected_components(g, component);
+    size_t num = connected_components(g, container_value_fn(component));
 
     REQUIRE(num == 1);
     REQUIRE(all_same_component(component, {0, 1, 2}));
@@ -342,7 +342,7 @@ TEST_CASE("connected_components - undirected triangle (vov vs UAL)", "[algorithm
     undirected_adjacency_list<int, int> g({{0, 1, 1}, {1, 2, 1}, {2, 0, 1}});
     std::vector<uint32_t>               component(3);
 
-    size_t num = connected_components(g, component);
+    size_t num = connected_components(g, container_value_fn(component));
 
     REQUIRE(num == 1);
     REQUIRE(all_same_component(component, {0, 1, 2}));
@@ -354,7 +354,7 @@ TEST_CASE("connected_components - undirected star (vov vs UAL)", "[algorithm][co
     vov_void              g({{0, 1}, {1, 0}, {0, 2}, {2, 0}, {0, 3}, {3, 0}, {0, 4}, {4, 0}});
     std::vector<uint32_t> component(5);
 
-    size_t num = connected_components(g, component);
+    size_t num = connected_components(g, container_value_fn(component));
 
     REQUIRE(num == 1);
     REQUIRE(all_same_component(component, {0, 1, 2, 3, 4}));
@@ -364,7 +364,7 @@ TEST_CASE("connected_components - undirected star (vov vs UAL)", "[algorithm][co
     undirected_adjacency_list<int, int> g({{0, 1, 1}, {0, 2, 1}, {0, 3, 1}, {0, 4, 1}});
     std::vector<uint32_t>               component(5);
 
-    size_t num = connected_components(g, component);
+    size_t num = connected_components(g, container_value_fn(component));
 
     REQUIRE(num == 1);
     REQUIRE(all_same_component(component, {0, 1, 2, 3, 4}));
@@ -389,7 +389,7 @@ TEST_CASE("connected_components - undirected complex (vov vs UAL)", "[algorithm]
     g.resize_vertices(6); // Add isolated vertex 5
     std::vector<uint32_t> component(6);
 
-    size_t num = connected_components(g, component);
+    size_t num = connected_components(g, container_value_fn(component));
 
     REQUIRE(num == 3);
     REQUIRE(all_same_component(component, {0, 1, 2}));
@@ -404,7 +404,7 @@ TEST_CASE("connected_components - undirected complex (vov vs UAL)", "[algorithm]
     g.resize_vertices(6); // Add isolated vertex 5
     std::vector<uint32_t> component(6);
 
-    size_t num = connected_components(g, component);
+    size_t num = connected_components(g, container_value_fn(component));
 
     REQUIRE(num == 3);
     REQUIRE(all_same_component(component, {0, 1, 2}));
@@ -426,7 +426,7 @@ TEST_CASE("connected_components (UAL) - single vertex", "[algorithm][connected_c
   g.create_vertex(0);
   std::vector<uint32_t> component(num_vertices(g));
 
-  size_t num_components = connected_components(g, component);
+  size_t num_components = connected_components(g, container_value_fn(component));
 
   REQUIRE(num_components == 1);
   REQUIRE(component[0] == 0);
@@ -438,7 +438,7 @@ TEST_CASE("connected_components (UAL) - single edge", "[algorithm][connected_com
   Graph                 g({{0, 1, 1}});
   std::vector<uint32_t> component(num_vertices(g));
 
-  size_t num_components = connected_components(g, component);
+  size_t num_components = connected_components(g, container_value_fn(component));
 
   REQUIRE(num_components == 1);
   REQUIRE(all_same_component(component, {0, 1}));
@@ -451,7 +451,7 @@ TEST_CASE("connected_components (UAL) - path graph", "[algorithm][connected_comp
   Graph                 g({{0, 1, 1}, {1, 2, 1}, {2, 3, 1}});
   std::vector<uint32_t> component(num_vertices(g));
 
-  size_t num_components = connected_components(g, component);
+  size_t num_components = connected_components(g, container_value_fn(component));
 
   REQUIRE(num_components == 1);
   REQUIRE(all_same_component(component, {0, 1, 2, 3}));
@@ -464,7 +464,7 @@ TEST_CASE("connected_components (UAL) - cycle graph", "[algorithm][connected_com
   Graph                 g({{0, 1, 1}, {1, 2, 1}, {2, 3, 1}, {3, 4, 1}, {4, 0, 1}});
   std::vector<uint32_t> component(num_vertices(g));
 
-  size_t num_components = connected_components(g, component);
+  size_t num_components = connected_components(g, container_value_fn(component));
 
   REQUIRE(num_components == 1);
   REQUIRE(all_same_component(component, {0, 1, 2, 3, 4}));
@@ -477,7 +477,7 @@ TEST_CASE("connected_components (UAL) - disconnected graph", "[algorithm][connec
   Graph                 g({{0, 1, 1}, {2, 3, 1}});
   std::vector<uint32_t> component(num_vertices(g));
 
-  size_t num_components = connected_components(g, component);
+  size_t num_components = connected_components(g, container_value_fn(component));
 
   REQUIRE(num_components == 2);
   REQUIRE(all_same_component(component, {0, 1}));
@@ -495,7 +495,7 @@ TEST_CASE("connected_components (UAL) - isolated vertices", "[algorithm][connect
   }
   std::vector<uint32_t> component(num_vertices(g));
 
-  size_t num_components = connected_components(g, component);
+  size_t num_components = connected_components(g, container_value_fn(component));
 
   REQUIRE(num_components == 5);
   for (size_t i = 0; i < 5; ++i) {
@@ -512,7 +512,7 @@ TEST_CASE("connected_components (UAL) - star graph", "[algorithm][connected_comp
   Graph                 g({{0, 1, 1}, {0, 2, 1}, {0, 3, 1}, {0, 4, 1}});
   std::vector<uint32_t> component(num_vertices(g));
 
-  size_t num_components = connected_components(g, component);
+  size_t num_components = connected_components(g, container_value_fn(component));
 
   REQUIRE(num_components == 1);
   REQUIRE(all_same_component(component, {0, 1, 2, 3, 4}));
@@ -525,7 +525,7 @@ TEST_CASE("connected_components (UAL) - complete graph", "[algorithm][connected_
   Graph                 g({{0, 1, 1}, {0, 2, 1}, {0, 3, 1}, {1, 2, 1}, {1, 3, 1}, {2, 3, 1}});
   std::vector<uint32_t> component(num_vertices(g));
 
-  size_t num_components = connected_components(g, component);
+  size_t num_components = connected_components(g, container_value_fn(component));
 
   REQUIRE(num_components == 1);
   REQUIRE(all_same_component(component, {0, 1, 2, 3}));
@@ -538,7 +538,7 @@ TEST_CASE("connected_components (UAL) - tree structure", "[algorithm][connected_
   Graph                 g({{0, 1, 1}, {0, 2, 1}, {1, 3, 1}, {1, 4, 1}, {2, 5, 1}, {2, 6, 1}});
   std::vector<uint32_t> component(num_vertices(g));
 
-  size_t num_components = connected_components(g, component);
+  size_t num_components = connected_components(g, container_value_fn(component));
 
   REQUIRE(num_components == 1);
   REQUIRE(all_same_component(component, {0, 1, 2, 3, 4, 5, 6}));
@@ -560,7 +560,7 @@ TEST_CASE("connected_components (UAL) - multiple components of different sizes",
   g.resize_vertices(6); // Add isolated vertex 5
   std::vector<uint32_t> component(num_vertices(g));
 
-  size_t num_components = connected_components(g, component);
+  size_t num_components = connected_components(g, container_value_fn(component));
 
   REQUIRE(num_components == 3);
   REQUIRE(all_same_component(component, {0, 1, 2}));
@@ -578,7 +578,7 @@ TEST_CASE("connected_components (UAL) - self loop", "[algorithm][connected_compo
                            {0, 1, 1}});
   std::vector<uint32_t> component(num_vertices(g));
 
-  size_t num_components = connected_components(g, component);
+  size_t num_components = connected_components(g, container_value_fn(component));
 
   REQUIRE(num_components == 1);
   REQUIRE(all_same_component(component, {0, 1}));
@@ -591,7 +591,7 @@ TEST_CASE("connected_components (UAL) - with edge values", "[algorithm][connecte
   Graph                 g({{0, 1, 10}, {1, 2, 20}});
   std::vector<uint32_t> component(num_vertices(g));
 
-  size_t num_components = connected_components(g, component);
+  size_t num_components = connected_components(g, container_value_fn(component));
 
   REQUIRE(num_components == 1);
   REQUIRE(all_same_component(component, {0, 1, 2}));
@@ -608,7 +608,7 @@ TEST_CASE("connected_components (UAL) - with vertex values", "[algorithm][connec
   g.create_edge(0, 1, 1);
   std::vector<uint32_t> component(num_vertices(g));
 
-  size_t num_components = connected_components(g, component);
+  size_t num_components = connected_components(g, container_value_fn(component));
 
   REQUIRE(num_components == 2);
   REQUIRE(all_same_component(component, {0, 1}));
@@ -626,7 +626,7 @@ TEST_CASE("kosaraju - single vertex", "[algorithm][kosaraju][scc]") {
   auto                  g_t = single_vertex<Graph>(); // Transpose
   std::vector<uint32_t> component(num_vertices(g));
 
-  kosaraju(g, g_t, component);
+  kosaraju(g, g_t, container_value_fn(component));
 
   REQUIRE(component[0] == 0);
   REQUIRE(count_unique_components(component) == 1);
@@ -640,7 +640,7 @@ TEST_CASE("kosaraju - simple cycle", "[algorithm][kosaraju][scc]") {
   Graph                 g_t({{1, 0}, {2, 1}, {0, 2}}); // Transpose
   std::vector<uint32_t> component(num_vertices(g));
 
-  kosaraju(g, g_t, component);
+  kosaraju(g, g_t, container_value_fn(component));
 
   // All three vertices should be in the same SCC
   REQUIRE(all_same_component(component, {0, 1, 2}));
@@ -655,7 +655,7 @@ TEST_CASE("kosaraju - two SCCs", "[algorithm][kosaraju][scc]") {
   Graph                 g_t({{1, 0}, {0, 1}, {2, 1}, {3, 2}, {2, 3}}); // Transpose
   std::vector<uint32_t> component(num_vertices(g));
 
-  kosaraju(g, g_t, component);
+  kosaraju(g, g_t, container_value_fn(component));
 
   // Vertices 0 and 1 should be in same SCC
   REQUIRE(all_same_component(component, {0, 1}));
@@ -673,7 +673,7 @@ TEST_CASE("kosaraju - no cycles (DAG)", "[algorithm][kosaraju][scc]") {
   Graph                 g_t({{1, 0}, {2, 1}, {3, 2}}); // Transpose
   std::vector<uint32_t> component(num_vertices(g));
 
-  kosaraju(g, g_t, component);
+  kosaraju(g, g_t, container_value_fn(component));
 
   // Each vertex should be in its own SCC
   REQUIRE(count_unique_components(component) == 4);
@@ -708,7 +708,7 @@ TEST_CASE("kosaraju - complex SCC structure", "[algorithm][kosaraju][scc]") {
                              {5, 4}}); // Cross-SCC edge transposed
   std::vector<uint32_t> component(num_vertices(g));
 
-  kosaraju(g, g_t, component);
+  kosaraju(g, g_t, container_value_fn(component));
 
   REQUIRE(count_unique_components(component) == 3);
   REQUIRE(all_same_component(component, {0, 1, 2}));
@@ -826,7 +826,7 @@ TEST_CASE("connected_components - empty graph", "[algorithm][connected_component
   auto                  g = empty_graph<Graph>();
   std::vector<uint32_t> component;
 
-  size_t num_components = connected_components(g, component);
+  size_t num_components = connected_components(g, container_value_fn(component));
 
   REQUIRE(num_components == 0);
 }
@@ -838,7 +838,7 @@ TEST_CASE("connected_components - self loops", "[algorithm][connected_components
   Graph                 g({{0, 0}, {0, 1}, {1, 0}, {1, 1}});
   std::vector<uint32_t> component(num_vertices(g));
 
-  size_t num_components = connected_components(g, component);
+  size_t num_components = connected_components(g, container_value_fn(component));
 
   REQUIRE(num_components == 1);
   REQUIRE(all_same_component(component, {0, 1}));
@@ -852,7 +852,7 @@ TEST_CASE("kosaraju - self loops", "[algorithm][kosaraju][scc]") {
   Graph                 g_t({{0, 0}, {1, 0}, {1, 1}}); // Transpose
   std::vector<uint32_t> component(num_vertices(g));
 
-  kosaraju(g, g_t, component);
+  kosaraju(g, g_t, container_value_fn(component));
 
   // Self-loops don't create SCCs by themselves without cycles
   // 0 -> 1 is a DAG, so they should be in different SCCs
@@ -872,7 +872,7 @@ TEST_CASE("kosaraju - graph with singleton SCCs", "[algorithm][kosaraju][scc][co
   Graph                 g_t({{1, 0}, {0, 1}, {2, 1}, {3, 2}});
   std::vector<uint32_t> component(num_vertices(g));
 
-  kosaraju(g, g_t, component);
+  kosaraju(g, g_t, container_value_fn(component));
 
   // Verify structure
   REQUIRE(count_unique_components(component) == 3); // {0,1}, {2}, {3}
@@ -901,7 +901,7 @@ TEST_CASE("kosaraju - multiple cycles sharing vertices", "[algorithm][kosaraju][
                              {1, 4}}); // Second cycle transposed
   std::vector<uint32_t> component(num_vertices(g));
 
-  kosaraju(g, g_t, component);
+  kosaraju(g, g_t, container_value_fn(component));
 
   // All vertices should be in the same SCC
   REQUIRE(count_unique_components(component) == 1);
@@ -930,7 +930,7 @@ TEST_CASE("kosaraju - nested SCCs with bridges", "[algorithm][kosaraju][scc][com
                              {4, 5}}); // SCC3 transposed
   std::vector<uint32_t> component(num_vertices(g));
 
-  kosaraju(g, g_t, component);
+  kosaraju(g, g_t, container_value_fn(component));
 
   REQUIRE(count_unique_components(component) == 3);
   REQUIRE(all_same_component(component, {0, 1}));
@@ -948,7 +948,7 @@ TEST_CASE("kosaraju - complete directed graph", "[algorithm][kosaraju][scc][comp
   Graph g_t({{1, 0}, {0, 1}, {2, 0}, {0, 2}, {3, 0}, {0, 3}, {2, 1}, {1, 2}, {3, 1}, {1, 3}, {3, 2}, {2, 3}});
   std::vector<uint32_t> component(num_vertices(g));
 
-  kosaraju(g, g_t, component);
+  kosaraju(g, g_t, container_value_fn(component));
 
   // All vertices should be in one SCC
   REQUIRE(count_unique_components(component) == 1);
@@ -963,7 +963,7 @@ TEST_CASE("kosaraju - star topology DAG", "[algorithm][kosaraju][scc][comprehens
   Graph                 g_t({{1, 0}, {2, 0}, {3, 0}, {4, 0}}); // All point to center
   std::vector<uint32_t> component(num_vertices(g));
 
-  kosaraju(g, g_t, component);
+  kosaraju(g, g_t, container_value_fn(component));
 
   // No cycles, each vertex is its own SCC
   REQUIRE(count_unique_components(component) == 5);
@@ -982,7 +982,7 @@ TEST_CASE("kosaraju - bidirectional star", "[algorithm][kosaraju][scc][comprehen
   Graph                 g_t({{1, 0}, {0, 1}, {2, 0}, {0, 2}, {3, 0}, {0, 3}});
   std::vector<uint32_t> component(num_vertices(g));
 
-  kosaraju(g, g_t, component);
+  kosaraju(g, g_t, container_value_fn(component));
 
   // All vertices in one SCC (can reach each other through center)
   REQUIRE(count_unique_components(component) == 1);
@@ -1017,7 +1017,7 @@ TEST_CASE("kosaraju - long chain of SCCs", "[algorithm][kosaraju][scc][comprehen
                              {6, 7}}); // SCC3
   std::vector<uint32_t> component(num_vertices(g));
 
-  kosaraju(g, g_t, component);
+  kosaraju(g, g_t, container_value_fn(component));
 
   REQUIRE(count_unique_components(component) == 4);
   REQUIRE(all_same_component(component, {0, 1}));
@@ -1034,7 +1034,7 @@ TEST_CASE("kosaraju - converging paths", "[algorithm][kosaraju][scc][comprehensi
   Graph                 g_t({{2, 0}, {2, 1}, {3, 2}, {4, 3}, {2, 4}});
   std::vector<uint32_t> component(num_vertices(g));
 
-  kosaraju(g, g_t, component);
+  kosaraju(g, g_t, container_value_fn(component));
 
   REQUIRE(count_unique_components(component) == 3); // {0}, {1}, {2,3,4}
   REQUIRE(all_same_component(component, {2, 3, 4}));
@@ -1051,7 +1051,7 @@ TEST_CASE("kosaraju - diverging paths", "[algorithm][kosaraju][scc][comprehensiv
   Graph                 g_t({{1, 0}, {0, 1}, {2, 1}, {3, 1}});
   std::vector<uint32_t> component(num_vertices(g));
 
-  kosaraju(g, g_t, component);
+  kosaraju(g, g_t, container_value_fn(component));
 
   REQUIRE(count_unique_components(component) == 3); // {0,1}, {2}, {3}
   REQUIRE(all_same_component(component, {0, 1}));
@@ -1085,7 +1085,7 @@ TEST_CASE("kosaraju - cross edges between SCCs", "[algorithm][kosaraju][scc][com
                              {5, 2}}); // Cross edges
   std::vector<uint32_t> component(num_vertices(g));
 
-  kosaraju(g, g_t, component);
+  kosaraju(g, g_t, container_value_fn(component));
 
   REQUIRE(count_unique_components(component) == 2);
   REQUIRE(all_same_component(component, {0, 1, 2}));
@@ -1101,7 +1101,7 @@ TEST_CASE("kosaraju - triangle with tail", "[algorithm][kosaraju][scc][comprehen
   Graph                 g_t({{1, 0}, {2, 1}, {0, 2}, {3, 2}, {4, 3}});
   std::vector<uint32_t> component(num_vertices(g));
 
-  kosaraju(g, g_t, component);
+  kosaraju(g, g_t, container_value_fn(component));
 
   REQUIRE(count_unique_components(component) == 3); // {0,1,2}, {3}, {4}
   REQUIRE(all_same_component(component, {0, 1, 2}));
@@ -1117,7 +1117,7 @@ TEST_CASE("kosaraju - back edges creating large SCC", "[algorithm][kosaraju][scc
   Graph                 g_t({{1, 0}, {2, 1}, {3, 2}, {4, 3}, {0, 4}});
   std::vector<uint32_t> component(num_vertices(g));
 
-  kosaraju(g, g_t, component);
+  kosaraju(g, g_t, container_value_fn(component));
 
   REQUIRE(count_unique_components(component) == 1);
   REQUIRE(all_same_component(component, {0, 1, 2, 3, 4}));
@@ -1131,7 +1131,7 @@ TEST_CASE("kosaraju - multiple self-loops in cycle", "[algorithm][kosaraju][scc]
   Graph                 g_t({{0, 0}, {1, 0}, {1, 1}, {2, 1}, {2, 2}, {0, 2}});
   std::vector<uint32_t> component(num_vertices(g));
 
-  kosaraju(g, g_t, component);
+  kosaraju(g, g_t, container_value_fn(component));
 
   // Self-loops don't affect the SCC structure
   REQUIRE(count_unique_components(component) == 1);
@@ -1146,7 +1146,7 @@ TEST_CASE("kosaraju - single vertex self-loop only", "[algorithm][kosaraju][scc]
   Graph                 g_t({{0, 0}});
   std::vector<uint32_t> component(num_vertices(g));
 
-  kosaraju(g, g_t, component);
+  kosaraju(g, g_t, container_value_fn(component));
 
   REQUIRE(count_unique_components(component) == 1);
   REQUIRE(component[0] == 0);
@@ -1160,7 +1160,7 @@ TEST_CASE("kosaraju - parallel edges", "[algorithm][kosaraju][scc][comprehensive
   Graph                 g_t({{1, 0}, {1, 0}, {0, 1}, {0, 1}});
   std::vector<uint32_t> component(num_vertices(g));
 
-  kosaraju(g, g_t, component);
+  kosaraju(g, g_t, container_value_fn(component));
 
   // Multiple edges don't change SCC structure
   REQUIRE(count_unique_components(component) == 1);
@@ -1186,7 +1186,7 @@ TEST_CASE("kosaraju - butterfly pattern", "[algorithm][kosaraju][scc][comprehens
                              {2, 4}}); // Triangle 2
   std::vector<uint32_t> component(num_vertices(g));
 
-  kosaraju(g, g_t, component);
+  kosaraju(g, g_t, container_value_fn(component));
 
   // All vertices in one SCC (connected through shared vertex 2)
   REQUIRE(count_unique_components(component) == 1);
@@ -1203,7 +1203,7 @@ TEST_CASE("kosaraju - weakly connected but not strongly", "[algorithm][kosaraju]
   Graph                 g_t({{1, 0}, {2, 1}, {3, 2}});
   std::vector<uint32_t> component(num_vertices(g));
 
-  kosaraju(g, g_t, component);
+  kosaraju(g, g_t, container_value_fn(component));
 
   REQUIRE(count_unique_components(component) == 4);
   for (size_t i = 0; i < 4; ++i) {
@@ -1229,7 +1229,7 @@ TEST_CASE("kosaraju - large component count verification", "[algorithm][kosaraju
   Graph                 g_t({{1, 0}, {2, 1}, {3, 2}, {0, 3}, {4, 3}, {5, 4}, {4, 5}, {6, 5}});
   std::vector<uint32_t> component(num_vertices(g));
 
-  kosaraju(g, g_t, component);
+  kosaraju(g, g_t, container_value_fn(component));
 
   REQUIRE(count_unique_components(component) == 3);
   REQUIRE(all_same_component(component, {0, 1, 2, 3}));
@@ -1287,7 +1287,7 @@ TEMPLATE_TEST_CASE("connected_components - sparse two components",
   Graph g({{10, 20, 1}, {20, 10, 1}, {20, 30, 1}, {30, 20, 1}, {40, 50, 1}, {50, 40, 1}});
   auto component = make_vertex_property_map<Graph, uint32_t>(g, 0);
 
-  size_t num_components = connected_components(g, component);
+  size_t num_components = connected_components(g, container_value_fn(component));
 
   REQUIRE(num_components == 2);
   REQUIRE(sparse_same_component(component, std::vector<id_type>{10, 20, 30}));
@@ -1305,7 +1305,7 @@ TEMPLATE_TEST_CASE("connected_components - sparse single component",
   Graph g({{10, 20, 1}, {20, 10, 1}, {20, 30, 1}, {30, 20, 1}, {30, 40, 1}, {40, 30, 1}});
   auto component = make_vertex_property_map<Graph, uint32_t>(g, 0);
 
-  size_t num_components = connected_components(g, component);
+  size_t num_components = connected_components(g, container_value_fn(component));
 
   REQUIRE(num_components == 1);
   REQUIRE(sparse_same_component(component, std::vector<id_type>{10, 20, 30, 40}));
@@ -1322,7 +1322,7 @@ TEMPLATE_TEST_CASE("connected_components - sparse isolated vertices",
   Graph g({{10, 20, 1}, {20, 10, 1}, {30, 30, 1}, {40, 40, 1}});
   auto component = make_vertex_property_map<Graph, uint32_t>(g, 0);
 
-  size_t num_components = connected_components(g, component);
+  size_t num_components = connected_components(g, container_value_fn(component));
 
   // 10-20 form one component, 30 and 40 are each their own
   REQUIRE(num_components >= 2);
@@ -1396,7 +1396,7 @@ TEMPLATE_TEST_CASE("kosaraju - sparse simple cycle",
   Graph g_t({{20, 10, 1}, {30, 20, 1}, {10, 30, 1}});
   auto component = make_vertex_property_map<Graph, uint32_t>(g, 0);
 
-  kosaraju(g, g_t, component);
+  kosaraju(g, g_t, container_value_fn(component));
 
   REQUIRE(sparse_same_component(component, std::vector<id_type>{10, 20, 30}));
 }
@@ -1412,7 +1412,7 @@ TEMPLATE_TEST_CASE("kosaraju - sparse two SCCs",
   Graph g_t({{20, 10, 1}, {10, 20, 1}, {30, 20, 1}, {40, 30, 1}, {30, 40, 1}});
   auto component = make_vertex_property_map<Graph, uint32_t>(g, 0);
 
-  kosaraju(g, g_t, component);
+  kosaraju(g, g_t, container_value_fn(component));
 
   REQUIRE(sparse_count_unique_components(component) == 2);
   REQUIRE(sparse_same_component(component, std::vector<id_type>{10, 20}));
@@ -1431,7 +1431,7 @@ TEMPLATE_TEST_CASE("kosaraju - sparse DAG (no cycles)",
   Graph g_t({{20, 10, 1}, {30, 20, 1}});
   auto component = make_vertex_property_map<Graph, uint32_t>(g, 0);
 
-  kosaraju(g, g_t, component);
+  kosaraju(g, g_t, container_value_fn(component));
 
   REQUIRE(sparse_count_unique_components(component) == 3);
   REQUIRE(sparse_different_components(component, id_type(10), id_type(20)));
diff --git a/tests/algorithms/test_dijkstra_shortest_paths.cpp b/tests/algorithms/test_dijkstra_shortest_paths.cpp
index 8be9ca2..edd197a 100644
--- a/tests/algorithms/test_dijkstra_shortest_paths.cpp
+++ b/tests/algorithms/test_dijkstra_shortest_paths.cpp
@@ -49,7 +49,9 @@ TEST_CASE("dijkstra_shortest_paths - CLRS example", "[algorithm][dijkstra_shorte
 
   init_shortest_paths(g, distance, predecessor);
 
-  dijkstra_shortest_paths(g, vertex_id_t<Graph>(0), distance, predecessor,
+  dijkstra_shortest_paths(g, vertex_id_t<Graph>(0),
+                          container_value_fn(distance),
+                          container_value_fn(predecessor),
                           [](const auto& g, const auto& uv) { return edge_value(g, uv); });
 
   // Validate against known results from CLRS Figure 24.6
@@ -69,7 +71,9 @@ TEST_CASE("dijkstra_shortest_paths - path graph", "[algorithm][dijkstra_shortest
 
   init_shortest_paths(g, distance, predecessor);
 
-  dijkstra_shortest_paths(g, vertex_id_t<Graph>(0), distance, predecessor,
+  dijkstra_shortest_paths(g, vertex_id_t<Graph>(0),
+                          container_value_fn(distance),
+                          container_value_fn(predecessor),
                           [](const auto& g, const auto& uv) { return edge_value(g, uv); });
 
   // Path: 0 -> 1 -> 2 -> 3 with weight 1 each
@@ -87,7 +91,8 @@ TEST_CASE("dijkstra_shortest_distances - no predecessors", "[algorithm][dijkstra
   init_shortest_paths(g, distance);
 
   // Test distances-only variant (no predecessor tracking)
-  dijkstra_shortest_distances(g, vertex_id_t<Graph>(0), distance,
+  dijkstra_shortest_distances(g, vertex_id_t<Graph>(0),
+                              container_value_fn(distance),
                               [](const auto& g, const auto& uv) { return edge_value(g, uv); });
 
   // Validate distances match expected results
@@ -110,7 +115,9 @@ TEST_CASE("dijkstra_shortest_paths - multi-source", "[algorithm][dijkstra_shorte
   // Start from vertices 0 and 3
   std::vector<vertex_id_t<Graph>> sources = {0, 3};
 
-  dijkstra_shortest_paths(g, sources, distance, predecessor,
+  dijkstra_shortest_paths(g, sources,
+                          container_value_fn(distance),
+                          container_value_fn(predecessor),
                           [](const auto& g, const auto& uv) { return edge_value(g, uv); });
 
   // Both source vertices should have distance 0
@@ -133,7 +140,9 @@ TEST_CASE("dijkstra_shortest_distances - multi-source", "[algorithm][dijkstra_sh
   // Start from vertices 0 and 3
   std::vector<vertex_id_t<Graph>> sources = {0, 3};
 
-  dijkstra_shortest_distances(g, sources, distance, [](const auto& g, const auto& uv) { return edge_value(g, uv); });
+  dijkstra_shortest_distances(g, sources,
+                              container_value_fn(distance),
+                              [](const auto& g, const auto& uv) { return edge_value(g, uv); });
 
   // Both source vertices should have distance 0
   REQUIRE(distance[0] == 0);
@@ -152,7 +161,9 @@ TEST_CASE("dijkstra_shortest_paths - with visitor", "[algorithm][dijkstra_shorte
   CountingVisitor visitor;
 
   dijkstra_shortest_paths(
-        g, vertex_id_t<Graph>(0), distance, predecessor,
+        g, vertex_id_t<Graph>(0),
+        container_value_fn(distance),
+        container_value_fn(predecessor),
         [](const auto& g, const auto& uv) { return edge_value(g, uv); }, visitor);
 
   // Verify visitor was called (should have discovered all 4 vertices, examined them, and relaxed edges)
@@ -176,7 +187,9 @@ TEST_CASE("dijkstra_shortest_paths - unweighted graph (default weight)", "[algor
   init_shortest_paths(g, distance, predecessor);
 
   // Use default weight function (returns 1 for all edges)
-  dijkstra_shortest_paths(g, vertex_id_t<Graph>(0), distance, predecessor);
+  dijkstra_shortest_paths(g, vertex_id_t<Graph>(0),
+                          container_value_fn(distance),
+                          container_value_fn(predecessor));
 
   REQUIRE(distance[0] == 0);
   REQUIRE(distance[1] == 1);
@@ -193,7 +206,9 @@ TEST_CASE("dijkstra_shortest_paths - predecessor path reconstruction", "[algorit
 
   init_shortest_paths(g, distance, predecessor);
 
-  dijkstra_shortest_paths(g, vertex_id_t<Graph>(0), distance, predecessor,
+  dijkstra_shortest_paths(g, vertex_id_t<Graph>(0),
+                          container_value_fn(distance),
+                          container_value_fn(predecessor),
                           [](const auto& g, const auto& uv) { return edge_value(g, uv); });
 
   // Reconstruct path from 0 to 3: should be 0 -> 1 -> 2 -> 3
@@ -228,7 +243,9 @@ TEST_CASE("dijkstra_shortest_paths - unreachable vertices", "[algorithm][dijkstr
 
   init_shortest_paths(g, distance, predecessor);
 
-  dijkstra_shortest_paths(g, vertex_id_t<Graph>(0), distance, predecessor);
+  dijkstra_shortest_paths(g, vertex_id_t<Graph>(0),
+                          container_value_fn(distance),
+                          container_value_fn(predecessor));
 
   // Vertices 0 and 1 should be reachable
   REQUIRE(distance[0] == 0);
@@ -270,7 +287,9 @@ TEST_CASE("dijkstra_shortest_paths - vertex id visitor", "[algorithm][dijkstra_s
   init_shortest_paths(g, distance, predecessor);
 
   IdCountingVisitor visitor;
-  dijkstra_shortest_paths(g, vertex_id_t<Graph>(0), distance, predecessor,
+  dijkstra_shortest_paths(g, vertex_id_t<Graph>(0),
+                          container_value_fn(distance),
+                          container_value_fn(predecessor),
                           [](const auto& g, const auto& uv) { return edge_value(g, uv); }, visitor);
 
   // All 5 vertices should be discovered via id-based callbacks
@@ -287,32 +306,6 @@ TEST_CASE("dijkstra_shortest_paths - vertex id visitor", "[algorithm][dijkstra_s
 // Error / Exception Condition Tests
 // =============================================================================
 
-TEST_CASE("dijkstra_shortest_paths - distances too small throws", "[algorithm][dijkstra_shortest_paths][error]") {
-  using Graph = vov_weighted;
-
-  auto                            g = clrs_dijkstra_graph<Graph>(); // 5 vertices
-  std::vector<int>                distances(2);                     // too small
-  std::vector<vertex_id_t<Graph>> predecessor(num_vertices(g));
-  init_shortest_paths(g, distances, predecessor);
-
-  CHECK_THROWS_AS(dijkstra_shortest_paths(g, vertex_id_t<Graph>(0), distances, predecessor,
-                                          [](const auto& g, const auto& uv) { return edge_value(g, uv); }),
-                  std::out_of_range);
-}
-
-TEST_CASE("dijkstra_shortest_paths - predecessor too small throws", "[algorithm][dijkstra_shortest_paths][error]") {
-  using Graph = vov_weighted;
-
-  auto                            g = clrs_dijkstra_graph<Graph>(); // 5 vertices
-  std::vector<int>                distances(num_vertices(g));
-  std::vector<vertex_id_t<Graph>> predecessor(2); // too small
-  init_shortest_paths(g, distances, predecessor);
-
-  CHECK_THROWS_AS(dijkstra_shortest_paths(g, vertex_id_t<Graph>(0), distances, predecessor,
-                                          [](const auto& g, const auto& uv) { return edge_value(g, uv); }),
-                  std::out_of_range);
-}
-
 TEST_CASE("dijkstra_shortest_paths - source vertex out of range throws", "[algorithm][dijkstra_shortest_paths][error]") {
   using Graph = vov_weighted;
 
@@ -321,7 +314,9 @@ TEST_CASE("dijkstra_shortest_paths - source vertex out of range throws", "[algor
   std::vector<vertex_id_t<Graph>> predecessor(num_vertices(g));
   init_shortest_paths(g, distances, predecessor);
 
-  CHECK_THROWS_AS(dijkstra_shortest_paths(g, vertex_id_t<Graph>(99), distances, predecessor,
+  CHECK_THROWS_AS(dijkstra_shortest_paths(g, vertex_id_t<Graph>(99),
+                                          container_value_fn(distances),
+                                          container_value_fn(predecessor),
                                           [](const auto& g, const auto& uv) { return edge_value(g, uv); }),
                   std::out_of_range);
 }
@@ -335,7 +330,9 @@ TEST_CASE("dijkstra_shortest_paths - negative edge weight throws", "[algorithm][
   init_shortest_paths(g, distances, predecessor);
 
   // Weight function that always returns a negative value triggers the signed-weight guard
-  CHECK_THROWS_AS(dijkstra_shortest_paths(g, vertex_id_t<Graph>(0), distances, predecessor,
+  CHECK_THROWS_AS(dijkstra_shortest_paths(g, vertex_id_t<Graph>(0),
+                                          container_value_fn(distances),
+                                          container_value_fn(predecessor),
                                           [](const auto&, const auto&) { return -1; }),
                   std::out_of_range);
 }
@@ -352,8 +349,10 @@ TEST_CASE("dijkstra_shortest_paths - infinite weight edge triggers logic_error",
   std::vector<vertex_id_t<Graph>> predecessor(num_vertices(g));
   init_shortest_paths(g, distances, predecessor);
 
-  const auto INF = shortest_path_infinite_distance<distance_type>();
-  CHECK_THROWS_AS(dijkstra_shortest_paths(g, vertex_id_t<Graph>(0), distances, predecessor,
+  const auto INF = infinite_distance<distance_type>();
+  CHECK_THROWS_AS(dijkstra_shortest_paths(g, vertex_id_t<Graph>(0),
+                                          container_value_fn(distances),
+                                          container_value_fn(predecessor),
                                           [INF](const auto&, const auto&) { return INF; }),
                   std::logic_error);
 }
@@ -369,7 +368,9 @@ TEST_CASE("dijkstra_shortest_paths - on_edge_not_relaxed visitor callback", "[al
   init_shortest_paths(g, distances, predecessor);
 
   CountingVisitor visitor;
-  dijkstra_shortest_paths(g, vertex_id_t<Graph>(0), distances, predecessor,
+  dijkstra_shortest_paths(g, vertex_id_t<Graph>(0),
+                          container_value_fn(distances),
+                          container_value_fn(predecessor),
                           [](const auto& g, const auto& uv) { return edge_value(g, uv); }, visitor);
 
   CHECK(visitor.edges_not_relaxed > 0);
@@ -397,13 +398,15 @@ TEMPLATE_TEST_CASE("dijkstra_shortest_paths - sparse CLRS example",
   const auto& exp   = clrs_dijkstra_sparse_expected{};
 
   auto g            = map_fixtures::clrs_dijkstra_graph<Graph>();
-  auto distances    = make_vertex_property_map<Graph, int>(g, shortest_path_infinite_distance<int>());
+  auto distances    = make_vertex_property_map<Graph, int>(g, infinite_distance<int>());
   auto predecessors = make_vertex_property_map<Graph, id_type>(g, id_type{});
   // Initialize predecessors: each vertex points to itself
   for (auto&& [uid, u] : views::vertexlist(g))
     predecessors[uid] = uid;
 
-  dijkstra_shortest_paths(g, id_type(exp.s), distances, predecessors,
+  dijkstra_shortest_paths(g, id_type(exp.s),
+                          container_value_fn(distances),
+                          container_value_fn(predecessors),
                           [](const auto& g, const auto& uv) { return edge_value(g, uv); });
 
   // Validate distances against known CLRS results
@@ -423,9 +426,10 @@ TEMPLATE_TEST_CASE("dijkstra_shortest_distances - sparse CLRS example",
   const auto& exp = clrs_dijkstra_sparse_expected{};
 
   auto g         = map_fixtures::clrs_dijkstra_graph<Graph>();
-  auto distances = make_vertex_property_map<Graph, int>(g, shortest_path_infinite_distance<int>());
+  auto distances = make_vertex_property_map<Graph, int>(g, infinite_distance<int>());
 
-  dijkstra_shortest_distances(g, id_type(exp.s), distances,
+  dijkstra_shortest_distances(g, id_type(exp.s),
+                              container_value_fn(distances),
                               [](const auto& g, const auto& uv) { return edge_value(g, uv); });
 
   for (size_t i = 0; i < exp.num_vertices; ++i) {
@@ -441,14 +445,16 @@ TEMPLATE_TEST_CASE("dijkstra_shortest_paths - sparse multi-source",
   const auto& exp = clrs_dijkstra_sparse_expected{};
 
   auto g            = map_fixtures::clrs_dijkstra_graph<Graph>();
-  auto distances    = make_vertex_property_map<Graph, int>(g, shortest_path_infinite_distance<int>());
+  auto distances    = make_vertex_property_map<Graph, int>(g, infinite_distance<int>());
   auto predecessors = make_vertex_property_map<Graph, id_type>(g, id_type{});
   for (auto&& [uid, u] : views::vertexlist(g))
     predecessors[uid] = uid;
 
   // Start from s (10) and y (40)
   std::vector<id_type> sources = {exp.s, exp.y};
-  dijkstra_shortest_paths(g, sources, distances, predecessors,
+  dijkstra_shortest_paths(g, sources,
+                          container_value_fn(distances),
+                          container_value_fn(predecessors),
                           [](const auto& g, const auto& uv) { return edge_value(g, uv); });
 
   // Both sources should have distance 0
@@ -457,7 +463,7 @@ TEMPLATE_TEST_CASE("dijkstra_shortest_paths - sparse multi-source",
 
   // All vertices should be reachable
   for (size_t i = 0; i < exp.num_vertices; ++i) {
-    REQUIRE(distances[exp.vertex_ids[i]] < shortest_path_infinite_distance<int>());
+    REQUIRE(distances[exp.vertex_ids[i]] < infinite_distance<int>());
   }
 }
 
@@ -469,14 +475,16 @@ TEMPLATE_TEST_CASE("dijkstra_shortest_paths - sparse with visitor",
   const auto& exp = clrs_dijkstra_sparse_expected{};
 
   auto g            = map_fixtures::clrs_dijkstra_graph<Graph>();
-  auto distances    = make_vertex_property_map<Graph, int>(g, shortest_path_infinite_distance<int>());
+  auto distances    = make_vertex_property_map<Graph, int>(g, infinite_distance<int>());
   auto predecessors = make_vertex_property_map<Graph, id_type>(g, id_type{});
   for (auto&& [uid, u] : views::vertexlist(g))
     predecessors[uid] = uid;
 
   CountingVisitor visitor;
   dijkstra_shortest_paths(
-        g, id_type(exp.s), distances, predecessors,
+        g, id_type(exp.s),
+        container_value_fn(distances),
+        container_value_fn(predecessors),
         [](const auto& g, const auto& uv) { return edge_value(g, uv); }, visitor);
 
   REQUIRE(visitor.vertices_discovered == static_cast<int>(exp.num_vertices));
@@ -491,13 +499,15 @@ TEMPLATE_TEST_CASE("dijkstra_shortest_paths - sparse source not in graph throws"
   using id_type = vertex_id_t<Graph>;
 
   auto g            = map_fixtures::clrs_dijkstra_graph<Graph>();
-  auto distances    = make_vertex_property_map<Graph, int>(g, shortest_path_infinite_distance<int>());
+  auto distances    = make_vertex_property_map<Graph, int>(g, infinite_distance<int>());
   auto predecessors = make_vertex_property_map<Graph, id_type>(g, id_type{});
   for (auto&& [uid, u] : views::vertexlist(g))
     predecessors[uid] = uid;
 
   // Vertex ID 999 does not exist in the sparse graph
-  CHECK_THROWS_AS(dijkstra_shortest_paths(g, id_type(999), distances, predecessors,
+  CHECK_THROWS_AS(dijkstra_shortest_paths(g, id_type(999),
+                                          container_value_fn(distances),
+                                          container_value_fn(predecessors),
                                           [](const auto& g, const auto& uv) { return edge_value(g, uv); }),
                   std::out_of_range);
 }
@@ -558,12 +568,14 @@ TEMPLATE_TEST_CASE("dijkstra_shortest_paths - string vertex IDs",
   static_assert(std::is_same_v<id_type, std::string>, "vertex_id_t must be std::string");
 
   auto g            = clrs_dijkstra_string_graph<Graph>();
-  auto distances    = make_vertex_property_map<Graph, int>(g, shortest_path_infinite_distance<int>());
+  auto distances    = make_vertex_property_map<Graph, int>(g, infinite_distance<int>());
   auto predecessors = make_vertex_property_map<Graph, id_type>(g, id_type{});
   for (auto&& [uid, u] : views::vertexlist(g))
     predecessors[uid] = uid;
 
-  dijkstra_shortest_paths(g, std::string("s"), distances, predecessors,
+  dijkstra_shortest_paths(g, std::string("s"),
+                          container_value_fn(distances),
+                          container_value_fn(predecessors),
                           [](const auto& g, const auto& uv) { return edge_value(g, uv); });
 
   // Validate all distances
@@ -585,9 +597,10 @@ TEMPLATE_TEST_CASE("dijkstra_shortest_distances - string vertex IDs",
   using id_type = vertex_id_t<Graph>;
 
   auto g         = clrs_dijkstra_string_graph<Graph>();
-  auto distances = make_vertex_property_map<Graph, int>(g, shortest_path_infinite_distance<int>());
+  auto distances = make_vertex_property_map<Graph, int>(g, infinite_distance<int>());
 
-  dijkstra_shortest_distances(g, std::string("s"), distances,
+  dijkstra_shortest_distances(g, std::string("s"),
+                              container_value_fn(distances),
                               [](const auto& g, const auto& uv) { return edge_value(g, uv); });
 
   for (const auto& [vid, expected_dist] : clrs_string_expected::distances) {
@@ -602,14 +615,16 @@ TEMPLATE_TEST_CASE("dijkstra_shortest_paths - string vertex IDs multi-source",
   using id_type = vertex_id_t<Graph>;
 
   auto g            = clrs_dijkstra_string_graph<Graph>();
-  auto distances    = make_vertex_property_map<Graph, int>(g, shortest_path_infinite_distance<int>());
+  auto distances    = make_vertex_property_map<Graph, int>(g, infinite_distance<int>());
   auto predecessors = make_vertex_property_map<Graph, id_type>(g, id_type{});
   for (auto&& [uid, u] : views::vertexlist(g))
     predecessors[uid] = uid;
 
   // Start from "s" and "y"
   std::vector<id_type> sources = {std::string("s"), std::string("y")};
-  dijkstra_shortest_paths(g, sources, distances, predecessors,
+  dijkstra_shortest_paths(g, sources,
+                          container_value_fn(distances),
+                          container_value_fn(predecessors),
                           [](const auto& g, const auto& uv) { return edge_value(g, uv); });
 
   // Both sources should have distance 0
@@ -618,7 +633,7 @@ TEMPLATE_TEST_CASE("dijkstra_shortest_paths - string vertex IDs multi-source",
 
   // All vertices should be reachable
   for (const auto& [vid, _] : clrs_string_expected::distances) {
-    REQUIRE(distances[vid] < shortest_path_infinite_distance<int>());
+    REQUIRE(distances[vid] < infinite_distance<int>());
   }
 }
 
@@ -629,14 +644,16 @@ TEMPLATE_TEST_CASE("dijkstra_shortest_paths - string vertex IDs with visitor",
   using id_type = vertex_id_t<Graph>;
 
   auto g            = clrs_dijkstra_string_graph<Graph>();
-  auto distances    = make_vertex_property_map<Graph, int>(g, shortest_path_infinite_distance<int>());
+  auto distances    = make_vertex_property_map<Graph, int>(g, infinite_distance<int>());
   auto predecessors = make_vertex_property_map<Graph, id_type>(g, id_type{});
   for (auto&& [uid, u] : views::vertexlist(g))
     predecessors[uid] = uid;
 
   CountingVisitor visitor;
   dijkstra_shortest_paths(
-        g, std::string("s"), distances, predecessors,
+        g, std::string("s"),
+        container_value_fn(distances),
+        container_value_fn(predecessors),
         [](const auto& g, const auto& uv) { return edge_value(g, uv); }, visitor);
 
   REQUIRE(visitor.vertices_discovered == static_cast<int>(clrs_string_expected::num_vertices));
@@ -652,13 +669,15 @@ TEMPLATE_TEST_CASE("dijkstra_shortest_paths - string vertex IDs invalid source t
   using id_type = vertex_id_t<Graph>;
 
   auto g            = clrs_dijkstra_string_graph<Graph>();
-  auto distances    = make_vertex_property_map<Graph, int>(g, shortest_path_infinite_distance<int>());
+  auto distances    = make_vertex_property_map<Graph, int>(g, infinite_distance<int>());
   auto predecessors = make_vertex_property_map<Graph, id_type>(g, id_type{});
   for (auto&& [uid, u] : views::vertexlist(g))
     predecessors[uid] = uid;
 
   // "nonexistent" is not a vertex in the graph
-  CHECK_THROWS_AS(dijkstra_shortest_paths(g, std::string("nonexistent"), distances, predecessors,
+  CHECK_THROWS_AS(dijkstra_shortest_paths(g, std::string("nonexistent"),
+                                          container_value_fn(distances),
+                                          container_value_fn(predecessors),
                                           [](const auto& g, const auto& uv) { return edge_value(g, uv); }),
                   std::out_of_range);
 }
@@ -670,12 +689,14 @@ TEMPLATE_TEST_CASE("dijkstra_shortest_paths - string vertex IDs path reconstruct
   using id_type = vertex_id_t<Graph>;
 
   auto g            = clrs_dijkstra_string_graph<Graph>();
-  auto distances    = make_vertex_property_map<Graph, int>(g, shortest_path_infinite_distance<int>());
+  auto distances    = make_vertex_property_map<Graph, int>(g, infinite_distance<int>());
   auto predecessors = make_vertex_property_map<Graph, id_type>(g, id_type{});
   for (auto&& [uid, u] : views::vertexlist(g))
     predecessors[uid] = uid;
 
-  dijkstra_shortest_paths(g, std::string("s"), distances, predecessors,
+  dijkstra_shortest_paths(g, std::string("s"),
+                          container_value_fn(distances),
+                          container_value_fn(predecessors),
                           [](const auto& g, const auto& uv) { return edge_value(g, uv); });
 
   // Reconstruct path from "s" to "x": should be s -> y -> t -> x (cost 5+3+1=9)
diff --git a/tests/algorithms/test_label_propagation.cpp b/tests/algorithms/test_label_propagation.cpp
index fba4ffb..23454eb 100644
--- a/tests/algorithms/test_label_propagation.cpp
+++ b/tests/algorithms/test_label_propagation.cpp
@@ -57,7 +57,7 @@ TEST_CASE("label_propagation - empty graph", "[algorithm][label_propagation]") {
   std::mt19937     rng{42};
 
   // Should return without crash
-  label_propagation(g, label, rng);
+  label_propagation(g, container_value_fn(label), rng);
 
   REQUIRE(label.empty());
 }
@@ -70,7 +70,7 @@ TEST_CASE("label_propagation - single vertex no edges", "[algorithm][label_propa
   std::vector<int> label = {7};
   std::mt19937     rng{42};
 
-  label_propagation(g, label, rng);
+  label_propagation(g, container_value_fn(label), rng);
 
   REQUIRE(label[0] == 7); // unchanged — no neighbours
 }
@@ -84,7 +84,7 @@ TEST_CASE("label_propagation - single edge two different labels", "[algorithm][l
   std::vector<int> label = {10, 20};
   std::mt19937     rng{42};
 
-  label_propagation(g, label, rng);
+  label_propagation(g, container_value_fn(label), rng);
 
   // After convergence both vertices must share one of the original labels
   REQUIRE(label[0] == label[1]);
@@ -100,7 +100,7 @@ TEST_CASE("label_propagation - path graph all same label", "[algorithm][label_pr
   std::vector<int> label = {5, 5, 5, 5};
   std::mt19937     rng{42};
 
-  label_propagation(g, label, rng);
+  label_propagation(g, container_value_fn(label), rng);
 
   // Already converged — should stay the same
   for (auto& l : label) {
@@ -116,7 +116,7 @@ TEST_CASE("label_propagation - path graph alternating labels", "[algorithm][labe
   std::vector<int> label = {0, 1, 0, 1};
   std::mt19937     rng{42};
 
-  label_propagation(g, label, rng);
+  label_propagation(g, container_value_fn(label), rng);
 
   // Should reach a stable result (all vertices have some valid label)
   std::set<int> valid = {0, 1};
@@ -132,7 +132,7 @@ TEST_CASE("label_propagation - cycle graph 5 vertices", "[algorithm][label_propa
   std::vector<int> label = {0, 1, 2, 3, 4};
   std::mt19937     rng{42};
 
-  label_propagation(g, label, rng);
+  label_propagation(g, container_value_fn(label), rng);
 
   // All vertices should converge to a single label
   REQUIRE(fully_converged(label));
@@ -148,7 +148,7 @@ TEST_CASE("label_propagation - complete graph K4 majority wins", "[algorithm][la
   std::vector<int> label = {99, 99, 99, 42};
   std::mt19937     rng{42};
 
-  label_propagation(g, label, rng);
+  label_propagation(g, container_value_fn(label), rng);
 
   // Majority label should win
   for (auto& l : label) {
@@ -165,7 +165,7 @@ TEST_CASE("label_propagation - disconnected graph", "[algorithm][label_propagati
   std::vector<int> label = {10, 20, 30, 40};
   std::mt19937     rng{42};
 
-  label_propagation(g, label, rng);
+  label_propagation(g, container_value_fn(label), rng);
 
   // Each component converges independently
   REQUIRE(label[0] == label[1]);
@@ -183,7 +183,7 @@ TEST_CASE("label_propagation - max_iters = 0", "[algorithm][label_propagation]")
   std::vector<int> label = {10, 20};
   std::mt19937     rng{42};
 
-  label_propagation(g, label, rng, size_t{0});
+  label_propagation(g, container_value_fn(label), rng, size_t{0});
 
   // No iterations performed — labels unchanged
   REQUIRE(label[0] == 10);
@@ -206,7 +206,7 @@ TEST_CASE("label_propagation - max_iters = 1", "[algorithm][label_propagation]")
   std::vector<int> label = {0, 1, 1, 1, 1};
   std::mt19937     rng{42};
 
-  label_propagation(g, label, rng, size_t{1});
+  label_propagation(g, container_value_fn(label), rng, size_t{1});
 
   // After exactly one round: centre 0 should adopt label 1 (majority of neighbours)
   // Leaves may or may not change depending on processing order, but centre should change.
@@ -223,7 +223,7 @@ TEST_CASE("label_propagation - all vertices same label", "[algorithm][label_prop
   std::vector<int> label = {3, 3, 3};
   std::mt19937     rng{42};
 
-  label_propagation(g, label, rng);
+  label_propagation(g, container_value_fn(label), rng);
 
   // Already converged — should stay unchanged
   for (auto& l : label) {
@@ -240,7 +240,7 @@ TEST_CASE("label_propagation - tie breaking", "[algorithm][label_propagation]")
   std::vector<int> label = {10, 20, 30};
   std::mt19937     rng{42};
 
-  label_propagation(g, label, rng);
+  label_propagation(g, container_value_fn(label), rng);
 
   // Result should be one of the original labels (not some arbitrary value)
   std::set<int> valid = {10, 20, 30};
@@ -261,7 +261,7 @@ TEST_CASE("label_propagation - empty_label: all unlabelled", "[algorithm][label_
   std::vector<int> label = {-1, -1, -1};
   std::mt19937     rng{42};
 
-  label_propagation(g, label, -1, rng);
+  label_propagation(g, container_value_fn(label), -1, rng);
 
   // All unlabelled, no source of labels — should remain -1
   for (auto& l : label) {
@@ -278,7 +278,7 @@ TEST_CASE("label_propagation - empty_label: one labelled vertex propagates", "[a
   std::vector<int> label = {42, -1, -1, -1};
   std::mt19937     rng{42};
 
-  label_propagation(g, label, -1, rng);
+  label_propagation(g, container_value_fn(label), -1, rng);
 
   // Label should propagate outward from vertex 0
   for (auto& l : label) {
@@ -297,7 +297,7 @@ TEST_CASE("label_propagation - empty_label: disconnected labelled + unlabelled",
   std::vector<int> label = {5, 5, -1, -1};
   std::mt19937     rng{42};
 
-  label_propagation(g, label, -1, rng);
+  label_propagation(g, container_value_fn(label), -1, rng);
 
   // Component 1 stays labelled
   REQUIRE(label[0] == 5);
@@ -317,7 +317,7 @@ TEST_CASE("label_propagation - empty_label: mixed pre-labelled and unlabelled",
   std::vector<int> label = {7, -1, 7, -1};
   std::mt19937     rng{42};
 
-  label_propagation(g, label, -1, rng);
+  label_propagation(g, container_value_fn(label), -1, rng);
 
   // All should acquire label 7
   for (auto& l : label) {
@@ -337,8 +337,8 @@ TEST_CASE("label_propagation - empty_label: no empty labels present behaves like
   std::mt19937     rng1{42};
   std::mt19937     rng2{42};
 
-  label_propagation(g, label1, rng1);
-  label_propagation(g, label2, -1, rng2);
+  label_propagation(g, container_value_fn(label1), rng1);
+  label_propagation(g, container_value_fn(label2), -1, rng2);
 
   // Both overloads should produce the same result
   REQUIRE(label1 == label2);
@@ -357,7 +357,7 @@ TEMPLATE_TEST_CASE("label_propagation - single edge (typed)", "[algorithm][label
   std::vector<int> label = {10, 20};
   std::mt19937     rng{42};
 
-  label_propagation(g, label, rng);
+  label_propagation(g, container_value_fn(label), rng);
 
   REQUIRE(label[0] == label[1]);
   REQUIRE((label[0] == 10 || label[0] == 20));
@@ -372,7 +372,7 @@ TEMPLATE_TEST_CASE("label_propagation - path graph (typed)", "[algorithm][label_
   std::vector<int> label = {1, 2, 1, 2};
   std::mt19937     rng{42};
 
-  label_propagation(g, label, rng);
+  label_propagation(g, container_value_fn(label), rng);
 
   std::set<int> valid = {1, 2};
   REQUIRE(all_labelled(label, valid));
@@ -387,7 +387,7 @@ TEMPLATE_TEST_CASE("label_propagation - cycle graph (typed)", "[algorithm][label
   std::vector<int> label = {0, 1, 2, 3, 4};
   std::mt19937     rng{42};
 
-  label_propagation(g, label, rng);
+  label_propagation(g, container_value_fn(label), rng);
 
   REQUIRE(fully_converged(label));
 }
@@ -401,7 +401,7 @@ TEMPLATE_TEST_CASE("label_propagation - disconnected graph (typed)", "[algorithm
   std::vector<int> label = {10, 20, 30, 40};
   std::mt19937     rng{42};
 
-  label_propagation(g, label, rng);
+  label_propagation(g, container_value_fn(label), rng);
 
   REQUIRE(label[0] == label[1]);
   REQUIRE(label[2] == label[3]);
@@ -446,7 +446,7 @@ TEMPLATE_TEST_CASE("label_propagation - sparse single edge",
   label[20]  = 200;
 
   std::mt19937 rng{42};
-  label_propagation(g, label, rng);
+  label_propagation(g, container_value_fn(label), rng);
 
   // Both should converge to same label
   REQUIRE(label[10] == label[20]);
@@ -465,7 +465,7 @@ TEMPLATE_TEST_CASE("label_propagation - sparse path all same label",
   auto label = make_vertex_property_map<Graph, int>(g, 5);
 
   std::mt19937 rng{42};
-  label_propagation(g, label, rng);
+  label_propagation(g, container_value_fn(label), rng);
 
   // Already converged — should stay unchanged
   REQUIRE(label[10] == 5);
@@ -490,7 +490,7 @@ TEMPLATE_TEST_CASE("label_propagation - sparse K4 majority wins",
   label[40]  = 42; // minority
 
   std::mt19937 rng{42};
-  label_propagation(g, label, rng);
+  label_propagation(g, container_value_fn(label), rng);
 
   // Majority label 99 should win
   REQUIRE(label[10] == 99);
@@ -515,7 +515,7 @@ TEMPLATE_TEST_CASE("label_propagation - sparse disconnected",
   label[40]  = 400;
 
   std::mt19937 rng{42};
-  label_propagation(g, label, rng);
+  label_propagation(g, container_value_fn(label), rng);
 
   // Each component converges independently
   REQUIRE(label[10] == label[20]);
@@ -537,7 +537,7 @@ TEMPLATE_TEST_CASE("label_propagation - sparse empty_label propagation",
   label[10]  = 42; // only vertex 10 is labelled
 
   std::mt19937 rng{42};
-  label_propagation(g, label, -1, rng);
+  label_propagation(g, container_value_fn(label), -1, rng);
 
   // Label should propagate from vertex 10 outward
   REQUIRE(label[10] == 42);
diff --git a/tests/algorithms/test_mst.cpp b/tests/algorithms/test_mst.cpp
index c023f38..8589c02 100644
--- a/tests/algorithms/test_mst.cpp
+++ b/tests/algorithms/test_mst.cpp
@@ -309,7 +309,9 @@ TEST_CASE("prim - simple triangle", "[algorithm][mst][prim]") {
   std::vector<int>      weight(3);
   init_shortest_paths(g, weight, predecessor);
 
-  auto total_wt = prim(g, 0, predecessor, weight);
+  auto total_wt = prim(g, 0,
+                       container_value_fn(weight),
+                       container_value_fn(predecessor));
 
   // Check MST properties
   REQUIRE(predecessor[0] == 0); // Root
@@ -330,7 +332,9 @@ TEST_CASE("prim - linear graph", "[algorithm][mst][prim]") {
   std::vector<int>      weight(4);
   init_shortest_paths(g, weight, predecessor);
 
-  prim(g, 0, predecessor, weight);
+  prim(g, 0,
+       container_value_fn(weight),
+       container_value_fn(predecessor));
 
   REQUIRE(predecessor[0] == 0); // Root
 
@@ -360,7 +364,9 @@ TEST_CASE("prim - complete graph K4", "[algorithm][mst][prim]") {
   std::vector<int>      weight(4);
   init_shortest_paths(g, weight, predecessor);
 
-  prim(g, 0, predecessor, weight);
+  prim(g, 0,
+       container_value_fn(weight),
+       container_value_fn(predecessor));
 
   REQUIRE(predecessor[0] == 0);
 
@@ -400,7 +406,9 @@ TEST_CASE("kruskal and prim produce same MST weight", "[algorithm][mst]") {
   std::vector<uint32_t> predecessor(5);
   std::vector<int>      weight(5);
   init_shortest_paths(g, weight, predecessor);
-  prim(g, 0, predecessor, weight);
+  prim(g, 0,
+       container_value_fn(weight),
+       container_value_fn(predecessor));
 
   int prim_weight = weight[1] + weight[2] + weight[3] + weight[4];
 
@@ -424,7 +432,9 @@ TEST_CASE("prim - undirected_adjacency_list triangle", "[algorithm][mst][prim][u
   std::vector<int>      weight(3);
   init_shortest_paths(g, weight, predecessor);
 
-  auto total_wt = prim(g, 0, predecessor, weight);
+  auto total_wt = prim(g, 0,
+                       container_value_fn(weight),
+                       container_value_fn(predecessor));
 
   // Check MST properties
   REQUIRE(predecessor[0] == 0); // Root
@@ -446,7 +456,9 @@ TEST_CASE("prim - undirected_adjacency_list linear graph", "[algorithm][mst][pri
   std::vector<int>      weight(4);
   init_shortest_paths(g, weight, predecessor);
 
-  auto total_wt = prim(g, 0, predecessor, weight);
+  auto total_wt = prim(g, 0,
+                       container_value_fn(weight),
+                       container_value_fn(predecessor));
 
   REQUIRE(predecessor[0] == 0); // Root
 
@@ -466,7 +478,9 @@ TEST_CASE("prim - undirected_adjacency_list complete graph K4", "[algorithm][mst
   std::vector<int>      weight(4);
   init_shortest_paths(g, weight, predecessor);
 
-  auto total_wt = prim(g, 0, predecessor, weight);
+  auto total_wt = prim(g, 0,
+                       container_value_fn(weight),
+                       container_value_fn(predecessor));
 
   REQUIRE(predecessor[0] == 0);
 
@@ -486,7 +500,9 @@ TEST_CASE("prim - undirected_adjacency_list CLRS example", "[algorithm][mst][pri
   std::vector<int>      weight(5);
   init_shortest_paths(g, weight, predecessor);
 
-  auto total_wt = prim(g, 0, predecessor, weight);
+  auto total_wt = prim(g, 0,
+                       container_value_fn(weight),
+                       container_value_fn(predecessor));
 
   REQUIRE(predecessor[0] == 0); // Root
 
@@ -520,7 +536,9 @@ TEMPLATE_TEST_CASE("prim - sparse triangle",
   auto weight_map  = make_vertex_property_map<Graph, int>(g, 0);
   init_shortest_paths(g, weight_map, predecessor);
 
-  auto total_wt = prim(g, id_type(10), predecessor, weight_map);
+  auto total_wt = prim(g, id_type(10),
+                       container_value_fn(weight_map),
+                       container_value_fn(predecessor));
 
   REQUIRE(predecessor[id_type(10)] == id_type(10)); // Root
   REQUIRE(total_wt == 3);                           // 1 + 2
@@ -539,7 +557,9 @@ TEMPLATE_TEST_CASE("prim - sparse linear graph",
   auto weight_map  = make_vertex_property_map<Graph, int>(g, 0);
   init_shortest_paths(g, weight_map, predecessor);
 
-  auto total_wt = prim(g, id_type(10), predecessor, weight_map);
+  auto total_wt = prim(g, id_type(10),
+                       container_value_fn(weight_map),
+                       container_value_fn(predecessor));
 
   REQUIRE(predecessor[id_type(10)] == id_type(10)); // Root
   REQUIRE(total_wt == 6);                           // 1 + 2 + 3
@@ -559,7 +579,9 @@ TEMPLATE_TEST_CASE("prim - sparse complete graph K4",
   auto weight_map  = make_vertex_property_map<Graph, int>(g, 0);
   init_shortest_paths(g, weight_map, predecessor);
 
-  auto total_wt = prim(g, id_type(10), predecessor, weight_map);
+  auto total_wt = prim(g, id_type(10),
+                       container_value_fn(weight_map),
+                       container_value_fn(predecessor));
 
   REQUIRE(predecessor[id_type(10)] == id_type(10)); // Root
   REQUIRE(total_wt == 6);                           // Same as contiguous K4 test
@@ -587,7 +609,9 @@ TEMPLATE_TEST_CASE("prim - sparse kruskal comparison",
   auto predecessor = make_vertex_property_map<Graph, id_type>(g, id_type{});
   auto weight_map  = make_vertex_property_map<Graph, int>(g, 0);
   init_shortest_paths(g, weight_map, predecessor);
-  auto prim_weight = prim(g, id_type(10), predecessor, weight_map);
+  auto prim_weight = prim(g, id_type(10),
+                          container_value_fn(weight_map),
+                          container_value_fn(predecessor));
 
   REQUIRE(kruskal_weight == prim_weight);
 }
@@ -604,5 +628,8 @@ TEMPLATE_TEST_CASE("prim - sparse invalid seed throws",
   auto weight_map  = make_vertex_property_map<Graph, int>(g, 0);
   init_shortest_paths(g, weight_map, predecessor);
 
-  CHECK_THROWS_AS(prim(g, id_type(999), predecessor, weight_map), std::out_of_range);
+  CHECK_THROWS_AS(prim(g, id_type(999),
+                       container_value_fn(weight_map),
+                       container_value_fn(predecessor)),
+                  std::out_of_range);
 }
diff --git a/tests/algorithms/test_scc_bidirectional.cpp b/tests/algorithms/test_scc_bidirectional.cpp
index fa0963f..5dacc5b 100644
--- a/tests/algorithms/test_scc_bidirectional.cpp
+++ b/tests/algorithms/test_scc_bidirectional.cpp
@@ -110,7 +110,7 @@ TEST_CASE("kosaraju bidir - single vertex (vov)", "[algorithm][kosaraju][scc][bi
   auto g = single_vertex<bidir_vov_void>();
 
   std::vector<uint32_t> component(num_vertices(g));
-  kosaraju(g, component);
+  kosaraju(g, container_value_fn(component));
 
   REQUIRE(component[0] == 0);
   REQUIRE(count_unique_components(component) == 1);
@@ -120,7 +120,7 @@ TEST_CASE("kosaraju bidir - single vertex (vol)", "[algorithm][kosaraju][scc][bi
   auto g = single_vertex<bidir_vol_void>();
 
   std::vector<uint32_t> component(num_vertices(g));
-  kosaraju(g, component);
+  kosaraju(g, container_value_fn(component));
 
   REQUIRE(component[0] == 0);
   REQUIRE(count_unique_components(component) == 1);
@@ -135,7 +135,7 @@ TEST_CASE("kosaraju bidir - simple cycle (vov)", "[algorithm][kosaraju][scc][bid
   bidir_vov_void        g({{0, 1}, {1, 2}, {2, 0}});
   std::vector<uint32_t> component(num_vertices(g));
 
-  kosaraju(g, component);
+  kosaraju(g, container_value_fn(component));
 
   REQUIRE(all_same_component(component, {0, 1, 2}));
   REQUIRE(count_unique_components(component) == 1);
@@ -145,7 +145,7 @@ TEST_CASE("kosaraju bidir - simple cycle (vol)", "[algorithm][kosaraju][scc][bid
   bidir_vol_void        g({{0, 1}, {1, 2}, {2, 0}});
   std::vector<uint32_t> component(num_vertices(g));
 
-  kosaraju(g, component);
+  kosaraju(g, container_value_fn(component));
 
   REQUIRE(all_same_component(component, {0, 1, 2}));
   REQUIRE(count_unique_components(component) == 1);
@@ -162,7 +162,7 @@ TEST_CASE("kosaraju bidir - two SCCs (vov)", "[algorithm][kosaraju][scc][bidirec
   bidir_vov_void        g({{0, 1}, {1, 0}, {1, 2}, {2, 3}, {3, 2}});
   std::vector<uint32_t> component(num_vertices(g));
 
-  kosaraju(g, component);
+  kosaraju(g, container_value_fn(component));
 
   REQUIRE(all_same_component(component, {0, 1}));
   REQUIRE(all_same_component(component, {2, 3}));
@@ -174,7 +174,7 @@ TEST_CASE("kosaraju bidir - two SCCs (vol)", "[algorithm][kosaraju][scc][bidirec
   bidir_vol_void        g({{0, 1}, {1, 0}, {1, 2}, {2, 3}, {3, 2}});
   std::vector<uint32_t> component(num_vertices(g));
 
-  kosaraju(g, component);
+  kosaraju(g, container_value_fn(component));
 
   REQUIRE(all_same_component(component, {0, 1}));
   REQUIRE(all_same_component(component, {2, 3}));
@@ -191,7 +191,7 @@ TEST_CASE("kosaraju bidir - DAG (vov)", "[algorithm][kosaraju][scc][bidirectiona
   bidir_vov_void        g({{0, 1}, {1, 2}, {2, 3}});
   std::vector<uint32_t> component(num_vertices(g));
 
-  kosaraju(g, component);
+  kosaraju(g, container_value_fn(component));
 
   REQUIRE(count_unique_components(component) == 4);
   for (size_t i = 0; i < 4; ++i)
@@ -203,7 +203,7 @@ TEST_CASE("kosaraju bidir - DAG (vol)", "[algorithm][kosaraju][scc][bidirectiona
   bidir_vol_void        g({{0, 1}, {1, 2}, {2, 3}});
   std::vector<uint32_t> component(num_vertices(g));
 
-  kosaraju(g, component);
+  kosaraju(g, container_value_fn(component));
 
   REQUIRE(count_unique_components(component) == 4);
   for (size_t i = 0; i < 4; ++i)
@@ -223,7 +223,7 @@ TEST_CASE("kosaraju bidir - complex SCCs (vov)", "[algorithm][kosaraju][scc][bid
   bidir_vov_void g({{0, 1}, {1, 2}, {2, 0}, {2, 3}, {3, 4}, {4, 3}, {4, 5}});
 
   std::vector<uint32_t> component(num_vertices(g));
-  kosaraju(g, component);
+  kosaraju(g, container_value_fn(component));
 
   REQUIRE(count_unique_components(component) == 3);
   REQUIRE(all_same_component(component, {0, 1, 2}));
@@ -237,7 +237,7 @@ TEST_CASE("kosaraju bidir - complex SCCs (vol)", "[algorithm][kosaraju][scc][bid
   bidir_vol_void g({{0, 1}, {1, 2}, {2, 0}, {2, 3}, {3, 4}, {4, 3}, {4, 5}});
 
   std::vector<uint32_t> component(num_vertices(g));
-  kosaraju(g, component);
+  kosaraju(g, container_value_fn(component));
 
   REQUIRE(count_unique_components(component) == 3);
   REQUIRE(all_same_component(component, {0, 1, 2}));
@@ -256,7 +256,7 @@ TEST_CASE("kosaraju bidir - self loops", "[algorithm][kosaraju][scc][bidirection
   bidir_vov_void        g({{0, 0}, {1, 1}, {0, 1}});
   std::vector<uint32_t> component(num_vertices(g));
 
-  kosaraju(g, component);
+  kosaraju(g, container_value_fn(component));
 
   // Each vertex is its own SCC (self-loop doesn't merge with others)
   REQUIRE(count_unique_components(component) == 2);
@@ -281,8 +281,8 @@ TEST_CASE("kosaraju bidir - agrees with two-graph overload", "[algorithm][kosara
   std::vector<uint32_t> comp_bidir(num_vertices(g_bidir));
   std::vector<uint32_t> comp_twog(num_vertices(g_fwd));
 
-  kosaraju(g_bidir, comp_bidir);
-  kosaraju(g_fwd, g_rev, comp_twog);
+  kosaraju(g_bidir, container_value_fn(comp_bidir));
+  kosaraju(g_fwd, g_rev, container_value_fn(comp_twog));
 
   // Both should find the same number of SCCs
   REQUIRE(count_unique_components(comp_bidir) == count_unique_components(comp_twog));
@@ -304,7 +304,7 @@ TEST_CASE("kosaraju bidir - weighted edges ignored", "[algorithm][kosaraju][scc]
   bidir_vov_int         g({{0, 1, 10}, {1, 2, 20}, {2, 0, 30}});
   std::vector<uint32_t> component(num_vertices(g));
 
-  kosaraju(g, component);
+  kosaraju(g, container_value_fn(component));
 
   REQUIRE(all_same_component(component, {0, 1, 2}));
   REQUIRE(count_unique_components(component) == 1);
@@ -320,7 +320,7 @@ TEST_CASE("kosaraju bidir - disconnected graph", "[algorithm][kosaraju][scc][bid
 
   // Need 5 vertices (0-4). Graph constructor infers from max vertex id in edge list.
   std::vector<uint32_t> component(num_vertices(g));
-  kosaraju(g, component);
+  kosaraju(g, container_value_fn(component));
 
   REQUIRE(count_unique_components(component) == 3);
   REQUIRE(all_same_component(component, {0, 1}));
diff --git a/tests/container/dynamic_graph/test_dynamic_graph_integration.cpp b/tests/container/dynamic_graph/test_dynamic_graph_integration.cpp
index f4ed8a1..64c239a 100644
--- a/tests/container/dynamic_graph/test_dynamic_graph_integration.cpp
+++ b/tests/container/dynamic_graph/test_dynamic_graph_integration.cpp
@@ -113,14 +113,6 @@ static_assert(std::is_reference_v<graph::adj_list::raw_vertex_id_t<mos_void>>,
 static_assert(std::is_same_v<graph::adj_list::vertex_id_t<mos_void>, std::string>,
               "vertex_id_t for map-based graphs should be std::string (value type)");
 
-// vertex_id_store_t: value for integral, reference_wrapper for map-based
-static_assert(sizeof(graph::vertex_id_store_t<vov_void>) == sizeof(uint64_t) &&
-                  std::is_unsigned_v<graph::vertex_id_store_t<vov_void>>,
-              "vertex_id_store_t for vector-based graphs should be a 64-bit unsigned integral type");
-static_assert(std::is_same_v<graph::vertex_id_store_t<mos_void>,
-                             std::reference_wrapper<const std::string>>,
-              "vertex_id_store_t for map-based graphs should be reference_wrapper<const string>");
-
 //==================================================================================================
 // Helper: Count all edges
 //==================================================================================================