@metamesh/modeling 0.18.0 → 0.20.0

package/dist/engine/native/material-components.js

@@ -1,7 +1,8 @@
 import { GeometryError } from "../../geometry/errors.js";
-import { triangleSolidAngle } from "../../geometry/mesh/mesh-solid-intersections.js";
-import { assertMeshAllocationWithinLimits, } from "../../geometry/model-limits.js";
+import { assertMeshAllocationWithinLimits } from "../../geometry/limits.js";
+import { triangleSolidAngle } from "../../geometry/mesh/solid-intersections.js";
 import { ownScopedManifoldValue, scopedManifoldModule, } from "./context.js";
+import { observeNativeMesh, } from "./mesh-observation.js";
 import { assertNativeSolidStatus } from "./status.js";
 const MAXIMUM_CONTAINMENT_TESTS = 2_000_000;
 /** Certifies the native sign only when its floating-point error cannot reach zero. */
@@ -34,56 +35,6 @@ function certifiedNativeOrientation(volume, bounds, triangles) {
         return undefined;
     return Math.abs(volume) > error ? (volume < 0 ? -1 : 1) : undefined;
 }
-/** Observes native coordinates and topology without converting geometry to Float32. */
-function nativeShellMesh(scope, shell, limits) {
-    const vertices = shell.numVert();
-    const properties = shell.numPropVert();
-    const triangles = shell.numTri();
-    // Both native observation work and copied topology stay within the host's mesh limits.
-    // Charge the Float64 coordinates, Float32 property mesh, index map and triangle indices.
-    assertMeshAllocationWithinLimits(Math.max(vertices, properties), triangles, vertices * 24 + properties * (shell.numProp() + 4) * 4 + triangles * 12, "components", limits);
-    const coordinates = new Float64Array(vertices * 3);
-    const encoded = ownScopedManifoldValue(scope, shell.warpBatch((positions, count) => {
-        coordinates.set(positions);
-        for (let vertex = 0; vertex < count; vertex++) {
-            // Exact Float32-safe IDs recover native indices even when property vertices
-            // are duplicated or reordered by getMesh(). The original coordinates stay Float64.
-            positions[vertex * 3] = vertex % 65536;
-            positions[vertex * 3 + 1] = Math.floor(vertex / 65536);
-            positions[vertex * 3 + 2] = 0;
-        }
-    }));
-    assertNativeSolidStatus(encoded, "components");
-    if (encoded.numVert() !== vertices || encoded.numTri() !== triangles)
-        throw new GeometryError("INVALID_TOPOLOGY", "Native observation changed shell topology.", {
-            operation: "components",
-        });
-    const mesh = encoded.getMesh();
-    if (mesh.numVert !== properties || mesh.numTri !== triangles)
-        throw new GeometryError("INVALID_TOPOLOGY", "Native observation changed property topology.", {
-            operation: "components",
-        });
-    const indices = new Uint32Array(properties);
-    for (let vertex = 0; vertex < properties; vertex++) {
-        const offset = vertex * mesh.numProp;
-        const low = mesh.vertProperties[offset];
-        const high = mesh.vertProperties[offset + 1];
-        const index = low + high * 65536;
-        if (!Number.isInteger(low) ||
-            low < 0 ||
-            low >= 65536 ||
-            !Number.isInteger(high) ||
-            high < 0 ||
-            !Number.isSafeInteger(index) ||
-            index >= vertices ||
-            mesh.vertProperties[offset + 2] !== 0)
-            throw new GeometryError("INVALID_TOPOLOGY", "Native observation lost a vertex identity.", {
-                operation: "components",
-            });
-        indices[vertex] = index;
-    }
-    return { coordinates, vertexIndices: indices, triangles: mesh.triVerts };
-}
 /** Computes signed enclosed volume without rounding, including folded contact boundaries. */
 function nativeShellOrientation(mesh) {
     const { coordinates, vertexIndices, triangles } = mesh;
@@ -186,7 +137,7 @@ export function solidMaterialComponents(scope, solid, limits) {
             shell.numPropVert() * (shell.numProp() + 4) * 4 +
             shell.numTri() * 12;
         assertMeshAllocationWithinLimits(Math.max(vertices, properties), triangles, bytes, "components", limits);
-        const mesh = nativeShellMesh(scope, shell, limits);
+        const mesh = observeNativeMesh(scope, shell, limits, "components");
         meshes.set(shell, mesh);
         observedVertices = vertices;
         observedProperties = properties;

package/dist/engine/native/mesh-observation.js

@@ -0,0 +1,55 @@
+import { GeometryError } from "../../geometry/errors.js";
+import { assertMeshAllocationWithinLimits } from "../../geometry/limits.js";
+import { ownScopedManifoldValue } from "./context.js";
+import { assertNativeSolidStatus } from "./status.js";
+/** Observes native coordinates and topology without a Float32 geometry round trip. */
+export function observeNativeMesh(scope, solid, limits, operation) {
+    const vertices = solid.numVert();
+    const properties = solid.numPropVert();
+    const triangles = solid.numTri();
+    assertMeshAllocationWithinLimits(Math.max(vertices, properties), triangles, vertices * 24 + properties * (solid.numProp() + 4) * 4 + triangles * 20 + 4, operation, limits);
+    const coordinates = new Float64Array(vertices * 3);
+    const encoded = ownScopedManifoldValue(scope, solid.warpBatch((positions, count) => {
+        coordinates.set(positions);
+        for (let vertex = 0; vertex < count; vertex++) {
+            // Float32-safe IDs preserve native identity through property-vertex duplication/reordering.
+            positions[vertex * 3] = vertex % 65536;
+            positions[vertex * 3 + 1] = Math.floor(vertex / 65536);
+            positions[vertex * 3 + 2] = 0;
+        }
+    }));
+    assertNativeSolidStatus(encoded, operation);
+    if (encoded.numVert() !== vertices || encoded.numTri() !== triangles)
+        throw new GeometryError("INVALID_TOPOLOGY", "Native observation changed shell topology.", {
+            operation,
+        });
+    const mesh = encoded.getMesh();
+    if (mesh.numVert !== properties || mesh.numTri !== triangles)
+        throw new GeometryError("INVALID_TOPOLOGY", "Native observation changed property topology.", {
+            operation,
+        });
+    const indices = new Uint32Array(properties);
+    for (let vertex = 0; vertex < properties; vertex++) {
+        const offset = vertex * mesh.numProp;
+        const low = mesh.vertProperties[offset];
+        const high = mesh.vertProperties[offset + 1];
+        const index = low + high * 65536;
+        if (!Number.isInteger(low) ||
+            low < 0 ||
+            low >= 65536 ||
+            !Number.isInteger(high) ||
+            high < 0 ||
+            !Number.isSafeInteger(index) ||
+            index >= vertices ||
+            mesh.vertProperties[offset + 2] !== 0)
+            throw new GeometryError("INVALID_TOPOLOGY", "Native observation lost a vertex identity.", {
+                operation,
+            });
+        indices[vertex] = index;
+    }
+    return {
+        coordinates,
+        vertexIndices: indices,
+        triangles: mesh.triVerts,
+    };
+}

package/dist/engine/native/regions.js

@@ -1,6 +1,6 @@
 import { GeometryError } from "../../geometry/errors.js";
-import { contourContainsPoint, normalizeContour, normalizeRegion, signedContourArea, } from "../../geometry/regions.js";
-import { assertSamplingCount, resolveGeometrySamplingLimits, } from "../../geometry/sampling-limits.js";
+import { contourContainsPoint, normalizeContour, normalizeRegion, signedContourArea, } from "../../geometry/regions/operations.js";
+import { assertSamplingCount, resolveGeometrySamplingLimits, } from "../../geometry/sampling/limits.js";
 import { assertScopedManifoldValue, ownScopedManifoldValue, scopedManifoldModule, } from "./context.js";
 /** @internal One contour ceiling shared with authored input normalization preflights. */
 export const MAX_AGGREGATE_CONTOURS = 25_000;
@@ -9,6 +9,7 @@ const assertRegionBounds = (regions, operation, limits = {}) => {
     if (!hasArrayShape) {
         throw new GeometryError("INVALID_ARGUMENT", "Regions must be an array.", { operation });
     }
+    const maximumPoints = resolveGeometrySamplingLimits(limits).maxProfilePoints;
     let contours = 0;
     let vertices = 0;
     if (regions.length > MAX_AGGREGATE_CONTOURS) {
@@ -47,9 +48,9 @@ const assertRegionBounds = (regions, operation, limits = {}) => {
                     details: { contours, vertices },
                 });
             }
-            assertSamplingCount(vertices, operation, resolveGeometrySamplingLimits(limits).maxProfilePoints);
-            for (const loop of [polygon.outer, ...polygon.holes]) {
-                for (const point of loop) {
+            assertSamplingCount(vertices, operation, maximumPoints);
+            for (const contour of [polygon.outer, ...polygon.holes]) {
+                for (const point of contour) {
                     if (!Array.isArray(point) || point.length !== 2) {
                         throw new GeometryError("INVALID_ARGUMENT", "Region points must be exact XY tuples.", {
                             operation,
@@ -67,7 +68,7 @@ const assertRegionBounds = (regions, operation, limits = {}) => {
 };
 const contoursFromRegion = (region) => region
     .flatMap((polygon) => [polygon.outer, ...polygon.holes])
-    .map((loop) => loop.map(([x, y]) => [x, y]));
+    .map((contour) => contour.map(([x, y]) => [x, y]));
 /**
  * Converts explicit normalized region topology to a scope-owned CrossSection.
  *
@@ -82,14 +83,19 @@ export function regionToCrossSection(context, region, limits = {}) {
         return ownScopedManifoldValue(context, module.CrossSection.union([]));
     return ownScopedManifoldValue(context, new module.CrossSection(contoursFromRegion(normalized)));
 }
-const regionFromLoops = (loops) => {
-    const outers = loops
-        .filter((loop) => signedContourArea(loop) > 0)
+/**
+ * Classifies native XY contours in millimetres into CCW exteriors and CW holes.
+ * Each hole belongs to its smallest enclosing exterior; contour order carries no topology identity.
+ * Normalization validates the resulting material regions.
+ */
+export const regionFromContours = (contours) => {
+    const outers = contours
+        .filter((contour) => signedContourArea(contour) > 0)
         .map((outer) => ({ outer: normalizeContour(outer, true), holes: [] }));
-    const holes = loops
-        .filter((loop) => signedContourArea(loop) < 0)
+    const holes = contours
+        .filter((contour) => signedContourArea(contour) < 0)
         .map((hole) => normalizeContour(hole, false));
-    if (outers.length === 0 && loops.length > 0) {
+    if (outers.length === 0 && contours.length > 0) {
         throw new GeometryError("INVALID_TOPOLOGY", "CrossSection did not contain an exterior contour.");
     }
     const outerBounds = new Map(outers.map((polygon) => {
@@ -103,20 +109,35 @@ const regionFromLoops = (loops) => {
             maximumX = Math.max(maximumX, x);
             maximumY = Math.max(maximumY, y);
         }
-        return [polygon, { minimumX, minimumY, maximumX, maximumY }];
+        return [
+            polygon,
+            {
+                minimumX,
+                minimumY,
+                maximumX,
+                maximumY,
+                area: Math.abs(signedContourArea(polygon.outer)),
+            },
+        ];
     }));
     for (const hole of holes) {
         const [x, y] = hole[0];
-        const owner = outers
-            .filter((polygon) => {
+        let owner;
+        let smallestArea = Infinity;
+        // Material islands can nest inside cavities. Keep the nearest enclosing exterior without
+        // sorting candidates or remeasuring their contours for every hole.
+        for (const polygon of outers) {
             const bounds = outerBounds.get(polygon);
-            return (x >= bounds.minimumX &&
+            if ((owner === undefined || bounds.area < smallestArea) &&
+                x >= bounds.minimumX &&
                 x <= bounds.maximumX &&
                 y >= bounds.minimumY &&
                 y <= bounds.maximumY &&
-                contourContainsPoint(polygon.outer, hole[0]));
-        })
-            .sort((a, b) => Math.abs(signedContourArea(a.outer)) - Math.abs(signedContourArea(b.outer)))[0];
+                contourContainsPoint(polygon.outer, hole[0])) {
+                owner = polygon;
+                smallestArea = bounds.area;
+            }
+        }
         if (owner === undefined) {
             throw new GeometryError("INVALID_TOPOLOGY", "CrossSection hole had no containing exterior.");
         }
@@ -128,12 +149,12 @@ const regionFromLoops = (loops) => {
 export function crossSectionToRegion(context, section, limits = {}) {
     assertScopedManifoldValue(context, section);
     assertSamplingCount(section.numVert(), "crossSectionToRegion", resolveGeometrySamplingLimits(limits).maxProfilePoints);
-    // Normalization owns the one immutable coordinate copy and reuses validated child loops.
-    const loops = section.toPolygons();
-    if (loops.length > MAX_AGGREGATE_CONTOURS) {
+    // Normalization owns the one immutable coordinate copy and reuses validated child contours.
+    const contours = section.toPolygons();
+    if (contours.length > MAX_AGGREGATE_CONTOURS) {
         throw new GeometryError("COMPLEXITY_LIMIT", "Resolved regions exceed 25000 contours.", {
             operation: "crossSectionToRegion",
         });
     }
-    return regionFromLoops(loops);
+    return regionFromContours(contours);
 }

package/dist/engine/native/scoped-primitives.js

@@ -1,6 +1,6 @@
-import { resolveCylinderPrimitive } from "../../geometry/cylinder.js";
-import { assertMeshAllocationWithinLimits, resolveModelingLimits, } from "../../geometry/model-limits.js";
-import { boxFaceAxes, resolveBoxPrimitive, resolveSpherePrimitive, resolveTorusPrimitive, resolveTubePrimitive, } from "../../geometry/primitive-resolvers.js";
+import { assertMeshAllocationWithinLimits, resolveModelingLimits, } from "../../geometry/limits.js";
+import { resolveCylinderPrimitive } from "../../geometry/primitives/cylinder.js";
+import { boxFaceAxes, resolveBoxPrimitive, resolveSpherePrimitive, resolveTorusPrimitive, resolveTubePrimitive, } from "../../geometry/primitives/resolvers.js";
 import { ownScopedManifoldValue, scopedManifoldModule, } from "./context.js";
 import { transform } from "./transforms.js";
 const meshBudget = (vertices, triangles, operation, limits) => assertMeshAllocationWithinLimits(vertices, triangles, 12 * (vertices + triangles), operation, resolveModelingLimits(limits));

package/dist/engine/native/scoped-threads.js

@@ -1,18 +1,10 @@
 import { scopedManifoldModule, scopedManifoldScope, trackScopedManifoldValue, } from "./context.js";
-import { internalThreadCutterSolid, preflightInternalThreadCutterSolid, preflightThreadedNutSolid, preflightThreadedRodSolid, threadedNutSolid, threadedRodSolid, threadRidgeSolid, } from "./threads.js";
+import { internalThreadCutterSolid, threadedNutSolid, threadedRodSolid, threadRidgeSolid, } from "./threads.js";
 /** Converts a runtime-neutral helical ridge mesh into a context-owned Manifold. */
 export function threadRidge(context, options) {
     const solid = threadRidgeSolid(scopedManifoldModule(context), options, scopedManifoldScope(context));
     return trackScopedManifoldValue(context, solid);
 }
-/** Preflights the exact compensated direct mesh used by {@link threadedRod}. */
-export function preflightThreadedRod(options) {
-    return preflightThreadedRodSolid(options);
-}
-/** Preflights the exact extended mesh used by {@link internalThreadCutter}. */
-export function preflightInternalThreadCutter(options) {
-    return preflightInternalThreadCutterSolid(options);
-}
 /** Creates a compensated context-owned external threaded rod along +Z. */
 export function threadedRod(context, options) {
     const solid = threadedRodSolid(scopedManifoldModule(context), options, scopedManifoldScope(context));
@@ -23,10 +15,6 @@ export function internalThreadCutter(context, options) {
     const solid = internalThreadCutterSolid(scopedManifoldModule(context), options, scopedManifoldScope(context));
     return trackScopedManifoldValue(context, solid);
 }
-/** Preflights a nut's exact body, cutter, and chamfer geometry without WASM allocation. */
-export function preflightThreadedNut(options) {
-    return preflightThreadedNutSolid(options);
-}
 /** Creates a context-owned nut body and subtracts its compensated internal thread. */
 export function threadedNut(context, options) {
     const solid = threadedNutSolid(scopedManifoldModule(context), options, scopedManifoldScope(context));

package/dist/engine/native/threads.js

@@ -1,7 +1,7 @@
-import { threadRidgeMesh, threadSolidMesh } from "../../geometry/mechanical/index.js";
+import { threadRidgeMesh, threadSolidMesh } from "../../geometry/mechanical/threads/mesh.js";
 import { resolveCompensatedThreadSolidMesh, resolveThreadedNutSolid, } from "../../geometry/mechanical/threads/solids.js";
 import { triangleMeshToManifold } from "./adapter.js";
-export { preflightThreadedRodSolid, preflightInternalThreadCutterSolid, preflightThreadedNutSolid, } from "../../geometry/mechanical/threads/solids.js";
+export {} from "../../geometry/mechanical/threads/solids.js";
 /** Converts the runtime-neutral ridge mesh into a scope-owned Manifold solid. */
 export function threadRidgeSolid(module, options, scope) {
     return triangleMeshToManifold(module, threadRidgeMesh(options), scope);

package/dist/engine/native/transforms.js

@@ -1,5 +1,5 @@
-import { attachmentTransform3 } from "../../geometry/anchors.js";
 import { GeometryError } from "../../geometry/errors.js";
+import { attachmentTransform3 } from "../../geometry/transforms/anchors.js";
 import { assertScopedManifoldValue, ownScopedManifoldValue, } from "./context.js";
 const finiteVector = (value, name, operation) => {
     if (!value.every(Number.isFinite)) {
@@ -110,5 +110,5 @@ export function attach(context, solid, source, target, options = {}) {
         ...(options.gap === undefined ? {} : { gap: options.gap }),
         ...(options.spin === undefined ? {} : { spin: options.spin }),
         ...(options.tolerance === undefined ? {} : { tolerance: options.tolerance }),
-    }));
+    }).toData());
 }

package/dist/engine/operations/construction.js

@@ -1,22 +1,23 @@
-import { edgeTreatmentSetbacks } from "../../geometry/edge-finishing.js";
 import { GeometryError } from "../../geometry/errors.js";
-import { resolveExtrusionContourDivisions, resolveExtrusionControls, } from "../../geometry/extrusion.js";
-import { heightfieldMesh } from "../../geometry/heightfield.js";
+import { resolveExtrusionContourSlices, resolveExtrusionControls, } from "../../geometry/extrusion/controls.js";
 import { immutableMeshView } from "../../geometry/immutable-buffer.js";
+import { assertMeshAllocationWithinLimits, resolveModelingLimits } from "../../geometry/limits.js";
 import { vector2Data, vector3Data } from "../../geometry/math/vector-value.js";
-import { assertMeshAllocationWithinLimits } from "../../geometry/model-limits.js";
-import { path3InputData } from "../../geometry/paths/path-value.js";
-import { assertPrimitiveOptions } from "../../geometry/primitive-resolvers.js";
-import { matchProfiles } from "../../geometry/profiles/match-profiles.js";
-import { resolveGeometryResolution } from "../../geometry/resolution.js";
-import { assertSamplingCount } from "../../geometry/sampling-limits.js";
-import { sweepMesh } from "../../geometry/sweeps/sweep-mesh.js";
+import { heightfieldMesh } from "../../geometry/mesh/heightfield.js";
+import { path3InputData } from "../../geometry/paths/value.js";
+import { edgeTreatmentSetbacks } from "../../geometry/primitives/edges.js";
+import { assertPrimitiveOptions } from "../../geometry/primitives/resolvers.js";
+import { assertSamplingCount } from "../../geometry/sampling/limits.js";
+import { resolveGeometryResolution } from "../../geometry/sampling/resolution.js";
+import { sweepMesh } from "../../geometry/sweep/mesh.js";
+import { validateSweepOptions, validateSweepTransformOptions, } from "../../geometry/sweep/orientation.js";
+import { isSweepTransformRoute, sweepTransforms } from "../../geometry/sweep/transforms.js";
 import { triangleMeshToManifold } from "../native/adapter.js";
 import { ownScopedManifoldValue, scopedManifoldScope, trackScopedManifoldValue, } from "../native/context.js";
 import * as kernel from "../native/index.js";
 import { buildFinishedExtrusion } from "./extrusion-finishing.js";
 import { createLoftOperation } from "./loft.js";
-import { buildProfileSweepMesh } from "./primitives/profile-mesh.js";
+import { buildProfileLoftMesh, buildProfileSweepMesh } from "./primitives/profile-mesh.js";
 /** Internal host-bound construction operations. */
 export function createConstructionOperations(environment, sections) {
     const { module, scope, limits, assertActive, throwGeometryError, resolveHandle, nativeSolid, nativeSection, wrapSolid, wrapSection, ownSolid, ownSection, validateFiniteNumber, requirePositiveNumber, validateCoordinates, assertOperandCount, assertMeshAllocation, withResolutionDefaults, resolveCircularSegments, } = environment;
@@ -56,26 +57,67 @@ export function createConstructionOperations(environment, sections) {
         }
         assertSamplingCount(native.numVert(), "extrude", resolved.limits.maxProfilePoints);
         const controls = resolveExtrusionControls(value.height, resolved, "extrude");
-        let divisions = value.divisions;
-        if (divisions === undefined) {
+        if (controls.scales[0] === 0 && native.numContour() > 1)
+            throwGeometryError("INVALID_TOPOLOGY", "extrude", "An extrusion apex requires one simple boundary without holes or disconnected components.");
+        let slices = value.slices;
+        if (slices === undefined) {
             const policy = resolveGeometryResolution(resolved.resolution, resolved.limits);
             // Untwisted uniform taper has planar sides. Its default two-cap topology
             // needs no native contour extraction or longitudinal interpolation.
             if (controls.twist === 0 &&
                 controls.scales[0] === controls.scales[1] &&
                 policy.maxSegmentLength === undefined)
-                divisions = 0;
+                slices = 1;
             else {
                 const profile = corresponding(handle) ? handle : sectionProfile(handle);
-                divisions = resolveExtrusionContourDivisions(profile.components.flatMap((component) => [component.outer, ...component.holes].map((contour) => contour.points)), value.height, resolved);
+                slices = resolveExtrusionContourSlices(profile.components.flatMap((component) => [component.outer, ...component.holes].map((contour) => contour.points)), value.height, resolved);
             }
         }
-        const vertices = native.numVert() * (divisions + 2), 
+        const vertices = native.numVert() * (slices + 1), 
         // A connected extrusion has T = 2V + 4H - 4. Treating every extra contour as
         // a hole also bounds disconnected Sections, without extracting native point data.
         triangles = Math.max(0, vertices * 2 + 4 * native.numContour() - 8);
         assertMeshAllocationWithinLimits(vertices, triangles, vertices * 12 + triangles * 12, "extrude", resolved.limits);
-        return ownSolid(native.extrude(value.height, divisions, controls.twist, controls.scales, controls.center));
+        if (controls.twist !== 0 && controls.scales[0] !== controls.scales[1]) {
+            // Manifold scales its world XY axes after twisting. The authored contract scales
+            // profile-local axes first, so only this mixed case needs explicit corresponding rows.
+            const profile = corresponding(handle) ? handle : sectionProfile(handle);
+            let pointCount = 0, contourCount = 0;
+            for (const component of profile.components)
+                for (const contour of [component.outer, ...component.holes]) {
+                    pointCount += contour.points.length;
+                    contourCount++;
+                }
+            // Native contours can simplify repeated landmarks. These rows retain every logical
+            // slot, so bound their actual allocation before transforming any profile coordinates.
+            assertSamplingCount(pointCount, "extrude", resolved.limits.maxProfilePoints);
+            const retainedVertices = pointCount * (slices + 1), retainedTriangles = 2 * retainedVertices + 4 * contourCount;
+            assertMeshAllocationWithinLimits(retainedVertices, retainedTriangles, 12 * (retainedVertices + retainedTriangles), "extrude", resolved.limits);
+            const stations = Array.from({ length: slices + 1 }, (_, index) => {
+                const t = index / slices, angle = ((controls.twist * Math.PI) / 180) * t;
+                const c = Math.cos(angle), s = Math.sin(angle);
+                const sx = 1 + (controls.scales[0] - 1) * t, sy = 1 + (controls.scales[1] - 1) * t;
+                const contour = (value) => ({
+                    ...value,
+                    points: value.points.map(([x, y]) => [
+                        x * sx * c - y * sy * s,
+                        x * sx * s + y * sy * c,
+                    ]),
+                });
+                return {
+                    z: value.height * (controls.center ? t - 0.5 : t),
+                    profile: {
+                        components: profile.components.map((component) => ({
+                            ...component,
+                            outer: contour(component.outer),
+                            holes: component.holes.map(contour),
+                        })),
+                    },
+                };
+            });
+            return solidFromMesh(buildProfileLoftMesh(module, stations, resolved.limits));
+        }
+        return ownSolid(native.extrude(value.height, slices - 1, controls.twist, controls.scales, controls.center));
     };
     const applyBoolean = (values, operation) => {
         assertOperandCount(values, operation);
@@ -83,10 +125,10 @@ export function createConstructionOperations(environment, sections) {
         if (natives.some((native) => native.kind !== kind))
             throwGeometryError("INVALID_ARGUMENT", operation, "Boolean operands must have the same dimensionality.");
         if (kind === "solid") {
-            const solids = values.map((value) => nativeSolid(value));
+            const solids = natives.map((native) => native.value);
             return wrapSolid(operation === "union" ? kernel.union(scope, solids) : kernel.intersect(scope, solids));
         }
-        const sections = values.map((value) => nativeSection(value));
+        const sections = natives.map((native) => native.value);
         return ownSection(operation === "union"
             ? module.CrossSection.union(sections)
             : module.CrossSection.intersection(sections));
@@ -99,10 +141,10 @@ export function createConstructionOperations(environment, sections) {
         if (cutters.length === 0)
             return value;
         return native.kind === "solid"
-            ? wrapSolid(kernel.subtract(scope, native.value, cutters.map((cutter) => nativeSolid(cutter))))
+            ? wrapSolid(kernel.subtract(scope, native.value, natives.map((cutter) => cutter.value)))
             : ownSection(module.CrossSection.difference([
                 native.value,
-                ...cutters.map((cutter) => nativeSection(cutter)),
+                ...natives.map((cutter) => cutter.value),
             ]));
     });
     const solidFromMesh = (input) => {
@@ -204,14 +246,22 @@ export function createConstructionOperations(environment, sections) {
             return ownSolid(native.revolve(sweepSegments, degrees));
         },
         loft: createLoftOperation(environment, solidFromMesh),
-        matchProfiles: (profiles, value = {}) => {
-            assertActive();
-            return matchProfiles(profiles, withResolutionDefaults(value));
-        },
-        sweep: (shape, path, value = {}) => {
+        sweep: (shape, route, value = {}) => {
             assertActive();
+            if (isSweepTransformRoute(route)) {
+                validateSweepTransformOptions(value);
+                const selectedLimits = resolveModelingLimits(value.limits, limits);
+                const closed = value.closed ?? false;
+                const transforms = sweepTransforms(route, closed, selectedLimits);
+                const profile = corresponding(shape) ? shape : sectionProfile(shape);
+                assertSamplingCount(profile.components.reduce((count, component) => count +
+                    component.outer.points.length +
+                    component.holes.reduce((sum, hole) => sum + hole.points.length, 0), 0), "sweep", selectedLimits.maxSweepProfilePoints);
+                return solidFromMesh(buildProfileLoftMesh(module, transforms.map((transform) => ({ profile, transform })), selectedLimits, closed));
+            }
+            validateSweepOptions(value);
             const defaults = withResolutionDefaults(value);
-            const data = path3InputData(path, value.closed, defaults.limits);
+            const data = path3InputData(route, value.closed, defaults.limits);
             const selected = { ...defaults, closed: data.closed };
             if (corresponding(shape))
                 return solidFromMesh(buildProfileSweepMesh(module, shape, data.points, selected, selected.limits));

package/dist/engine/operations/context.js

@@ -1,10 +1,11 @@
-import { resolveGeometryResolution } from "../../geometry/resolution.js";
+import { resolveGeometryResolution, } from "../../geometry/sampling/resolution.js";
 import { createConstructionOperations } from "./construction.js";
+import { createCutterOperations } from "./cutters.js";
 import { createOperationEnvironment } from "./environment.js";
 import { createHoleCutterOperation } from "./hole-cutter.js";
 import { createInspectionOperations } from "./inspection.js";
+import { createJoinOperation } from "./join.js";
 import { createMechanicalOperations } from "./mechanical.js";
-import { createPatternOperations } from "./patterns.js";
 import { createPrimitiveOperations } from "./primitives/construction.js";
 import { createSectionOperations } from "./sections.js";
 import { createTransformOperations } from "./transforms.js";
@@ -14,8 +15,8 @@ export function createModelingContext(owner, initialResolution) {
         const environment = createOperationEnvironment(owner, resolution);
         const transforms = createTransformOperations(environment);
         const sections = createSectionOperations(environment, transforms);
-        const primitives = createPrimitiveOperations(environment, transforms, sections);
         const construction = createConstructionOperations(environment, sections);
+        const primitives = createPrimitiveOperations(environment, transforms, sections, construction);
         const mechanical = createMechanicalOperations(environment, {
             cylinder: primitives.cylinder,
             box: primitives.box,
@@ -28,7 +29,6 @@ export function createModelingContext(owner, initialResolution) {
             translate: transforms.operations.translate,
             subtract: construction.subtract,
         });
-        const patterns = createPatternOperations(environment, transforms);
         const inspection = createInspectionOperations(environment);
         return Object.freeze({
             withResolution: (value) => {
@@ -39,15 +39,24 @@ export function createModelingContext(owner, initialResolution) {
             ...sections,
             ...primitives,
             ...construction,
+            join: createJoinOperation(environment),
             holeCutter: createHoleCutterOperation(environment, {
                 cylinder: primitives.cylinder,
                 extrude: construction.extrude,
                 loft: construction.loft,
                 translate: transforms.operations.translate,
-                union: construction.union,
             }),
+            ...createCutterOperations(environment, {
+                polygon: sections.polygon,
+                extrude: construction.extrude,
+                box: primitives.box,
+                cylinder: primitives.cylinder,
+                sphere: primitives.sphere,
+                subtract: construction.subtract,
+                translate: transforms.operations.translate,
+                hull: construction.hull,
+            }, transforms),
             ...mechanical,
-            ...patterns,
             ...inspection,
             anchor: owner.anchor,
             withAnchors: owner.withAnchors,