@metamesh/modeling 0.0.0-stage → 0.6.0

package/dist/geometry/paths/planar.js

@@ -0,0 +1,135 @@
+import { GeometryError } from "../errors.js";
+import { length3, normalize3, subtract3 } from "../math/vector3.js";
+import { assertSamplingCount, resolveGeometrySamplingLimits, } from "../sampling-limits.js";
+const requireFinitePathValues = (values, operation) => {
+    if (!values.every(Number.isFinite)) {
+        throw new GeometryError("NON_FINITE_VALUE", "Path dimensions and coordinates must be finite.", {
+            operation,
+        });
+    }
+};
+const segmentLengths = (path, closed) => path.map((point, index) => {
+    if (!closed && index === path.length - 1)
+        return 0;
+    const next = path[(index + 1) % path.length];
+    const delta = subtract3(next, point);
+    return Math.hypot(delta[0], delta[1], delta[2]);
+});
+/**
+ * Places an exact item count at equal arc-length intervals along a sampled path.
+ *
+ * Coordinates are unit-agnostic. Closed paths must omit their duplicated seam;
+ * open paths include both endpoints when `count` is greater than one.
+ * Coordinates and total length must be finite. Input points and output placements are each
+ * limited by maxPathPoints (default 100000); exact counts exceeding that ceiling reject before length calculation.
+ */
+export const distributeAlongPath = (path, count, closed, limits = {}) => {
+    if (path.length < (closed ? 3 : 2)) {
+        throw new Error(`${closed ? "Closed" : "Open"} distribution paths need more points.`);
+    }
+    if (!Number.isInteger(count) || count < 1) {
+        throw new Error("Path distribution count must be a positive integer.");
+    }
+    const maximum = resolveGeometrySamplingLimits(limits).maxPathPoints;
+    assertSamplingCount(count, "distributeAlongPath", maximum);
+    assertSamplingCount(path.length, "distributeAlongPath", maximum);
+    for (const point of path)
+        requireFinitePathValues(point, "distributeAlongPath");
+    const lengths = segmentLengths(path, closed);
+    const total = lengths.reduce((sum, length) => sum + length, 0);
+    requireFinitePathValues([total], "distributeAlongPath");
+    if (!(total > 0))
+        throw new Error("Cannot distribute along a zero-length path.");
+    const denominator = closed ? count : Math.max(1, count - 1);
+    let traversed = 0;
+    let segment = 0;
+    return Array.from({ length: count }, (_, itemIndex) => {
+        const target = total * (itemIndex / denominator);
+        for (; segment < lengths.length; segment += 1) {
+            const length = lengths[segment];
+            if (length === 0)
+                continue;
+            if (target <= traversed + length || segment === lengths.length - 1) {
+                const start = path[segment];
+                const end = path[(segment + 1) % path.length];
+                const amount = Math.min(1, Math.max(0, (target - traversed) / length));
+                return {
+                    position: [
+                        start[0] + (end[0] - start[0]) * amount,
+                        start[1] + (end[1] - start[1]) * amount,
+                        start[2] + (end[2] - start[2]) * amount,
+                    ],
+                    tangent: normalize3(subtract3(end, start)),
+                };
+            }
+            traversed += length;
+        }
+        throw new Error("Path distribution invariant failed.");
+    });
+};
+/**
+ * Replaces each vertex of a non-duplicated closed polyline with a sampled
+ * quadratic corner in the same coordinate system as the input.
+ *
+ * `radius` is the desired tangent distance for a right angle and is capped to
+ * 45% of adjacent segment lengths to prevent neighboring corners from crossing.
+ * The returned path does not duplicate its closing point.
+ * Coordinates and radius must be finite; input and output are each limited by maxPathPoints (default 100000).
+ */
+export const roundClosedPolylinePath = (points, radius, segmentsPerCorner, limits = {}) => {
+    if (points.length < 3)
+        throw new Error("Closed polylines need at least three points.");
+    const maximum = resolveGeometrySamplingLimits(limits).maxPathPoints;
+    assertSamplingCount(points.length, "roundClosedPolylinePath", maximum);
+    requireFinitePathValues([radius], "roundClosedPolylinePath");
+    if (!(radius > 0))
+        throw new Error("Corner radius must be positive.");
+    if (!Number.isInteger(segmentsPerCorner) || segmentsPerCorner < 1) {
+        throw new Error("Rounded corners need at least one segment.");
+    }
+    assertSamplingCount(points.length * (segmentsPerCorner + 1), "roundClosedPolylinePath", maximum);
+    for (const point of points)
+        requireFinitePathValues(point, "roundClosedPolylinePath");
+    return points.flatMap((point, index) => {
+        const previous = points[(index - 1 + points.length) % points.length];
+        const next = points[(index + 1) % points.length];
+        const incomingDelta = subtract3(point, previous);
+        const outgoingDelta = subtract3(next, point);
+        const incomingLength = length3(incomingDelta);
+        const outgoingLength = length3(outgoingDelta);
+        requireFinitePathValues([incomingLength, outgoingLength], "roundClosedPolylinePath");
+        if (!(incomingLength > 0) || !(outgoingLength > 0)) {
+            throw new Error("Closed polylines cannot contain duplicate adjacent points.");
+        }
+        const incoming = normalize3(incomingDelta);
+        const outgoing = normalize3(outgoingDelta);
+        const cornerCosine = Math.max(-1, Math.min(1, -(incoming[0] * outgoing[0] + incoming[1] * outgoing[1] + incoming[2] * outgoing[2])));
+        const cornerAngle = Math.acos(cornerCosine);
+        if (cornerAngle < 1e-6 || Math.abs(Math.PI - cornerAngle) < 1e-6) {
+            throw new Error("Rounded polyline corners must change direction.");
+        }
+        const tangentDistance = Math.min(radius / Math.tan(cornerAngle / 2), incomingLength * 0.45, outgoingLength * 0.45);
+        const entry = [
+            point[0] - incoming[0] * tangentDistance,
+            point[1] - incoming[1] * tangentDistance,
+            point[2] - incoming[2] * tangentDistance,
+        ];
+        const exit = [
+            point[0] + outgoing[0] * tangentDistance,
+            point[1] + outgoing[1] * tangentDistance,
+            point[2] + outgoing[2] * tangentDistance,
+        ];
+        requireFinitePathValues([...entry, ...exit], "roundClosedPolylinePath");
+        return Array.from({ length: segmentsPerCorner + 1 }, (_, step) => {
+            const t = step / segmentsPerCorner;
+            const inverse = 1 - t;
+            const sample = [
+                inverse * inverse * entry[0] + 2 * inverse * t * point[0] + t * t * exit[0],
+                inverse * inverse * entry[1] + 2 * inverse * t * point[1] + t * t * exit[1],
+                inverse * inverse * entry[2] + 2 * inverse * t * point[2] + t * t * exit[2],
+            ];
+            requireFinitePathValues(sample, "roundClosedPolylinePath");
+            return sample;
+        });
+    });
+};

package/dist/geometry/paths/resampling.js

@@ -0,0 +1,124 @@
+import { curveFailure, normalizeCurveDirection, validateCurvePoint3, } from "../curves/evaluation.js";
+import { assertSampleVertexCount, createPlanarSampleWriter, createSpatialSampleWriter, resolveSamplingBudget, } from "../curves/sampling.js";
+import { resolveGeometryResolution } from "../resolution.js";
+import { assertSamplingCount, resolveGeometrySamplingLimits } from "../sampling-limits.js";
+const z = (point) => point[2] ?? 0;
+const distance = (a, b) => {
+    const value = Math.hypot(b[0] - a[0], b[1] - a[1], z(b) - z(a));
+    if (!Number.isFinite(value))
+        curveFailure("NON_FINITE_VALUE", "Curve extent exceeds finite arithmetic.");
+    return value;
+};
+function resamplePolyline(path, dimensions, options, createWriter) {
+    const maximum = resolveSamplingBudget(options);
+    if (options.closed !== undefined && typeof options.closed !== "boolean")
+        curveFailure("INVALID_ARGUMENT", "closed must be a boolean.");
+    const closed = options.closed ?? false;
+    if (path.length < (closed ? 3 : 2))
+        curveFailure("INVALID_ARGUMENT", `A ${closed ? "closed" : "open"} polyline needs at least ${closed ? "three" : "two"} points.`);
+    assertSamplingCount(path.length, "sampleCurve", resolveGeometrySamplingLimits(options.limits).maxPathPoints, "Polyline input exceeds the configured path point ceiling.");
+    if (options.segments !== undefined)
+        assertSampleVertexCount(options.segments + (closed ? 0 : 1), maximum);
+    // Keep caller point references only within this synchronous operation. Unlike 2D promotion,
+    // normalization needs no extra 3D vector for every input point.
+    const points = [];
+    const lengths = [];
+    let total = 0;
+    for (const input of path) {
+        if (input.length !== dimensions)
+            curveFailure(dimensions === 2 ? "INVALID_ARGUMENT" : "NON_FINITE_VALUE", dimensions === 2
+                ? "Planar curve points must have two coordinates."
+                : "Curve coordinates must be finite three-dimensional points.");
+        if (!input.every(Number.isFinite))
+            curveFailure("NON_FINITE_VALUE", "Curve coordinates must be finite three-dimensional points.");
+        const previous = points.at(-1);
+        const length = previous === undefined ? 0 : distance(previous, input);
+        if (previous !== undefined && length === 0)
+            continue;
+        total += length;
+        if (!Number.isFinite(total))
+            curveFailure("NON_FINITE_VALUE", "Polyline length exceeds finite arithmetic.");
+        points.push(input);
+        lengths.push(total);
+    }
+    if (closed) {
+        if (points.length > 1 && distance(points[0], points.at(-1)) === 0) {
+            points.pop();
+            lengths.pop();
+            total = lengths.at(-1) ?? 0;
+        }
+        if (points.length < 3)
+            curveFailure("DEGENERATE_GEOMETRY", "A closed polyline needs at least three distinct consecutive points.");
+        total += distance(points.at(-1), points[0]);
+        if (!Number.isFinite(total))
+            curveFailure("NON_FINITE_VALUE", "Polyline length exceeds finite arithmetic.");
+        points.push(points[0]);
+        lengths.push(total);
+    }
+    if (total === 0)
+        curveFailure("DEGENERATE_GEOMETRY", "A zero-length polyline cannot be resampled.");
+    const policy = options.segments === undefined
+        ? resolveGeometryResolution(options.resolution, options.limits)
+        : undefined;
+    const segments = options.segments ??
+        (policy?.maxSegmentLength === undefined
+            ? points.length - 1
+            : Math.max(closed ? 3 : 1, Math.ceil(total / policy.maxSegmentLength)));
+    if (closed && segments < 3)
+        curveFailure("INVALID_ARGUMENT", "Closed polyline sampling needs at least three segments.");
+    const vertexCount = segments + (closed ? 0 : 1);
+    assertSampleVertexCount(vertexCount, maximum);
+    const writer = createWriter();
+    const point = [0, 0, 0], tangent = [0, 0, 0];
+    let source = 1;
+    for (let i = 0; i < vertexCount; i++) {
+        const at = total * (i / segments);
+        // At an exact source vertex choose its outgoing edge; the last open endpoint uses its incoming edge.
+        while (source < points.length - 1 && lengths[source] <= at)
+            source++;
+        const a = points[source - 1], b = points[source];
+        if (i === 0 || i === segments) {
+            const endpoint = i === 0 ? points[0] : points.at(-1);
+            point[0] = endpoint[0];
+            point[1] = endpoint[1];
+            point[2] = z(endpoint);
+        }
+        else {
+            const t = (at - lengths[source - 1]) / (lengths[source] - lengths[source - 1]);
+            // Preserve the original direct interpolation order used by existing mechanical paths.
+            point[0] = a[0] + (b[0] - a[0]) * t;
+            point[1] = a[1] + (b[1] - a[1]) * t;
+            point[2] = z(a) + (z(b) - z(a)) * t;
+        }
+        validateCurvePoint3(point);
+        tangent[0] = b[0] - a[0];
+        tangent[1] = b[1] - a[1];
+        tangent[2] = z(b) - z(a);
+        normalizeCurveDirection(tangent, tangent);
+        writer.append(point, tangent);
+    }
+    return writer.finish();
+}
+/** Resamples a spatial polyline at equal arc lengths with directed outgoing tangents.
+ * @remarks Open paths retain both endpoints; closed paths include the closing edge and omit the
+ * repeated seam. Repeated adjacent inputs and explicit closing duplicates are removed. Physical
+ * maxSegmentLength bounds arc-length intervals; exact counts override that policy. Output edges
+ * may bridge original corners. Sampling never silently lowers the requested detail to fit its budget.
+ * @example
+ * ```ts
+ * const path = resamplePolyline3([[0,0,0],[10,0,0],[10,10,0]], {segments: 8});
+ * ```
+ */
+export function resamplePolyline3(path, options = {}) {
+    return resamplePolyline(path, 3, options, createSpatialSampleWriter);
+}
+/** Resamples a planar polyline with the same point, tangent, seam and budget guarantees as 3D.
+ * @remarks Only final 2D output vectors are copied and frozen. No immutable 3D intermediate is built.
+ * @example
+ * ```ts
+ * const loop = resamplePolyline2([[0,0],[5,0],[5,5],[0,5]], {closed: true, segments: 20});
+ * ```
+ */
+export function resamplePolyline2(path, options = {}) {
+    return resamplePolyline(path, 2, options, createPlanarSampleWriter);
+}

package/dist/geometry/polygon-clipping.js

@@ -0,0 +1,52 @@
+import * as clippingModule from "polygon-clipping";
+const moduleWithDefault = clippingModule;
+/** @internal Normalizes polygon-clipping's CommonJS and bundled ESM module shapes. */
+export const polygonClipping = moduleWithDefault.default ?? clippingModule;
+const CLIPPING_COORDINATE_GRID = 1e9;
+const snapCoordinate = (value) => Math.round(value * CLIPPING_COORDINATE_GRID) / CLIPPING_COORDINATE_GRID;
+/** Canonicalizes shared endpoints below model tolerance before they enter the sweep-line kernel. */
+function snapGeometry(geometry) {
+    if (geometry.length === 0)
+        return [];
+    const multiPolygon = typeof geometry[0]?.[0]?.[0] === "number"
+        ? [geometry]
+        : geometry;
+    return multiPolygon.map((polygon) => polygon.map((ring) => ring.map(([x, y]) => [snapCoordinate(x), snapCoordinate(y)])));
+}
+function normalizeGeometry(geometry) {
+    return snapGeometry(polygonClipping.union(snapGeometry(geometry)));
+}
+/** Reduces associative clipping operations as a tree to bound each sweep-line workload. */
+function reducePolygonGeometry(geometries, combine) {
+    let level = geometries
+        .filter((geometry) => geometry.length > 0)
+        .map(normalizeGeometry);
+    if (level.length === 0)
+        return [];
+    while (level.length > 1) {
+        const next = [];
+        for (let index = 0; index < level.length; index += 2) {
+            const left = level[index];
+            const right = level[index + 1];
+            next.push(right === undefined
+                ? normalizeGeometry(left)
+                : snapGeometry(combine(snapGeometry(left), snapGeometry(right))));
+        }
+        level = next;
+    }
+    return normalizeGeometry(level[0]);
+}
+/**
+ * Unions polygon-clipping inputs through a balanced reduction.
+ *
+ * Incrementally simplifying overlapping inputs prevents the sweep-line implementation from seeing
+ * thousands of redundant segment intersections in one operation. This is especially important for
+ * sampled strokes, where every segment rectangle and round join overlaps its neighbors.
+ */
+export function unionPolygonGeometry(geometries) {
+    return reducePolygonGeometry(geometries, (left, right) => polygonClipping.union(left, right));
+}
+/** @internal Balanced symmetric difference keeps compound even-odd SVG fills bounded. */
+export function xorPolygonGeometry(geometries) {
+    return reducePolygonGeometry(geometries, (left, right) => polygonClipping.xor(left, right));
+}

package/dist/geometry/primitive-options.js

@@ -0,0 +1 @@
+export {};

package/dist/geometry/primitive-resolution.js

@@ -0,0 +1,17 @@
+import { GeometryError } from "./errors.js";
+import { resolveCircularSegments } from "./resolution.js";
+import { assertSamplingCount, resolveGeometrySamplingLimits } from "./sampling-limits.js";
+/**
+ * Resolves a circular primitive's exact or adaptive segment count.
+ *
+ * @internal Exact counts override physical sampling, while explicit allocation ceilings still apply.
+ */
+export function resolveCircularPrimitiveSegments(radius, options, operation) {
+    if (options.segments === undefined) {
+        return resolveCircularSegments(radius, options.resolution, options.limits);
+    }
+    if (!Number.isSafeInteger(options.segments) || options.segments < 3)
+        throw new GeometryError("INVALID_ARGUMENT", "segments must be a safe integer of at least three.", { operation, details: { value: options.segments } });
+    assertSamplingCount(options.segments, operation, resolveGeometrySamplingLimits(options.limits).maxCircularSegments);
+    return options.segments;
+}

package/dist/geometry/primitive-resolvers.js

@@ -0,0 +1,235 @@
+import { edgeTreatmentPointCount, edgeTreatmentSetbacks, sampleEdgeTreatment, } from "./edge-finishing.js";
+import { GeometryError } from "./errors.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. */
+export const boxEdges = [
+    "top-front",
+    "top-back",
+    "top-left",
+    "top-right",
+    "bottom-front",
+    "bottom-back",
+    "bottom-left",
+    "bottom-right",
+    "front-left",
+    "front-right",
+    "back-left",
+    "back-right",
+];
+/** @internal Axis and outward sign of one nominal box face. */
+export const boxFaceAxes = {
+    top: [2, 1],
+    bottom: [2, -1],
+    front: [1, 1],
+    back: [1, -1],
+    left: [0, -1],
+    right: [0, 1],
+};
+const expandBoxEdges = (selection) => {
+    if (selection === "top" || selection === "bottom")
+        return boxEdges.filter((edge) => edge.startsWith(selection + "-"));
+    if (selection === "vertical")
+        return boxEdges.slice(8);
+    if (boxEdges.includes(selection))
+        return [selection];
+    throw new GeometryError("INVALID_ARGUMENT", "Unsupported box edge selection.", {
+        operation: "box",
+    });
+};
+/** @internal Conservative allocation/work bounds include intersections of independently sampled masks. */
+function selectedBoxCounts(cuts) {
+    let vertices = 8 + cuts.reduce((sum, cut) => sum + 2 * (cut.count + 1), 0);
+    const axes = (edge) => edge.split("-").map((face) => boxFaceAxes[face]);
+    for (let index = 0; index < cuts.length; index++)
+        for (let other = index + 1; other < cuts.length; other++) {
+            const a = axes(cuts[index].edge), b = axes(cuts[other].edge);
+            const sameAxis = a.every(([axis]) => b.some(([other]) => other === axis));
+            const conflict = a.some(([axis, sign]) => b.some(([other, otherSign]) => axis === other && sign !== otherSign));
+            if (!sameAxis && !conflict)
+                vertices += 4 * cuts[index].count * cuts[other].count;
+        }
+    return { vertices, triangles: 2 * vertices - 4 };
+}
+/** @internal Shared option-shape validation for primitive adapters. */
+export function assertPrimitiveOptions(value, operation) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new GeometryError("INVALID_ARGUMENT", "options must be an object.", { operation });
+    }
+}
+/** @internal Shared finite, positive dimension validation. */
+export function assertPositivePrimitive(value, name, operation) {
+    if (!Number.isFinite(value) || value <= 0) {
+        throw new GeometryError("INVALID_ARGUMENT", `${name} must be finite and positive.`, {
+            operation,
+            details: { name, value },
+        });
+    }
+}
+/** @internal Resolves one positive scalar radial dimension before sampling or allocation. */
+export function resolvePrimitiveRadius(options, operation) {
+    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;
+    assertPositivePrimitive(radius, "radius", operation);
+    return radius;
+}
+/** @internal Resolved pure dimensions and treatment for a box, before kernel allocation. */
+export function resolveBoxPrimitive(options) {
+    const operation = "box";
+    assertPrimitiveOptions(options, operation);
+    if (options.center !== undefined && typeof options.center !== "boolean") {
+        throw new GeometryError("INVALID_ARGUMENT", "center must be boolean when supplied.", {
+            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;
+    for (let axis = 0; axis < 3; axis += 1) {
+        assertPositivePrimitive(dimensions[axis], `size[${axis}]`, operation);
+    }
+    const base = { center: options.center ?? true, dimensions };
+    if (options.treatment === undefined)
+        return base;
+    assertPrimitiveOptions(options.treatment, operation);
+    const treatment = "kind" in options.treatment ? options.treatment : undefined;
+    if (treatment === undefined ||
+        treatment.kind === "smooth" ||
+        treatment.kind === "profile" ||
+        (treatment.kind === "chamfer" && typeof treatment.distance !== "number")) {
+        const selections = treatment === undefined
+            ? Object.entries(options.treatment)
+            : boxEdges.map((edge) => [edge, treatment]);
+        if (selections.length === 0 || selections.length > 12)
+            throw new GeometryError("INVALID_ARGUMENT", "Box treatments require a nonempty map of nominal edges or groups.", { operation });
+        const cuts = [];
+        for (const [selection, selected] of selections) {
+            const setbacks = edgeTreatmentSetbacks(selected, operation, Math.PI / 2, options.limits);
+            if (setbacks.some((value) => value <= 0))
+                throw new GeometryError("INVALID_ARGUMENT", "Box treatments require positive setbacks.", {
+                    operation,
+                });
+            for (const edge of expandBoxEdges(selection)) {
+                if (cuts.some((cut) => cut.edge === edge))
+                    throw new GeometryError("INVALID_ARGUMENT", "Box edge selections must not overlap.", {
+                        operation,
+                    });
+                const [first, second] = edge.split("-"), a = boxFaceAxes[first][0], b = boxFaceAxes[second][0];
+                if (setbacks[0] >= dimensions[b] || setbacks[1] >= dimensions[a])
+                    throw new GeometryError("INVALID_ARGUMENT", "Box edge setbacks must fit their adjoining dimensions.", { operation });
+                cuts.push({
+                    edge,
+                    treatment: selected,
+                    setbacks,
+                    count: edgeTreatmentPointCount(selected, operation, options.limits === undefined ? {} : { limits: options.limits }),
+                });
+            }
+        }
+        for (const cut of cuts) {
+            const [first, second] = cut.edge.split("-"), [a, sa] = boxFaceAxes[first], [b, sb] = boxFaceAxes[second];
+            for (const other of cuts) {
+                if (other === cut)
+                    continue;
+                const [of, os] = other.edge.split("-"), [oa, osa] = boxFaceAxes[of], [ob, osb] = boxFaceAxes[os];
+                if (a === oa &&
+                    b === ob &&
+                    ((sa === osa && sb !== osb && cut.setbacks[0] + other.setbacks[0] >= dimensions[b]) ||
+                        (sb === osb && sa !== osa && cut.setbacks[1] + other.setbacks[1] >= dimensions[a])))
+                    throw new GeometryError("INVALID_ARGUMENT", "Opposing box edge setbacks must leave positive flat space.", { operation });
+            }
+        }
+        cuts.sort((a, b) => boxEdges.indexOf(a.edge) - boxEdges.indexOf(b.edge));
+        const counts = selectedBoxCounts(cuts);
+        assertMeshAllocationWithinLimits(counts.vertices, counts.triangles, 12 * (counts.vertices + counts.triangles), operation, resolveModelingLimits(options.limits));
+        const profiles = new Map();
+        return {
+            ...base,
+            treatment: {
+                kind: "selected",
+                cuts: cuts.map((cut) => {
+                    let profile = profiles.get(cut.treatment);
+                    if (!profile) {
+                        profile = sampleEdgeTreatment(cut.treatment, operation, options.limits === undefined ? {} : { limits: options.limits });
+                        profiles.set(cut.treatment, profile);
+                    }
+                    return { edge: cut.edge, profile };
+                }),
+            },
+        };
+    }
+    const setbacks = edgeTreatmentSetbacks(treatment, operation, Math.PI / 2, options.limits);
+    if (setbacks.some((value) => value <= 0))
+        throw new GeometryError("INVALID_ARGUMENT", "Box treatments require positive setbacks.", {
+            operation,
+        });
+    const distance = setbacks[0];
+    assertPositivePrimitive(distance, "edge treatment size", operation);
+    const inner = [
+        dimensions[0] - 2 * distance,
+        dimensions[1] - 2 * distance,
+        dimensions[2] - 2 * distance,
+    ];
+    if (inner.some((value) => !Number.isFinite(value) || value <= 0)) {
+        throw new GeometryError("INVALID_ARGUMENT", "The edge treatment must be less than half every box dimension.", { operation });
+    }
+    return treatment.kind === "chamfer"
+        ? { ...base, treatment: { kind: "chamfer", inner } }
+        : {
+            ...base,
+            treatment: {
+                kind: "round",
+                inner,
+                radius: distance,
+                segments: resolveCircularPrimitiveSegments(distance, treatment, operation),
+            },
+        };
+}
+/** @internal Validates tube dimensions shared by both adapters before allocating cylinders. */
+export function resolveTubePrimitive(options) {
+    assertPrimitiveOptions(options, "tube");
+    assertPositivePrimitive(options.innerRadius, "innerRadius", "tube");
+    assertPositivePrimitive(options.outerRadius, "outerRadius", "tube");
+    assertPositivePrimitive(options.height, "height", "tube");
+    if (!(options.outerRadius > options.innerRadius)) {
+        throw new GeometryError("INVALID_ARGUMENT", "outerRadius must be larger than innerRadius.", {
+            operation: "tube",
+        });
+    }
+}
+/** @internal Resolves sphere sampling shared by compiled and authored adapters. */
+export function resolveSpherePrimitive(options) {
+    const radius = resolvePrimitiveRadius(options, "sphere");
+    return { radius, segments: resolveCircularPrimitiveSegments(radius, options, "sphere") };
+}
+/** @internal Resolves torus profile and sweep sampling before allocating kernel geometry. */
+export function resolveTorusPrimitive(options) {
+    assertPrimitiveOptions(options, "torus");
+    assertPositivePrimitive(options.majorRadius, "majorRadius", "torus");
+    assertPositivePrimitive(options.minorRadius, "minorRadius", "torus");
+    if (!(options.majorRadius > options.minorRadius)) {
+        throw new GeometryError("INVALID_ARGUMENT", "majorRadius must be larger than minorRadius.", {
+            operation: "torus",
+        });
+    }
+    return {
+        profileSegments: resolveCircularPrimitiveSegments(options.minorRadius, {
+            ...(options.minorSegments === undefined ? {} : { segments: options.minorSegments }),
+            ...(options.resolution === undefined ? {} : { resolution: options.resolution }),
+            ...(options.limits === undefined ? {} : { limits: options.limits }),
+        }, "torus"),
+        sweepSegments: resolveCircularPrimitiveSegments(options.majorRadius + options.minorRadius, {
+            ...(options.majorSegments === undefined ? {} : { segments: options.majorSegments }),
+            ...(options.resolution === undefined ? {} : { resolution: options.resolution }),
+            ...(options.limits === undefined ? {} : { limits: options.limits }),
+        }, "torus"),
+    };
+}