@metamesh/modeling 0.14.0 → 0.15.0

package/dist/geometry/revolve/revolve-mesh.js

@@ -3,6 +3,7 @@ import { triangulateContour } from "../loft/loft.js";
 import { validateTriangleMesh } from "../mesh/mesh.js";
 import { assertMeshAllocationWithinLimits, resolveModelingLimits, } from "../model-limits.js";
 import { writeMeshVertex } from "../numeric.js";
+import { path2InputData } from "../paths/path-value.js";
 import { resolveCircularPrimitiveSegments } from "../primitive-resolution.js";
 import { normalizeContour } from "../regions.js";
 import { assertSamplingCount } from "../sampling-limits.js";
@@ -16,6 +17,7 @@ const AXIS_EPSILON = 1e-10;
  * vertices and zero-area quads. Profile edges that lie entirely on the axis
  * collapse to the solid's interior and are intentionally omitted.
  * Profile coordinates must fit finite Float32 mesh storage.
+ * Path2 profiles must be closed; raw point collections have an implicit closing edge.
  *
  * @param profile - Closed CCW `[radius, z]` profile without a duplicated seam point.
  * @param options - Optional physical or exact circumferential sampling controls. Defaults to `{}`.
@@ -24,28 +26,31 @@ const AXIS_EPSILON = 1e-10;
  * @example Partial revolution with end caps
  * ```ts
  * // Each point is [radius, Z]; the profile seam is implicit.
- * revolveMesh([[0, 0], [12, 0], [8, 20], [0, 20]], { revolveDegrees: 270 });
+ * revolveMesh([[0, 0], [12, 0], [8, 20], [0, 20]], { degrees: 270 });
  * ```
  */
-export const revolveMesh = (profile, options = {}) => {
+export const revolveMesh = (input, options = {}) => {
     if (typeof options !== "object" || options === null || Array.isArray(options))
         throw new GeometryError("INVALID_ARGUMENT", "Revolution options require an object.", {
             operation: "revolveMesh",
         });
-    const degrees = options.revolveDegrees ?? 360;
+    const degrees = options.degrees ?? 360;
     if (!Number.isFinite(degrees) || degrees <= 0 || degrees > 360)
-        throw new GeometryError("INVALID_ARGUMENT", "revolveDegrees must be in (0, 360].", {
+        throw new GeometryError("INVALID_ARGUMENT", "degrees must be in (0, 360].", {
             operation: "revolveMesh",
         });
+    const limits = resolveModelingLimits(options.limits);
+    let profile = path2InputData(input, true, { maxPathPoints: limits.maxProfilePoints }).points;
     if (profile.length < 3) {
-        throw new Error("A revolved profile needs at least three points.");
+        throw new GeometryError("DEGENERATE_GEOMETRY", "A revolved profile needs at least three points.", {
+            operation: "revolveMesh",
+        });
     }
-    const limits = resolveModelingLimits(options.limits);
     assertSamplingCount(profile.length, "revolveMesh", limits.maxProfilePoints);
     let maximumRadius = 0;
     for (const [radius, z] of profile) {
         if (!Number.isFinite(radius) || !Number.isFinite(z) || radius < 0) {
-            throw new Error("Revolved profile coordinates must be finite and radii non-negative.");
+            throw new GeometryError(Number.isFinite(radius) && Number.isFinite(z) ? "INVALID_ARGUMENT" : "NON_FINITE_VALUE", "Revolved profile coordinates must be finite and radii non-negative.", { operation: "revolveMesh" });
         }
         if (!Number.isFinite(Math.fround(radius)) || !Number.isFinite(Math.fround(z))) {
             throw new GeometryError("NON_FINITE_VALUE", "Revolved profile coordinates exceed finite Float32 mesh storage.", { operation: "revolveMesh" });

package/dist/geometry/stroke-path.js

@@ -1,21 +1,12 @@
 import { GeometryError } from "./errors.js";
-import { unionPolygonGeometry } from "./polygon-clipping.js";
-import { normalizeRegion } from "./regions.js";
+import { path2InputData } from "./paths/path-value.js";
+import { clippingRing, regionFromMultiPolygon, unionPolygonGeometry } from "./polygon-clipping.js";
 import { resolveCircularSegments } from "./resolution.js";
 import { assertSamplingCount, resolveGeometrySamplingLimits, } from "./sampling-limits.js";
 import { resolveGeometryTolerance } from "./tolerance.js";
 const DEFAULT_MITER_LIMIT = 4;
 function fail(message) {
-    throw new GeometryError("INVALID_ARGUMENT", message, { operation: "strokePathRegion" });
-}
-function ring(points) {
-    const result = points.map(([x, y]) => [x, y]);
-    const first = result[0];
-    const last = result.at(-1);
-    if (first !== undefined && last !== undefined && (first[0] !== last[0] || first[1] !== last[1])) {
-        result.push([...first]);
-    }
-    return result;
+    throw new GeometryError("INVALID_ARGUMENT", message, { operation: "strokeRegionData" });
 }
 function ellipsePoints(center, radius, segments) {
     return Array.from({ length: segments }, (_, index) => {
@@ -76,8 +67,9 @@ function deduplicatePath(path, closed, width) {
     return Object.freeze(points);
 }
 /** @internal Bounded CCW stroke primitives shared by native sections and pure clipping. */
-export function strokePathContours(path, options, exactCircularSegments) {
-    const closed = options.closed ?? false;
+export function strokePathContours(input, options, exactCircularSegments) {
+    const limits = resolveGeometrySamplingLimits(options.limits);
+    const { points: path, closed } = path2InputData(input, options.closed, limits);
     const cap = options.cap ?? "butt";
     const join = options.join ?? "miter";
     if (typeof closed !== "boolean")
@@ -97,9 +89,8 @@ export function strokePathContours(path, options, exactCircularSegments) {
             ? resolveCircularSegments(options.width / 2, options.resolution, options.limits)
             : 3);
     const half = options.width / 2;
-    const limits = resolveGeometrySamplingLimits(options.limits);
-    assertSamplingCount(path.length, "strokePathRegion", limits.maxPathPoints);
-    assertSamplingCount(circularSegments, "strokePathRegion", limits.maxCircularSegments);
+    assertSamplingCount(path.length, "strokeRegionData", limits.maxPathPoints);
+    assertSamplingCount(circularSegments, "strokeRegionData", limits.maxCircularSegments);
     const normalizedPath = deduplicatePath(path, closed, options.width);
     if (normalizedPath.length < (closed ? 3 : 2))
         return [];
@@ -109,7 +100,7 @@ export function strokePathContours(path, options, exactCircularSegments) {
     const constructionVertices = segmentCount * 4 +
         joinCount * (join === "round" ? circularSegments : join === "miter" ? 4 : 3) +
         (!closed && cap === "round" ? 2 * circularSegments : 0);
-    assertSamplingCount(constructionVertices, "strokePathRegion", limits.maxProfilePoints);
+    assertSamplingCount(constructionVertices, "strokeRegionData", limits.maxProfilePoints);
     for (let index = 0; index < segmentCount; index += 1) {
         let start = normalizedPath[index];
         let end = normalizedPath[(index + 1) % normalizedPath.length];
@@ -158,17 +149,11 @@ export function strokePathMultiPolygon(path, options, circularSegments) {
     const contours = strokePathContours(path, options, circularSegments);
     if (contours.length === 0)
         return [];
-    const result = unionPolygonGeometry(contours.map((contour) => [ring(contour)]));
+    const result = unionPolygonGeometry(contours.map((contour) => [clippingRing(contour)]));
     const outputVertices = result.reduce((count, polygon) => count + polygon.reduce((total, contour) => total + Math.max(0, contour.length - 1), 0), 0);
-    assertSamplingCount(outputVertices, "strokePathRegion", resolveGeometrySamplingLimits(options.limits).maxProfilePoints);
+    assertSamplingCount(outputVertices, "strokeRegionData", resolveGeometrySamplingLimits(options.limits).maxProfilePoints);
     return result;
 }
-function regionFromMultiPolygon(value) {
-    return normalizeRegion(value.map((polygon) => ({
-        outer: polygon[0].slice(0, -1).map(([x, y]) => [x, y]),
-        holes: polygon.slice(1).map((hole) => hole.slice(0, -1).map(([x, y]) => [x, y])),
-    })));
-}
 /**
  * Converts a sampled millimetre path into the filled region covered by a centered stroke.
  *
@@ -177,7 +162,7 @@ function regionFromMultiPolygon(value) {
  * resolution. Bevels fill the outer corner triangle; miters extend the outer edges to their
  * intersection, falling back to bevels above SVG's default miter limit of 4.
  */
-export function strokePathRegion(path, options) {
+export function strokeRegionData(path, options) {
     const result = strokePathMultiPolygon(path, options);
     if (result.length === 0)
         return fail("The sampled stroke path has no visible length.");

package/dist/geometry/svg/fill.js

@@ -1,16 +1,8 @@
-import { polygonClipping, unionPolygonGeometry, xorPolygonGeometry } from "../polygon-clipping.js";
-import { normalizeRegion, signedContourArea } from "../regions.js";
+import { clippingRing, polygonClipping, regionFromMultiPolygon, unionPolygonGeometry, xorPolygonGeometry, } from "../polygon-clipping.js";
+import { signedContourArea } from "../regions.js";
 import { assertSamplingCount } from "../sampling-limits.js";
 /** Private clipping stage with the selected execution's immutable allocation ceiling. */
-export function createBoundedSvgClipping(maximumVertices) {
-    function ring(points) {
-        const result = points.map(([x, y]) => [x, y]);
-        const first = result[0];
-        const last = result.at(-1);
-        if (first !== undefined && last !== undefined && (first[0] !== last[0] || first[1] !== last[1]))
-            result.push([...first]);
-        return result;
-    }
+export function createBoundedSvgClipping(maxVertices) {
     function ringVertexCount(value) {
         const first = value[0];
         const last = value.at(-1);
@@ -21,7 +13,7 @@ export function createBoundedSvgClipping(maximumVertices) {
         return value.reduce((total, polygon) => total + polygon.reduce((polygonTotal, path) => polygonTotal + ringVertexCount(path), 0), 0);
     }
     function assertExpandedVertexCount(vertices, stage) {
-        assertSamplingCount(vertices, "preflightSvgRegion", maximumVertices, `SVG ${stage} exceeds ${maximumVertices} expanded vertices (requires ${vertices}).`);
+        assertSamplingCount(vertices, "preflightSvgRegion", maxVertices, `SVG ${stage} exceeds ${maxVertices} expanded vertices (requires ${vertices}).`);
     }
     function boundedMultiPolygon(value, stage) {
         assertExpandedVertexCount(multiPolygonVertexCount(value), stage);
@@ -136,16 +128,16 @@ export function createBoundedSvgClipping(maximumVertices) {
             .map((subpath) => subpath.points);
         if (rings.length === 0)
             return [];
-        const polygons = rings.map((points) => [ring(points)]);
+        const polygons = rings.map((points) => [clippingRing(points)]);
         if (fillRule === "evenodd") {
             return boundedXor(polygons.map((polygon) => [polygon]), "even-odd fill output");
         }
         const positive = rings
             .filter((points) => signedContourArea(points) >= 0)
-            .map((points) => [ring(points)]);
+            .map((points) => [clippingRing(points)]);
         const negative = rings
             .filter((points) => signedContourArea(points) < 0)
-            .map((points) => [ring(points)]);
+            .map((points) => [clippingRing(points)]);
         if (positive.length === 0)
             return boundedUnion([negative], "negative fill output");
         if (negative.length === 0)
@@ -155,12 +147,6 @@ export function createBoundedSvgClipping(maximumVertices) {
         // precisely where positive and negative nonzero winding counts match.
         return differingCoverage(positive, negative);
     }
-    function regionFromMultiPolygon(value) {
-        return normalizeRegion(value.map((polygon) => ({
-            outer: polygon[0].slice(0, -1).map(([x, y]) => [x, y]),
-            holes: polygon.slice(1).map((hole) => hole.slice(0, -1).map(([x, y]) => [x, y])),
-        })));
-    }
     return {
         assertExpandedVertexCount,
         boundedMultiPolygon,

package/dist/geometry/svg-import.js

@@ -429,7 +429,7 @@ function measureSvgRegion(region) {
     let minEdgeLength = Number.POSITIVE_INFINITY;
     let minX = Number.POSITIVE_INFINITY;
     let minY = Number.POSITIVE_INFINITY;
-    let shortEdges = 0;
+    let shortEdgeCount = 0;
     let vertices = 0;
     for (const polygon of region) {
         for (const loop of [polygon.outer, ...polygon.holes]) {
@@ -443,7 +443,7 @@ function measureSvgRegion(region) {
             for (const length of loopEdgeLengths(loop)) {
                 minEdgeLength = Math.min(minEdgeLength, length);
                 if (length < SHORT_EDGE_LENGTH_MM)
-                    shortEdges += 1;
+                    shortEdgeCount += 1;
             }
         }
     }
@@ -456,13 +456,13 @@ function measureSvgRegion(region) {
     return Object.freeze({
         area: regionArea(region),
         bounds,
-        components: region.length,
-        contours: region.length + holes,
-        holes,
+        componentCount: region.length,
+        contourCount: region.length + holes,
+        holeCount: holes,
         minEdgeLength: Number.isFinite(minEdgeLength) ? minEdgeLength : null,
-        shortEdges,
-        tinyIslands: region.filter((polygon) => polygonArea(polygon) < TINY_ISLAND_AREA_MM2).length,
-        vertices,
+        shortEdgeCount,
+        tinyIslandCount: region.filter((polygon) => polygonArea(polygon) < TINY_ISLAND_AREA_MM2).length,
+        vertexCount: vertices,
     });
 }
 /**
@@ -498,10 +498,10 @@ function createSvgRegionPreflight(svg, options = {}) {
     const stack = [];
     const geometry = [];
     let elementCount = 0;
-    let emptyElements = 0;
+    let emptyElementCount = 0;
     let expandedGeometryVertices = 0;
-    let implicitFilledClosures = 0;
-    let invisibleElements = 0;
+    let implicitFilledClosureCount = 0;
+    let invisibleElementCount = 0;
     let nodeCount = 0;
     let rootSeen = false;
     let strokeConstructionVertices = 0;
@@ -582,9 +582,9 @@ function createSvgRegionPreflight(svg, options = {}) {
             const paintedStroke = isPainted(paint.stroke, paint.strokeOpacity) && paint.strokeWidth > 0;
             const elementGeometry = [];
             if (!paintedFill && !paintedStroke)
-                invisibleElements += 1;
+                invisibleElementCount += 1;
             if (paintedFill) {
-                implicitFilledClosures += subpaths.filter((subpath) => !subpath.closed && subpath.points.length >= 3).length;
+                implicitFilledClosureCount += subpaths.filter((subpath) => !subpath.closed && subpath.points.length >= 3).length;
                 appendGeometry(elementGeometry, fillGeometry(subpaths, paint.fillRule), "element fill output");
             }
             if (paintedStroke) {
@@ -606,7 +606,7 @@ function createSvgRegionPreflight(svg, options = {}) {
                 }
             }
             if ((paintedFill || paintedStroke) && elementGeometry.every((value) => value.length === 0)) {
-                emptyElements += 1;
+                emptyElementCount += 1;
             }
             geometry.push(...elementGeometry);
         }
@@ -628,17 +628,17 @@ function createSvgRegionPreflight(svg, options = {}) {
         geometry: measureSvgRegion(region),
         region,
         repairs: Object.freeze({
-            emptyElements,
-            implicitFilledClosures,
-            invisibleElements,
-            removedDuplicateVertices: budget.removedDuplicateCount,
-            removedSeamVertices: budget.removedSeamCount,
+            emptyElementCount,
+            implicitFilledClosureCount,
+            invisibleElementCount,
+            removedDuplicateVertexCount: budget.removedDuplicateCount,
+            removedSeamVertexCount: budget.removedSeamCount,
         }),
         source: Object.freeze({
-            bytes,
-            elements: elementCount,
-            emittedVertices: budget.emittedCount,
-            parsedVertices: budget.parsedCount,
+            byteCount: bytes,
+            elementCount,
+            emittedVertexCount: budget.emittedCount,
+            parsedVertexCount: budget.parsedCount,
         }),
     });
 }

package/dist/geometry/sweeps/options.js

@@ -1,4 +1,5 @@
 import { GeometryError } from "../errors.js";
+import { vector2Data } from "../math/vector-value.js";
 /** @internal Validates local scales before any manufacturing buffer allocation. */
 export function resolveSweepScales(scale, stationCount) {
     const fail = () => {
@@ -10,14 +11,14 @@ export function resolveSweepScales(scale, stationCount) {
                 fail();
             return [value, value];
         }
-        if (!Array.isArray(value) ||
-            value.length !== 2 ||
-            !value.every((n) => typeof n === "number" && Number.isFinite(n) && n > 0))
+        const coordinates = vector2Data(value);
+        if (!coordinates.every((n) => typeof n === "number" && Number.isFinite(n) && n > 0))
             fail();
-        return value;
+        return coordinates;
     };
     if (scale === undefined ||
         typeof scale === "number" ||
+        (typeof scale === "object" && scale !== null && "toArray" in scale) ||
         (Array.isArray(scale) && typeof scale[0] === "number")) {
         const value = pair(scale ?? 1);
         return Array.from({ length: stationCount }, () => value);

package/dist/geometry/sweeps/orientation.js

@@ -14,7 +14,7 @@ export function validateSweepOptions(options) {
         "limits",
         "orientation",
         "resolution",
-        "twistDegrees",
+        "twist",
         "twistBy",
         "scale",
         "seamProfileOffset",
@@ -27,8 +27,8 @@ export function validateSweepOptions(options) {
         options.twistBy !== "length" &&
         options.twistBy !== "stations")
         fail("Sweep twistBy must be length or stations.");
-    if (!Number.isFinite(options.twistDegrees ?? 0))
-        throw new GeometryError("NON_FINITE_VALUE", "Sweep twistDegrees must be finite.", {
+    if (!Number.isFinite(options.twist ?? 0))
+        throw new GeometryError("NON_FINITE_VALUE", "Sweep twist must be finite.", {
             operation: "sweep",
         });
     const policy = options.orientation;
@@ -58,8 +58,8 @@ export function validateSweepOptions(options) {
     if (Object.keys(policy).some((key) => !keys.includes(key)))
         fail("Unsupported field for the selected sweep orientation.");
 }
-function directedNormal(value, tangent, label) {
-    validateSweepNormal(value, "sweep");
+function directedNormal(input, tangent, label) {
+    const value = validateSweepNormal(input, "sweep");
     const maximum = Math.max(...value.map(Math.abs));
     const unit = normalize3([value[0] / maximum, value[1] / maximum, value[2] / maximum]);
     const projected = projectOntoPlane3(unit, tangent);

package/dist/geometry/sweeps/stations.js

@@ -65,14 +65,14 @@ function frameRotation(from, to) {
 export function planSweepStations(contours, path, scales, options, frames) {
     const closed = options.closed ?? false;
     const segmentCount = closed ? path.length : path.length - 1;
-    const twist = ((options.twistDegrees ?? 0) / 180) * Math.PI;
-    if (!Number.isFinite(twist))
-        throw new GeometryError("NON_FINITE_VALUE", "Sweep twistDegrees must be finite.", {
+    const twistRadians = ((options.twist ?? 0) / 180) * Math.PI;
+    if (!Number.isFinite(twistRadians))
+        throw new GeometryError("NON_FINITE_VALUE", "Sweep twist must be finite.", {
             operation: "sweep",
         });
     const intervals = [];
     const progress = sweepProgress(path, options);
-    if (twist === 0)
+    if (twistRadians === 0)
         return { intervals: Array(segmentCount).fill(1), stationCount: path.length, progress };
     const resolution = resolveGeometryResolution(options.resolution, options.limits);
     const limits = resolveGeometrySamplingLimits(options.limits);
@@ -92,7 +92,7 @@ export function planSweepStations(contours, path, scales, options, frames) {
     let stationCount = closed ? 0 : 1;
     for (let i = 0; i < segmentCount; i++) {
         const next = (i + 1) % path.length;
-        const twistStep = Math.abs(twist * (progress[i + 1] - progress[i]));
+        const twistStep = Math.abs(twistRadians * (progress[i + 1] - progress[i]));
         const frameAngle = frames === undefined ? 0 : frameRotation(frames[i], frames[next]).angle;
         const angle = frameAngle + twistStep;
         const maximumScale = Math.max(...scales[i], ...scales[next]);
@@ -104,9 +104,9 @@ export function planSweepStations(contours, path, scales, options, frames) {
         const a = curvature / 8, b = (edgeLength * (maximumScale * angle + scaleChange)) / 4;
         const requiredAngular = resolution.circularSegments === undefined
             ? Math.max(1, Math.ceil((b + Math.hypot(b, 2 * Math.sqrt(a * resolution.maxChordError))) /
-                (2 * resolution.maxChordError)), Math.ceil((resolution.minimumSegments * angle) / (2 * Math.PI)))
+                (2 * resolution.maxChordError)), Math.ceil((resolution.minSegments * angle) / (2 * Math.PI)))
             : Math.max(1, Math.ceil((resolution.circularSegments * angle) / (2 * Math.PI)));
-        const allowedAngular = Math.max(1, scaleChange === 0 ? 0 : resolution.maximumSegments, Math.ceil((resolution.maximumSegments * angle) / (2 * Math.PI)));
+        const allowedAngular = Math.max(1, scaleChange === 0 ? 0 : resolution.maxSegments, Math.ceil((resolution.maxSegments * angle) / (2 * Math.PI)));
         if (requiredAngular > allowedAngular)
             throw new GeometryError("COMPLEXITY_LIMIT", `Sweep surface refinement requires ${requiredAngular} intervals; the selected circular ceiling allows ${allowedAngular}.`, {
                 operation: "sweep",
@@ -126,7 +126,7 @@ export function planSweepStations(contours, path, scales, options, frames) {
 }
 /** Inserts twist samples without calling authored guides again or changing original station meaning. */
 export function refineSweepStations(path, scales, frames, options, plan) {
-    const twist = ((options.twistDegrees ?? 0) / 180) * Math.PI;
+    const twistRadians = ((options.twist ?? 0) / 180) * Math.PI;
     const segmentCount = plan.intervals.length;
     const points = [], sampledScales = [], sampledFrames = [], twists = [];
     for (let i = 0; i < segmentCount; i++) {
@@ -148,14 +148,14 @@ export function refineSweepStations(path, scales, frames, options, plan) {
                     binormal: rotateAroundAxis3Radians(frames[i].binormal, rotation.axis, rotation.angle * amount),
                     tangent: rotateAroundAxis3Radians(frames[i].tangent, rotation.axis, rotation.angle * amount),
                 });
-            twists.push(twist * (plan.progress[i] + (plan.progress[i + 1] - plan.progress[i]) * amount));
+            twists.push(twistRadians * (plan.progress[i] + (plan.progress[i + 1] - plan.progress[i]) * amount));
         }
     }
     if (options.closed !== true) {
         points.push(path.at(-1));
         sampledScales.push(scales.at(-1));
         sampledFrames.push(frames.at(-1));
-        twists.push(twist);
+        twists.push(twistRadians);
     }
     return { path: points, scales: sampledScales, frames: sampledFrames, twists };
 }

package/dist/geometry/sweeps/sweep-closed.js

@@ -20,9 +20,9 @@ export const buildClosedSweepMesh = (profile, path, options = {}) => {
             operation,
         });
     }
-    const twistRadians = ((options.twistDegrees ?? 0) / 180) * Math.PI;
+    const twistRadians = ((options.twist ?? 0) / 180) * Math.PI;
     if (!Number.isFinite(twistRadians)) {
-        throw new GeometryError("NON_FINITE_VALUE", "Sweep twistDegrees must be finite.", {
+        throw new GeometryError("NON_FINITE_VALUE", "Sweep twist must be finite.", {
             operation,
         });
     }

package/dist/geometry/sweeps/sweep-mesh.js

@@ -1,4 +1,6 @@
 import { GeometryError } from "../errors.js";
+import { resolveModelingLimits } from "../model-limits.js";
+import { path2InputData, path3InputData, } from "../paths/path-value.js";
 import { validateSweepOptions } from "./orientation.js";
 import { buildClosedSweepMesh } from "./sweep-closed.js";
 import { buildOpenSweepMesh } from "./sweep-open.js";
@@ -15,12 +17,16 @@ import { buildOpenSweepMesh } from "./sweep-open.js";
  */
 export function sweepMesh(profile, path, options = {}) {
     validateSweepOptions(options);
-    if (options.closed === true) {
-        return buildClosedSweepMesh(profile, path, options);
+    const limits = resolveModelingLimits(options.limits);
+    const outline = path2InputData(profile, true, { maxPathPoints: limits.maxProfilePoints }).points;
+    const data = path3InputData(path, options.closed, limits);
+    const selected = { ...options, closed: data.closed };
+    if (data.closed) {
+        return buildClosedSweepMesh(outline, data.points, selected);
     }
     if ((options.seamProfileOffset ?? 0) !== 0)
         throw new GeometryError("INVALID_ARGUMENT", "A seamProfileOffset requires a closed path.", {
             operation: "sweep",
         });
-    return buildOpenSweepMesh(profile, path, options);
+    return buildOpenSweepMesh(outline, data.points, selected);
 }

package/dist/geometry/sweeps/sweep-open.js

@@ -13,7 +13,7 @@ export const buildOpenSweepMesh = (profile, path, options = {}) => {
     path = normalizeSweepPath(path, false, operation, options.limits);
     assertSweepAllocation(path.length, profile.length, false, operation, options.limits);
     let scales = resolveSweepScales(options.scale, path.length);
-    const twistRadians = ((options.twistDegrees ?? 0) / 180) * Math.PI;
+    const twistRadians = ((options.twist ?? 0) / 180) * Math.PI;
     if (twistRadians !== 0) {
         const plan = planSweepStations([profile], path, scales, options);
         assertSweepAllocation(plan.stationCount, profile.length, false, operation, options.limits);

package/dist/geometry/sweeps/validation.js

@@ -1,4 +1,5 @@
 import { GeometryError } from "../errors.js";
+import { vector3Data } from "../math/vector-value.js";
 import { assertMeshAllocationWithinLimits, resolveModelingLimits, } from "../model-limits.js";
 import { writeMeshVertex } from "../numeric.js";
 import { normalizeContour } from "../regions.js";
@@ -97,13 +98,8 @@ export function writeSweepVertex(positions, offset, point, operation) {
     writeMeshVertex(positions, offset, point, operation);
 }
 /** @internal Checks user-provided orientation controls before vector normalization. */
-export function validateSweepNormal(normal, operation) {
-    const hasArrayShape = Array.isArray(normal);
-    if (!hasArrayShape || normal.length !== 3) {
-        throw new GeometryError("INVALID_ARGUMENT", "Sweep normals must be exact XYZ tuples.", {
-            operation,
-        });
-    }
+export function validateSweepNormal(input, operation) {
+    const normal = vector3Data(input);
     if (![normal[0], normal[1], normal[2]].every(Number.isFinite)) {
         throw new GeometryError("NON_FINITE_VALUE", "Sweep normal coordinates must be finite XYZ values.", { operation });
     }
@@ -112,4 +108,5 @@ export function validateSweepNormal(normal, operation) {
             operation,
         });
     }
+    return normal;
 }

package/dist/geometry/transform-geometry.js

@@ -3,35 +3,28 @@ import { normalizeContour, normalizeRegion, signedContourArea } from "./regions.
 import { readTransformMatrix } from "./transform-matrix.js";
 import { embedTransform2 } from "./transform2.js";
 import { applyValidatedTransformPoint3, validateTransform3 } from "./transform3.js";
-/** Applies an affine transform to a 3D path without mutating its points. */
+/** Internal owned coordinates for a Path3 result; no mutable coordinates escape the path value. */
 export function transformPath3(path, placement) {
     const transform = readTransformMatrix(placement, 3);
     validateTransform3(transform);
-    return Object.freeze(path.map((point) => Object.freeze(applyValidatedTransformPoint3(transform, point))));
+    return path.map((point) => applyValidatedTransformPoint3(transform, point));
 }
 const transformPoint2 = (point, transform) => {
     const values = vector2Data(point);
     const transformed = applyValidatedTransformPoint3(transform, [values[0], values[1], 0]);
-    return Object.freeze([transformed[0], transformed[1]]);
+    return [transformed[0], transformed[1]];
 };
-const transformPlanarPath = (path, transform) => Object.freeze(path.map((point) => transformPoint2(point, transform)));
-/** Applies a canonical affine XY transform to a 2D path without changing point order. */
+const transformPlanarPath = (path, transform) => Object.freeze(path.map((point) => Object.freeze(transformPoint2(point, transform))));
+/** Internal owned XY coordinates preserving path traversal; public interchange is frozen by Path2. */
 export function transformPath2(path, transform, tolerance = {}) {
-    return transformPlanarPath(path, embedTransform2(readTransformMatrix(transform, 2), tolerance));
+    const matrix = embedTransform2(readTransformMatrix(transform, 2), tolerance);
+    return path.map((point) => transformPoint2(point, matrix));
 }
 const transformContourWithMatrix = (loop, transform, tolerance) => {
     const counterClockwise = signedContourArea(loop) > 0;
     const normalized = normalizeContour(loop, counterClockwise, tolerance);
     return normalizeContour(transformPlanarPath(normalized, transform), counterClockwise, tolerance);
 };
-/**
- * Applies a canonical affine XY transform to a closed loop and preserves its original winding.
- *
- * Reflections reverse the point order automatically through normalization.
- */
-export function transformContour(loop, transform, tolerance = {}) {
-    return transformContourWithMatrix(loop, embedTransform2(readTransformMatrix(transform, 2), tolerance), tolerance);
-}
 /**
  * Transforms serialized polygon data with reflection-safe winding, without an engine.
  * Use Section.transform(placement) when authoring filled geometry; this utility serves pure data preparation.

package/dist/index.js

@@ -1,6 +1,7 @@
 /** Immutable modeling recipes and math values; the host owns geometry evaluation. @packageDocumentation */
 export { transform2, transform3, } from "./geometry/transform-chain.js";
 export { vector2, vector3, } from "./geometry/math/vector-value.js";
+export { path2, path3, } from "./geometry/paths/path-value.js";
 export * from "./model/operations.js";
 export * from "./model/generation.js";
 export { immutableBuffer, immutableMesh } from "./model/immutable-buffer.js";

package/dist/model/execution-binding.js

@@ -1,7 +1,7 @@
 import { GeometryError } from "../geometry/errors.js";
 // One protocol key lets locally bundled operation wrappers resolve the host's execution
 // without depending on package instances, class identity, or initializing a native runtime.
-const executionKey = Symbol.for("@metamesh/modeling/execution/6");
+const executionKey = Symbol.for("@metamesh/modeling/execution/7");
 const bindings = globalThis;
 /** Internal host binding. Executable callbacks are synchronous and may not nest executions. */
 export function bindModelContext(context, build) {
@@ -10,7 +10,7 @@ export function bindModelContext(context, build) {
             operation: "build",
         });
     }
-    bindings[executionKey] = { version: 6, context };
+    bindings[executionKey] = { version: 7, context };
     try {
         return build();
     }
@@ -31,5 +31,5 @@ export function currentModelContext(operation) {
 /** Reads an optional binding without initializing an engine or creating ambient authoring state. */
 export function activeModelContext() {
     const binding = bindings[executionKey];
-    return binding?.version === 6 ? binding.context : undefined;
+    return binding?.version === 7 ? binding.context : undefined;
 }

package/dist/model/geometry-recipes.js

@@ -1,7 +1,7 @@
 import { createSectionHandle, createSolidHandle } from "./shape-handles.js";
 // One realm protocol lets bundled authoring code declare recipes before a host is initialized.
 // The payload contains no native handles and the engine remains responsible for realization.
-const recipeKey = Symbol.for("@metamesh/modeling/recipe/6");
+const recipeKey = Symbol.for("@metamesh/modeling/recipe/7");
 /** Reads private recipe metadata without requiring an execution context. */
 export const geometryRecipe = (value) => Object.getOwnPropertyDescriptor(value, recipeKey)?.value;
 /** Recognizes only opaque recipe handles issued by this engine. */