@metamesh/modeling 0.19.0 → 0.20.0

package/dist/geometry/svg/import.js

@@ -1,12 +1,12 @@
 import { SaxesParser } from "saxes";
 import { SVGPathData } from "svg-pathdata";
-import { bounds2 } from "../bounds-value.js";
-import { fitBounds } from "../bounds.js";
+import { fitBounds } from "../bounds/operations.js";
+import { bounds2 } from "../bounds/value.js";
 import { GeometryError } from "../errors.js";
-import { regionArea, signedContourArea } from "../regions.js";
-import { resolveCircularSegments, resolveGeometryResolution, } from "../resolution.js";
-import { resolveGeometrySamplingLimits } from "../sampling-limits.js";
-import { strokePathMultiPolygon } from "../stroke-path.js";
+import { regionArea, signedContourArea } from "../regions/operations.js";
+import { strokePathMultiPolygon } from "../regions/stroke.js";
+import { resolveGeometrySamplingLimits } from "../sampling/limits.js";
+import { resolveCircularSegments, resolveGeometryResolution, } from "../sampling/resolution.js";
 import { createBoundedSvgClipping } from "./fill.js";
 import { inverseMatrix, multiplyMatrices as multiply, transformPoint } from "./matrix.js";
 import { flattenSvgSubpaths, SvgVertexBudget } from "./path.js";
@@ -32,7 +32,7 @@ const SUPPORTED_TAGS = new Set([
 const SVG_NAMESPACE = "http://www.w3.org/2000/svg";
 const NUMBER_PATTERN = /^[-+]?(?:\d*\.\d+|\d+\.?)(?:e[-+]?\d+)?$/i;
 const SAFE_COLOR_PATTERN = /^(?:none|#[0-9a-f]{3,8}|(?:rgb|hsl)a?\([\d\s.,%+-]+\)|[a-z]+)$/i;
-const PRESENTATION_ATTRIBUTES = [
+const PAINT_ATTRIBUTES = new Set([
     "fill",
     "fill-opacity",
     "fill-rule",
@@ -41,9 +41,8 @@ const PRESENTATION_ATTRIBUTES = [
     "stroke-linejoin",
     "stroke-opacity",
     "stroke-width",
-    "style",
-];
-const COMMON_ATTRIBUTES = new Set(["id", "name", "transform", ...PRESENTATION_ATTRIBUTES]);
+]);
+const COMMON_ATTRIBUTES = new Set(["id", "name", "transform", "style", ...PAINT_ATTRIBUTES]);
 const ATTRIBUTES_BY_TAG = {
     svg: new Set([
         ...COMMON_ATTRIBUTES,
@@ -170,22 +169,12 @@ function inlineStyle(value) {
     if (value === undefined || value.trim() === "")
         return {};
     const output = {};
-    const allowed = new Set([
-        "fill",
-        "fill-opacity",
-        "fill-rule",
-        "stroke",
-        "stroke-linecap",
-        "stroke-linejoin",
-        "stroke-opacity",
-        "stroke-width",
-    ]);
     for (const declaration of value.split(";")) {
         if (declaration.trim() === "")
             continue;
         const separator = declaration.indexOf(":");
         const key = declaration.slice(0, separator).trim().toLowerCase();
-        if (separator <= 0 || !allowed.has(key))
+        if (separator <= 0 || !PAINT_ATTRIBUTES.has(key))
             return fail(`Unsupported SVG style “${key}”.`);
         output[key] = declaration.slice(separator + 1).trim();
     }
@@ -346,6 +335,7 @@ function adaptivePathSubpaths(d, transform, resolution, budget, estimate = false
     }
 }
 function elementSubpaths(tag, values, transform, resolution, budget, estimate = false) {
+    let pathData;
     switch (tag) {
         case "rect": {
             const x = finite(values.x, 0);
@@ -357,25 +347,19 @@ function elementSubpaths(tag, values, transform, resolution, budget, estimate =
             const rx = values.rx === undefined ? finite(values.ry, 0) : finite(values.rx, 0);
             const ry = values.ry === undefined ? rx : finite(values.ry, 0);
             if (rx === 0 || ry === 0) {
-                return adaptivePathSubpaths(`M${x} ${y}H${x + width}V${y + height}H${x}Z`, transform, resolution, budget, estimate);
+                pathData = `M${x} ${y}H${x + width}V${y + height}H${x}Z`;
             }
-            const radiusX = Math.min(Math.max(0, rx), width / 2);
-            const radiusY = Math.min(Math.max(0, ry), height / 2);
-            return adaptivePathSubpaths(`M${x + radiusX} ${y}H${x + width - radiusX}A${radiusX} ${radiusY} 0 0 1 ${x + width} ${y + radiusY}V${y + height - radiusY}A${radiusX} ${radiusY} 0 0 1 ${x + width - radiusX} ${y + height}H${x + radiusX}A${radiusX} ${radiusY} 0 0 1 ${x} ${y + height - radiusY}V${y + radiusY}A${radiusX} ${radiusY} 0 0 1 ${x + radiusX} ${y}Z`, transform, resolution, budget, estimate);
-        }
-        case "circle": {
-            const radius = finite(values.r);
-            const segments = resolveCircularSegments(radius * maximumLinearScale(transform), resolution, budget.limits);
-            return [
-                {
-                    closed: true,
-                    points: ellipsePoints(finite(values.cx, 0), finite(values.cy, 0), radius, radius, segments, budget),
-                },
-            ];
+            else {
+                const radiusX = Math.min(Math.max(0, rx), width / 2);
+                const radiusY = Math.min(Math.max(0, ry), height / 2);
+                pathData = `M${x + radiusX} ${y}H${x + width - radiusX}A${radiusX} ${radiusY} 0 0 1 ${x + width} ${y + radiusY}V${y + height - radiusY}A${radiusX} ${radiusY} 0 0 1 ${x + width - radiusX} ${y + height}H${x + radiusX}A${radiusX} ${radiusY} 0 0 1 ${x} ${y + height - radiusY}V${y + radiusY}A${radiusX} ${radiusY} 0 0 1 ${x + radiusX} ${y}Z`;
+            }
+            break;
         }
+        case "circle":
         case "ellipse": {
-            const radiusX = finite(values.rx);
-            const radiusY = finite(values.ry);
+            const radiusX = finite(tag === "circle" ? values.r : values.rx);
+            const radiusY = tag === "circle" ? radiusX : finite(values.ry);
             const segments = resolveCircularSegments(Math.max(radiusX, radiusY) * maximumLinearScale(transform), resolution, budget.limits);
             return [
                 {
@@ -385,20 +369,23 @@ function elementSubpaths(tag, values, transform, resolution, budget, estimate =
             ];
         }
         case "line":
-            return adaptivePathSubpaths(`M${finite(values.x1, 0)} ${finite(values.y1, 0)}L${finite(values.x2, 0)} ${finite(values.y2, 0)}`, transform, resolution, budget, estimate);
-        case "polyline": {
-            const points = parsePoints(values.points);
-            return adaptivePathSubpaths(points.map(([x, y], index) => `${index === 0 ? "M" : "L"}${x} ${y}`).join(""), transform, resolution, budget, estimate);
-        }
+            pathData = `M${finite(values.x1, 0)} ${finite(values.y1, 0)}L${finite(values.x2, 0)} ${finite(values.y2, 0)}`;
+            break;
+        case "polyline":
         case "polygon": {
             const points = parsePoints(values.points);
-            return adaptivePathSubpaths(`${points.map(([x, y], index) => `${index === 0 ? "M" : "L"}${x} ${y}`).join("")}Z`, transform, resolution, budget, estimate);
+            pathData = points.map(([x, y], index) => `${index === 0 ? "M" : "L"}${x} ${y}`).join("");
+            if (tag === "polygon")
+                pathData += "Z";
+            break;
         }
         case "path":
-            return adaptivePathSubpaths(values.d ?? "", transform, resolution, budget, estimate);
+            pathData = values.d ?? "";
+            break;
         default:
             return [];
     }
+    return adaptivePathSubpaths(pathData, transform, resolution, budget, estimate);
 }
 function strokeConstructionVertexCount(subpath, paint, circularSegments) {
     const minimumPoints = subpath.closed ? 3 : 2;
@@ -413,7 +400,9 @@ function strokeConstructionVertexCount(subpath, paint, circularSegments) {
                 : paint.strokeLinejoin === "miter"
                     ? 4
                     : 3) +
-        (!subpath.closed && paint.strokeLinecap === "round" ? 2 * circularSegments : 0));
+        (!subpath.closed && paint.strokeLinecap === "round"
+            ? 2 * (Math.ceil(circularSegments / 2) - 1)
+            : 0));
 }
 function transformMultiPolygon(value, matrix) {
     return value.map((polygon) => polygon.map((path) => path.map((point) => {
@@ -425,12 +414,6 @@ function polygonArea(polygon) {
     return (Math.abs(signedContourArea(polygon.outer)) -
         polygon.holes.reduce((total, hole) => total + Math.abs(signedContourArea(hole)), 0));
 }
-function loopEdgeLengths(loop) {
-    return loop.map((point, index) => {
-        const next = loop[(index + 1) % loop.length];
-        return Math.hypot(next[0] - point[0], next[1] - point[1]);
-    });
-}
 function measureSvgRegion(region) {
     const holes = region.reduce((total, polygon) => total + polygon.holes.length, 0);
     let maxX = Number.NEGATIVE_INFINITY;
@@ -443,13 +426,14 @@ function measureSvgRegion(region) {
     for (const polygon of region) {
         for (const loop of [polygon.outer, ...polygon.holes]) {
             vertices += loop.length;
-            for (const point of loop) {
+            for (let index = 0; index < loop.length; index += 1) {
+                const point = loop[index];
+                const next = loop[(index + 1) % loop.length];
                 minX = Math.min(minX, point[0]);
                 minY = Math.min(minY, point[1]);
                 maxX = Math.max(maxX, point[0]);
                 maxY = Math.max(maxY, point[1]);
-            }
-            for (const length of loopEdgeLengths(loop)) {
+                const length = Math.hypot(next[0] - point[0], next[1] - point[1]);
                 minEdgeLength = Math.min(minEdgeLength, length);
                 if (length < SHORT_EDGE_LENGTH_MM)
                     shortEdgeCount += 1;
@@ -475,18 +459,13 @@ function measureSvgRegion(region) {
     });
 }
 /**
- * Parses the bounded SVG subset into a robust millimetre region and an import-review report.
+ * Runs one bounded SVG import pass, optionally retaining coarse spans for fitted bounds.
  *
  * Presentation colors are ignored, but every visible fill and positive-width stroke contributes
  * geometry. Open filled subpaths use SVG's implicit closure while open strokes remain open.
  * Transforms and declared physical units are flattened, viewport placement is explicit, and
  * metadata is ignored. Tiny-island and short-edge counts are conservative physical indicators,
  * not proof of raster provenance or process-specific manufacturability.
- *
- * @param svg - Complete SVG XML source, limited to 256 KiB of UTF-8.
- * @param options - Physical flattening and viewport-origin controls.
- * @returns The normalized sampled region plus bounded review metrics and repairs.
- * @throws {@link GeometryError} When XML, supported-feature, geometry, or complexity checks fail.
  */
 function createSvgRegionPreflight(svg, options = {}, estimate = false) {
     const bytes = new TextEncoder().encode(svg).byteLength;
@@ -566,7 +545,8 @@ function createSvgRegionPreflight(svg, options = {}, estimate = false) {
         }
         if (tag === "svg" && parent !== undefined)
             return fail("Nested SVG roots are not supported.");
-        let transform = multiply(parent?.transform ?? [1, 0, 0, 1, 0, 0], parseTransform(values.transform));
+        const localTransform = parseTransform(values.transform);
+        let transform = multiply(parent?.transform ?? [1, 0, 0, 1, 0, 0], localTransform);
         const paint = parsePaint(values, parent?.paint ?? DEFAULT_PAINT);
         if (tag === "svg") {
             if (rootSeen)
@@ -576,7 +556,7 @@ function createSvgRegionPreflight(svg, options = {}, estimate = false) {
             const [, , viewWidth, viewHeight] = box;
             const width = lengthMm(values.width, viewWidth);
             const height = lengthMm(values.height, viewHeight);
-            transform = multiply(canvasTransform(values, width, height, box, origin), parseTransform(values.transform));
+            transform = multiply(canvasTransform(values, width, height, box, origin), localTransform);
             if (options.fit !== undefined) {
                 // Fitted artwork has no meaningful source-unit topology tolerance. Keep sampling,
                 // stroking and clipping near a unit viewport, then compose this physical-unit scale
@@ -592,6 +572,8 @@ function createSvgRegionPreflight(svg, options = {}, estimate = false) {
             elementCount += 1;
             if (elementCount > MAX_SVG_ELEMENTS)
                 return fail(`SVG geometry may contain at most ${MAX_SVG_ELEMENTS} elements.`);
+            // Flatten with transformed error bounds, retaining source coordinates for stroke widths.
+            // Fills can use transformed points immediately; stroke outlines must be built locally first.
             const localSubpaths = elementSubpaths(tag, values, transform, resolution, budget, estimate);
             const subpaths = localSubpaths.map((subpath) => ({
                 ...subpath,
@@ -607,6 +589,7 @@ function createSvgRegionPreflight(svg, options = {}, estimate = false) {
             if (!paintedFill && !paintedStroke)
                 invisibleElementCount += 1;
             if (paintedFill) {
+                // SVG implicitly closes filled paths without closing those same paths for strokes.
                 implicitFilledClosureCount += subpaths.filter((subpath) => !subpath.closed && subpath.points.length >= 3).length;
                 appendGeometry(elementGeometry, fillGeometry(subpaths, paint.fillRule), "element fill output");
             }
@@ -681,7 +664,7 @@ function createSvgRegionPreflight(svg, options = {}, estimate = false) {
  * manufacturability or later solid validity.
  *
  * @param svg - Complete SVG XML source, limited to 256 KiB of UTF-8.
- * @param options - Physical flattening and viewport-origin controls.
+ * @param options - Physical sampling, viewport origin, and optional fitting to millimetre bounds.
  * @returns The canonical normalized region plus bounded source, topology, and safe-repair facts.
  * @throws {@link GeometryError} When XML, supported-feature, geometry, or complexity checks fail.
  */
@@ -689,7 +672,7 @@ export function preflightSvgRegion(svg, options = {}) {
     if (options.fit === undefined)
         return createSvgRegionPreflight(svg, options)[0];
     // Capture mutable caller data once; all refinement passes fit to the same finite target.
-    const target = bounds2(options.fit);
+    const target = bounds2(options.fit).toData();
     const resolution = svgResolution(options);
     let samplingScale = 1;
     for (let pass = 0; pass < MAX_SVG_FIT_PASSES; pass++) {

package/dist/geometry/svg/path.js

@@ -1,9 +1,9 @@
 import { SVGPathData, SVGPathDataTransformer } from "svg-pathdata";
-import { resolveArcSegments, resolveGeometryResolution, } from "../resolution.js";
-import { assertSamplingCount, resolveGeometrySamplingLimits, } from "../sampling-limits.js";
+import { assertSamplingCount, resolveGeometrySamplingLimits, } from "../sampling/limits.js";
+import { resolveArcSegments, resolveGeometryResolution, } from "../sampling/resolution.js";
 import { complexity, invalid, rethrowAsInvalid } from "./errors.js";
 import { transformPoint } from "./matrix.js";
-export const MAX_CURVE_RECURSION = 16;
+const MAX_CURVE_RECURSION = 16;
 export class SvgVertexBudget {
     limits;
     #emittedCount = 0;

package/dist/geometry/sweep/closed.js

@@ -0,0 +1,55 @@
+import { add3, rotateAroundAxis3Radians, scale3 } from "../math/vector3.js";
+import { validateTriangleMesh } from "../mesh/operations.js";
+import { validateSweepOptions } from "./orientation.js";
+import { sweepSeamOffset } from "./seam.js";
+import { prepareSweepStations, resolveSweepScales } from "./stations.js";
+import { assertSweepAllocation, normalizeSweepPath, normalizeSweepProfile, writeSweepVertex, } from "./validation.js";
+/** @internal Checks host allocation policy before frames or manufacturing buffers. */
+export const buildClosedSweepMesh = (profile, inputPath, options = {}) => {
+    const operation = "sweep";
+    validateSweepOptions(options);
+    profile = normalizeSweepProfile(profile, operation, options.limits);
+    const normalizedPath = normalizeSweepPath(inputPath, true, operation, options.limits);
+    assertSweepAllocation(normalizedPath.length, profile.length, true, operation, options.limits);
+    const originalScales = resolveSweepScales(options.scale, normalizedPath, options.closed);
+    const twistRadians = ((options.twist ?? 0) / 180) * Math.PI;
+    const ringVertexCount = profile.length;
+    const normalizedSeamProfileOffset = sweepSeamOffset(profile, originalScales[0], options.twist ?? 0);
+    const { path, scales, frames: transportedFrames, twists, } = prepareSweepStations([profile], normalizedPath, originalScales, options, (count) => assertSweepAllocation(count, profile.length, true, operation, options.limits));
+    const positions = new Float32Array(path.length * ringVertexCount * 3);
+    for (let ring = 0; ring < path.length; ring += 1) {
+        const point = path[ring];
+        const tangent = transportedFrames[ring].tangent;
+        const twist = twists?.[ring] ?? twistRadians * (ring / path.length);
+        const baseNormal = transportedFrames[ring].normal;
+        const normal = rotateAroundAxis3Radians(baseNormal, tangent, twist);
+        const binormal = rotateAroundAxis3Radians(transportedFrames[ring].binormal, tangent, twist);
+        const [scaleX, scaleY] = scales[ring];
+        for (let profileIndex = 0; profileIndex < profile.length; profileIndex += 1) {
+            const [x, y] = profile[profileIndex];
+            const vertex = add3(point, add3(scale3(normal, x * scaleX), scale3(binormal, y * scaleY)));
+            writeSweepVertex(positions, (ring * ringVertexCount + profileIndex) * 3, vertex, operation);
+        }
+    }
+    const indices = new Uint32Array(path.length * ringVertexCount * 2 * 3);
+    let cursor = 0;
+    for (let ring = 0; ring < path.length; ring += 1) {
+        const nextRing = (ring + 1) % path.length;
+        const nextProfileOffset = nextRing === 0 ? normalizedSeamProfileOffset : 0;
+        for (let profileIndex = 0; profileIndex < ringVertexCount; profileIndex += 1) {
+            const following = (profileIndex + 1) % ringVertexCount;
+            const a = ring * ringVertexCount + profileIndex;
+            const b = ring * ringVertexCount + following;
+            const c = nextRing * ringVertexCount + ((following + nextProfileOffset) % ringVertexCount);
+            const d = nextRing * ringVertexCount + ((profileIndex + nextProfileOffset) % ringVertexCount);
+            indices[cursor] = a;
+            indices[cursor + 1] = b;
+            indices[cursor + 2] = c;
+            indices[cursor + 3] = a;
+            indices[cursor + 4] = c;
+            indices[cursor + 5] = d;
+            cursor += 6;
+        }
+    }
+    return validateTriangleMesh({ indices, positions });
+};

package/dist/geometry/sweep/mesh.js

@@ -0,0 +1,30 @@
+import { resolveModelingLimits } from "../limits.js";
+import { pointLoftProfile, prepareLoftGeometry } from "../loft/geometry.js";
+import { simpleLoftMesh } from "../loft/simple-mesh.js";
+import { path2InputData, path3InputData, } from "../paths/value.js";
+import { buildClosedSweepMesh } from "./closed.js";
+import { buildOpenSweepMesh } from "./open.js";
+import { validateSweepOptions, validateSweepTransformOptions } from "./orientation.js";
+import { isSweepTransformRoute, sweepTransforms } from "./transforms.js";
+import { normalizeSweepProfile } from "./validation.js";
+export function sweepMesh(profile, route, options = {}) {
+    const explicit = isSweepTransformRoute(route);
+    if (explicit)
+        validateSweepTransformOptions(options);
+    else
+        validateSweepOptions(options);
+    const limits = resolveModelingLimits(options.limits);
+    const outline = path2InputData(profile, true, { maxPathPoints: limits.maxProfilePoints }).points;
+    if (explicit) {
+        const transforms = sweepTransforms(route, options.closed ?? false, limits);
+        const profile = pointLoftProfile(normalizeSweepProfile(outline, "sweep", limits));
+        const geometry = prepareLoftGeometry(transforms.map((transform) => ({ profile, transform })), {}, limits, true);
+        return simpleLoftMesh(geometry, limits, options.closed ?? false);
+    }
+    const data = path3InputData(route, options.closed, limits);
+    const selected = { ...options, closed: data.closed };
+    if (data.closed) {
+        return buildClosedSweepMesh(outline, data.points, selected);
+    }
+    return buildOpenSweepMesh(outline, data.points, selected);
+}

package/dist/geometry/{sweeps/sweep-open.js → sweep/open.js}

@@ -1,34 +1,19 @@
-import { triangulateContour } from "../loft/loft.js";
 import { add3, rotateAroundAxis3Radians, scale3 } from "../math/vector3.js";
-import { validateTriangleMesh } from "../mesh/mesh.js";
-import { resolveSweepScales } from "./options.js";
-import { computeSweepFrames, validateSweepOptions } from "./orientation.js";
-import { planSweepStations, refineSweepStations } from "./stations.js";
+import { validateTriangleMesh } from "../mesh/operations.js";
+import { triangulateContour } from "../regions/triangulation.js";
+import { validateSweepOptions } from "./orientation.js";
+import { prepareSweepStations, resolveSweepScales } from "./stations.js";
 import { assertSweepAllocation, normalizeSweepPath, normalizeSweepProfile, writeSweepVertex, } from "./validation.js";
 /** @internal Checks host allocation policy before frames, caps or manufacturing buffers. */
-export const buildOpenSweepMesh = (profile, path, options = {}) => {
+export const buildOpenSweepMesh = (profile, inputPath, options = {}) => {
     const operation = "sweep";
     validateSweepOptions(options);
     profile = normalizeSweepProfile(profile, operation, options.limits);
-    path = normalizeSweepPath(path, false, operation, options.limits);
-    assertSweepAllocation(path.length, profile.length, false, operation, options.limits);
-    let scales = resolveSweepScales(options.scale, path.length);
+    const normalizedPath = normalizeSweepPath(inputPath, false, operation, options.limits);
+    assertSweepAllocation(normalizedPath.length, profile.length, false, operation, options.limits);
+    const originalScales = resolveSweepScales(options.scale, normalizedPath, options.closed);
     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);
-    }
-    let frames = computeSweepFrames(path, options);
-    let twists;
-    if (twistRadians !== 0) {
-        const plan = planSweepStations([profile], path, scales, options, frames);
-        assertSweepAllocation(plan.stationCount, profile.length, false, operation, options.limits);
-        const refined = refineSweepStations(path, scales, frames, options, plan);
-        path = refined.path;
-        scales = refined.scales;
-        frames = refined.frames;
-        twists = refined.twists;
-    }
+    const { path, scales, frames, twists } = prepareSweepStations([profile], normalizedPath, originalScales, options, (count) => assertSweepAllocation(count, profile.length, false, operation, options.limits));
     const caps = triangulateContour(profile);
     const ringVertexCount = profile.length;
     const sideVertexCount = path.length * ringVertexCount;

package/dist/geometry/{sweeps → sweep}/orientation.js

@@ -1,24 +1,25 @@
 import { GeometryError } from "../errors.js";
 import { cross3, normalize3, projectOntoPlane3, subtract3 } from "../math/vector3.js";
 import { computeClosedParallelTransportFrames, computeParallelTransportFrames, } from "../paths/frames.js";
+import { resolveGeometryResolution } from "../sampling/resolution.js";
 import { validateSweepNormal } from "./validation.js";
 const fail = (message, code = "INVALID_ARGUMENT") => {
     throw new GeometryError(code, message, { operation: "sweep" });
 };
-/** @internal Validates the canonical sweep controls without evaluating authored guides. */
+/** @internal Validates explicit station controls without accepting path deformation. */
+export function validateSweepTransformOptions(options) {
+    if (typeof options !== "object" || options === null || Array.isArray(options))
+        fail("Sweep options must be an object.");
+    if (Object.keys(options).some((key) => !["closed", "limits"].includes(key)))
+        fail("Explicit sweep transforms cannot be combined with path controls.");
+    if (options.closed !== undefined && typeof options.closed !== "boolean")
+        fail("Sweep closed must be boolean.");
+}
+/** @internal Validates path controls without evaluating authored normal guides. */
 export function validateSweepOptions(options) {
     if (typeof options !== "object" || options === null || Array.isArray(options))
         fail("Sweep options must be an object.");
-    const allowed = [
-        "closed",
-        "limits",
-        "orientation",
-        "resolution",
-        "twist",
-        "twistBy",
-        "scale",
-        "seamProfileOffset",
-    ];
+    const allowed = ["closed", "limits", "orientation", "resolution", "twist", "twistBy", "scale"];
     if (Object.keys(options).some((key) => !allowed.includes(key)))
         fail("Unsupported sweep option.");
     if (options.closed !== undefined && typeof options.closed !== "boolean")
@@ -31,6 +32,8 @@ export function validateSweepOptions(options) {
         throw new GeometryError("NON_FINITE_VALUE", "Sweep twist must be finite.", {
             operation: "sweep",
         });
+    if (options.resolution !== undefined)
+        resolveGeometryResolution(options.resolution, options.limits);
     const policy = options.orientation;
     if (policy === undefined)
         return;

package/dist/geometry/sweep/seam.js

@@ -0,0 +1,30 @@
+import { GeometryError } from "../errors.js";
+import { resolveGeometryTolerance } from "../tolerance.js";
+/** @internal Finds a verified cyclic closure; ordinary full turns retain the zero-offset path. */
+export function sweepSeamOffset(profile, scale, twist) {
+    const angle = ((twist % 360) * Math.PI) / 180;
+    const cosine = Math.cos(angle), sine = Math.sin(angle);
+    const points = profile.map(([x, y]) => [x * scale[0], y * scale[1]]);
+    const tolerance = resolveGeometryTolerance(points.reduce((extent, [x, y]) => Math.max(extent, Math.abs(x), Math.abs(y)), 1)).linear;
+    const rotated = points.map(([x, y]) => [
+        x * cosine - y * sine,
+        x * sine + y * cosine,
+    ]);
+    let comparisons = 0;
+    const matches = (index, offset) => {
+        if (++comparisons > 1_000_000)
+            throw new GeometryError("COMPLEXITY_LIMIT", "Sweep seam matching exceeded its comparison budget.", { operation: "sweep" });
+        const a = rotated[index], b = points[(index + offset) % points.length];
+        return Math.hypot(a[0] - b[0], a[1] - b[1]) <= tolerance;
+    };
+    for (let offset = 0; offset < points.length; offset++) {
+        if (!matches(0, offset))
+            continue;
+        let index = 1;
+        while (index < points.length && matches(index, offset))
+            index++;
+        if (index === points.length)
+            return offset;
+    }
+    throw new GeometryError("INVALID_TOPOLOGY", "Sweep twist must return every profile boundary to a coincident cyclic alignment.", { operation: "sweep" });
+}

package/dist/geometry/{sweeps → sweep}/stations.js

@@ -1,7 +1,9 @@
 import { GeometryError } from "../errors.js";
+import { vector2Data } from "../math/vector-value.js";
 import { cross3, dot3, lerp3, normalize3, rotateAroundAxis3Radians } from "../math/vector3.js";
-import { resolveGeometryResolution } from "../resolution.js";
-import { assertSamplingCount, resolveGeometrySamplingLimits } from "../sampling-limits.js";
+import { assertSamplingCount, resolveGeometrySamplingLimits } from "../sampling/limits.js";
+import { resolveGeometryResolution } from "../sampling/resolution.js";
+import { computeSweepFrames } from "./orientation.js";
 /** @internal Original station progression, with a virtual final seam endpoint for closed paths. */
 export function sweepProgress(path, options) {
     if (options.twistBy !== undefined &&
@@ -24,6 +26,62 @@ export function sweepProgress(path, options) {
         throw new GeometryError("DEGENERATE_GEOMETRY", "Sweep progression needs finite positive path length.", { operation: "sweep" });
     return cumulative.map((length) => length / total);
 }
+/** @internal Resolves positive physical station scales independently of twist progression. */
+export function resolveSweepScales(scale, path, closed = false) {
+    const fail = () => {
+        throw new GeometryError("INVALID_ARGUMENT", "Sweep scales must be positive finite XY pairs, with one pair per original station when varying.", { operation: "sweep" });
+    };
+    const pair = (value) => {
+        if (typeof value === "number") {
+            if (!(value > 0) || !Number.isFinite(value))
+                fail();
+            return [value, value];
+        }
+        const coordinates = vector2Data(value);
+        if (!coordinates.every((n) => Number.isFinite(n) && n > 0))
+            fail();
+        return coordinates;
+    };
+    if (scale === undefined ||
+        typeof scale === "number" ||
+        (typeof scale === "object" && scale !== null && "toData" in scale) ||
+        (Array.isArray(scale) && typeof scale[0] === "number")) {
+        const value = pair(scale ?? 1);
+        if (closed || (value[0] === 1 && value[1] === 1))
+            return Array.from({ length: path.length }, () => value);
+        return sweepProgress(path, {}).map((amount) => [
+            1 + (value[0] - 1) * amount,
+            1 + (value[1] - 1) * amount,
+        ]);
+    }
+    if (!Array.isArray(scale) || scale.length !== path.length)
+        fail();
+    return scale.map(pair);
+}
+/** @internal Untwisted, constant-scale sweeps keep their original station-only mesh. */
+function needsSweepRefinement(scales, options) {
+    return ((options.twist ?? 0) !== 0 ||
+        options.resolution?.maxSegmentLength !== undefined ||
+        scales.some((scale, i) => i > 0 && (scale[0] !== scales[i - 1][0] || scale[1] !== scales[i - 1][1])));
+}
+/**
+ * @internal Prepares frames and refinement after caller-owned normalization, initial allocation,
+ * scales and seam checks. Rejects predicted work before authored guides, then checks frame-aware
+ * work before interpolation. Callers retain their own simple or hole-aware allocation budgets.
+ */
+export function prepareSweepStations(contours, path, scales, options, assertAllocation) {
+    const refine = needsSweepRefinement(scales, options);
+    if (refine) {
+        const plan = planSweepStations(contours, path, scales, options);
+        assertAllocation(plan.stationCount);
+    }
+    const frames = computeSweepFrames(path, options);
+    if (!refine)
+        return { path, scales, frames, twists: undefined };
+    const plan = planSweepStations(contours, path, scales, options, frames);
+    assertAllocation(plan.stationCount);
+    return refineSweepStations(path, scales, frames, options, plan);
+}
 /** Shortest rotation between two right-handed transported frames, including a stable half turn. */
 function frameRotation(from, to) {
     const cosine = Math.max(-1, Math.min(1, (dot3(from.normal, to.normal) +
@@ -61,7 +119,7 @@ function frameRotation(from, to) {
             halfTurn[i] = (matrix[i][principal] + matrix[principal][i]) / (4 * component);
     return { axis: normalize3(halfTurn), angle };
 }
-/** Plans refinement of the whole triangulated surface, including its mixed edge/twist error. */
+/** @internal Plans refinement of the whole triangulated surface, including its mixed edge/twist error. */
 export function planSweepStations(contours, path, scales, options, frames) {
     const closed = options.closed ?? false;
     const segmentCount = closed ? path.length : path.length - 1;
@@ -72,7 +130,7 @@ export function planSweepStations(contours, path, scales, options, frames) {
         });
     const intervals = [];
     const progress = sweepProgress(path, options);
-    if (twistRadians === 0)
+    if (!needsSweepRefinement(scales, options))
         return { intervals: Array(segmentCount).fill(1), stationCount: path.length, progress };
     const resolution = resolveGeometryResolution(options.resolution, options.limits);
     const limits = resolveGeometrySamplingLimits(options.limits);
@@ -101,11 +159,18 @@ export function planSweepStations(contours, path, scales, options, frames) {
         // term bounds the mixed profile-edge/station derivative; bounding only vertex
         // trajectories misses the systematic inward bias of a twisted quad diagonal.
         const curvature = radius * (maximumScale * (angle * angle + frameAngle * twistStep) + 2 * scaleChange * angle);
-        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.minSegments * angle) / (2 * Math.PI)))
-            : Math.max(1, Math.ceil((resolution.circularSegments * angle) / (2 * Math.PI)));
+        const a = curvature / 8, 
+        // A straight homothetic taper has planar walls; only differential XY
+        // scaling adds mixed surface error when the frame and twist stay fixed.
+        mixedScaleChange = angle === 0 && scales[i][0] * scales[next][1] === scales[i][1] * scales[next][0]
+            ? 0
+            : scaleChange, b = (edgeLength * (maximumScale * angle + mixedScaleChange)) / 4;
+        const requiredPhysical = Math.max(1, Math.ceil((b + Math.hypot(b, 2 * Math.sqrt(a * resolution.maxChordError))) /
+            (2 * resolution.maxChordError)));
+        const angularIntervals = Math.max(1, Math.ceil(((resolution.circularSegments ?? resolution.minSegments) * angle) / (2 * Math.PI)));
+        const requiredAngular = resolution.circularSegments === undefined || scaleChange > 0
+            ? Math.max(requiredPhysical, angularIntervals)
+            : angularIntervals;
         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}.`, {
@@ -124,7 +189,7 @@ export function planSweepStations(contours, path, scales, options, frames) {
     }
     return { intervals, stationCount, progress };
 }
-/** Inserts twist samples without calling authored guides again or changing original station meaning. */
+/** @internal Inserts physical samples without recalling authored guides or changing original station meaning. */
 export function refineSweepStations(path, scales, frames, options, plan) {
     const twistRadians = ((options.twist ?? 0) / 180) * Math.PI;
     const segmentCount = plan.intervals.length;

package/dist/geometry/sweep/transforms.js

@@ -0,0 +1,30 @@
+import { GeometryError } from "../errors.js";
+import { assertSamplingCount } from "../sampling/limits.js";
+import { isFrame3Input } from "../transforms/matrix-input.js";
+import { transform3 } from "../transforms/value.js";
+/** @internal Distinguishes point paths from placements without allocating a frame matrix. */
+export function isSweepTransformRoute(route) {
+    if (!Array.isArray(route) || route.length === 0)
+        return false;
+    const first = route[0];
+    if (Array.isArray(first))
+        return first.length === 16;
+    const method = typeof first === "object" && first !== null ? Reflect.get(first, "toData") : undefined;
+    if (typeof method !== "function")
+        return isFrame3Input(first);
+    const data = Reflect.apply(method, first, []);
+    return Array.isArray(data) && data.length === 16;
+}
+/** @internal Checks station budgets before capturing explicit affine placements. */
+export function sweepTransforms(transforms, closed, limits) {
+    if (!Array.isArray(transforms) || transforms.length < (closed ? 3 : 2))
+        throw new GeometryError("INVALID_ARGUMENT", "Sweep requires at least two transforms, or three for a closed sweep.", { operation: "sweep" });
+    assertSamplingCount(transforms.length, "sweep", limits.maxPathPoints);
+    return Array.from(transforms, (placement) => {
+        if (placement === undefined)
+            throw new GeometryError("INVALID_ARGUMENT", "Every sweep station requires a transform.", {
+                operation: "sweep",
+            });
+        return transform3(placement).toData();
+    });
+}