@metamesh/modeling 0.0.0-stage → 0.7.0

package/dist/geometry/profiles/matched.js

@@ -0,0 +1,192 @@
+import { planarCubicControl } from "../curves/evaluation.js";
+import { resolveLineSegmentCount, resolveUniformCubicSegments } from "../curves/sampling.js";
+import { GeometryError } from "../errors.js";
+import { normalizeRegion2, signedAreaLoop2 } from "../regions.js";
+import { resolveArcSegments, resolveGeometryResolution } from "../resolution.js";
+import { assertSamplingCount, resolveGeometrySamplingLimits } from "../sampling-limits.js";
+import { createProfileSpanSampler } from "./span-sampling.js";
+const isArray = (value) => Array.isArray(value);
+const fail = (message) => {
+    throw new GeometryError("INVALID_ARGUMENT", message, { operation: "matchProfiles" });
+};
+const point = (value) => {
+    if (!isArray(value) || value.length !== 2 || !value.every(Number.isFinite))
+        fail("Profile points must contain two finite coordinates.");
+};
+const identity = (value) => {
+    if (typeof value !== "string" || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(value) || value.length > 64)
+        fail("Profile identities must be canonical identifiers of at most 64 characters.");
+};
+const validateContour = (contour) => {
+    identity(contour.id);
+    if (!isArray(contour.spans) || contour.spans.length === 0 || contour.spans.length > 1000)
+        fail("Each profile contour needs one through 1000 identified spans.");
+    const ids = new Set();
+    for (const span of contour.spans) {
+        identity(span.id);
+        if (ids.has(span.id))
+            fail("Span identities must be unique within a contour.");
+        ids.add(span.id);
+        if (span.segments !== undefined && (!Number.isSafeInteger(span.segments) || span.segments < 1))
+            fail("Exact span intervals must be positive safe integers.");
+        if (span.kind === "line" || span.kind === "cubic") {
+            point(span.start);
+            point(span.end);
+            if (span.kind === "cubic") {
+                point(span.control1);
+                point(span.control2);
+            }
+        }
+        else if (span.kind === "arc") {
+            point(span.center);
+            if (![span.radius, span.startDegrees, span.sweepDegrees].every(Number.isFinite) ||
+                span.radius < 0 ||
+                Math.abs(span.sweepDegrees) > 360 ||
+                span.sweepDegrees === 0)
+                fail("Arc spans need nonnegative radius and a nonzero finite sweep no larger than 360 degrees.");
+        }
+        else
+            fail("Profile spans must be identified lines, circular arcs, or cubic Béziers.");
+    }
+    for (let index = 0; index < contour.spans.length; index += 1) {
+        const currentSpan = contour.spans[index];
+        const nextSpan = contour.spans[(index + 1) % contour.spans.length];
+        const end = currentSpan.kind === "cubic" ? currentSpan.end : createProfileSpanSampler(currentSpan)(1);
+        const next = nextSpan.kind === "cubic" ? nextSpan.start : createProfileSpanSampler(nextSpan)(0);
+        const scale = Math.max(1, ...end.map(Math.abs), ...next.map(Math.abs));
+        if (Math.hypot(end[0] - next[0], end[1] - next[1]) > scale * 1e-12)
+            fail("Ordered profile spans must meet at their paired landmarks.");
+    }
+};
+const contours = (component) => [
+    component.outer,
+    ...component.holes,
+];
+/**
+ * Explicitly matches identified component/contour/span topology across a family.
+ * Every paired span uses the maximum physical subdivision count requested by any member.
+ * Cubics share a checked uniform parameter grid, including grids selected by exact paired requests.
+ * Input order and winding are preserved. Collapsed spans retain repeated logical slots, which
+ * the engine maps to shared physical vertices while omitting degenerate faces.
+ *
+ * @example Match named rectangle landmarks
+ * ```ts
+ * matchProfiles([
+ *   rectangleProfile({ size: [20, 12] }),
+ *   rectangleProfile({ size: [30, 20], treatment: { kind: "round", radius: 3 } }),
+ * ]);
+ * ```
+ */
+export function matchProfiles(profiles, options = {}) {
+    if (!isArray(profiles) || profiles.length === 0 || profiles.length > 1000)
+        fail("A profile family needs one through 1000 members.");
+    const limits = resolveGeometrySamplingLimits(options.limits);
+    const resolution = resolveGeometryResolution({ ...options.resolution }, limits);
+    // This family-wide work bound is independent of configurable per-profile output ceilings.
+    const maximumFamilyPoints = 1_000_000;
+    const cubicBudget = Math.min(limits.maxProfilePoints, Math.floor(maximumFamilyPoints / profiles.length));
+    const first = profiles[0];
+    for (const profile of profiles) {
+        if (!isArray(profile.components) ||
+            profile.components.length === 0 ||
+            profile.components.length > 1000)
+            fail("Profiles need one through 1000 components.");
+        const componentIds = new Set();
+        for (const component of profile.components) {
+            identity(component.id);
+            if (componentIds.has(component.id))
+                fail("Component identities must be unique.");
+            componentIds.add(component.id);
+            if (!isArray(component.holes) || component.holes.length > 1000)
+                fail("Components may have at most 1000 holes.");
+            const contourIds = new Set();
+            for (const contour of contours(component)) {
+                if (contourIds.has(contour.id))
+                    fail("Contour identities must be unique within each component.");
+                contourIds.add(contour.id);
+                validateContour(contour);
+            }
+        }
+        if (profile.components.length !== first.components.length)
+            fail("Profile components cannot appear or disappear within a family.");
+        profile.components.forEach((component, componentIndex) => {
+            const expected = first.components[componentIndex];
+            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];
+                if (contour.id !== paired.id ||
+                    contour.spans.length !== paired.spans.length ||
+                    contour.spans.some((span, index) => span.id !== paired.spans[index].id))
+                    fail("Profile contour and paired span identities must retain the same order.");
+            });
+        });
+    }
+    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];
+            if (span.segments !== undefined)
+                return span.segments;
+            const selectedResolution = resolveGeometryResolution({ ...resolution, ...span.resolution }, limits);
+            if (span.kind === "arc")
+                return span.radius === 0
+                    ? 1
+                    : resolveArcSegments(span.radius, Math.abs(span.sweepDegrees), selectedResolution, limits);
+            if (span.kind === "cubic")
+                return resolveUniformCubicSegments(planarCubicControl(span), selectedResolution, cubicBudget);
+            return resolveLineSegmentCount(Math.hypot(span.end[0] - span.start[0], span.end[1] - span.start[1]), selectedResolution.maxSegmentLength);
+        }));
+        // An exact request in another member may choose a non-dyadic grid. Recheck adaptive
+        // cubics on that actual shared grid instead of assuming a larger count retains the bound.
+        while (true) {
+            let checkedCount = count;
+            for (const profile of profiles) {
+                const span = contours(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));
+            }
+            if (checkedCount === count)
+                break;
+            count = checkedCount;
+        }
+        pointsPerProfile += count;
+        assertSamplingCount(pointsPerProfile, "matchProfiles", limits.maxProfilePoints, "Profile sampling exceeds its selected per-profile point ceiling.");
+        assertSamplingCount(pointsPerProfile * profiles.length, "matchProfiles", maximumFamilyPoints, "Profile family sampling exceeds its one-million-logical-slot work bound.");
+        return count;
+    })));
+    return Object.freeze(profiles.map((profile) => {
+        const components = profile.components.map((component, componentIndex) => {
+            const sampled = contours(component).map((contour, contourIndex) => {
+                const points = [], spans = [];
+                contour.spans.forEach((span, spanIndex) => {
+                    const count = sampling[componentIndex][contourIndex][spanIndex];
+                    const sample = createProfileSpanSampler(span);
+                    for (let index = 0; index < count; index += 1) {
+                        points.push(Object.freeze(sample(index / count)));
+                        spans.push(span.id);
+                    }
+                });
+                const area = signedAreaLoop2(points);
+                if (!(contourIndex === 0 ? area > 0 : area < 0))
+                    fail("Outer contours must be CCW and holes CW; matching never reorders winding.");
+                return Object.freeze({
+                    id: contour.id,
+                    points: Object.freeze(points),
+                    spans: Object.freeze(spans),
+                });
+            });
+            return Object.freeze({
+                id: component.id,
+                outer: sampled[0],
+                holes: Object.freeze(sampled.slice(1)),
+            });
+        });
+        // This validates intersections and containment, without changing logical slots or topology.
+        normalizeRegion2(components.map((component) => ({
+            outer: component.outer.points,
+            holes: component.holes.map((hole) => hole.points),
+        })));
+        return Object.freeze({ components: Object.freeze(components) });
+    }));
+}

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

@@ -0,0 +1,137 @@
+import { GeometryError } from "../errors.js";
+import { resolveGeometryResolution } from "../resolution.js";
+import { resolveGeometrySamplingLimits } from "../sampling-limits.js";
+import { requireProfileVertexCount } from "./validation.js";
+const OPERATION = "sampleOpenProfile";
+const MAX_SEGMENTS = 31;
+const MAX_DEPTH = 24;
+function invalid(message) {
+    throw new GeometryError("INVALID_ARGUMENT", message, { operation: OPERATION });
+}
+function midpoint(a, b) {
+    return [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2];
+}
+function distanceToChord(point, start, end) {
+    const dx = end[0] - start[0];
+    const dy = end[1] - start[1];
+    const squared = dx * dx + dy * dy;
+    const t = squared === 0
+        ? 0
+        : Math.max(0, Math.min(1, ((point[0] - start[0]) * dx + (point[1] - start[1]) * dy) / squared));
+    return Math.hypot(point[0] - start[0] - t * dx, point[1] - start[1] - t * dy);
+}
+/**
+ * Samples 1–31 line/cubic segments into a deeply immutable open [radius,height] polyline.
+ * Anchors must progress strictly upward; nonnegative-radius cubic controls must have ordered
+ * heights between their endpoints. Cubics use de Casteljau subdivision with a conservative
+ * control-hull chord-error bound. Lines also obey the optional physical edge-length ceiling.
+ * 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 4096 vertices.
+ * @returns Frozen open polyline in millimetres, ordered from lowest to highest anchor.
+ * @throws {@link GeometryError} for invalid coordinates, order, scale, or exceeded subdivision budget.
+ *
+ * @example
+ * ```ts
+ * const side = sampleOpenProfile({
+ *   start: { radius: 0.5, height: 0 },
+ *   segments: [{ type: "line", end: { radius: 1, height: 1 } }],
+ * }, { radiusScale: 12, heightScale: 30 });
+ * ```
+ */
+export function sampleOpenProfile(curve, options = {}) {
+    const radiusScale = options.radiusScale ?? 1;
+    const heightScale = options.heightScale ?? 1;
+    if (![radiusScale, heightScale].every((scale) => Number.isFinite(scale) && scale > 0)) {
+        invalid("Profile scales must be finite and positive.");
+    }
+    const maximumVertices = options.maximumVertices ??
+        Math.min(4096, resolveGeometrySamplingLimits(options.limits).maxProfilePoints);
+    requireProfileVertexCount(maximumVertices, 2, OPERATION, options.limits);
+    const maximumProfilePoints = resolveGeometrySamplingLimits(options.limits).maxProfilePoints;
+    const segmentInput = curve.segments;
+    if (!Array.isArray(segmentInput) ||
+        curve.segments.length < 1 ||
+        curve.segments.length > MAX_SEGMENTS) {
+        invalid("An open profile must contain 1–31 segments.");
+    }
+    const resolution = resolveGeometryResolution(options.resolution, options.limits);
+    const physical = (point) => {
+        if (!point || !Number.isFinite(point.radius) || !Number.isFinite(point.height)) {
+            invalid("Profile coordinates must be finite.");
+        }
+        const radius = point.radius * radiusScale;
+        const height = point.height * heightScale;
+        if (!Number.isFinite(radius) || !Number.isFinite(height) || radius < 0) {
+            invalid("Scaled coordinates must be finite with a nonnegative radius.");
+        }
+        return [radius, height];
+    };
+    const output = [];
+    const append = (point) => {
+        if (output.length >= maximumVertices || output.length >= maximumProfilePoints) {
+            throw new GeometryError("COMPLEXITY_LIMIT", "Profile sampling exceeds its vertex budget.", {
+                operation: OPERATION,
+                details: { maximumVertices },
+            });
+        }
+        output.push(Object.freeze(point));
+    };
+    const flatten = (a, b, c, d, depth) => {
+        if (Math.max(distanceToChord(b, a, d), distanceToChord(c, a, d)) <= resolution.maxChordError &&
+            (resolution.maxSegmentLength === undefined ||
+                Math.hypot(d[0] - a[0], d[1] - a[1]) <= resolution.maxSegmentLength)) {
+            append(d);
+            return;
+        }
+        if (depth >= MAX_DEPTH) {
+            throw new GeometryError("COMPLEXITY_LIMIT", "Profile subdivision exceeds its recursion limit.", {
+                operation: OPERATION,
+                details: { maximumDepth: MAX_DEPTH },
+            });
+        }
+        const ab = midpoint(a, b), bc = midpoint(b, c), cd = midpoint(c, d);
+        const abc = midpoint(ab, bc), bcd = midpoint(bc, cd), split = midpoint(abc, bcd);
+        flatten(a, ab, abc, split, depth + 1);
+        flatten(split, bcd, cd, d, depth + 1);
+    };
+    let start = physical(curve.start);
+    append(start);
+    for (const segment of curve.segments) {
+        const end = physical(segment.end);
+        if (!(end[1] > start[1]))
+            invalid("Profile anchor heights must increase strictly.");
+        if (segment.type === "line") {
+            const length = Math.hypot(end[0] - start[0], end[1] - start[1]);
+            const count = resolution.maxSegmentLength === undefined
+                ? 1
+                : Math.max(1, Math.ceil(length / resolution.maxSegmentLength));
+            if (count > maximumVertices - output.length) {
+                throw new GeometryError("COMPLEXITY_LIMIT", "Profile line exceeds its vertex budget.", {
+                    operation: OPERATION,
+                    details: { maximumVertices },
+                });
+            }
+            for (let index = 1; index <= count; index++) {
+                const t = index / count;
+                append(index === count
+                    ? end
+                    : [start[0] + (end[0] - start[0]) * t, start[1] + (end[1] - start[1]) * t]);
+            }
+        }
+        else if (segment.type === "cubic") {
+            const first = physical(segment.control1), second = physical(segment.control2);
+            if (!(start[1] <= first[1] && first[1] <= second[1] && second[1] <= end[1])) {
+                invalid("Cubic control heights must progress between their anchors.");
+            }
+            flatten(start, first, second, end, 0);
+        }
+        else {
+            invalid("Profile segments must be lines or cubics.");
+        }
+        start = end;
+    }
+    return Object.freeze(output);
+}

package/dist/geometry/profiles/profiles.js

@@ -0,0 +1,91 @@
+import { GeometryError } from "../errors.js";
+import { resolveCircularPrimitiveSegments } from "../primitive-resolution.js";
+import { assertPrimitiveOptions } from "../primitive-resolvers.js";
+import { requireFiniteProfileValues, requireProfileVertexCount } from "./validation.js";
+export { rectangleLoop } from "./rectangle.js";
+/**
+ * Creates an immutable centered CCW circle with +X seam and vertex or face radial sizing.
+ *
+ * @example Explicit circular point data
+ * ```ts
+ * circleLoop({ diameter: 20, segments: 32 });
+ * ```
+ */
+export const circleLoop = (options) => {
+    const operation = "circleLoop";
+    assertPrimitiveOptions(options, operation);
+    if ((options.radius === undefined) === (options.diameter === undefined)) {
+        throw new GeometryError("INVALID_ARGUMENT", "Specify exactly one radius or diameter.", {
+            operation,
+        });
+    }
+    const radius = options.radius ?? options.diameter / 2;
+    requireFiniteProfileValues([radius], operation);
+    if (!(radius > 0)) {
+        throw new GeometryError("INVALID_ARGUMENT", "Circle radius must be positive.", { operation });
+    }
+    const segments = resolveCircularPrimitiveSegments(radius, options, operation);
+    requireProfileVertexCount(segments, 3, operation, options.limits);
+    const sizing = options.sizing ?? "vertex";
+    if (sizing !== "vertex" && sizing !== "face") {
+        throw new GeometryError("INVALID_ARGUMENT", "Circle sizing must be vertex or face.", {
+            operation,
+        });
+    }
+    const sampledRadius = sizing === "face" ? radius / Math.cos(Math.PI / segments) : radius;
+    requireFiniteProfileValues([sampledRadius], operation);
+    return Object.freeze(Array.from({ length: segments }, (_, index) => {
+        const angle = (Math.PI * 2 * index) / segments;
+        return Object.freeze([sampledRadius * Math.cos(angle), sampledRadius * Math.sin(angle)]);
+    }));
+};
+/**
+ * Creates a centered CCW point loop with vertex or face radial sizing and an implicit seam.
+ *
+ * @example Hexagon sized to its faces
+ * ```ts
+ * regularPolygonLoop({ radius: 10, sides: 6, sizing: "face" });
+ * ```
+ */
+export const regularPolygonLoop = (options) => {
+    const operation = "regularPolygonLoop";
+    const { radius, sides, rotationDegrees = 0, sizing = "vertex" } = options;
+    requireFiniteProfileValues([radius, rotationDegrees], 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 rotation = ((rotationDegrees % 360) * Math.PI) / 180;
+    return Array.from({ length: sides }, (_, index) => {
+        const angle = rotation + (Math.PI * 2 * index) / sides;
+        return [sampledRadius * Math.cos(angle), sampledRadius * Math.sin(angle)];
+    });
+};
+/**
+ * Creates a centered CCW alternating-radius star within the selected profile sampling ceiling.
+ *
+ * @example Five-point outline
+ * ```ts
+ * starLoop(12, 5, 6);
+ * ```
+ */
+export const starLoop = (outerRadius, points, innerRadius = outerRadius / 2, limits = {}) => {
+    const operation = "starLoop";
+    requireFiniteProfileValues([outerRadius, innerRadius], 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);
+    return Array.from({ length: points * 2 }, (_, index) => {
+        const radius = index % 2 === 0 ? outerRadius : innerRadius;
+        const angle = (Math.PI * index) / points;
+        return [radius * Math.cos(angle), radius * Math.sin(angle)];
+    });
+};

package/dist/geometry/profiles/rectangle.js

@@ -0,0 +1,249 @@
+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";
+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;
+    requireFiniteProfileValues([width, height], operation);
+    if (!(width > 0) || !(height > 0))
+        fail(operation, "Rectangle dimensions must be positive.");
+    const treatment = options.treatment;
+    const square = { kind: "round", radius: 0 };
+    const corners = treatment === undefined
+        ? [square, square, square, square]
+        : Array.isArray(treatment)
+            ? treatment
+            : [treatment, treatment, treatment, treatment];
+    if (corners.length !== 4 ||
+        corners.some((corner) => typeof corner !== "object" || corner === null))
+        fail(operation, "Rectangle treatments require a uniform treatment or four corner objects.");
+    const setbacks = corners.map((corner) => {
+        if (corner.kind === "square") {
+            if (!Array.isArray(treatment))
+                fail(operation, "An untreated corner is available only in a four-corner treatment tuple.");
+            return [0, 0];
+        }
+        return edgeTreatmentSetbacks(corner, operation, Math.PI / 2, options.limits);
+    });
+    const [tr, tl, bl, br] = setbacks;
+    if (tr[1] + tl[0] > width ||
+        bl[1] + br[0] > width ||
+        tl[1] + bl[0] > height ||
+        br[1] + tr[0] > height)
+        fail(operation, "Adjacent rectangle corner treatments must fit without overlap.");
+    if (!Array.isArray(treatment) &&
+        treatment?.kind === "chamfer" &&
+        setbacks.some((pair) => pair.some((value) => 2 * value >= Math.min(width, height))))
+        fail(operation, "Uniform chamfers must be smaller than half every dimension.");
+    const baseLimits = resolveModelingLimits(options.limits);
+    const limits = { ...baseLimits };
+    for (const corner of corners)
+        if (corner.kind === "round" || corner.kind === "smooth") {
+            const local = resolveModelingLimits(corner.limits, baseLimits);
+            for (const key of Object.keys(baseLimits))
+                limits[key] = Math.min(limits[key], local[key]);
+        }
+    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) {
+    if (corner.kind !== "round")
+        return 1;
+    const selected = resolveModelingLimits(limits);
+    const exact = corner.segments ?? corner.resolution?.circularSegments;
+    if (exact !== undefined && Number.isSafeInteger(exact) && exact >= 3)
+        assertSamplingCount(exact, "rectangleLoop", selected.maxCircularSegments);
+    if (corner.radius === 0 &&
+        corner.segments === undefined &&
+        corner.resolution?.circularSegments === undefined)
+        return 1;
+    return (resolveAlignedCircularSegments(Math.max(corner.radius, Number.MIN_VALUE), {
+        alignTo: [4],
+        minimumSegments: 4,
+        ...(corner.segments === undefined ? {} : { segments: corner.segments }),
+        ...(corner.resolution === undefined ? {} : { resolution: corner.resolution }),
+        limits: selected,
+    }) / 4);
+}
+/**
+ * Creates an immutable CCW rectangle loop. Round radius zero is square; tangent saturated endpoints occur once.
+ *
+ * @example Rounded rectangle outline
+ * ```ts
+ * rectangleLoop({ size: [30, 20], treatment: { kind: "round", radius: 3 } });
+ * ```
+ */
+export function rectangleLoop(options) {
+    const { width, height, corners, limits } = resolveRectangle(options, "rectangleLoop");
+    const counts = corners.map((corner) => {
+        if (corner.kind === "square")
+            return 1;
+        if (corner.kind === "round") {
+            const intervals = rectangleCornerSegments(corner, limits);
+            return corner.radius > 0 ? intervals + 1 : 1;
+        }
+        return edgeTreatmentPointCount(corner, "rectangleLoop", { limits });
+    });
+    requireProfileVertexCount(counts.reduce((sum, count) => sum + count, 0), 3, "rectangleLoop", limits);
+    const x = width / 2, y = height / 2;
+    const vertices = [
+        [x, y],
+        [-x, y],
+        [-x, -y],
+        [x, -y],
+    ];
+    const incoming = [
+        [0, -1],
+        [1, 0],
+        [0, 1],
+        [-1, 0],
+    ];
+    const outgoing = [
+        [-1, 0],
+        [0, -1],
+        [1, 0],
+        [0, 1],
+    ];
+    const points = [];
+    corners.forEach((corner, index) => {
+        if (corner.kind === "round" && corner.radius > 0) {
+            const start = (index * Math.PI) / 2, size = corner.radius, [vx, vy] = vertices[index];
+            const cx = vx - Math.cos(start + Math.PI / 4) * Math.SQRT2 * size;
+            const cy = vy - Math.sin(start + Math.PI / 4) * Math.SQRT2 * size;
+            for (let step = 0; step < counts[index]; step++) {
+                const angle = start + (step * Math.PI) / (2 * (counts[index] - 1));
+                points.push([cx + Math.cos(angle) * size, cy + Math.sin(angle) * size]);
+            }
+            return;
+        }
+        const samples = corner.kind === "square"
+            ? [[0, 0]]
+            : sampleEdgeTreatment(corner, "rectangleLoop", { limits });
+        for (const [a, b] of samples)
+            points.push([
+                vertices[index][0] + incoming[index][0] * a + outgoing[index][0] * b,
+                vertices[index][1] + incoming[index][1] * a + outgoing[index][1] * b,
+            ]);
+    });
+    const epsilon = Math.max(width, height) * Number.EPSILON * 8;
+    const same = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1]) <= epsilon;
+    const clean = points.filter((point, index) => index === 0 || !same(point, points[index - 1]));
+    if (clean.length > 1 && same(clean[0], clean.at(-1)))
+        clean.pop();
+    return Object.freeze(clean.map(([px, py]) => Object.freeze(options.center === false ? [px + x, py + y] : [px, py])));
+}
+/**
+ * Creates an identified rectangle whose edge/corner spans survive zero and saturated round radii. Outer winding is CCW.
+ *
+ * @example Retain rectangle landmarks
+ * ```ts
+ * rectangleProfile({ size: [30, 20], treatment: { kind: "round", radius: 3 } });
+ * ```
+ */
+export function rectangleProfile(options) {
+    const { width, height, corners, setbacks, limits } = resolveRectangle(options, "rectangleProfile");
+    const id = options.id ?? "body";
+    const spanCount = corners.reduce((sum, corner) => sum +
+        (corner.kind === "profile"
+            ? edgeTreatmentPointCount(corner, "rectangleProfile", { limits }) - 1
+            : 1), 4);
+    // A square's four collapsed corner landmarks add four metadata slots without adding physical points.
+    assertSamplingCount(spanCount, "rectangleProfile", limits.maxProfilePoints + 4);
+    if (typeof id !== "string" || !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(id) || id.length > 64)
+        fail("rectangleProfile", "Profile identities must be canonical identifiers of at most 64 characters.");
+    const x = width / 2, y = height / 2;
+    const vertices = [
+        [x, y, 0],
+        [-x, y, 90],
+        [-x, -y, 180],
+        [x, -y, 270],
+    ];
+    const names = ["top-right", "top-left", "bottom-left", "bottom-right"];
+    const edges = ["top", "left", "bottom", "right"];
+    const point = (px, py) => options.center === false ? [px + x, py + y] : [px, py];
+    const spans = [];
+    const incoming = [
+        [0, -1],
+        [1, 0],
+        [0, 1],
+        [-1, 0],
+    ];
+    const outgoing = [
+        [-1, 0],
+        [0, -1],
+        [1, 0],
+        [0, 1],
+    ];
+    const map = (index, a, b) => point(vertices[index][0] + incoming[index][0] * a + outgoing[index][0] * b, vertices[index][1] + incoming[index][1] * a + outgoing[index][1] * b);
+    const endpoints = setbacks.map(([a, b], index) => ({
+        start: map(index, a, 0),
+        end: map(index, 0, b),
+        center: map(index, a, b),
+    }));
+    corners.forEach((corner, index) => {
+        const shape = endpoints[index], startDegrees = vertices[index][2];
+        if (corner.kind === "chamfer")
+            spans.push({ id: names[index], kind: "line", start: shape.start, end: shape.end });
+        else if (corner.kind === "smooth") {
+            sampleEdgeTreatment(corner, "rectangleProfile", { limits });
+            spans.push({
+                id: names[index],
+                kind: "cubic",
+                start: shape.start,
+                control1: map(index, 0, 0),
+                control2: map(index, 0, 0),
+                end: shape.end,
+                ...(corner.segments === undefined ? {} : { segments: corner.segments }),
+                ...(corner.resolution === undefined ? {} : { resolution: corner.resolution }),
+            });
+        }
+        else if (corner.kind === "profile") {
+            const samples = sampleEdgeTreatment(corner, "rectangleProfile", { limits });
+            for (let slot = 0; slot < samples.length - 1; slot++)
+                spans.push({
+                    id: `${names[index]}-${slot}`,
+                    kind: "line",
+                    start: map(index, ...samples[slot]),
+                    end: map(index, ...samples[slot + 1]),
+                });
+        }
+        else {
+            const exact = corner.kind === "round" &&
+                (corner.segments !== undefined || corner.resolution?.circularSegments !== undefined);
+            if (corner.kind === "round")
+                rectangleCornerSegments(corner, limits);
+            spans.push({
+                id: names[index],
+                kind: "arc",
+                center: shape.center,
+                radius: setbacks[index][0],
+                startDegrees,
+                sweepDegrees: 90,
+                ...(exact ? { segments: rectangleCornerSegments(corner, limits) } : {}),
+                ...(corner.kind === "round" && corner.resolution !== undefined
+                    ? { resolution: { ...corner.resolution } }
+                    : {}),
+            });
+        }
+        spans.push({
+            id: edges[index],
+            kind: "line",
+            start: shape.end,
+            end: endpoints[(index + 1) % 4].start,
+        });
+    });
+    return { components: [{ id, holes: [], outer: { id: "outline", spans } }] };
+}