memory grows when using flip geodesics shortening the same paths

Reproduce the repeated calls in the provided C++ program, starting with geometrycentral/surface/flip_geodesics.h and the FlipEdgeNetwork calls reinitializePath(), iterativeShorten(), and rewind(). Track resident memory across repeated runs and inspect the lifecycle of those operations. Done means repeated shortening of the same path no longer causes unexplained memory growth.

When I follow the official documentation to call the flip geodesics algorithm multiple times on the same dataset, the memory usage keeps growing.
Shortening many paths，doc: https://geometry-central.net/surface/algorithms/flip_geodesics/
I'm a C++ beginner, and with the help of the documentation and ChatGPT, I wrote the following program:

#include <fstream>
#include <vector>

#include <chrono>
#include "geometrycentral/surface/flip_geodesics.h"
#include "geometrycentral/surface/vertex_position_geometry.h"
#include "geometrycentral/surface/meshio.h"
#include "geometrycentral/surface/mesh_graph_algorithms.h"

#include <mach/mach.h>
#include <iostream>
#include <mach/task.h>
#include <mach/mach_init.h>
#include <libproc.h>      // for proc_pidinfo() on some macOS versions
#include <sys/types.h>    // for pid_t
#include <unistd.h>       // for getpid() and getrusage()
#include <sys/resource.h> // for getrusage()

using namespace geometrycentral;
using namespace geometrycentral::surface;

int computeFlipGeodesicPath(
    std::unique_ptr<FlipEdgeNetwork> &edgeNetwork,
    int vertex0,
    int vertex1)
{
    Vertex startVert = edgeNetwork->tri->intrinsicMesh->vertex(vertex0); // populate these somehow
    Vertex endVert = edgeNetwork->tri->intrinsicMesh->vertex(vertex1);

    // Get an initial dijkstra path
    // (surface/mesh_graph_algorithms.h)
    std::vector<Halfedge> dijkstraPath = shortestEdgePath(*edgeNetwork->tri, startVert, endVert);

    // Reinitialize the ede network to contain this path
    edgeNetwork->reinitializePath({dijkstraPath});

    // Straighten the path to geodesic
    edgeNetwork->iterativeShorten();

    // Extract the path and store it in the vector
    // std::vector<Vector3> path3D = edgeNetwork->getPathPolyline3D().front();

    // Be kind, rewind
    edgeNetwork->rewind();
    return 1;
}

int main()
{
    using namespace std::chrono;

    std::unique_ptr<ManifoldSurfaceMesh> mesh;
    std::unique_ptr<VertexPositionGeometry> geom;
    std::tie(mesh, geom) = readManifoldSurfaceMesh("/Downloads/test.obj");

    std::unique_ptr<FlipEdgeNetwork> edgeNetwork(new FlipEdgeNetwork(*mesh, *geom, {}));
    edgeNetwork->supportRewinding = true;
    edgeNetwork->posGeom = geom.get();

    struct task_basic_info t_info;
    mach_msg_type_number_t t_info_count = TASK_BASIC_INFO_COUNT;

    // 1
    computeFlipGeodesicPath(edgeNetwork, 36841, 29806);

    if (KERN_SUCCESS != task_info(mach_task_self(), TASK_BASIC_INFO, (task_info_t)&t_info, &t_info_count))
    {
        std::cerr << "task_info() failed" << std::endl;
        return 1;
    }

    std::cout << "Resident Memory Size: " << t_info.resident_size / 1024 / 1024 << " MB" << std::endl;

    // 2
    computeFlipGeodesicPath(edgeNetwork, 36841, 29806);
    if (KERN_SUCCESS != task_info(mach_task_self(), TASK_BASIC_INFO, (task_info_t)&t_info, &t_info_count))
    {
        std::cerr << "task_info() failed" << std::endl;
        return 1;
    }
    std::cout << "Resident Memory Size: " << t_info.resident_size / 1024 / 1024 << " MB" << std::endl;

    // 3
    computeFlipGeodesicPath(edgeNetwork, 36841, 29806);
    if (KERN_SUCCESS != task_info(mach_task_self(), TASK_BASIC_INFO, (task_info_t)&t_info, &t_info_count))
    {
        std::cerr << "task_info() failed" << std::endl;
        return 1;
    }
    std::cout << "Resident Memory Size: " << t_info.resident_size / 1024 / 1024 << " MB" << std::endl;

    return 0;
}

result:

obj file:
test.obj.zip