@metamesh/modeling 0.19.0 → 0.20.0

package/dist/engine/operations/construction.js

@@ -1,22 +1,23 @@
-import { edgeTreatmentSetbacks } from "../../geometry/edge-finishing.js";
 import { GeometryError } from "../../geometry/errors.js";
-import { resolveExtrusionContourDivisions, resolveExtrusionControls, } from "../../geometry/extrusion.js";
-import { heightfieldMesh } from "../../geometry/heightfield.js";
+import { resolveExtrusionContourSlices, resolveExtrusionControls, } from "../../geometry/extrusion/controls.js";
 import { immutableMeshView } from "../../geometry/immutable-buffer.js";
+import { assertMeshAllocationWithinLimits, resolveModelingLimits } from "../../geometry/limits.js";
 import { vector2Data, vector3Data } from "../../geometry/math/vector-value.js";
-import { assertMeshAllocationWithinLimits } from "../../geometry/model-limits.js";
-import { path3InputData } from "../../geometry/paths/path-value.js";
-import { assertPrimitiveOptions } from "../../geometry/primitive-resolvers.js";
-import { matchProfiles } from "../../geometry/profiles/match-profiles.js";
-import { resolveGeometryResolution } from "../../geometry/resolution.js";
-import { assertSamplingCount } from "../../geometry/sampling-limits.js";
-import { sweepMesh } from "../../geometry/sweeps/sweep-mesh.js";
+import { heightfieldMesh } from "../../geometry/mesh/heightfield.js";
+import { path3InputData } from "../../geometry/paths/value.js";
+import { edgeTreatmentSetbacks } from "../../geometry/primitives/edges.js";
+import { assertPrimitiveOptions } from "../../geometry/primitives/resolvers.js";
+import { assertSamplingCount } from "../../geometry/sampling/limits.js";
+import { resolveGeometryResolution } from "../../geometry/sampling/resolution.js";
+import { sweepMesh } from "../../geometry/sweep/mesh.js";
+import { validateSweepOptions, validateSweepTransformOptions, } from "../../geometry/sweep/orientation.js";
+import { isSweepTransformRoute, sweepTransforms } from "../../geometry/sweep/transforms.js";
 import { triangleMeshToManifold } from "../native/adapter.js";
 import { ownScopedManifoldValue, scopedManifoldScope, trackScopedManifoldValue, } from "../native/context.js";
 import * as kernel from "../native/index.js";
 import { buildFinishedExtrusion } from "./extrusion-finishing.js";
 import { createLoftOperation } from "./loft.js";
-import { buildProfileSweepMesh } from "./primitives/profile-mesh.js";
+import { buildProfileLoftMesh, buildProfileSweepMesh } from "./primitives/profile-mesh.js";
 /** Internal host-bound construction operations. */
 export function createConstructionOperations(environment, sections) {
     const { module, scope, limits, assertActive, throwGeometryError, resolveHandle, nativeSolid, nativeSection, wrapSolid, wrapSection, ownSolid, ownSection, validateFiniteNumber, requirePositiveNumber, validateCoordinates, assertOperandCount, assertMeshAllocation, withResolutionDefaults, resolveCircularSegments, } = environment;
@@ -56,26 +57,67 @@ export function createConstructionOperations(environment, sections) {
         }
         assertSamplingCount(native.numVert(), "extrude", resolved.limits.maxProfilePoints);
         const controls = resolveExtrusionControls(value.height, resolved, "extrude");
-        let divisions = value.divisions;
-        if (divisions === undefined) {
+        if (controls.scales[0] === 0 && native.numContour() > 1)
+            throwGeometryError("INVALID_TOPOLOGY", "extrude", "An extrusion apex requires one simple boundary without holes or disconnected components.");
+        let slices = value.slices;
+        if (slices === undefined) {
             const policy = resolveGeometryResolution(resolved.resolution, resolved.limits);
             // Untwisted uniform taper has planar sides. Its default two-cap topology
             // needs no native contour extraction or longitudinal interpolation.
             if (controls.twist === 0 &&
                 controls.scales[0] === controls.scales[1] &&
                 policy.maxSegmentLength === undefined)
-                divisions = 0;
+                slices = 1;
             else {
                 const profile = corresponding(handle) ? handle : sectionProfile(handle);
-                divisions = resolveExtrusionContourDivisions(profile.components.flatMap((component) => [component.outer, ...component.holes].map((contour) => contour.points)), value.height, resolved);
+                slices = resolveExtrusionContourSlices(profile.components.flatMap((component) => [component.outer, ...component.holes].map((contour) => contour.points)), value.height, resolved);
             }
         }
-        const vertices = native.numVert() * (divisions + 2), 
+        const vertices = native.numVert() * (slices + 1), 
         // A connected extrusion has T = 2V + 4H - 4. Treating every extra contour as
         // a hole also bounds disconnected Sections, without extracting native point data.
         triangles = Math.max(0, vertices * 2 + 4 * native.numContour() - 8);
         assertMeshAllocationWithinLimits(vertices, triangles, vertices * 12 + triangles * 12, "extrude", resolved.limits);
-        return ownSolid(native.extrude(value.height, divisions, controls.twist, controls.scales, controls.center));
+        if (controls.twist !== 0 && controls.scales[0] !== controls.scales[1]) {
+            // Manifold scales its world XY axes after twisting. The authored contract scales
+            // profile-local axes first, so only this mixed case needs explicit corresponding rows.
+            const profile = corresponding(handle) ? handle : sectionProfile(handle);
+            let pointCount = 0, contourCount = 0;
+            for (const component of profile.components)
+                for (const contour of [component.outer, ...component.holes]) {
+                    pointCount += contour.points.length;
+                    contourCount++;
+                }
+            // Native contours can simplify repeated landmarks. These rows retain every logical
+            // slot, so bound their actual allocation before transforming any profile coordinates.
+            assertSamplingCount(pointCount, "extrude", resolved.limits.maxProfilePoints);
+            const retainedVertices = pointCount * (slices + 1), retainedTriangles = 2 * retainedVertices + 4 * contourCount;
+            assertMeshAllocationWithinLimits(retainedVertices, retainedTriangles, 12 * (retainedVertices + retainedTriangles), "extrude", resolved.limits);
+            const stations = Array.from({ length: slices + 1 }, (_, index) => {
+                const t = index / slices, angle = ((controls.twist * Math.PI) / 180) * t;
+                const c = Math.cos(angle), s = Math.sin(angle);
+                const sx = 1 + (controls.scales[0] - 1) * t, sy = 1 + (controls.scales[1] - 1) * t;
+                const contour = (value) => ({
+                    ...value,
+                    points: value.points.map(([x, y]) => [
+                        x * sx * c - y * sy * s,
+                        x * sx * s + y * sy * c,
+                    ]),
+                });
+                return {
+                    z: value.height * (controls.center ? t - 0.5 : t),
+                    profile: {
+                        components: profile.components.map((component) => ({
+                            ...component,
+                            outer: contour(component.outer),
+                            holes: component.holes.map(contour),
+                        })),
+                    },
+                };
+            });
+            return solidFromMesh(buildProfileLoftMesh(module, stations, resolved.limits));
+        }
+        return ownSolid(native.extrude(value.height, slices - 1, controls.twist, controls.scales, controls.center));
     };
     const applyBoolean = (values, operation) => {
         assertOperandCount(values, operation);
@@ -83,10 +125,10 @@ export function createConstructionOperations(environment, sections) {
         if (natives.some((native) => native.kind !== kind))
             throwGeometryError("INVALID_ARGUMENT", operation, "Boolean operands must have the same dimensionality.");
         if (kind === "solid") {
-            const solids = values.map((value) => nativeSolid(value));
+            const solids = natives.map((native) => native.value);
             return wrapSolid(operation === "union" ? kernel.union(scope, solids) : kernel.intersect(scope, solids));
         }
-        const sections = values.map((value) => nativeSection(value));
+        const sections = natives.map((native) => native.value);
         return ownSection(operation === "union"
             ? module.CrossSection.union(sections)
             : module.CrossSection.intersection(sections));
@@ -99,10 +141,10 @@ export function createConstructionOperations(environment, sections) {
         if (cutters.length === 0)
             return value;
         return native.kind === "solid"
-            ? wrapSolid(kernel.subtract(scope, native.value, cutters.map((cutter) => nativeSolid(cutter))))
+            ? wrapSolid(kernel.subtract(scope, native.value, natives.map((cutter) => cutter.value)))
             : ownSection(module.CrossSection.difference([
                 native.value,
-                ...cutters.map((cutter) => nativeSection(cutter)),
+                ...natives.map((cutter) => cutter.value),
             ]));
     });
     const solidFromMesh = (input) => {
@@ -204,14 +246,22 @@ export function createConstructionOperations(environment, sections) {
             return ownSolid(native.revolve(sweepSegments, degrees));
         },
         loft: createLoftOperation(environment, solidFromMesh),
-        matchProfiles: (profiles, value = {}) => {
-            assertActive();
-            return matchProfiles(profiles, withResolutionDefaults(value));
-        },
-        sweep: (shape, path, value = {}) => {
+        sweep: (shape, route, value = {}) => {
             assertActive();
+            if (isSweepTransformRoute(route)) {
+                validateSweepTransformOptions(value);
+                const selectedLimits = resolveModelingLimits(value.limits, limits);
+                const closed = value.closed ?? false;
+                const transforms = sweepTransforms(route, closed, selectedLimits);
+                const profile = corresponding(shape) ? shape : sectionProfile(shape);
+                assertSamplingCount(profile.components.reduce((count, component) => count +
+                    component.outer.points.length +
+                    component.holes.reduce((sum, hole) => sum + hole.points.length, 0), 0), "sweep", selectedLimits.maxSweepProfilePoints);
+                return solidFromMesh(buildProfileLoftMesh(module, transforms.map((transform) => ({ profile, transform })), selectedLimits, closed));
+            }
+            validateSweepOptions(value);
             const defaults = withResolutionDefaults(value);
-            const data = path3InputData(path, value.closed, defaults.limits);
+            const data = path3InputData(route, value.closed, defaults.limits);
             const selected = { ...defaults, closed: data.closed };
             if (corresponding(shape))
                 return solidFromMesh(buildProfileSweepMesh(module, shape, data.points, selected, selected.limits));

package/dist/engine/operations/context.js

@@ -1,11 +1,11 @@
-import { resolveGeometryResolution } from "../../geometry/resolution.js";
+import { resolveGeometryResolution, } from "../../geometry/sampling/resolution.js";
 import { createConstructionOperations } from "./construction.js";
+import { createCutterOperations } from "./cutters.js";
 import { createOperationEnvironment } from "./environment.js";
 import { createHoleCutterOperation } from "./hole-cutter.js";
 import { createInspectionOperations } from "./inspection.js";
 import { createJoinOperation } from "./join.js";
 import { createMechanicalOperations } from "./mechanical.js";
-import { createPatternOperations } from "./patterns.js";
 import { createPrimitiveOperations } from "./primitives/construction.js";
 import { createSectionOperations } from "./sections.js";
 import { createTransformOperations } from "./transforms.js";
@@ -15,8 +15,8 @@ export function createModelingContext(owner, initialResolution) {
         const environment = createOperationEnvironment(owner, resolution);
         const transforms = createTransformOperations(environment);
         const sections = createSectionOperations(environment, transforms);
-        const primitives = createPrimitiveOperations(environment, transforms, sections);
         const construction = createConstructionOperations(environment, sections);
+        const primitives = createPrimitiveOperations(environment, transforms, sections, construction);
         const mechanical = createMechanicalOperations(environment, {
             cylinder: primitives.cylinder,
             box: primitives.box,
@@ -29,7 +29,6 @@ export function createModelingContext(owner, initialResolution) {
             translate: transforms.operations.translate,
             subtract: construction.subtract,
         });
-        const patterns = createPatternOperations(environment, transforms);
         const inspection = createInspectionOperations(environment);
         return Object.freeze({
             withResolution: (value) => {
@@ -46,10 +45,18 @@ export function createModelingContext(owner, initialResolution) {
                 extrude: construction.extrude,
                 loft: construction.loft,
                 translate: transforms.operations.translate,
-                union: construction.union,
             }),
+            ...createCutterOperations(environment, {
+                polygon: sections.polygon,
+                extrude: construction.extrude,
+                box: primitives.box,
+                cylinder: primitives.cylinder,
+                sphere: primitives.sphere,
+                subtract: construction.subtract,
+                translate: transforms.operations.translate,
+                hull: construction.hull,
+            }, transforms),
             ...mechanical,
-            ...patterns,
             ...inspection,
             anchor: owner.anchor,
             withAnchors: owner.withAnchors,

package/dist/engine/operations/cutters.js

@@ -0,0 +1,112 @@
+import { GeometryError } from "../../geometry/errors.js";
+import { assertMeshAllocationWithinLimits, resolveModelingLimits, } from "../../geometry/limits.js";
+import { chamferCornerCutterPoints, cutterExcess, edgeCutterContour, } from "../../geometry/primitives/cutters.js";
+import { edgeTreatmentSetbacks } from "../../geometry/primitives/edges.js";
+import { assertPositivePrimitive, assertPrimitiveOptions, } from "../../geometry/primitives/resolvers.js";
+import { resolveSphericalPrimitiveSegments } from "../../geometry/primitives/sampling.js";
+import { assertSamplingCount } from "../../geometry/sampling/limits.js";
+import { anchor3 } from "../../geometry/transforms/anchors.js";
+/** Host-bound explicit cutters; construction, placement and subtraction retain their existing owners. */
+export function createCutterOperations(environment, operations, transforms) {
+    const empty = () => environment.ownSolid(environment.module.Manifold.union([]));
+    const origin = anchor3({ position: [0, 0, 0], direction: [0, 0, 1] });
+    const place = (options, solid, anchors) => transforms.placedSolid(options, () => environment.nativeSolid(solid), () => anchors);
+    const nonnegative = (value, name, operation) => {
+        if (!Number.isFinite(value) || value < 0)
+            throw new GeometryError("INVALID_ARGUMENT", `${name} must be finite and nonnegative.`, {
+                operation,
+            });
+        return value;
+    };
+    const roundSampling = (treatment, selected, operation) => {
+        const options = {
+            radius: treatment.radius,
+            ...(treatment.segments === undefined ? {} : { segments: treatment.segments }),
+            resolution: { ...selected.resolution, ...treatment.resolution },
+            limits: resolveModelingLimits(treatment.limits, selected.limits),
+        };
+        return {
+            ...options,
+            segments: resolveSphericalPrimitiveSegments(options.radius, options, operation),
+        };
+    };
+    return {
+        edgeCutter: (options) => {
+            environment.assertActive();
+            assertPrimitiveOptions(options, "edgeCutter");
+            assertPositivePrimitive(options.length, "length", "edgeCutter");
+            if (options.overrun !== undefined)
+                assertPrimitiveOptions(options.overrun, "edgeCutter");
+            const bottom = nonnegative(options.overrun?.bottom ?? 0, "overrun.bottom", "edgeCutter"), top = nonnegative(options.overrun?.top ?? 0, "overrun.top", "edgeCutter");
+            const height = options.length + bottom + top;
+            assertPositivePrimitive(height, "extended length", "edgeCutter");
+            const selected = environment.withResolutionDefaults(options);
+            const treatment = options.treatment;
+            assertPrimitiveOptions(treatment, "edgeCutter");
+            const excess = cutterExcess(options.excess ?? 0.05, "edgeCutter");
+            let solid;
+            if ((options.angle ?? 90) === 90 && treatment.kind === "round") {
+                const [radius] = edgeTreatmentSetbacks(treatment, "edgeCutter");
+                if (radius === 0)
+                    solid = empty();
+                else {
+                    const sampling = roundSampling(treatment, selected, "edgeCutter");
+                    assertSamplingCount(sampling.segments / 4 + (excess === 0 ? 2 : 4), "edgeCutter", sampling.limits.maxProfilePoints);
+                    // Native cylinder and sphere equators share coordinates and angular refinement.
+                    // Passing the round through a clipped Section would introduce near-coincident seams.
+                    const cube = operations.translate(operations.box({
+                        size: [radius + excess, radius + excess, height],
+                        center: false,
+                        limits: sampling.limits,
+                    }), [-excess, -excess, -bottom]);
+                    const cylinder = operations.translate(operations.cylinder({ ...sampling, height, center: false }), [radius, radius, -bottom]);
+                    solid = operations.subtract(cube, [cylinder]);
+                }
+            }
+            else {
+                const contour = edgeCutterContour(treatment, options.angle ?? 90, excess, selected.resolution, selected.limits);
+                solid =
+                    contour.length === 0
+                        ? empty()
+                        : operations.translate(operations.extrude(operations.polygon(contour), {
+                            height,
+                            resolution: selected.resolution,
+                            limits: selected.limits,
+                        }), [0, 0, -bottom]);
+            }
+            return place(options, solid, {
+                origin,
+                bottom: anchor3({ position: [0, 0, 0], direction: [0, 0, -1] }),
+                top: anchor3({ position: [0, 0, options.length], direction: [0, 0, 1] }),
+            });
+        },
+        cornerCutter: (options) => {
+            environment.assertActive();
+            assertPrimitiveOptions(options, "cornerCutter");
+            assertPrimitiveOptions(options.treatment, "cornerCutter");
+            const treatment = options.treatment;
+            if ((treatment.kind !== "round" && treatment.kind !== "chamfer") ||
+                (treatment.kind === "chamfer" && typeof treatment.distance !== "number"))
+                throw new GeometryError("INVALID_ARGUMENT", "Corner cutters require a round treatment or one equal chamfer distance.", { operation: "cornerCutter" });
+            const selected = environment.withResolutionDefaults(options);
+            const excess = cutterExcess(options.excess ?? 0.05, "cornerCutter");
+            const [distance] = edgeTreatmentSetbacks(treatment, "cornerCutter");
+            let solid;
+            if (distance === 0)
+                solid = empty();
+            else if (treatment.kind === "chamfer") {
+                const points = chamferCornerCutterPoints(distance, excess);
+                assertMeshAllocationWithinLimits(10, 16, 26 * 12, "cornerCutter", selected.limits);
+                solid = operations.hull({ points });
+            }
+            else {
+                const radius = treatment.radius;
+                const sampling = roundSampling(treatment, selected, "cornerCutter");
+                const cube = operations.translate(operations.box({ size: radius + excess, center: false, limits: sampling.limits }), [-excess, -excess, -excess]);
+                const sphere = operations.translate(operations.sphere(sampling), [radius, radius, radius]);
+                solid = operations.subtract(cube, [sphere]);
+            }
+            return place(options, solid, { origin });
+        },
+    };
+}

package/dist/engine/operations/environment.js

@@ -1,5 +1,5 @@
-import { resolveModelingLimits } from "../../geometry/model-limits.js";
-import { resolveCircularPrimitiveSegments } from "../../geometry/primitive-resolution.js";
+import { resolveModelingLimits } from "../../geometry/limits.js";
+import { resolveCircularPrimitiveSegments } from "../../geometry/primitives/sampling.js";
 /** Applies explicit resolution inheritance once for this bound context. */
 export function createOperationEnvironment(owner, resolution) {
     const withResolutionDefaults = (value) => {

package/dist/engine/operations/extrusion-finishing.js

@@ -1,20 +1,21 @@
-import { edgeTreatmentPointCount, edgeTreatmentSetbacks, sampleEdgeTreatment, } from "../../geometry/edge-finishing.js";
 import { GeometryError } from "../../geometry/errors.js";
-import { resolveExtrusionControls } from "../../geometry/extrusion.js";
-import { assertMeshAllocationWithinLimits, } from "../../geometry/model-limits.js";
-import { planRegionOffsets } from "../../geometry/region-offset.js";
-import { assertSamplingCount } from "../../geometry/sampling-limits.js";
+import { resolveExtrusionControls, } from "../../geometry/extrusion/controls.js";
+import { mergeExtrusionStations } from "../../geometry/extrusion/stations.js";
+import { twistedChamferStations } from "../../geometry/extrusion/twisted-chamfer.js";
+import { assertMeshAllocationWithinLimits } from "../../geometry/limits.js";
+import { edgeTreatmentPointCount, edgeTreatmentSetbacks, sampleEdgeTreatment, } from "../../geometry/primitives/edges.js";
+import { planRegionOffsets } from "../../geometry/regions/offset.js";
+import { assertSamplingCount } from "../../geometry/sampling/limits.js";
+import { resolveGeometryResolution, } from "../../geometry/sampling/resolution.js";
 import { buildProfileLoftMesh } from "./primitives/profile-mesh.js";
 const fail = (message) => {
     throw new GeometryError("INVALID_ARGUMENT", message, { operation: "extrude" });
 };
-/** Finishes every material rim through one source-corresponding regular offset family. */
+/** @internal Builds end-treated stations and lofts their corresponding material boundaries. */
 export function buildFinishedExtrusion(module, profile, options) {
     const controls = resolveExtrusionControls(options.height, options, "extrude");
-    if (controls.twist !== 0 ||
-        controls.scales.some((scale) => scale !== 1) ||
-        options.divisions !== undefined)
-        fail("End treatments require a straight extrusion without twist, top scaling or divisions.");
+    if (controls.scales.some((scale) => scale !== 1))
+        fail("End treatments require unit scale.");
     if (typeof options.ends !== "object" || options.ends === null || Array.isArray(options.ends))
         fail("ends must be an object.");
     const bottom = options.ends.bottom, top = options.ends.top;
@@ -24,15 +25,25 @@ export function buildFinishedExtrusion(module, profile, options) {
     const topSize = top === undefined ? [0, 0] : edgeTreatmentSetbacks(top, "extrude", Math.PI / 2, options.limits);
     if (bottomSize[1] + topSize[1] >= options.height)
         fail("End treatments must leave positive length between their side setbacks.");
+    if (controls.twist !== 0) {
+        if ((bottomSize[0] > 0 && bottom?.kind !== "chamfer") ||
+            (topSize[0] > 0 && top?.kind !== "chamfer"))
+            fail("Twisted extrusion ends support chamfers; round, smooth and profile treatments require zero twist.");
+        return buildProfileLoftMesh(module, twistedChamferStations(profile, options, options.limits, bottomSize, topSize), options.limits);
+    }
     const plan = planRegionOffsets(profile, [0, Math.max(bottomSize[0], topSize[0])], "extrude", options.limits);
     const sampling = {
         resolution: options.resolution,
         limits: options.limits,
         magnification: plan.magnification,
     };
-    const rowCount = (bottom === undefined ? 1 : edgeTreatmentPointCount(bottom, "extrude", sampling)) +
+    const policy = resolveGeometryResolution(options.resolution, options.limits);
+    const slices = options.slices ??
+        (policy.maxSegmentLength === undefined
+            ? 1
+            : Math.max(1, Math.ceil(options.height / policy.maxSegmentLength)));
+    const treatmentCount = (bottom === undefined ? 1 : edgeTreatmentPointCount(bottom, "extrude", sampling)) +
         (top === undefined ? 1 : edgeTreatmentPointCount(top, "extrude", sampling));
-    assertSamplingCount(rowCount, "extrude", options.limits.maxPathPoints);
     let pointCount = 0, contourCount = 0;
     for (const component of profile.components) {
         for (const contour of [component.outer, ...component.holes]) {
@@ -40,15 +51,30 @@ export function buildFinishedExtrusion(module, profile, options) {
             contourCount++;
         }
     }
-    const vertexCount = rowCount * pointCount, triangleCount = 2 * vertexCount + 4 * contourCount;
-    assertMeshAllocationWithinLimits(vertexCount, triangleCount, 12 * (vertexCount + triangleCount), "extrude", options.limits);
+    const checkRows = (rowCount) => {
+        assertSamplingCount(rowCount, "extrude", options.limits.maxPathPoints);
+        const vertexCount = rowCount * pointCount, triangleCount = 2 * vertexCount + 4 * contourCount;
+        assertMeshAllocationWithinLimits(vertexCount, triangleCount, 12 * (vertexCount + triangleCount), "extrude", options.limits);
+    };
+    // Preflight the known minimum before sampling; check the exact merged count below.
+    checkRows(Math.max(slices + 1, treatmentCount));
     const bottomPoints = bottom === undefined ? [[0, 0]] : sampleEdgeTreatment(bottom, "extrude", sampling);
     const topPoints = top === undefined ? [[0, 0]] : sampleEdgeTreatment(top, "extrude", sampling);
-    const rows = [
+    const treatmentRows = [
         ...bottomPoints.map(([inset, depth]) => ({ inset, z: depth })),
         ...[...topPoints].reverse().map(([inset, depth]) => ({ inset, z: options.height - depth })),
     ];
-    const stations = rows.map(({ inset, z }) => ({
+    // Interpolate only added grid heights; required knots retain same-height profile steps.
+    let interval = 0;
+    const rows = mergeExtrusionStations(options.height, slices, treatmentRows, (z) => {
+        while (interval < treatmentRows.length - 2 && z > treatmentRows[interval + 1].z)
+            interval++;
+        const a = treatmentRows[interval], b = treatmentRows[interval + 1];
+        const inset = a.inset + ((b.inset - a.inset) * (z - a.z)) / (b.z - a.z);
+        return { z, inset };
+    }, options.limits);
+    checkRows(rows.length);
+    const stations = rows.map(({ z, inset }) => ({
         z: controls.center ? z - options.height / 2 : z,
         profile: plan.profileAt(inset),
     }));