@metamesh/modeling 0.18.0 → 0.20.0

package/dist/geometry/profiles/contour.js

@@ -1,12 +1,24 @@
-import { sampleCurve2 } from "../curves/sampling.js";
+import { planarCubicControl } from "../curves/evaluation.js";
+import { sampleCubicControlPoints, sampleCurve2 } from "../curves/sampling.js";
 import { GeometryError } from "../errors.js";
-import { normalizeContour } from "../regions.js";
-import { resolveGeometrySamplingLimits } from "../sampling-limits.js";
+import { normalizeContour } from "../regions/operations.js";
+import { resolveGeometrySamplingLimits } from "../sampling/limits.js";
 import { requireProfileVertexCount } from "./validation.js";
 const OPERATION = "sampleContour";
 function invalid(message) {
     throw new GeometryError("INVALID_ARGUMENT", message, { operation: OPERATION });
 }
+function sampleSpanPoints(span, options) {
+    if (span.kind !== "cubic")
+        return sampleCurve2(span, options).points;
+    const control = planarCubicControl(span);
+    // Constant curves still need the shared sampler's degenerate-tangent rejection.
+    if (control.every((point) => point.every((value, axis) => value === control[0][axis])))
+        return sampleCurve2(span, options).points;
+    const points = [span.start];
+    sampleCubicControlPoints(control, options, (point) => points.push([point[0], point[1]]));
+    return points;
+}
 /**
  * Samples 2–32 connected line/cubic segments into a simple, nonzero-area, immutable CCW XY loop.
  *
@@ -16,8 +28,8 @@ function invalid(message) {
  * `normalizeContour`; this is a single contour without holes. No editor modes or normalized
  * coordinate range are required. No native engine, SDK, or ambient resolution is used.
  *
- * @param curve - Closed contour in millimetres unless positive scales convert its coordinates.
- * @param options - Physical resolution and unique vertex budget; defaults to min(4096, maxProfilePoints).
+ * @param curve - Closed contour in millimetres, or coordinates converted by the selected scales.
+ * @param options - Coordinate scales, physical sampling, and vertex limits.
  * @returns Frozen counterclockwise loop in millimetres, without a repeated seam endpoint.
  * @throws {@link GeometryError} for invalid data, topology, scale, or exceeded sampling budgets.
  *
@@ -89,11 +101,11 @@ export function sampleContour(curve, options = {}) {
         else {
             invalid("Cross-section segments must be lines or cubics.");
         }
-        const sampled = sampleCurve2(span, {
+        const sampled = sampleSpanPoints(span, {
             ...(options.resolution === undefined ? {} : { resolution: options.resolution }),
             maxVertices: remainingVertices,
             limits,
-        }).points;
+        });
         const endIndex = sampled.length - (closed ? 1 : 0);
         for (let pointIndex = 1; pointIndex < endIndex; pointIndex++)
             output.push(sampled[pointIndex]);

package/dist/geometry/profiles/{match-profiles.js → matching.js}

@@ -1,9 +1,9 @@
 import { planarCubicControl } from "../curves/evaluation.js";
 import { resolveLineSegmentCount, resolveUniformCubicSegments } from "../curves/sampling.js";
 import { GeometryError } from "../errors.js";
-import { normalizeRegion, signedContourArea } from "../regions.js";
-import { resolveArcSegments, resolveGeometryResolution } from "../resolution.js";
-import { assertSamplingCount, resolveGeometrySamplingLimits } from "../sampling-limits.js";
+import { normalizeRegion, signedContourArea } from "../regions/operations.js";
+import { assertSamplingCount, resolveGeometrySamplingLimits } from "../sampling/limits.js";
+import { resolveArcSegments, resolveGeometryResolution } from "../sampling/resolution.js";
 import { createProfileSpanSampler } from "./span-sampling.js";
 const isArray = (value) => Array.isArray(value);
 const fail = (message) => {
@@ -62,6 +62,7 @@ const contours = (component) => [
     component.outer,
     ...component.holes,
 ];
+const contourAt = (component, index) => index === 0 ? component.outer : component.holes[index - 1];
 /**
  * Explicitly matches identified component/contour/span topology across a family.
  *
@@ -70,6 +71,8 @@ const contours = (component) => [
  * Input order and winding are preserved. Collapsed spans retain repeated logical slots, which
  * the engine maps to shared physical vertices while omitting degenerate faces.
  *
+ * @param profiles - 1–1000 profiles with matching component, contour, and span IDs, in order.
+ *
  * @example Match named rectangle landmarks
  * ```ts
  * matchProfiles([
@@ -115,7 +118,7 @@ export function matchProfiles(profiles, options = {}) {
             if (component.id !== expected.id || component.holes.length !== expected.holes.length)
                 fail("Profile component identities and hole counts must retain the same order.");
             contours(component).forEach((contour, contourIndex) => {
-                const paired = contours(expected)[contourIndex];
+                const paired = contourAt(expected, contourIndex);
                 if (contour.id !== paired.id ||
                     contour.spans.length !== paired.spans.length ||
                     contour.spans.some((span, index) => span.id !== paired.spans[index].id))
@@ -126,7 +129,7 @@ export function matchProfiles(profiles, options = {}) {
     let pointsPerProfile = 0;
     const sampling = first.components.map((component, componentIndex) => contours(component).map((contour, contourIndex) => contour.spans.map((_, spanIndex) => {
         let count = Math.max(...profiles.map((profile) => {
-            const span = contours(profile.components[componentIndex])[contourIndex].spans[spanIndex];
+            const span = contourAt(profile.components[componentIndex], contourIndex).spans[spanIndex];
             if (span.segments !== undefined)
                 return span.segments;
             const selectedResolution = resolveGeometryResolution({ ...resolution, ...span.resolution }, limits);
@@ -143,7 +146,7 @@ export function matchProfiles(profiles, options = {}) {
         while (true) {
             let checkedCount = count;
             for (const profile of profiles) {
-                const span = contours(profile.components[componentIndex])[contourIndex].spans[spanIndex];
+                const span = contourAt(profile.components[componentIndex], contourIndex).spans[spanIndex];
                 if (span.kind === "cubic" && span.segments === undefined)
                     checkedCount = Math.max(checkedCount, resolveUniformCubicSegments(planarCubicControl(span), resolveGeometryResolution({ ...resolution, ...span.resolution }, limits), cubicBudget, count));
             }

package/dist/geometry/profiles/primitives/circle.js

@@ -1,4 +1,4 @@
-import { resolveCircularSampling } from "../../circular-sampling.js";
+import { resolveCircularSampling } from "../../sampling/circular.js";
 import { requireProfileVertexCount } from "../validation.js";
 /**
  * Creates an immutable centered CCW circle with +X seam and vertex or face radial sizing.

package/dist/geometry/profiles/primitives/ellipse.js

@@ -1,7 +1,7 @@
 import { GeometryError } from "../../errors.js";
 import { vector2Data } from "../../math/vector-value.js";
-import { resolveCircularPrimitiveSegments } from "../../primitive-resolution.js";
-import { assertPrimitiveOptions } from "../../primitive-resolvers.js";
+import { assertPrimitiveOptions } from "../../primitives/resolvers.js";
+import { resolveCircularPrimitiveSegments } from "../../primitives/sampling.js";
 import { requireFiniteProfileValues, requireProfileVertexCount } from "../validation.js";
 /**
  * Creates an immutable centered CCW ellipse with +X seam within the selected sampling ceiling.

package/dist/geometry/profiles/primitives/rectangle.js

@@ -1,10 +1,10 @@
-import { edgeTreatmentPointCount, edgeTreatmentSetbacks, sampleEdgeTreatment, } from "../../edge-finishing.js";
 import { GeometryError } from "../../errors.js";
+import { resolveModelingLimits } from "../../limits.js";
 import { vector2Data } from "../../math/vector-value.js";
-import { resolveModelingLimits } from "../../model-limits.js";
-import { assertPrimitiveOptions } from "../../primitive-resolvers.js";
-import { resolveAlignedCircularSegments } from "../../resolution.js";
-import { assertSamplingCount } from "../../sampling-limits.js";
+import { edgeTreatmentPointCount, edgeTreatmentSetbacks, sampleEdgeTreatment, } from "../../primitives/edges.js";
+import { assertPrimitiveOptions } from "../../primitives/resolvers.js";
+import { assertSamplingCount } from "../../sampling/limits.js";
+import { resolveAlignedCircularSegments } from "../../sampling/resolution.js";
 import { requireFiniteProfileValues, requireProfileVertexCount } from "../validation.js";
 const fail = (operation, message) => {
     throw new GeometryError("INVALID_ARGUMENT", message, { operation });
@@ -56,8 +56,8 @@ export function resolveRectangle(options, operation) {
         }
     return { width, height, corners, setbacks, limits };
 }
-/** @internal Resolves one quarter arc under the same exact and physical convention as native rectangles. */
-export function rectangleCornerSegments(corner, limits) {
+// Pure contours and identified profiles use the same quarter-arc sampling as native rectangles.
+function rectangleCornerSegments(corner, limits) {
     if (corner.kind !== "round")
         return 1;
     const selected = resolveModelingLimits(limits);
@@ -156,7 +156,7 @@ export function rectangleContour(options) {
  *
  * Use [rectangle](/docs/reference/model/rectangle) for a filled Section.
  *
- * @see {@link matchProfiles} to sample a family with shared landmark correspondence.
+ * @see [matchProfiles](/docs/reference/geometry/matchProfiles) to sample a family with shared landmark correspondence.
  * @see {@link rectangleContour} for sampled boundary coordinates.
  *
  * @example Retain rectangle landmarks

package/dist/geometry/profiles/primitives/star.js

@@ -1,5 +1,5 @@
 import { GeometryError } from "../../errors.js";
-import { assertPrimitiveOptions } from "../../primitive-resolvers.js";
+import { assertPrimitiveOptions } from "../../primitives/resolvers.js";
 import { requireFiniteProfileValues, requireProfileVertexCount } from "../validation.js";
 /**
  * Creates an immutable centered CCW alternating-radius star within the selected profile sampling ceiling.

package/dist/geometry/profiles/side-profile.js

@@ -1,7 +1,7 @@
 import { GeometryError } from "../errors.js";
-import { normalizeContour } from "../regions.js";
-import { resolveGeometryResolution } from "../resolution.js";
-import { resolveGeometrySamplingLimits } from "../sampling-limits.js";
+import { normalizeContour } from "../regions/operations.js";
+import { resolveGeometrySamplingLimits } from "../sampling/limits.js";
+import { resolveGeometryResolution } from "../sampling/resolution.js";
 import { requireProfileVertexCount } from "./validation.js";
 const OPERATION = "sampleSideProfile";
 const MAX_SEGMENTS = 31;
@@ -30,8 +30,8 @@ function distanceToChord(point, start, end) {
  * Neither normalized coordinates nor editor metadata are required. Endpoints are retained once;
  * no axis closure, winding normalization, or manufacturing repair is performed.
  *
- * @param curve - Open outline in millimetres unless the positive scales convert its coordinates.
- * @param options - Physical resolution and output budget; defaults to min(4096, maxProfilePoints).
+ * @param curve - Open outline in millimetres, or coordinates converted by the selected scales.
+ * @param options - Coordinate scales, physical sampling, and vertex limits.
  * @returns Frozen open polyline in millimetres, ordered from lowest to highest anchor.
  * @throws {@link GeometryError} for invalid coordinates, order, scale, or exceeded subdivision budget.
  *
@@ -144,6 +144,9 @@ export function sampleSideProfile(curve, options = {}) {
  * Returns a counterclockwise filled-boundary contour without a repeated seam vertex.
  * Radii must be nonnegative; the result must enclose nonzero area without touching itself.
  * This is a solid-body closure, not a hollow-wall or mounting-bore construction.
+ *
+ * @param side - [radius, height] points in millimetres, with increasing heights.
+ * @param limits - Point limits, including any added axis endpoints.
  */
 export function closeToAxis(side, limits) {
     const operation = "closeToAxis";

package/dist/geometry/profiles/validation.js

@@ -1,5 +1,5 @@
 import { GeometryError } from "../errors.js";
-import { assertSamplingCount, resolveGeometrySamplingLimits, } from "../sampling-limits.js";
+import { assertSamplingCount, resolveGeometrySamplingLimits, } from "../sampling/limits.js";
 /** @internal Validates finite dimensions shared by the pure profile factories. */
 export function requireFiniteProfileValues(values, operation) {
     if (!values.every(Number.isFinite)) {

package/dist/geometry/{polygon-clipping.js → regions/clipping.js}

@@ -1,5 +1,5 @@
 import * as clippingModule from "polygon-clipping";
-import { normalizeRegion } from "./regions.js";
+import { normalizeRegion } from "./operations.js";
 const moduleWithDefault = clippingModule;
 /** @internal Normalizes polygon-clipping's CommonJS and bundled ESM module shapes. */
 export const polygonClipping = moduleWithDefault.default ?? clippingModule;

package/dist/geometry/{convex-offset.js → regions/convex-offset.js}

@@ -1,4 +1,4 @@
-import { GeometryError } from "./errors.js";
+import { GeometryError } from "../errors.js";
 /** @internal Parallel-edge offsets shared by convex extrusion rims and pocket entries. */
 export function convexContourOffsets(points, operation) {
     const fail = (message) => {

package/dist/geometry/regions/offset.js

@@ -0,0 +1,280 @@
+import { GeometryError } from "../errors.js";
+import { resolveModelingLimits } from "../limits.js";
+import { assertSamplingCount } from "../sampling/limits.js";
+import { resolveGeometryTolerance } from "../tolerance.js";
+import { normalizeRegionWithWork, signedContourArea } from "./operations.js";
+const maximumWork = 2_000_000;
+// Keep these kernels local to isolate V8's array-type feedback from other modeling operations.
+// Shared helpers see more array representations, which can slow hot loops even when inlined.
+const cross = (a, b) => a[0] * b[1] - a[1] * b[0];
+const dot = (a, b) => a[0] * b[0] + a[1] * b[1];
+const difference = (a, b) => [a[0] - b[0], a[1] - b[1]];
+/**
+ * Plans parallel-edge offsets of every material boundary, preserving logical slots and seams.
+ * Positive distance contracts material; negative distance expands it. The range includes zero.
+ * Boundary events are excluded throughout the interval, not only at generated mesh stations.
+ * @internal
+ */
+export function planRegionOffsets(profile, range, operation, overrides = {}) {
+    const fail = (code, message, boundary) => {
+        throw new GeometryError(code, message, {
+            operation,
+            ...(boundary === undefined ? {} : { details: { boundary } }),
+        });
+    };
+    if (!Array.isArray(range) || range.length !== 2 || range.some((value) => !Number.isFinite(value)))
+        fail("NON_FINITE_VALUE", "Offset bounds must be a finite distance pair.");
+    if (range[0] > 0 || range[1] < 0 || range[0] > range[1])
+        fail("INVALID_ARGUMENT", "Offset bounds must be ordered and include zero.");
+    range = [range[0], range[1]];
+    if (!Array.isArray(profile?.components) || profile.components.length === 0)
+        fail("DEGENERATE_GEOMETRY", "Finishing requires a nonempty filled profile.");
+    const limits = resolveModelingLimits(overrides);
+    let logicalCount = 0;
+    const identity = (value) => typeof value === "string" && /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(value) && value.length <= 64;
+    const prepare = (source) => {
+        if (typeof source !== "object" ||
+            source === null ||
+            !identity(source.id) ||
+            !Array.isArray(source.points) ||
+            !Array.isArray(source.spans) ||
+            source.points.length !== source.spans.length ||
+            source.spans.some((span) => !identity(span)))
+            fail("INVALID_TOPOLOGY", "Offset contours require identified points and paired span slots.");
+        logicalCount += source.points.length;
+        assertSamplingCount(logicalCount, operation, limits.maxProfilePoints);
+        if (logicalCount * 176 > limits.maxBytes)
+            fail("COMPLEXITY_LIMIT", "Offset planning exceeds the configured intermediate byte ceiling.");
+        const points = [];
+        const slots = [];
+        for (const point of source.points) {
+            if (!Array.isArray(point) ||
+                point.length !== 2 ||
+                point.some((value) => !Number.isFinite(value)))
+                fail("NON_FINITE_VALUE", "Offset contours require finite XY points.", source.id);
+            const previous = points.at(-1);
+            if (previous === undefined || previous[0] !== point[0] || previous[1] !== point[1])
+                points.push(Object.freeze([point[0], point[1]]));
+            slots.push(points.length - 1);
+        }
+        if (points.length > 1 &&
+            points[0][0] === points.at(-1)[0] &&
+            points[0][1] === points.at(-1)[1]) {
+            const last = points.length - 1;
+            points.pop();
+            for (let index = 0; index < slots.length; index++)
+                if (slots[index] === last)
+                    slots[index] = 0;
+        }
+        if (points.length < 3)
+            fail("DEGENERATE_GEOMETRY", "An offset boundary needs three physical vertices.", source.id);
+        const directions = points.map((point, index) => {
+            const delta = difference(points[(index + 1) % points.length], point);
+            const length = Math.hypot(...delta);
+            if (!(length > 0) || !Number.isFinite(length))
+                fail("DEGENERATE_GEOMETRY", "Offset edges require finite positive length.", source.id);
+            return [delta[0] / length, delta[1] / length];
+        });
+        const motion = directions.map((edge, index) => {
+            const previous = directions[(index + directions.length - 1) % directions.length];
+            const denominator = 1 + dot(previous, edge);
+            if (!(denominator > Number.EPSILON * 8))
+                fail("DEGENERATE_GEOMETRY", "Offset boundaries cannot backtrack.", source.id);
+            const result = [
+                (-previous[1] - edge[1]) / denominator,
+                (previous[0] + edge[0]) / denominator,
+            ];
+            if (!result.every(Number.isFinite))
+                fail("NON_FINITE_VALUE", "Offset corner motion exceeds numeric precision.", source.id);
+            return Object.freeze(result);
+        });
+        // A logical point on a straight run follows the run's corresponding edge
+        // fraction. A normal-only velocity could let a nearby moving corner overtake it.
+        const corners = directions.flatMap((edge, index) => {
+            const previous = directions[(index + directions.length - 1) % directions.length];
+            return Math.abs(cross(previous, edge)) > Number.EPSILON * 32 ? [index] : [];
+        });
+        if (corners.length < 3)
+            fail("DEGENERATE_GEOMETRY", "Offset boundaries need three resolved corners.", source.id);
+        for (let corner = 0; corner < corners.length; corner++) {
+            const first = corners[corner], last = corners[(corner + 1) % corners.length];
+            const start = points[first], end = points[last];
+            const delta = difference(end, start), squaredLength = dot(delta, delta);
+            for (let index = (first + 1) % points.length; index !== last; index = (index + 1) % points.length) {
+                const fraction = dot(difference(points[index], start), delta) / squaredLength;
+                motion[index] = Object.freeze([
+                    motion[first][0] + (motion[last][0] - motion[first][0]) * fraction,
+                    motion[first][1] + (motion[last][1] - motion[first][1]) * fraction,
+                ]);
+            }
+        }
+        return Object.freeze({
+            id: source.id,
+            spans: Object.freeze([...source.spans]),
+            slots: Object.freeze(slots),
+            points: Object.freeze(points),
+            motion: Object.freeze(motion),
+        });
+    };
+    const componentIds = new Set();
+    const components = profile.components.map((component) => {
+        if (typeof component !== "object" ||
+            component === null ||
+            !identity(component.id) ||
+            componentIds.has(component.id) ||
+            !Array.isArray(component.holes))
+            fail("INVALID_TOPOLOGY", "Offset components require unique identities and explicit holes.");
+        componentIds.add(component.id);
+        const outer = prepare(component.outer);
+        const holes = component.holes.map(prepare);
+        const ids = new Set([outer.id]);
+        for (const hole of holes) {
+            if (ids.has(hole.id))
+                fail("INVALID_TOPOLOGY", "Offset contour identities must be unique.");
+            ids.add(hole.id);
+        }
+        if (signedContourArea(outer.points) <= 0 ||
+            holes.some((hole) => signedContourArea(hole.points) >= 0))
+            fail("INVALID_TOPOLOGY", "Offset outer contours must be CCW and holes clockwise.");
+        return { id: component.id, outer, holes };
+    });
+    const initial = normalizeRegionWithWork(components.map((component) => ({
+        outer: component.outer.points,
+        holes: component.holes.map((hole) => hole.points),
+    })));
+    const contours = components.flatMap((component) => [component.outer, ...component.holes]);
+    const allPoints = contours.flatMap((contour) => contour.points);
+    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+    for (const [x, y] of allPoints) {
+        minX = Math.min(minX, x);
+        minY = Math.min(minY, y);
+        maxX = Math.max(maxX, x);
+        maxY = Math.max(maxY, y);
+    }
+    const tolerance = resolveGeometryTolerance(Math.max(maxX - minX, maxY - minY));
+    const epsilon = Math.max(tolerance.linear, Number.EPSILON * 16 * Math.max(Math.abs(minX), Math.abs(maxX), Math.abs(minY), Math.abs(maxY)));
+    const pointAt = (point, velocity, distance) => distance === 0 ? point : [point[0] + distance * velocity[0], point[1] + distance * velocity[1]];
+    const edges = contours.flatMap((contour) => contour.points.map((a, index) => {
+        const next = (index + 1) % contour.points.length;
+        const b = contour.points[next], av = contour.motion[index], bv = contour.motion[next];
+        const delta = difference(b, a), length = Math.hypot(...delta);
+        const direction = [delta[0] / length, delta[1] / length];
+        const lengthSlope = dot(difference(bv, av), direction);
+        for (const distance of range) {
+            if (!(length + lengthSlope * distance > epsilon))
+                fail("DEGENERATE_GEOMETRY", "Treatment offset collapses or reverses a contour edge.", contour.id);
+        }
+        const endpoints = [
+            pointAt(a, av, range[0]),
+            pointAt(a, av, range[1]),
+            pointAt(b, bv, range[0]),
+            pointAt(b, bv, range[1]),
+        ];
+        if (endpoints.some((point) => point.some((value) => !Number.isFinite(value))))
+            fail("NON_FINITE_VALUE", "Offset coordinates exceed numeric precision.", contour.id);
+        return {
+            contour,
+            index,
+            a,
+            b,
+            av,
+            bv,
+            direction,
+            length,
+            lengthSlope,
+            minX: Math.min(...endpoints.map((point) => point[0])) - epsilon,
+            maxX: Math.max(...endpoints.map((point) => point[0])) + epsilon,
+            minY: Math.min(...endpoints.map((point) => point[1])) - epsilon,
+            maxY: Math.max(...endpoints.map((point) => point[1])) + epsilon,
+        };
+    }));
+    // Intersect affine inequalities c + slope*d >= 0 over the complete distance interval.
+    const intersect = (bounds, constant, slope) => {
+        if (slope === 0)
+            return constant >= 0;
+        const root = -constant / slope;
+        if (slope > 0)
+            bounds[0] = Math.max(bounds[0], root);
+        else
+            bounds[1] = Math.min(bounds[1], root);
+        return bounds[0] <= bounds[1];
+    };
+    const collide = (a, b) => {
+        const bounds = [range[0], range[1]];
+        const delta = difference(b.a, a.a), deltaSlope = difference(b.av, a.av);
+        const determinant = cross(a.direction, b.direction);
+        if (Math.abs(determinant) > tolerance.angular) {
+            const alongA = cross(delta, b.direction) / determinant;
+            const alongASlope = cross(deltaSlope, b.direction) / determinant;
+            const alongB = cross(delta, a.direction) / determinant;
+            const alongBSlope = cross(deltaSlope, a.direction) / determinant;
+            const slack = epsilon / Math.abs(determinant);
+            return (intersect(bounds, alongA + slack, alongASlope) &&
+                intersect(bounds, a.length - alongA + slack, a.lengthSlope - alongASlope) &&
+                intersect(bounds, alongB + slack, alongBSlope) &&
+                intersect(bounds, b.length - alongB + slack, b.lengthSlope - alongBSlope));
+        }
+        // Near-parallel support lines need both line coincidence and tangential overlap.
+        const distance = cross(a.direction, delta), distanceSlope = cross(a.direction, deltaSlope);
+        const longest = Math.max(a.length + a.lengthSlope * range[0], a.length + a.lengthSlope * range[1], b.length + b.lengthSlope * range[0], b.length + b.lengthSlope * range[1]);
+        const slack = epsilon + Math.abs(determinant) * longest;
+        if (!intersect(bounds, slack - distance, -distanceSlope) ||
+            !intersect(bounds, slack + distance, distanceSlope))
+            return false;
+        const same = dot(a.direction, b.direction) >= 0;
+        const lowPoint = same ? b.a : b.b, lowVelocity = same ? b.av : b.bv;
+        const highPoint = same ? b.b : b.a, highVelocity = same ? b.bv : b.av;
+        const low = dot(difference(lowPoint, a.a), a.direction);
+        const lowSlope = dot(difference(lowVelocity, a.av), a.direction);
+        const high = dot(difference(highPoint, a.a), a.direction);
+        const highSlope = dot(difference(highVelocity, a.av), a.direction);
+        return (intersect(bounds, high + epsilon, highSlope) &&
+            intersect(bounds, a.length - low + epsilon, a.lengthSlope - lowSlope));
+    };
+    edges.sort((a, b) => a.minX - b.minX || a.minY - b.minY);
+    const active = [];
+    let workCount = initial.workCount;
+    for (const current of edges) {
+        let retained = 0;
+        for (const candidate of active) {
+            if (++workCount > maximumWork)
+                fail("COMPLEXITY_LIMIT", "Offset validation exceeds the 2000000 candidate-work ceiling.");
+            if (candidate.maxX < current.minX)
+                continue;
+            active[retained++] = candidate;
+            if (candidate.maxY < current.minY || current.maxY < candidate.minY)
+                continue;
+            if (candidate.contour === current.contour &&
+                ((candidate.index + 1) % current.contour.points.length === current.index ||
+                    (current.index + 1) % current.contour.points.length === candidate.index))
+                continue;
+            if (collide(candidate, current))
+                fail("SELF_INTERSECTION", "Treatment offsets make source boundaries contact or intersect.", current.contour.id);
+        }
+        active.length = retained;
+        active.push(current);
+    }
+    const magnification = contours.reduce((maximum, contour) => contour.motion.reduce((maximum, motion) => Math.max(maximum, Math.hypot(...motion)), maximum), 1);
+    const contourAt = (contour, distance) => ({
+        id: contour.id,
+        spans: contour.spans,
+        points: Object.freeze(contour.slots.map((slot) => Object.freeze(pointAt(contour.points[slot], contour.motion[slot], distance)))),
+    });
+    return Object.freeze({
+        magnification,
+        workCount,
+        profileAt(distance) {
+            if (!Number.isFinite(distance))
+                fail("NON_FINITE_VALUE", "Offset distance must be finite.");
+            if (distance < range[0] || distance > range[1])
+                fail("INVALID_ARGUMENT", "Offset distance is outside the validated interval.");
+            return Object.freeze({
+                components: Object.freeze(components.map((component) => Object.freeze({
+                    id: component.id,
+                    outer: Object.freeze(contourAt(component.outer, distance)),
+                    holes: Object.freeze(component.holes.map((hole) => Object.freeze(contourAt(hole, distance)))),
+                }))),
+            });
+        },
+    });
+}