@metamesh/modeling 0.19.0 → 0.20.0

package/dist/engine/operations/join.js

@@ -1,13 +1,13 @@
-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 { assertMeshAllocationWithinLimits } from "../../geometry/limits.js";
+import { clipJoinPolygon, createJoinPolygonIndex, expandJoinPolygon, inJoinPolygon, intersectJoinPolygons, joinArea, joinHeight, JoinWork, prepareJoinLayer, subtractJoinPolygon, } from "../../geometry/mesh/join-layers.js";
+import { validateSolidMesh } from "../../geometry/mesh/solid.js";
+import { planRegionOffsets } from "../../geometry/regions/offset.js";
+import { contourContainsPoint } from "../../geometry/regions/operations.js";
+import { assertSamplingCount } from "../../geometry/sampling/limits.js";
+import { resolveGeometryResolution } from "../../geometry/sampling/resolution.js";
 import { resolveGeometryTolerance } from "../../geometry/tolerance.js";
+import { anchor3, anchorFrame3 } from "../../geometry/transforms/anchors.js";
 import { nativeConstructionMesh } from "../native/construction-mesh.js";
 import { ownScopedManifoldValue } from "../native/context.js";
 import { observeNativeMesh } from "../native/mesh-observation.js";
@@ -16,12 +16,18 @@ import { nativeCollarProfile } from "./join-collar-profile.js";
 const fail = (message, phase) => {
     throw new GeometryError("INVALID_ARGUMENT", message, { operation: "join", details: { phase } });
 };
+// Keep these kernels local to isolate V8's array-type feedback from other modeling operations.
+// Shared helpers see more array representations, which can slow hot loops even when inlined.
 const dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
-const contours = (profile) => profile.components.flatMap((component) => [
+const profileContours = (profile) => profile.components.flatMap((component) => [
     component.outer.points,
     ...component.holes.map((hole) => hole.points),
 ]);
-/** One deferred connection, with native operands authoritative throughout support proofs. */
+/**
+ * Builds one connection from authoritative native operands. Proves support coverage, material,
+ * and the constant-section collar before constructing the transition. Only the finished collar
+ * is transformed back and fused with the unchanged original operands.
+ */
 export function createJoinOperation(environment) {
     return (base, feature, options) => {
         const { module, scope } = environment;
@@ -70,9 +76,21 @@ export function createJoinOperation(environment) {
             : 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);
+        const sourceAnchor = anchor3({
+            position: supplied.position,
+            direction: supplied.direction,
+            up: 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 frame = anchorFrame3(anchor3({
+            position: sourceAnchor.position,
+            direction: [
+                -sourceAnchor.direction[0],
+                -sourceAnchor.direction[1],
+                -sourceAnchor.direction[2],
+            ],
+            up: sourceAnchor.up,
+        }));
         const { xAxis: x, yAxis: y, zAxis: z, origin: o } = frame;
         const forward = [
             x[0],
@@ -134,11 +152,11 @@ export function createJoinOperation(environment) {
         const closingInset = epsilon * 8;
         const offset = planRegionOffsets(source, [-width, closingInset], "join", limits);
         work.use(offset.workCount);
-        const region = (loops) => own(loops.length === 0
+        const crossSectionFromContours = (contours) => own(contours.length === 0
             ? sourceSection.subtract(sourceSection)
-            : new module.CrossSection(loops.map((loop) => loop.map((p) => [p[0], p[1]])), "NonZero"));
+            : new module.CrossSection(contours.map((contour) => contour.map((p) => [p[0], p[1]])), "NonZero"));
         const expandedProfile = offset.profileAt(-width);
-        const footprint = region(contours(expandedProfile));
+        const footprint = crossSectionFromContours(profileContours(expandedProfile));
         const triangles = [];
         const canonicalPlanes = [];
         const chartTolerance = resolveGeometryTolerance(scale);
@@ -174,12 +192,12 @@ export function createJoinOperation(environment) {
             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));
+            const clipped = own(crossSectionFromContours([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.
+            // Float64 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();
@@ -196,9 +214,9 @@ export function createJoinOperation(environment) {
         }
         // 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 &&
+        const convexPartition = (contours) => {
+            const outer = contours[0];
+            const convex = contours.length === 1 &&
                 outer.length >= 3 &&
                 joinArea(outer) > 0 &&
                 outer.every((point, i) => {
@@ -210,12 +228,15 @@ export function createJoinOperation(environment) {
                 });
             if (convex)
                 return [outer];
-            const vertices = loops.flat();
+            const vertices = contours.flat();
             return module
-                .triangulate(loops.map((loop) => loop.map((p) => [p[0], p[1]])), 0, false)
+                .triangulate(contours.map((contour) => contour.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 footprintCells = expandedProfile.components.flatMap((component) => convexPartition(crossSectionFromContours([
+            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.
@@ -254,21 +275,21 @@ export function createJoinOperation(environment) {
         // 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) => {
+        const proofSections = cells.map((cell) => {
             work.use(cell.polygon.length);
             const expanded = expandJoinPolygon(cell.polygon, epsilon / (2 * Math.SQRT2), work);
-            return region([expanded]);
+            return crossSectionFromContours([expanded]);
         });
-        const proofPoints = proofRegions.reduce((count, region) => count + region.numVert(), 0);
+        const proofPoints = proofSections.reduce((count, section) => count + section.numVert(), 0);
         assertMeshAllocationWithinLimits(proofPoints * 2, proofPoints * 4, proofPoints * 96, "join", limits);
-        const proofCoverage = own(module.CrossSection.union(proofRegions));
+        const proofCoverage = own(module.CrossSection.union(proofSections));
         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;
+        let maximumSlope = 0, highestSupport = -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));
+                highestSupport = Math.max(highestSupport, joinHeight(cell.plane, point));
             }
         }
         allowance *= 1 + maximumSlope;
@@ -286,14 +307,18 @@ export function createJoinOperation(environment) {
                         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)
+        const collarTop = highestSupport + height + allowance;
+        if (collarTop > 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 proofDomain = own(module.Manifold.extrude(footprint, collarTop + 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];
+                const area = proofSections[index];
                 if (area.isEmpty())
                     return [];
                 const guard = epsilon * (2 + Math.hypot(cell.plane[0], cell.plane[1]) / 2);
@@ -314,33 +339,33 @@ export function createJoinOperation(environment) {
         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);
+        const overhead = terrain(() => collarTop + 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 domain = own(module.Manifold.extrude(footprint, collarTop - 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 expected = own(module.Manifold.extrude(innerSection, collarTop - epsilon * 2).translate([0, 0, epsilon * 2]));
+        const outer = own(module.Manifold.extrude(outerSection, collarTop - 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);
+        const originalContours = profileContours(source), outsideContours = profileContours(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);
+        const insideContours = profileContours(insideProfile);
+        const closingSection = crossSectionFromContours(insideContours);
         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));
+        const closingCore = own(module.Manifold.extrude(closingSection, collarTop));
         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 contourIndex = 0; contourIndex < originalContours.length; contourIndex++) {
+            const original = originalContours[contourIndex], expanded = outsideContours[contourIndex];
             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]);
@@ -382,6 +407,16 @@ export function createJoinOperation(environment) {
             }
             return group;
         });
+        const appendClippedCells = (polygon) => {
+            for (const [cellIndex, cell] of cells.entries()) {
+                work.use();
+                const piece = intersectJoinPolygons(polygon, cell.polygon);
+                if (piece.length >= 3 && Math.abs(joinArea(piece)) > meshEpsilon ** 2) {
+                    polygons.push(piece);
+                    bottomGroups.push(cellGroups[cellIndex]);
+                }
+            }
+        };
         // 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++) {
@@ -395,45 +430,23 @@ export function createJoinOperation(environment) {
                 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]);
-                    }
-                }
+                appendClippedCells(band);
             }
         // 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 contourIndex = 0; contourIndex < originalContours.length; contourIndex++) {
+            const original = originalContours[contourIndex], inside = insideContours[contourIndex];
             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]);
-                    }
-                }
+                appendClippedCells(ring);
             }
         }
         // 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]);
-                }
-            }
-        }
+        for (const coreCell of coreCells)
+            appendClippedCells(coreCell);
         const stripIndex = createJoinPolygonIndex(strips.map((strip) => strip.polygon), work, limits);
         const rise = (p) => {
             for (const index of stripIndex(p, epsilon)) {
@@ -452,7 +465,7 @@ export function createJoinOperation(environment) {
         const layerOptions = {
             bottomGroups,
             supportPlanes,
-            triangulate: (loops) => module.triangulate(loops.map((loop) => loop.map((p) => [p[0], p[1]])), 0, false),
+            triangulate: (contours) => module.triangulate(contours.map((contour) => contour.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.
@@ -465,7 +478,7 @@ export function createJoinOperation(environment) {
         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.
+            // Float64 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");

package/dist/engine/operations/knuckle-hinge.js

@@ -1,15 +1,16 @@
 import { GeometryError } from "../../geometry/errors.js";
 import { resolveKnuckleHinge } from "../../geometry/mechanical/knuckle-hinge.js";
-import { assertPrimitiveOptions } from "../../geometry/primitive-resolvers.js";
-import { assertSamplingCount } from "../../geometry/sampling-limits.js";
+import { assertPrimitiveOptions } from "../../geometry/primitives/resolvers.js";
+import { assertSamplingCount } from "../../geometry/sampling/limits.js";
+import { frameTransform3 } from "../../geometry/transforms/affine3.js";
 /** Composes existing scoped operations after resolving both halves against one host policy. */
 export function createKnuckleHingeOperation(environment, operations) {
     return (options) => {
         environment.assertActive();
         assertPrimitiveOptions(options, "knuckleHinge");
         const resolved = environment.withResolutionDefaults(options);
-        const d = resolveKnuckleHinge(options, resolved);
-        assertSamplingCount(d.segments * d.spec.knuckleCount * 2, "knuckleHinge", resolved.limits.maxVertices);
+        const dimensions = resolveKnuckleHinge(options, resolved);
+        assertSamplingCount(dimensions.segments * dimensions.spec.knuckleCount * 2, "knuckleHinge", resolved.limits.maxVertices);
         const invalid = (message) => {
             throw new GeometryError("INVALID_ARGUMENT", message, { operation: "knuckleHinge" });
         };
@@ -18,8 +19,8 @@ export function createKnuckleHingeOperation(environment, operations) {
             const chamfer = half.chamfer ?? 0;
             if (!Number.isFinite(chamfer) ||
                 chamfer < 0 ||
-                2 * chamfer >= d.knuckleLength ||
-                chamfer >= d.minimumBarrelWall)
+                2 * chamfer >= dimensions.knuckleLength ||
+                chamfer >= dimensions.minimumBarrelWall)
                 invalid("chamfer must be nonnegative and leave a positive axial band and faceted barrel wall.");
             const web = half.web;
             if (web !== undefined) {
@@ -34,9 +35,9 @@ export function createKnuckleHingeOperation(environment, operations) {
                     !Number.isFinite(web.zMin + web.thickness))
                     invalid("Web dimensions must be finite, with positive reach and thickness.");
                 if (2 * chamfer >= web.thickness ||
-                    2 * Math.SQRT2 * chamfer >= Math.min(d.knuckleLength, web.reach))
+                    2 * Math.SQRT2 * chamfer >= Math.min(dimensions.knuckleLength, web.reach))
                     invalid("chamfer must leave a positive web band and noncollapsed end contours.");
-                const innerRadius = d.barrelRadius * Math.cos(Math.PI / d.segments);
+                const innerRadius = dimensions.barrelRadius * Math.cos(Math.PI / dimensions.segments);
                 if (web.zMin >= innerRadius || web.zMin + web.thickness <= -innerRadius)
                     invalid("A web must overlap the interior of its barrel.");
             }
@@ -49,7 +50,7 @@ export function createKnuckleHingeOperation(environment, operations) {
             radius,
             height: length,
             center: false,
-            segments: d.segments,
+            segments: dimensions.segments,
             sizing: bore ? "face" : "vertex",
             ...(chamfer === 0
                 ? {}
@@ -69,7 +70,7 @@ export function createKnuckleHingeOperation(environment, operations) {
                 // Parallel offsets finish the exposed tip; the two root corners stay square.
                 const corner = { kind: "chamfer", distance: chamfer + (Math.SQRT2 - 2) * inset };
                 const profile = operations.rectangle({
-                    size: [d.knuckleLength - 2 * inset, web.reach - inset],
+                    size: [dimensions.knuckleLength - 2 * inset, web.reach - inset],
                     center: false,
                     treatment: [corner, corner, { kind: "square" }, { kind: "square" }],
                 });
@@ -78,10 +79,10 @@ export function createKnuckleHingeOperation(environment, operations) {
                     web.direction === "positive-y" ? 1 : -1,
                 ]);
             };
-            for (const interval of d.knuckles) {
+            for (const interval of dimensions.knuckles) {
                 if (interval.side !== side)
                     continue;
-                features.push(atBase(axial(d.barrelRadius, interval.start, interval.length, false, chamfer)));
+                features.push(atBase(axial(dimensions.barrelRadius, interval.start, interval.length, false, chamfer)));
                 if (web !== undefined) {
                     features.push(chamfer === 0
                         ? operations.translate(operations.box({
@@ -99,30 +100,34 @@ export function createKnuckleHingeOperation(environment, operations) {
                             [chamfer, web.thickness],
                         ].map(([inset, z]) => ({
                             profile: webProfile(web, inset),
-                            frame: {
+                            transform: frameTransform3({
                                 origin: [interval.start, 0, z],
                                 xAxis: [1, 0, 0],
                                 yAxis: [0, 1, 0],
                                 zAxis: [0, 0, 1],
-                            },
+                            }),
                         }))));
                 }
             }
-            if (side === "a" && d.pin !== null)
-                features.push(atBase(axial(d.pinRadius, d.pin.start, d.pin.length)));
+            if (side === "a" && dimensions.pin !== null)
+                features.push(atBase(axial(dimensions.pinRadius, dimensions.pin.start, dimensions.pin.length)));
             // Match the kernel cylinders to the same mesh precision as the explicit web stations.
             const solid = operations.union(features.map((feature) => chamfer === 0 || web === undefined
                 ? feature
                 : operations.solidFromMesh(environment.analyzedMeshFor(feature).mesh)));
             // Overtravel is numerical cutter extent, independent of the physical radial/axial allowances.
-            const overtravel = Math.min(d.knuckleLength, d.barrelRadius) * 0.01;
-            const result = side === "a" && d.pin !== null
+            const overtravel = Math.min(dimensions.knuckleLength, dimensions.barrelRadius) * 0.01;
+            const result = side === "a" && dimensions.pin !== null
                 ? solid
                 : operations.subtract(solid, [
-                    atBase(axial(d.boreRadius, -d.spec.length / 2 - overtravel, d.spec.length + 2 * overtravel, true)),
+                    atBase(axial(dimensions.boreRadius, -dimensions.spec.length / 2 - overtravel, dimensions.spec.length + 2 * overtravel, true)),
                 ]);
             return operations.translate(result, [0, 0, baseZ]);
         };
-        return Object.freeze({ halfA: buildHalf("a", a), halfB: buildHalf("b", b), axis: d.axis });
+        return Object.freeze({
+            halfA: buildHalf("a", a),
+            halfB: buildHalf("b", b),
+            axis: dimensions.axis,
+        });
     };
 }

package/dist/engine/operations/loft.js

@@ -1,10 +1,9 @@
 import { GeometryError } from "../../geometry/errors.js";
-import { loftProfilePointCount, pointLoftProfile, prepareLoftGeometry, } from "../../geometry/loft/loft-geometry.js";
-import { loftFrame, resolveLoftControls } from "../../geometry/loft/loft-options.js";
-import { simpleLoftMesh } from "../../geometry/loft/loft-simple-mesh.js";
-import { analyzeTriangleMesh } from "../../geometry/mesh/mesh.js";
-import { capturePath2Input, path2InputData, } from "../../geometry/paths/path-value.js";
-import { assertSamplingCount, } from "../../geometry/sampling-limits.js";
+import { loftProfilePointCount, pointLoftProfile, prepareLoftGeometry, } from "../../geometry/loft/geometry.js";
+import { loftTransform, resolveLoftControls } from "../../geometry/loft/options.js";
+import { simpleLoftMesh } from "../../geometry/loft/simple-mesh.js";
+import { capturePath2Input, path2InputData } from "../../geometry/paths/value.js";
+import { assertSamplingCount, } from "../../geometry/sampling/limits.js";
 import { buildProfileLoftMesh } from "./primitives/profile-mesh.js";
 import { correspondingPrimitiveProfiles, rectangularPrimitiveFamily, } from "./primitives/profiles.js";
 const explicitProfile = (value) => typeof value === "object" &&
@@ -73,7 +72,7 @@ export function createLoftOperation(environment, solidFromMesh) {
         if (!Array.isArray(inputStations) || inputStations.length < 2)
             fail("Loft requires at least two stations.");
         assertSamplingCount(inputStations.length, "loft", environment.limits.maxPathPoints);
-        inputStations.forEach((station) => loftFrame(station));
+        inputStations.forEach((station) => loftTransform(station));
         let selected = environment.withResolutionDefaults(value);
         resolveLoftControls(value, inputStations.length);
         const captured = inputStations.map(({ profile, ...placement }) => {
@@ -108,7 +107,7 @@ export function createLoftOperation(environment, solidFromMesh) {
         let recipeSampled;
         if (explicit) {
             if (!stations.every((station) => explicitProfile(station.profile)))
-                fail("Identified profile stations cannot be mixed with Sections or point loops.");
+                fail("Identified profile stations cannot be mixed with Sections or point contours.");
             profiles = stations.map((station) => station.profile);
             authoritative = true;
         }
@@ -159,20 +158,14 @@ export function createLoftOperation(environment, solidFromMesh) {
         if (authoritative && controls.methods.some((method) => method !== "direct"))
             fail("Identified landmarks cannot be remapped by geometric loft correspondence.");
         const input = stations.map((station, index) => ({
-            frame: loftFrame(station),
+            transform: loftTransform(station),
             profile: profiles[index],
         }));
         const geometry = prepareLoftGeometry(input, selected, selected.limits, authoritative, recipeSampled);
         if (geometry.stations.every((station) => station.profile.components.length === 1 &&
             station.profile.components[0].holes.length === 0))
             return solidFromMesh(simpleLoftMesh(geometry, selected.limits));
-        const mesh = buildProfileLoftMesh(environment.module, geometry.stations, selected.limits, false, 0, (station, contour, slot) => geometry.world[station][contour][slot]);
-        if (analyzeTriangleMesh(mesh).signedVolume < 0)
-            for (let index = 0; index < mesh.indices.length; index += 3) {
-                const b = mesh.indices[index + 1];
-                mesh.indices[index + 1] = mesh.indices[index + 2];
-                mesh.indices[index + 2] = b;
-            }
+        const mesh = buildProfileLoftMesh(environment.module, geometry.stations, selected.limits, false, [], (station, contour, slot) => geometry.world[station][contour][slot]);
         return solidFromMesh(mesh);
     };
 }

package/dist/engine/operations/mechanical.js

@@ -1,3 +1,4 @@
+import { preflightInternalThreadCutterSolid, preflightThreadedNutSolid, preflightThreadedRodSolid, } from "../../geometry/mechanical/threads/solids.js";
 import * as kernel from "../native/index.js";
 import { createKnuckleHingeOperation } from "./knuckle-hinge.js";
 /** Internal host-bound mechanical operations. */
@@ -18,33 +19,21 @@ export function createMechanicalOperations(environment, construction) {
         threadedRod: (value) => {
             assertActive();
             const resolved = withResolutionDefaults(value);
-            kernel.preflightThreadedRod(resolved);
+            preflightThreadedRodSolid(resolved);
             return wrapSolid(kernel.threadedRod(scope, resolved));
         },
         internalThreadCutter: (value) => {
             assertActive();
             const resolved = withResolutionDefaults(value);
-            kernel.preflightInternalThreadCutter(resolved);
+            preflightInternalThreadCutterSolid(resolved);
             return wrapSolid(kernel.internalThreadCutter(scope, resolved));
         },
         threadedNut: (value) => {
             assertActive();
             const resolved = nutOptions(value);
-            kernel.preflightThreadedNut(resolved);
+            preflightThreadedNutSolid(resolved);
             return wrapSolid(kernel.threadedNut(scope, resolved));
         },
-        preflightThreadedRod: (value) => {
-            assertActive();
-            return kernel.preflightThreadedRod(withResolutionDefaults(value));
-        },
-        preflightThreadedNut: (value) => {
-            assertActive();
-            return kernel.preflightThreadedNut(nutOptions(value));
-        },
-        preflightInternalThreadCutter: (value) => {
-            assertActive();
-            return kernel.preflightInternalThreadCutter(withResolutionDefaults(value));
-        },
     };
     return operations;
 }

package/dist/engine/operations/primitives/anchors.js

@@ -1,7 +1,7 @@
-import { anchor3, boxAnchor3 } from "../../../geometry/anchors.js";
-import { resolveCylinderRadii } from "../../../geometry/cylinder.js";
 import { vector3Data } from "../../../geometry/math/vector-value.js";
-import { resolveTubeRadii } from "../../../geometry/primitive-resolvers.js";
+import { resolveCylinderRadii } from "../../../geometry/primitives/cylinder.js";
+import { resolveTubeRadii } from "../../../geometry/primitives/resolvers.js";
+import { anchor3, boxAnchor3 } from "../../../geometry/transforms/anchors.js";
 const faces = ["left", "right", "back", "front", "bottom", "top"];
 /** Nominal primitive datums; construction validates dimensions before these factories run. */
 export function boxAnchors(options) {
@@ -10,7 +10,7 @@ export function boxAnchors(options) {
         : vector3Data(options.size);
     const center = options.center === false ? [size[0] / 2, size[1] / 2, size[2] / 2] : [0, 0, 0];
     return {
-        center: anchor3(center, [0, 0, 1]),
+        center: anchor3({ position: center, direction: [0, 0, 1] }),
         ...Object.fromEntries(faces.map((face) => [
             face,
             boxAnchor3({
@@ -28,13 +28,17 @@ function axialAnchors(radii, height, centered) {
     const radius = (radii[0] + radii[1]) / 2;
     const slope = (radii[1] - radii[0]) / height;
     return {
-        center: anchor3([0, 0, middle], [0, 0, 1]),
-        ...(radii[0] === 0 ? {} : { bottom: anchor3([0, 0, bottom], [0, 0, -1]) }),
-        ...(radii[1] === 0 ? {} : { top: anchor3([0, 0, bottom + height], [0, 0, 1]) }),
-        right: anchor3([radius, 0, middle], [1, 0, -slope], [0, 0, 1]),
-        left: anchor3([-radius, 0, middle], [-1, 0, -slope], [0, 0, 1]),
-        front: anchor3([0, radius, middle], [0, 1, -slope], [0, 0, 1]),
-        back: anchor3([0, -radius, middle], [0, -1, -slope], [0, 0, 1]),
+        center: anchor3({ position: [0, 0, middle], direction: [0, 0, 1] }),
+        ...(radii[0] === 0
+            ? {}
+            : { bottom: anchor3({ position: [0, 0, bottom], direction: [0, 0, -1] }) }),
+        ...(radii[1] === 0
+            ? {}
+            : { top: anchor3({ position: [0, 0, bottom + height], direction: [0, 0, 1] }) }),
+        right: anchor3({ position: [radius, 0, middle], direction: [1, 0, -slope], up: [0, 0, 1] }),
+        left: anchor3({ position: [-radius, 0, middle], direction: [-1, 0, -slope], up: [0, 0, 1] }),
+        front: anchor3({ position: [0, radius, middle], direction: [0, 1, -slope], up: [0, 0, 1] }),
+        back: anchor3({ position: [0, -radius, middle], direction: [0, -1, -slope], up: [0, 0, 1] }),
     };
 }
 /** Cylinder and frustum cap anchors omit an end whose nominal radius is zero. */
@@ -60,16 +64,16 @@ export function torusAnchors(options) {
 export function planarAnchors(size, centered = true) {
     const x = centered ? 0 : size[0] / 2, y = centered ? 0 : size[1] / 2;
     return {
-        center: anchor3([x, y, 0], [0, 0, 1]),
-        top: anchor3([x, y, 0], [0, 0, 1]),
-        bottom: anchor3([x, y, 0], [0, 0, -1]),
-        right: anchor3([x + size[0] / 2, y, 0], [1, 0, 0], [0, 0, 1]),
-        left: anchor3([x - size[0] / 2, y, 0], [-1, 0, 0], [0, 0, 1]),
-        front: anchor3([x, y + size[1] / 2, 0], [0, 1, 0], [0, 0, 1]),
-        back: anchor3([x, y - size[1] / 2, 0], [0, -1, 0], [0, 0, 1]),
+        center: anchor3({ position: [x, y, 0], direction: [0, 0, 1] }),
+        top: anchor3({ position: [x, y, 0], direction: [0, 0, 1] }),
+        bottom: anchor3({ position: [x, y, 0], direction: [0, 0, -1] }),
+        right: anchor3({ position: [x + size[0] / 2, y, 0], direction: [1, 0, 0], up: [0, 0, 1] }),
+        left: anchor3({ position: [x - size[0] / 2, y, 0], direction: [-1, 0, 0], up: [0, 0, 1] }),
+        front: anchor3({ position: [x, y + size[1] / 2, 0], direction: [0, 1, 0], up: [0, 0, 1] }),
+        back: anchor3({ position: [x, y - size[1] / 2, 0], direction: [0, -1, 0], up: [0, 0, 1] }),
     };
 }
 /** A construction-origin reference for primitives without meaningful principal side datums. */
 export const originAnchor = () => ({
-    center: anchor3([0, 0, 0], [0, 0, 1]),
+    center: anchor3({ position: [0, 0, 0], direction: [0, 0, 1] }),
 });