@metamesh/modeling 0.16.0 → 0.18.0

package/dist/engine/finalization.js

@@ -1,16 +1,11 @@
 import { GeometryError } from "../geometry/errors.js";
+import { immutableMeshView, isImmutableBuffer, } from "../geometry/immutable-buffer.js";
 import { optimizePlanarPatches } from "../geometry/mesh/mesh-planar.js";
 import { validateAnalyzedSolidMesh } from "../geometry/mesh/mesh-solid.js";
 import { analyzeTriangleMesh, } from "../geometry/mesh/mesh.js";
-import { immutableMeshView } from "../model/immutable-buffer.js";
 import { MeshViewCache } from "./mesh-view-cache.js";
 import { copiedMeshViews, copiedUint32Array } from "./native/copied-views.js";
 const isArray = (value) => Array.isArray(value);
-const snapshotMeshes = new WeakMap();
-/** Registers trusted snapshot storage without exposing its shared backing arrays publicly. */
-export function rememberSnapshotPart(part, mesh) {
-    snapshotMeshes.set(part, mesh);
-}
 function fitsGeometryLimits(mesh, limits) {
     const buffers = new Set([mesh.positions.buffer, mesh.indices.buffer]);
     let bytes = 0;
@@ -96,12 +91,15 @@ export function captureExportParts(parts, limits) {
     const captured = parts.map((part) => {
         if (typeof part !== "object" || part === null)
             throw new GeometryError("INVALID_ARGUMENT", "Export part IDs must be unique canonical identifiers.", { operation: "export3mf" });
-        // Access public owned-copy getters exactly once, or retain trusted private sharing for a
-        // snapshot created by this engine. Capture still copies before the asynchronous boundary.
-        const mesh = snapshotMeshes.get(part) ?? { positions: part.positions, indices: part.indices };
+        // Trusted immutable storage can outlive the asynchronous export directly. Mutable external
+        // input is captured once below, preserving shared backing buffers before the first await.
+        const { positions, indices } = part;
+        const immutable = isImmutableBuffer(positions) && isImmutableBuffer(indices);
+        const mesh = immutableMeshView({ positions, indices });
         const id = part.id, color = part.color;
         return {
             id,
+            immutable,
             positions: mesh.positions,
             indices: mesh.indices,
             ...(color === undefined ? {} : { color }),
@@ -149,7 +147,9 @@ export function captureExportParts(parts, limits) {
     const copiedBuffers = new Map();
     return captured.map((part) => ({
         id: part.id,
-        ...copiedMeshViews(part, copiedBuffers),
+        ...(part.immutable
+            ? { positions: part.positions, indices: part.indices }
+            : copiedMeshViews(part, copiedBuffers)),
         ...(part.color === undefined ? {} : { color: part.color }),
     }));
 }

package/dist/engine/index.js

@@ -1,23 +1,26 @@
 import { GeometryError } from "../geometry/errors.js";
 import { defaultModelingLimits, resolveModelingLimits } from "../geometry/model-limits.js";
 import { createExecutionContext } from "./execution.js";
-import { captureExportParts } from "./finalization.js";
 import createManifoldModule from "./kernel/manifold.js";
 import { withManifoldScope } from "./native/context.js";
-import { createSession } from "./session.js";
+import { createSession } from "./session/session.js";
 export { defaultModelingLimits };
+export { export3mf } from "./export-3mf.js";
 /** URL of the package's pinned WASM asset; browser bundlers may replace it with their emitted URL. */
 export const modelingWasmUrl = new URL("./kernel/manifold.wasm", import.meta.url).href;
 /**
  * Runs declaration and immediate assertions without initializing a kernel or finalizing parts.
- * Geometry observations require an initialized session's `validate` method instead.
+ * Returns reached assertion errors and warnings; unexpected execution failures throw.
+ * Returned geometry is not realized or validated.
+ * Geometry observations require an initialized session's `check` method instead.
  */
-export function validateModel(program, params, ...settings) {
-    const session = createSession(program, settings[0] ?? {}, defaultModelingLimits, (_options, callback) => callback(() => {
-        throw new GeometryError("INVALID_ARGUMENT", "Geometry observations require an initialized model session.", { operation: "validateModel", details: { requiresKernel: true } });
+export function checkModel(program, ...args) {
+    const [parameters, options] = args;
+    const session = createSession(program, options ?? {}, defaultModelingLimits, (_options, callback) => callback(() => {
+        throw new GeometryError("INVALID_ARGUMENT", "Geometry observations require an initialized model session.", { operation: "checkModel", details: { requiresKernel: true } });
     }));
     try {
-        return session.validate(params);
+        return session.check(...[parameters]);
     }
     finally {
         session.dispose();
@@ -26,20 +29,16 @@ export function validateModel(program, params, ...settings) {
 /** Serializes operations over one initialized kernel; sessions own their caches. */
 function engineFromModule(module, engineLimits) {
     let building = false;
-    return Object.freeze({
+    const engine = Object.freeze({
         limits: engineLimits,
-        async export3mf(parts, options = {}) {
-            if (building)
-                throw new GeometryError("INVALID_ARGUMENT", "An engine cannot export during another operation.", { operation: "export3mf" });
-            const snapshot = captureExportParts(parts, engineLimits);
-            const snapshotOptions = { ...options };
-            building = true;
+        run(program, ...args) {
+            const [parameters, options] = args;
+            const session = createSessionForRun(program, { ...options, cache: false });
             try {
-                const { meshesTo3mf } = await import("./export-3mf.js");
-                return meshesTo3mf(snapshot, snapshotOptions);
+                return session.run(...[parameters]);
             }
             finally {
-                building = false;
+                session.dispose();
             }
         },
         createSession(program, ...settings) {
@@ -51,8 +50,8 @@ function engineFromModule(module, engineLimits) {
                 const limits = resolveModelingLimits(options.limits, engineLimits);
                 building = true;
                 try {
-                    // The trusted finalizer captures only copied manufacturing buffers. Its snapshot has
-                    // owned-copy accessors, so publish it after the native scope's structural escape check.
+                    // The trusted finalizer captures geometry outside native ownership. Publish its
+                    // immutable storage only after the native scope's structural escape check.
                     let captured;
                     withManifoldScope(module, (scope) => {
                         let execution;
@@ -71,6 +70,10 @@ function engineFromModule(module, engineLimits) {
             });
         },
     });
+    return engine;
+    function createSessionForRun(program, options) {
+        return engine.createSession(program, ...[options]);
+    }
 }
 /**
  * Initializes one host kernel and returns a lifecycle-safe engine. No generator initializes WASM.
@@ -78,21 +81,12 @@ function engineFromModule(module, engineLimits) {
  * @example Build a box in a host application
  * ```ts
  * import { box, generate } from "@metamesh/modeling";
- * import { createModelEngine } from "@metamesh/modeling/engine";
+ * import { createModelEngine, export3mf } from "@metamesh/modeling/engine";
  *
  * const engine = await createModelEngine();
  * const model = generate<Record<never, never>>(({ part }) => [part("body", box({ size: [30, 20, 8] }))]);
- * const session = engine.createSession(model);
- * try {
- *   const snapshot = session.run({});
- *   try {
- *     await engine.export3mf(snapshot.parts);
- *   } finally {
- *     snapshot.dispose();
- *   }
- * } finally {
- *   session.dispose();
- * }
+ * const result = engine.run(model);
+ * await export3mf(result.parts);
  * ```
  */
 export async function createModelEngine(options = {}) {

package/dist/engine/model-parts.js

@@ -0,0 +1,8 @@
+import { GeometryError } from "../geometry/errors.js";
+/** Resolves an exact semantic ID without changing output order or retaining another index. */
+export function requireModelPart(parts, id) {
+    const part = parts.find((part) => part.id === id);
+    if (part !== undefined)
+        return part;
+    throw new GeometryError("INVALID_ARGUMENT", `Model has no part ${JSON.stringify(id)}. Available parts: ${parts.map((part) => part.id).join(", ")}.`, { operation: "part", details: { partId: id } });
+}

package/dist/engine/model-summary.js

@@ -1,7 +1,7 @@
 import { GeometryError } from "../geometry/errors.js";
 /** Counts manufacturing instances while charging shared backing storage only once. */
 export function createModelSummary(limits) {
-    let vertices = 0, triangles = 0, bytes = 0, partCount = 0, volumeMm3 = 0;
+    let vertices = 0, triangles = 0, bytes = 0, partCount = 0, signedVolume = 0;
     const storage = new Set();
     const min = [Infinity, Infinity, Infinity], max = [-Infinity, -Infinity, -Infinity];
     return {
@@ -10,7 +10,7 @@ export function createModelSummary(limits) {
             const measurements = geometry.measurements;
             vertices += measurements.vertexCount;
             triangles += measurements.triangleCount;
-            volumeMm3 += measurements.signedVolume;
+            signedVolume += measurements.signedVolume;
             for (const buffer of [geometry.positions.buffer, geometry.indices.buffer])
                 if (!storage.has(buffer)) {
                     storage.add(buffer);
@@ -35,10 +35,10 @@ export function createModelSummary(limits) {
                     vertexCount: vertices,
                     triangleCount: triangles,
                     byteCount: bytes,
-                    volumeMm3,
+                    signedVolume,
                     buildMs: builtAt - startedAt,
-                    finalizationMs: endedAt - builtAt,
-                    generationMs: endedAt - startedAt,
+                    finalizeMs: endedAt - builtAt,
+                    generateMs: endedAt - startedAt,
                 }),
             };
         },

package/dist/engine/native/index.js

@@ -5,7 +5,7 @@
  */
 export { createScopedManifoldContext, withManifoldScope, } from "./context.js";
 export { box, cylinder, sphere, torus, tube, } from "./scoped-primitives.js";
-export { compose, hull, intersect, minkowskiSum, subtract, union, } from "./operations.js";
+export { hull, intersect, minkowskiSum, subtract, union } from "./operations.js";
 export { attach, mirror, rotate, scale, transform, translate, } from "./transforms.js";
 export { internalThreadCutter, preflightInternalThreadCutter, preflightThreadedNut, preflightThreadedRod, threadRidge, threadedNut, threadedRod, } from "./scoped-threads.js";
 export {} from "./threads.js";

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

@@ -256,8 +256,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 +291,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/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/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,12 +1,13 @@
-import { resolveGeometryResolution } from "../geometry/resolution.js";
-import { createConstructionOperations } from "./construction-operations.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 { 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) => {
@@ -18,6 +19,10 @@ export function createModelingContext(owner, initialResolution) {
         const mechanical = createMechanicalOperations(environment, {
             cylinder: primitives.cylinder,
             box: primitives.box,
+            rectangle: primitives.rectangle,
+            scale: transforms.operations.scale,
+            solidFromMesh: construction.solidFromMesh,
+            loft: construction.loft,
             union: construction.union,
             rotate: transforms.operations.rotate,
             translate: transforms.operations.translate,
@@ -34,6 +39,13 @@ export function createModelingContext(owner, initialResolution) {
             ...sections,
             ...primitives,
             ...construction,
+            holeCutter: createHoleCutterOperation(environment, {
+                cylinder: primitives.cylinder,
+                extrude: construction.extrude,
+                loft: construction.loft,
+                translate: transforms.operations.translate,
+                union: construction.union,
+            }),
             ...mechanical,
             ...patterns,
             ...inspection,

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,9 +1,10 @@
-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 { 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 "./primitives/profile-mesh.js";
 const fail = (message) => {
     throw new GeometryError("INVALID_ARGUMENT", message, { operation: "extrude" });
 };
@@ -19,22 +20,7 @@ export function buildFinishedExtrusion(module, profile, options) {
     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 edges = points.map((point, index) => {
-        const next = points[(index + 1) % points.length], dx = next[0] - point[0], dy = next[1] - point[1];
-        const length = Math.hypot(dx, dy);
-        if (!(length > 0) || !Number.isFinite(length))
-            fail("End treatment contours must have distinct finite vertices.");
-        return [dx / length, dy / length];
-    });
-    const miters = edges.map((edge, index) => {
-        const previous = edges[(index + edges.length - 1) % edges.length];
-        const turn = previous[0] * edge[1] - previous[1] * edge[0];
-        if (!(turn > 1e-12))
-            fail("End treatments require a strictly convex counterclockwise contour without collinear vertices.");
-        const denominator = 1 + previous[0] * edge[0] + previous[1] * edge[1];
-        return [(-previous[1] - edge[1]) / denominator, (previous[0] + edge[0]) / denominator];
-    });
-    const magnification = miters.reduce((maximum, [x, y]) => Math.max(maximum, Math.hypot(x, y)), 1);
+    const { magnification, offset } = convexContourOffsets(points, "extrude");
     const sampling = {
         resolution: options.resolution,
         limits: options.limits,
@@ -58,19 +44,6 @@ export function buildFinishedExtrusion(module, profile, options) {
         ...bottomPoints.map(([inset, depth]) => ({ inset, z: depth })),
         ...[...topPoints].reverse().map(([inset, depth]) => ({ inset, z: options.height - depth })),
     ];
-    const offset = (inset) => {
-        const result = points.map(([x, y], index) => [
-            x + miters[index][0] * inset,
-            y + miters[index][1] * inset,
-        ]);
-        for (let index = 0; index < result.length; index++) {
-            const point = result[index], next = result[(index + 1) % result.length], edge = edges[index];
-            if (!point.every(Number.isFinite) ||
-                !((next[0] - point[0]) * edge[0] + (next[1] - point[1]) * edge[1] > 0))
-                fail("End treatment inset collapses or reverses a contour edge.");
-        }
-        return result;
-    };
     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,