@metamesh/modeling 0.0.0-stage → 0.6.0

package/dist/engine/transform-operations.js

@@ -0,0 +1,225 @@
+import { attachTransform } from "../geometry/anchors.js";
+import { assertPrimitiveOptions } from "../geometry/primitive-resolvers.js";
+import { eulerTransform3, scaleTransform3, translationTransform3 } from "../geometry/transform3.js";
+import * as kernel from "./native/index.js";
+import { transformPrimitiveSectionProfile } from "./primitive-profiles.js";
+/** Internal host-bound transform operations. */
+export function createTransformOperations(environment) {
+    const { scope, throwGeometryError, resolveHandle, nativeSolid, wrapSolid, ownSection, validateFiniteNumber, validateCoordinates, } = environment;
+    const preserveProfile = (source, result, matrix) => {
+        environment.preserveAnchors(source, result, [
+            matrix[0],
+            matrix[1],
+            0,
+            matrix[2],
+            matrix[3],
+            matrix[4],
+            0,
+            matrix[5],
+            0,
+            0,
+            1,
+            0,
+            0,
+            0,
+            0,
+            1,
+        ]);
+        const profile = environment.primitiveProfileFor(source);
+        return profile === undefined
+            ? result
+            : environment.rememberPrimitiveProfile(result, transformPrimitiveSectionProfile(profile, matrix));
+    };
+    const translate = ((value, offset) => {
+        const native = resolveHandle(value);
+        validateCoordinates(offset, native.kind === "section" ? 2 : 3, "translate");
+        return native.kind === "section"
+            ? preserveProfile(value, ownSection(native.value.translate(offset)), [
+                1,
+                0,
+                offset[0],
+                0,
+                1,
+                offset[1],
+                0,
+                0,
+                1,
+            ])
+            : environment.preserveAnchors(value, wrapSolid(kernel.translate(scope, native.value, offset)), translationTransform3(offset));
+    });
+    const rotate = ((value, degrees) => {
+        const native = resolveHandle(value);
+        if (native.kind === "section") {
+            if (typeof degrees !== "number")
+                return throwGeometryError("INVALID_ARGUMENT", "rotate", "Section rotation requires a scalar angle.");
+            const angle = (validateFiniteNumber(degrees, "rotate") * Math.PI) / 180;
+            const c = Math.cos(angle), s = Math.sin(angle);
+            return preserveProfile(value, ownSection(native.value.rotate(degrees)), [
+                c,
+                -s,
+                0,
+                s,
+                c,
+                0,
+                0,
+                0,
+                1,
+            ]);
+        }
+        if (typeof degrees === "number")
+            return throwGeometryError("INVALID_ARGUMENT", "rotate", "Solid rotation requires XYZ angles.");
+        validateCoordinates(degrees, 3, "rotate");
+        return environment.preserveAnchors(value, wrapSolid(kernel.rotate(scope, native.value, degrees)), eulerTransform3(degrees));
+    });
+    const scale = ((value, factors) => {
+        const native = resolveHandle(value);
+        const values = typeof factors === "number" ? [factors] : factors;
+        if (typeof factors !== "number")
+            validateCoordinates(factors, native.kind === "section" ? 2 : 3, "scale");
+        if (!values.every(Number.isFinite) || values.some((factor) => factor === 0))
+            throwGeometryError("SINGULAR_TRANSFORM", "scale", "Scale factors must be finite and nonzero.");
+        return native.kind === "section"
+            ? preserveProfile(value, ownSection(native.value.scale(factors)), [
+                typeof factors === "number" ? factors : factors[0],
+                0,
+                0,
+                0,
+                typeof factors === "number" ? factors : factors[1],
+                0,
+                0,
+                0,
+                1,
+            ])
+            : environment.preserveAnchors(value, wrapSolid(kernel.scale(scope, native.value, factors)), scaleTransform3(typeof factors === "number" ? [factors, factors, factors] : factors));
+    });
+    const mirror = ((value, normal) => {
+        const native = resolveHandle(value);
+        validateCoordinates(normal, native.kind === "section" ? 2 : 3, "mirror");
+        if (normal.every((coordinate) => coordinate === 0))
+            throwGeometryError("INVALID_ARGUMENT", "mirror", "Mirror normal must be nonzero.");
+        return native.kind === "section"
+            ? (() => {
+                const maximum = Math.max(Math.abs(normal[0]), Math.abs(normal[1]));
+                const nx = normal[0] / maximum, ny = normal[1] / maximum;
+                const length = Math.hypot(nx, ny), x = nx / length, y = ny / length;
+                return preserveProfile(value, ownSection(native.value.mirror([x, y])), [
+                    1 - 2 * x * x,
+                    -2 * x * y,
+                    0,
+                    -2 * x * y,
+                    1 - 2 * y * y,
+                    0,
+                    0,
+                    0,
+                    1,
+                ]);
+            })()
+            : (() => {
+                const maximum = Math.max(...normal.map(Math.abs));
+                const scaled = normal.map((coordinate) => coordinate / maximum);
+                const length = Math.hypot(...scaled);
+                const [x, y, z] = scaled.map((coordinate) => coordinate / length);
+                return environment.preserveAnchors(value, wrapSolid(kernel.mirror(scope, native.value, normal)), [
+                    1 - 2 * x * x,
+                    -2 * x * y,
+                    -2 * x * z,
+                    0,
+                    -2 * x * y,
+                    1 - 2 * y * y,
+                    -2 * y * z,
+                    0,
+                    -2 * x * z,
+                    -2 * y * z,
+                    1 - 2 * z * z,
+                    0,
+                    0,
+                    0,
+                    0,
+                    1,
+                ]);
+            })();
+    });
+    const transform = ((value, matrix) => {
+        const native = resolveHandle(value);
+        if (native.kind === "solid") {
+            validateCoordinates(matrix, 16, "transform");
+            return environment.preserveAnchors(value, wrapSolid(kernel.transform(scope, native.value, matrix)), matrix);
+        }
+        validateCoordinates(matrix, 9, "transform");
+        const m = matrix;
+        if (m[6] !== 0 || m[7] !== 0 || m[8] !== 1)
+            throwGeometryError("INVALID_ARGUMENT", "transform", "Section transform must be affine.");
+        if (m[0] * m[4] - m[1] * m[3] === 0)
+            throwGeometryError("SINGULAR_TRANSFORM", "transform", "Section transform must be nonsingular.");
+        const columnMajor = [m[0], m[3], m[6], m[1], m[4], m[7], m[2], m[5], m[8]];
+        return preserveProfile(value, ownSection(native.value.transform(columnMajor)), m);
+    });
+    const placementMatrix = (placement, shape) => {
+        if (placement === undefined)
+            return undefined;
+        if (typeof placement !== "object" || placement === null || Array.isArray(placement))
+            throwGeometryError("INVALID_ARGUMENT", "placement", "placement must be an explicit source/target anchor object.");
+        const source = typeof placement.source === "string"
+            ? shape === undefined
+                ? throwGeometryError("INVALID_ARGUMENT", "placement", "Named source anchors require a constructed shape.")
+                : environment.anchor(shape, placement.source)
+            : placement.source;
+        for (const anchor of [source, placement.target]) {
+            if (typeof anchor !== "object" || anchor === null)
+                throwGeometryError("INVALID_ARGUMENT", "placement", "Placement requires explicit source and target anchors.");
+            validateCoordinates(anchor.position, 3, "placement");
+            validateCoordinates(anchor.direction, 3, "placement");
+            validateCoordinates(anchor.up, 3, "placement");
+        }
+        const spinDegrees = validateFiniteNumber(placement.spinDegrees ?? 0, "placement");
+        return attachTransform(source, placement.target, {
+            ...(placement.alignment === undefined ? {} : { alignment: placement.alignment }),
+            ...(placement.gap === undefined ? {} : { gap: placement.gap }),
+            ...(placement.tolerance === undefined ? {} : { tolerance: placement.tolerance }),
+            spinRadians: (spinDegrees * Math.PI) / 180,
+        });
+    };
+    const placedSolid = (value, create, anchors) => {
+        assertPrimitiveOptions(value, "primitive");
+        const solid = wrapSolid(create());
+        if (anchors !== undefined)
+            environment.rememberAnchors(solid, anchors());
+        const matrix = placementMatrix(value.placement, solid);
+        return matrix === undefined ? solid : transform(solid, matrix);
+    };
+    const placedSection = (value, create) => {
+        assertPrimitiveOptions(value, "primitive");
+        const section = create();
+        const matrix = placementMatrix(value.placement, section);
+        if (matrix === undefined)
+            return section;
+        if (Math.abs(matrix[8]) > 1e-10 || Math.abs(matrix[9]) > 1e-10 || Math.abs(matrix[11]) > 1e-10)
+            throwGeometryError("INVALID_ARGUMENT", "placement", "Section placement must preserve the XY plane.");
+        const xy = [
+            matrix[0],
+            matrix[1],
+            matrix[3],
+            matrix[4],
+            matrix[5],
+            matrix[7],
+            0,
+            0,
+            1,
+        ];
+        const result = transform(section, xy);
+        return environment.preserveAnchors(section, result, matrix);
+    };
+    const operations = {
+        translate,
+        rotate,
+        scale,
+        mirror,
+        transform,
+        attach: (value, source, target, valueOptions) => {
+            nativeSolid(value);
+            const matrix = placementMatrix({ ...valueOptions, source, target }, value);
+            return transform(value, matrix);
+        },
+    };
+    return { operations, placedSolid, placedSection };
+}

package/dist/engine/types.js

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

package/dist/geometry/anchors.js

@@ -0,0 +1,226 @@
+import { GeometryError } from "./errors.js";
+import { resolveGeometryTolerance } from "./tolerance.js";
+import { composeTransform3, frameTransform3, inverseTransform3 } from "./transform3.js";
+const boxFaces = {
+    back: [
+        [0, -1, 0],
+        [0, 0, 1],
+    ],
+    bottom: [
+        [0, 0, -1],
+        [0, 1, 0],
+    ],
+    front: [
+        [0, 1, 0],
+        [0, 0, 1],
+    ],
+    left: [
+        [-1, 0, 0],
+        [0, 0, 1],
+    ],
+    right: [
+        [1, 0, 0],
+        [0, 0, 1],
+    ],
+    top: [
+        [0, 0, 1],
+        [0, 1, 0],
+    ],
+};
+const primitiveAnchorOrigin = (options, operation) => {
+    if (options.center !== undefined && typeof options.center !== "boolean")
+        throw new GeometryError("INVALID_ARGUMENT", "center must be boolean.", { operation });
+    const origin = options.origin === undefined ? [0, 0, 0] : options.origin;
+    if (!Array.isArray(origin) || origin.length !== 3)
+        throw new GeometryError("INVALID_ARGUMENT", "origin must be an exact XYZ tuple.", {
+            operation,
+        });
+    for (let axis = 0; axis < 3; axis++)
+        if (!Number.isFinite(origin[axis]))
+            throw new GeometryError("NON_FINITE_VALUE", "Anchor origin must be finite.", { operation });
+    return origin;
+};
+const assertAnchorOptions = (options, operation) => {
+    if (typeof options !== "object" || options === null || Array.isArray(options))
+        throw new GeometryError("INVALID_ARGUMENT", "Anchor options must be an object.", { operation });
+};
+/** Creates an outward face-center anchor using the same local origin convention as box().
+ * @remarks origin applies an explicit translation. For rotated components, transform the
+ * resulting anchor frame explicitly; no anchor is inherited from a Boolean result.
+ */
+export function boxAnchor3(options) {
+    const operation = "boxAnchor3";
+    assertAnchorOptions(options, operation);
+    const origin = primitiveAnchorOrigin(options, operation);
+    if (typeof options.size !== "number" &&
+        (!Array.isArray(options.size) || options.size.length !== 3))
+        throw new GeometryError("INVALID_ARGUMENT", "Box anchor size must be a number or XYZ tuple.", {
+            operation,
+        });
+    const size = typeof options.size === "number" ? [options.size, options.size, options.size] : options.size;
+    for (let axis = 0; axis < 3; axis++)
+        if (!Number.isFinite(size[axis]) || size[axis] <= 0)
+            throw new GeometryError("INVALID_ARGUMENT", "Box anchor dimensions must be positive.", {
+                operation,
+            });
+    if (!Object.hasOwn(boxFaces, options.face))
+        throw new GeometryError("INVALID_ARGUMENT", "Unsupported box anchor face.", { operation });
+    const [direction, up] = boxFaces[options.face];
+    const coordinate = (axis) => {
+        if (options.center ?? true)
+            return origin[axis] + (direction[axis] * size[axis]) / 2;
+        return (origin[axis] + (direction[axis] > 0 ? size[axis] : direction[axis] < 0 ? 0 : size[axis] / 2));
+    };
+    return createAnchor3([coordinate(0), coordinate(1), coordinate(2)], direction, up);
+}
+/** Creates a cap-center or radial-side anchor using cylinder()'s construction origin.
+ * @remarks Both centered and noncentered cylinders extend along +Z. Side angle uses degrees;
+ * origin applies an explicit translation, and arbitrary component transforms remain explicit.
+ */
+export function cylinderAnchor3(options) {
+    const operation = "cylinderAnchor3";
+    assertAnchorOptions(options, operation);
+    const origin = primitiveAnchorOrigin(options, operation);
+    const { radius, height, face } = options;
+    const angleDegrees = options.angleDegrees === undefined ? 0 : options.angleDegrees;
+    if (!Number.isFinite(radius) || radius <= 0 || !Number.isFinite(height) || height <= 0)
+        throw new GeometryError("INVALID_ARGUMENT", "Cylinder anchor dimensions must be positive.", {
+            operation,
+        });
+    if (!Number.isFinite(angleDegrees))
+        throw new GeometryError("NON_FINITE_VALUE", "Cylinder anchor angle must be finite.", {
+            operation,
+        });
+    if (face !== "bottom" && face !== "top" && face !== "side")
+        throw new GeometryError("INVALID_ARGUMENT", "Unsupported cylinder anchor face.", { operation });
+    const center = options.center ?? true;
+    if (face === "top")
+        return createAnchor3([origin[0], origin[1], origin[2] + (center ? height / 2 : height)], [0, 0, 1], [0, 1, 0]);
+    if (face === "bottom")
+        return createAnchor3([origin[0], origin[1], origin[2] - (center ? height / 2 : 0)], [0, 0, -1], [0, 1, 0]);
+    const angle = angleDegrees * (Math.PI / 180);
+    const cosine = Math.cos(angle), sine = Math.sin(angle);
+    return createAnchor3([origin[0] + radius * cosine, origin[1] + radius * sine, origin[2] + (center ? 0 : height / 2)], [cosine, sine, 0], [0, 0, 1]);
+}
+const dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+const cross = (a, b) => [
+    a[1] * b[2] - a[2] * b[1],
+    a[2] * b[0] - a[0] * b[2],
+    a[0] * b[1] - a[1] * b[0],
+];
+const normalized = (vector, label, tolerance) => {
+    if (!vector.every(Number.isFinite)) {
+        throw new GeometryError("NON_FINITE_VALUE", `${label} coordinates must be finite.`);
+    }
+    const magnitude = Math.hypot(vector[0], vector[1], vector[2]);
+    if (!Number.isFinite(magnitude)) {
+        throw new GeometryError("NON_FINITE_VALUE", `${label} length must be finite.`);
+    }
+    if (magnitude <= tolerance) {
+        throw new GeometryError("DEGENERATE_GEOMETRY", `${label} must have non-zero length.`);
+    }
+    return Object.freeze([vector[0] / magnitude, vector[1] / magnitude, vector[2] / magnitude]);
+};
+/**
+ * Constructs a normalized immutable attachment anchor.
+ *
+ * `up` is projected onto the plane perpendicular to `direction`, removing small
+ * input drift while preserving its roll intent.
+ *
+ * @param position - Finite anchor point in model coordinates.
+ * @param direction - Non-zero outward attachment normal.
+ * @param up - Non-parallel roll reference; defaults to +Y.
+ * @param tolerance - Optional comparison overrides.
+ * @returns A frozen anchor with unit, orthogonal direction and up vectors.
+ * @throws {@link GeometryError} For non-finite or degenerate inputs.
+ */
+export function createAnchor3(position, direction, up = [0, 1, 0], tolerance = {}) {
+    if (!position.every(Number.isFinite)) {
+        throw new GeometryError("NON_FINITE_VALUE", "Anchor position coordinates must be finite.");
+    }
+    const resolved = resolveGeometryTolerance(Math.max(1, Math.hypot(direction[0], direction[1], direction[2])), tolerance);
+    const zAxis = normalized(direction, "Anchor direction", resolved.linear);
+    const projectedUp = [
+        up[0] - zAxis[0] * dot(up, zAxis),
+        up[1] - zAxis[1] * dot(up, zAxis),
+        up[2] - zAxis[2] * dot(up, zAxis),
+    ];
+    const normalizedUp = normalized(projectedUp, "Anchor up direction", resolved.linear);
+    return Object.freeze({
+        direction: zAxis,
+        position: Object.freeze([position[0], position[1], position[2]]),
+        up: normalizedUp,
+    });
+}
+/**
+ * Converts an anchor into a right-handed frame with direction as local +Z.
+ *
+ * @param anchor - Anchor created by {@link createAnchor3} or equivalent valid data.
+ * @param tolerance - Optional comparison overrides.
+ * @returns A normalized right-handed frame at the anchor position.
+ */
+export function anchorFrame3(anchor, tolerance = {}) {
+    const normalizedAnchor = createAnchor3(anchor.position, anchor.direction, anchor.up, tolerance);
+    const xAxis = normalized(cross(normalizedAnchor.up, normalizedAnchor.direction), "Anchor X axis", 0);
+    return Object.freeze({
+        origin: normalizedAnchor.position,
+        xAxis,
+        yAxis: normalizedAnchor.up,
+        zAxis: normalizedAnchor.direction,
+    });
+}
+/**
+ * Builds the transform that moves a source anchor onto a target anchor.
+ *
+ * The default `opposed` alignment points the source outward normal against the
+ * target outward normal, producing face-to-face mating. A positive gap moves the
+ * attachment point along the target's outward direction. Spin is applied after
+ * alignment around the final source direction.
+ *
+ * @param source - Anchor expressed in the moving object's local coordinates.
+ * @param target - Desired anchor pose in destination coordinates.
+ * @param options - Alignment, gap, spin, and tolerance policy.
+ * @returns A frozen affine transform for the moving object.
+ * @throws {@link GeometryError} For invalid anchors or non-finite options.
+ */
+export function attachTransform(source, target, options = {}) {
+    const gap = options.gap ?? 0;
+    const spin = options.spinRadians ?? 0;
+    if (options.alignment !== undefined &&
+        options.alignment !== "opposed" &&
+        options.alignment !== "same") {
+        throw new GeometryError("INVALID_ARGUMENT", "Attachment alignment must be opposed or same.");
+    }
+    if (!Number.isFinite(gap) || !Number.isFinite(spin)) {
+        throw new GeometryError("NON_FINITE_VALUE", "Attachment gap and spin must be finite.");
+    }
+    const sourceFrame = anchorFrame3(source, options.tolerance);
+    const targetAnchor = createAnchor3(target.position, target.direction, target.up, options.tolerance);
+    const desiredDirection = (options.alignment ?? "opposed") === "opposed"
+        ? [-targetAnchor.direction[0], -targetAnchor.direction[1], -targetAnchor.direction[2]]
+        : targetAnchor.direction;
+    const baseFrame = anchorFrame3(createAnchor3(targetAnchor.position, desiredDirection, targetAnchor.up, options.tolerance), options.tolerance);
+    const cosine = Math.cos(spin);
+    const sine = Math.sin(spin);
+    const spunX = [
+        baseFrame.xAxis[0] * cosine + baseFrame.yAxis[0] * sine,
+        baseFrame.xAxis[1] * cosine + baseFrame.yAxis[1] * sine,
+        baseFrame.xAxis[2] * cosine + baseFrame.yAxis[2] * sine,
+    ];
+    const spunY = [
+        -baseFrame.xAxis[0] * sine + baseFrame.yAxis[0] * cosine,
+        -baseFrame.xAxis[1] * sine + baseFrame.yAxis[1] * cosine,
+        -baseFrame.xAxis[2] * sine + baseFrame.yAxis[2] * cosine,
+    ];
+    const desiredFrame = {
+        origin: [
+            targetAnchor.position[0] + targetAnchor.direction[0] * gap,
+            targetAnchor.position[1] + targetAnchor.direction[1] * gap,
+            targetAnchor.position[2] + targetAnchor.direction[2] * gap,
+        ],
+        xAxis: spunX,
+        yAxis: spunY,
+        zAxis: baseFrame.zAxis,
+    };
+    return composeTransform3(frameTransform3(desiredFrame, options.tolerance), inverseTransform3(frameTransform3(sourceFrame, options.tolerance)));
+}

package/dist/geometry/curves/evaluation.js

@@ -0,0 +1,162 @@
+import { GeometryError } from "../errors.js";
+// This parameter-space probe only resolves stationary tangent direction; it does not control
+// geometric sampling tolerance or move output points. Retain its established one-sided behavior.
+const STATIONARY_TANGENT_PROBE = 0.000001;
+/** @internal Shared structured failures for evaluation and sampling. */
+export function curveFailure(code, message) {
+    throw new GeometryError(code, message, { operation: "sampleCurve" });
+}
+/** @internal Validates original inputs and intermediate arithmetic without copying them. */
+export function validateCurvePoint3(point) {
+    if (point.length !== 3 || !point.every(Number.isFinite))
+        curveFailure("NON_FINITE_VALUE", "Curve coordinates must be finite three-dimensional points.");
+    return point;
+}
+/** @internal Planar input promotion is scratch data, never a completed sampled result. */
+export function liftPointTo3D(point) {
+    if (point.length !== 2)
+        curveFailure("INVALID_ARGUMENT", "Planar curve points must have two coordinates.");
+    return validateCurvePoint3([point[0], point[1], 0]);
+}
+/** @internal Promotes planar controls only to mutable evaluation scratch, never a sampled snapshot. */
+export function planarCubicControl(curve) {
+    return [
+        liftPointTo3D(curve.start),
+        liftPointTo3D(curve.control1),
+        liftPointTo3D(curve.control2),
+        liftPointTo3D(curve.end),
+    ];
+}
+/** @internal Rejects overflowing extents even when endpoints are separately finite. */
+export function curveDistance(a, b) {
+    const result = Math.hypot(b[0] - a[0], b[1] - a[1], b[2] - a[2]);
+    if (!Number.isFinite(result))
+        curveFailure("NON_FINITE_VALUE", "Curve extent exceeds finite arithmetic.");
+    return result;
+}
+/** @internal Weighted interpolation preserves finite large coordinates and the existing operation order. */
+export function interpolateCurvePoint(a, b, t, result) {
+    result[0] = a[0] * (1 - t) + b[0] * t;
+    result[1] = a[1] * (1 - t) + b[1] * t;
+    result[2] = a[2] * (1 - t) + b[2] * t;
+    validateCurvePoint3(result);
+}
+/** @internal Normalization uses hypot and canonical positive zero components. */
+export function normalizeCurveDirection(direction, result) {
+    const length = Math.hypot(...direction);
+    if (!Number.isFinite(length))
+        curveFailure("NON_FINITE_VALUE", "Curve tangent exceeds finite arithmetic.");
+    if (length === 0)
+        curveFailure("DEGENERATE_GEOMETRY", "A curve must have a usable nonzero tangent.");
+    result[0] = direction[0] / length || 0;
+    result[1] = direction[1] / length || 0;
+    result[2] = direction[2] / length || 0;
+}
+/** @internal Safe to alias result because normalization reads each component before replacing it. */
+export function curveDirection(a, b, result) {
+    result[0] = b[0] - a[0];
+    result[1] = b[1] - a[1];
+    result[2] = b[2] - a[2];
+    normalizeCurveDirection(result, result);
+}
+/** @internal Bounding distance to the finite chord, using the existing arithmetic order. */
+export function distanceToCurveChord(point, start, end) {
+    const extent = curveDistance(start, end);
+    if (extent === 0)
+        return curveDistance(point, start);
+    const x = (end[0] - start[0]) / extent || 0;
+    const y = (end[1] - start[1]) / extent || 0;
+    const z = (end[2] - start[2]) / extent || 0;
+    const relativeX = point[0] - start[0];
+    const relativeY = point[1] - start[1];
+    const relativeZ = point[2] - start[2];
+    const along = Math.max(0, Math.min(extent, relativeX * x + relativeY * y + relativeZ * z));
+    const result = Math.hypot(relativeX - along * x, relativeY - along * y, relativeZ - along * z);
+    if (!Number.isFinite(result))
+        curveFailure("NON_FINITE_VALUE", "Bézier flatness exceeds finite arithmetic.");
+    return result;
+}
+/** @internal Subdivision retains its new control polygons; evaluation reuses separate scratch. */
+export function splitCubicControl(control, parameter = 0.5) {
+    const a = [0, 0, 0], b = [0, 0, 0], c = [0, 0, 0];
+    const d = [0, 0, 0], e = [0, 0, 0], middle = [0, 0, 0];
+    interpolateCurvePoint(control[0], control[1], parameter, a);
+    interpolateCurvePoint(control[1], control[2], parameter, b);
+    interpolateCurvePoint(control[2], control[3], parameter, c);
+    interpolateCurvePoint(a, b, parameter, d);
+    interpolateCurvePoint(b, c, parameter, e);
+    interpolateCurvePoint(d, e, parameter, middle);
+    return [
+        [control[0], a, d, middle],
+        [middle, e, c, control[3]],
+    ];
+}
+/** @internal Derivative controls are constant for a cubic, so calculate them once per invocation. */
+export class CubicEvaluator {
+    #control;
+    #derivative;
+    #a = [0, 0, 0];
+    #b = [0, 0, 0];
+    #c = [0, 0, 0];
+    #d = [0, 0, 0];
+    #e = [0, 0, 0];
+    #probe = [0, 0, 0];
+    constructor(control) {
+        this.#control = control;
+    }
+    point(t, result) {
+        if (t === 0 || t === 1) {
+            const endpoint = this.#control[t === 0 ? 0 : 3];
+            result[0] = endpoint[0];
+            result[1] = endpoint[1];
+            result[2] = endpoint[2];
+            return;
+        }
+        interpolateCurvePoint(this.#control[0], this.#control[1], t, this.#a);
+        interpolateCurvePoint(this.#control[1], this.#control[2], t, this.#b);
+        interpolateCurvePoint(this.#control[2], this.#control[3], t, this.#c);
+        interpolateCurvePoint(this.#a, this.#b, t, this.#d);
+        interpolateCurvePoint(this.#b, this.#c, t, this.#e);
+        interpolateCurvePoint(this.#d, this.#e, t, result);
+    }
+    tangent(t, point, result) {
+        // Profile correspondence needs points only. Tangent-bearing curves calculate these once,
+        // retaining the established derivative arithmetic without allocating unused controls.
+        const control = this.#control;
+        const derivative = (this.#derivative ??= [
+            [control[1][0] - control[0][0], control[1][1] - control[0][1], control[1][2] - control[0][2]],
+            [control[2][0] - control[1][0], control[2][1] - control[1][1], control[2][2] - control[1][2]],
+            [control[3][0] - control[2][0], control[3][1] - control[2][1], control[3][2] - control[2][2]],
+        ]);
+        interpolateCurvePoint(derivative[0], derivative[1], t, this.#a);
+        interpolateCurvePoint(derivative[1], derivative[2], t, this.#b);
+        interpolateCurvePoint(this.#a, this.#b, t, result);
+        if (Math.hypot(...result) > 0) {
+            normalizeCurveDirection(result, result);
+            return;
+        }
+        // At stationary endpoints or cusps, use an outgoing one-sided secant when available.
+        // A fixed small parameter probe retains the previous fallback without an output-spacing dependency.
+        if (t < 1) {
+            this.point(Math.min(1, t + STATIONARY_TANGENT_PROBE), this.#probe);
+            if (curveDistance(point, this.#probe) > 0) {
+                curveDirection(point, this.#probe, result);
+                return;
+            }
+        }
+        if (t > 0) {
+            this.point(Math.max(0, t - STATIONARY_TANGENT_PROBE), this.#probe);
+            if (curveDistance(this.#probe, point) > 0) {
+                curveDirection(this.#probe, point, result);
+                return;
+            }
+        }
+        // If rounding erases both local probes, retain the first usable directed control edge.
+        for (let i = 0; i < 3; i++)
+            if (curveDistance(this.#control[i], this.#control[i + 1]) > 0) {
+                curveDirection(this.#control[i], this.#control[i + 1], result);
+                return;
+            }
+        curveFailure("DEGENERATE_GEOMETRY", "A constant Bézier curve has no tangent.");
+    }
+}