@metamesh/modeling 0.0.0-stage → 0.7.0

package/dist/geometry/resolution.js

@@ -0,0 +1,236 @@
+import { GeometryError } from "./errors.js";
+import { resolveGeometrySamplingLimits } from "./sampling-limits.js";
+const DEFAULT_MAX_CHORD_ERROR = 0.05;
+const DEFAULT_MINIMUM_SEGMENTS = 16;
+const invalid = (message, details) => {
+    throw new GeometryError("INVALID_ARGUMENT", message, {
+        operation: "geometryResolution",
+        ...(details === undefined ? {} : { details }),
+    });
+};
+/** @internal Resolves operation policy over explicit allocation ceilings and defaults. */
+export function resolveGeometryResolution(policy = {}, limits = {}) {
+    const merged = policy;
+    const circularSegments = merged.circularSegments;
+    const allowedMaximum = resolveGeometrySamplingLimits(limits).maxCircularSegments;
+    const minimumSegments = merged.minimumSegments ?? Math.min(DEFAULT_MINIMUM_SEGMENTS, allowedMaximum);
+    const maximumSegments = merged.maximumSegments ?? allowedMaximum;
+    const maxChordError = merged.maxChordError ?? DEFAULT_MAX_CHORD_ERROR;
+    const maxSegmentLength = merged.maxSegmentLength;
+    if (!Number.isSafeInteger(minimumSegments) || minimumSegments < 3) {
+        invalid("minimumSegments must be an integer of at least three.", { minimumSegments });
+    }
+    if (!Number.isSafeInteger(maximumSegments) ||
+        maximumSegments < minimumSegments ||
+        maximumSegments > allowedMaximum) {
+        invalid("maximumSegments must be a safe integer between minimumSegments and maxCircularSegments.", {
+            allowedMaximum,
+            maximumSegments,
+            minimumSegments,
+        });
+    }
+    if (!Number.isFinite(maxChordError) || maxChordError <= 0) {
+        invalid("maxChordError must be finite and positive.", { maxChordError });
+    }
+    if (maxSegmentLength !== undefined &&
+        (!Number.isFinite(maxSegmentLength) || maxSegmentLength <= 0)) {
+        invalid("maxSegmentLength must be finite and positive when supplied.", {
+            maxSegmentLength,
+        });
+    }
+    if (circularSegments !== undefined &&
+        (!Number.isSafeInteger(circularSegments) ||
+            circularSegments < 3 ||
+            circularSegments > maximumSegments)) {
+        invalid("circularSegments must be an integer from three through maximumSegments.", {
+            circularSegments,
+            maximumSegments,
+        });
+    }
+    return Object.freeze({
+        ...(circularSegments === undefined ? {} : { circularSegments }),
+        maxChordError,
+        ...(maxSegmentLength === undefined ? {} : { maxSegmentLength }),
+        maximumSegments,
+        minimumSegments,
+    });
+}
+const requiredFullCircleSegments = (radius, resolution) => {
+    const chordAngle = 2 * Math.acos(Math.max(-1, Math.min(1, 1 - resolution.maxChordError / radius)));
+    const chordSegments = chordAngle === 0 ? Number.POSITIVE_INFINITY : Math.ceil((Math.PI * 2) / chordAngle);
+    const lengthSegments = resolution.maxSegmentLength === undefined
+        ? 0
+        : Math.ceil((Math.PI * 2 * radius) / resolution.maxSegmentLength);
+    return Math.max(resolution.minimumSegments, chordSegments, lengthSegments);
+};
+const assertRadius = (radius, operation) => {
+    if (!Number.isFinite(radius) || radius <= 0) {
+        throw new GeometryError("INVALID_ARGUMENT", "Curve radius must be finite and positive.", {
+            operation,
+            details: { radius },
+        });
+    }
+};
+/**
+ * Resolves a deterministic full-circle segment count for one radius.
+ *
+ * An exact `circularSegments` value wins. Otherwise the smallest regular polygon satisfying both
+ * physical error criteria is used. A safety cap that would violate either criterion raises
+ * `COMPLEXITY_LIMIT` rather than silently reducing quality.
+ *
+ * @param radius - Circle radius in millimetres.
+ * @param policy - Optional operation-level policy under explicit sampling ceilings.
+ * @returns Full-circle segment count.
+ * @throws {@link GeometryError} when radius or policy is invalid, or the requested tolerance
+ * exceeds the configured segment safety limit.
+ * @see {@link resolveArcSegments}
+ * @see {@link resolveAlignedCircularSegments}
+ *
+ * @example
+ * ```ts
+ * const circleSegments = resolveCircularSegments(25, { maxChordError: 0.05 });
+ * ```
+ */
+export function resolveCircularSegments(radius, policy = {}, limits = {}) {
+    const operation = "resolveCircularSegments";
+    assertRadius(radius, operation);
+    const resolution = resolveGeometryResolution(policy, limits);
+    if (resolution.circularSegments !== undefined)
+        return resolution.circularSegments;
+    const required = requiredFullCircleSegments(radius, resolution);
+    if (required > resolution.maximumSegments) {
+        throw new GeometryError("COMPLEXITY_LIMIT", `The requested physical curve tolerance requires ${required} segments, above the ${resolution.maximumSegments}-segment safety limit.`, {
+            operation,
+            details: {
+                maximumSegments: resolution.maximumSegments,
+                radius,
+                requiredSegments: required,
+            },
+        });
+    }
+    return required;
+}
+const greatestCommonDivisor = (left, right) => {
+    let a = left;
+    let b = right;
+    while (b !== 0) {
+        const remainder = a % b;
+        a = b;
+        b = remainder;
+    }
+    return a;
+};
+const checkedLeastCommonMultiple = (left, right, operation) => {
+    const scaledLeft = left / greatestCommonDivisor(left, right);
+    if (scaledLeft > Number.MAX_SAFE_INTEGER / right) {
+        throw new GeometryError("COMPLEXITY_LIMIT", "The requested segment alignments exceed safe integer complexity.", { operation, details: { left, right } });
+    }
+    return scaledLeft * right;
+};
+/**
+ * Resolves a deterministic full-circle count aligned to reusable topology factors.
+ *
+ * `alignTo` must be non-empty and contain only positive safe integers. Its checked least common
+ * multiple defines the alignment grid. An exact `segments` value wins over
+ * `resolution.circularSegments` and adaptive sampling, but is never rounded: it must already be
+ * aligned and meet `minimumSegments`. Adaptive counts are rounded upward and fail with
+ * `COMPLEXITY_LIMIT` when the aligned result exceeds the configured safety cap.
+ *
+ * @param radius - Positive circle radius in millimetres used for adaptive physical sampling.
+ * @param options - Required alignment factors plus optional floor, exact count, and resolution.
+ * @returns An aligned full-circle segment count.
+ * @throws {@link GeometryError} when radius, alignment factors, segment floors, or resolution are
+ * invalid, or alignment exceeds safe integer or configured complexity limits.
+ * @see {@link resolveCircularSegments}
+ *
+ * @example
+ * ```ts
+ * const alignedSegments = resolveAlignedCircularSegments(20, { alignTo: [4, 6] });
+ * ```
+ */
+export function resolveAlignedCircularSegments(radius, options) {
+    const operation = "resolveAlignedCircularSegments";
+    assertRadius(radius, operation);
+    const alignTo = options.alignTo;
+    const hasArrayShape = Array.isArray(alignTo);
+    if (!hasArrayShape || alignTo.length === 0) {
+        throw new GeometryError("INVALID_ARGUMENT", "alignTo must be a non-empty array.", {
+            operation,
+        });
+    }
+    let alignment = 1;
+    for (const factor of alignTo) {
+        if (!Number.isSafeInteger(factor) || factor <= 0) {
+            throw new GeometryError("INVALID_ARGUMENT", "Every alignTo value must be a positive safe integer.", { operation, details: { factor } });
+        }
+        alignment = checkedLeastCommonMultiple(alignment, factor, operation);
+    }
+    const minimumSegments = options.minimumSegments ?? 3;
+    if (!Number.isSafeInteger(minimumSegments) || minimumSegments < 3) {
+        throw new GeometryError("INVALID_ARGUMENT", "minimumSegments must be a safe integer of at least three.", { operation, details: { minimumSegments } });
+    }
+    const resolution = options.segments === undefined
+        ? resolveGeometryResolution(options.resolution, options.limits)
+        : resolveGeometryResolution({
+            circularSegments: options.segments,
+        }, options.limits);
+    if (resolution.circularSegments !== undefined) {
+        const exactSegments = resolution.circularSegments;
+        if (exactSegments < minimumSegments || exactSegments % alignment !== 0) {
+            throw new GeometryError("INVALID_ARGUMENT", "The exact segment count must meet minimumSegments and every alignTo factor.", {
+                operation,
+                details: { alignment, exactSegments, minimumSegments },
+            });
+        }
+        return exactSegments;
+    }
+    const baseSegments = resolveCircularSegments(radius, {
+        ...resolution,
+    }, options.limits);
+    const requiredSegments = Math.max(baseSegments, minimumSegments);
+    const multiplier = Math.ceil(requiredSegments / alignment);
+    if (!Number.isSafeInteger(multiplier) || multiplier > Number.MAX_SAFE_INTEGER / alignment) {
+        throw new GeometryError("COMPLEXITY_LIMIT", "The aligned segment count exceeds safe integer complexity.", { operation, details: { alignment, requiredSegments } });
+    }
+    const alignedSegments = multiplier * alignment;
+    if (alignedSegments > resolution.maximumSegments) {
+        throw new GeometryError("COMPLEXITY_LIMIT", "Aligned circular tessellation exceeds the configured segment safety limit.", {
+            operation,
+            details: {
+                alignment,
+                maximumSegments: resolution.maximumSegments,
+                requiredSegments,
+                segments: alignedSegments,
+            },
+        });
+    }
+    return alignedSegments;
+}
+/**
+ * Resolves the number of segments needed for a circular arc.
+ *
+ * Full-circle limits and exact circular counts are scaled to the requested angular span, matching
+ * the reusable BOSL2-style convention while retaining at least one segment.
+ *
+ * @param radius - Arc radius in millimetres.
+ * @param angleDegrees - Non-zero signed sweep angle no greater than 360 degrees in magnitude.
+ * @param policy - Optional operation-level policy over the active model scope.
+ * @returns Segment count for the requested arc span.
+ * @throws {@link GeometryError} when radius, angle, or resolution policy is invalid, or the
+ * corresponding full-circle tolerance exceeds the configured safety limit.
+ * @see {@link resolveCircularSegments}
+ *
+ * @example
+ * ```ts
+ * const quarterTurnSegments = resolveArcSegments(10, 90);
+ * ```
+ */
+export function resolveArcSegments(radius, angleDegrees, policy = {}, limits = {}) {
+    const operation = "resolveArcSegments";
+    assertRadius(radius, operation);
+    if (!Number.isFinite(angleDegrees) || angleDegrees === 0 || Math.abs(angleDegrees) > 360) {
+        throw new GeometryError("INVALID_ARGUMENT", "angleDegrees must be finite, non-zero, and no greater than 360 degrees in magnitude.", { operation, details: { angleDegrees } });
+    }
+    const ratio = Math.abs(angleDegrees) / 360;
+    return Math.max(1, Math.ceil(resolveCircularSegments(radius, policy, limits) * ratio));
+}

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

@@ -0,0 +1,129 @@
+import { GeometryError } from "../errors.js";
+import { triangulateLoop2 } from "../loft.js";
+import { validateTriangleMesh } from "../mesh.js";
+import { assertMeshAllocationWithinLimits, resolveModelingLimits, } from "../model-limits.js";
+import { writeMeshVertex } from "../numeric.js";
+import { resolveCircularPrimitiveSegments } from "../primitive-resolution.js";
+import { normalizeLoop2 } from "../regions.js";
+import { assertSamplingCount } from "../sampling-limits.js";
+const AXIS_EPSILON = 1e-10;
+/**
+ * Revolves a non-duplicated closed `[radius, z]` profile around +Z.
+ *
+ * The profile is ordered counter-clockwise when radius points right and Z
+ * points up. Angular and profile seams wrap by index. A profile point on the
+ * axis is emitted once and joined as a triangle fan, avoiding coincident seam
+ * vertices and zero-area quads. Profile edges that lie entirely on the axis
+ * collapse to the solid's interior and are intentionally omitted.
+ * Profile coordinates must fit finite Float32 mesh storage.
+ *
+ * @param profile - Closed CCW `[radius, z]` profile without a duplicated seam point.
+ * @param options - Optional physical or exact circumferential sampling controls. Defaults to `{}`.
+ * @returns A closed indexed triangle mesh revolved counter-clockwise around +Z.
+ *
+ * @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]], { revolveDegrees: 270 });
+ * ```
+ */
+export const revolveMesh = (profile, options = {}) => {
+    if (typeof options !== "object" || options === null || Array.isArray(options))
+        throw new GeometryError("INVALID_ARGUMENT", "Revolution options require an object.", {
+            operation: "revolveMesh",
+        });
+    const degrees = options.revolveDegrees ?? 360;
+    if (!Number.isFinite(degrees) || degrees <= 0 || degrees > 360)
+        throw new GeometryError("INVALID_ARGUMENT", "revolveDegrees must be in (0, 360].", {
+            operation: "revolveMesh",
+        });
+    if (profile.length < 3) {
+        throw new Error("A revolved profile needs at least three points.");
+    }
+    const limits = resolveModelingLimits(options.limits);
+    assertSamplingCount(profile.length, "revolveMesh", limits.maxProfilePoints);
+    let maximumRadius = 0;
+    for (const [radius, z] of profile) {
+        if (!Number.isFinite(radius) || !Number.isFinite(z) || radius < 0) {
+            throw new Error("Revolved profile coordinates must be finite and radii non-negative.");
+        }
+        if (!Number.isFinite(Math.fround(radius)) || !Number.isFinite(Math.fround(z))) {
+            throw new GeometryError("NON_FINITE_VALUE", "Revolved profile coordinates exceed finite Float32 mesh storage.", { operation: "revolveMesh" });
+        }
+        maximumRadius = Math.max(maximumRadius, radius);
+    }
+    profile = normalizeLoop2(profile, true);
+    const circularSegments = resolveCircularPrimitiveSegments(maximumRadius, options, "revolveMesh");
+    const closed = degrees === 360;
+    const segments = closed
+        ? circularSegments
+        : Math.max(1, Math.ceil((circularSegments * degrees) / 360));
+    const rings = closed ? segments : segments + 1;
+    const vertexCount = profile.reduce((count, [radius]) => count + (radius <= AXIS_EPSILON ? 1 : rings), 0);
+    const triangleCount = profile.reduce((count, [radius], index) => {
+        const currentOnAxis = radius <= AXIS_EPSILON;
+        const nextOnAxis = profile[(index + 1) % profile.length][0] <= AXIS_EPSILON;
+        return (count +
+            (currentOnAxis && nextOnAxis ? 0 : currentOnAxis || nextOnAxis ? segments : segments * 2));
+    }, 0) + (closed ? 0 : (profile.length - 2) * 2);
+    assertMeshAllocationWithinLimits(vertexCount, triangleCount, (vertexCount + triangleCount) * 12, "revolveMesh", limits);
+    const vertexIndices = profile.map(([radius]) => radius <= AXIS_EPSILON ? new Uint32Array(1) : new Uint32Array(rings));
+    const positions = new Float32Array(vertexCount * 3);
+    let vertex = 0;
+    for (let profileIndex = 0; profileIndex < profile.length; profileIndex += 1) {
+        const [radius, z] = profile[profileIndex];
+        const indices = vertexIndices[profileIndex];
+        if (radius <= AXIS_EPSILON) {
+            indices[0] = vertex;
+            writeMeshVertex(positions, vertex++ * 3, [0, 0, z], "revolveMesh");
+            continue;
+        }
+        for (let segment = 0; segment < rings; segment += 1) {
+            const angle = (segment * degrees * Math.PI) / 180 / segments;
+            indices[segment] = vertex;
+            writeMeshVertex(positions, vertex++ * 3, [radius * Math.cos(angle), radius * Math.sin(angle), z], "revolveMesh");
+        }
+    }
+    const indices = new Uint32Array(triangleCount * 3);
+    let cursor = 0;
+    const triangle = (a, b, c) => {
+        indices[cursor++] = a;
+        indices[cursor++] = b;
+        indices[cursor++] = c;
+    };
+    for (let profileIndex = 0; profileIndex < profile.length; profileIndex += 1) {
+        const following = (profileIndex + 1) % profile.length;
+        const currentRadius = profile[profileIndex][0];
+        const followingRadius = profile[following][0];
+        const current = vertexIndices[profileIndex];
+        const next = vertexIndices[following];
+        const currentOnAxis = currentRadius <= AXIS_EPSILON;
+        const nextOnAxis = followingRadius <= AXIS_EPSILON;
+        if (currentOnAxis && nextOnAxis) {
+            continue;
+        }
+        for (let segment = 0; segment < segments; segment += 1) {
+            const nextSegment = closed ? (segment + 1) % segments : segment + 1;
+            if (currentOnAxis) {
+                triangle(current[0], next[nextSegment], next[segment]);
+            }
+            else if (nextOnAxis) {
+                triangle(current[segment], current[nextSegment], next[0]);
+            }
+            else {
+                triangle(current[segment], current[nextSegment], next[nextSegment]);
+                triangle(current[segment], next[nextSegment], next[segment]);
+            }
+        }
+    }
+    if (!closed) {
+        const cap = triangulateLoop2(profile);
+        const at = (profileIndex, station) => vertexIndices[profileIndex][profile[profileIndex][0] <= AXIS_EPSILON ? 0 : station];
+        for (let offset = 0; offset < cap.length; offset += 3) {
+            const a = cap[offset], b = cap[offset + 1], c = cap[offset + 2];
+            triangle(at(a, 0), at(b, 0), at(c, 0));
+            triangle(at(a, segments), at(c, segments), at(b, segments));
+        }
+    }
+    return validateTriangleMesh({ positions, indices });
+};

package/dist/geometry/sampling-limits.js

@@ -0,0 +1,29 @@
+import { GeometryError } from "./errors.js";
+/** Conservative defaults; trusted callers can supply larger explicit ceilings. */
+export const defaultGeometrySamplingLimits = Object.freeze({
+    maxPathPoints: 100_000,
+    maxProfilePoints: 100_000,
+    maxSweepProfilePoints: 4_096,
+    maxCircularSegments: 512,
+});
+/** Resolves finite positive safe-integer allocation ceilings without ambient state. */
+export function resolveGeometrySamplingLimits(overrides = {}) {
+    if (typeof overrides !== "object" || overrides === null || Array.isArray(overrides))
+        throw new GeometryError("INVALID_ARGUMENT", "Sampling limits must be an object.", {
+            operation: "geometrySamplingLimits",
+        });
+    const result = { ...defaultGeometrySamplingLimits, ...overrides };
+    for (const key of Object.keys(defaultGeometrySamplingLimits)) {
+        if (!Number.isSafeInteger(result[key]) || result[key] < (key === "maxCircularSegments" ? 3 : 1))
+            throw new GeometryError("INVALID_ARGUMENT", `${key} must be a positive safe integer${key === "maxCircularSegments" ? " of at least three" : ""}.`, { operation: "geometrySamplingLimits" });
+    }
+    return Object.freeze(result);
+}
+/** @internal Checks predictable allocations before constructing arrays or evaluating callbacks. */
+export function assertSamplingCount(count, operation, maximum, message = `Sampling requires ${count} items; the configured ceiling and array capacity allow ${Math.min(maximum, 0xffff_ffff)}.`) {
+    if (!Number.isSafeInteger(count) || count < 0 || count > maximum || count > 0xffff_ffff)
+        throw new GeometryError("COMPLEXITY_LIMIT", message, {
+            operation,
+            details: { requiredCount: count, allowedCount: Math.min(maximum, 0xffff_ffff) },
+        });
+}

package/dist/geometry/stroke-path.js

@@ -0,0 +1,181 @@
+import { GeometryError } from "./errors.js";
+import { unionPolygonGeometry } from "./polygon-clipping.js";
+import { normalizeRegion2 } from "./regions.js";
+import { resolveCircularSegments } from "./resolution.js";
+import { assertSamplingCount, resolveGeometrySamplingLimits, } from "./sampling-limits.js";
+import { resolveGeometryTolerance } from "./tolerance.js";
+const DEFAULT_MITER_LIMIT = 4;
+function fail(message) {
+    throw new GeometryError("INVALID_ARGUMENT", message, { operation: "strokePathRegion" });
+}
+function ring(points) {
+    const result = points.map(([x, y]) => [x, y]);
+    const first = result[0];
+    const last = result.at(-1);
+    if (first !== undefined && last !== undefined && (first[0] !== last[0] || first[1] !== last[1])) {
+        result.push([...first]);
+    }
+    return result;
+}
+function ellipsePoints(center, radius, segments) {
+    return Array.from({ length: segments }, (_, index) => {
+        const angle = (index * Math.PI * 2) / segments;
+        return [center[0] + Math.cos(angle) * radius, center[1] + Math.sin(angle) * radius];
+    });
+}
+function circlePolygon(center, radius, segments) {
+    return [ring(ellipsePoints(center, radius, segments))];
+}
+function cornerPolygon(previous, point, next, halfWidth, join) {
+    const incomingLength = Math.hypot(point[0] - previous[0], point[1] - previous[1]);
+    const outgoingLength = Math.hypot(next[0] - point[0], next[1] - point[1]);
+    const incoming = [
+        (point[0] - previous[0]) / incomingLength,
+        (point[1] - previous[1]) / incomingLength,
+    ];
+    const outgoing = [
+        (next[0] - point[0]) / outgoingLength,
+        (next[1] - point[1]) / outgoingLength,
+    ];
+    const turn = incoming[0] * outgoing[1] - incoming[1] * outgoing[0];
+    if (Math.abs(turn) <= Number.EPSILON * 8)
+        return undefined;
+    const side = turn > 0 ? -1 : 1;
+    const before = [-incoming[1] * halfWidth * side, incoming[0] * halfWidth * side];
+    const after = [-outgoing[1] * halfWidth * side, outgoing[0] * halfWidth * side];
+    const points = [point, [point[0] + before[0], point[1] + before[1]]];
+    const denominator = 1 + incoming[0] * outgoing[0] + incoming[1] * outgoing[1];
+    // The outer offset-line intersection has radius halfWidth / cos(turnAngle / 2).
+    // Apply SVG's miter ratio before division so sharp reversals cannot create an unbounded tip.
+    if (join === "miter" && denominator >= 2 / DEFAULT_MITER_LIMIT ** 2) {
+        points.push([
+            point[0] + (before[0] + after[0]) / denominator,
+            point[1] + (before[1] + after[1]) / denominator,
+        ]);
+    }
+    points.push([point[0] + after[0], point[1] + after[1]]);
+    return [ring(points)];
+}
+/** Removes consecutive points that cannot define a visible stroke segment at model scale. */
+function deduplicatePath(path, closed, width) {
+    const scale = Math.max(width, ...path.flatMap(([x, y]) => [Math.abs(x), Math.abs(y)]));
+    const tolerance = resolveGeometryTolerance(scale).linear;
+    const points = [];
+    for (const point of path) {
+        const previous = points.at(-1);
+        if (previous === undefined ||
+            Math.hypot(point[0] - previous[0], point[1] - previous[1]) > tolerance) {
+            points.push(point);
+        }
+    }
+    if (closed && points.length > 1) {
+        const first = points[0];
+        const last = points.at(-1);
+        if (Math.hypot(first[0] - last[0], first[1] - last[1]) <= tolerance)
+            points.pop();
+    }
+    return Object.freeze(points);
+}
+/** @internal Polygon-clipping representation shared with the bounded SVG importer. */
+export function strokePathMultiPolygon(path, options, circularSegments) {
+    const closed = options.closed ?? false;
+    const cap = options.cap ?? "butt";
+    const join = options.join ?? "miter";
+    const half = options.width / 2;
+    const limits = resolveGeometrySamplingLimits(options.limits);
+    assertSamplingCount(path.length, "strokePathRegion", limits.maxPathPoints);
+    assertSamplingCount(circularSegments, "strokePathRegion", limits.maxCircularSegments);
+    const normalizedPath = deduplicatePath(path, closed, options.width);
+    if (normalizedPath.length < (closed ? 3 : 2))
+        return [];
+    const polygons = [];
+    const segmentCount = closed ? normalizedPath.length : normalizedPath.length - 1;
+    const joinCount = closed ? normalizedPath.length : Math.max(0, normalizedPath.length - 2);
+    const constructionVertices = segmentCount * 4 +
+        joinCount * (join === "round" ? circularSegments : join === "miter" ? 4 : 3) +
+        (!closed && cap === "round" ? 2 * circularSegments : 0);
+    assertSamplingCount(constructionVertices, "strokePathRegion", limits.maxProfilePoints);
+    for (let index = 0; index < segmentCount; index += 1) {
+        let start = normalizedPath[index];
+        let end = normalizedPath[(index + 1) % normalizedPath.length];
+        const length = Math.hypot(end[0] - start[0], end[1] - start[1]);
+        const tangent = [(end[0] - start[0]) / length, (end[1] - start[1]) / length];
+        if (!closed && cap === "square") {
+            if (index === 0)
+                start = [start[0] - tangent[0] * half, start[1] - tangent[1] * half];
+            if (index === segmentCount - 1) {
+                end = [end[0] + tangent[0] * half, end[1] + tangent[1] * half];
+            }
+        }
+        const normal = [-tangent[1] * half, tangent[0] * half];
+        polygons.push([
+            ring([
+                [start[0] + normal[0], start[1] + normal[1]],
+                [end[0] + normal[0], end[1] + normal[1]],
+                [end[0] - normal[0], end[1] - normal[1]],
+                [start[0] - normal[0], start[1] - normal[1]],
+            ]),
+        ]);
+    }
+    if (join === "round") {
+        const joinPoints = closed ? normalizedPath : normalizedPath.slice(1, -1);
+        polygons.push(...joinPoints.map((point) => circlePolygon(point, half, circularSegments)));
+    }
+    else {
+        const first = closed ? 0 : 1;
+        const end = closed ? normalizedPath.length : normalizedPath.length - 1;
+        for (let index = first; index < end; index += 1) {
+            const corner = cornerPolygon(normalizedPath[(index - 1 + normalizedPath.length) % normalizedPath.length], normalizedPath[index], normalizedPath[(index + 1) % normalizedPath.length], half, join);
+            if (corner !== undefined)
+                polygons.push(corner);
+        }
+    }
+    if (!closed && cap === "round") {
+        polygons.push(circlePolygon(normalizedPath[0], half, circularSegments), circlePolygon(normalizedPath.at(-1), half, circularSegments));
+    }
+    const result = unionPolygonGeometry(polygons);
+    const outputVertices = result.reduce((count, polygon) => count + polygon.reduce((total, contour) => total + Math.max(0, contour.length - 1), 0), 0);
+    assertSamplingCount(outputVertices, "strokePathRegion", limits.maxProfilePoints);
+    return result;
+}
+function regionFromMultiPolygon(value) {
+    return normalizeRegion2(value.map((polygon) => ({
+        outer: polygon[0].slice(0, -1).map(([x, y]) => [x, y]),
+        holes: polygon.slice(1).map((hole) => hole.slice(0, -1).map(([x, y]) => [x, y])),
+    })));
+}
+/**
+ * Converts a sampled millimetre path into the filled region covered by a centered stroke.
+ *
+ * Closed paths omit a duplicated seam point. Zero-length sampled segments are ignored, while the
+ * effective path must still contain visible length. Round caps and joins use deterministic physical
+ * resolution. Bevels fill the outer corner triangle; miters extend the outer edges to their
+ * intersection, falling back to bevels above SVG's default miter limit of 4.
+ */
+export function strokePathRegion(path, options) {
+    const closed = options.closed ?? false;
+    if (!Number.isFinite(options.width) || options.width <= 0) {
+        return fail("Stroke width must be finite and greater than zero.");
+    }
+    if (path.length < (closed ? 3 : 2)) {
+        return fail(`${closed ? "Closed" : "Open"} strokes need more sampled path points.`);
+    }
+    if (!path.every((point) => Number.isFinite(point[0]) && Number.isFinite(point[1]))) {
+        return fail("Stroke path coordinates must be finite.");
+    }
+    const cap = options.cap ?? "butt";
+    const join = options.join ?? "miter";
+    if (!["butt", "round", "square"].includes(cap)) {
+        return fail("Stroke cap must be butt, round, or square.");
+    }
+    if (!["bevel", "miter", "round"].includes(join)) {
+        return fail("Stroke join must be bevel, miter, or round.");
+    }
+    const circularSegments = cap === "round" || join === "round"
+        ? resolveCircularSegments(options.width / 2, options.resolution, options.limits)
+        : 3;
+    const result = strokePathMultiPolygon(path, { ...options, cap, closed, join }, circularSegments);
+    if (result.length === 0)
+        return fail("The sampled stroke path has no visible length.");
+    return regionFromMultiPolygon(result);
+}

package/dist/geometry/svg/errors.js

@@ -0,0 +1,23 @@
+import { GeometryError } from "../errors.js";
+export function invalid(operation, message) {
+    throw new GeometryError("INVALID_ARGUMENT", message, { operation });
+}
+export function unsupported(operation, message) {
+    throw new GeometryError("UNSUPPORTED_RUNTIME", message, { operation });
+}
+export function emptyGeometry(operation, message) {
+    throw new GeometryError("DEGENERATE_GEOMETRY", message, { operation });
+}
+export function complexity(operation, message, details) {
+    throw new GeometryError("COMPLEXITY_LIMIT", message, {
+        operation,
+        ...(details === undefined ? {} : { details }),
+    });
+}
+export function rethrowAsInvalid(operation, error) {
+    if (error instanceof GeometryError) {
+        throw error;
+    }
+    const detail = error instanceof Error ? error.message : String(error);
+    invalid(operation, `Invalid SVG input: ${detail}`);
+}