@metamesh/modeling 0.16.0 → 0.18.0

package/dist/geometry/convex-offset.js

@@ -0,0 +1,41 @@
+import { GeometryError } from "./errors.js";
+/** @internal Parallel-edge offsets shared by convex extrusion rims and pocket entries. */
+export function convexContourOffsets(points, operation) {
+    const fail = (message) => {
+        throw new GeometryError("INVALID_ARGUMENT", message, { operation });
+    };
+    if (points.length < 3)
+        fail("A convex contour needs at least three vertices.");
+    const edges = points.map((point, index) => {
+        const next = points[(index + 1) % points.length];
+        const dx = next[0] - point[0], dy = next[1] - point[1];
+        const length = Math.hypot(dx, dy);
+        if (!(length > 0) || !Number.isFinite(length))
+            fail("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("Entry and 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];
+    });
+    return {
+        magnification: miters.reduce((maximum, [x, y]) => Math.max(maximum, Math.hypot(x, y)), 1),
+        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("Treatment offset collapses or reverses a contour edge.");
+            }
+            return result;
+        },
+    };
+}

package/dist/geometry/heightfield.js

@@ -1,4 +1,5 @@
 import { GeometryError } from "./errors.js";
+import { vector2Data } from "./math/vector-value.js";
 import { validateTriangleMesh } from "./mesh/mesh.js";
 import { assertMeshAllocationWithinLimits, resolveModelingLimits, } from "./model-limits.js";
 import { writeMeshVertex } from "./numeric.js";
@@ -33,21 +34,18 @@ function planHeightfield(options, limits) {
         yAt = (index) => coordinates.y[index];
     }
     else {
-        if (!Array.isArray(options.size) ||
-            options.size.length !== 2 ||
-            !options.size.every((value) => Number.isFinite(value) && value > 0) ||
+        const size = vector2Data(options.size);
+        const origin = options.origin === undefined ? undefined : vector2Data(options.origin);
+        if (!size.every((value) => Number.isFinite(value) && value > 0) ||
             !Array.isArray(options.segments) ||
             options.segments.length !== 2 ||
             !options.segments.every((value) => Number.isSafeInteger(value) && value > 0) ||
-            (options.origin !== undefined &&
-                (!Array.isArray(options.origin) ||
-                    options.origin.length !== 2 ||
-                    !options.origin.every(Number.isFinite)))) {
+            (origin !== undefined && !origin.every(Number.isFinite))) {
             throw new GeometryError("INVALID_ARGUMENT", "Uniform heightfields need a finite positive footprint, integer intervals, and finite origin.", { operation });
         }
         [x, y] = options.segments;
-        const [width, depth] = options.size;
-        const [originX, originY] = options.origin ?? [-width / 2, -depth / 2];
+        const [width, depth] = size;
+        const [originX, originY] = origin ?? [-width / 2, -depth / 2];
         xAt = (index) => originX + (width * index) / x;
         yAt = (index) => originY + (depth * index) / y;
     }
@@ -84,7 +82,7 @@ function planHeightfield(options, limits) {
  * Successful preflight leaves height values, Float32 base storage, and generated mesh validity to
  * construction. `byteCount` covers position and index buffers, not total working memory.
  *
- * @see {@link heightfieldMesh}
+ * @see `mesh.heightfield`
  */
 export function preflightHeightfield(options, limits = {}) {
     return planHeightfield(options, limits).facts;
@@ -96,11 +94,11 @@ export function preflightHeightfield(options, limits = {}) {
  * Top winding is +Z, the base is -Z, and sides face outward. Coordinates and heights must fit
  * Float32 storage. Explicit axes are captured before sampling; shared wall vertices prevent cracks.
  *
- * @see {@link preflightHeightfield}
+ * @see `mesh.preflightHeightfield`
  *
  * @example Sample a closed wavy mesh
  * ```ts
- * heightfieldMesh({
+ * mesh.heightfield({
  *   size: [30, 20], segments: [24, 16],
  *   height: ([x, y]) => 3 + Math.cos(x / 5) * Math.cos(y / 5),
  * });

package/dist/{model → geometry}/immutable-buffer.js

@@ -1,6 +1,7 @@
 const constructors = { Float32Array, Float64Array, Uint32Array, Uint8Array, Int32Array };
-const protocol = Symbol.for("@metamesh/modeling/immutable-buffer/1");
+const protocol = Symbol.for("@metamesh/modeling/immutable-buffer/2");
 const storage = new WeakMap();
+const ownedBuffers = new WeakMap();
 const adopted = new WeakMap();
 /**
  * Copies numeric data once into private storage. This pure helper needs no active generation.
@@ -10,6 +11,7 @@ const adopted = new WeakMap();
  * const heights = immutableBuffer(new Float32Array([2, 4, 6]));
  * const count = heights.length;
  * const first = heights.at(0);
+ * const doubled = Array.from(heights, (height) => height * 2);
  * const editable = heights.copy();
  * editable[0] = 8; // heights still contains 2, 4, 6.
  * ```
@@ -18,8 +20,19 @@ export function immutableBuffer(source) {
     const entry = Object.entries(constructors).find(([, constructor]) => source instanceof constructor);
     if (entry === undefined)
         throw new TypeError("immutableBuffer requires a supported numeric typed array.");
-    const [kind, constructor] = entry;
+    const constructor = entry[1];
     const owned = new constructor(source);
+    return ownImmutableBuffer(owned);
+}
+/** Wraps storage whose exclusive mutable ownership has already been captured by the host. */
+export function ownImmutableBuffer(owned) {
+    const previous = ownedBuffers.get(owned);
+    if (previous !== undefined)
+        return previous;
+    const entry = Object.entries(constructors).find(([, constructor]) => owned instanceof constructor);
+    if (entry === undefined)
+        throw new TypeError("Unsupported owned numeric storage.");
+    const [kind, constructor] = entry;
     const length = owned.length;
     const result = Object.freeze({
         [protocol]: kind,
@@ -29,18 +42,20 @@ export function immutableBuffer(source) {
             return Number.isInteger(offset) && offset >= 0 && offset < length ? owned[offset] : undefined;
         },
         copy: () => new constructor(owned),
+        [Symbol.iterator]: () => owned.values(),
     });
     storage.set(result, owned);
+    ownedBuffers.set(owned, result);
     return result;
 }
 /**
  * Copies mesh buffers into immutable data; geometric validation still occurs when modeling or finalizing.
  * @example
  * ```ts
- * import { generate, immutableMesh } from "@metamesh/modeling";
- * import { heightfieldMesh } from "@metamesh/modeling/geometry";
+ * import { generate } from "@metamesh/modeling";
+ * import * as mesh from "@metamesh/modeling/geometry/mesh";
  * const model = generate(({ computed, part }) => {
- *   const surface = computed("surface", () => immutableMesh(heightfieldMesh({
+ *   const surface = computed("surface", () => mesh.immutable(mesh.heightfield({
  *     size: [10, 10], segments: [8, 8], height: () => 2,
  *   })));
  *   return [part("surface", surface)];
@@ -50,7 +65,7 @@ export function immutableBuffer(source) {
 export function immutableMesh(mesh) {
     const { positions, indices } = mesh;
     if (!(positions instanceof Float32Array) || !(indices instanceof Uint32Array))
-        throw new TypeError("immutableMesh requires Float32 positions and Uint32 indices.");
+        throw new TypeError("mesh.immutable requires Float32 positions and Uint32 indices.");
     return Object.freeze({
         positions: immutableBuffer(positions),
         indices: immutableBuffer(indices),
@@ -75,7 +90,8 @@ export function isImmutableBuffer(value) {
         Number.isSafeInteger(length) &&
         length >= 0 &&
         typeof field("at") === "function" &&
-        typeof field("copy") === "function");
+        typeof field("copy") === "function" &&
+        typeof field(Symbol.iterator) === "function");
 }
 /** Adopts separately bundled factories once, copying before trusting their storage or methods. */
 export function adoptImmutableBuffer(buffer) {
@@ -104,6 +120,11 @@ export function immutableBufferView(buffer) {
 /** Normalizes trusted modeling/finalization inputs without copying or exposing storage publicly. */
 export function immutableMeshView(mesh) {
     const { positions, indices } = mesh;
+    if (positions instanceof Float32Array &&
+        indices instanceof Uint32Array &&
+        Object.getOwnPropertyDescriptor(mesh, "positions")?.value === positions &&
+        Object.getOwnPropertyDescriptor(mesh, "indices")?.value === indices)
+        return mesh;
     return {
         positions: isImmutableBuffer(positions) ? immutableBufferView(positions) : positions,
         indices: isImmutableBuffer(indices) ? immutableBufferView(indices) : indices,

package/dist/geometry/index.js

@@ -1,18 +1,16 @@
 /** Pure geometry foundations without host initialization. @packageDocumentation */
 export { bounds2, bounds3, } from "./bounds-value.js";
-export { boundsFromSize, boundsSize, boundsCenter, containsBounds, fitBounds, layoutRow, } from "./bounds.js";
+export { boundsSize, boundsCenter, fitBounds, layoutRow, } from "./bounds.js";
+export { resolveCircularSampling, } from "./circular-sampling.js";
 export { fitTextLayout } from "./text-fitting.js";
 export { gridPatternTransforms, linearPatternTransforms, radialPatternTransforms, pathPatternTransforms, } from "./patterns.js";
-export { validateSolidMesh } from "./mesh/mesh-solid.js";
-export { computeTriangleMeshCentroid } from "./mesh/mesh-centroid.js";
-export { matchProfiles, } from "./profiles/matched.js";
-export { heightfieldMesh, preflightHeightfield, } from "./heightfield.js";
-export { preflightThreadedRodSolid as preflightThreadedRod, preflightInternalThreadCutterSolid as preflightInternalThreadCutter, preflightThreadedNutSolid as preflightThreadedNut, } from "./mechanical/thread-solids.js";
+export { matchProfiles, } from "./profiles/match-profiles.js";
+export { preflightThreadedRodSolid as preflightThreadedRod, preflightInternalThreadCutterSolid as preflightInternalThreadCutter, preflightThreadedNutSolid as preflightThreadedNut, } from "./mechanical/threads/solids.js";
 export { anchorFrame3, attachmentTransform3, boxAnchor3, anchor3, cylinderAnchor3, } from "./anchors.js";
 export { defaultGeometrySamplingLimits, resolveGeometrySamplingLimits, } from "./sampling-limits.js";
 export { GeometryError, isGeometryError, } from "./errors.js";
 export { resolveExtrusionDivisions, } from "./extrusion.js";
-export { extrudeMesh, loftMesh, triangulateContour, } from "./loft/loft.js";
+export { triangulateContour, } from "./loft/loft.js";
 export { transform2, transform3, } from "./transform-value.js";
 export { vector2, vector3, } from "./math/vector-value.js";
 export { add2, subtract2, scale2, dot2, cross2, length2, distance2, normalize2, lerp2, rotate2, } from "./math/vector2.js";
@@ -20,34 +18,31 @@ export { add3, cross3, dot3, length3, distance3, lerp3, normalize3, projectOntoP
 export { minimumCylindricalGearToothCountWithoutUndercut, resolveCylindricalGear, resolveCylindricalGearPair, resolveRackPitch, sampleCylindricalGearOutline, sampleInternalCylindricalGearSpaceOutline, sampleRackToothPath, } from "./mechanical/gears.js";
 export { measureInternalCylindricalGearPairMotion, } from "./mechanical/gear-motion.js";
 export { METRIC_FASTENER_STANDARDS, getMetricClearanceHoleDiameter, getMetricFastenerStandard, } from "./mechanical/standards.js";
-export { helicalThreadRidgeMesh, helicalThreadSolidMesh } from "./mechanical/thread-mesh.js";
-export { compensateThreadProfileAxially, compensateThreadProfileForFaceting, threadProfile, } from "./mechanical/thread-profiles.js";
-export { preflightHelicalThreadSolidMesh, } from "./mechanical/thread-mesh-plan.js";
-export { sampleConventionalThreadHelices as sampleThreadHelices, } from "./mechanical/thread-helices.js";
-export { PRINTABLE_THREAD_FIT_POLICIES, compensateThreadDiameters, resolvePrintableThreadFitPolicy, resolveThreadCircularSegments, } from "./mechanical/threads.js";
-export { analyzeTriangleMesh, joinTriangleMeshes, meshBounds, reverseTriangleMesh, transformTriangleMesh, validateTriangleMesh, } from "./mesh/mesh.js";
-export { computeTriangleMeshSignature, } from "./mesh/mesh-signature.js";
-export { optimizePlanarPatches, } from "./mesh/mesh-planar.js";
-export { analyzeTriangleMeshQuality, } from "./mesh/mesh-quality.js";
+export { compensateThreadProfileAxially, compensateThreadProfileForFaceting, threadProfile, } from "./mechanical/threads/profiles.js";
+export {} from "./mechanical/threads/mesh-plan.js";
+export { sampleConventionalThreadHelices as sampleThreadHelices, } from "./mechanical/threads/helices.js";
+export { PRINTABLE_THREAD_FIT_POLICIES, compensateThreadDiameters, resolvePrintableThreadFitPolicy, resolveThreadCircularSegments, } from "./mechanical/threads/fit.js";
 export { computeClosedParallelTransportFrames, computeParallelTransportFrames, } from "./paths/frames.js";
 export { sampleHelix } from "./paths/helix.js";
 export { path2, path3, } from "./paths/path-value.js";
 export { distributeAlongPath, roundClosedPolylinePath, } from "./paths/planar.js";
-export { circleContour, rectangleContour, regularPolygonContour, starContour, } from "./profiles/profiles.js";
+export { circleContour } from "./profiles/primitives/circle.js";
+export { rectangleContour } from "./profiles/primitives/rectangle.js";
+export { regularPolygonContour, } from "./profiles/primitives/regular-polygon.js";
+export { starContour } from "./profiles/primitives/star.js";
 export { closeToAxis, sampleSideProfile, } from "./profiles/side-profile.js";
 export { sampleContour, } from "./profiles/contour.js";
-export { ellipseContour } from "./profiles/shapes.js";
-export { rectangleProfile, } from "./profiles/rectangle.js";
+export { ellipseContour } from "./profiles/primitives/ellipse.js";
+export { rectangleProfile, } from "./profiles/primitives/rectangle.js";
 export { contourContainsPoint, normalizeContour, normalizePolygon, normalizeRegion, regionArea, regionBounds, signedContourArea, } from "./regions.js";
 export { resolveAlignedCircularSegments, resolveArcSegments, resolveCircularSegments, } from "./resolution.js";
-export { revolveMesh } from "./revolve/revolve-mesh.js";
-export { preflightSvgRegion, } from "./svg-import.js";
+export { preflightSvgRegion, } from "./svg/import.js";
 export { strokeRegionData, } from "./stroke-path.js";
-export { sweepMesh } from "./sweeps/sweep-mesh.js";
 export { DEFAULT_GEOMETRY_TOLERANCE, resolveGeometryTolerance, } from "./tolerance.js";
 export { transformRegionData } from "./transform-geometry.js";
-export { IDENTITY_TRANSFORM3, applyTransformDirection3, applyTransformPoint3, composeTransform3, eulerTransform3, frameTransform3, inverseTransform3, rotationTransform3, scaleTransform3, transformDeterminant3, translationTransform3, validateTransform3, } from "./transform3.js";
+export { IDENTITY_TRANSFORM3, applyTransformDirection3, applyTransformPoint3, composeTransform3, eulerTransform3, frameTransform3, inverseTransform3, rotationTransform3, scaleTransform3, transformDeterminant3, translationTransform3, validateTransform3, validateRigidTransform3, } from "./transform3.js";
 export { sampleTextContours } from "./text-contours.js";
 export { sampleCurve2, sampleCurve3 } from "./curves/sampling.js";
 export { resamplePolyline2, resamplePolyline3, } from "./paths/resampling.js";
 export { resolveKnuckleHinge, } from "./mechanical/knuckle-hinge.js";
+export { immutableBuffer, } from "./immutable-buffer.js";

package/dist/geometry/loft/loft.js

@@ -10,7 +10,7 @@ export { triangulateContour } from "./loft-triangulation.js";
 /**
  * Lofts simple point loops at z heights or explicit right-handed frames, in input order.
  *
- * An explicit correspondence method is required. CCW-normalized loops retain their
+ * Correspondence defaults to direct. CCW-normalized loops retain their
  * seam and original vertices; unequal counts gain subdivisions or repeated fan slots.
  * Both ends use ear-clipped caps, supporting concave profiles without center fans.
  * Intermediate slices interpolate placed world vertices, never frame axes.
@@ -21,12 +21,14 @@ export { triangulateContour } from "./loft-triangulation.js";
  * ```ts
  * const bottom = rectangleContour({ size: [20, 12] });
  * const top = rectangleContour({ size: [30, 20], treatment: { kind: "round", radius: 3 } });
- * loftMesh([{ profile: bottom, z: 0 }, { profile: top, z: 30 }], { correspondence: "reindex" });
+ * mesh.loft([{ profile: bottom, z: 0 }, { profile: top, z: 30 }], { correspondence: "reindex" });
  * ```
  */
-export function loftMesh(stations, options) {
-    if (options?.correspondence === undefined)
-        throw new GeometryError("INVALID_ARGUMENT", "Point-loop lofts require an explicit correspondence method.", { operation: "loftMesh" });
+export function loftMesh(stations, options = {}) {
+    if (typeof options !== "object" || options === null || Array.isArray(options))
+        throw new GeometryError("INVALID_ARGUMENT", "Loft options must be an object.", {
+            operation: "loftMesh",
+        });
     const limits = resolveModelingLimits(options.limits);
     if (!Array.isArray(stations) || stations.length < 2)
         throw new GeometryError("INVALID_ARGUMENT", "Loft requires at least two stations.", {
@@ -53,16 +55,19 @@ export function loftMesh(stations, options) {
 /**
  * Linearly extrudes one simple profile along +Z with robust ear-clipped caps.
  * Path2 profiles must be closed; raw point collections have an implicit closing edge.
+ * End treatments are unsupported and reject at runtime. Use Section.extrude for finished ends.
  *
  * @example Extrude point data without an engine
  * ```ts
  * const outline = rectangleContour({ size: [30, 20], treatment: { kind: "round", radius: 3 } });
- * extrudeMesh(outline, { height: 8 });
+ * mesh.extrude(outline, { height: 8 });
  * ```
  */
 export function extrudeMesh(input, options) {
     const { height } = options;
     const { center, scales, twist } = resolveExtrusionControls(height, options, "extrudeMesh");
+    if ("ends" in options)
+        throw new GeometryError("INVALID_ARGUMENT", "extrudeMesh does not support end treatments. Use Section.extrude instead.", { operation: "extrudeMesh" });
     if (!Number.isFinite(height) || height <= 0) {
         throw new GeometryError("INVALID_ARGUMENT", "Extrusion height must be finite and positive.", {
             operation: "extrudeMesh",

package/dist/geometry/math/immutable-value.js

@@ -1,5 +1,5 @@
 // A versioned realm protocol lets separately bundled authoring values cross the host boundary.
-const immutableMath = Symbol.for("@metamesh/modeling/immutable-math/8");
+const immutableMath = Symbol.for("@metamesh/modeling/immutable-math/9");
 /**
  * Brands and freezes only this constructor's prototype. Pure-annotated callers let bundlers
  * discard unused classes without dropping initialization for classes that remain reachable.

package/dist/geometry/mechanical/index.js

@@ -5,10 +5,10 @@
  */
 export { minimumCylindricalGearToothCountWithoutUndercut, resolveCylindricalGear, resolveCylindricalGearPair, resolveRackPitch, sampleCylindricalGearOutline, sampleInternalCylindricalGearSpaceOutline, sampleRackToothPath, } from "./gears.js";
 export { measureInternalCylindricalGearPairMotion } from "./gear-motion.js";
-export { helicalThreadRidgeMesh, helicalThreadSolidMesh } from "./thread-mesh.js";
-export { compensateThreadProfileAxially, compensateThreadProfileForFaceting, threadProfile, } from "./thread-profiles.js";
-export { preflightHelicalThreadSolidMesh } from "./thread-mesh-plan.js";
-export { sampleConventionalThreadHelices as sampleThreadHelices } from "./thread-helices.js";
-export { compensateThreadDiameters, PRINTABLE_THREAD_FIT_POLICIES, resolvePrintableThreadFitPolicy, resolveThreadCircularSegments, } from "./threads.js";
+export { threadRidgeMesh, threadSolidMesh } from "./threads/mesh.js";
+export { compensateThreadProfileAxially, compensateThreadProfileForFaceting, threadProfile, } from "./threads/profiles.js";
+export { preflightThreadSolidMesh } from "./threads/mesh-plan.js";
+export { sampleConventionalThreadHelices as sampleThreadHelices } from "./threads/helices.js";
+export { compensateThreadDiameters, PRINTABLE_THREAD_FIT_POLICIES, resolvePrintableThreadFitPolicy, resolveThreadCircularSegments, } from "./threads/fit.js";
 export { getMetricClearanceHoleDiameter, getMetricFastenerStandard, METRIC_FASTENER_STANDARDS, } from "./standards.js";
 export { resolveKnuckleHinge, } from "./knuckle-hinge.js";

package/dist/geometry/mechanical/threads/bevel.js

@@ -0,0 +1,24 @@
+import { GeometryError } from "../../errors.js";
+/** @internal Validates and captures factory-specific automatic bevel sizes. */
+export function resolveBevel(value, automatic, defaults, operation, parameter = "bevel") {
+    if (value === undefined)
+        return Object.freeze([defaults[0], defaults[1]]);
+    const invalid = () => {
+        throw new GeometryError("INVALID_ARGUMENT", `${parameter} must be a nonnegative finite size, "auto", or a [bottom, top] pair.`, {
+            operation,
+            details: { parameter },
+        });
+    };
+    const pair = Array.isArray(value) ? value : [value, value];
+    if (pair.length !== 2)
+        invalid();
+    const size = (index) => {
+        const item = pair[index];
+        if (item === "auto")
+            return automatic[index];
+        if (typeof item !== "number" || !Number.isFinite(item) || item < 0)
+            return invalid();
+        return item;
+    };
+    return Object.freeze([size(0), size(1)]);
+}

package/dist/geometry/mechanical/{threads.js → threads/fit.js}

@@ -1,7 +1,7 @@
-import { GeometryError } from "../errors.js";
-import { resolveCircularSegments, resolveGeometryResolution, } from "../resolution.js";
-import { resolveGeometryTolerance } from "../tolerance.js";
-import { compensateThreadProfileForFaceting } from "./thread-profiles.js";
+import { GeometryError } from "../../errors.js";
+import { resolveCircularSegments, resolveGeometryResolution, } from "../../resolution.js";
+import { resolveGeometryTolerance } from "../../tolerance.js";
+import { compensateThreadProfileForFaceting } from "./profiles.js";
 const frozenFit = (maleRadialInset, femaleRadialOutset, axialBacklash) => Object.freeze({ axialBacklash, femaleRadialOutset, maleRadialInset });
 /**
  * Conservative baseline print-fit policies in millimetres.

package/dist/geometry/mechanical/{thread-helices.js → threads/helices.js}

@@ -1,7 +1,7 @@
 /** Conventional thread helix sampling, independent of surface construction. */
-import { GeometryError } from "../errors.js";
-import { assertSamplingCount, resolveGeometrySamplingLimits, } from "../sampling-limits.js";
-import { assertFiniteThreadNumber } from "./thread-profiles.js";
+import { GeometryError } from "../../errors.js";
+import { assertSamplingCount, resolveGeometrySamplingLimits, } from "../../sampling-limits.js";
+import { assertFiniteThreadNumber } from "./profiles.js";
 /**
  * Samples evenly phased thread helices with finite `lead = pitch * starts`.
  * All starts together respect maxPathPoints (default 100000); excessive counts fail before allocation.

package/dist/geometry/mechanical/{thread-mesh-plan.js → threads/mesh-plan.js}

@@ -1,9 +1,10 @@
 /** Thread input resolution, end/bevel boundaries, and allocation preflight. */
-import { GeometryError } from "../errors.js";
-import { assertMeshAllocationWithinLimits, resolveModelingLimits, } from "../model-limits.js";
-import { resolveCircularSegments, resolveGeometryResolution, } from "../resolution.js";
-import { resolveGeometryTolerance } from "../tolerance.js";
-import { assertFiniteThreadNumber, createThreadRidgeSection, freezeThreadProfilePoints, MAX_THREAD_PROFILE_POINTS, } from "./thread-profiles.js";
+import { GeometryError } from "../../errors.js";
+import { assertMeshAllocationWithinLimits, resolveModelingLimits, } from "../../model-limits.js";
+import { resolveCircularSegments, resolveGeometryResolution, } from "../../resolution.js";
+import { resolveGeometryTolerance } from "../../tolerance.js";
+import { resolveBevel } from "./bevel.js";
+import { assertFiniteThreadNumber, createThreadRidgeSection, freezeThreadProfilePoints, MAX_THREAD_PROFILE_POINTS, } from "./profiles.js";
 const validateMeshingProfile = (profile, linearTolerance, operation) => {
     const pitch = assertFiniteThreadNumber(profile.pitch, "profile.pitch", operation);
     const depth = assertFiniteThreadNumber(profile.depth, "profile.depth", operation);
@@ -74,7 +75,7 @@ const reindexThreadSectionForMajorEnvelope = (section, pitch, linearTolerance, o
     return Object.freeze({ phaseOffset: cutPoint + pitch / 2, section: reindexed });
 };
 /** @internal Resolves shared ridge and solid sampling before construction. */
-export const resolveHelicalThreadMeshOptions = (options, operation, circularSamplingRadius) => {
+export const resolveHelicalThreadMeshOptions = (options, operation, circularSamplingRadius, reservations = [0, 0]) => {
     const diameter = assertFiniteThreadNumber(options.majorDiameter, "majorDiameter", operation);
     const length = assertFiniteThreadNumber(options.length, "length", operation);
     assertFiniteThreadNumber(options.profile.pitch, "profile.pitch", operation);
@@ -103,8 +104,8 @@ export const resolveHelicalThreadMeshOptions = (options, operation, circularSamp
             operation,
         });
     }
-    const bottomBoundary = bottom === "standard" ? 0 : endLength;
-    const topBoundary = top === "standard" ? length : length - endLength;
+    const bottomBoundary = bottom === "standard" ? 0 : Math.max(endLength, reservations[0]);
+    const topBoundary = top === "standard" ? length : length - Math.max(endLength, reservations[1]);
     const usable = topBoundary - bottomBoundary;
     if (!(diameter - 2 * options.profile.depth > tolerance.linear)) {
         throw new GeometryError("INVALID_ARGUMENT", "A positive minor diameter is required.", {
@@ -185,6 +186,7 @@ export const resolveHelicalThreadMeshOptions = (options, operation, circularSamp
         });
     }
     return {
+        bevel: [0, 0],
         bottom,
         bottomBoundary,
         bottomLeadFullCenter,
@@ -215,19 +217,14 @@ export const resolveHelicalThreadMeshOptions = (options, operation, circularSamp
 };
 /** @internal Resolves the active radial bevel boundary at one axial station. */
 export const threadSurfaceBevelBoundaryAt = (axial, profile, resolved, options) => {
-    const bottomBevelSize = Math.min(options.bevelBottomSize ?? options.bevelSize ?? profile.depth, resolved.length / 2);
-    const topBevelSize = Math.min(options.bevelTopSize ?? options.bevelSize ?? profile.depth, resolved.length / 2);
+    const [bottomBevelSize, topBevelSize] = resolved.bevel;
     const bevelOffset = options.bevelOffset ?? 0;
     const bottomFace = bevelOffset;
     const topFace = resolved.length - bevelOffset;
     // Include the zero-depth stations here so callers can solve the exact point where a linear
     // thread flank first meets the bevel. Applying the boundary at zero depth remains a no-op.
-    const bottomApplies = options.bevelBottom === true &&
-        bottomBevelSize > 0 &&
-        axial <= bottomFace + bottomBevelSize + resolved.tolerance.linear;
-    const topApplies = options.bevelTop === true &&
-        topBevelSize > 0 &&
-        axial >= topFace - topBevelSize - resolved.tolerance.linear;
+    const bottomApplies = bottomBevelSize > 0 && axial <= bottomFace + bottomBevelSize + resolved.tolerance.linear;
+    const topApplies = topBevelSize > 0 && axial >= topFace - topBevelSize - resolved.tolerance.linear;
     if (!bottomApplies && !topApplies)
         return undefined;
     const bottomDepth = bottomApplies
@@ -265,14 +262,9 @@ export const requirePositiveThreadSurfaceRadius = (radius, resolved, operation)
     }
 };
 const resolveMaximumThreadSurfaceRadius = (options, diameter, length, operation) => {
-    const bevelSize = assertFiniteThreadNumber(options.bevelSize ?? options.profile.depth, "bevelSize", operation);
-    const bottomBevelSize = assertFiniteThreadNumber(options.bevelBottomSize ?? bevelSize, "bevelBottomSize", operation);
-    const topBevelSize = assertFiniteThreadNumber(options.bevelTopSize ?? bevelSize, "bevelTopSize", operation);
+    const [bottomBevelSize, topBevelSize] = resolveBevel(options.bevel, [options.profile.depth, options.profile.depth], [0, 0], operation);
     const bevelOffset = assertFiniteThreadNumber(options.bevelOffset ?? 0, "bevelOffset", operation);
-    if (bevelSize < 0 ||
-        bottomBevelSize < 0 ||
-        topBevelSize < 0 ||
-        bevelOffset < 0 ||
+    if (bevelOffset < 0 ||
         bevelOffset * 2 > length ||
         (options.bevelMode !== undefined &&
             options.bevelMode !== "inset" &&
@@ -286,39 +278,33 @@ const resolveMaximumThreadSurfaceRadius = (options, diameter, length, operation)
         return majorRadius;
     const outsetRadius = (style, size) => (style === "blunt" ? majorRadius : majorRadius - options.profile.depth) +
         Math.min(size, length / 2);
-    return Math.max(majorRadius, options.bevelBottom === true
+    return Math.max(majorRadius, bottomBevelSize > 0
         ? outsetRadius(options.ends?.bottom ?? "blunt", bottomBevelSize)
-        : majorRadius, options.bevelTop === true
-        ? outsetRadius(options.ends?.top ?? "blunt", topBevelSize)
-        : majorRadius);
+        : majorRadius, topBevelSize > 0 ? outsetRadius(options.ends?.top ?? "blunt", topBevelSize) : majorRadius);
 };
 /** @internal Resolves the solid's sampling and conservative allocation plan. */
 export const resolveHelicalThreadSolidMeshPreflight = (options, operation) => {
-    const requestedEndLength = options.ends?.endLength ?? 0;
-    const sharedBevelSize = options.bevelSize ?? options.profile.depth;
-    const bottomBevelSize = options.bevelBottomSize ?? sharedBevelSize;
-    const topBevelSize = options.bevelTopSize ?? sharedBevelSize;
-    const bluntBevelReservation = Math.max(options.bevelBottom === true && (options.ends?.bottom ?? "blunt") === "blunt"
-        ? bottomBevelSize
-        : 0, options.bevelTop === true && (options.ends?.top ?? "blunt") === "blunt" ? topBevelSize : 0);
-    const effectiveBluntBevelReservation = Math.min(bluntBevelReservation, options.length / 2);
-    const resolvedOptions = effectiveBluntBevelReservation > 0
-        ? {
-            ...options,
-            ends: {
-                ...options.ends,
-                endLength: Math.max(requestedEndLength, effectiveBluntBevelReservation),
-            },
-        }
-        : options;
-    const resolved = resolveHelicalThreadMeshOptions(resolvedOptions, operation, (diameter, length) => resolveMaximumThreadSurfaceRadius(resolvedOptions, diameter, length, operation));
+    const sizes = resolveBevel(options.bevel, [options.profile.depth, options.profile.depth], [0, 0], operation);
+    const bottomBevelSize = Math.min(sizes[0], options.length / 2);
+    const topBevelSize = Math.min(sizes[1], options.length / 2);
+    const offset = options.bevelOffset ?? 0;
+    const base = resolveHelicalThreadMeshOptions(options, operation, (diameter, length) => resolveMaximumThreadSurfaceRadius(options, diameter, length, operation), [
+        bottomBevelSize > 0 && (options.ends?.bottom ?? "blunt") === "blunt"
+            ? offset + bottomBevelSize
+            : 0,
+        topBevelSize > 0 && (options.ends?.top ?? "blunt") === "blunt" ? offset + topBevelSize : 0,
+    ]);
+    const resolved = {
+        ...base,
+        bevel: [bottomBevelSize, topBevelSize],
+    };
     if ((options.bevelMode ?? "inset") === "inset") {
         const majorRadius = resolved.diameter / 2;
-        if (options.bevelBottom === true) {
-            requirePositiveThreadSurfaceRadius(applyThreadSurfaceBevel(majorRadius, 0, options.profile, resolved, resolvedOptions), resolved, operation);
+        if (bottomBevelSize > 0) {
+            requirePositiveThreadSurfaceRadius(applyThreadSurfaceBevel(majorRadius, 0, options.profile, resolved, options), resolved, operation);
         }
-        if (options.bevelTop === true) {
-            requirePositiveThreadSurfaceRadius(applyThreadSurfaceBevel(majorRadius, resolved.length, options.profile, resolved, resolvedOptions), resolved, operation);
+        if (topBevelSize > 0) {
+            requirePositiveThreadSurfaceRadius(applyThreadSurfaceBevel(majorRadius, resolved.length, options.profile, resolved, options), resolved, operation);
         }
     }
     const resolution = resolveGeometryResolution(options.resolution, options.limits);
@@ -354,9 +340,8 @@ export const resolveHelicalThreadSolidMeshPreflight = (options, operation) => {
  * `circularSegments` is the selected count; row and triangle counts are conservative estimates.
  * Successful preflight leaves generated coordinate and topology checks to mesh construction.
  *
- * @see {@link helicalThreadSolidMesh}
+ * See `mesh.threadSolid` for standalone mesh construction.
  */
-export function preflightHelicalThreadSolidMesh(options) {
-    return resolveHelicalThreadSolidMeshPreflight(options, "preflightHelicalThreadSolidMesh")
-        .preflight;
+export function preflightThreadSolidMesh(options) {
+    return resolveHelicalThreadSolidMeshPreflight(options, "preflightThreadSolidMesh").preflight;
 }

package/dist/geometry/mechanical/{thread-mesh.js → threads/mesh.js}

@@ -1,9 +1,9 @@
 /** Closed ridge and complete-solid mesh construction from resolved thread plans. */
-import { triangulateContour } from "../loft/loft.js";
-import { analyzeTriangleMesh, joinTriangleMeshes, reverseTriangleMesh, validateTriangleMesh, } from "../mesh/mesh.js";
-import { assertMeshAllocationWithinLimits, resolveModelingLimits } from "../model-limits.js";
-import { resolveHelicalThreadMeshOptions, resolveHelicalThreadSolidMeshPreflight, } from "./thread-mesh-plan.js";
-import { buildThreadSurfaceColumn, stitchThreadSurfaceColumns } from "./thread-surface.js";
+import { triangulateContour } from "../../loft/loft.js";
+import { analyzeTriangleMesh, joinTriangleMeshes, reverseTriangleMesh, validateTriangleMesh, } from "../../mesh/mesh.js";
+import { assertMeshAllocationWithinLimits, resolveModelingLimits } from "../../model-limits.js";
+import { resolveHelicalThreadMeshOptions, resolveHelicalThreadSolidMeshPreflight, } from "./mesh-plan.js";
+import { buildThreadSurfaceColumn, stitchThreadSurfaceColumns } from "./surface.js";
 const MINIMUM_TAPERED_RIDGE_HEIGHT = 0.0005;
 const buildThreadRidgeComponent = (options) => {
     const { profile } = options;
@@ -74,8 +74,8 @@ const buildThreadRidgeComponent = (options) => {
  * conservative pre-allocation estimate rejects excessive meshes before constructing position
  * arrays.
  */
-export function helicalThreadSolidMesh(options) {
-    const operation = "helicalThreadSolidMesh";
+export function threadSolidMesh(options) {
+    const operation = "threadSolidMesh";
     const { maximumAxialSegmentLength, resolved } = resolveHelicalThreadSolidMeshPreflight(options, operation);
     const positions = [];
     const columns = Array.from({ length: resolved.segments }, (_, column) => buildThreadSurfaceColumn(options.profile, resolved, options, resolved.phase + (column * 2 * Math.PI) / resolved.segments, maximumAxialSegmentLength, positions));
@@ -113,8 +113,8 @@ export function helicalThreadSolidMesh(options) {
  * shaft's radial/axial frame. The mesh is intended for union with its
  * minor-envelope cylinder and never owns WASM objects.
  */
-export function helicalThreadRidgeMesh(options) {
-    const operation = "helicalThreadRidgeMesh";
+export function threadRidgeMesh(options) {
+    const operation = "threadRidgeMesh";
     const resolved = resolveHelicalThreadMeshOptions(options, operation);
     const z0 = resolved.bottomBoundary - resolved.section[0][0];
     const z1 = resolved.topBoundary - resolved.section.at(-1)[0];

package/dist/geometry/mechanical/{thread-profiles.js → threads/profiles.js}

@@ -1,7 +1,7 @@
 /** Periodic thread profiles and axial/radial fit compensation. */
-import { GeometryError } from "../errors.js";
-import { triangulateContour } from "../loft/loft.js";
-import { resolveGeometryTolerance } from "../tolerance.js";
+import { GeometryError } from "../../errors.js";
+import { triangulateContour } from "../../loft/loft.js";
+import { resolveGeometryTolerance } from "../../tolerance.js";
 const BUTTRESS_DEFAULT_DEPTH_RATIO = 0.66271;
 const BUTTRESS_CREST_FLAT_RATIO = 0.16316;
 const BUTTRESS_PRESSURE_ANGLE_RADIANS = (7 * Math.PI) / 180;