@metamesh/modeling 0.17.0 → 0.19.0

package/dist/geometry/primitive-resolvers.js

@@ -1,5 +1,6 @@
 import { edgeTreatmentPointCount, edgeTreatmentSetbacks, sampleEdgeTreatment, } from "./edge-finishing.js";
 import { GeometryError } from "./errors.js";
+import { vector3Data } from "./math/vector-value.js";
 import { assertMeshAllocationWithinLimits, resolveModelingLimits } from "./model-limits.js";
 import { resolveCircularPrimitiveSegments } from "./primitive-resolution.js";
 /** @internal Face pairs define the twelve nominal box edges in deterministic order. */
@@ -87,13 +88,9 @@ export function resolveBoxPrimitive(options) {
             operation,
         });
     }
-    if (typeof options.size !== "number" &&
-        (!Array.isArray(options.size) || options.size.length !== 3)) {
-        throw new GeometryError("INVALID_ARGUMENT", "size must be a number or an exact XYZ tuple.", {
-            operation,
-        });
-    }
-    const dimensions = typeof options.size === "number" ? [options.size, options.size, options.size] : options.size;
+    const dimensions = typeof options.size === "number"
+        ? [options.size, options.size, options.size]
+        : vector3Data(options.size);
     for (let axis = 0; axis < 3; axis += 1) {
         assertPositivePrimitive(dimensions[axis], `size[${axis}]`, operation);
     }
@@ -193,17 +190,48 @@ export function resolveBoxPrimitive(options) {
             },
         };
 }
-/** @internal Validates tube dimensions shared by both adapters before allocating cylinders. */
-export function resolveTubePrimitive(options) {
+/** @internal Resolves one complete radius or diameter pair before applying faceting compensation. */
+export function resolveTubeRadii(options) {
     assertPrimitiveOptions(options, "tube");
-    assertPositivePrimitive(options.innerRadius, "innerRadius", "tube");
-    assertPositivePrimitive(options.outerRadius, "outerRadius", "tube");
+    const radii = options.innerRadius !== undefined || options.outerRadius !== undefined;
+    const diameters = options.innerDiameter !== undefined || options.outerDiameter !== undefined;
+    if (radii === diameters)
+        throw new GeometryError("INVALID_ARGUMENT", "Supply one complete radius or diameter pair.", {
+            operation: "tube",
+        });
+    const innerRadius = radii ? options.innerRadius : options.innerDiameter / 2;
+    const outerRadius = radii ? options.outerRadius : options.outerDiameter / 2;
+    assertPositivePrimitive(innerRadius, "innerRadius", "tube");
+    assertPositivePrimitive(outerRadius, "outerRadius", "tube");
+    if (!(outerRadius > innerRadius))
+        throw new GeometryError("INVALID_ARGUMENT", "Outer size must be larger than inner size.", {
+            operation: "tube",
+        });
+    return { innerRadius, outerRadius };
+}
+/** @internal Resolves shared faceting so compensated inner and outer rings retain a positive wall. */
+export function resolveTubePrimitive(options) {
+    const { innerRadius, outerRadius } = resolveTubeRadii(options);
     assertPositivePrimitive(options.height, "height", "tube");
-    if (!(options.outerRadius > options.innerRadius)) {
-        throw new GeometryError("INVALID_ARGUMENT", "outerRadius must be larger than innerRadius.", {
+    if (options.center !== undefined && typeof options.center !== "boolean")
+        throw new GeometryError("INVALID_ARGUMENT", "center must be boolean when supplied.", {
             operation: "tube",
         });
-    }
+    const sizing = (value) => {
+        if (value !== undefined && value !== "vertex" && value !== "face")
+            throw new GeometryError("INVALID_ARGUMENT", "Tube sizing must be vertex or face.", {
+                operation: "tube",
+            });
+        return value ?? "vertex";
+    };
+    const innerSizing = sizing(options.innerSizing), outerSizing = sizing(options.outerSizing);
+    const segments = Math.max(resolveCircularPrimitiveSegments(innerRadius, { ...options, sizing: innerSizing }, "tube"), resolveCircularPrimitiveSegments(outerRadius, { ...options, sizing: outerSizing }, "tube"));
+    const cosine = Math.cos(Math.PI / segments);
+    const innerVertexRadius = innerSizing === "face" ? innerRadius / cosine : innerRadius;
+    const outerVertexRadius = outerSizing === "face" ? outerRadius / cosine : outerRadius;
+    if (!Number.isFinite(outerVertexRadius) || !(outerVertexRadius > innerVertexRadius))
+        throw new GeometryError("INVALID_ARGUMENT", "Tube sizing and sampling must leave a finite positive wall.", { operation: "tube" });
+    return { innerVertexRadius, outerVertexRadius, segments };
 }
 /** @internal Resolves sphere sampling shared by compiled and authored adapters. */
 export function resolveSpherePrimitive(options) {

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

@@ -0,0 +1,19 @@
+import { resolveCircularSampling } from "../../circular-sampling.js";
+import { requireProfileVertexCount } from "../validation.js";
+/**
+ * Creates an immutable centered CCW circle with +X seam and vertex or face radial sizing.
+ *
+ * @example Explicit circular point data
+ * ```ts
+ * circleContour({ diameter: 20, segments: 32 });
+ * ```
+ */
+export const circleContour = (options) => {
+    const operation = "circleContour";
+    const { segments, vertexRadius } = resolveCircularSampling(options);
+    requireProfileVertexCount(segments, 3, operation, options.limits);
+    return Object.freeze(Array.from({ length: segments }, (_, index) => {
+        const angle = (Math.PI * 2 * index) / segments;
+        return Object.freeze([vertexRadius * Math.cos(angle), vertexRadius * Math.sin(angle)]);
+    }));
+};

package/dist/geometry/profiles/{shapes.js → primitives/ellipse.js}

@@ -1,7 +1,8 @@
-import { GeometryError } from "../errors.js";
-import { resolveCircularPrimitiveSegments } from "../primitive-resolution.js";
-import { assertPrimitiveOptions } from "../primitive-resolvers.js";
-import { requireFiniteProfileValues, requireProfileVertexCount } from "./validation.js";
+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 { requireFiniteProfileValues, requireProfileVertexCount } from "../validation.js";
 /**
  * Creates an immutable centered CCW ellipse with +X seam within the selected sampling ceiling.
  *
@@ -17,12 +18,7 @@ export function ellipseContour(options) {
             operation: "ellipseContour",
         });
     }
-    const dimensions = options.radius ?? options.size;
-    if (!Array.isArray(dimensions) || dimensions.length !== 2) {
-        throw new GeometryError("INVALID_ARGUMENT", "Ellipse dimensions must be an exact XY tuple.", {
-            operation: "ellipseContour",
-        });
-    }
+    const dimensions = vector2Data(options.radius ?? options.size);
     const factor = options.radius === undefined ? 0.5 : 1;
     const radiusX = dimensions[0] * factor;
     const radiusY = dimensions[1] * factor;

package/dist/geometry/profiles/{rectangle.js → primitives/rectangle.js}

@@ -1,22 +1,20 @@
-import { edgeTreatmentPointCount, edgeTreatmentSetbacks, sampleEdgeTreatment, } from "../edge-finishing.js";
-import { GeometryError } from "../errors.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 { requireFiniteProfileValues, requireProfileVertexCount } from "./validation.js";
+import { edgeTreatmentPointCount, edgeTreatmentSetbacks, sampleEdgeTreatment, } from "../../edge-finishing.js";
+import { GeometryError } from "../../errors.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 { requireFiniteProfileValues, requireProfileVertexCount } from "../validation.js";
 const fail = (operation, message) => {
     throw new GeometryError("INVALID_ARGUMENT", message, { operation });
 };
 /** @internal Validates the shared rectangle family before native or pure allocation. */
 export function resolveRectangle(options, operation) {
     assertPrimitiveOptions(options, operation);
-    if (typeof options.size !== "number" &&
-        (!Array.isArray(options.size) || options.size.length !== 2))
-        fail(operation, "size must be a number or an exact XY tuple.");
     if (options.center !== undefined && typeof options.center !== "boolean")
         fail(operation, "center must be boolean.");
-    const [width, height] = typeof options.size === "number" ? [options.size, options.size] : options.size;
+    const [width, height] = typeof options.size === "number" ? [options.size, options.size] : vector2Data(options.size);
     requireFiniteProfileValues([width, height], operation);
     if (!(width > 0) || !(height > 0))
         fail(operation, "Rectangle dimensions must be positive.");
@@ -79,7 +77,11 @@ export function rectangleCornerSegments(corner, limits) {
     }) / 4);
 }
 /**
- * Creates an immutable sampled CCW rectangle boundary. Round radius zero is square; tangent saturated endpoints occur once.
+ * Creates an immutable sampled CCW rectangle boundary.
+ *
+ * @remarks
+ * A zero round radius leaves square corners. When rounded corners meet, their shared endpoints
+ * appear once.
  *
  * Use [rectangle](/docs/reference/model/rectangle) for a filled Section.
  *

package/dist/geometry/profiles/primitives/regular-polygon.js

@@ -0,0 +1,33 @@
+import { GeometryError } from "../../errors.js";
+import { requireFiniteProfileValues, requireProfileVertexCount } from "../validation.js";
+/**
+ * Creates an immutable centered CCW point loop with vertex or face radial sizing and an implicit seam.
+ *
+ * @example Hexagon sized to its faces
+ * ```ts
+ * regularPolygonContour({ radius: 10, sides: 6, sizing: "face" });
+ * ```
+ */
+export const regularPolygonContour = (options) => {
+    const operation = "regularPolygonContour";
+    const { radius, sides, rotation = 0, sizing = "vertex" } = options;
+    requireFiniteProfileValues([radius, rotation], operation);
+    if (!(radius > 0)) {
+        throw new GeometryError("INVALID_ARGUMENT", "Polygon radius must be positive.", { operation });
+    }
+    requireProfileVertexCount(sides, 3, operation, options.limits);
+    if (sizing !== "vertex" && sizing !== "face")
+        throw new GeometryError("INVALID_ARGUMENT", "Polygon sizing must be vertex or face.", {
+            operation,
+        });
+    const sampledRadius = sizing === "face" ? radius / Math.cos(Math.PI / sides) : radius;
+    requireFiniteProfileValues([sampledRadius], operation);
+    const rotationRadians = ((rotation % 360) * Math.PI) / 180;
+    return Object.freeze(Array.from({ length: sides }, (_, index) => {
+        const angle = rotationRadians + (Math.PI * 2 * index) / sides;
+        return Object.freeze([
+            sampledRadius * Math.cos(angle),
+            sampledRadius * Math.sin(angle),
+        ]);
+    }));
+};

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

@@ -0,0 +1,28 @@
+import { GeometryError } from "../../errors.js";
+import { assertPrimitiveOptions } from "../../primitive-resolvers.js";
+import { requireFiniteProfileValues, requireProfileVertexCount } from "../validation.js";
+/**
+ * Creates an immutable centered CCW alternating-radius star within the selected profile sampling ceiling.
+ *
+ * @example Five-point outline
+ * ```ts
+ * starContour({ outerRadius: 12, innerRadius: 6, points: 5 });
+ * ```
+ */
+export const starContour = (options) => {
+    const operation = "starContour";
+    assertPrimitiveOptions(options, operation);
+    const { outerRadius, innerRadius, points, rotation = 0, limits } = options;
+    requireFiniteProfileValues([outerRadius, innerRadius, rotation], operation);
+    if (!(outerRadius > 0) || !(innerRadius > 0) || innerRadius >= outerRadius) {
+        throw new GeometryError("INVALID_ARGUMENT", "Star radii must be positive, with the inner radius smaller than the outer.", { operation });
+    }
+    requireProfileVertexCount(points, 3, operation, limits);
+    requireProfileVertexCount(points * 2, 6, operation, limits);
+    const rotationRadians = ((rotation % 360) * Math.PI) / 180;
+    return Object.freeze(Array.from({ length: points * 2 }, (_, index) => {
+        const radius = index % 2 === 0 ? outerRadius : innerRadius;
+        const angle = (Math.PI * index) / points + rotationRadians;
+        return Object.freeze([radius * Math.cos(angle), radius * Math.sin(angle)]);
+    }));
+};

package/dist/geometry/region-offset.js

@@ -0,0 +1,278 @@
+import { GeometryError } from "./errors.js";
+import { resolveModelingLimits } from "./model-limits.js";
+import { normalizeRegionWithWork, signedContourArea } from "./regions.js";
+import { assertSamplingCount } from "./sampling-limits.js";
+import { resolveGeometryTolerance } from "./tolerance.js";
+const maximumWork = 2_000_000;
+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)))),
+                }))),
+            });
+        },
+    });
+}

package/dist/geometry/regions.js

@@ -274,6 +274,17 @@ const normalizePolygonWithBudget = (polygon, tolerance, budget) => {
  * Previously validated immutable results may be returned unchanged under the same tolerance policy.
  */
 export function normalizeRegion(region, tolerance = {}) {
+    return normalizeRegionWithWork(region, tolerance).region;
+}
+/** @internal Shares normalization's bounded predicate work with a containing operation. */
+export function normalizeRegionWithWork(region, tolerance = {}) {
+    const budget = { candidates: 0 };
+    return {
+        region: normalizeRegionWithBudget(region, tolerance, budget),
+        workCount: budget.candidates,
+    };
+}
+function normalizeRegionWithBudget(region, tolerance, budget) {
     const policy = resolveGeometryTolerance(1, tolerance);
     if (samePolicy(normalizedRegions.get(region), policy))
         return region;
@@ -282,7 +293,6 @@ export function normalizeRegion(region, tolerance = {}) {
             throw new GeometryError("INVALID_TOPOLOGY", "Region polygons must not contain missing entries.");
         }
     }
-    const budget = { candidates: 0 };
     const polygons = region.map((polygon) => normalizePolygonWithBudget(polygon, policy, budget));
     const containsFilledPoint = (polygon, point) => contourContainsPoint(polygon.outer, point) &&
         !polygon.holes.some((hole) => contourContainsPoint(hole, point));

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

@@ -26,7 +26,7 @@ const AXIS_EPSILON = 1e-10;
  * @example Partial revolution with end caps
  * ```ts
  * // Each point is [radius, Z]; the profile seam is implicit.
- * revolveMesh([[0, 0], [12, 0], [8, 20], [0, 20]], { degrees: 270 });
+ * mesh.revolve([[0, 0], [12, 0], [8, 20], [0, 20]], { degrees: 270 });
  * ```
  */
 export const revolveMesh = (input, options = {}) => {

package/dist/geometry/{svg-import.js → svg/import.js}

@@ -1,15 +1,15 @@
 import { SaxesParser } from "saxes";
 import { SVGPathData } from "svg-pathdata";
-import { bounds2 } from "./bounds-value.js";
-import { fitBounds } from "./bounds.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 { createBoundedSvgClipping } from "./svg/fill.js";
-import { inverseMatrix, multiplyMatrices as multiply, transformPoint } from "./svg/matrix.js";
-import { flattenSvgSubpaths, SvgVertexBudget } from "./svg/path.js";
+import { bounds2 } from "../bounds-value.js";
+import { fitBounds } from "../bounds.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 { createBoundedSvgClipping } from "./fill.js";
+import { inverseMatrix, multiplyMatrices as multiply, transformPoint } from "./matrix.js";
+import { flattenSvgSubpaths, SvgVertexBudget } from "./path.js";
 const MAX_SVG_BYTES = 256 * 1024;
 const MAX_SVG_ELEMENTS = 500;
 const MAX_SVG_NESTING_DEPTH = 64;

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

@@ -10,7 +10,7 @@ import { buildOpenSweepMesh } from "./sweep-open.js";
  * @example Sweep point data along a bent path
  * ```ts
  * const profile = rectangleContour({ size: [6, 3] });
- * sweepMesh(profile, [[0, 0, 0], [0, 0, 15], [10, 0, 25]], {
+ * mesh.sweep(profile, [[0, 0, 0], [0, 0, 15], [10, 0, 25]], {
  *   orientation: { kind: "transport", initialNormal: [0, 1, 0] },
  * });
  * ```

package/dist/geometry/transform3.js

@@ -59,6 +59,35 @@ export function validateTransform3(transform, tolerance = {}) {
     }
     return transform;
 }
+/**
+ * Validates a proper rigid transform: finite translation and a right-handed orthonormal rotation.
+ * Scale, shear, reflection, and perspective are rejected within the default angular tolerance.
+ * Returns the original row-major 4x4 matrix without copying or normalizing it.
+ *
+ * @throws {@link GeometryError} For a malformed, non-finite, or non-rigid matrix.
+ */
+export function validateRigidTransform3(transform) {
+    if (!Array.isArray(transform) || transform.length !== 16)
+        throw new GeometryError("INVALID_ARGUMENT", "Rigid transforms require sixteen matrix entries.");
+    for (let index = 0; index < 16; index++) {
+        if (!Object.hasOwn(transform, index) || !Number.isFinite(transform[index]))
+            throw new GeometryError("NON_FINITE_VALUE", "Rigid transforms require sixteen finite values.");
+    }
+    validateTransform3(transform);
+    const tolerance = resolveGeometryTolerance().angular;
+    for (let row = 0; row < 3; row++) {
+        for (let other = row; other < 3; other++) {
+            let product = 0;
+            for (let column = 0; column < 3; column++)
+                product += transform[row * 4 + column] * transform[other * 4 + column];
+            if (Math.abs(product - (row === other ? 1 : 0)) > tolerance)
+                throw new GeometryError("INVALID_ARGUMENT", "Rigid placement permits only translation and rotation; scale and shear are not supported.");
+        }
+    }
+    if (Math.abs(transformDeterminant3(transform) - 1) > tolerance)
+        throw new GeometryError("INVALID_ARGUMENT", "Rigid placement does not support reflection.");
+    return transform;
+}
 /**
  * Creates an immutable translation transform.
  *

package/dist/index.js

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