@metamesh/modeling 0.17.0 → 0.19.0

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

@@ -2,6 +2,7 @@ import { GeometryError } from "../../geometry/errors.js";
 import { triangleSolidAngle } from "../../geometry/mesh/mesh-solid-intersections.js";
 import { assertMeshAllocationWithinLimits, } from "../../geometry/model-limits.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;
@@ -256,8 +207,8 @@ export function solidMaterialComponents(scope, solid, limits) {
         return Object.freeze([solid]);
     if (entries.length !== shells.length || orphanedCavity) {
         // Selecting from the original would retain contact sheets inside a sealed cavity.
-        // Rebuild only this exceptional case from its material boundaries. The JS kernel's
-        // compose aliases union, so turn inward shells into positive native cutters instead.
+        // Rebuild only this exceptional case from its material boundaries. Union fills inward
+        // shells, so turn them into positive native cutters instead.
         const cutters = new Map(exteriors.map(({ shell }) => [shell, []]));
         for (const { cavity, parent } of enclosedCavities) {
             // An inward shell removes positive occupancy only inside an exterior. A lone
@@ -291,7 +242,7 @@ export function solidMaterialComponents(scope, solid, limits) {
         if (parent !== undefined)
             children.get(parent.shell).push(exterior.shell);
     }
-    // The JS kernel aliases compose to union, which fills independently supplied inward shells.
+    // Union fills independently supplied inward shells.
     // Select from the original material instead, retaining its native precision and cavity winding.
     return Object.freeze(exteriors.map(({ shell }) => {
         const selected = ownScopedManifoldValue(scope, solid.intersect(shell));

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

@@ -0,0 +1,55 @@
+import { GeometryError } from "../../geometry/errors.js";
+import { assertMeshAllocationWithinLimits, } from "../../geometry/model-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/operations.js

@@ -41,13 +41,6 @@ export function intersect(context, solids) {
         return solids[0];
     return ownScopedManifoldValue(context, scopedManifoldModule(context).Manifold.intersection(solids));
 }
-/** Combines disjoint context-owned solids without resolving overlaps. */
-export function compose(context, solids) {
-    operands(context, solids, "compose");
-    if (solids.length === 1)
-        return solids[0];
-    return ownScopedManifoldValue(context, scopedManifoldModule(context).Manifold.compose(solids));
-}
 /**
  * Creates the scope-owned convex hull of finite XYZ millimetre points or solids.
  *

package/dist/engine/native/regions.js

@@ -82,7 +82,8 @@ export function regionToCrossSection(context, region, limits = {}) {
         return ownScopedManifoldValue(context, module.CrossSection.union([]));
     return ownScopedManifoldValue(context, new module.CrossSection(contoursFromRegion(normalized)));
 }
-const regionFromLoops = (loops) => {
+/** Internal filled-loop classification shared by native Section and exact collar observations. */
+export const regionFromLoops = (loops) => {
     const outers = loops
         .filter((loop) => signedContourArea(loop) > 0)
         .map((outer) => ({ outer: normalizeContour(outer, true), holes: [] }));

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

@@ -90,18 +90,19 @@ export function cylinder(context, options) {
 }
 /** Creates a scope-owned hollow tube along +Z. */
 export function tube(context, options) {
-    resolveTubePrimitive(options);
-    const segments = resolveCylinderPrimitive({ ...options, radius: options.outerRadius }).segments;
+    const { segments, innerVertexRadius, outerVertexRadius } = resolveTubePrimitive(options);
     meshBudget(4 * segments, 8 * segments, "tube", options.limits);
     const outer = cylinder(context, {
         ...options,
-        radius: options.outerRadius,
+        radius: outerVertexRadius,
+        segments,
     });
     const inner = cylinder(context, {
         ...options,
         center: true,
         height: options.height + 0.02,
-        radius: options.innerRadius,
+        radius: innerVertexRadius,
+        segments,
     });
     const positionedInner = options.center === false
         ? ownScopedManifoldValue(context, inner.translate([0, 0, options.height / 2]))

package/dist/engine/native/threads.js

@@ -1,10 +1,10 @@
-import { helicalThreadRidgeMesh, helicalThreadSolidMesh } from "../../geometry/mechanical/index.js";
-import { resolveCompensatedThreadSolidMesh, resolveThreadedNutSolid, } from "../../geometry/mechanical/thread-solids.js";
+import { threadRidgeMesh, threadSolidMesh } from "../../geometry/mechanical/index.js";
+import { resolveCompensatedThreadSolidMesh, resolveThreadedNutSolid, } from "../../geometry/mechanical/threads/solids.js";
 import { triangleMeshToManifold } from "./adapter.js";
-export { preflightThreadedRodSolid, preflightInternalThreadCutterSolid, preflightThreadedNutSolid, } from "../../geometry/mechanical/thread-solids.js";
+export { preflightThreadedRodSolid, preflightInternalThreadCutterSolid, preflightThreadedNutSolid, } 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, helicalThreadRidgeMesh(options), scope);
+    return triangleMeshToManifold(module, threadRidgeMesh(options), scope);
 }
 const compensatedThreadSolid = (module, options, role, scope) => {
     const resolved = resolveCompensatedThreadSolidMesh(options, role);
@@ -12,7 +12,7 @@ const compensatedThreadSolid = (module, options, role, scope) => {
 };
 const compensatedThreadSolidFromResolved = (module, resolved, scope) => {
     const { axialExtension, meshOptions } = resolved;
-    const combined = triangleMeshToManifold(module, helicalThreadSolidMesh(meshOptions), scope);
+    const combined = triangleMeshToManifold(module, threadSolidMesh(meshOptions), scope);
     return axialExtension === 0 ? combined : scope.own(combined.translate([0, 0, -axialExtension]));
 };
 /** Creates a compensated, scope-owned external threaded rod along +Z. */
@@ -30,21 +30,21 @@ export function internalThreadCutterSolid(module, options, scope) {
 /** Creates a scope-owned nut body and subtracts its compensated internal thread. */
 export function threadedNutSolid(module, options, scope) {
     const resolved = resolveThreadedNutSolid(options, "threadedNutSolid");
-    const { bevelBottom, bevelTop, outerRadius } = resolved;
-    const { bodySegments: segments, chamferSize: chamfer } = resolved.preflight;
+    const { outerRadius } = resolved;
+    const { bodySegments: segments, outerBevel: [bottomBevel, topBevel], } = resolved.preflight;
     const bodyParts = [];
-    if (bevelBottom) {
-        bodyParts.push(scope.own(module.Manifold.cylinder(chamfer, outerRadius - chamfer, outerRadius, segments, false)));
+    if (bottomBevel > 0) {
+        bodyParts.push(scope.own(module.Manifold.cylinder(bottomBevel, outerRadius - bottomBevel, outerRadius, segments, false)));
     }
-    const middleStart = bevelBottom ? chamfer : 0;
-    const middleEnd = options.thickness - (bevelTop ? chamfer : 0);
+    const middleStart = bottomBevel;
+    const middleEnd = options.thickness - topBevel;
     if (middleEnd > middleStart) {
         const middle = scope.own(module.Manifold.cylinder(middleEnd - middleStart, outerRadius, outerRadius, segments, false));
         bodyParts.push(middleStart === 0 ? middle : scope.own(middle.translate([0, 0, middleStart])));
     }
-    if (bevelTop) {
-        const top = scope.own(module.Manifold.cylinder(chamfer, outerRadius, outerRadius - chamfer, segments, false));
-        bodyParts.push(scope.own(top.translate([0, 0, options.thickness - chamfer])));
+    if (topBevel > 0) {
+        const top = scope.own(module.Manifold.cylinder(topBevel, outerRadius, outerRadius - topBevel, segments, false));
+        bodyParts.push(scope.own(top.translate([0, 0, options.thickness - topBevel])));
     }
     const body = bodyParts.length === 1 ? bodyParts[0] : scope.own(module.Manifold.union(bodyParts));
     const cutter = compensatedThreadSolidFromResolved(module, resolved.cutter, scope);

package/dist/engine/{construction-operations.js → operations/construction.js}

@@ -1,22 +1,22 @@
-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 { 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/matched.js";
-import { resolveGeometryResolution } from "../geometry/resolution.js";
-import { assertSamplingCount } from "../geometry/sampling-limits.js";
-import { sweepMesh } from "../geometry/sweeps/sweep-mesh.js";
-import { immutableMeshView } from "../model/immutable-buffer.js";
+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 { immutableMeshView } from "../../geometry/immutable-buffer.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 { 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-operations.js";
-import { triangleMeshToManifold } from "./native/adapter.js";
-import { ownScopedManifoldValue, scopedManifoldScope, trackScopedManifoldValue, } from "./native/context.js";
-import * as kernel from "./native/index.js";
-import { buildProfileSweepMesh } from "./profile-mesh.js";
+import { createLoftOperation } from "./loft.js";
+import { 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;
@@ -33,7 +33,10 @@ export function createConstructionOperations(environment, sections) {
         return { normal, offset: validateFiniteNumber(value.offset ?? 0, operation) };
     };
     const fromContours = (contours) => sections.polygon({ contours });
-    const corresponding = (value) => typeof value === "object" && value !== null && "components" in value;
+    const corresponding = (value) => typeof value === "object" &&
+        value !== null &&
+        "components" in value &&
+        Array.isArray(value.components);
     const shapeSection = (shape) => corresponding(shape)
         ? nativeSection(fromContours(shape.components.flatMap((component) => [component.outer, ...component.holes].map((contour) => contour.points))))
         : nativeSection(shape);
@@ -74,7 +77,7 @@ export function createConstructionOperations(environment, sections) {
         assertMeshAllocationWithinLimits(vertices, triangles, vertices * 12 + triangles * 12, "extrude", resolved.limits);
         return ownSolid(native.extrude(value.height, divisions, controls.twist, controls.scales, controls.center));
     };
-    const boolean = (values, operation) => {
+    const applyBoolean = (values, operation) => {
         assertOperandCount(values, operation);
         const natives = values.map(resolveHandle), kind = natives[0].kind;
         if (natives.some((native) => native.kind !== kind))
@@ -109,9 +112,9 @@ export function createConstructionOperations(environment, sections) {
         return wrapSolid(trackScopedManifoldValue(scope, triangleMeshToManifold(module, mesh, scopedManifoldScope(scope))));
     };
     const operations = {
-        union: ((values) => boolean(values, "union")),
+        union: ((values) => applyBoolean(values, "union")),
         subtract,
-        intersect: ((values) => boolean(values, "intersect")),
+        intersect: ((values) => applyBoolean(values, "intersect")),
         split: (solid, cutter) => {
             const results = nativeSolid(solid).split(nativeSolid(cutter));
             return Object.freeze([ownSolid(results[0]), ownSolid(results[1])]);
@@ -122,7 +125,6 @@ export function createConstructionOperations(environment, sections) {
             const results = native.splitByPlane(plane.normal, plane.offset);
             return Object.freeze([ownSolid(results[0]), ownSolid(results[1])]);
         },
-        compose: (values) => wrapSolid(kernel.compose(scope, values.map(nativeSolid))),
         hull: ((value) => {
             assertActive();
             assertPrimitiveOptions(value, "hull");

package/dist/engine/{modeling-context.js → operations/context.js}

@@ -1,13 +1,14 @@
-import { resolveGeometryResolution } from "../geometry/resolution.js";
-import { createConstructionOperations } from "./construction-operations.js";
-import { createHoleCutterOperation } from "./hole-cutter-operation.js";
-import { createInspectionOperations } from "./inspection-operations.js";
-import { createMechanicalOperations } from "./mechanical-operations.js";
-import { createOperationEnvironment } from "./operation-environment.js";
-import { createPatternOperations } from "./pattern-operations.js";
-import { createPrimitiveOperations } from "./primitive-operations.js";
-import { createSectionOperations } from "./section-operations.js";
-import { createTransformOperations } from "./transform-operations.js";
+import { resolveGeometryResolution } from "../../geometry/resolution.js";
+import { createConstructionOperations } from "./construction.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";
 /** Composes bound families over one execution owner and immutable local resolution. */
 export function createModelingContext(owner, initialResolution) {
     const make = (resolution) => {
@@ -39,6 +40,7 @@ export function createModelingContext(owner, initialResolution) {
             ...sections,
             ...primitives,
             ...construction,
+            join: createJoinOperation(environment),
             holeCutter: createHoleCutterOperation(environment, {
                 cylinder: primitives.cylinder,
                 extrude: construction.extrude,

package/dist/engine/{operation-environment.js → 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/model-limits.js";
+import { resolveCircularPrimitiveSegments } from "../../geometry/primitive-resolution.js";
 /** Applies explicit resolution inheritance once for this bound context. */
 export function createOperationEnvironment(owner, resolution) {
     const withResolutionDefaults = (value) => {

package/dist/engine/{extrusion-finishing.js → operations/extrusion-finishing.js}

@@ -1,14 +1,14 @@
-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 { buildProfileLoftMesh } from "./profile-mesh.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 { planRegionOffsets } from "../../geometry/region-offset.js";
+import { assertSamplingCount } from "../../geometry/sampling-limits.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. */
+/** Finishes every material rim through one source-corresponding regular offset family. */
 export function buildFinishedExtrusion(module, profile, options) {
     const controls = resolveExtrusionControls(options.height, options, "extrude");
     if (controls.twist !== 0 ||
@@ -17,15 +17,6 @@ export function buildFinishedExtrusion(module, profile, options) {
         fail("End treatments require a straight extrusion without twist, top scaling or divisions.");
     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,10 +24,23 @@ 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 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 rowCount = (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;
+    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 vertexCount = rowCount * pointCount, triangleCount = 2 * vertexCount + 4 * contourCount;
     assertMeshAllocationWithinLimits(vertexCount, triangleCount, 12 * (vertexCount + triangleCount), "extrude", options.limits);
     const bottomPoints = bottom === undefined ? [[0, 0]] : sampleEdgeTreatment(bottom, "extrude", sampling);
     const topPoints = top === undefined ? [[0, 0]] : sampleEdgeTreatment(top, "extrude", sampling);
@@ -44,12 +48,9 @@ export function buildFinishedExtrusion(module, profile, options) {
         ...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 }) => ({
         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/{hole-cutter-operation.js → operations/hole-cutter.js}

@@ -1,6 +1,6 @@
-import { convexContourOffsets } from "../geometry/convex-offset.js";
-import { GeometryError } from "../geometry/errors.js";
-import { assertPrimitiveOptions } from "../geometry/primitive-resolvers.js";
+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. */
 export function createHoleCutterOperation(environment, operations) {
     return (options) => {

package/dist/engine/{inspection-operations.js → operations/inspection.js}

@@ -1,13 +1,13 @@
-import { vector3Data } from "../geometry/math/vector-value.js";
-import { ownScopedManifoldValue } from "./native/context.js";
-import { copiedMeshViews } from "./native/copied-views.js";
-import { measureSolidDistance } from "./native/distance.js";
-import { assertNativeSolidStatus } from "./native/status.js";
+import { vector3Data } from "../../geometry/math/vector-value.js";
+import { ownScopedManifoldValue } from "../native/context.js";
+import { copiedMeshViews } from "../native/copied-views.js";
+import { measureSolidDistance } from "../native/distance.js";
+import { assertNativeSolidStatus } from "../native/status.js";
 /** Internal host-bound inspection operations. */
 export function createInspectionOperations(environment) {
     const { scope, throwGeometryError, nativeSolid, resolveHandle, ownSolid, ownSection, wrapSolid, wrapSection, validateFiniteNumber, requirePositiveNumber, validateCoordinates, analyzedMeshFor, solidInspectionFor, sectionInspectionFor, solidComponentsFor, sectionComponentsFor, } = environment;
     const operations = {
-        toTriangleMesh: (value) => copiedMeshViews(analyzedMeshFor(value).mesh, new Map()),
+        toMesh: (value) => copiedMeshViews(analyzedMeshFor(value).mesh, new Map()),
         inspectSection: sectionInspectionFor,
         inspectSolid: solidInspectionFor,
         isEmpty: (handle) => {

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

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