@metamesh/modeling 0.18.0 → 0.20.0

package/dist/engine/operations/cutters.js

@@ -0,0 +1,112 @@
+import { GeometryError } from "../../geometry/errors.js";
+import { assertMeshAllocationWithinLimits, resolveModelingLimits, } from "../../geometry/limits.js";
+import { chamferCornerCutterPoints, cutterExcess, edgeCutterContour, } from "../../geometry/primitives/cutters.js";
+import { edgeTreatmentSetbacks } from "../../geometry/primitives/edges.js";
+import { assertPositivePrimitive, assertPrimitiveOptions, } from "../../geometry/primitives/resolvers.js";
+import { resolveSphericalPrimitiveSegments } from "../../geometry/primitives/sampling.js";
+import { assertSamplingCount } from "../../geometry/sampling/limits.js";
+import { anchor3 } from "../../geometry/transforms/anchors.js";
+/** Host-bound explicit cutters; construction, placement and subtraction retain their existing owners. */
+export function createCutterOperations(environment, operations, transforms) {
+    const empty = () => environment.ownSolid(environment.module.Manifold.union([]));
+    const origin = anchor3({ position: [0, 0, 0], direction: [0, 0, 1] });
+    const place = (options, solid, anchors) => transforms.placedSolid(options, () => environment.nativeSolid(solid), () => anchors);
+    const nonnegative = (value, name, operation) => {
+        if (!Number.isFinite(value) || value < 0)
+            throw new GeometryError("INVALID_ARGUMENT", `${name} must be finite and nonnegative.`, {
+                operation,
+            });
+        return value;
+    };
+    const roundSampling = (treatment, selected, operation) => {
+        const options = {
+            radius: treatment.radius,
+            ...(treatment.segments === undefined ? {} : { segments: treatment.segments }),
+            resolution: { ...selected.resolution, ...treatment.resolution },
+            limits: resolveModelingLimits(treatment.limits, selected.limits),
+        };
+        return {
+            ...options,
+            segments: resolveSphericalPrimitiveSegments(options.radius, options, operation),
+        };
+    };
+    return {
+        edgeCutter: (options) => {
+            environment.assertActive();
+            assertPrimitiveOptions(options, "edgeCutter");
+            assertPositivePrimitive(options.length, "length", "edgeCutter");
+            if (options.overrun !== undefined)
+                assertPrimitiveOptions(options.overrun, "edgeCutter");
+            const bottom = nonnegative(options.overrun?.bottom ?? 0, "overrun.bottom", "edgeCutter"), top = nonnegative(options.overrun?.top ?? 0, "overrun.top", "edgeCutter");
+            const height = options.length + bottom + top;
+            assertPositivePrimitive(height, "extended length", "edgeCutter");
+            const selected = environment.withResolutionDefaults(options);
+            const treatment = options.treatment;
+            assertPrimitiveOptions(treatment, "edgeCutter");
+            const excess = cutterExcess(options.excess ?? 0.05, "edgeCutter");
+            let solid;
+            if ((options.angle ?? 90) === 90 && treatment.kind === "round") {
+                const [radius] = edgeTreatmentSetbacks(treatment, "edgeCutter");
+                if (radius === 0)
+                    solid = empty();
+                else {
+                    const sampling = roundSampling(treatment, selected, "edgeCutter");
+                    assertSamplingCount(sampling.segments / 4 + (excess === 0 ? 2 : 4), "edgeCutter", sampling.limits.maxProfilePoints);
+                    // Native cylinder and sphere equators share coordinates and angular refinement.
+                    // Passing the round through a clipped Section would introduce near-coincident seams.
+                    const cube = operations.translate(operations.box({
+                        size: [radius + excess, radius + excess, height],
+                        center: false,
+                        limits: sampling.limits,
+                    }), [-excess, -excess, -bottom]);
+                    const cylinder = operations.translate(operations.cylinder({ ...sampling, height, center: false }), [radius, radius, -bottom]);
+                    solid = operations.subtract(cube, [cylinder]);
+                }
+            }
+            else {
+                const contour = edgeCutterContour(treatment, options.angle ?? 90, excess, selected.resolution, selected.limits);
+                solid =
+                    contour.length === 0
+                        ? empty()
+                        : operations.translate(operations.extrude(operations.polygon(contour), {
+                            height,
+                            resolution: selected.resolution,
+                            limits: selected.limits,
+                        }), [0, 0, -bottom]);
+            }
+            return place(options, solid, {
+                origin,
+                bottom: anchor3({ position: [0, 0, 0], direction: [0, 0, -1] }),
+                top: anchor3({ position: [0, 0, options.length], direction: [0, 0, 1] }),
+            });
+        },
+        cornerCutter: (options) => {
+            environment.assertActive();
+            assertPrimitiveOptions(options, "cornerCutter");
+            assertPrimitiveOptions(options.treatment, "cornerCutter");
+            const treatment = options.treatment;
+            if ((treatment.kind !== "round" && treatment.kind !== "chamfer") ||
+                (treatment.kind === "chamfer" && typeof treatment.distance !== "number"))
+                throw new GeometryError("INVALID_ARGUMENT", "Corner cutters require a round treatment or one equal chamfer distance.", { operation: "cornerCutter" });
+            const selected = environment.withResolutionDefaults(options);
+            const excess = cutterExcess(options.excess ?? 0.05, "cornerCutter");
+            const [distance] = edgeTreatmentSetbacks(treatment, "cornerCutter");
+            let solid;
+            if (distance === 0)
+                solid = empty();
+            else if (treatment.kind === "chamfer") {
+                const points = chamferCornerCutterPoints(distance, excess);
+                assertMeshAllocationWithinLimits(10, 16, 26 * 12, "cornerCutter", selected.limits);
+                solid = operations.hull({ points });
+            }
+            else {
+                const radius = treatment.radius;
+                const sampling = roundSampling(treatment, selected, "cornerCutter");
+                const cube = operations.translate(operations.box({ size: radius + excess, center: false, limits: sampling.limits }), [-excess, -excess, -excess]);
+                const sphere = operations.translate(operations.sphere(sampling), [radius, radius, radius]);
+                solid = operations.subtract(cube, [sphere]);
+            }
+            return place(options, solid, { origin });
+        },
+    };
+}

package/dist/engine/operations/environment.js

@@ -1,5 +1,5 @@
-import { resolveModelingLimits } from "../../geometry/model-limits.js";
-import { resolveCircularPrimitiveSegments } from "../../geometry/primitive-resolution.js";
+import { resolveModelingLimits } from "../../geometry/limits.js";
+import { resolveCircularPrimitiveSegments } from "../../geometry/primitives/sampling.js";
 /** Applies explicit resolution inheritance once for this bound context. */
 export function createOperationEnvironment(owner, resolution) {
     const withResolutionDefaults = (value) => {

package/dist/engine/operations/extrusion-finishing.js

@@ -1,31 +1,23 @@
-import { convexContourOffsets } from "../../geometry/convex-offset.js";
-import { edgeTreatmentPointCount, edgeTreatmentSetbacks, sampleEdgeTreatment, } from "../../geometry/edge-finishing.js";
 import { GeometryError } from "../../geometry/errors.js";
-import { resolveExtrusionControls } from "../../geometry/extrusion.js";
-import { assertMeshAllocationWithinLimits, } from "../../geometry/model-limits.js";
-import { assertSamplingCount } from "../../geometry/sampling-limits.js";
+import { resolveExtrusionControls, } from "../../geometry/extrusion/controls.js";
+import { mergeExtrusionStations } from "../../geometry/extrusion/stations.js";
+import { twistedChamferStations } from "../../geometry/extrusion/twisted-chamfer.js";
+import { assertMeshAllocationWithinLimits } from "../../geometry/limits.js";
+import { edgeTreatmentPointCount, edgeTreatmentSetbacks, sampleEdgeTreatment, } from "../../geometry/primitives/edges.js";
+import { planRegionOffsets } from "../../geometry/regions/offset.js";
+import { assertSamplingCount } from "../../geometry/sampling/limits.js";
+import { resolveGeometryResolution, } from "../../geometry/sampling/resolution.js";
 import { buildProfileLoftMesh } from "./primitives/profile-mesh.js";
 const fail = (message) => {
     throw new GeometryError("INVALID_ARGUMENT", message, { operation: "extrude" });
 };
-/** Finishes inward convex extrusion rims with exact parallel-edge offsets and retained correspondence. */
+/** @internal Builds end-treated stations and lofts their corresponding material boundaries. */
 export function buildFinishedExtrusion(module, profile, options) {
     const controls = resolveExtrusionControls(options.height, options, "extrude");
-    if (controls.twist !== 0 ||
-        controls.scales.some((scale) => scale !== 1) ||
-        options.divisions !== undefined)
-        fail("End treatments require a straight extrusion without twist, top scaling or divisions.");
+    if (controls.scales.some((scale) => scale !== 1))
+        fail("End treatments require unit scale.");
     if (typeof options.ends !== "object" || options.ends === null || Array.isArray(options.ends))
         fail("ends must be an object.");
-    if (profile.components.length !== 1 || profile.components[0].holes.length !== 0)
-        fail("End treatments require one convex contour without holes; use explicit loft profiles for other topology.");
-    const contour = profile.components[0].outer, points = contour.points;
-    const { magnification, offset } = convexContourOffsets(points, "extrude");
-    const sampling = {
-        resolution: options.resolution,
-        limits: options.limits,
-        magnification,
-    };
     const bottom = options.ends.bottom, top = options.ends.top;
     const bottomSize = bottom === undefined
         ? [0, 0]
@@ -33,23 +25,58 @@ export function buildFinishedExtrusion(module, profile, options) {
     const topSize = top === undefined ? [0, 0] : edgeTreatmentSetbacks(top, "extrude", Math.PI / 2, options.limits);
     if (bottomSize[1] + topSize[1] >= options.height)
         fail("End treatments must leave positive length between their side setbacks.");
-    const rowCount = (bottom === undefined ? 1 : edgeTreatmentPointCount(bottom, "extrude", sampling)) +
+    if (controls.twist !== 0) {
+        if ((bottomSize[0] > 0 && bottom?.kind !== "chamfer") ||
+            (topSize[0] > 0 && top?.kind !== "chamfer"))
+            fail("Twisted extrusion ends support chamfers; round, smooth and profile treatments require zero twist.");
+        return buildProfileLoftMesh(module, twistedChamferStations(profile, options, options.limits, bottomSize, topSize), options.limits);
+    }
+    const plan = planRegionOffsets(profile, [0, Math.max(bottomSize[0], topSize[0])], "extrude", options.limits);
+    const sampling = {
+        resolution: options.resolution,
+        limits: options.limits,
+        magnification: plan.magnification,
+    };
+    const policy = resolveGeometryResolution(options.resolution, options.limits);
+    const slices = options.slices ??
+        (policy.maxSegmentLength === undefined
+            ? 1
+            : Math.max(1, Math.ceil(options.height / policy.maxSegmentLength)));
+    const treatmentCount = (bottom === undefined ? 1 : edgeTreatmentPointCount(bottom, "extrude", sampling)) +
         (top === undefined ? 1 : edgeTreatmentPointCount(top, "extrude", sampling));
-    assertSamplingCount(rowCount, "extrude", options.limits.maxPathPoints);
-    const vertexCount = rowCount * points.length, triangleCount = 2 * vertexCount - 4;
-    assertMeshAllocationWithinLimits(vertexCount, triangleCount, 12 * (vertexCount + triangleCount), "extrude", options.limits);
+    let pointCount = 0, contourCount = 0;
+    for (const component of profile.components) {
+        for (const contour of [component.outer, ...component.holes]) {
+            pointCount += contour.points.length;
+            contourCount++;
+        }
+    }
+    const checkRows = (rowCount) => {
+        assertSamplingCount(rowCount, "extrude", options.limits.maxPathPoints);
+        const vertexCount = rowCount * pointCount, triangleCount = 2 * vertexCount + 4 * contourCount;
+        assertMeshAllocationWithinLimits(vertexCount, triangleCount, 12 * (vertexCount + triangleCount), "extrude", options.limits);
+    };
+    // Preflight the known minimum before sampling; check the exact merged count below.
+    checkRows(Math.max(slices + 1, treatmentCount));
     const bottomPoints = bottom === undefined ? [[0, 0]] : sampleEdgeTreatment(bottom, "extrude", sampling);
     const topPoints = top === undefined ? [[0, 0]] : sampleEdgeTreatment(top, "extrude", sampling);
-    const rows = [
+    const treatmentRows = [
         ...bottomPoints.map(([inset, depth]) => ({ inset, z: depth })),
         ...[...topPoints].reverse().map(([inset, depth]) => ({ inset, z: options.height - depth })),
     ];
-    offset(Math.max(bottomSize[0], topSize[0])); // fit fails before allocating the full station family
-    const stations = rows.map(({ inset, z }) => ({
+    // Interpolate only added grid heights; required knots retain same-height profile steps.
+    let interval = 0;
+    const rows = mergeExtrusionStations(options.height, slices, treatmentRows, (z) => {
+        while (interval < treatmentRows.length - 2 && z > treatmentRows[interval + 1].z)
+            interval++;
+        const a = treatmentRows[interval], b = treatmentRows[interval + 1];
+        const inset = a.inset + ((b.inset - a.inset) * (z - a.z)) / (b.z - a.z);
+        return { z, inset };
+    }, options.limits);
+    checkRows(rows.length);
+    const stations = rows.map(({ z, inset }) => ({
         z: controls.center ? z - options.height / 2 : z,
-        profile: {
-            components: [{ ...profile.components[0], outer: { ...contour, points: offset(inset) } }],
-        },
+        profile: plan.profileAt(inset),
     }));
     return buildProfileLoftMesh(module, stations, options.limits);
 }

package/dist/engine/operations/hole-cutter.js

@@ -1,7 +1,12 @@
-import { convexContourOffsets } from "../../geometry/convex-offset.js";
 import { GeometryError } from "../../geometry/errors.js";
-import { assertPrimitiveOptions } from "../../geometry/primitive-resolvers.js";
-/** Composes cutters inside the evaluating host, retaining deferred Section and sampling ownership. */
+import { assertMeshAllocationWithinLimits } from "../../geometry/limits.js";
+import { pointLoftProfile } from "../../geometry/loft/geometry.js";
+import { edgeTreatmentPointCount, edgeTreatmentSetbacks, sampleEdgeTreatment, } from "../../geometry/primitives/edges.js";
+import { assertPrimitiveOptions } from "../../geometry/primitives/resolvers.js";
+import { circleContour } from "../../geometry/profiles/primitives/circle.js";
+import { convexContourOffsets } from "../../geometry/regions/convex-offset.js";
+import { assertSamplingCount } from "../../geometry/sampling/limits.js";
+/** Composes one corresponding loft, retaining deferred Section and host sampling ownership. */
 export function createHoleCutterOperation(environment, operations) {
     return (options) => {
         environment.assertActive();
@@ -11,137 +16,143 @@ export function createHoleCutterOperation(environment, operations) {
         };
         const positive = (value, name) => {
             if (!Number.isFinite(value) || value <= 0)
-                fail(`${name} must be finite and positive.`);
+                fail(name + " must be finite and positive.");
             return value;
         };
         const nonnegative = (value, name) => {
             if (!Number.isFinite(value) || value < 0)
-                fail(`${name} must be finite and nonnegative.`);
+                fail(name + " must be finite and nonnegative.");
             return value;
         };
         const height = positive(options.height, "height");
         const circular = options.diameter !== undefined;
         if (circular === (options.profile !== undefined))
             fail("Specify exactly one diameter or Section profile.");
-        if (!circular &&
-            (options.recess !== undefined ||
-                options.segments !== undefined ||
-                options.sizing !== undefined))
-            fail("Circular recess, segments and sizing options require a diameter.");
-        if (options.recess !== undefined && options.entryChamfer !== undefined)
-            fail("A recess and entryChamfer are mutually exclusive.");
-        const face = options.face ?? "top";
-        if (face !== "top" && face !== "bottom")
-            fail("face must be top or bottom.");
+        if (!circular && (options.segments !== undefined || options.sizing !== undefined))
+            fail("Circular segments and sizing options require a diameter.");
+        if (options.sizing !== undefined && options.sizing !== "vertex" && options.sizing !== "face")
+            fail("sizing must be vertex or face.");
         if (options.overrun !== undefined)
             assertPrimitiveOptions(options.overrun, "holeCutter");
+        if (options.openings !== undefined)
+            assertPrimitiveOptions(options.openings, "holeCutter");
         const bottom = nonnegative(options.overrun?.bottom ?? 0, "overrun.bottom");
         const top = nonnegative(options.overrun?.top ?? 0, "overrun.top");
         const length = positive(height + bottom + top, "extended height");
-        const chamfer = nonnegative(options.entryChamfer ?? 0, "entryChamfer");
-        if (chamfer >= height)
-            fail("entryChamfer must be smaller than height.");
         const selected = environment.withResolutionDefaults(options);
         const sampling = { resolution: selected.resolution, limits: selected.limits };
-        if (circular)
-            positive(options.diameter, "diameter");
-        if (options.recess !== undefined) {
-            const recess = options.recess;
-            assertPrimitiveOptions(recess, "holeCutter");
-            positive(recess.diameter, "recess.diameter");
-            if (recess.diameter <= options.diameter)
-                fail("The recess diameter must exceed the bore diameter.");
-            let depth;
-            if (recess.kind === "counterbore")
-                depth = positive(recess.depth, "recess.depth");
-            else if (recess.kind === "countersink") {
-                if (!Number.isFinite(recess.includedAngle) ||
-                    recess.includedAngle <= 0 ||
-                    recess.includedAngle >= 180)
-                    fail("Countersink includedAngle must be between zero and 180 degrees.");
-                depth = positive((recess.diameter - options.diameter) /
-                    (2 * Math.tan((recess.includedAngle * Math.PI) / 360)), "recess depth");
+        const radius = circular ? positive(options.diameter, "diameter") / 2 : 0;
+        const plan = (opening) => {
+            if (opening === undefined)
+                return { width: 0, depth: 0 };
+            assertPrimitiveOptions(opening, "holeCutter");
+            if (opening.kind === "counterbore" || opening.kind === "countersink") {
+                if (!circular)
+                    fail("Screw seats require a circular diameter.");
+                positive(opening.diameter, "opening.diameter");
+                if (opening.diameter <= radius * 2)
+                    fail("The opening seat diameter must exceed the bore diameter.");
+                const width = opening.diameter / 2 - radius;
+                let depth;
+                if (opening.kind === "counterbore")
+                    depth = positive(opening.depth, "opening.depth");
+                else {
+                    if (!Number.isFinite(opening.includedAngle) ||
+                        opening.includedAngle <= 0 ||
+                        opening.includedAngle >= 180)
+                        fail("Countersink includedAngle must be between zero and 180 degrees.");
+                    depth = positive(width / Math.tan((opening.includedAngle * Math.PI) / 360), "opening depth");
+                }
+                return { width, depth, recess: opening };
             }
-            else
-                return fail("Unsupported recess kind.");
-            if (depth > height)
-                fail("The recess must fit within height.");
-            const segments = environment.resolveCircularSegments(recess.diameter / 2, options);
-            const common = { ...sampling, segments, sizing: options.sizing ?? "vertex", center: false };
-            const bore = operations.translate(operations.cylinder({ ...common, diameter: options.diameter, height: length }), [0, 0, -bottom]);
-            const seat = operations.translate(operations.cylinder({
-                ...common,
-                diameter: recess.kind === "counterbore"
-                    ? recess.diameter
-                    : face === "top"
-                        ? [options.diameter, recess.diameter]
-                        : [recess.diameter, options.diameter],
-                height: depth,
-            }), [0, 0, face === "top" ? height - depth : 0]);
-            const excess = face === "top" ? top : bottom;
-            return operations.union([
-                bore,
-                seat,
-                ...(excess === 0
-                    ? []
-                    : [
-                        operations.translate(operations.cylinder({
-                            ...common,
-                            diameter: recess.diameter,
-                            height: excess,
-                        }), [0, 0, face === "top" ? height : -bottom]),
-                    ]),
-            ]);
-        }
-        if (circular) {
-            const openingOverrun = face === "top" ? top : bottom;
-            const segments = environment.resolveCircularSegments(options.diameter / 2 + chamfer + (chamfer === 0 ? 0 : openingOverrun), options);
-            const common = { ...sampling, segments, sizing: options.sizing ?? "vertex", center: false };
-            const bore = operations.translate(operations.cylinder({
-                ...common,
-                diameter: options.diameter,
-                height: length,
-            }), [0, 0, -bottom]);
-            if (chamfer === 0)
-                return bore;
-            // Circular entries retain nominal radial dimensions. Section entries below instead
-            // offset their supplied polygon edges; their faceted envelope remains authoritative.
-            const mouth = options.diameter + 2 * (chamfer + openingOverrun);
-            const entry = operations.translate(operations.cylinder({
-                ...common,
-                diameter: face === "top" ? [options.diameter, mouth] : [mouth, options.diameter],
-                height: chamfer + openingOverrun,
-            }), [0, 0, face === "top" ? height - chamfer : -bottom]);
-            return operations.union([bore, entry]);
+            const [width, depth] = edgeTreatmentSetbacks(opening, "holeCutter", Math.PI / 2, selected.limits);
+            return { width, depth, treatment: opening };
+        };
+        const lower = plan(options.openings?.bottom), upper = plan(options.openings?.top);
+        if (lower.depth + upper.depth >= height)
+            fail("Opening depths must leave a positive untreated bore interval.");
+        const maximumRadius = radius + Math.max(lower.width, upper.width);
+        const segments = circular
+            ? environment.resolveCircularSegments(maximumRadius, options)
+            : undefined;
+        if (lower.depth === 0 && upper.depth === 0) {
+            // Shared validation still applies before taking the disabled-treatment fast path.
+            for (const opening of [lower, upper])
+                if (opening.treatment)
+                    edgeTreatmentPointCount(opening.treatment, "holeCutter", sampling);
+            return operations.translate(circular
+                ? operations.cylinder({
+                    ...sampling,
+                    diameter: options.diameter,
+                    height: length,
+                    segments: segments,
+                    sizing: options.sizing ?? "vertex",
+                    center: false,
+                })
+                : operations.extrude(options.profile, { ...sampling, height: length }), [0, 0, -bottom]);
         }
-        const profile = options.profile;
-        if (chamfer === 0)
-            return operations.translate(operations.extrude(profile, { ...sampling, height: length }), [
-                0,
-                0,
-                -bottom,
-            ]);
-        const source = environment.sectionProfileFor(profile);
-        if (source.components.length !== 1 || source.components[0].holes.length !== 0)
-            fail("Entry chamfers require one strictly convex contour without holes.");
-        const component = source.components[0];
-        const offset = convexContourOffsets(component.outer.points, "holeCutter").offset;
-        const rows = face === "top"
-            ? [
-                { z: -bottom, inset: 0 },
-                { z: height - chamfer, inset: 0 },
-                { z: height + top, inset: -chamfer - top },
-            ]
-            : [
-                { z: -bottom, inset: -chamfer - bottom },
-                { z: chamfer, inset: 0 },
-                { z: height + top, inset: 0 },
-            ];
-        const stations = rows.map(({ z, inset }) => ({
+        const source = circular ? undefined : environment.sectionProfileFor(options.profile);
+        if (source && (source.components.length !== 1 || source.components[0].holes.length !== 0))
+            fail("Opening treatments require one strictly convex contour without holes.");
+        const component = source?.components[0];
+        const offsets = component
+            ? convexContourOffsets(component.outer.points, "holeCutter")
+            : undefined;
+        const magnification = offsets?.magnification ?? (options.sizing === "face" ? 1 / Math.cos(Math.PI / segments) : 1);
+        const treatmentSampling = { ...sampling, magnification };
+        const count = (opening) => opening.recess
+            ? opening.recess.kind === "counterbore"
+                ? 3
+                : 2
+            : opening.treatment
+                ? edgeTreatmentPointCount(opening.treatment, "holeCutter", treatmentSampling)
+                : 1;
+        const rowCount = count(lower) + count(upper) + (bottom > 0 ? 1 : 0) + (top > 0 ? 1 : 0);
+        const pointCount = segments ?? component.outer.points.length;
+        assertSamplingCount(rowCount, "holeCutter", selected.limits.maxPathPoints);
+        const vertices = rowCount * pointCount, triangles = 2 * pointCount * (rowCount - 1) + 2 * (pointCount - 2);
+        assertMeshAllocationWithinLimits(vertices, triangles, 12 * (vertices + triangles), "holeCutter", selected.limits);
+        const points = (opening) => {
+            if (opening.recess)
+                return opening.recess.kind === "counterbore"
+                    ? [
+                        [opening.width, 0],
+                        [opening.width, opening.depth],
+                        [0, opening.depth],
+                    ]
+                    : [
+                        [opening.width, 0],
+                        [0, opening.depth],
+                    ];
+            return opening.treatment
+                ? sampleEdgeTreatment(opening.treatment, "holeCutter", treatmentSampling)
+                : [[0, 0]];
+        };
+        const rows = [
+            ...(bottom > 0 ? [{ z: -bottom, expansion: lower.width }] : []),
+            ...points(lower).map(([expansion, z]) => ({ z, expansion })),
+            ...[...points(upper)]
+                .reverse()
+                .map(([expansion, depth]) => ({ z: height - depth, expansion })),
+            ...(top > 0 ? [{ z: height + top, expansion: upper.width }] : []),
+        ];
+        const contour = (expansion) => circular
+            ? circleContour({
+                ...sampling,
+                radius: radius + expansion,
+                segments: segments,
+                sizing: options.sizing ?? "vertex",
+            })
+            : offsets.offset(-expansion);
+        const stations = rows.map(({ z, expansion }) => ({
             z,
-            profile: {
-                components: [{ ...component, outer: { ...component.outer, points: offset(inset) } }],
-            },
+            profile: component
+                ? {
+                    components: [
+                        { ...component, outer: { ...component.outer, points: contour(expansion) } },
+                    ],
+                }
+                : pointLoftProfile(contour(expansion)),
         }));
         return operations.loft(stations, sampling);
     };

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

@@ -0,0 +1,120 @@
+import { GeometryError } from "../../geometry/errors.js";
+import { assertMeshAllocationWithinLimits } from "../../geometry/limits.js";
+import { assertSamplingCount } from "../../geometry/sampling/limits.js";
+import { observeNativeMesh } from "../native/mesh-observation.js";
+import { regionFromContours } 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 contours = [];
+    const visited = new Set();
+    for (const start of next.keys()) {
+        if (visited.has(start))
+            continue;
+        const contour = [];
+        let id = start;
+        do {
+            work.use();
+            if (visited.has(id))
+                fail();
+            visited.add(id);
+            contour.push(points.get(id));
+            id = next.get(id) ?? fail();
+        } while (id !== start);
+        // Remove tessellation diagonals along the same physical wall within Float64 comparison tolerance.
+        let scale = 1;
+        for (const [x, y] of contour) {
+            work.use();
+            scale = Math.max(scale, Math.abs(x), Math.abs(y));
+        }
+        const tolerance = scale * Number.EPSILON * 64;
+        let changed = true;
+        while (changed && contour.length > 3) {
+            changed = false;
+            for (let index = 0; index < contour.length; index++) {
+                work.use();
+                const a = contour[(index + contour.length - 1) % contour.length], b = contour[index], c = contour[(index + 1) % contour.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(contour.length - index - 1);
+                    contour.splice(index, 1);
+                    changed = true;
+                    break;
+                }
+            }
+        }
+        contours.push(contour);
+    }
+    if (contours.length === 0)
+        fail();
+    const region = regionFromContours(contours);
+    const profileContour = (id, points) => ({
+        id,
+        points,
+        spans: points.map((_, index) => `point-${index}`),
+    });
+    return {
+        components: region.map((component, index) => ({
+            id: `component-${index}`,
+            outer: profileContour("outer", component.outer),
+            holes: component.holes.map((hole, index) => profileContour(`hole-${index}`, hole)),
+        })),
+    };
+}