@metamesh/modeling 0.18.0 → 0.19.0

package/dist/engine/operations/join-collar-profile.js

@@ -0,0 +1,120 @@
+import { GeometryError } from "../../geometry/errors.js";
+import { assertMeshAllocationWithinLimits, } from "../../geometry/model-limits.js";
+import { assertSamplingCount } from "../../geometry/sampling-limits.js";
+import { observeNativeMesh } from "../native/mesh-observation.js";
+import { regionFromLoops } from "../native/regions.js";
+/** Slices original native facets; CrossSection quantization must not move the feature wall datum. */
+export function nativeCollarProfile(scope, feature, height, limits, work) {
+    const raw = observeNativeMesh(scope, feature, limits, "join");
+    const fail = () => {
+        throw new GeometryError("INVALID_TOPOLOGY", "The feature datum needs regular closed collar boundaries.", { operation: "join" });
+    };
+    const points = new Map();
+    const next = new Map();
+    const incoming = new Set();
+    const pointAt = (id) => [
+        raw.coordinates[id * 3],
+        raw.coordinates[id * 3 + 1],
+        raw.coordinates[id * 3 + 2],
+    ];
+    for (let triangle = 0; triangle < raw.triangles.length; triangle += 3) {
+        work.use();
+        const ids = [0, 1, 2].map((offset) => raw.vertexIndices[raw.triangles[triangle + offset]]);
+        const vertices = ids.map(pointAt);
+        const cut = [];
+        for (let edge = 0; edge < 3; edge++) {
+            const a = vertices[edge], b = vertices[(edge + 1) % 3];
+            const aBelow = a[2] <= height, bBelow = b[2] <= height;
+            if (aBelow === bBelow)
+                continue;
+            const ai = ids[edge], bi = ids[(edge + 1) % 3];
+            const fraction = (height - a[2]) / (b[2] - a[2]);
+            const identity = fraction === 0
+                ? `v${ai}`
+                : fraction === 1
+                    ? `v${bi}`
+                    : `e${Math.min(ai, bi)}:${Math.max(ai, bi)}`;
+            if (!points.has(identity)) {
+                assertSamplingCount(points.size + 1, "join", limits.maxProfilePoints);
+                assertMeshAllocationWithinLimits(0, 0, (points.size + 1) * 192, "join", limits);
+                points.set(identity, [a[0] + (b[0] - a[0]) * fraction, a[1] + (b[1] - a[1]) * fraction]);
+            }
+            if (!cut.includes(identity))
+                cut.push(identity);
+        }
+        if (cut.length === 0 || cut.length === 1)
+            continue;
+        if (cut.length !== 2)
+            fail();
+        const a = vertices[0], b = vertices[1], c = vertices[2];
+        const nx = (b[1] - a[1]) * (c[2] - a[2]) - (b[2] - a[2]) * (c[1] - a[1]);
+        const ny = (b[2] - a[2]) * (c[0] - a[0]) - (b[0] - a[0]) * (c[2] - a[2]);
+        const p = points.get(cut[0]), q = points.get(cut[1]);
+        if ((q[0] - p[0]) * -ny + (q[1] - p[1]) * nx < 0)
+            cut.reverse();
+        const from = cut[0], to = cut[1];
+        if (next.has(from) || incoming.has(to))
+            fail();
+        next.set(from, to);
+        incoming.add(to);
+        assertSamplingCount(next.size, "join", limits.maxProfilePoints);
+        assertMeshAllocationWithinLimits(0, 0, next.size * 192, "join", limits);
+    }
+    const loops = [];
+    const visited = new Set();
+    for (const start of next.keys()) {
+        if (visited.has(start))
+            continue;
+        const loop = [];
+        let id = start;
+        do {
+            work.use();
+            if (visited.has(id))
+                fail();
+            visited.add(id);
+            loop.push(points.get(id));
+            id = next.get(id) ?? fail();
+        } while (id !== start);
+        // Remove tessellation diagonals along the same physical wall, at Double comparison precision.
+        let scale = 1;
+        for (const [x, y] of loop) {
+            work.use();
+            scale = Math.max(scale, Math.abs(x), Math.abs(y));
+        }
+        const tolerance = scale * Number.EPSILON * 64;
+        let changed = true;
+        while (changed && loop.length > 3) {
+            changed = false;
+            for (let index = 0; index < loop.length; index++) {
+                work.use();
+                const a = loop[(index + loop.length - 1) % loop.length], b = loop[index], c = loop[(index + 1) % loop.length];
+                const dx = c[0] - a[0], dy = c[1] - a[1], length = Math.hypot(dx, dy);
+                const fraction = ((b[0] - a[0]) * dx + (b[1] - a[1]) * dy) / (length * length);
+                if (fraction >= 0 &&
+                    fraction <= 1 &&
+                    Math.abs(dx * (b[1] - a[1]) - dy * (b[0] - a[0])) <= tolerance * length) {
+                    work.use(loop.length - index - 1);
+                    loop.splice(index, 1);
+                    changed = true;
+                    break;
+                }
+            }
+        }
+        loops.push(loop);
+    }
+    if (loops.length === 0)
+        fail();
+    const region = regionFromLoops(loops);
+    const contour = (id, points) => ({
+        id,
+        points,
+        spans: points.map((_, index) => `point-${index}`),
+    });
+    return {
+        components: region.map((component, index) => ({
+            id: `component-${index}`,
+            outer: contour("outer", component.outer),
+            holes: component.holes.map((hole, index) => contour(`hole-${index}`, hole)),
+        })),
+    };
+}

package/dist/engine/operations/join.js

@@ -0,0 +1,508 @@
+import { anchor3, anchorFrame3 } from "../../geometry/anchors.js";
+import { GeometryError } from "../../geometry/errors.js";
+import { clipJoinPolygon, createJoinPolygonIndex, expandJoinPolygon, inJoinPolygon, intersectJoinPolygons, joinArea, joinHeight, JoinWork, prepareJoinLayer, subtractJoinPolygon, } from "../../geometry/join-geometry.js";
+import { validateSolidMesh } from "../../geometry/mesh/mesh-solid.js";
+import { assertMeshAllocationWithinLimits } from "../../geometry/model-limits.js";
+import { planRegionOffsets } from "../../geometry/region-offset.js";
+import { contourContainsPoint } from "../../geometry/regions.js";
+import { resolveGeometryResolution } from "../../geometry/resolution.js";
+import { assertSamplingCount } from "../../geometry/sampling-limits.js";
+import { resolveGeometryTolerance } from "../../geometry/tolerance.js";
+import { nativeConstructionMesh } from "../native/construction-mesh.js";
+import { ownScopedManifoldValue } from "../native/context.js";
+import { observeNativeMesh } from "../native/mesh-observation.js";
+import { assertNativeSolidStatus } from "../native/status.js";
+import { nativeCollarProfile } from "./join-collar-profile.js";
+const fail = (message, phase) => {
+    throw new GeometryError("INVALID_ARGUMENT", message, { operation: "join", details: { phase } });
+};
+const dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+const contours = (profile) => profile.components.flatMap((component) => [
+    component.outer.points,
+    ...component.holes.map((hole) => hole.points),
+]);
+/** One deferred connection, with native operands authoritative throughout support proofs. */
+export function createJoinOperation(environment) {
+    return (base, feature, options) => {
+        const { module, scope } = environment;
+        const own = (value) => {
+            // Register first: failed native proofs and limit checks must dispose their intermediates too.
+            ownScopedManifoldValue(scope, value);
+            const vertices = value.numVert();
+            if (value instanceof module.Manifold) {
+                const triangles = value.numTri();
+                assertMeshAllocationWithinLimits(vertices, triangles, 12 * (vertices + triangles), "join", limits);
+            }
+            else
+                assertSamplingCount(vertices, "join", limits.maxProfilePoints);
+            return value;
+        };
+        if (typeof options !== "object" || options === null || Array.isArray(options))
+            fail("Join options are required.", "options");
+        if (Object.keys(options).some((key) => !["source", "transition", "resolution", "limits"].includes(key)))
+            fail("Unknown join option.", "options");
+        const transition = options.transition;
+        if (typeof transition !== "object" ||
+            transition === null ||
+            Array.isArray(transition) ||
+            Object.keys(transition).some((key) => !["kind", "width", "height"].includes(key)))
+            fail("Transition requires width and height and accepts an optional kind.", "options");
+        const kind = transition.kind === undefined ? "smooth" : transition.kind;
+        if (kind !== "smooth" && kind !== "straight")
+            fail('Join transition kind must be "smooth" or "straight".', "options");
+        const { width, height } = transition;
+        if (!Number.isFinite(width) || !Number.isFinite(height))
+            throw new GeometryError("NON_FINITE_VALUE", "Join width and height must be finite.", {
+                operation: "join",
+            });
+        if (width < 0 || height < 0 || (width === 0) !== (height === 0))
+            fail("Join width and height must both be positive or both zero.", "options");
+        const selected = environment.withResolutionDefaults(options);
+        const { limits } = selected;
+        const policy = resolveGeometryResolution(selected.resolution, limits);
+        const originalBase = environment.nativeSolid(base), originalFeature = environment.nativeSolid(feature);
+        assertNativeSolidStatus(originalBase, "join");
+        assertNativeSolidStatus(originalFeature, "join");
+        if (originalBase.isEmpty() || originalFeature.isEmpty())
+            throw new GeometryError("DEGENERATE_GEOMETRY", "Joining requires nonempty base and feature solids.", { operation: "join" });
+        const supplied = typeof options.source === "string"
+            ? environment.anchor(feature, options.source)
+            : options.source;
+        if (typeof supplied !== "object" || supplied === null)
+            fail("Join source must name a feature anchor or supply an Anchor3.", "source");
+        const sourceAnchor = anchor3(supplied.position, supplied.direction, supplied.up);
+        // The root points out of the feature; chart Z points into its unchanged straight collar.
+        const frame = anchorFrame3(anchor3(sourceAnchor.position, [-sourceAnchor.direction[0], -sourceAnchor.direction[1], -sourceAnchor.direction[2]], sourceAnchor.up));
+        const { xAxis: x, yAxis: y, zAxis: z, origin: o } = frame;
+        const forward = [
+            x[0],
+            x[1],
+            x[2],
+            0,
+            y[0],
+            y[1],
+            y[2],
+            0,
+            z[0],
+            z[1],
+            z[2],
+            0,
+            o[0],
+            o[1],
+            o[2],
+            1,
+        ];
+        const inverse = [
+            x[0],
+            y[0],
+            z[0],
+            0,
+            x[1],
+            y[1],
+            z[1],
+            0,
+            x[2],
+            y[2],
+            z[2],
+            0,
+            -dot(x, o),
+            -dot(y, o),
+            -dot(z, o),
+            1,
+        ];
+        // Local copies serve the proofs. Fuse the original operands later to avoid a frame round trip.
+        const support = own(originalBase.transform(inverse)), neck = own(originalFeature.transform(inverse));
+        const bounds = neck.boundingBox();
+        const raw = observeNativeMesh(scope, support, limits, "join");
+        const scale = Math.max(1, ...bounds.min.map(Math.abs), ...bounds.max.map(Math.abs), width, height);
+        // Final mesh capture is Float32. Reserve conversion/closure error before the sampling budget.
+        const epsilon = Math.max(resolveGeometryTolerance(scale).linear, support.tolerance(), neck.tolerance(), scale * 2 ** -22);
+        // Contact selection uses native precision; the larger Float32 meshing allowance must not bridge a gap.
+        const datumTolerance = Math.max(support.tolerance(), neck.tolerance(), scale * Number.EPSILON * 64);
+        let allowance = epsilon * 16;
+        if (allowance >= policy.maxChordError / 2)
+            fail("Join coordinate precision cannot resolve the requested physical error budget.", "precision");
+        const meshEpsilon = epsilon / 8;
+        // Slice just inside the root cap, removing cut seams only within the reserved numeric allowance.
+        const sourceSection = own(own(neck.slice(epsilon * 2)).simplify(epsilon / 8));
+        if (sourceSection.isEmpty())
+            fail("Source datum must cut a nonempty straight feature collar.", "collar");
+        const work = new JoinWork();
+        // Native Sections supply robust regional proofs; exact facet slicing retains wall coordinates
+        // for the corresponding construction instead of moving them through integer clipping.
+        const source = nativeCollarProfile(scope, neck, epsilon * 2, limits, work);
+        const closingInset = epsilon * 8;
+        const offset = planRegionOffsets(source, [-width, closingInset], "join", limits);
+        work.use(offset.workCount);
+        const region = (loops) => own(loops.length === 0
+            ? sourceSection.subtract(sourceSection)
+            : new module.CrossSection(loops.map((loop) => loop.map((p) => [p[0], p[1]])), "NonZero"));
+        const expandedProfile = offset.profileAt(-width);
+        const footprint = region(contours(expandedProfile));
+        const triangles = [];
+        const canonicalPlanes = [];
+        const chartTolerance = resolveGeometryTolerance(scale);
+        let chartArithmeticScale = scale;
+        const maxZ = bounds.max[2];
+        for (let i = 0; i < raw.triangles.length; i += 3) {
+            work.use();
+            const points = [0, 1, 2].map((j) => {
+                const index = raw.vertexIndices[raw.triangles[i + j]] * 3;
+                return [
+                    raw.coordinates[index],
+                    raw.coordinates[index + 1],
+                    raw.coordinates[index + 2],
+                ];
+            });
+            const a = points[0], b = points[1], c = points[2];
+            const ab = [b[0] - a[0], b[1] - a[1], b[2] - a[2]], ac = [c[0] - a[0], c[1] - a[1], c[2] - a[2]];
+            const normal = [
+                ab[1] * ac[2] - ab[2] * ac[1],
+                ab[2] * ac[0] - ab[0] * ac[2],
+                ab[0] * ac[1] - ab[1] * ac[0],
+            ];
+            const normalLength = Math.hypot(...normal);
+            if (normal[2] <= normalLength * 1e-10)
+                continue;
+            let plane = [
+                -normal[0] / normal[2],
+                -normal[1] / normal[2],
+                a[2] + (normal[0] / normal[2]) * a[0] + (normal[1] / normal[2]) * a[1],
+            ];
+            let polygon = points.map((p) => [p[0], p[1]]);
+            polygon = clipJoinPolygon(polygon, [plane[0], plane[1], plane[2] + datumTolerance]);
+            polygon = clipJoinPolygon(polygon, [-plane[0], -plane[1], maxZ - plane[2]]);
+            if (polygon.length < 3 || Math.abs(joinArea(polygon)) <= meshEpsilon ** 2)
+                continue;
+            const clipped = own(region([polygon]).intersect(footprint));
+            if (clipped.isEmpty())
+                continue;
+            for (const point of points)
+                chartArithmeticScale = Math.max(chartArithmeticScale, ...point.map(Math.abs));
+            // Double arithmetic can give coplanar tessellation triangles slightly different equations.
+            // Match dimensionless unit normals and actual height predictions, never encoded face IDs.
+            const priorPlane = canonicalPlanes.find((candidate) => {
+                work.use();
+                const length = Math.hypot(candidate[0], candidate[1], 1);
+                return (Math.hypot(-candidate[0] / length - normal[0] / normalLength, -candidate[1] / length - normal[1] / normalLength, 1 / length - normal[2] / normalLength) <= chartTolerance.angular &&
+                    points.every((point) => Math.abs(joinHeight(candidate, [point[0], point[1]]) - point[2]) <=
+                        chartTolerance.linear));
+            });
+            if (priorPlane === undefined)
+                canonicalPlanes.push(plane);
+            else
+                plane = priorPlane;
+            triangles.push({ polygon, plane });
+        }
+        // Convex components need one exact clip, not arbitrary triangulation seams.
+        // Inspect the actual clipping coordinates; holes and concavity retain their full partition.
+        const convexPartition = (loops) => {
+            const outer = loops[0];
+            const convex = loops.length === 1 &&
+                outer.length >= 3 &&
+                joinArea(outer) > 0 &&
+                outer.every((point, i) => {
+                    work.use();
+                    const previous = outer[(i + outer.length - 1) % outer.length], next = outer[(i + 1) % outer.length];
+                    return ((point[0] - previous[0]) * (next[1] - point[1]) -
+                        (point[1] - previous[1]) * (next[0] - point[0]) >=
+                        0);
+                });
+            if (convex)
+                return [outer];
+            const vertices = loops.flat();
+            return module
+                .triangulate(loops.map((loop) => loop.map((p) => [p[0], p[1]])), 0, false)
+                .map((ids) => ids.map((id) => vertices[id]));
+        };
+        const footprintCells = expandedProfile.components.flatMap((component) => convexPartition(region([component.outer.points, ...component.holes.map((hole) => hole.points)]).toPolygons()));
+        const usable = (polygon) => polygon.length >= 3 && Math.abs(joinArea(polygon)) > meshEpsilon ** 2;
+        const cells = [];
+        // Remove every nearer exit over its complete projected overlap, rather than probing a few rays.
+        for (let i = 0; i < triangles.length; i++) {
+            const current = triangles[i];
+            let visible = footprintCells
+                .map((polygon) => intersectJoinPolygons(current.polygon, polygon))
+                .filter(usable);
+            for (let j = 0; j < triangles.length && visible.length > 0; j++) {
+                if (i === j)
+                    continue;
+                work.use();
+                const other = triangles[j];
+                const overlap = intersectJoinPolygons(current.polygon, other.polygon);
+                if (!usable(overlap))
+                    continue;
+                const difference = [
+                    current.plane[0] - other.plane[0],
+                    current.plane[1] - other.plane[1],
+                    current.plane[2] - other.plane[2],
+                ];
+                const equal = overlap.every((point) => Math.abs(joinHeight(difference, point)) <= chartTolerance.linear);
+                if (equal && j > i)
+                    continue;
+                const nearer = equal ? other.polygon : clipJoinPolygon(other.polygon, difference);
+                if (usable(nearer))
+                    visible = visible
+                        .flatMap((polygon) => subtractJoinPolygon(polygon, nearer, work))
+                        .filter(usable);
+            }
+            for (const polygon of visible)
+                cells.push({ polygon, plane: current.plane });
+        }
+        if (cells.length === 0)
+            fail("The entire transition footprint needs a regular outward support patch after the source datum.", "support");
+        // Bound each affine proof cell's extension by epsilon/2 in Euclidean distance.
+        // The native union must cover the complete footprint; every extended part is
+        // included in the material witness below, so a real slit cannot be waived.
+        const proofRegions = cells.map((cell) => {
+            work.use(cell.polygon.length);
+            const expanded = expandJoinPolygon(cell.polygon, epsilon / (2 * Math.SQRT2), work);
+            return region([expanded]);
+        });
+        const proofPoints = proofRegions.reduce((count, region) => count + region.numVert(), 0);
+        assertMeshAllocationWithinLimits(proofPoints * 2, proofPoints * 4, proofPoints * 96, "join", limits);
+        const proofCoverage = own(module.CrossSection.union(proofRegions));
+        if (!own(footprint.subtract(proofCoverage)).isEmpty())
+            fail("The entire transition footprint needs a regular outward support patch after the source datum.", "support");
+        let maximumSlope = 0, greatest = -Infinity;
+        for (const cell of cells) {
+            maximumSlope = Math.max(maximumSlope, Math.hypot(cell.plane[0], cell.plane[1]));
+            for (const point of cell.polygon) {
+                greatest = Math.max(greatest, joinHeight(cell.plane, point));
+            }
+        }
+        allowance *= 1 + maximumSlope;
+        if (allowance >= policy.maxChordError / 2)
+            fail("Support slope exhausts the physical extraction error budget.", "precision");
+        // Local bounds keep distant roots from broadening each other's support searches.
+        const cellIndex = createJoinPolygonIndex(cells.map((cell) => cell.polygon), work, limits);
+        for (const cell of cells)
+            for (const point of cell.polygon)
+                for (const index of cellIndex(point, meshEpsilon)) {
+                    const other = cells[index];
+                    work.use();
+                    if (cell !== other &&
+                        inJoinPolygon(point, other.polygon, meshEpsilon) &&
+                        Math.abs(joinHeight(cell.plane, point) - joinHeight(other.plane, point)) > allowance)
+                        fail("Support patch must be continuous; height jumps and branch changes are unsupported.", "support");
+                }
+        const H = greatest + height + allowance;
+        if (H > maxZ + epsilon)
+            fail("Feature needs a longer constant-section collar above the support patch.", "collar");
+        const proofDomain = own(module.Manifold.extrude(footprint, H + allowance * 3).translate([0, 0, -allowance * 2]));
+        const toNative = (mesh) => nativeConstructionMesh(scope, mesh, limits, "join");
+        const terrain = (top, bottom) => {
+            const pieces = cells.flatMap((cell, index) => {
+                const area = proofRegions[index];
+                if (area.isEmpty())
+                    return [];
+                const guard = epsilon * (2 + Math.hypot(cell.plane[0], cell.plane[1]) / 2);
+                const slab = own(module.Manifold.extrude(area, 1));
+                const piece = own(slab.warpBatch((vertices, count) => {
+                    work.use(count);
+                    for (let i = 0; i < count; i++) {
+                        const k = i * 3, value = joinHeight(cell.plane, [vertices[k], vertices[k + 1]]);
+                        vertices[k + 2] = vertices[k + 2] > 0.5 ? top(value, guard) : bottom(value, guard);
+                    }
+                }));
+                assertNativeSolidStatus(piece, "join");
+                return [piece];
+            });
+            return own(own(module.Manifold.union(pieces)).intersect(proofDomain));
+        };
+        // Follow the curved chart. A flat witness would incorrectly exclude thin curved shells.
+        const witness = terrain((value, guard) => value - guard, (value, guard) => value - guard - epsilon * 6);
+        if (!own(witness.subtract(support)).isEmpty())
+            fail("Support material is missing or too thin beneath the complete curved footprint.", "support");
+        const overhead = terrain(() => H + allowance, (value, guard) => value + guard);
+        if (!own(overhead.intersect(support)).isEmpty())
+            fail("Support reenters the connection band above the selected patch.", "support");
+        // Guard both directions over the full collar volume: matching two cross-sections is insufficient.
+        const domain = own(module.Manifold.extrude(footprint, H - epsilon * 2).translate([0, 0, epsilon * 2]));
+        const innerSection = own(sourceSection.offset(-epsilon * 2, "Miter"));
+        const outerSection = own(sourceSection.offset(epsilon * 2, "Miter"));
+        const expected = own(module.Manifold.extrude(innerSection, H - epsilon * 2).translate([0, 0, epsilon * 2]));
+        const outer = own(module.Manifold.extrude(outerSection, H - epsilon * 2).translate([0, 0, epsilon * 2]));
+        const actual = own(neck.intersect(domain));
+        if (!own(expected.subtract(actual)).isEmpty() || !own(actual.subtract(outer)).isEmpty())
+            fail("Feature must have a straight constant-section collar throughout the complete connection band.", "collar");
+        if (width === 0)
+            return environment.wrapSolid(own(originalBase.add(originalFeature)));
+        const originalLoops = contours(source), outsideLoops = contours(expandedProfile);
+        // Close inside the real feature wall, proving this private numerical overlap adds no exposed shape.
+        const insideProfile = offset.profileAt(closingInset);
+        const insideLoops = contours(insideProfile);
+        const closingSection = region(insideLoops);
+        if (closingSection.isEmpty() || closingSection.numContour() !== sourceSection.numContour())
+            fail("Source boundaries cannot resolve the private closing allowance.", "precision");
+        const closingCore = own(module.Manifold.extrude(closingSection, H));
+        if (!own(own(closingCore.subtract(neck)).subtract(support)).isEmpty())
+            fail("The private closing boundary cannot be contained in the supplied solids.", "precision");
+        const strips = [];
+        for (let loop = 0; loop < originalLoops.length; loop++) {
+            const original = originalLoops[loop], expanded = outsideLoops[loop];
+            for (let i = 0; i < original.length; i++) {
+                const next = (i + 1) % original.length, a = original[i], b = original[next];
+                const length = Math.hypot(b[0] - a[0], b[1] - a[1]);
+                if (length <= epsilon)
+                    fail("Source edge cannot resolve the connection precision.", "precision");
+                strips.push({
+                    polygon: [a, expanded[i], expanded[next], b],
+                    start: a,
+                    normal: [(b[1] - a[1]) / length, -(b[0] - a[0]) / length],
+                });
+            }
+        }
+        // A straight profile is planar on each support facet; only the cubic needs transverse rows.
+        const effectiveRise = height + epsilon * 2;
+        const curvature = 6 * Math.hypot(width * offset.magnification * (1 + maximumSlope), effectiveRise);
+        const tolerance = (policy.maxChordError - allowance) / 4;
+        const divisions = kind === "straight"
+            ? 1
+            : Math.max(2, Math.ceil(Math.sqrt(curvature / (8 * tolerance))), policy.maxSegmentLength === undefined
+                ? 0
+                : Math.ceil((3 *
+                    Math.hypot(width * offset.magnification * (1 + maximumSlope), effectiveRise)) /
+                    policy.maxSegmentLength));
+        if (divisions > limits.maxPathPoints)
+            throw new GeometryError("COMPLEXITY_LIMIT", "Join profile exceeds its station ceiling.", {
+                operation: "join",
+            });
+        const polygons = [];
+        const bottomGroups = [];
+        const planeGroups = new Map();
+        const supportPlanes = [];
+        const cellGroups = cells.map((cell) => {
+            const key = cell.plane.join(",");
+            let group = planeGroups.get(key);
+            if (group === undefined) {
+                group = planeGroups.size;
+                planeGroups.set(key, group);
+                supportPlanes.push(cell.plane);
+            }
+            return group;
+        });
+        // Split at every chart crossing so the generated surface retains actual support facets and creases.
+        for (const strip of strips)
+            for (let row = 0; row < divisions; row++) {
+                const exponent = kind === "straight" ? 1 : 3;
+                const ra = width * (1 - row / divisions) ** exponent, rb = width * (1 - (row + 1) / divisions) ** exponent;
+                const projection = [
+                    strip.normal[0],
+                    strip.normal[1],
+                    -strip.normal[0] * strip.start[0] - strip.normal[1] * strip.start[1],
+                ];
+                const band = clipJoinPolygon(clipJoinPolygon(strip.polygon, [projection[0], projection[1], projection[2] - rb]), [-projection[0], -projection[1], ra - projection[2]]);
+                if (band.length < 3)
+                    continue;
+                for (const [cellIndex, cell] of cells.entries()) {
+                    work.use();
+                    const piece = intersectJoinPolygons(band, cell.polygon);
+                    if (piece.length >= 3 && Math.abs(joinArea(piece)) > meshEpsilon ** 2) {
+                        polygons.push(piece);
+                        bottomGroups.push(cellGroups[cellIndex]);
+                    }
+                }
+            }
+        // Use the same corresponding boundaries and clipping arithmetic as the outside strips.
+        // Independent native offsets/intersections would round these shared mesh seams differently.
+        for (let loop = 0; loop < originalLoops.length; loop++) {
+            const original = originalLoops[loop], inside = insideLoops[loop];
+            for (let i = 0; i < original.length; i++) {
+                const next = (i + 1) % original.length;
+                const ring = [original[i], original[next], inside[next], inside[i]];
+                for (const [cellIndex, cell] of cells.entries()) {
+                    work.use();
+                    const piece = intersectJoinPolygons(ring, cell.polygon);
+                    if (piece.length >= 3 && Math.abs(joinArea(piece)) > meshEpsilon ** 2) {
+                        polygons.push(piece);
+                        bottomGroups.push(cellGroups[cellIndex]);
+                    }
+                }
+            }
+        }
+        // Fill the already-proven feature interior down to the same support witness. An annular-only
+        // collar can enclose a numerical contact sheet when two independently transformed caps meet.
+        const coreCells = insideProfile.components.flatMap((component) => convexPartition([component.outer.points, ...component.holes.map((hole) => hole.points)]));
+        for (const coreCell of coreCells) {
+            for (const [cellIndex, cell] of cells.entries()) {
+                work.use();
+                const piece = intersectJoinPolygons(coreCell, cell.polygon);
+                if (piece.length >= 3 && Math.abs(joinArea(piece)) > meshEpsilon ** 2) {
+                    polygons.push(piece);
+                    bottomGroups.push(cellGroups[cellIndex]);
+                }
+            }
+        }
+        const stripIndex = createJoinPolygonIndex(strips.map((strip) => strip.polygon), work, limits);
+        const rise = (p) => {
+            for (const index of stripIndex(p, epsilon)) {
+                const strip = strips[index];
+                work.use();
+                if (inJoinPolygon(p, strip.polygon, epsilon)) {
+                    const r = Math.max(0, Math.min(width, (p[0] - strip.start[0]) * strip.normal[0] + (p[1] - strip.start[1]) * strip.normal[1]));
+                    return height * (kind === "straight" ? 1 - r / width : (1 - Math.cbrt(r / width)) ** 3);
+                }
+            }
+            if (source.components.some((component) => contourContainsPoint(component.outer.points, p) &&
+                !component.holes.some((hole) => contourContainsPoint(hole.points, p))))
+                return height;
+            return fail("Transition cell escaped its source offset strip.", "transition");
+        };
+        const layerOptions = {
+            bottomGroups,
+            supportPlanes,
+            triangulate: (loops) => module.triangulate(loops.map((loop) => loop.map((p) => [p[0], p[1]])), 0, false),
+        };
+        const layer = prepareJoinLayer(polygons, meshEpsilon, limits, work, layerOptions);
+        // Prepared nodes retain their incident support planes, avoiding a second spatial guess at creases.
+        const chartHeight = (value) => value ?? fail("Join layer has no supporting chart plane.", "support");
+        // A guarded witness can miss a void immediately under the selected face. Prove the complete
+        // numerical foot before adding material, retaining its exact boundary and affine support faces.
+        const footMesh = layer.supportBand(epsilon * 8);
+        validateSolidMesh(footMesh);
+        const footNative = toNative(footMesh);
+        const missingFoot = own(own(footNative.subtract(support)).subtract(neck));
+        if (!missingFoot.isEmpty()) {
+            // Native subtraction can retain zero-thickness contact sheets. Bound each component at
+            // Double roundoff, never by the larger construction allowance or another component's area.
+            const missingComponents = missingFoot.decompose().map(own);
+            if (missingComponents.length === 0)
+                fail("Numerical connection containment could not be established.", "support");
+            for (const missing of missingComponents) {
+                work.use();
+                const bounds = missing.boundingBox();
+                if (![...bounds.min, ...bounds.max].every(Number.isFinite))
+                    fail("Numerical connection containment could not be established.", "support");
+                const arithmetic = Number.EPSILON *
+                    64 *
+                    Math.max(chartArithmeticScale, ...bounds.min.map(Math.abs), ...bounds.max.map(Math.abs));
+                const roundoff = Math.min(arithmetic, support.tolerance(), neck.tolerance());
+                // Measure around the component, avoiding cancellation against global chart coordinates.
+                const center = bounds.min.map((value, axis) => value / 2 + bounds.max[axis] / 2);
+                const centered = own(missing.warpBatch((positions, count) => {
+                    work.use(count);
+                    for (let i = 0; i < positions.length; i++)
+                        positions[i] = positions[i] - center[i % 3];
+                }));
+                const volume = Math.abs(centered.volume());
+                const area = missing.surfaceArea();
+                if (![roundoff, volume, area].every(Number.isFinite) || roundoff < 0 || area < 0)
+                    fail("Numerical connection containment could not be established.", "support");
+                if (volume > area * roundoff)
+                    fail("Support material must fill the complete numerical connection foot.", "support");
+            }
+        }
+        const collarMesh = layer.build(
+        // Begin inside the proven support witness, fading the extraction allowance to zero at the wall.
+        // This avoids nearly coincident foot slivers when the native Boolean meets its Float32 chart.
+        (p, value) => chartHeight(value) + rise(p) * (effectiveRise / height) - epsilon * 2, (_p, value) => chartHeight(value) - epsilon * 8, policy.maxSegmentLength);
+        validateSolidMesh(collarMesh);
+        const collar = toNative(collarMesh);
+        const worldCollar = own(collar.transform(forward));
+        // Construction adds a collar; neither supplied operand is trimmed, moved, or reconstructed.
+        const combined = own(module.Manifold.union([originalBase, originalFeature, worldCollar]));
+        assertNativeSolidStatus(combined, "join");
+        return environment.wrapSolid(combined);
+    };
+}

package/dist/engine/recipe-realization.js

@@ -48,7 +48,7 @@ export class RecipeRealization {
     realizedShape(shape) {
         return this.realized.get(shape);
     }
-    /** Prefers intermediate operands when not every computed output fits the retention budget. */
+    /** Prefers intermediate operands when not every memo output fits the retention budget. */
     retentionCandidates(values) {
         const shapes = new Set(recipeShapes(values));
         return [...shapes].sort((left, right) => Number(this.operands.has(right)) - Number(this.operands.has(left)));