// Direct construction with explicit template parameters
tf::vector<float, 3> v0{1.f, 2.f, 3.f};

// Factory - type and dims deduced from arguments (requires at least 2)
auto v1 = tf::make_vector(1.f, 2.f, 3.f);  // tf::vector<float, 3>

// View from existing data
float buf[3]{1.f, 2.f, 3.f};
auto vview0 = tf::make_vector_view(buf);           // deduces size from array
auto vview1 = tf::make_vector_view<3>(&buf[0]);    // explicit size from pointer
auto [x, y, z] = vview0;

// From vector - normalizes automatically
tf::unit_vector<float, 3> uv0{v0};
auto uv1 = tf::make_unit_vector(v0);

// Factory - type and dims deduced, normalizes automatically
auto uv2 = tf::make_unit_vector(1.f, 0.f, 0.f);  // tf::unit_vector<float, 3>

// Unsafe - skips normalization (caller guarantees unit length)
auto uv3 = tf::make_unit_vector(tf::unsafe, v0);
auto uv4 = tf::make_unit_vector(tf::unsafe, 1.f, 0.f, 0.f);
auto uv5 = tf::normalized(v0);
// copy
auto uv6 = tf::normalized(uv);
// no-op
tf::normalize(uv);

// View from existing unit vector
auto uvview = tf::make_unit_vector_view(uv0);
auto [x, y, z] = uvview;

// Direct construction with explicit template parameters
tf::point<float, 3> pt0{1.f, 2.f, 3.f};

// Factory - type and dims deduced from arguments (requires at least 2)
auto pt1 = tf::make_point(4.f, 5.f, 6.f);  // tf::point<float, 3>

// View from existing data
float buf[3]{1.f, 2.f, 3.f};
auto pview0 = tf::make_point_view(buf);           // deduces size from array
auto pview1 = tf::make_point_view<3>(&buf[0]);    // explicit size from pointer
auto [x, y, z] = pview0;

auto line0 = tf::make_line_between_points(pt0, pt1);
auto line1 = tf::make_line(pt_origin, vec_direction);
auto line2 = tf::make_line_like(point_like, vector_like); // Creates view when inputs are views

tf::point<float, 3> origin = line0.origin;
tf::vector<float, 3> direction = line0.direction;

// Support parametric evaluation
auto point_on_line = line0(2.5f); // origin + 2.5 * direction

// ray follows the same pattern
auto ray0 = tf::make_ray_between_points(pt0, pt1);

tf::point<float, 3> pt;
tf::unit_vector<float, 3> normal;
auto plane0 = tf::make_plane(pt, pt, pt);
auto plane1 = tf::make_plane(normal, pt);
auto plane2 = tf::make_plane(normal, -tf::dot(normal, pt));
auto plane3 = tf::make_plane_like(unit_vector_like, coordinate_type); // View when inputs are views

// Creates copies of the two points
auto seg0 = tf::make_segment_between_points(pt0, pt1);
auto [seg0_pt0, seg0_pt1] = seg0;

std::array<tf::point<float, 3>, 2> r; // any range of two points
auto seg1 = tf::make_segment(r);

// With edges that index into a larger range of points
std::array<int, 2> ids{0, 1};
auto seg2 = tf::make_segment(ids, r);
// ids are a view, as are the points
auto [id0, id1] = seg2.indices();
auto [seg2_pt0, seg2_pt1] = seg2;

std::array<tf::point<float, 3>, 3> r;
auto polygon0 = tf::make_polygon(r);

// With faces that index into a larger range of points
std::array<int, 3> ids{0, 1, 2};
auto polygon1 = tf::make_polygon(ids, r);
// ids are a view, as are the points
auto [id0, id1, id2] = polygon1.indices();
auto [pt0, pt1, pt2] = polygon1;

auto aabb0 = tf::make_aabb_like(min_point_like, max_point_like); // View when inputs are views
auto aabb1 = tf::make_aabb(min_point, max_point); // Always owning

// AABB of any finite primitive
tf::aabb<float, 3> aabb = tf::aabb_from(primitive);

// Additional methods
auto diag = aabb.diagonal();
auto center = aabb.center();
auto size = aabb.size();

tf::transformation_view<float, 3> tr_view{float_ptr};
tf::transformation<float, 3> tr{tr_view};
tr.fill(other_float_ptr);

// Convenience factories
auto identity = tf::make_identity_transformation<float, 3>();
auto translated = tf::make_transformation_from_translation(vector);

// Memory layout: Dims rows of Dims+1 columns
// Last element of each row is the translation for that dimension
auto tr0 = translated(0, 3);
auto tr1 = translated(1, 3);
auto tr2 = translated(2, 3);

tf::frame<float, 3> frame0;
tf::frame<float, 3> frame1{tr_view};

// Safe policy ensures inverse is always computed after changes
frame.fill(float_ptr/*, ptr for inverse*/);
frame.set(transformation /*, inverse_transformation*/);

const auto &transformation = frame.transformation();
const auto &inverse_transformation = frame.inverse_transformation();

// Rotate around arbitrary axis (must be unit vector)
auto axis = tf::make_unit_vector(tf::vector<float, 3>{0, 0, 1});
auto rot = tf::make_rotation(tf::deg(45.f), axis);

// Rotate around principal axes (optimized)
auto rot_x = tf::make_rotation(tf::deg(90.f), tf::axis<0>);  // X-axis
auto rot_y = tf::make_rotation(tf::deg(90.f), tf::axis<1>);  // Y-axis
auto rot_z = tf::make_rotation(tf::deg(90.f), tf::axis<2>);  // Z-axis

// 2D rotation (around implicit Z-axis)
auto rot_2d = tf::make_rotation(tf::rad(tf::pi<float> / 4));

// Rotate around axis passing through a pivot point
tf::point<float, 3> pivot{1.f, 0.f, 0.f};
auto rot = tf::make_rotation(tf::deg(45.f), axis, pivot);

// With principal axes
auto rot_x = tf::make_rotation(tf::deg(90.f), tf::axis<0>, pivot);

// 2D rotation around pivot
tf::point<float, 2> pivot_2d{1.f, 1.f};
auto rot_2d = tf::make_rotation(tf::deg(45.f), pivot_2d);

// Align one direction to another
auto from = tf::make_unit_vector(tf::vector<float, 3>{1, 0, 0});
auto to = tf::make_unit_vector(tf::vector<float, 3>{0, 1, 0});
auto rot = tf::make_rotation_aligning(from, to);

// Useful for orienting objects along a direction
auto view_dir = tf::make_unit_vector(camera_direction);
auto z_axis = tf::make_unit_vector<float, 3>(tf::axis<2>);
auto orient = tf::make_rotation_aligning(z_axis, view_dir);

// Also works in 2D
auto from_2d = tf::make_unit_vector(tf::vector<float, 2>{1, 0});
auto to_2d = tf::make_unit_vector(tf::vector<float, 2>{0, 1});
auto rot_2d = tf::make_rotation_aligning(from_2d, to_2d);

// Rodrigues vector: axis = direction, angle = magnitude
// Here: axis ≈ (0.27, 0.53, 0.80), angle ≈ 0.374 rad
auto rot = tf::make_rotation_from_rodrigues(0.1f, 0.2f, 0.3f);

// Small rotations (linearized): R ≈ I + [r]×
auto small_rot = tf::make_rotation_from_rodrigues(0.001f, 0.002f, 0.0f);

auto tr0 = tf::random_transformation<float>();
auto tr1 = tf::random_transformation<float>();
auto tr1_dot_tr0 = tf::transformed(tr0, tr1);
auto frame = tf::make_frame(tr1_dot_tr0);

// Transform any primitive
auto transformed_point = tf::transformed(pt, tr0);
auto transformed_polygon = tf::transformed(polygon, frame);

// Transform a normal (uses inverse transpose, different from unit vectors)
auto transformed_n = tf::transformed_normal(normal, frame);

// Squared distance (faster, avoids sqrt)
auto d2 = tf::distance2(point, polygon);

// Distance
auto d = tf::distance(segment0, segment1);

// Closest point on polygon to a point
auto metric_pt = tf::closest_metric_point(polygon, point);
auto [dist2, closest_pt] = metric_pt;

// Closest points between two primitives
auto metric_pair = tf::closest_metric_point_pair(polygon0, polygon1);
auto [dist2, pt_on_poly0, pt_on_poly1] = metric_pair;

// Intersection test
bool do_intersect = tf::intersects(aabb0, aabb1);

// Point vs plane (2D or 3D)
auto side = tf::classify(point, plane);
if (side == tf::sidedness::on_positive_side) { /* above plane */ }

// Point vs 2D segment (which side of the line?)
auto side_2d = tf::classify(point_2d, segment_2d);

// Point vs polygon (inside/outside test)
auto cont = tf::classify(point, polygon);
if (cont != tf::containment::outside) { /* point inside or on boundary */ }

auto seg = tf::make_segment_between_points(tf::random_point<float, 3>(),
                                            tf::random_point<float, 3>());
auto ray = tf::make_ray_between_points(tf::random_point<float, 3>(),
                                        tf::random_point<float, 3>());

// Configure parametric bounds [min_t, max_t] for valid intersections
auto config = tf::make_ray_config(0.f, 100.f);

// ray_cast: lightweight result (status + t only)
auto r_cast = tf::ray_cast(ray, seg, config);
if (r_cast) {
  auto [status, t] = r_cast;
  // t is the parametric distance: hit_point = ray.origin + t * ray.direction
}

// ray_hit: includes the intersection point
auto r_hit = tf::ray_hit(ray, seg, config);
if (r_hit) {
  auto [status, t, point] = r_hit;
}

auto r0 = tf::make_range(your_container);
// If you know it has n-elements and this is not known to tf::static_size
auto r1 = tf::make_range<N>(your_container);

auto r2 = tf::make_range(r1);
static_assert(tf::static_size_v<decltype(r2)> == N);
std::array<int, 3> arr;
auto r3 = tf::make_range(arr);
static_assert(tf::static_size_v<decltype(r3)> == 3);

std::vector<int> raw_ids;
auto triangle_faces0 = tf::make_blocked_range<3>(raw_ids);
auto [t0id0, t0id1, t0id2] = triangle_faces0.front();

// Legacy VTK format (3, a, b, c, 3, e, f, g)
auto triangle_faces1 = tf::make_tag_blocked_range<3>(raw_ids);
auto [t1id0, t1id1, t1id2] = triangle_faces1.front();

// Segments
auto segments0 = tf::make_blocked_range<2>(raw_ids);
auto [s0id0, s0id1] = segments0.front();

// Sliding window for curve points
auto segments1 = tf::make_slide_range<2>(raw_ids);
auto [s1id0, s1id1] = segments1.front();

tf::buffer<int> offsets = {0, 3, 7, 10}; // Block boundaries
tf::buffer<int> data = {0,1,2, 3,4,5,6, 7,8,9}; // Packed data

auto blocks = tf::make_offset_block_range(offsets, data);
for (auto block : blocks) {
    for (auto value : block) {
        // Process value
    }
}

tf::buffer<int> indices = {2, 0, 3, 1};
tf::buffer<float> values = {10.0f, 20.0f, 30.0f, 40.0f};

auto indirect_view = tf::make_indirect_range(indices, values);
// indirect_view[0] == values[2] == 30.0f
// indirect_view[1] == values[0] == 10.0f

std::array<int, 4> indices_static = {2, 0, 3, 1};
auto indirect_view_static = tf::make_indirect_range(indices_static, values);
static_assert(tf::static_size_v<decltype(indirect_view_static)> == 4);

tf::buffer<std::array<int, 3>> faces = {{0,1,2}, {3,4,5}, {6,7,8}};
tf::index_map_buffer<int> face_map; // Maps old face IDs to new point IDs
// Fill face_map...

auto remapped_faces = tf::make_block_indirect_range(faces, face_map.f());

auto r = remapped_faces.front();
static_assert(tf::static_size_v<decltype(r)> == 3);

// Sequence range for indices
auto sequence = tf::make_sequence_range(100); // 0, 1, 2, ..., 99

// Enumeration
auto enumerated = tf::enumerate(data_range); // pairs of (index, value)

// Zip ranges together
auto zipped = tf::zip(range1, range2, range3);

// Take/drop operations
auto first_10 = tf::take(data_range, 10);
auto skip_5 = tf::drop(data_range, 5);

// Slice operations
auto slice = tf::slice(data_range, 5, 14); // Elements 5-14

// Constant range (for default values)
auto constant_values = tf::make_constant_range(default_value, count);

// Mapped range (transform on access)
auto mapped = tf::make_mapped_range(data_range, [](auto x) { return x * 2; });

// From flat ranges
std::vector<float> raw_pts;
auto pts0 = tf::make_points<3>(raw_pts);
tf::point_view<float, 3> pt = pts0.front();

// From ranges of primitives
std::vector<tf::point<float, 3>> owned_pts;
auto pts1 = tf::make_points(owned_pts);

// Zero-copy view creation
float* coordinate_array = get_external_coords();
int point_count = get_point_count();
auto point_view = tf::make_points<3>(tf::make_range(coordinate_array, point_count * 3));

// Work with individual points
for (auto point : point_view) {
    // point is a tf::point_view<float, 3>
    auto [x, y, z] = point;
}

auto segments0 = tf::make_segments(tf::make_blocked_range<2>(points));
// or a sliding window
auto segments1 = tf::make_segments(tf::make_slide_range<2>(points));

std::vector<int> flat_ids = {0, 1, 2, 3};  // Two edges
auto edges = tf::make_edges(flat_ids);  // Automatically blocks by 2

for (auto edge : edges) {
    auto [v0, v1] = edge;
    // Process vertex indices
}

auto segments = tf::make_segments(edges, points);

// Segment elements give you points
auto [pt0, pt1] = segments.front();

// Access indices through .indices()
auto [id0, id1] = segments.front().indices();

// Access the underlying ranges
auto edges_range = segments.edges();
auto points_range = segments.points();

// Sliding window for continuous polylines
// Each point connects to the next: (0,1), (1,2), (2,3), (3,4)
std::vector<int> path_ids = {0, 1, 2, 3, 4};
auto segments = tf::make_segments(tf::make_slide_range<2>(path_ids), points);

for (auto [pt0, pt1] : segments) {
    // Process consecutive point pairs
}

auto polygons0 = tf::make_polygons(tf::make_blocked_range<3>(points));
// or strips
auto polygons1 = tf::make_polygons(tf::make_slide_range<3>(points));

std::vector<int> flat_ids = {0, 1, 2, 3, 4, 5};  // Two triangles
auto faces = tf::make_faces<3>(flat_ids);

for (auto face : faces) {
    auto [v0, v1, v2] = face;
    // Process vertex indices
}

auto polygons = tf::make_polygons(faces, points);

// Polygon elements give you points
auto [pt0, pt1, pt2] = polygons.front();

// Access indices through .indices()
auto [id0, id1, id2] = polygons.front().indices();

// Access the underlying ranges
auto faces_range = polygons.faces();
auto points_range = polygons.points();

// VTK legacy format: (3, a, b, c, 3, e, f, g, ...)
// Each polygon prefixed with vertex count
auto polygons = tf::make_polygons(tf::make_tag_blocked_range<3>(ids), points);

// Offsets define face boundaries, data contains vertex indices
tf::buffer<int> offsets = {0, 3, 7, 10};  // 3 faces: tri, quad, tri
tf::buffer<int> data = {0,1,2, 3,4,5,6, 7,8,9};

auto faces = tf::make_faces(offsets, data);
auto polygons = tf::make_polygons(faces, points);

// Iterate over variable-size polygons
for (auto polygon : polygons) {
    for (auto pt : polygon) {
        // Process each point
    }
    for (auto id : polygon.indices()) {
        // Process vertex index
    }
}

// Paths
tf::offset_block_buffer<int, int> path_data;
path_data.push_back({0, 1, 2, 3}); // First path
path_data.push_back({4, 5, 6});    // Second path

auto paths = tf::make_paths(path_data);
for (auto path : paths) {
    for (auto vertex_id : path) {
        // Process path vertices
    }
}

// Curves combine paths with point data
tf::offset_block_buffer<int, int> path_indices;
tf::points_buffer<float, 3> curve_points;
// Fill data...

auto curves = tf::make_curves(path_indices, curve_points);
for (auto curve : curves) {
    // Access both indices and geometry
    for (auto vertex_id : curve.indices()) {
        // Process vertex indices
    }
    for (auto point : curve) {
        // Process geometric points
    }
}

// Tag with a transformation (automatically wrapped in a frame)
auto rotation = tf::make_rotation(tf::deg(45.f), tf::axis<2>);
auto rotated_polygons = polygons | tf::tag(rotation);

// Tag with a frame (transformation + inverse)
auto frame = tf::make_frame(tf::random_transformation<float, 3>());
auto transformed_mesh = polygons | tf::tag(frame);

// Works with all primitive ranges
auto translated_points = points | tf::tag(translation);
auto rotated_segments = segments | tf::tag(rotation);

// Returns the tagged frame
auto frame = tf::frame_of(transformed_mesh);

// Returns identity_frame when not tagged
auto identity = tf::frame_of(polygons);

// Works uniformly for tagged and untagged ranges
auto pt = tf::transformed(point, tf::frame_of(range));  // no-op if untagged

// Polygon area (3D polygons projected to their plane)
auto a = tf::area(polygon);
auto a2 = tf::area2(polygon);  // Squared, avoids sqrt

// Signed volume of a closed mesh
// Positive = outward-facing normals, negative = inward-facing
auto vol = tf::signed_volume(polygons);

// Mean edge length (useful for adaptive algorithms, mesh density)
auto mean = tf::mean_edge_length(polygons);
auto mean_seg = tf::mean_edge_length(segments);

// Min/max edge length (mesh quality assessment)
auto min_len = tf::min_edge_length(polygons);
auto max_len = tf::max_edge_length(polygons);

// Also works with segments
auto min_seg = tf::min_edge_length(segments);
auto max_seg = tf::max_edge_length(segments);

// Normal from three points (CCW winding, right-hand rule)
auto normal = tf::make_normal(pt0, pt1, pt2);

// Normal from polygon (uses first 3 vertices)
auto poly_normal = tf::make_normal(polygon);

// Normalize vectors
tf::normalize(vector);               // In-place
auto unit = tf::normalized(vector);  // Returns a unit_vector

// Centroid (mean position)
auto pt_center = tf::centroid(points);        // Point cloud
auto poly_center = tf::centroid(polygon);     // Single polygon
auto mesh_center = tf::centroid(polygons);    // Mesh (weighted by vertex count)

// Covariance matrix (for OBB computation, PCA, etc.)
auto [centroid, cov] = tf::covariance_of(points);

// Cross-covariance matrix between two point sets (for rigid alignment)
auto [cx, cy, cross_cov] = tf::cross_covariance_of(X, Y);

// AABB from a single primitive
tf::aabb<float, 3> pt_box = tf::aabb_from(point);
tf::aabb<float, 3> seg_box = tf::aabb_from(segment);
tf::aabb<float, 3> poly_box = tf::aabb_from(polygon);

// AABB from ranges
tf::aabb<float, 3> pts_box = tf::aabb_from(points);
tf::aabb<float, 3> mesh_box = tf::aabb_from(polygons);
tf::aabb<float, 3> segs_box = tf::aabb_from(segments);

// OBB from ranges (uses PCA)
tf::obb<float, 3> pts_obb = tf::obb_from(points);
tf::obb<float, 3> mesh_obb = tf::obb_from(polygons);
tf::obb<float, 3> segs_obb = tf::obb_from(segments);

// Access OBB properties
auto origin = mesh_obb.origin;           // Corner point
auto axes = mesh_obb.axes;               // Orientation (unit vectors)
auto extent = mesh_obb.extent;           // Full dimensions along each axis

// OBBRSS from ranges (uses PCA)
tf::obbrss<float, 3> pts_obbrss = tf::obbrss_from(points);
tf::obbrss<float, 3> mesh_obbrss = tf::obbrss_from(polygons);
tf::obbrss<float, 3> segs_obbrss = tf::obbrss_from(segments);

// Access OBBRSS properties
auto obb_origin = mesh_obbrss.obb_origin;  // OBB corner
auto rss_origin = mesh_obbrss.rss_origin;  // RSS rectangle corner
auto axes = mesh_obbrss.axes;              // Shared orientation
auto extent = mesh_obbrss.extent;          // OBB dimensions
auto length = mesh_obbrss.length;          // RSS rectangle dimensions
auto radius = mesh_obbrss.radius;          // RSS sphere radius

// Start with a polygon range
auto polygons = tf::make_polygons(tf::make_faces<3>(face_indices), points);

// Extract a single polygon
auto polygon = polygons.front();

// Extract a point from the polygon
auto point = polygon[0];

// Extract coordinate type and dimensions at any level
using poly_coord_t = tf::coordinate_type_t<decltype(polygons)>;  // float
using point_coord_t = tf::coordinate_type_t<decltype(point)>;    // float

constexpr auto poly_dims = tf::coordinate_dims_v<decltype(polygons)>;  // 3
constexpr auto point_dims = tf::coordinate_dims_v<decltype(point)>;    // 3

// Common type across multiple policies (useful for mixed operations)
using common_t = tf::coordinate_type_t<Policy0, Policy1>;

// Static assertions for compile-time checks
static_assert(tf::coordinate_dims_v<decltype(polygon)> == 3);

tf::buffer<float> coords;
coords.allocate(1000);  // Allocates uninitialized memory
coords.push_back(1.0f);
coords.emplace_back(2.0f);

// Take ownership of underlying memory
std::size_t byte_size = coords.size() * sizeof(float);
float* raw_ptr = coords.release();

// Standard container interface
for (auto value : coords) {
    // Process value
}

tf::blocked_buffer<int, 3> triangle_indices;
triangle_indices.emplace_back(0, 1, 2);
triangle_indices.push_back({3, 4, 5});

// Access blocks
auto triangle = triangle_indices.front(); // Returns array-like object
auto [v0, v1, v2] = triangle;

// Access underlying flat memory
int* raw_data = triangle_indices.data_buffer().data();
std::size_t total_ints = triangle_indices.size() * 3;

tf::offset_block_buffer<int, int> polygon_indices;
polygon_indices.push_back({0, 1, 2});     // Triangle
polygon_indices.push_back({3, 4, 5, 6}); // Quad
polygon_indices.push_back(tf::make_range( // a range
                polygon_indices.front()));

// Iterate over variable-length blocks
for (auto polygon : polygon_indices) {
    for (auto vertex_id : polygon) {
        // Process vertex
    }
}

// Access underlying flat data
auto& offsets = polygon_indices.offsets_buffer();
auto& data = polygon_indices.data_buffer();

tf::points_buffer<float, 3> points;
points.allocate(1000);
points.emplace_back(1.0f, 2.0f, 3.0f);
points.push_back(tf::make_point(4.0f, 5.0f, 6.0f));

// Semantic access through range view
auto first_point = points.front();
auto points_view = points.points(); // a tf::points view

// Direct access to flat memory
float* coordinates = points.data_buffer().data();
std::size_t total_floats = points.size() * 3;

tf::vectors_buffer<float, 3> vectors;
vectors.allocate(500);
vectors.emplace_back(1.0f, 0.0f, 0.0f);

// Semantic access
auto first_vector = vectors.front();
auto vectors_view = vectors.vectors(); // a tf::vectors view

// Direct access to flat memory
float* vector_data = vectors.data_buffer().data();

tf::unit_vectors_buffer<float, 3> normals;
normals.allocate(1000);
normals.push_back(tf::make_unit_vector(1.0f, 0.0f, 0.0f));

// Semantic access
auto normals_view = normals.unit_vectors();
auto first_normal = normals_view.front();

// Direct access to flat memory
float* normal_data = normals.data_buffer().data();

tf::segments_buffer<int, float, 3> segments;
segments.edges_buffer().emplace_back(0, 1);
segments.points_buffer().emplace_back(0.0f, 0.0f, 0.0f);
segments.points_buffer().emplace_back(1.0f, 0.0f, 0.0f);

// Semantic access
auto segments_view = segments.segments();  // Equivalent range view
auto first_segment = segments_view.front();
auto [pt0, pt1] = first_segment;

// Direct access to flat memory
int* edge_indices = segments.edges_buffer().data_buffer().data();
float* point_coords = segments.points_buffer().data_buffer().data();

// Static size (triangles) - faces buffer is a blocked buffer
tf::polygons_buffer<int, float, 3, 3> triangles;
triangles.faces_buffer().emplace_back(0, 1, 2);

// Dynamic size (mixed polygons) - faces buffer is an offset block buffer
tf::polygons_buffer<int, float, 3, tf::dynamic_size> mixed_polygons;
mixed_polygons.faces_buffer().push_back({0, 1, 2});     // Triangle
mixed_polygons.faces_buffer().push_back({3, 4, 5, 6}); // Quad

// Semantic access
auto polygons_view = mixed_polygons.polygons();  // Equivalent range view
auto mesh_points = mixed_polygons.points();
auto mesh_faces = mixed_polygons.faces();

// Direct access to flat memory
int* face_data = mixed_polygons.faces_buffer().data_buffer().data();
float* point_data = mixed_polygons.points_buffer().data_buffer().data();

tf::curves_buffer<int, float, 3> curves;
curves.paths_buffer().push_back({0, 1, 2});

// Semantic access
auto curves_view = curves.curves();  // Equivalent range view
auto curve_points = curves.points();
auto curve_paths = curves.paths();

// Direct access to flat memory
int* path_data = curves.paths_buffer().data_buffer().data();
float* point_data = curves.points_buffer().data_buffer().data();

// Owning buffer type
tf::index_map_buffer<int> im;
im.f().allocate(original_size);
im.kept_ids().allocate(kept_size);

// View type from existing ranges
auto im_view = tf::make_index_map(
                tf::make_range(im.f()),
                tf::make_range(im.kept_ids()));

// Access underlying data
int* forward_data = im.f().data();
int* kept_data = im.kept_ids().data();

// Check if element was removed
if (im.f()[old_id] == im.f().size()) {
    // Element was removed
}

// Iterate only kept elements
for (auto old_id : im.kept_ids()) {
    auto new_id = im.f()[old_id];  // Always valid
}

// From boolean mask
tf::buffer<bool> mask = /* ... */;
auto im = tf::mask_to_index_map<int>(mask);

// From ID list
tf::buffer<int> ids = {2, 5, 7};
auto im = tf::ids_to_index_map<int>(ids, total_count);

// For deduplication
tf::index_map_buffer<int> im;
tf::make_unique_index_map(data, im /*equals_f, less_than_f*/);

// Tag with transformation (wrapped in frame automatically)
auto rotation = tf::make_rotation(tf::deg(45.f), tf::axis<2>);
auto rotated_mesh = polygons | tf::tag(rotation);

// Tag with frame (transformation + inverse)
auto frame = tf::make_frame(tf::random_transformation<float, 3>());
auto dynamic_mesh = polygons | tf::tag(frame);

// Tag a point with a normal
auto point = tf::random_point<float, 3>() | tf::tag_normal(normal);
auto n = point.normal();

// Tag a segment with a plane
auto segment = tf::make_segment_between_points(p0, p1) | tf::tag_plane(plane);
auto p = segment.plane();

// Provide the value or let it compute
auto tagged0 = polygon | tf::tag_plane(precomputed_plane);
auto tagged1 = polygon | tf::tag_plane();  // computes plane automatically

// make_plane detects the tag and returns cached value
auto cached_plane = tf::make_plane(tagged1);  // no recomputation

// Same for normals
auto with_normal = polygon | tf::tag_normal();  // computes normal
auto cached_normal = tf::make_normal(with_normal);  // returns cached

auto tagged = polygon | tf::tag_plane();
auto still_tagged = tagged | tf::tag_plane();  // no-op
auto also_tagged = tagged | tf::tag_plane(some_plane);  // also no-op

// Tag points with normals
auto points = tf::make_points<3>(coords) | tf::tag_normals(point_normals);

// Access normals on the range
const auto& normals = points.normals();

auto points = tf::make_points<3>(coords) | tf::tag_normals(point_normals);
auto polygons = tf::make_polygons(faces, points) | tf::tag_normals(face_normals);

// Access normals at each level
const auto& pt_normals = polygons.points().normals();  // point normals
const auto& poly_normals = polygons.normals();         // face normals

auto points = tf::make_points<3>(coords) | tf::zip_normals(point_normals);
auto polygons = tf::make_polygons(faces, points) | tf::zip_normals(face_normals);

// Access on ranges
const auto& pt_normals = points.normals();
const auto& poly_normals = polygons.normals();

// Access on individual elements
const auto& pt_normal = points.front().normal();
const auto& face_normal = polygons.front().normal();

// Tag spatial tree for accelerated queries
tf::aabb_tree<int, float, 3> tree(polygons, tf::config_tree(4, 4));
tf::aabb_tree<int, float, 3> point_tree(polygons.points(), tf::config_tree(4, 4));

auto form = tf::make_polygons(polygons.faces(),
                              polygons.points() | tf::tag(point_tree))
            | tf::tag(tree);

auto face_membership = tf::make_face_membership(polygons);
auto edge_link = tf::make_manifold_edge_link(polygons);

// Tag topology structures for mesh operations
auto form_with_topology = form | tf::tag(face_membership) | tf::tag(edge_link);

// Tag a point with an ID
auto point = tf::random_point<float, 3>() | tf::tag_id("vertex_0");
const auto& id = point.id();

// Tag with arbitrary state (direction + color)
auto direction = tf::normalized(tf::random_vector<float, 3>());
std::array<float, 3> color{1.0f, 0.0f, 0.0f};
auto point_with_state = point | tf::tag_state(direction, color);
const auto& [dir, col] = point_with_state.state();

// Tagged objects still behave like the original
auto d2 = tf::distance2(point_with_state, tf::random_point<float, 3>());

auto points = tf::make_points<3>(raw_pts)
              | tf::zip_ids(ids)
              | tf::zip_normals(tf::make_unit_vectors<3>(raw_normals));

// Access all IDs/normals as ranges
const auto& all_ids = points.ids();
const auto& all_normals = points.normals();

// Access individual element's data
auto pt = points.front();
const auto& pt_id = pt.id();
const auto& pt_normal = pt.normal();

auto point = tf::random_point<float, 3>()
             | tf::tag_id("vertex")
             | tf::tag_normal(normal);

tf::frame<float, 3> frame{tf::random_transformation<float, 3>()};
auto transformed = tf::transformed(point, frame);

// Point transformed, normal rotated, id copied
const auto& same_id = transformed.id();
const auto& rotated_normal = transformed.normal();

auto plain_points = points | tf::plain();

// Basic parallel apply
tf::parallel_for_each(points, [](auto&& pt) {
    pt = tf::normalized(pt.as_vector());
});

// With zip for multiple ranges
tf::parallel_for_each(tf::zip(range1, range2), [](auto pair) {
    auto &&[elem1, elem2] = pair;
    elem1 += elem2;
});

// With checked execution (use sequential if size is small)
tf::parallel_for_each(points, [](auto&& pt) {
    pt = tf::normalized(pt.as_vector());
}, tf::checked);