@metamesh/modeling 0.18.0 → 0.20.0

package/dist/geometry/mesh/join-layers.js

@@ -0,0 +1,833 @@
+import { GeometryError } from "../errors.js";
+import { assertMeshAllocationWithinLimits } from "../limits.js";
+import { signedContourArea } from "../regions/operations.js";
+/** @internal One bounded traversal budget for connection arrangement and meshing. */
+export class JoinWork {
+    count;
+    constructor(initial = 0) {
+        this.count = initial;
+    }
+    use(amount = 1) {
+        this.count += amount;
+        if (this.count > 2_000_000)
+            throw new GeometryError("COMPLEXITY_LIMIT", "Join arrangement exceeds 2,000,000 work steps.", { operation: "join" });
+    }
+}
+/** @internal Evaluate an affine support chart, in local millimetres. */
+export const joinHeight = (plane, p) => plane[0] * p[0] + plane[1] * p[1] + plane[2];
+/** @internal Stable signed area of a closed projected polygon. */
+export const joinArea = signedContourArea;
+/** @internal Clip a convex cell to a closed affine half-plane; no topology matching occurs. */
+export function clipJoinPolygon(polygon, plane) {
+    return clipJoinHalfPlane(polygon, (point) => joinHeight(plane, point));
+}
+function clipJoinHalfPlane(polygon, distance) {
+    const output = [];
+    if (polygon.length === 0)
+        return output;
+    let da = distance(polygon[0]);
+    for (let i = 0; i < polygon.length; i++) {
+        const a = polygon[i], b = polygon[(i + 1) % polygon.length];
+        const db = distance(b);
+        const aInside = da >= 0, bInside = db >= 0;
+        if (aInside)
+            output.push(a);
+        if (aInside !== bInside) {
+            const t = da / (da - db);
+            output.push([a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t]);
+        }
+        da = db;
+    }
+    return output;
+}
+/** @internal Intersection of convex projected cells, retaining their exact clipping boundaries. */
+export function intersectJoinPolygons(first, second) {
+    let result = first;
+    const sign = Math.sign(joinArea(second));
+    if (second.length < 3 || sign === 0)
+        return [];
+    for (let i = 0; i < second.length && result.length >= 3; i++) {
+        const a = second[i], b = second[(i + 1) % second.length];
+        result = clipJoinEdge(result, a, b, sign);
+    }
+    return result;
+}
+/** @internal Difference of two convex cells as disjoint convex construction cells. */
+export function subtractJoinPolygon(subject, cut, work) {
+    const usable = (polygon) => polygon.length >= 3 && joinArea(polygon) !== 0;
+    if (!usable(subject))
+        return [];
+    if (!usable(cut))
+        return [subject];
+    let inside = subject;
+    const result = [];
+    const sign = Math.sign(joinArea(cut));
+    for (let i = 0; i < cut.length && usable(inside); i++) {
+        work.use(inside.length * 2 + 1);
+        const a = cut[i], b = cut[(i + 1) % cut.length];
+        const dx = b[0] - a[0], dy = b[1] - a[1];
+        if (Math.hypot(dx, dy) <= joinEdgeRoundoff(a, b))
+            continue;
+        const outside = clipJoinEdge(inside, a, b, -sign);
+        if (usable(outside))
+            result.push(outside);
+        inside = clipJoinEdge(inside, a, b, sign);
+    }
+    return result;
+}
+const joinEdgeRoundoff = (a, b) => Number.EPSILON * 64 * Math.max(1, Math.abs(a[0]), Math.abs(a[1]), Math.abs(b[0]), Math.abs(b[1]));
+// Retain the edge origin when evaluating a geometric cut. Expanding a tiny edge
+// into a*x+b*y+c can cancel its constant and create an unrelated half-plane.
+function clipJoinEdge(polygon, a, b, sign) {
+    const dx = b[0] - a[0], dy = b[1] - a[1];
+    if (Math.hypot(dx, dy) <= joinEdgeRoundoff(a, b))
+        return polygon;
+    return clipJoinHalfPlane(polygon, (p) => sign * (dx * (p[1] - a[1]) - dy * (p[0] - a[0])));
+}
+/**
+ * @internal Square Minkowski sum, bounded by sqrt(2)*margin from the source cell.
+ * The absolute bound also holds at acute corners, unlike parallel-edge miters.
+ */
+export function expandJoinPolygon(polygon, margin, work) {
+    const candidates = polygon
+        .flatMap(([x, y]) => [
+        [x - margin, y - margin],
+        [x + margin, y - margin],
+        [x + margin, y + margin],
+        [x - margin, y + margin],
+    ])
+        .sort((a, b) => {
+        work.use();
+        return a[0] - b[0] || a[1] - b[1];
+    });
+    const turn = (a, b, c) => (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]);
+    const half = (points) => {
+        const result = [];
+        for (const point of points) {
+            while (result.length >= 2) {
+                work.use();
+                if (turn(result.at(-2), result.at(-1), point) > 0)
+                    break;
+                result.pop();
+            }
+            result.push(point);
+        }
+        result.pop();
+        return result;
+    };
+    return [...half(candidates), ...half([...candidates].reverse())];
+}
+/** @internal Local convex-cell containment, including shared crease edges. */
+export function inJoinPolygon(point, polygon, epsilon) {
+    const sign = Math.sign(joinArea(polygon));
+    if (sign === 0 || polygon.length < 3)
+        return false;
+    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+    for (const [x, y] of polygon) {
+        minX = Math.min(minX, x);
+        minY = Math.min(minY, y);
+        maxX = Math.max(maxX, x);
+        maxY = Math.max(maxY, y);
+    }
+    if (point[0] < minX - epsilon ||
+        point[0] > maxX + epsilon ||
+        point[1] < minY - epsilon ||
+        point[1] > maxY + epsilon)
+        return false;
+    return polygon.every((a, i) => {
+        const b = polygon[(i + 1) % polygon.length];
+        return (sign * ((b[0] - a[0]) * (point[1] - a[1]) - (b[1] - a[1]) * (point[0] - a[0])) >=
+            -epsilon * Math.hypot(b[0] - a[0], b[1] - a[1]));
+    });
+}
+/** @internal Conservative point queries in original polygon order; geometric predicates remain with the caller. */
+export function createJoinPolygonIndex(polygons, work, limits) {
+    assertMeshAllocationWithinLimits(0, 0, polygons.length * 160, "join", limits);
+    const bounds = (entries) => {
+        let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+        for (const entry of entries) {
+            work.use();
+            minX = Math.min(minX, entry.min[0]);
+            minY = Math.min(minY, entry.min[1]);
+            maxX = Math.max(maxX, entry.max[0]);
+            maxY = Math.max(maxY, entry.max[1]);
+        }
+        return { min: [minX, minY], max: [maxX, maxY] };
+    };
+    const entries = [];
+    for (const [id, polygon] of polygons.entries()) {
+        if (polygon.length === 0)
+            continue;
+        let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+        for (const p of polygon) {
+            work.use();
+            minX = Math.min(minX, p[0]);
+            minY = Math.min(minY, p[1]);
+            maxX = Math.max(maxX, p[0]);
+            maxY = Math.max(maxY, p[1]);
+        }
+        entries.push({ id, min: [minX, minY], max: [maxX, maxY] });
+    }
+    const build = (entries) => {
+        const box = bounds(entries);
+        if (entries.length <= 4)
+            return { ...box, entries };
+        const axis = box.max[0] - box.min[0] >= box.max[1] - box.min[1] ? 0 : 1;
+        const sorted = [...entries].sort((a, b) => {
+            work.use();
+            return a.min[axis] + a.max[axis] - b.min[axis] - b.max[axis];
+        });
+        const middle = sorted.length >>> 1;
+        return { ...box, children: [build(sorted.slice(0, middle)), build(sorted.slice(middle))] };
+    };
+    const root = build(entries);
+    const queries = new Map();
+    let queryBytes = 0;
+    return (point, epsilon) => {
+        work.use();
+        let minX = point[0], maxX = point[0], minY = point[1], maxY = point[1];
+        let queryKey;
+        const step = epsilon > 0 ? 2 ** Math.floor(Math.log2(epsilon)) : 0;
+        const x = Math.floor(point[0] / step), y = Math.floor(point[1] / step);
+        if (step > 0 && [x, y, x + 1, y + 1].every(Number.isSafeInteger)) {
+            const tile = [x * step, (x + 1) * step, y * step, (y + 1) * step];
+            if (tile.every(Number.isFinite) &&
+                point[0] >= tile[0] &&
+                point[0] <= tile[1] &&
+                point[1] >= tile[2] &&
+                point[1] <= tile[3]) {
+                [minX, maxX, minY, maxY] = tile;
+                queryKey = `${epsilon}:${x},${y}`;
+                const cached = queries.get(queryKey);
+                if (cached !== undefined)
+                    return cached;
+            }
+        }
+        const result = [], pending = [root];
+        // Cache only a conservative candidate list for the whole tile. The caller still tests
+        // the original query point, so nearby proxy/native coordinates never change acceptance.
+        const contains = (box) => maxX >= box.min[0] - epsilon &&
+            minX <= box.max[0] + epsilon &&
+            maxY >= box.min[1] - epsilon &&
+            minY <= box.max[1] + epsilon;
+        while (pending.length > 0) {
+            work.use();
+            const node = pending.pop();
+            if (!contains(node))
+                continue;
+            if (node.children !== undefined)
+                pending.push(...node.children);
+            else
+                for (const entry of node.entries) {
+                    work.use();
+                    if (contains(entry))
+                        result.push(entry.id);
+                }
+        }
+        result.sort((a, b) => {
+            work.use();
+            return a - b;
+        });
+        if (queryKey !== undefined) {
+            queryBytes += 128 + queryKey.length * 2 + result.length * 8;
+            assertMeshAllocationWithinLimits(0, 0, polygons.length * 160 + queryBytes, "join", limits);
+            queries.set(queryKey, result);
+        }
+        return result;
+    };
+}
+/**
+ * @internal Prepare one conforming XY partition for proof and visible layers at different heights.
+ * Shared construction vertices are captured once; this does not weld or repair an input mesh.
+ */
+export function prepareJoinLayer(polygons, epsilon, limits, work, options = {}) {
+    const points = [];
+    const nativePoints = [];
+    const sourcePoints = [];
+    const buckets = new Map();
+    const represented = new Map();
+    let coordinateScale = 1, inputSlots = 0;
+    for (const polygon of polygons)
+        for (const p of polygon) {
+            work.use();
+            inputSlots++;
+            coordinateScale = Math.max(coordinateScale, Math.abs(p[0]), Math.abs(p[1]));
+        }
+    // Budget retained Double lineage, represented nodes and face-slot tables before copying them.
+    assertMeshAllocationWithinLimits(0, 0, inputSlots * 176, "join", limits);
+    // Retain Double intersection lineage for noding, while capturing each representable
+    // Float32 construction node once. Neither operation changes an input solid mesh.
+    const constructionEpsilon = Math.min(epsilon, coordinateScale * Number.EPSILON * 64);
+    const grid = constructionEpsilon;
+    const representationGrid = 2 ** Math.floor(Math.log2(epsilon));
+    const point = (p) => {
+        const x = Math.floor(p[0] / grid), y = Math.floor(p[1] / grid);
+        for (let dx = -1; dx <= 1; dx++)
+            for (let dy = -1; dy <= 1; dy++) {
+                const entries = buckets.get(`${x + dx},${y + dy}`);
+                if (entries !== undefined)
+                    for (const index of entries) {
+                        work.use();
+                        const source = sourcePoints[index];
+                        if (Math.hypot(p[0] - source.p[0], p[1] - source.p[1]) <= constructionEpsilon)
+                            return source;
+                    }
+            }
+        const px = Math.fround(Math.round(p[0] / representationGrid) * representationGrid), py = Math.fround(Math.round(p[1] / representationGrid) * representationGrid);
+        const representedKey = `${px},${py}`;
+        let id = represented.get(representedKey);
+        if (id === undefined) {
+            id = points.length;
+            represented.set(representedKey, id);
+            points.push([px, py]);
+            nativePoints.push([p[0], p[1]]);
+        }
+        const index = sourcePoints.length;
+        const source = { p: [p[0], p[1]], id };
+        sourcePoints.push(source);
+        const key = `${x},${y}`;
+        const entries = buckets.get(key);
+        if (entries === undefined)
+            buckets.set(key, [index]);
+        else
+            entries.push(index);
+        assertMeshAllocationWithinLimits(points.length * 2, points.length * 8, points.length * 168, "join", limits);
+        return source;
+    };
+    if (options.bottomGroups !== undefined && options.bottomGroups.length !== polygons.length)
+        throw new GeometryError("INVALID_ARGUMENT", "Join cap lineage must cover every source cell.", {
+            operation: "join",
+        });
+    const cells = polygons
+        .map((polygon, index) => ({ polygon, group: options.bottomGroups?.[index] ?? index }))
+        .filter(({ polygon: p }) => p.length >= 3 && Math.abs(joinArea(p)) > constructionEpsilon * constructionEpsilon)
+        .map(({ polygon: p, group }) => {
+        const oriented = joinArea(p) > 0 ? p : [...p].reverse();
+        const nodes = oriented
+            .map(point)
+            .filter((node, i, all) => node.id !== all[(i + all.length - 1) % all.length].id);
+        return { ids: nodes.map((node) => node.id), source: nodes.map((node) => node.p), group };
+    })
+        .filter((cell) => cell.ids.length >= 3 && joinArea(cell.ids.map((id) => points[id])) > 0);
+    // Split shared partition edges at every retained crossing, including collinear T junctions.
+    const pointIndex = joinPointIndex(sourcePoints, work, limits, inputSlots * 176);
+    const faces = cells
+        .map(({ ids: cell, source }) => cell.flatMap((id, i) => {
+        const a = source[i], b = source[(i + 1) % cell.length];
+        const dx = b[0] - a[0], dy = b[1] - a[1], length = Math.hypot(dx, dy);
+        const entries = [{ id, t: 0 }];
+        const seen = new Set(cell);
+        for (const node of pointIndex(a, b, constructionEpsilon)) {
+            work.use();
+            const candidate = node.id;
+            if (seen.has(candidate))
+                continue;
+            const p = node.p;
+            const t = ((p[0] - a[0]) * dx + (p[1] - a[1]) * dy) / (length * length);
+            if (t > constructionEpsilon / length &&
+                t < 1 - constructionEpsilon / length &&
+                Math.abs(dx * (p[1] - a[1]) - dy * (p[0] - a[0])) <= constructionEpsilon * length) {
+                entries.push({ id: candidate, t });
+                seen.add(candidate);
+            }
+        }
+        return entries.sort((a, b) => a.t - b.t).map((entry) => entry.id);
+    }))
+        .map((face) => {
+        const seen = new Set();
+        return face.filter((id) => {
+            if (seen.has(id))
+                return false;
+            seen.add(id);
+            return true;
+        });
+    });
+    const partitionBytes = inputSlots * 176 + (options.supportPlanes === undefined ? 0 : points.length * 16);
+    assertMeshAllocationWithinLimits(0, 0, partitionBytes, "join", limits);
+    const supportHeights = options.supportPlanes === undefined ? undefined : new Float64Array(points.length);
+    const nativeSupportHeights = options.supportPlanes === undefined ? undefined : new Float64Array(points.length);
+    if (options.supportPlanes !== undefined) {
+        const incidents = new Map();
+        for (let index = 0; index < faces.length; index++) {
+            const group = cells[index].group, plane = options.supportPlanes[group];
+            if (plane === undefined || plane.length !== 3 || !plane.every(Number.isFinite))
+                throw new GeometryError("INVALID_ARGUMENT", "Join support planes must cover every cap group.", { operation: "join" });
+            for (const id of faces[index]) {
+                work.use();
+                let groups = incidents.get(id);
+                if (groups === undefined) {
+                    groups = new Set();
+                    incidents.set(id, groups);
+                }
+                groups.add(group);
+            }
+        }
+        for (const [id, groups] of incidents) {
+            if (groups.size > 1)
+                nativePoints[id] = alignJoinCrease(nativePoints[id], [...groups].map((group) => options.supportPlanes[group]), epsilon, work);
+            // Incident lineage is authoritative at a shared node. Native crease coordinates satisfy
+            // those planes; the proxy uses their minimum without re-searching nearby support cells.
+            let proxyHeight = Infinity, nativeHeight = Infinity;
+            for (const group of groups) {
+                work.use(2);
+                const plane = options.supportPlanes[group];
+                proxyHeight = Math.min(proxyHeight, joinHeight(plane, points[id]));
+                nativeHeight = Math.min(nativeHeight, joinHeight(plane, nativePoints[id]));
+            }
+            supportHeights[id] = proxyHeight;
+            nativeSupportHeights[id] = nativeHeight;
+        }
+    }
+    // Capture height-independent triangulation once for both the contact proof and visible collar.
+    const topTriangles = [], bottomTriangles = [];
+    const triangle = (target, a, b, c) => {
+        const slots = topTriangles.length + bottomTriangles.length + 3;
+        assertMeshAllocationWithinLimits(points.length * 2, slots / 3, partitionBytes + slots * 8, "join", limits);
+        target.push(a, b, c);
+    };
+    const edges = new Map();
+    for (const face of faces) {
+        triangulateJoinCell(face, points, work, (a, b, c) => {
+            triangle(topTriangles, a, b, c);
+            if (options.triangulate === undefined)
+                triangle(bottomTriangles, a, c, b);
+        });
+        for (let i = 0; i < face.length; i++) {
+            const a = face[i], b = face[(i + 1) % face.length];
+            appendJoinEdge(edges, a, b, points);
+        }
+    }
+    // Affine support caps can drop transverse cell edges. The sampled top keeps
+    // every cell because its heights can vary within a single support group.
+    if (options.triangulate !== undefined)
+        appendJoinCaps(faces, cells.map((cell) => cell.group), points, options.triangulate, (a, b, c) => triangle(bottomTriangles, a, b, c), work);
+    const realize = (top, bottom, maximumLength, upperTriangles) => {
+        const positions = [], nativePositions = [], indices = [];
+        // Each upper vertex is immediately followed by its lower partner.
+        const vertices = new Map();
+        const vertex = (id) => {
+            const cached = vertices.get(id);
+            if (cached !== undefined)
+                return cached;
+            const p = points[id], hi = top(p, supportHeights?.[id]), lo = bottom(p, supportHeights?.[id]);
+            const native = nativePoints[id], nativeHi = top(native, nativeSupportHeights?.[id]), nativeLo = bottom(native, nativeSupportHeights?.[id]);
+            if (![hi, lo, nativeHi, nativeLo].every(Number.isFinite) || hi <= lo || nativeHi <= nativeLo)
+                throw new GeometryError("DEGENERATE_GEOMETRY", "Join layer needs resolved positive thickness.", { operation: "join" });
+            const upper = positions.length / 3;
+            assertMeshAllocationWithinLimits(positions.length / 3 + 2, indices.length / 3, (positions.length + 6) * 12 + indices.length * 4, "join", limits);
+            positions.push(p[0], p[1], hi, p[0], p[1], lo);
+            nativePositions.push(native[0], native[1], nativeHi, native[0], native[1], nativeLo);
+            vertices.set(id, upper);
+            return upper;
+        };
+        const append = (a, b, c) => {
+            assertMeshAllocationWithinLimits(positions.length / 3, indices.length / 3 + 1, positions.length * 12 + (indices.length + 3) * 4, "join", limits);
+            indices.push(a, b, c);
+        };
+        for (let i = 0; i < upperTriangles.length; i += 3)
+            append(vertex(upperTriangles[i]), vertex(upperTriangles[i + 1]), vertex(upperTriangles[i + 2]));
+        for (let i = 0; i < bottomTriangles.length; i += 3)
+            append(vertex(bottomTriangles[i]) + 1, vertex(bottomTriangles[i + 1]) + 1, vertex(bottomTriangles[i + 2]) + 1);
+        for (const edge of edges.values()) {
+            if (edge.paired)
+                continue;
+            const a = vertex(edge.a), b = vertex(edge.b);
+            append(a, a + 1, b + 1);
+            append(a, b + 1, b);
+        }
+        assertMeshAllocationWithinLimits(positions.length / 3, indices.length / 3, positions.length * 12 + indices.length * 4, "join", limits);
+        // Coarse caps need no unused partners for fine top interior vertices.
+        const used = new Map();
+        const constructionVertices = new Map();
+        const compact = [];
+        const compactNative = [];
+        const capture = (old) => {
+            let id = used.get(old);
+            if (id === undefined) {
+                const x = Math.fround(positions[old * 3]), y = Math.fround(positions[old * 3 + 1]), z = Math.fround(positions[old * 3 + 2]);
+                const key = `${x},${y},${z}`;
+                id = constructionVertices.get(key);
+                if (id === undefined) {
+                    id = compact.length / 3;
+                    constructionVertices.set(key, id);
+                    compact.push(x, y, z);
+                    compactNative.push(nativePositions[old * 3], nativePositions[old * 3 + 1], nativePositions[old * 3 + 2]);
+                }
+                used.set(old, id);
+            }
+            return id;
+        };
+        const compactIndices = [];
+        for (let i = 0; i < indices.length; i += 3) {
+            const a = capture(indices[i]), b = capture(indices[i + 1]), c = capture(indices[i + 2]);
+            if (a === b || b === c || c === a)
+                throw new GeometryError("DEGENERATE_GEOMETRY", "Join layer thickness exceeds coordinate precision.", { operation: "join" });
+            compactIndices.push(a, b, c);
+        }
+        return refineJoinLayer(compact, compactNative, compactIndices, maximumLength, limits, work);
+    };
+    return {
+        build: (top, bottom, maximumLength) => realize(top, bottom, maximumLength, topTriangles),
+        supportBand: (depth) => {
+            if (supportHeights === undefined || !Number.isFinite(depth) || depth <= 0)
+                throw new GeometryError("INVALID_ARGUMENT", "A support band needs retained affine planes and positive finite depth.", { operation: "join" });
+            assertMeshAllocationWithinLimits(points.length * 2, Math.max(topTriangles.length + bottomTriangles.length, bottomTriangles.length * 2) / 3, partitionBytes + (topTriangles.length + bottomTriangles.length * 2) * 8, "join", limits);
+            // Coalesced cap lineage already triangulates each affine support face. Reverse that cap
+            // for the proof's top, retaining the visible collar's exact outer and crease boundaries.
+            const upperTriangles = [];
+            for (let i = 0; i < bottomTriangles.length; i += 3) {
+                work.use();
+                upperTriangles.push(bottomTriangles[i], bottomTriangles[i + 2], bottomTriangles[i + 1]);
+            }
+            const support = (_p, height) => height;
+            return realize(support, (p, height) => support(p, height) - depth, undefined, upperTriangles);
+        },
+    };
+}
+// Query both coordinates: disconnected roots often share X ranges while lying far apart in Y.
+// A one-axis sweep needlessly visits every other root for each retained partition edge.
+function joinPointIndex(points, work, limits, allocationBytes) {
+    const build = (entries) => {
+        let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+        for (const { p } of entries) {
+            work.use();
+            minX = Math.min(minX, p[0]);
+            minY = Math.min(minY, p[1]);
+            maxX = Math.max(maxX, p[0]);
+            maxY = Math.max(maxY, p[1]);
+        }
+        const bounds = { min: [minX, minY], max: [maxX, maxY] };
+        if (entries.length <= 16)
+            return { ...bounds, entries };
+        const axis = maxX - minX >= maxY - minY ? 0 : 1;
+        const sorted = [...entries].sort((a, b) => {
+            work.use();
+            return a.p[axis] - b.p[axis];
+        });
+        const middle = sorted.length >>> 1;
+        return { ...bounds, children: [build(sorted.slice(0, middle)), build(sorted.slice(middle))] };
+    };
+    const root = build(points);
+    const queries = new Map();
+    let queryBytes = 0;
+    return (a, b, epsilon) => {
+        work.use();
+        const first = `${a[0]},${a[1]}`, second = `${b[0]},${b[1]}`;
+        const queryKey = `${epsilon}:${first < second ? `${first}:${second}` : `${second}:${first}`}`;
+        const cached = queries.get(queryKey);
+        if (cached !== undefined)
+            return cached;
+        const dx = b[0] - a[0], dy = b[1] - a[1];
+        const lineTolerance = epsilon * Math.hypot(dx, dy);
+        const minX = Math.min(a[0], b[0]) - epsilon, minY = Math.min(a[1], b[1]) - epsilon;
+        const maxX = Math.max(a[0], b[0]) + epsilon, maxY = Math.max(a[1], b[1]) + epsilon;
+        const result = [], pending = [root];
+        while (pending.length > 0) {
+            work.use();
+            const node = pending.pop();
+            if (node.max[0] < minX || node.min[0] > maxX || node.max[1] < minY || node.min[1] > maxY)
+                continue;
+            // Long diagonal edges have large boxes. Reject nodes outside their narrow line band,
+            // reserving arithmetic roundoff so this broad phase cannot drop a real T junction.
+            const minimumCross = dx * ((dx >= 0 ? node.min[1] : node.max[1]) - a[1]) -
+                dy * ((dy >= 0 ? node.max[0] : node.min[0]) - a[0]);
+            const maximumCross = dx * ((dx >= 0 ? node.max[1] : node.min[1]) - a[1]) -
+                dy * ((dy >= 0 ? node.min[0] : node.max[0]) - a[0]);
+            const roundoff = Number.EPSILON *
+                16 *
+                (Math.abs(dx) * (Math.max(Math.abs(node.min[1]), Math.abs(node.max[1])) + Math.abs(a[1])) +
+                    Math.abs(dy) * (Math.max(Math.abs(node.min[0]), Math.abs(node.max[0])) + Math.abs(a[0])));
+            if (minimumCross > lineTolerance + roundoff || maximumCross < -lineTolerance - roundoff)
+                continue;
+            if (node.children !== undefined)
+                pending.push(...node.children);
+            else
+                for (const entry of node.entries) {
+                    work.use();
+                    if (entry.p[0] >= minX && entry.p[0] <= maxX && entry.p[1] >= minY && entry.p[1] <= maxY)
+                        result.push(entry);
+                }
+        }
+        queryBytes += 128 + queryKey.length * 2 + result.length * 8;
+        assertMeshAllocationWithinLimits(0, 0, allocationBytes + queryBytes, "join", limits);
+        queries.set(queryKey, result);
+        return result;
+    };
+}
+// A merged construction node must remain on its source facets' actual crease.
+// Only the retained Double coordinates move; proxy topology stays untouched.
+function alignJoinCrease(point, planes, epsilon, work) {
+    const reference = planes[0];
+    const equations = planes
+        .slice(1)
+        .map((plane) => [
+        plane[0] - reference[0],
+        plane[1] - reference[1],
+        plane[2] - reference[2],
+    ]);
+    const resolved = equations.filter((plane) => Math.hypot(plane[0], plane[1]) >
+        Number.EPSILON * 64 * Math.max(1, Math.hypot(reference[0], reference[1])));
+    if (resolved.length === 0) {
+        const roundoff = Number.EPSILON * 128 * Math.max(1, Math.abs(point[0]), Math.abs(point[1]));
+        if (equations.some((plane) => Math.abs(joinHeight(plane, point)) > roundoff * Math.max(1, Math.abs(plane[2]))))
+            throw new GeometryError("DEGENERATE_GEOMETRY", "Join incident support planes do not share a resolved crease.", { operation: "join" });
+        return point;
+    }
+    let first = resolved[0], second, best = 0;
+    for (let i = 0; i < resolved.length; i++)
+        for (let j = i + 1; j < resolved.length; j++) {
+            work.use();
+            const a = resolved[i], b = resolved[j];
+            const angle = Math.abs(a[0] * b[1] - a[1] * b[0]) / (Math.hypot(a[0], a[1]) * Math.hypot(b[0], b[1]));
+            if (angle > best) {
+                first = a;
+                second = b;
+                best = angle;
+            }
+        }
+    let result;
+    if (second !== undefined && best > Number.EPSILON * 64) {
+        const determinant = first[0] * second[1] - first[1] * second[0];
+        result = [
+            (first[1] * second[2] - first[2] * second[1]) / determinant,
+            (first[2] * second[0] - first[0] * second[2]) / determinant,
+        ];
+    }
+    else {
+        const fraction = joinHeight(first, point) / (first[0] * first[0] + first[1] * first[1]);
+        result = [point[0] - fraction * first[0], point[1] - fraction * first[1]];
+    }
+    const roundoff = Number.EPSILON *
+        128 *
+        Math.max(1, Math.abs(point[0]), Math.abs(point[1]), Math.abs(result[0]), Math.abs(result[1]));
+    if (!result.every(Number.isFinite) ||
+        Math.hypot(result[0] - point[0], result[1] - point[1]) > epsilon + roundoff ||
+        equations.some((plane) => Math.abs(joinHeight(plane, result)) >
+            roundoff * Math.max(1, Math.abs(plane[0]), Math.abs(plane[1]), Math.abs(plane[2]))))
+        throw new GeometryError("DEGENERATE_GEOMETRY", "Join support crease cannot resolve within its construction precision.", { operation: "join" });
+    return result;
+}
+// Use retained boundary nodes only. A representable one-grid-cell-wide polygon
+// need not contain a representable fan centre; introducing one can tear its edge.
+function triangulateJoinCell(face, points, work, append) {
+    const cross = (a, b, c) => {
+        const p = points[a], q = points[b], r = points[c];
+        return (q[0] - p[0]) * (r[1] - p[1]) - (q[1] - p[1]) * (r[0] - p[0]);
+    };
+    const remaining = [...face];
+    while (remaining.length > 3) {
+        let clipped = false;
+        for (let i = 0; i < remaining.length; i++) {
+            work.use();
+            const a = remaining[(i + remaining.length - 1) % remaining.length], b = remaining[i], c = remaining[(i + 1) % remaining.length];
+            if (cross(a, b, c) <= 0)
+                continue;
+            if (remaining.some((p) => {
+                work.use();
+                return (p !== a &&
+                    p !== b &&
+                    p !== c &&
+                    cross(a, b, p) >= 0 &&
+                    cross(b, c, p) >= 0 &&
+                    cross(c, a, p) >= 0);
+            }))
+                continue;
+            append(a, b, c);
+            remaining.splice(i, 1);
+            clipped = true;
+            break;
+        }
+        if (!clipped)
+            throw new GeometryError("INVALID_TOPOLOGY", "Join cell cannot retain its represented boundary.", { operation: "join" });
+    }
+    if (remaining.length === 3 && cross(remaining[0], remaining[1], remaining[2]) > 0)
+        append(remaining[0], remaining[1], remaining[2]);
+    else
+        throw new GeometryError("INVALID_TOPOLOGY", "Join cell has no representable final triangle.", {
+            operation: "join",
+        });
+}
+// Shared edges must occur exactly twice with opposite winding, in both the full
+// partition and each cap group. Keep paired records so a third use still rejects.
+function appendJoinEdge(edges, a, b, points) {
+    const key = `${Math.min(a, b)},${Math.max(a, b)}`;
+    const previous = edges.get(key);
+    if (previous === undefined)
+        edges.set(key, { a, b, paired: false });
+    else if (previous.a !== b || previous.b !== a || previous.paired)
+        throw new GeometryError("INVALID_TOPOLOGY", "Join partition cells reverse or repeat a shared boundary.", {
+            operation: "join",
+            details: {
+                count: previous.paired ? 2 : 1,
+                x1: points[a][0],
+                y1: points[a][1],
+                x2: points[b][0],
+                y2: points[b][1],
+            },
+        });
+    else
+        previous.paired = true;
+}
+function appendJoinCaps(faces, groups, points, triangulate, append, work) {
+    const grouped = new Map();
+    for (let index = 0; index < faces.length; index++) {
+        const face = faces[index];
+        const group = groups[index];
+        let edges = grouped.get(group);
+        if (edges === undefined) {
+            edges = new Map();
+            grouped.set(group, edges);
+        }
+        for (let i = 0; i < face.length; i++) {
+            work.use();
+            const a = face[i], b = face[(i + 1) % face.length];
+            appendJoinEdge(edges, a, b, points);
+        }
+    }
+    for (const edges of grouped.values()) {
+        const boundary = [...edges.values()].filter((edge) => !edge.paired);
+        const outgoing = new Map();
+        for (const edge of boundary) {
+            const entries = outgoing.get(edge.a);
+            if (entries === undefined)
+                outgoing.set(edge.a, [edge]);
+            else
+                entries.push(edge);
+        }
+        const visited = new Set();
+        const loops = [];
+        for (const start of boundary) {
+            if (visited.has(start))
+                continue;
+            const loop = [];
+            let current = start;
+            while (!visited.has(current)) {
+                work.use();
+                visited.add(current);
+                loop.push(current.a);
+                if (current.b === start.a)
+                    break;
+                const candidates = outgoing.get(current.b)?.filter((edge) => !visited.has(edge));
+                if (candidates === undefined || candidates.length === 0)
+                    throw new GeometryError("INVALID_TOPOLOGY", "Join cap boundary does not close.", {
+                        operation: "join",
+                    });
+                const a = points[current.a], b = points[current.b];
+                const dx = b[0] - a[0], dy = b[1] - a[1];
+                current = candidates.reduce((best, candidate) => {
+                    work.use();
+                    const angle = (edge) => {
+                        const p = points[edge.b];
+                        const ex = p[0] - b[0], ey = p[1] - b[1];
+                        return Math.atan2(dx * ey - dy * ex, dx * ex + dy * ey);
+                    };
+                    return angle(candidate) > angle(best) ? candidate : best;
+                });
+            }
+            if (current.b !== start.a)
+                throw new GeometryError("INVALID_TOPOLOGY", "Join cap boundary branches ambiguously.", {
+                    operation: "join",
+                });
+            if (loop.length >= 3)
+                loops.push(loop);
+        }
+        const flat = loops.flat();
+        for (const triangle of triangulate(loops.map((loop) => loop.map((id) => points[id])))) {
+            work.use();
+            const a = flat[triangle[0]], b = flat[triangle[1]], c = flat[triangle[2]];
+            if (a === undefined || b === undefined || c === undefined)
+                throw new GeometryError("INVALID_TOPOLOGY", "Join cap triangulation lost a boundary slot.", {
+                    operation: "join",
+                });
+            if (joinArea([points[a], points[b], points[c]]) > 0)
+                append(a, c, b);
+            else
+                append(a, b, c);
+        }
+    }
+}
+function refineJoinLayer(positions, nativePositions, initialIndices, maximumLength, limits, work) {
+    // Inputs are owned arrays with proxy positions already rounded to Float32.
+    // Keep native coordinates separate until both buffers are finalized.
+    if (maximumLength === undefined)
+        return {
+            positions: Float32Array.from(positions),
+            nativePositions: Float64Array.from(nativePositions),
+            indices: Uint32Array.from(initialIndices),
+        };
+    if (!Number.isFinite(maximumLength) || maximumLength <= 0)
+        throw new GeometryError("INVALID_ARGUMENT", "Join segment length must be finite and positive.", {
+            operation: "join",
+        });
+    let indices = initialIndices;
+    const key = (a, b) => (a < b ? `${a},${b}` : `${b},${a}`);
+    while (true) {
+        // Discover all splits before replacing faces so every incident triangle
+        // shares each edge midpoint, regardless of its other edge lengths.
+        const midpoints = new Map();
+        for (let i = 0; i < indices.length; i += 3) {
+            const face = [indices[i], indices[i + 1], indices[i + 2]];
+            for (let j = 0; j < 3; j++) {
+                work.use();
+                const a = face[j], b = face[(j + 1) % 3];
+                const edge = key(a, b);
+                if (midpoints.has(edge))
+                    continue;
+                const length = Math.hypot(positions[a * 3] - positions[b * 3], positions[a * 3 + 1] - positions[b * 3 + 1], positions[a * 3 + 2] - positions[b * 3 + 2]);
+                if (length <= maximumLength)
+                    continue;
+                const p = [0, 1, 2].map((axis) => Math.fround((positions[a * 3 + axis] + positions[b * 3 + axis]) / 2));
+                if ([a, b].some((id) => p.every((value, axis) => value === positions[id * 3 + axis])))
+                    throw new GeometryError("DEGENERATE_GEOMETRY", "Join edge sampling exceeds coordinate precision.", {
+                        operation: "join",
+                    });
+                assertMeshAllocationWithinLimits(positions.length / 3 + 1, indices.length / 3, (positions.length + 3) * 12 + indices.length * 4, "join", limits);
+                midpoints.set(edge, positions.length / 3);
+                positions.push(p[0], p[1], p[2]);
+                for (let axis = 0; axis < 3; axis++)
+                    nativePositions.push((nativePositions[a * 3 + axis] + nativePositions[b * 3 + axis]) / 2);
+            }
+        }
+        if (midpoints.size === 0)
+            return {
+                positions: Float32Array.from(positions),
+                nativePositions: Float64Array.from(nativePositions),
+                indices: Uint32Array.from(indices),
+            };
+        const next = [];
+        for (let i = 0; i < indices.length; i += 3) {
+            work.use();
+            const a = indices[i], b = indices[i + 1], c = indices[i + 2];
+            const u = midpoints.get(key(a, b)), v = midpoints.get(key(b, c)), w = midpoints.get(key(c, a));
+            const mask = Number(u !== undefined) + 2 * Number(v !== undefined) + 4 * Number(w !== undefined);
+            switch (mask) {
+                case 0:
+                    next.push(a, b, c);
+                    break;
+                case 1:
+                    next.push(a, u, c, u, b, c);
+                    break;
+                case 2:
+                    next.push(b, v, a, v, c, a);
+                    break;
+                case 4:
+                    next.push(c, w, b, w, a, b);
+                    break;
+                case 3:
+                    next.push(b, v, u, a, u, c, u, v, c);
+                    break;
+                case 6:
+                    next.push(c, w, v, b, v, a, v, w, a);
+                    break;
+                case 5:
+                    next.push(a, u, w, c, w, b, w, u, b);
+                    break;
+                case 7:
+                    next.push(a, u, w, u, b, v, w, v, c, u, v, w);
+                    break;
+            }
+            assertMeshAllocationWithinLimits(positions.length / 3, next.length / 3, positions.length * 12 + next.length * 4, "join", limits);
+        }
+        indices = next;
+    }
+}