From 413bd88b2cfb058864d28c1372107dc0512fbe35 Mon Sep 17 00:00:00 2001
From: BenPinet <be.pinet@gmail.com>
Date: Thu, 6 Aug 2026 14:06:21 +0200
Subject: [PATCH 1/3] fix(MakeTuple): remove std::make_tuple and std::make_pair

---
 include/geode/geometry/detail/aabb_impl.hpp   |   4 +-
 .../representation/builder/detail/copy.hpp    |   4 +-
 src/geode/geometry/basic_objects/triangle.cpp |   7 +-
 src/geode/geometry/bounding_box.cpp           |   2 +-
 src/geode/geometry/distance.cpp               | 134 +++++++++---------
 src/geode/geometry/intersection.cpp           |   4 +-
 src/geode/mesh/core/solid_mesh.cpp            |  11 +-
 src/geode/mesh/core/tetrahedral_solid.cpp     |   6 +-
 .../mesh/helpers/gradient_computation.cpp     |   8 +-
 src/geode/mesh/helpers/rasterize.cpp          |  14 +-
 .../model/helpers/aabb_model_helpers.cpp      |  10 +-
 .../model/helpers/component_mesh_polygons.cpp |  43 +++---
 .../model/helpers/convert_brep_section.cpp    |  16 +--
 src/geode/model/helpers/convert_to_mesh.cpp   |  32 +++--
 .../detail/split_along_block_mesh_borders.cpp |  10 +-
 .../model/helpers/surface_radial_sort.cpp     |   2 +-
 .../mixin/core/detail/relationships_impl.cpp  |   3 +-
 17 files changed, 168 insertions(+), 142 deletions(-)

diff --git a/include/geode/geometry/detail/aabb_impl.hpp b/include/geode/geometry/detail/aabb_impl.hpp
index f5ed6df9c..3d4473cc3 100644
--- a/include/geode/geometry/detail/aabb_impl.hpp
+++ b/include/geode/geometry/detail/aabb_impl.hpp
@@ -486,7 +486,7 @@ namespace geode
     {
         if( nb_bboxes() == 0 )
         {
-            return std::make_tuple( NO_ID, 0 );
+            return { NO_ID, 0 };
         }
         auto nearest_box = impl_->closest_element_box_hint( query );
         auto distance = action( query, nearest_box );
@@ -494,7 +494,7 @@ namespace geode
             Impl::ROOT_INDEX, 0, nb_bboxes(), action );
         OpenGeodeGeometryException::check_assertion(
             nearest_box != NO_ID, "No box found" );
-        return std::make_tuple( nearest_box, distance );
+        return { nearest_box, distance };
     }
 
     template < index_t dimension >
diff --git a/include/geode/model/representation/builder/detail/copy.hpp b/include/geode/model/representation/builder/detail/copy.hpp
index 0a250c3b6..0e5f34276 100644
--- a/include/geode/model/representation/builder/detail/copy.hpp
+++ b/include/geode/model/representation/builder/detail/copy.hpp
@@ -313,8 +313,8 @@ namespace geode
             for( const auto& component : range )
             {
                 tasks[count] = async::spawn( [&result, count, &component] {
-                    result[count] = std::make_pair(
-                        component.id(), component.mesh().clone() );
+                    result[count] = { component.id(),
+                        component.mesh().clone() };
                 } );
                 count++;
             }
diff --git a/src/geode/geometry/basic_objects/triangle.cpp b/src/geode/geometry/basic_objects/triangle.cpp
index 8e96c6248..5341f969b 100644
--- a/src/geode/geometry/basic_objects/triangle.cpp
+++ b/src/geode/geometry/basic_objects/triangle.cpp
@@ -182,7 +182,7 @@ namespace geode
         if( result->pivot != NO_LID )
         {
             return std::optional< std::pair< local_index_t, Vector3D > >{
-                std::make_pair( result->pivot, result->normal )
+                std::in_place, result->pivot, result->normal
             };
         }
         const auto max = absl::c_max_element( result->lengths );
@@ -205,7 +205,10 @@ namespace geode
             {
                 return std::nullopt;
             }
-            return std::make_pair( e2, result_left->normal );
+            return std::optional<
+                std::pair< local_index_t, Vector< dimension > > >{
+                std::in_place, e2, result_left->normal
+            };
         }
         return std::nullopt;
     }
diff --git a/src/geode/geometry/bounding_box.cpp b/src/geode/geometry/bounding_box.cpp
index d3ab82daa..4d1ba2e3f 100644
--- a/src/geode/geometry/bounding_box.cpp
+++ b/src/geode/geometry/bounding_box.cpp
@@ -217,7 +217,7 @@ namespace
                 axis = i;
             }
         }
-        return std::make_tuple( axis, length );
+        return { axis, length };
     }
 } // namespace
 
diff --git a/src/geode/geometry/distance.cpp b/src/geode/geometry/distance.cpp
index bba7dd93c..b53c70e47 100644
--- a/src/geode/geometry/distance.cpp
+++ b/src/geode/geometry/distance.cpp
@@ -158,8 +158,7 @@ namespace
             const geode::Segment< dimension >& segment )
     {
         const auto nearest_p = point_segment_projection( point, segment );
-        return std::make_tuple(
-            point_point_distance( point, nearest_p ), nearest_p );
+        return { point_point_distance( point, nearest_p ), nearest_p };
     }
 
     template < geode::index_t dimension >
@@ -169,8 +168,7 @@ namespace
             const geode::InfiniteLine< dimension >& line )
     {
         const auto nearest_p = point_line_projection( point, line );
-        return std::make_tuple(
-            point_point_distance( point, nearest_p ), nearest_p );
+        return { point_point_distance( point, nearest_p ), nearest_p };
     }
 
     std::tuple< double, geode::Point3D > no_pivot_point_triangle_distance(
@@ -337,12 +335,12 @@ namespace
                 }
             }
         }
-
-        geode::Point3D closest_point{ vertices[v0].get() + edge0 * p[0]
-                                      + edge1 * p[1] };
-        const auto distance =
-            geode::point_point_distance( point, closest_point );
-        return std::make_tuple( distance, std::move( closest_point ) );
+        std::tuple< double, geode::Point3D > result;
+        auto& [distance, closest_point] = result;
+        closest_point =
+            geode::Point3D{ vertices[v0].get() + edge0 * p[0] + edge1 * p[1] };
+        distance = geode::point_point_distance( point, closest_point );
+        return result;
     }
 
     std::pair< std::vector< geode::local_index_t >,
@@ -429,7 +427,7 @@ namespace
                 }
             }
         }
-        return std::make_tuple( min_distance, point0, point1 );
+        return { min_distance, point0, point1 };
     }
 
     std::tuple< double, geode::Point3D, geode::Point3D > test_close_triangles(
@@ -474,7 +472,7 @@ namespace
                 }
             }
         }
-        return std::make_tuple( min_distance, point0, point1 );
+        return { min_distance, point0, point1 };
     }
 
     template < geode::index_t dimension >
@@ -733,43 +731,52 @@ namespace
             point_point_distance( closest_on_segment0, closest_on_segment1 );
         if( distance < geode::GLOBAL_EPSILON )
         {
-            return std::make_tuple(
-                distance, closest_on_segment0, closest_on_segment1 );
+            return std::tuple< double, geode::Point< dimension >,
+                geode::Point< dimension > >{ distance, closest_on_segment0,
+                closest_on_segment1 };
         }
         const auto distance_to_closest0 =
             point_segment_distance( closest_on_segment0, segment1 );
         if( distance_to_closest0 < geode::GLOBAL_EPSILON )
         {
-            return std::make_tuple( distance_to_closest0, closest_on_segment0,
-                point_segment_projection( closest_on_segment0, segment1 ) );
+            return std::tuple< double, geode::Point< dimension >,
+                geode::Point< dimension > >{ distance_to_closest0,
+                closest_on_segment0,
+                point_segment_projection( closest_on_segment0, segment1 ) };
         }
         const auto distance_to_closest1 =
             point_segment_distance( closest_on_segment1, segment0 );
         if( distance_to_closest1 < geode::GLOBAL_EPSILON )
         {
-            return std::make_tuple( distance_to_closest1,
+            return std::tuple< double, geode::Point< dimension >,
+                geode::Point< dimension > >{ distance_to_closest1,
                 point_segment_projection( closest_on_segment1, segment0 ),
-                closest_on_segment1 );
+                closest_on_segment1 };
         }
         if( distance_to_closest0 < distance )
         {
             if( distance_to_closest1 < distance_to_closest0 )
             {
-                return std::make_tuple( distance_to_closest1,
+                return std::tuple< double, geode::Point< dimension >,
+                    geode::Point< dimension > >{ distance_to_closest1,
                     point_segment_projection( closest_on_segment1, segment0 ),
-                    closest_on_segment1 );
+                    closest_on_segment1 };
             }
-            return std::make_tuple( distance_to_closest0, closest_on_segment0,
-                point_segment_projection( closest_on_segment0, segment1 ) );
+            return std::tuple< double, geode::Point< dimension >,
+                geode::Point< dimension > >{ distance_to_closest0,
+                closest_on_segment0,
+                point_segment_projection( closest_on_segment0, segment1 ) };
         }
         if( distance_to_closest1 < distance )
         {
-            return std::make_tuple( distance_to_closest1,
+            return std::tuple< double, geode::Point< dimension >,
+                geode::Point< dimension > >{ distance_to_closest1,
                 point_segment_projection( closest_on_segment1, segment0 ),
-                closest_on_segment1 );
+                closest_on_segment1 };
         }
-        return std::make_tuple(
-            distance, closest_on_segment0, closest_on_segment1 );
+        return std::tuple< double, geode::Point< dimension >,
+            geode::Point< dimension > >{ distance, closest_on_segment0,
+            closest_on_segment1 };
     }
 
     template < geode::index_t dimension >
@@ -817,8 +824,7 @@ namespace
             }
             step /= 2;
         }
-        return std::make_tuple(
-            current_distance, current_point, current_point );
+        return { current_distance, current_point, current_point };
     }
 
 } // namespace
@@ -940,13 +946,14 @@ namespace geode
             s0 = -b0 / a00;
             s1 = 0;
         }
-
-        auto closest_on_line = line.origin() + line.direction() * s0;
-        auto closest_on_segment =
-            segment.vertices()[0].get() + segDirection * s1;
-        return std::make_tuple(
-            point_point_distance( closest_on_line, closest_on_segment ),
-            std::move( closest_on_segment ), std::move( closest_on_line ) );
+        std::tuple< double, geode::Point< dimension >,
+            geode::Point< dimension > >
+            result;
+        auto& [distance, closest_on_segment, closest_on_line] = result;
+        closest_on_line = line.origin() + line.direction() * s0;
+        closest_on_segment = segment.vertices()[0].get() + segDirection * s1;
+        distance = point_point_distance( closest_on_line, closest_on_segment );
+        return result;
     }
 
     template < index_t dimension >
@@ -995,7 +1002,7 @@ namespace geode
     {
         if( may_point_be_in_triangle( point, triangle ) )
         {
-            return std::make_tuple( 0.0, point );
+            return { 0.0, point };
         }
         const auto& vertices = triangle.vertices();
         std::array< Point2D, 3 > closest;
@@ -1037,7 +1044,7 @@ namespace geode
                 closest_point = closest[2];
             }
         }
-        return std::make_tuple( result, closest_point );
+        return { result, closest_point };
     }
 
     std::tuple< double, Point3D, Point3D > line_triangle_distance(
@@ -1091,7 +1098,7 @@ namespace geode
             if( b0 >= 0 && b1 >= 0 && b2 >= 0 )
             {
                 // The point Y is contained by the triangle.
-                return std::make_tuple( 0, Y, Y );
+                return { 0, Y, Y };
             }
         }
 
@@ -1123,8 +1130,7 @@ namespace geode
             }
         }
 
-        return std::make_tuple(
-            smallest_distance, closest_on_line, closest_on_edge );
+        return { smallest_distance, closest_on_line, closest_on_edge };
     }
 
     std::tuple< double, Point3D, Point3D > segment_triangle_distance(
@@ -1137,9 +1143,9 @@ namespace geode
             point_segment_projection( closest_on_line, segment );
         const auto reprojection_on_triangle =
             point_triangle_projection( closest_on_segment, triangle );
-        return std::make_tuple( point_point_distance( closest_on_segment,
-                                    reprojection_on_triangle ),
-            closest_on_segment, reprojection_on_triangle );
+        return { point_point_distance(
+                     closest_on_segment, reprojection_on_triangle ),
+            closest_on_segment, reprojection_on_triangle };
     }
 
     std::tuple< double, Point3D, Point3D >
@@ -1290,7 +1296,7 @@ namespace geode
             std::distance( lambdas.begin(), absl::c_min_element( lambdas ) ) );
         if( lambdas[facet] >= 0 )
         {
-            return std::make_tuple( 0.0, point );
+            return { 0.0, point };
         }
         const auto& facet_vertices =
             Tetrahedron::tetrahedron_facet_vertex[facet];
@@ -1314,7 +1320,7 @@ namespace geode
             {
                 return output;
             }
-            return std::make_tuple( -std::get< 0 >( output ), nearest_point );
+            return { -std::get< 0 >( output ), nearest_point };
         }
         return no_pivot_point_triangle_distance( point, triangle );
     }
@@ -1325,7 +1331,7 @@ namespace geode
         const Vector3D v{ plane.origin(), point };
         const auto distance = v.dot( plane.normal() );
         const Point3D projected_p{ point - plane.normal() * distance };
-        return std::make_tuple( distance, projected_p );
+        return { distance, projected_p };
     }
 
     std::tuple< double, Point3D > point_plane_distance(
@@ -1335,7 +1341,7 @@ namespace geode
         Point3D projected_p;
         std::tie( distance, projected_p ) =
             point_plane_signed_distance( point, plane );
-        return std::make_tuple( std::fabs( distance ), projected_p );
+        return { std::fabs( distance ), projected_p };
     }
 
     template < index_t dimension >
@@ -1347,12 +1353,11 @@ namespace geode
         {
             Vector< dimension > dummy_direction;
             dummy_direction.set_value( 0, 1 );
-            return std::make_tuple( sphere.radius(),
-                sphere.origin() + dummy_direction * sphere.radius() );
+            return { sphere.radius(),
+                sphere.origin() + dummy_direction * sphere.radius() };
         }
-        return std::make_tuple(
-            std::fabs( center_to_point.length() - sphere.radius() ),
-            sphere.origin() + center_to_point.normalize() * sphere.radius() );
+        return { std::fabs( center_to_point.length() - sphere.radius() ),
+            sphere.origin() + center_to_point.normalize() * sphere.radius() };
     }
 
     template < index_t dimension >
@@ -1364,11 +1369,11 @@ namespace geode
         {
             Vector< dimension > dummy_direction;
             dummy_direction.set_value( 0, 1 );
-            return std::make_tuple( -sphere.radius(),
-                sphere.origin() + dummy_direction * sphere.radius() );
+            return { -sphere.radius(),
+                sphere.origin() + dummy_direction * sphere.radius() };
         }
-        return std::make_tuple( center_to_point.length() - sphere.radius(),
-            sphere.origin() + center_to_point.normalize() * sphere.radius() );
+        return { center_to_point.length() - sphere.radius(),
+            sphere.origin() + center_to_point.normalize() * sphere.radius() };
     }
 
     template < index_t dimension >
@@ -1381,7 +1386,7 @@ namespace geode
         {
             return signed_distance;
         }
-        return std::make_tuple( 0, point );
+        return { 0, point };
     }
 
     std::tuple< double, Point3D > point_circle_distance(
@@ -1412,17 +1417,15 @@ namespace geode
                 other_direction
                 - circle.plane().normal()
                       * other_direction.dot( circle.plane().normal() );
-            return std::make_tuple(
-                std::sqrt( circle.radius() * circle.radius()
-                           + distance_to_plane * distance_to_plane ),
+            return { std::sqrt( circle.radius() * circle.radius()
+                                + distance_to_plane * distance_to_plane ),
                 circle.plane().origin()
-                    + other_projected_on_plane.normalize() * circle.radius() );
+                    + other_projected_on_plane.normalize() * circle.radius() };
         }
         const auto nearest_point =
             circle.plane().origin()
             + center_to_projected_point.normalize() * circle.radius();
-        return std::make_tuple(
-            point_point_distance( point, nearest_point ), nearest_point );
+        return { point_point_distance( point, nearest_point ), nearest_point };
     }
 
     std::tuple< double, Point3D > point_circle_signed_distance(
@@ -1436,7 +1439,7 @@ namespace geode
         {
             distance = -distance;
         }
-        return std::make_tuple( distance, nearest_point );
+        return { distance, nearest_point };
     }
 
     std::tuple< double, Point3D > point_disk_distance(
@@ -1450,8 +1453,7 @@ namespace geode
         if( point_point_distance( disk.plane().origin(), projected_on_plane )
             <= disk.radius() )
         {
-            return std::make_tuple(
-                std::fabs( distance_to_plane ), projected_on_plane );
+            return { std::fabs( distance_to_plane ), projected_on_plane };
         }
         return point_circle_distance( point, disk );
     }
diff --git a/src/geode/geometry/intersection.cpp b/src/geode/geometry/intersection.cpp
index cd493cb23..688567c86 100644
--- a/src/geode/geometry/intersection.cpp
+++ b/src/geode/geometry/intersection.cpp
@@ -1003,9 +1003,9 @@ namespace geode
         const auto compute_corectness = [&line]( const Plane& plane )
             -> CorrectnessInfo< OwnerInfiniteLine3D >::Correctness {
             auto output = point_plane_distance( line.origin(), plane );
-            return std::make_pair( std::get< 0 >( output ) <= GLOBAL_EPSILON,
+            return { std::get< 0 >( output ) <= GLOBAL_EPSILON,
                 OwnerInfiniteLine3D{
-                    line.direction(), std::move( std::get< 1 >( output ) ) } );
+                    line.direction(), std::move( std::get< 1 >( output ) ) } };
         };
         auto first_correctness = compute_corectness( plane0 );
         auto second_correctness = compute_corectness( plane1 );
diff --git a/src/geode/mesh/core/solid_mesh.cpp b/src/geode/mesh/core/solid_mesh.cpp
index 489cf2f48..985ba9cec 100644
--- a/src/geode/mesh/core/solid_mesh.cpp
+++ b/src/geode/mesh/core/solid_mesh.cpp
@@ -167,7 +167,8 @@ namespace
         geode::PolyhedronFacet facet,
         const std::array< geode::index_t, 2 >& edge_vertices )
     {
-        geode::PolyhedraAroundEdge result;
+        std::tuple< geode::PolyhedraAroundEdge, bool > result;
+        auto& [polyhedra_around_edge, found] = result;
         const auto first_polyhedron = facet.polyhedron_id;
         geode::index_t safety_count{ 0 };
         constexpr geode::index_t MAX_SAFETY_COUNT{ 1000 };
@@ -176,7 +177,7 @@ namespace
             if( const auto adj = solid.polyhedron_adjacent_facet( facet ) )
             {
                 const auto adj_facet = adj.value();
-                result.push_back( adj_facet.polyhedron_id );
+                polyhedra_around_edge.push_back( adj_facet.polyhedron_id );
                 for( const auto f : geode::LRange{ solid.nb_polyhedron_facets(
                          adj_facet.polyhedron_id ) } )
                 {
@@ -194,7 +195,8 @@ namespace
             }
             else
             {
-                return std::make_tuple( std::move( result ), false );
+                found = false;
+                return result;
             }
         } while( facet.polyhedron_id != first_polyhedron
                  && safety_count < MAX_SAFETY_COUNT );
@@ -209,7 +211,8 @@ namespace
             " ", solid.point( edge_vertices[1] ).string(),
             "). This is probably related to a bug in the polyhedron "
             "adjacencies." );
-        return std::make_tuple( std::move( result ), true );
+        found = true;
+        return result;
     }
 
     template < geode::index_t dimension >
diff --git a/src/geode/mesh/core/tetrahedral_solid.cpp b/src/geode/mesh/core/tetrahedral_solid.cpp
index 507485ba8..a048c442e 100644
--- a/src/geode/mesh/core/tetrahedral_solid.cpp
+++ b/src/geode/mesh/core/tetrahedral_solid.cpp
@@ -104,7 +104,7 @@ namespace
             const auto adj_optional = solid.polyhedron_adjacent( facet );
             if( !adj_optional )
             {
-                return std::make_pair( true, false );
+                return { true, false };
             }
             const auto adj = adj_optional.value();
             result.push_back( adj );
@@ -124,7 +124,7 @@ namespace
             }
             if( v0.size() != 1 || v1.size() != 1 )
             {
-                return std::make_pair( false, false );
+                return { false, false };
             }
             const auto adj_facet = ::tetrahedron_facet_from_vertices(
                 solid, facet, vertices_adj, adj );
@@ -150,7 +150,7 @@ namespace
                 "[TetrahedralSolid3D::propagate_around_edge] Next "
                 "facet not found" );
         } while( facet.polyhedron_id != first_polyhedron );
-        return std::make_pair( true, true );
+        return { true, true };
     }
 } // namespace
 
diff --git a/src/geode/mesh/helpers/gradient_computation.cpp b/src/geode/mesh/helpers/gradient_computation.cpp
index a5c7efffe..fea9a61ad 100644
--- a/src/geode/mesh/helpers/gradient_computation.cpp
+++ b/src/geode/mesh/helpers/gradient_computation.cpp
@@ -69,6 +69,8 @@ namespace
         std::tuple< geode::uuid, std::vector< geode::index_t > >
             compute_scalar_function_gradient() const
         {
+            std::tuple< geode::uuid, std::vector< geode::index_t > > result;
+            auto& [gradient_function_id, no_gradient_value_vertices] = result;
             geode::AttributeProperties attribute_properties;
             attribute_properties.assignable = false;
             attribute_properties.interpolable = false;
@@ -79,7 +81,7 @@ namespace
             distance_map_values.no_value = geode::Vector< Mesh::dim >{};
             const auto gradient_function_name =
                 absl::StrCat( scalar_function_->name().value(), "_gradient" );
-            auto gradient_function_id =
+            gradient_function_id =
                 mesh_.vertex_attribute_manager()
                     .template create_attribute< geode::VariableAttribute,
                         geode::Vector< Mesh::dim > >( gradient_function_name,
@@ -88,7 +90,6 @@ namespace
                 mesh_.vertex_attribute_manager()
                     .template find_attribute< geode::VariableAttribute,
                         geode::Vector< Mesh::dim > >( gradient_function_id );
-            std::vector< geode::index_t > no_gradient_value_vertices;
             for( const auto vertex_id : geode::Range{ mesh_.nb_vertices() } )
             {
                 if( !compute_gradient( *gradient_function, vertex_id ) )
@@ -96,8 +97,7 @@ namespace
                     no_gradient_value_vertices.push_back( vertex_id );
                 }
             }
-            return std::make_tuple(
-                gradient_function_id, std::move( no_gradient_value_vertices ) );
+            return result;
         }
 
     private:
diff --git a/src/geode/mesh/helpers/rasterize.cpp b/src/geode/mesh/helpers/rasterize.cpp
index 484e2fe71..8d80ba7a3 100644
--- a/src/geode/mesh/helpers/rasterize.cpp
+++ b/src/geode/mesh/helpers/rasterize.cpp
@@ -117,7 +117,7 @@ namespace
                 increments[i] = -1;
             }
         }
-        return std::make_tuple( deltas, increments );
+        return { deltas, increments };
     }
 
     template < geode::index_t dimension >
@@ -173,7 +173,7 @@ namespace
                 }
             }
         }
-        return std::make_tuple( major_edge, major_axis );
+        return { major_edge, major_axis };
     }
 
     template < geode::index_t dimension >
@@ -956,8 +956,9 @@ namespace
             geode::index_t vertex_id ) const
         {
             auto& vertex_jks = painted_vertices_[vertex_id];
-            auto oriented_jk =
-                std::make_tuple( current_j, current_k, counter_clockwise_ );
+            std::tuple< geode::index_t, geode::index_t, bool > oriented_jk{
+                current_j, current_k, counter_clockwise_
+            };
             if( absl::c_find( vertex_jks, oriented_jk ) == vertex_jks.end() )
             {
                 vertex_jks.emplace_back( std::move( oriented_jk ) );
@@ -971,8 +972,9 @@ namespace
             const Edge& edge ) const
         {
             auto& edge_jks = painted_edges_[edge];
-            auto oriented_jk =
-                std::make_tuple( current_j, current_k, counter_clockwise_ );
+            std::tuple< geode::index_t, geode::index_t, bool > oriented_jk{
+                current_j, current_k, counter_clockwise_
+            };
             if( absl::c_find( edge_jks, oriented_jk ) == edge_jks.end() )
             {
                 edge_jks.emplace_back( std::move( oriented_jk ) );
diff --git a/src/geode/model/helpers/aabb_model_helpers.cpp b/src/geode/model/helpers/aabb_model_helpers.cpp
index 41235dfe4..8dad8da50 100644
--- a/src/geode/model/helpers/aabb_model_helpers.cpp
+++ b/src/geode/model/helpers/aabb_model_helpers.cpp
@@ -71,9 +71,13 @@ namespace
     {
         const auto nb_non_empty_elements =
             count_non_empty_elements( range, nb_elements );
+        std::tuple< geode::AABBTree< dimension >,
+            absl::FixedArray< geode::uuid > >
+            result( geode::AABBTree< dimension >{},
+                absl::FixedArray< geode::uuid >{ nb_non_empty_elements } );
+        auto& [aabb, mapping] = result;
         absl::FixedArray< geode::BoundingBox< dimension > > boxes(
             nb_non_empty_elements );
-        absl::FixedArray< geode::uuid > mapping( nb_non_empty_elements );
         absl::FixedArray< async::task< void > > tasks( nb_non_empty_elements );
         geode::index_t id{ 0 };
         for( const auto& element : range )
@@ -92,8 +96,8 @@ namespace
         {
             task.get();
         }
-        return std::make_tuple(
-            geode::AABBTree< dimension >{ boxes }, std::move( mapping ) );
+        aabb = geode::AABBTree< dimension >{ boxes };
+        return result;
     }
 
     template < geode::index_t dimension, typename Range >
diff --git a/src/geode/model/helpers/component_mesh_polygons.cpp b/src/geode/model/helpers/component_mesh_polygons.cpp
index 49c1c4fc7..891b60f07 100644
--- a/src/geode/model/helpers/component_mesh_polygons.cpp
+++ b/src/geode/model/helpers/component_mesh_polygons.cpp
@@ -216,25 +216,28 @@ namespace
             const geode::Block3D& block,
             const geode::PolygonVertices& polygon_unique_vertices )
     {
+        std::tuple< absl::InlinedVector< geode::BlockPolyhedronFacet, 2 >,
+            absl::InlinedVector< geode::BlockPolyhedronFacet, 2 >, bool >
+            result;
+        auto& [facets_block_vertices, facets_unique_vertices, is_opposite] =
+            result;
+        is_opposite = false;
         auto output = polygon_vertices_to_block_facets_vertices(
             model, block, polygon_unique_vertices );
-        auto& facets_block_vertices = std::get< 0 >( output );
-        auto& facets_unique_vertices = std::get< 1 >( output );
+        facets_block_vertices = std::get< 0 >( output );
+        facets_unique_vertices = std::get< 1 >( output );
 
         if( facets_block_vertices.empty() )
         {
-            return std::make_tuple( std::move( facets_block_vertices ),
-                std::move( facets_unique_vertices ), false );
+            return result;
         }
-
         geode::detail::OrientedVertexCycle< geode::PolygonVertices >
             polygon_unique_vertices_cycle{ polygon_unique_vertices };
         if( polygon_unique_vertices_cycle.is_opposite(
                 geode::detail::OrientedVertexCycle< geode::PolygonVertices >{
                     facets_unique_vertices[0].vertices } ) )
         {
-            return std::make_tuple( std::move( facets_block_vertices ),
-                std::move( facets_unique_vertices ), false );
+            return result;
         }
         else if( facets_block_vertices.size() >= 2 )
         {
@@ -246,8 +249,8 @@ namespace
                 "[block_vertices_from_surface_polygon] The block facets found "
                 "from the polygon vertices have the same orientation." );
         }
-        return std::make_tuple( std::move( facets_block_vertices ),
-            std::move( facets_unique_vertices ), true );
+        is_opposite = true;
+        return result;
     }
 
     absl::InlinedVector< geode::BlockPolyhedronFacet, 2 >
@@ -403,22 +406,25 @@ namespace
     {
         auto output = edge_vertices_to_surface_vertices< dimension, ModelType >(
             model, surface, edge_unique_vertices );
-        auto& surface_edges_vertices = std::get< 0 >( output );
-        auto& surface_edges_unique_vertices = std::get< 1 >( output );
-
+        std::tuple< absl::InlinedVector< geode::SurfacePolygonEdge, 2 >,
+            absl::InlinedVector< geode::SurfacePolygonEdge, 2 >, bool >
+            result;
+        auto& [surface_edges_vertices, surface_edges_unique_vertices,
+            is_opposite] = result;
+        is_opposite = false;
+        surface_edges_vertices = std::get< 0 >( output );
+        surface_edges_unique_vertices = std::get< 1 >( output );
         if( surface_edges_vertices.empty() )
         {
-            return std::make_tuple( std::move( surface_edges_vertices ),
-                std::move( surface_edges_unique_vertices ), false );
+            return result;
         }
-
         if( edge_unique_vertices[0]
                 == surface_edges_unique_vertices[0].vertices[0]
             && edge_unique_vertices[1]
                    == surface_edges_unique_vertices[0].vertices[1] )
         {
-            return std::make_tuple( std::move( surface_edges_vertices ),
-                std::move( surface_edges_unique_vertices ), true );
+            is_opposite = true;
+            return result;
         }
         geode::OpenGeodeModelException::check_assertion(
             edge_unique_vertices[0]
@@ -428,8 +434,7 @@ namespace
             "[block_vertices_from_surface_polygon] The surface edges "
             "found from the polygon vertices don't have the same unique "
             "vertices." );
-        return std::make_tuple( std::move( surface_edges_vertices ),
-            std::move( surface_edges_unique_vertices ), false );
+        return result;
     }
 
     absl::InlinedVector< geode::SurfacePolygonEdge, 2 >
diff --git a/src/geode/model/helpers/convert_brep_section.cpp b/src/geode/model/helpers/convert_brep_section.cpp
index 2cd67cc99..973a902f3 100644
--- a/src/geode/model/helpers/convert_brep_section.cpp
+++ b/src/geode/model/helpers/convert_brep_section.cpp
@@ -479,10 +479,10 @@ namespace geode
     std::tuple< Section, ModelCopyMapping > convert_brep_into_section(
         const BRep& brep, local_index_t axis_to_remove )
     {
-        Section section;
+        std::tuple< Section, ModelCopyMapping > result;
+        auto& [section, mappings] = result;
         SectionBuilder builder{ section };
-        auto mappings =
-            copy_components< BRep, SectionBuilder >( brep, builder );
+        mappings = copy_components< BRep, SectionBuilder >( brep, builder );
         for( const auto& corner : brep.corners() )
         {
             builder.update_corner_mesh(
@@ -508,7 +508,7 @@ namespace geode
         }
         copy_unique_vertices( brep, builder, mappings );
         detail::build_model_boundaries( section, builder );
-        return std::make_tuple( std::move( section ), std::move( mappings ) );
+        return result;
     }
 
     std::tuple< BRep, ModelCopyMapping > convert_section_into_brep(
@@ -516,10 +516,10 @@ namespace geode
         local_index_t axis_to_add,
         double axis_coordinate )
     {
-        BRep brep;
+        std::tuple< BRep, ModelCopyMapping > result;
+        auto& [brep, mappings] = result;
         BRepBuilder builder{ brep };
-        auto mappings =
-            copy_components< Section, BRepBuilder >( section, builder );
+        mappings = copy_components< Section, BRepBuilder >( section, builder );
         for( const auto& corner : section.corners() )
         {
             builder.update_corner_mesh(
@@ -545,7 +545,7 @@ namespace geode
                     surface.mesh(), axis_to_add, axis_coordinate ) );
         }
         copy_unique_vertices( section, builder, mappings );
-        return std::make_tuple( std::move( brep ), std::move( mappings ) );
+        return result;
     }
 
     BRep extrude_section_to_brep(
diff --git a/src/geode/model/helpers/convert_to_mesh.cpp b/src/geode/model/helpers/convert_to_mesh.cpp
index d38aff20a..d1738e278 100644
--- a/src/geode/model/helpers/convert_to_mesh.cpp
+++ b/src/geode/model/helpers/convert_to_mesh.cpp
@@ -123,7 +123,6 @@ namespace
         geode::ModelToMeshMappings >
         convert_model_into_curve( const Model& model )
     {
-        geode::ModelToMeshMappings model2mesh;
         std::vector<
             std::reference_wrapper< const geode::EdgedCurve< Model::dim > > >
             meshes;
@@ -132,14 +131,17 @@ namespace
         {
             meshes.emplace_back( line.mesh() );
         }
-        auto mesh =
-            geode::detail::create_mesh< geode::EdgedCurve< Model::dim > >(
-                meshes );
+        std::tuple< std::unique_ptr< geode::EdgedCurve< Model::dim > >,
+            geode::ModelToMeshMappings >
+            result;
+        auto& [mesh, model2mesh] = result;
+        mesh = geode::detail::create_mesh< geode::EdgedCurve< Model::dim > >(
+            meshes );
         auto mesh_builder =
             geode::EdgedCurveBuilder< Model::dim >::create( *mesh );
         build_edges_from_model( model, model2mesh, *mesh_builder );
         map_corner_vertices( model, model2mesh );
-        return std::make_pair( std::move( mesh ), std::move( model2mesh ) );
+        return result;
     }
 
     template < geode::index_t dim >
@@ -252,17 +254,19 @@ namespace
         {
             meshes.emplace_back( surface.mesh() );
         }
-        auto mesh =
-            geode::detail::create_mesh< geode::SurfaceMesh< Model::dim > >(
-                meshes );
+        std::tuple< std::unique_ptr< geode::SurfaceMesh< Model::dim > >,
+            geode::ModelToMeshMappings >
+            result;
+        auto& [mesh, model2mesh] = result;
+        mesh = geode::detail::create_mesh< geode::SurfaceMesh< Model::dim > >(
+            meshes );
         auto mesh_builder =
             geode::SurfaceMeshBuilder< Model::dim >::create( *mesh );
-        geode::ModelToMeshMappings model2mesh;
         build_polygons_from_model( model, *mesh_builder, model2mesh );
         mesh_builder->compute_polygon_adjacencies();
         map_line_edges( model, model2mesh, *mesh );
         map_corner_vertices( model, model2mesh );
-        return std::make_pair( std::move( mesh ), std::move( model2mesh ) );
+        return result;
     }
 
     void set_block_polyhedra_adjacencies(
@@ -426,9 +430,11 @@ namespace geode
         {
             meshes.emplace_back( block.mesh() );
         }
-        auto mesh = geode::detail::create_mesh< SolidMesh3D >( meshes );
+        std::tuple< std::unique_ptr< geode::SolidMesh3D >, ModelToMeshMappings >
+            result;
+        auto& [mesh, brep2mesh] = result;
+        mesh = geode::detail::create_mesh< SolidMesh3D >( meshes );
         auto mesh_builder = geode::SolidMeshBuilder< 3 >::create( *mesh );
-        ModelToMeshMappings brep2mesh;
         for( const auto unique_vertex :
             geode::Range{ brep.nb_unique_vertices() } )
         {
@@ -453,6 +459,6 @@ namespace geode
             map_line_edges( brep, brep2mesh, *mesh );
             map_corner_vertices( brep, brep2mesh );
         }
-        return std::make_pair( std::move( mesh ), std::move( brep2mesh ) );
+        return result;
     }
 } // namespace geode
diff --git a/src/geode/model/helpers/detail/split_along_block_mesh_borders.cpp b/src/geode/model/helpers/detail/split_along_block_mesh_borders.cpp
index f5dd21e8a..64ceaea2c 100644
--- a/src/geode/model/helpers/detail/split_along_block_mesh_borders.cpp
+++ b/src/geode/model/helpers/detail/split_along_block_mesh_borders.cpp
@@ -103,10 +103,12 @@ namespace geode
                                         mesh_border_facets( block );
                                     SplitAlongSolidFacets block_splitter{ mesh,
                                         *builder };
-                                    return std::make_pair( block.id(),
-                                        block_splitter
-                                            .duplicate_points_and_process_solid_facets_and_edges(
-                                                solid_info ) );
+                                    std::pair< uuid, MeshesElementsMapping >
+                                        split_result{ block.id(),
+                                            block_splitter
+                                                .duplicate_points_and_process_solid_facets_and_edges(
+                                                    solid_info ) };
+                                    return split_result;
                                 } );
                         }
                         async::when_all( duplicate_tasks )
diff --git a/src/geode/model/helpers/surface_radial_sort.cpp b/src/geode/model/helpers/surface_radial_sort.cpp
index 1ac3c3a03..2a9c95968 100644
--- a/src/geode/model/helpers/surface_radial_sort.cpp
+++ b/src/geode/model/helpers/surface_radial_sort.cpp
@@ -131,7 +131,7 @@ namespace
             }
         }
         geode::sort_unique( polygons );
-        return std::make_pair( !degenerate_polygon, polygons );
+        return { !degenerate_polygon, polygons };
     }
 
     geode::SortedSurfaces sort( const geode::Segment3D& segment,
diff --git a/src/geode/model/mixin/core/detail/relationships_impl.cpp b/src/geode/model/mixin/core/detail/relationships_impl.cpp
index e709d3320..6deb59484 100644
--- a/src/geode/model/mixin/core/detail/relationships_impl.cpp
+++ b/src/geode/model/mixin/core/detail/relationships_impl.cpp
@@ -184,8 +184,7 @@ namespace geode
         {
             const auto id0 = graph_->edge_vertex( { component_id, 0 } );
             const auto id1 = graph_->edge_vertex( { component_id, 1 } );
-            return std::make_tuple(
-                component_from_index( id0 ), component_from_index( id1 ) );
+            return { component_from_index( id0 ), component_from_index( id1 ) };
         }
 
         void RelationshipsImpl::copy(

From 9f951bdc3fbcfaa81112225a1fa986c208645722 Mon Sep 17 00:00:00 2001
From: BenPinet <be.pinet@gmail.com>
Date: Thu, 6 Aug 2026 14:23:46 +0200
Subject: [PATCH 2/3] fix compilation

---
 src/geode/model/helpers/aabb_model_helpers.cpp | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/src/geode/model/helpers/aabb_model_helpers.cpp b/src/geode/model/helpers/aabb_model_helpers.cpp
index 8dad8da50..e2c1881c1 100644
--- a/src/geode/model/helpers/aabb_model_helpers.cpp
+++ b/src/geode/model/helpers/aabb_model_helpers.cpp
@@ -86,10 +86,11 @@ namespace
             {
                 continue;
             }
-            tasks[id] = async::spawn( [id, &mapping, &boxes, &element] {
-                mapping[id] = element.id();
-                boxes[id] = element.mesh().bounding_box();
-            } );
+            tasks[id] = async::spawn(
+                [id, &captured_mapping = mapping, &boxes, &element] {
+                    captured_mapping[id] = element.id();
+                    boxes[id] = element.mesh().bounding_box();
+                } );
             id++;
         }
         for( auto& task : async::when_all( tasks ).get() )

From 8a6237240963a0cc742b2313c37ed4142997a13d Mon Sep 17 00:00:00 2001
From: BenPinet <be.pinet@gmail.com>
Date: Thu, 6 Aug 2026 14:45:58 +0200
Subject: [PATCH 3/3] fix compilation

---
 src/geode/model/helpers/component_mesh_polygons.cpp | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/geode/model/helpers/component_mesh_polygons.cpp b/src/geode/model/helpers/component_mesh_polygons.cpp
index 891b60f07..1bd8d2fd1 100644
--- a/src/geode/model/helpers/component_mesh_polygons.cpp
+++ b/src/geode/model/helpers/component_mesh_polygons.cpp
@@ -241,11 +241,12 @@ namespace
         }
         else if( facets_block_vertices.size() >= 2 )
         {
+            auto& facets_unique_vertices_ref = facets_unique_vertices;
             geode::OpenGeodeModelException::check_assertion(
                 polygon_unique_vertices_cycle.is_opposite(
                     geode::detail::OrientedVertexCycle<
                         geode::PolygonVertices >{
-                        facets_unique_vertices[1].vertices } ),
+                        facets_unique_vertices_ref[1].vertices } ),
                 "[block_vertices_from_surface_polygon] The block facets found "
                 "from the polygon vertices have the same orientation." );
         }
@@ -426,11 +427,12 @@ namespace
             is_opposite = true;
             return result;
         }
+        auto& surface_edges_unique_vertices_ref = surface_edges_unique_vertices;
         geode::OpenGeodeModelException::check_assertion(
             edge_unique_vertices[0]
-                    == surface_edges_unique_vertices[0].vertices[1]
+                    == surface_edges_unique_vertices_ref[0].vertices[1]
                 && edge_unique_vertices[1]
-                       == surface_edges_unique_vertices[0].vertices[0],
+                       == surface_edges_unique_vertices_ref[0].vertices[0],
             "[block_vertices_from_surface_polygon] The surface edges "
             "found from the polygon vertices don't have the same unique "
             "vertices." );