@metamesh/modeling 0.13.0 → 0.14.0

package/dist/api/geometry.d.ts

@@ -11,6 +11,9 @@ export declare interface AcmeThreadProfileSpec extends ThreadProfileBaseSpec {
   readonly depth?: number;
 }
 
+/** Adds two finite XY vectors component-wise. */
+export declare const add2: (a: Vector2Tuple, b: Vector2Tuple) => Vector2Tuple;
+
 /**
  * Adds two finite XYZ vectors component-wise.
  * @example
@@ -18,10 +21,12 @@ export declare interface AcmeThreadProfileSpec extends ThreadProfileBaseSpec {
  * add3([1, 2, 3], [4, 5, 6]); // [5, 7, 9]
  * ```
  */
-export declare const add3: (a: Vector3, b: Vector3) => Vector3;
+export declare const add3: (a: Vector3Tuple, b: Vector3Tuple) => Vector3Tuple;
 
 /** Controls full-circle sampling that must satisfy one or more topology alignments. */
 export declare interface AlignedCircularSegmentsOptions {
+  /** Radial sizing used by adaptive error and edge-length checks. Defaults to vertex. */
+  readonly sizing?: RadialSizing;
   /**
    * Non-empty alignment factors. Every value must be a positive safe integer; the returned count
    * is divisible by their checked least common multiple.
@@ -84,11 +89,11 @@ export declare function analyzeTriangleMeshQuality(
  */
 export declare interface Anchor3 {
   /** Unit outward normal used as the anchor's local +Z direction. */
-  readonly direction: Vector3;
+  readonly direction: Vector3Tuple;
   /** World-space attachment position. */
-  readonly position: Vector3;
+  readonly position: Vector3Tuple;
   /** Roll guide projected into the plane perpendicular to `direction`. */
-  readonly up: Vector3;
+  readonly up: Vector3Tuple;
 }
 
 /**
@@ -113,9 +118,9 @@ export declare function anchorFrame3(
  * @returns A fresh transformed direction.
  */
 export declare function applyTransformDirection3(
-  transform: Transform3,
-  direction: Vector3,
-): Vector3;
+  transform: Transform3Matrix,
+  direction: Vector3Tuple,
+): Vector3Tuple;
 
 /**
  * Applies an affine transform to a point, including translation.
@@ -125,16 +130,16 @@ export declare function applyTransformDirection3(
  * @returns A fresh transformed point.
  */
 export declare function applyTransformPoint3(
-  transform: Transform3,
-  point: Vector3,
-): Vector3;
+  transform: Transform3Matrix,
+  point: Vector3Tuple,
+): Vector3Tuple;
 
 /** Planar circular arc with counterclockwise degree angles. */
 export declare interface ArcCurve2 {
   /** Selects a circular arc in the XY plane. */
   readonly kind: "arc";
   /** Circle center in millimetres. */
-  readonly center: Vector2;
+  readonly center: Vector2Tuple;
   /** Positive circular radius in millimetres. */
   readonly radius: number;
   /** Initial angle in degrees; defaults to zero. */
@@ -148,13 +153,13 @@ export declare interface ArcCurve3 {
   /** Selects a circular arc in the supplied plane. */
   readonly kind: "arc";
   /** Circle center in millimetres. */
-  readonly center: Vector3;
+  readonly center: Vector3Tuple;
   /** Positive circular radius in millimetres. */
   readonly radius: number;
   /** Orthogonal unit direction at zero degrees. */
-  readonly xAxis: Vector3;
+  readonly xAxis: Vector3Tuple;
   /** Orthogonal unit direction at positive ninety degrees. */
-  readonly yAxis: Vector3;
+  readonly yAxis: Vector3Tuple;
   /** Initial angle in degrees; defaults to zero. */
   readonly startDegrees?: number;
   /** Nonzero signed sweep in degrees, bounded to one complete turn. */
@@ -179,7 +184,7 @@ export declare function attachTransform(
   source: Anchor3,
   target: Anchor3,
   options?: AttachTransformOptions,
-): Transform3;
+): Transform3Matrix;
 
 /** Options controlling how one anchor is attached to another. */
 export declare interface AttachTransformOptions {
@@ -213,31 +218,31 @@ export declare type AxisAngleRotation3 =
 /** Axis-aligned bounds in two-dimensional model space. */
 export declare interface Bounds2 {
   /** Inclusive maximum X/Y coordinates. */
-  readonly max: Vector2;
+  readonly max: Vector2Tuple;
   /** Inclusive minimum X/Y coordinates. */
-  readonly min: Vector2;
+  readonly min: Vector2Tuple;
 }
 
 /** Axis-aligned bounds in three-dimensional model space. */
 export declare interface Bounds3 {
   /** Inclusive maximum X/Y/Z coordinates. */
-  readonly max: Vector3;
+  readonly max: Vector3Tuple;
   /** Inclusive minimum X/Y/Z coordinates. */
-  readonly min: Vector3;
+  readonly min: Vector3Tuple;
 }
 
 /** Midpoint of finite XY bounds in millimetres. */
-export declare function boundsCenter(bounds: Bounds2): Vector2;
+export declare function boundsCenter(bounds: Bounds2): Vector2Tuple;
 
 /** Midpoint of finite XYZ bounds in millimetres. */
-export declare function boundsCenter(bounds: Bounds3): Vector3;
+export declare function boundsCenter(bounds: Bounds3): Vector3Tuple;
 
 /** A uniform XY scale followed by translation, and the resulting bounds. */
 export declare interface BoundsFit2 {
   /** Positive uniform scale. */
   readonly scale: number;
   /** Millimetre translation applied after scaling around the origin. */
-  readonly position: Vector2;
+  readonly position: Vector2Tuple;
   /** Bounds after scaling and translation. */
   readonly bounds: Bounds2;
 }
@@ -247,7 +252,7 @@ export declare interface BoundsFit3 {
   /** Positive uniform scale. */
   readonly scale: number;
   /** Millimetre translation applied after scaling around the origin. */
-  readonly position: Vector3;
+  readonly position: Vector3Tuple;
   /** Bounds after scaling and translation. */
   readonly bounds: Bounds3;
 }
@@ -260,13 +265,13 @@ export declare interface BoundsFitOptions {
 
 /** Creates immutable centered XY bounds from nonnegative dimensions in millimetres. */
 export declare function boundsFromSize(
-  size: Vector2,
+  size: Vector2Tuple,
   options?: BoundsFromSizeOptions,
 ): Bounds2;
 
 /** Creates immutable centered XYZ bounds from nonnegative dimensions in millimetres. */
 export declare function boundsFromSize(
-  size: Vector3,
+  size: Vector3Tuple,
   options?: BoundsFromSizeOptions,
 ): Bounds3;
 
@@ -277,10 +282,10 @@ export declare interface BoundsFromSizeOptions {
 }
 
 /** Inclusive XY dimensions in millimetres; zero extents are retained. */
-export declare function boundsSize(bounds: Bounds2): Vector2;
+export declare function boundsSize(bounds: Bounds2): Vector2Tuple;
 
 /** Inclusive XYZ dimensions in millimetres; zero extents are retained. */
-export declare function boundsSize(bounds: Bounds3): Vector3;
+export declare function boundsSize(bounds: Bounds3): Vector3Tuple;
 
 /** 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
@@ -295,13 +300,13 @@ export declare type BoxAnchorFace =
 /** Box dimensions and construction origin for one named face anchor. */
 export declare interface BoxAnchorOptions {
   /** XYZ dimensions, or one uniform dimension, in millimetres. */
-  readonly size: number | Vector3;
+  readonly size: number | Vector3Tuple;
   /** Named outward face whose center is the attachment point. */
   readonly face: BoxAnchorFace;
   /** Centers the box around its construction origin; defaults to true, matching box(). */
   readonly center?: boolean;
   /** Construction origin; centered-box center or noncentered minimum corner. Defaults to zero. */
-  readonly origin?: Vector3;
+  readonly origin?: Vector3Tuple;
 }
 
 /** Box edges use +Z top, +Y front and +X right; vertical names list front/back first. */
@@ -339,7 +344,7 @@ export declare interface BoxOptions extends PrimitivePlacement {
    */
   readonly center?: boolean;
   /** Positive uniform size or explicit `[X, Y, Z]` extents in millimetres. */
-  readonly size: number | Vector3;
+  readonly size: number | Vector3Tuple;
   /** Uniform treatment or independent disjoint nominal edge/group treatments. */
   readonly treatment?: EdgeTreatment | BoxEdgeTreatments;
 }
@@ -443,6 +448,12 @@ export declare interface CircularPrimitiveOptions {
   readonly resolution?: GeometryResolution;
 }
 
+/** Circular sampling measured from the nominal inscribed or circumscribed radius. */
+export declare interface CircularResolutionOptions extends GeometryResolution {
+  /** Vertex sizing bounds inward sagitta; face sizing bounds outward excess. Defaults to vertex. */
+  readonly sizing?: RadialSizing;
+}
+
 /** Close, normal, and loose metric clearance-hole diameters in millimetres. */
 export declare interface ClearanceHoleDimensions {
   /** Close-fit clearance-hole diameter. */
@@ -456,6 +467,54 @@ export declare interface ClearanceHoleDimensions {
 /** Common clearance-hole fit categories, ordered from smallest to largest. */
 export declare type ClearanceHoleFit = "close" | "normal" | "loose";
 
+/**
+ * Finds the closest position anywhere on an open XY path or closed contour.
+ *
+ * Open paths need two points; closed paths need three and omit the duplicated seam.
+ * Repeated vertices are treated as zero-length edges. Inputs and derived distances must be
+ * finite. Only the final result is allocated, so scanning a dense boundary creates no per-edge objects.
+ * This measures the sampled boundary, not its filled interior or an underlying analytic curve.
+ *
+ * @example Find a point on a closed boundary
+ * ```ts
+ * closestPointOnPath([[0, 0], [10, 0], [10, 10]], [4, -2], { closed: true });
+ * ```
+ */
+export declare function closestPointOnPath(
+  path: Path2,
+  point: Vector2Tuple,
+  options?: ClosestPointOnPathOptions,
+): ClosestPointOnPathResult<Vector2Tuple>;
+
+/** Finds the closest position on an open XYZ path or explicitly closed spatial loop. */
+export declare function closestPointOnPath(
+  path: Path3,
+  point: Vector3Tuple,
+  options?: ClosestPointOnPathOptions,
+): ClosestPointOnPathResult<Vector3Tuple>;
+
+/** Topology and work ceiling for a closest-point query on a sampled path. */
+export declare interface ClosestPointOnPathOptions {
+  /** Include the last-to-first edge without duplicating the seam point. Defaults to false. */
+  readonly closed?: boolean;
+  /** Explicit path point ceiling; defaults to the package sampling limits. */
+  readonly limits?: Partial<GeometrySamplingLimits>;
+}
+
+/** Closest position on a sampled path, measured in millimetres. */
+export declare interface ClosestPointOnPathResult<
+  Point extends Vector2Tuple | Vector3Tuple,
+> {
+  /** Copied position on the selected edge. */
+  readonly point: Point;
+  /** Euclidean distance from the query point to the path. */
+  readonly distance: number;
+  /** Zero-based starting vertex of the selected edge. Equal distances keep the first edge. */
+  readonly edgeIndex: number;
+  /** Clamped interpolation fraction from the edge's start to its end. */
+  readonly fraction: number;
+}
+
 /**
  * Closes an open, strictly upward [radius, height] side outline to the radius-zero axis.
  * Adds horizontal bottom/top edges at the endpoint heights, retaining axis endpoints once.
@@ -464,7 +523,7 @@ export declare type ClearanceHoleFit = "close" | "normal" | "loose";
  * This is a solid-body closure, not a hollow-wall or mounting-bore construction.
  */
 export declare function closeToAxis(
-  side: readonly Vector2[],
+  side: readonly Vector2Tuple[],
   limits?: Partial<GeometrySamplingLimits>,
 ): Contour;
 
@@ -531,9 +590,9 @@ export declare function compensateThreadProfileForFaceting(
  * @returns A new frozen transform equal to `after * before`.
  */
 export declare function composeTransform3(
-  after: Transform3,
-  before: Transform3,
-): Transform3;
+  after: Transform3Matrix,
+  before: Transform3Matrix,
+): Transform3Matrix;
 
 /**
  * Builds rotation-minimizing frames for a non-duplicated closed path.
@@ -544,8 +603,8 @@ export declare function composeTransform3(
  * The maxPathPoints ceiling (default 100000) bounds path points and frames.
  */
 export declare const computeClosedParallelTransportFrames: (
-  path: readonly Vector3[],
-  initialNormal?: Vector3,
+  path: readonly Vector3Tuple[],
+  initialNormal?: Vector3Tuple,
   limits?: Partial<GeometrySamplingLimits>,
 ) => readonly PathFrame[];
 
@@ -555,8 +614,8 @@ export declare const computeClosedParallelTransportFrames: (
  * Paths exceeding maxPathPoints (default 100000) reject before frame allocation or guide evaluation.
  */
 export declare const computeParallelTransportFrames: (
-  path: readonly Vector3[],
-  initialNormal?: Vector3,
+  path: readonly Vector3Tuple[],
+  initialNormal?: Vector3Tuple,
   normalGuide?: PathNormalGuide,
   limits?: Partial<GeometrySamplingLimits>,
 ) => readonly PathFrame[];
@@ -572,7 +631,7 @@ export declare const computeParallelTransportFrames: (
  */
 export declare function computeTriangleMeshCentroid(
   mesh: TriangleMesh,
-): Vector3;
+): Vector3Tuple;
 
 /** Tests actual XY containment, including touching boundaries; dimensions must match. */
 export declare function containsBounds(outer: Bounds2, inner: Bounds2): boolean;
@@ -586,12 +645,12 @@ export declare function containsBounds(outer: Bounds3, inner: Bounds3): boolean;
  * Polygon exteriors are counter-clockwise and holes are clockwise. Algorithms
  * may reject duplicate adjacent points or fewer than three effective vertices.
  */
-export declare type Contour = readonly Vector2[];
+export declare type Contour = readonly Vector2Tuple[];
 
 /** Returns true when a point lies inside or on the boundary of a loop. */
 export declare function contourContainsPoint(
   loop: Contour,
-  point: Vector2,
+  point: Vector2Tuple,
 ): boolean;
 
 /** One explicitly closed planar contour, independent of editor metadata and parameter contracts. */
@@ -675,9 +734,9 @@ export declare type CorrespondingProfileStation = LoftPlacement & {
  * @throws {@link GeometryError} For non-finite or degenerate inputs.
  */
 export declare function createAnchor3(
-  position: Vector3,
-  direction: Vector3,
-  up?: Vector3,
+  position: Vector3Tuple,
+  direction: Vector3Tuple,
+  up?: Vector3Tuple,
   tolerance?: GeometryToleranceOptions,
 ): Anchor3;
 
@@ -714,6 +773,9 @@ export declare function createTriangleMeshSignature(
   options?: TriangleMeshSignatureOptions,
 ): TriangleMeshSignature;
 
+/** Returns the signed scalar cross product; positive means `b` is counter-clockwise from `a`. */
+export declare const cross2: (a: Vector2Tuple, b: Vector2Tuple) => number;
+
 /**
  * Returns the right-handed cross product.
  * @example
@@ -721,20 +783,20 @@ export declare function createTriangleMeshSignature(
  * cross3([1, 0, 0], [0, 1, 0]); // [0, 0, 1]
  * ```
  */
-export declare const cross3: (a: Vector3, b: Vector3) => Vector3;
+export declare const cross3: (a: Vector3Tuple, b: Vector3Tuple) => Vector3Tuple;
 
 /** Planar cubic Bézier with explicit endpoint and control coordinates. */
 export declare interface CubicBezierCurve2 {
   /** Selects a cubic Bézier through two endpoints and two controls. */
   readonly kind: "cubic";
   /** Initial XY point in millimetres. */
-  readonly start: Vector2;
+  readonly start: Vector2Tuple;
   /** First XY control point in millimetres. */
-  readonly control1: Vector2;
+  readonly control1: Vector2Tuple;
   /** Second XY control point in millimetres. */
-  readonly control2: Vector2;
+  readonly control2: Vector2Tuple;
   /** Final XY point in millimetres. */
-  readonly end: Vector2;
+  readonly end: Vector2Tuple;
 }
 
 /**
@@ -744,18 +806,18 @@ export declare interface CubicBezierCurve3 {
   /** Selects a cubic Bézier through two endpoints and two controls. */
   readonly kind: "cubic";
   /** Initial XYZ point in millimetres. */
-  readonly start: Vector3;
+  readonly start: Vector3Tuple;
   /** First XYZ control point in millimetres. */
-  readonly control1: Vector3;
+  readonly control1: Vector3Tuple;
   /** Second XYZ control point in millimetres. */
-  readonly control2: Vector3;
+  readonly control2: Vector3Tuple;
   /** Final XYZ point in millimetres. */
-  readonly end: Vector3;
+  readonly end: Vector3Tuple;
 }
 
 /** Returns cumulative arc length for finite points under maxPathPoints (default 100000); rejects overflowing length. */
 export declare const cumulativePathLengths: (
-  path: readonly Vector3[],
+  path: readonly Vector3Tuple[],
   limits?: Partial<GeometrySamplingLimits>,
 ) => readonly number[];
 
@@ -789,7 +851,7 @@ export declare interface CustomThreadProfileSpec extends ThreadProfileBaseSpec {
    * Open path spanning exactly `[-pitch/2, pitch/2]`, with both endpoints on the minor envelope,
    * one connected ridge, one contiguous crest, and radial zero at the major envelope.
    */
-  readonly points: readonly Vector2[];
+  readonly points: readonly Vector2Tuple[];
 }
 
 /** Creates a cap-center or radial-side anchor using cylinder()'s construction origin.
@@ -816,7 +878,7 @@ export declare interface CylinderAnchorOptions {
   /** Centers the cylinder along Z; defaults to true, matching cylinder(). */
   readonly center?: boolean;
   /** Construction origin; centered-axis midpoint or noncentered bottom axis. Defaults to zero. */
-  readonly origin?: Vector3;
+  readonly origin?: Vector3Tuple;
 }
 
 /**
@@ -992,6 +1054,12 @@ export declare const DEFAULT_GEOMETRY_TOLERANCE: Readonly<{
 /** Conservative defaults; trusted callers can supply larger explicit ceilings. */
 export declare const defaultGeometrySamplingLimits: GeometrySamplingLimits;
 
+/** Returns Euclidean point distance without allocating an intermediate difference vector. */
+export declare const distance2: (a: Vector2Tuple, b: Vector2Tuple) => number;
+
+/** Returns Euclidean point distance without allocating an intermediate difference vector. */
+export declare const distance3: (a: Vector3Tuple, b: Vector3Tuple) => number;
+
 /**
  * Places an exact item count at equal arc-length intervals along a sampled path.
  *
@@ -1001,12 +1069,15 @@ export declare const defaultGeometrySamplingLimits: GeometrySamplingLimits;
  * limited by maxPathPoints (default 100000); exact counts exceeding that ceiling reject before length calculation.
  */
 export declare const distributeAlongPath: (
-  path: readonly Vector3[],
+  path: readonly Vector3Tuple[],
   count: number,
   closed: boolean,
   limits?: Partial<GeometrySamplingLimits>,
 ) => readonly PathPlacement[];
 
+/** Returns the scalar dot product. */
+export declare const dot2: (a: Vector2Tuple, b: Vector2Tuple) => number;
+
 /**
  * Returns the scalar dot product.
  * @example
@@ -1014,7 +1085,7 @@ export declare const distributeAlongPath: (
  * dot3([1, 0, 0], [0, 1, 0]); // 0
  * ```
  */
-export declare const dot3: (a: Vector3, b: Vector3) => number;
+export declare const dot3: (a: Vector3Tuple, b: Vector3Tuple) => number;
 
 /**
  * Uniform finishing vocabulary shared by applicable solid edges and profile corners.
@@ -1042,13 +1113,13 @@ export declare type EllipseContourOptions = CircularPrimitiveOptions &
   (
     | {
         /** Positive XY radii in millimetres; mutually exclusive with size. */
-        readonly radius: Vector2;
+        readonly radius: Vector2Tuple;
         /** Full XY extents are unavailable when radius is supplied. */
         readonly size?: never;
       }
     | {
         /** Positive full XY extents in millimetres; mutually exclusive with radius. */
-        readonly size: Vector2;
+        readonly size: Vector2Tuple;
         /** XY radii are unavailable when size is supplied. */
         readonly radius?: never;
       }
@@ -1075,7 +1146,9 @@ export declare interface EndTreatments {
  * @returns A frozen row-major transform.
  * @throws {@link GeometryError} When an angle is non-finite.
  */
-export declare function eulerTransform3(rotationDegrees: Vector3): Transform3;
+export declare function eulerTransform3(
+  rotationDegrees: Vector3Tuple,
+): Transform3Matrix;
 
 /**
  * Linearly extrudes one simple profile along +Z with robust ear-clipped caps.
@@ -1112,7 +1185,7 @@ export declare interface ExtrusionSamplingOptions {
   /** Operation-level physical policy over the nearest model scope. */
   readonly resolution?: GeometryResolution;
   /** Finite uniform or XY scale of the top profile; defaults to one. */
-  readonly scaleTop?: number | Vector2;
+  readonly scaleTop?: number | Vector2Tuple;
   /** Finite rotation of the top profile about +Z, in degrees; defaults to zero. */
   readonly twistDegrees?: number;
 }
@@ -1161,13 +1234,13 @@ export declare function fitTextLayout(
 /** A right-handed orthonormal coordinate frame expressed in world coordinates. */
 export declare interface Frame3 {
   /** World-space origin of the local frame. */
-  readonly origin: Vector3;
+  readonly origin: Vector3Tuple;
   /** Unit vector defining the local +X axis. */
-  readonly xAxis: Vector3;
+  readonly xAxis: Vector3Tuple;
   /** Unit vector defining the local +Y axis. */
-  readonly yAxis: Vector3;
+  readonly yAxis: Vector3Tuple;
   /** Unit vector defining the local +Z axis. */
-  readonly zAxis: Vector3;
+  readonly zAxis: Vector3Tuple;
 }
 
 /**
@@ -1181,7 +1254,7 @@ export declare interface Frame3 {
 export declare function frameTransform3(
   frame: Frame3,
   tolerance?: GeometryToleranceOptions,
-): Transform3;
+): Transform3Matrix;
 
 /**
  * Error raised when a geometry precondition or invariant is not satisfied.
@@ -1297,22 +1370,22 @@ export declare type GridPatternOptions = {
 } & (
   | {
       /** Positive integer counts on X and Y. */
-      readonly count: Vector2;
+      readonly count: Vector2Tuple;
       /** Signed millimetres between adjacent copies on X and Y. */
-      readonly spacing: Vector2;
+      readonly spacing: Vector2Tuple;
     }
   | {
       /** Positive integer counts on X, Y and Z. */
-      readonly count: Vector3;
+      readonly count: Vector3Tuple;
       /** Signed millimetres between adjacent copies on X, Y and Z. */
-      readonly spacing: Vector3;
+      readonly spacing: Vector3Tuple;
     }
 );
 
 /** XY or XYZ grid placements in millimetres, in X-fastest order. */
 export declare function gridPatternTransforms(
   options: GridPatternOptions,
-): readonly Transform3[];
+): readonly Transform3Matrix[];
 
 /**
  * Builds a closed indexed mesh from a rectilinear top, matched boundary walls, and flat base.
@@ -1349,7 +1422,7 @@ export declare type HeightfieldMeshLimits = Partial<
  */
 export declare type HeightfieldOptions = {
   /** Absolute top Z at the supplied XY point. Every sample must be above baseZ. */
-  readonly height: (point: Vector2) => number;
+  readonly height: (point: Vector2Tuple) => number;
   /** Flat bottom Z. Defaults to zero. */
   readonly baseZ?: number;
   /**
@@ -1362,11 +1435,11 @@ export declare type HeightfieldOptions = {
 } & (
   | {
       /** Positive XY footprint for uniform sampling. */
-      readonly size: Vector2;
+      readonly size: Vector2Tuple;
       /** Exact positive integer X/Y interval counts. */
       readonly segments: readonly [x: number, y: number];
       /** Lower-left footprint XY. Omitted centers the footprint on XY. */
-      readonly origin?: Vector2;
+      readonly origin?: Vector2Tuple;
       /** Explicit coordinates cannot be combined with uniform sampling. */
       readonly coordinates?: never;
     }
@@ -1460,7 +1533,7 @@ export declare interface HelicalThreadSolidMeshPreflight {
 }
 
 /** Identity transform, safe to share because it is frozen. */
-export declare const IDENTITY_TRANSFORM3: Transform3;
+export declare const IDENTITY_TRANSFORM3: Transform3Matrix;
 
 /** Options for a compensated internal-thread subtraction tool along +Z. */
 export declare interface InternalThreadCutterOptions
@@ -1479,7 +1552,9 @@ export declare interface InternalThreadCutterOptions
  * @param transform - Transform to invert.
  * @returns A new frozen transform whose composition with the input is identity.
  */
-export declare function inverseTransform3(transform: Transform3): Transform3;
+export declare function inverseTransform3(
+  transform: Transform3Matrix,
+): Transform3Matrix;
 
 /**
  * Recognizes structured geometry errors from separately bundled Modeling copies in the same realm.
@@ -1509,20 +1584,34 @@ export declare function joinTriangleMeshes(
 export declare function layoutRow(
   bounds: readonly Bounds3[],
   options?: RowLayoutOptions,
-): readonly Vector3[];
+): readonly Vector3Tuple[];
 
 /** Returns Euclidean vector length in the vector's coordinate units. */
-export declare const length3: (vector: Vector3) => number;
+export declare const length2: (vector: Vector2Tuple) => number;
+
+/** Returns Euclidean vector length in the vector's coordinate units. */
+export declare const length3: (vector: Vector3Tuple) => number;
+
+/** Linearly interpolates two vectors; `t` is dimensionless and may extrapolate. */
+export declare const lerp2: (
+  a: Vector2Tuple,
+  b: Vector2Tuple,
+  t: number,
+) => Vector2Tuple;
 
 /** Linearly interpolates two vectors; `t` is dimensionless and may extrapolate. */
-export declare const lerp3: (a: Vector3, b: Vector3, t: number) => Vector3;
+export declare const lerp3: (
+  a: Vector3Tuple,
+  b: Vector3Tuple,
+  t: number,
+) => Vector3Tuple;
 
 /**
  * Equal linear intervals determined by exactly two of count, spacing and total length.
  */
 export declare type LinearPatternOptions = {
   /** Direction of repetition; magnitude is ignored. Defaults to +X. */
-  readonly direction?: Vector3;
+  readonly direction?: Vector3Tuple;
 } & (
   | {
       /** Positive copy count, including the original. */
@@ -1553,16 +1642,16 @@ export declare type LinearPatternOptions = {
 /** Equal linear placements in millimetres, including the original at the origin. */
 export declare function linearPatternTransforms(
   options: LinearPatternOptions,
-): readonly Transform3[];
+): readonly Transform3Matrix[];
 
 /** Straight planar curve in millimetres. */
 export declare interface LineCurve2 {
   /** Selects straight interpolation between the two endpoints. */
   readonly kind: "line";
   /** Initial XY point in millimetres. */
-  readonly start: Vector2;
+  readonly start: Vector2Tuple;
   /** Final XY point in millimetres. */
-  readonly end: Vector2;
+  readonly end: Vector2Tuple;
 }
 
 /** Straight spatial curve in millimetres. */
@@ -1570,9 +1659,9 @@ export declare interface LineCurve3 {
   /** Selects straight interpolation between the two endpoints. */
   readonly kind: "line";
   /** Initial XYZ point in millimetres. */
-  readonly start: Vector3;
+  readonly start: Vector3Tuple;
   /** Final XYZ point in millimetres. */
-  readonly end: Vector3;
+  readonly end: Vector3Tuple;
 }
 
 /**
@@ -1684,7 +1773,8 @@ export declare interface MatchProfilesOptions {
 /**
  * Measures sampled kinematic interference over one tooth cycle of an internal gear pair.
  *
- * The driver and ring rotate in the same direction at their resolved tooth-count ratio. Each
+ * The driver and ring start with half-tooth offsets for odd tooth counts, then rotate in the
+ * same direction at their resolved tooth-count ratio. Each
  * sampled pinion outline is subtracted from the ring's center-and-space opening; remaining area is
  * solid overlap. This catches involute, tip, and trimming interference that a single assembled pose
  * misses. It is a deterministic model check, not a certified gear-rating calculation.
@@ -1807,8 +1897,25 @@ export declare interface ModelingLimits extends GeometrySamplingLimits {
   readonly maxBytes: number;
 }
 
-/** Normalizes a finite vector and rejects nonfinite lengths or lengths at or below `epsilon`. */
-export declare const normalize3: (vector: Vector3, epsilon?: number) => Vector3;
+/**
+ * Returns a unit vector; `epsilon` is a finite, non-negative length threshold (default `1e-12`).
+ * Rejects invalid thresholds, nonfinite lengths, and lengths at or below the threshold with
+ * `INVALID_TOLERANCE`, `NON_FINITE_VALUE`, and `DEGENERATE_GEOMETRY` respectively.
+ */
+export declare const normalize2: (
+  vector: Vector2Tuple,
+  epsilon?: number,
+) => Vector2Tuple;
+
+/**
+ * Returns a unit vector; `epsilon` is a finite, non-negative length threshold (default `1e-12`).
+ * Rejects invalid thresholds, nonfinite lengths, and lengths at or below the threshold with
+ * `INVALID_TOLERANCE`, `NON_FINITE_VALUE`, and `DEGENERATE_GEOMETRY` respectively.
+ */
+export declare const normalize3: (
+  vector: Vector3Tuple,
+  epsilon?: number,
+) => Vector3Tuple;
 
 /**
  * Cleans and validates one closed loop.
@@ -1819,7 +1926,7 @@ export declare const normalize3: (vector: Vector3, epsilon?: number) => Vector3;
  * returned unchanged when their winding and tolerance policy match.
  */
 export declare function normalizeContour(
-  input: readonly Vector2[],
+  input: readonly Vector2Tuple[],
   counterClockwise: boolean,
   tolerance?: GeometryToleranceOptions,
 ): Contour;
@@ -1832,18 +1939,18 @@ export declare function normalizeContour(
  * may be returned unchanged under the same tolerance policy.
  */
 export declare function normalizePolygon(
-  polygon: Polygon,
+  polygon: PolygonData,
   tolerance?: GeometryToleranceOptions,
-): Polygon;
+): PolygonData;
 
 /**
  * Validates a disjoint explicit region and returns immutable normalized data.
  * Previously validated immutable results may be returned unchanged under the same tolerance policy.
  */
 export declare function normalizeRegion(
-  region: Region,
+  region: RegionData,
   tolerance?: GeometryToleranceOptions,
-): Region;
+): RegionData;
 
 /**
  * Improves pathological planar triangulation with bounded legal diagonal flips.
@@ -1864,28 +1971,28 @@ export declare function optimizePlanarPatches(
 ): PlanarMeshOptimizationResult;
 
 /** An ordered, open sequence of two-dimensional points. */
-export declare type Path2 = readonly Vector2[];
+export declare type Path2 = readonly Vector2Tuple[];
 
 /**
  * An ordered, open sequence of three-dimensional points.
  */
-export declare type Path3 = readonly Vector3[];
+export declare type Path3 = readonly Vector3Tuple[];
 
 /** Orthonormal right-handed frame sampled along a path. */
 export declare interface PathFrame {
   /** Unit path tangent. */
-  readonly tangent: Vector3;
+  readonly tangent: Vector3Tuple;
   /** Unit transported profile X axis. */
-  readonly normal: Vector3;
+  readonly normal: Vector3Tuple;
   /** Unit profile Y axis equal to tangent × normal. */
-  readonly binormal: Vector3;
+  readonly binormal: Vector3Tuple;
 }
 
 /**
  * Returns total sampled 3D path length, or zero for an empty path.
  */
 export declare const pathLength: (
-  path: readonly Vector3[],
+  path: readonly Vector3Tuple[],
   limits?: Partial<GeometrySamplingLimits>,
 ) => number;
 
@@ -1897,9 +2004,9 @@ export declare const pathLength: (
  * @returns A finite guide vector that is not parallel to the local path tangent.
  */
 export declare type PathNormalGuide = (
-  point: Vector3,
+  point: Vector3Tuple,
   index: number,
-) => Vector3;
+) => Vector3Tuple;
 
 /** Equal physical arc-length placements along an open or implicitly closed sampled path. */
 export declare interface PathPatternOptions {
@@ -1917,17 +2024,29 @@ export declare interface PathPatternOptions {
  * Explicit sampling ceilings bound both input points and output placements.
  */
 export declare function pathPatternTransforms(
-  path: readonly Vector3[],
+  path: readonly Vector3Tuple[],
   options: PathPatternOptions,
   limits?: Partial<GeometrySamplingLimits>,
-): readonly Transform3[];
+): readonly Transform3Matrix[];
 
 /** Position and unit tangent for one path-distributed item. */
 export declare interface PathPlacement {
   /** Interpolated point on the sampled path. */
-  readonly position: Vector3;
+  readonly position: Vector3Tuple;
   /** Unit tangent of the path segment containing the placement. */
-  readonly tangent: Vector3;
+  readonly tangent: Vector3Tuple;
+}
+
+/** A fixed XY point in world coordinates; omitted pivots use the coordinate origin. */
+export declare interface Pivot2Options {
+  /** World-space point left fixed by rotation or scaling. */
+  readonly pivot?: Vector2Input;
+}
+
+/** A fixed XYZ point in world coordinates; omitted pivots use the coordinate origin. */
+export declare interface Pivot3Options {
+  /** World-space point left fixed by rotation or scaling. */
+  readonly pivot?: Vector3Input;
 }
 
 /** Stable reason why planar optimization returned the original mesh unchanged. */
@@ -2008,7 +2127,7 @@ export declare interface PlanarPatchQuality {
   /** Smallest interior triangle angle in degrees. */
   readonly minimumTriangleAngleDegrees: number;
   /** Consistently wound unit normal for the patch plane. */
-  readonly normal: Vector3;
+  readonly normal: Vector3Tuple;
   /** Plane offset in `dot(normal, position) = planeOffset` form, in model units. */
   readonly planeOffset: number;
   /** Total patch area in squared model units. */
@@ -2026,7 +2145,7 @@ export declare interface PlanarPatchQuality {
  * their duplicated closing point. Holes must lie inside `outer` and must not
  * intersect each other or the exterior.
  */
-export declare interface Polygon {
+export declare interface PolygonData {
   /** Clockwise interior boundaries, each omitting its duplicated closing point. */
   readonly holes: readonly Contour[];
   /** Counter-clockwise exterior boundary, omitting its duplicated closing point. */
@@ -2178,7 +2297,7 @@ export declare interface ProfiledEdgeTreatment {
    * First coordinates decrease and second coordinates increase. Cylinder/extrusion ends use
    * cap inset first, side setback second; planar corners use incoming then outgoing edges.
    */
-  readonly profile: readonly Vector2[];
+  readonly profile: readonly Vector2Tuple[];
 }
 
 /** An identified line, circular arc, or cubic Bézier between corresponding landmarks. */
@@ -2194,15 +2313,15 @@ export declare type ProfileSpan2 = {
       /** Selects a straight span. */
       readonly kind: "line";
       /** Start point in millimetres. */
-      readonly start: Vector2;
+      readonly start: Vector2Tuple;
       /** End point in millimetres. */
-      readonly end: Vector2;
+      readonly end: Vector2Tuple;
     }
   | {
       /** Selects the geometric curve or span family. */
       readonly kind: "arc";
       /** Center point in millimetres. */
-      readonly center: Vector2;
+      readonly center: Vector2Tuple;
       /** Circular radius in millimetres. */
       readonly radius: number;
       /** Initial counterclockwise angle in degrees. */
@@ -2214,21 +2333,21 @@ export declare type ProfileSpan2 = {
       /** Selects a cubic Bézier span with the same coordinates as CubicBezierCurve2. */
       readonly kind: "cubic";
       /** Start point in millimetres. */
-      readonly start: Vector2;
+      readonly start: Vector2Tuple;
       /** First control point in millimetres. */
-      readonly control1: Vector2;
+      readonly control1: Vector2Tuple;
       /** Second control point in millimetres. */
-      readonly control2: Vector2;
+      readonly control2: Vector2Tuple;
       /** End point in millimetres. */
-      readonly end: Vector2;
+      readonly end: Vector2Tuple;
     }
 );
 
 /** Removes the component parallel to a normalized plane normal. */
 export declare const projectOntoPlane3: (
-  vector: Vector3,
-  normal: Vector3,
-) => Vector3;
+  vector: Vector3Tuple,
+  normal: Vector3Tuple,
+) => Vector3Tuple;
 
 /** Resolved pitch-line dimensions for a finite rack segment. */
 export declare interface RackPitchDimensions {
@@ -2275,21 +2394,19 @@ export declare interface RadialPatternOptions {
   /** Number of solids to return, including the original. */
   readonly count: number;
   /** Axis of the right-handed rotation. Its magnitude is ignored. */
-  readonly axis: Vector3;
+  readonly axis: Vector3Tuple;
   /** Signed rotation from one copy to the next, in degrees. */
   readonly angleDegrees: number;
   /** Rotation center in world coordinates. Defaults to the origin. */
-  readonly center?: Vector3;
+  readonly center?: Vector3Tuple;
 }
 
 /** Rotations about an explicit axis; angles use degrees and the first placement is identity. */
 export declare function radialPatternTransforms(
   options: RadialPatternOptions,
-): readonly Transform3[];
+): readonly Transform3Matrix[];
 
-/**
- * Radial dimensions refer to polygon vertices or compensate faceting to meet polygon faces.
- */
+/** Radial dimensions refer to polygon vertices or compensate faceting to meet polygon faces. */
 export declare type RadialSizing = "vertex" | "face";
 
 /**
@@ -2319,7 +2436,7 @@ export declare function rectangleContour(
  */
 export declare interface RectangleContourOptions {
   /** Positive uniform size or explicit XY extents in millimetres. */
-  readonly size: number | Vector2;
+  readonly size: number | Vector2Tuple;
   /** Center on XY; otherwise the minimum corner is the origin. Defaults to true. */
   readonly center?: boolean;
   /** Uniform treatment or four corner treatments. Exact round segments describe a complete circle and must divide by four. */
@@ -2362,9 +2479,6 @@ export declare interface RectangleProfileOptions extends RectangleContourOptions
   readonly id?: string;
 }
 
-/** A two-dimensional region represented by disjoint filled polygons. */
-export declare type Region = readonly Polygon[];
-
 /**
  * Returns the total filled area of a normalized region in square millimetres.
  *
@@ -2375,10 +2489,13 @@ export declare type Region = readonly Polygon[];
  * @param region - Normalized disjoint polygons with CCW outers and clockwise holes.
  * @returns Total filled area in square millimetres.
  */
-export declare function regionArea(region: Region): number;
+export declare function regionArea(region: RegionData): number;
 
 /** Returns finite axis-aligned bounds for a non-empty region. */
-export declare function regionBounds(region: Region): Bounds2;
+export declare function regionBounds(region: RegionData): Bounds2;
+
+/** A two-dimensional region represented by disjoint filled polygons. */
+export declare type RegionData = readonly PolygonData[];
 
 /**
  * Creates a centered CCW point loop with vertex or face radial sizing and an implicit seam.
@@ -2390,7 +2507,7 @@ export declare function regionBounds(region: Region): Bounds2;
  */
 export declare const regularPolygonContour: (
   options: RegularPolygonContourOptions,
-) => readonly Vector2[];
+) => readonly Vector2Tuple[];
 
 /** Exact regular polygon dimensions and counterclockwise degree rotation. */
 export declare interface RegularPolygonContourOptions extends RadialSizingOptions {
@@ -2410,7 +2527,7 @@ export declare interface RegularPolygonContourOptions extends RadialSizingOption
  * ```
  */
 export declare function resamplePolyline2(
-  path: readonly Vector2[],
+  path: readonly Vector2Tuple[],
   options?: PolylineResamplingOptions,
 ): SampledCurve2;
 
@@ -2426,7 +2543,7 @@ export declare function resamplePolyline2(
  * ```
  */
 export declare function resamplePolyline3(
-  path: readonly Vector3[],
+  path: readonly Vector3Tuple[],
   options?: PolylineResamplingOptions,
 ): SampledCurve3;
 
@@ -2478,7 +2595,7 @@ export declare function resolveAlignedCircularSegments(
 export declare function resolveArcSegments(
   radius: number,
   angleDegrees: number,
-  policy?: GeometryResolution,
+  policy?: CircularResolutionOptions,
   limits?: Partial<GeometrySamplingLimits>,
 ): number;
 
@@ -2486,7 +2603,8 @@ export declare function resolveArcSegments(
  * 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
+ * physical error criteria is used. Face sizing bounds the circumscribed polygon's outward
+ * excess and actual edge length. A safety cap that would violate either criterion raises
  * `COMPLEXITY_LIMIT` rather than silently reducing quality.
  *
  * @param radius - Circle radius in millimetres.
@@ -2504,7 +2622,7 @@ export declare function resolveArcSegments(
  */
 export declare function resolveCircularSegments(
   radius: number,
-  policy?: GeometryResolution,
+  policy?: CircularResolutionOptions,
   limits?: Partial<GeometrySamplingLimits>,
 ): number;
 
@@ -2559,7 +2677,7 @@ export declare interface ResolvedGeometryTolerance {
  * @returns Number of intermediate copies, excluding the two end profiles.
  */
 export declare function resolveExtrusionDivisions(
-  profile: Contour | Region,
+  profile: Contour | RegionData,
   height: number,
   options?: ExtrusionSamplingOptions,
 ): number;
@@ -2635,7 +2753,7 @@ export declare function reverseTriangleMesh(mesh: TriangleMesh): TriangleMesh;
  * ```
  */
 export declare const revolveMesh: (
-  profile: readonly Vector2[],
+  profile: readonly Vector2Tuple[],
   options?: RevolveOptions,
 ) => TriangleMesh;
 
@@ -2654,12 +2772,14 @@ export declare interface RevolveOptions extends CircularPrimitiveOptions {
   readonly limits?: Partial<ModelingLimits>;
 }
 
-/** Rotates a vector right-handed around an axis by `angle` radians. */
-export declare const rotateAroundAxis3: (
-  vector: Vector3,
-  axis: Vector3,
-  angle: number,
-) => Vector3;
+/**
+ * Rotates a finite vector counter-clockwise in XY by `degrees` about the origin.
+ * Throws `NON_FINITE_VALUE` for nonfinite coordinates, angles, or derived coordinates.
+ */
+export declare const rotate2: (
+  vector: Vector2Tuple,
+  degrees: number,
+) => Vector2Tuple;
 
 /**
  * Creates a right-handed axis-angle rotation transform.
@@ -2670,10 +2790,10 @@ export declare const rotateAroundAxis3: (
  * @returns A frozen row-major transform.
  */
 export declare function rotationTransform3(
-  axis: Vector3,
+  axis: Vector3Tuple,
   angle: AxisAngleRotation3,
   tolerance?: GeometryToleranceOptions,
-): Transform3;
+): Transform3Matrix;
 
 /**
  * Replaces each vertex of a non-duplicated closed polyline with a sampled
@@ -2685,11 +2805,11 @@ export declare function rotationTransform3(
  * Coordinates and radius must be finite; input and output are each limited by maxPathPoints (default 100000).
  */
 export declare const roundClosedPolylinePath: (
-  points: readonly Vector3[],
+  points: readonly Vector3Tuple[],
   radius: number,
   segmentsPerCorner: number,
   limits?: Partial<GeometrySamplingLimits>,
-) => readonly Vector3[];
+) => readonly Vector3Tuple[];
 
 /**
  * A circular edge or corner roundover with explicit physical sampling.
@@ -2793,9 +2913,9 @@ export declare function sampleCylindricalGearOutline(
 /** Immutable planar points and corresponding directed unit tangents. */
 export declare interface SampledCurve2 {
   /** Curves retain both endpoints, including full-circle seams; closed resampling omits its seam. */
-  readonly points: readonly Vector2[];
+  readonly points: readonly Vector2Tuple[];
   /** Directed unit vectors; stationary derivatives use the nearest usable direction. */
-  readonly tangents: readonly Vector2[];
+  readonly tangents: readonly Vector2Tuple[];
 }
 
 /**
@@ -2803,9 +2923,9 @@ export declare interface SampledCurve2 {
  */
 export declare interface SampledCurve3 {
   /** Curves retain both endpoints, including full-circle seams; closed resampling omits its seam. */
-  readonly points: readonly Vector3[];
+  readonly points: readonly Vector3Tuple[];
   /** Directed unit vectors; stationary derivatives use the nearest usable direction. */
-  readonly tangents: readonly Vector3[];
+  readonly tangents: readonly Vector3Tuple[];
 }
 
 /** Sampled paths plus conventional pitch and lead measurements. */
@@ -2832,7 +2952,7 @@ export declare const sampleHelix: ({
   segments,
   limits,
   axialWeight,
-}: SampleHelixOptions) => readonly Vector3[];
+}: SampleHelixOptions) => readonly Vector3Tuple[];
 
 /** Options for a sampled +Z helix with millimetre dimensions. */
 export declare interface SampleHelixOptions {
@@ -2903,7 +3023,7 @@ export declare function sampleRackToothPath(
 export declare function sampleSideProfile(
   curve: SideProfileCurve,
   options?: SampleSideProfileOptions,
-): readonly Vector2[];
+): readonly Vector2Tuple[];
 
 /** Physical scaling and bounded adaptive subdivision for an open profile. */
 export declare interface SampleSideProfileOptions {
@@ -2942,6 +3062,12 @@ export declare function sampleThreadHelices(
   options: ThreadHelixOptions,
 ): SampledThreadHelices;
 
+/** Multiplies a vector by a dimensionless scalar. */
+export declare const scale2: (
+  vector: Vector2Tuple,
+  scale: number,
+) => Vector2Tuple;
+
 /**
  * Multiplies a vector by a dimensionless scalar.
  * @example
@@ -2949,7 +3075,10 @@ export declare function sampleThreadHelices(
  * scale3([1, 2, 3], 2); // [2, 4, 6]
  * ```
  */
-export declare const scale3: (vector: Vector3, scale: number) => Vector3;
+export declare const scale3: (
+  vector: Vector3Tuple,
+  scale: number,
+) => Vector3Tuple;
 
 /**
  * Creates an immutable axis-aligned scale transform.
@@ -2960,7 +3089,9 @@ export declare const scale3: (vector: Vector3, scale: number) => Vector3;
  * @param factors - Finite, non-zero XYZ scale factors.
  * @returns A frozen row-major transform.
  */
-export declare function scaleTransform3(factors: Vector3): Transform3;
+export declare function scaleTransform3(
+  factors: Vector3Tuple,
+): Transform3Matrix;
 
 /** An open radius/height outline; consumers own closure, mounting geometry, and wall policy. */
 export declare interface SideProfileCurve {
@@ -3066,7 +3197,7 @@ export declare const starContour: (
   points: number,
   innerRadius?: number,
   limits?: Partial<GeometrySamplingLimits>,
-) => readonly Vector2[];
+) => readonly Vector2Tuple[];
 
 /** End-cap treatment for an open stroked path. */
 export declare type StrokePathCap = "butt" | "round" | "square";
@@ -3085,9 +3216,9 @@ export declare type StrokePathJoin = "bevel" | "miter" | "round";
 export declare function strokePathRegion(
   path: Path2,
   options: StrokePathRegionOptions,
-): Region;
+): RegionData;
 
-/** Physical stroke and topology controls for {@link strokePathRegion}. */
+/** Physical stroke and topology controls shared by pure regions and native Sections. */
 export declare interface StrokePathRegionOptions {
   /** Explicit path, circular and expanded-profile allocation ceilings. */
   readonly limits?: Partial<GeometrySamplingLimits>;
@@ -3103,6 +3234,12 @@ export declare interface StrokePathRegionOptions {
   readonly width: number;
 }
 
+/** Subtracts `b` from `a` component-wise. */
+export declare const subtract2: (
+  a: Vector2Tuple,
+  b: Vector2Tuple,
+) => Vector2Tuple;
+
 /**
  * Subtracts `b` from `a`.
  * @example
@@ -3110,7 +3247,10 @@ export declare interface StrokePathRegionOptions {
  * subtract3([4, 5, 6], [1, 2, 3]); // [3, 3, 3]
  * ```
  */
-export declare const subtract3: (a: Vector3, b: Vector3) => Vector3;
+export declare const subtract3: (
+  a: Vector3Tuple,
+  b: Vector3Tuple,
+) => Vector3Tuple;
 
 /** Sampling controls for deterministic SVG-to-region conversion. */
 export declare interface SvgImportOptions {
@@ -3134,7 +3274,7 @@ export declare interface SvgRegionPreflight {
   /** Appearance-preserving cleanup observed during parsing and normalization. */
   readonly repairs: SvgRegionPreflightRepairs;
   /** Canonical millimetre, Y-up geometry. */
-  readonly region: Region;
+  readonly region: RegionData;
   /** Bounded source and flattening complexity measurements. */
   readonly source: SvgRegionPreflightSourceMetrics;
 }
@@ -3200,7 +3340,7 @@ export declare interface SvgRegionPreflightSourceMetrics {
  */
 export declare function sweepMesh(
   profile: Contour,
-  path: readonly Vector3[],
+  path: readonly Vector3Tuple[],
   options?: SweepOptions,
 ): TriangleMesh;
 
@@ -3221,7 +3361,7 @@ export declare interface SweepOptions {
   /** Twist advances by physical path length (default), or normalized authored station position, including a closed seam gap. */
   readonly twistBy?: "length" | "stations";
   /** Positive uniform/XY scale, or one XY pair per path station. Defaults to one. */
-  readonly scale?: number | Vector2 | readonly Vector2[];
+  readonly scale?: number | Vector2Tuple | readonly Vector2Tuple[];
   /** Corresponding point-index advance at a rotationally equivalent closed seam. */
   readonly seamProfileOffset?: number;
 }
@@ -3234,13 +3374,13 @@ export declare type SweepOrientation =
       /** Minimizes frame rotation by parallel transport. */
       readonly kind: "transport";
       /** Initial profile +X guide, projected perpendicular to the first tangent. */
-      readonly initialNormal?: Vector3;
+      readonly initialNormal?: Vector3Tuple;
     }
   | {
       /** Projects one fixed world-space normal at every path station. */
       readonly kind: "fixed-normal";
       /** Directed profile +X guide; must not be parallel to any local tangent. */
-      readonly normal: Vector3;
+      readonly normal: Vector3Tuple;
     }
   | {
       /** Uses an explicitly directed normal callback at each original normalized station. */
@@ -3451,7 +3591,7 @@ export declare interface ThreadProfile {
   /** Adjacent axial thread spacing in millimetres. */
   readonly pitch: number;
   /** Immutable open `[axial, radial]` path spanning one pitch. */
-  readonly points: readonly Vector2[];
+  readonly points: readonly Vector2Tuple[];
   /** Axial width of the flat at the minor envelope. */
   readonly rootFlatWidth: number;
 }
@@ -3496,13 +3636,116 @@ export declare interface TorusOptions extends PrimitivePlacement {
   readonly resolution?: GeometryResolution;
 }
 
+/** Immutable reusable XY placement. Methods apply in written order; angles are degrees. */
+export declare interface Transform2 {
+  /** Applies a translation in model units after this placement. */
+  translate(offset: Vector2Input): Transform2;
+  /** Rotates counterclockwise in degrees about an optional world-space pivot (default origin). */
+  rotate(degrees: number, options?: Pivot2Options): Transform2;
+  /** Scales about an optional world-space pivot; finite nonzero factors may reflect. */
+  scale(factors: number | Vector2Input, options?: Pivot2Options): Transform2;
+  /** Applies this placement first, then `next`; neither operand is mutated. */
+  andThen(next: Transform2Input): Transform2;
+  /** Returns the inverse; singular and numerically unstable transforms throw GeometryError. */
+  inverse(): Transform2;
+  /** Transforms a finite point, including translation. Returns a fresh immutable vector. */
+  applyPoint(point: Vector2Input): Vector2;
+  /** Transforms a finite direction, excluding translation and retaining scale. This is not a normal transform. */
+  applyDirection(direction: Vector2Input): Vector2;
+  /** Applies the inverse transpose and normalizes. Ignores translation; rejects zero normals. */
+  applyNormal(normal: Vector2Input): Vector2;
+  /** Returns the frozen canonical row-major 3x3 matrix for interchange. */
+  toMatrix(): Transform2Matrix;
+  /** Embeds this placement in XYZ, leaving Z unchanged, for solids and 3D paths. */
+  to3D(): Transform3;
+}
+
+/**
+ * Creates an immutable XY transform, identity by default. Matrices are copied and validated.
+ * Pass it directly to Section.transform() and planar data helpers; to3D() explicitly crosses into XYZ.
+ * Zero scales and singular matrices throw GeometryError; negative scales reflect.
+ *
+ * @example
+ * ```ts
+ * const placement = transform2().rotate(90).translate([10, 0]);
+ * placement.applyPoint([1, 0]).toArray(); // approximately [10, 1]
+ * ```
+ */
+export declare function transform2(matrix?: Transform2Matrix): Transform2;
+
+/** An immutable XY transform or its canonical row-major matrix for interchange. */
+export declare type Transform2Input = Transform2 | Transform2Matrix;
+
+/**
+ * A row-major affine 3x3 XY matrix applied to column vectors.
+ * Translation occupies indices 2 and 5; the final row is `[0, 0, 1]`.
+ */
+export declare type Transform2Matrix = readonly [
+  m00: number,
+  m01: number,
+  m02: number,
+  m10: number,
+  m11: number,
+  m12: number,
+  m20: number,
+  m21: number,
+  m22: number,
+];
+
+/** Immutable reusable XYZ placement. Methods apply in written order; angles are degrees. */
+export declare interface Transform3 {
+  /** Applies a translation in model units after this placement. */
+  translate(offset: Vector3Input): Transform3;
+  /** Rotates about global X, then Y, then Z in degrees, about an optional world-space pivot. */
+  rotate(degrees: Vector3Input, options?: Pivot3Options): Transform3;
+  /** Rotates right-handed in degrees about a nonzero axis and optional world-space pivot. */
+  rotateAxis(
+    axis: Vector3Input,
+    degrees: number,
+    options?: Pivot3Options,
+  ): Transform3;
+  /** Scales about an optional world-space pivot; finite nonzero factors may reflect. */
+  scale(factors: number | Vector3Input, options?: Pivot3Options): Transform3;
+  /** Applies this placement first, then `next`; equivalent to composeTransform3(next, current). */
+  andThen(next: Transform3Input): Transform3;
+  /** Returns the inverse; singular and numerically unstable transforms throw GeometryError. */
+  inverse(): Transform3;
+  /** Transforms a finite point, including translation. Returns a fresh immutable vector. */
+  applyPoint(point: Vector3Input): Vector3;
+  /** Transforms a finite direction, excluding translation and retaining scale. This is not a normal transform. */
+  applyDirection(direction: Vector3Input): Vector3;
+  /** Applies the inverse transpose and normalizes. Ignores translation; rejects zero normals. */
+  applyNormal(normal: Vector3Input): Vector3;
+  /** Returns the frozen canonical row-major 4x4 matrix for interchange. */
+  toMatrix(): Transform3Matrix;
+  /** Restricts to XY; throws GeometryError for a plane change or singular XY restriction. */
+  to2D(): Transform2;
+}
+
+/**
+ * Creates an immutable XYZ transform, identity by default. Matrices are copied and validated.
+ * Calls apply in written order; rotations use degrees and pivots use current world coordinates.
+ * Zero scales, singular matrices, nonfinite inputs and zero rotation axes throw GeometryError.
+ * Use frameTransform3(frame) as the input for existing orthonormal frame placement.
+ *
+ * @example
+ * ```ts
+ * const placement = transform3().rotate([0, 0, 90]).translate([10, 0, 0]);
+ * placement.applyPoint([1, 0, 0]).toArray(); // approximately [10, 1, 0]
+ * ```
+ */
+export declare function transform3(matrix?: Transform3Matrix): Transform3;
+
+/** An immutable XYZ transform or its canonical row-major matrix for interchange. */
+export declare type Transform3Input = Transform3 | Transform3Matrix;
+
 /**
  * A row-major affine 4x4 matrix applied to column vectors.
  *
  * Translation occupies indices 3, 7, and 11. The final row must be
  * `[0, 0, 0, 1]` within the active geometry tolerance.
  */
-export declare type Transform3 = readonly [
+export declare type Transform3Matrix = readonly [
   m00: number,
   m01: number,
   m02: number,
@@ -3522,13 +3765,13 @@ export declare type Transform3 = readonly [
 ];
 
 /**
- * Transforms a closed loop and preserves its original winding convention.
+ * Applies a canonical affine XY transform to a closed loop and preserves its original winding.
  *
  * Reflections reverse the point order automatically through normalization.
  */
 export declare function transformContour(
   loop: Contour,
-  transform: Transform3,
+  transform: Transform2Input,
   tolerance?: GeometryToleranceOptions,
 ): Contour;
 
@@ -3540,27 +3783,32 @@ export declare function transformContour(
  * @param transform - Valid affine transform.
  * @returns Signed linear determinant.
  */
-export declare function transformDeterminant3(transform: Transform3): number;
+export declare function transformDeterminant3(
+  transform: Transform3Matrix,
+): number;
 
-/** Applies an XY-plane-preserving affine transform to a 2D path. */
+/** Applies a canonical affine XY transform to a 2D path without changing point order. */
 export declare function transformPath2(
   path: Path2,
-  transform: Transform3,
+  transform: Transform2Input,
   tolerance?: GeometryToleranceOptions,
 ): Path2;
 
 /** Applies an affine transform to a 3D path without mutating its points. */
 export declare function transformPath3(
   path: Path3,
-  transform: Transform3,
+  placement: Transform3Input,
 ): Path3;
 
-/** Transforms an explicit outer/hole region with reflection-safe winding correction. */
-export declare function transformRegion(
-  region: Region,
-  transform: Transform3,
+/**
+ * Transforms serialized polygon data with reflection-safe winding, without an engine.
+ * Use Section.transform(placement) when authoring filled geometry; this utility serves pure data preparation.
+ */
+export declare function transformRegionData(
+  region: RegionData,
+  transform: Transform2Input,
   tolerance?: GeometryToleranceOptions,
-): Region;
+): RegionData;
 
 /**
  * Applies an affine transform to a mesh and preserves outward face orientation.
@@ -3574,7 +3822,7 @@ export declare function transformRegion(
  */
 export declare function transformTriangleMesh(
   mesh: TriangleMesh,
-  transform: Transform3,
+  transform: Transform3Matrix,
 ): TriangleMesh;
 
 /**
@@ -3583,7 +3831,9 @@ export declare function transformTriangleMesh(
  * @param offset - Finite XYZ translation in model units.
  * @returns A frozen row-major transform.
  */
-export declare function translationTransform3(offset: Vector3): Transform3;
+export declare function translationTransform3(
+  offset: Vector3Tuple,
+): Transform3Matrix;
 
 /** Trapezoidal thread profile with a configurable included angle. */
 export declare interface TrapezoidalThreadProfileSpec extends ThreadProfileBaseSpec {
@@ -3802,9 +4052,9 @@ export declare function validateSolidMesh(
  * @throws {@link GeometryError} For non-finite, non-affine, or singular matrices.
  */
 export declare function validateTransform3(
-  transform: Transform3,
+  transform: Transform3Matrix,
   tolerance?: GeometryToleranceOptions,
-): Transform3;
+): Transform3Matrix;
 
 /**
  * Validates mesh buffers, indices, triangle area, and optionally closed topology.
@@ -3823,11 +4073,97 @@ export declare function validateTriangleMesh(
   options?: TriangleMeshValidationOptions,
 ): TriangleMesh;
 
+/** Immutable XY arithmetic; vector operations return new values and measurements return numbers. */
+export declare interface Vector2 {
+  /** X coordinate in the vector's coordinate units. */
+  readonly x: number;
+  /** Y coordinate in the vector's coordinate units. */
+  readonly y: number;
+  /** Adds another vector component-wise. */
+  add(other: Vector2Input): Vector2;
+  /** Subtracts another vector component-wise. */
+  subtract(other: Vector2Input): Vector2;
+  /** Multiplies by a finite dimensionless scalar. */
+  scale(factor: number): Vector2;
+  /** Returns a unit vector; rejects length at or below finite nonnegative `epsilon` (default `1e-12`). */
+  normalize(epsilon?: number): Vector2;
+  /** Interpolates toward another vector by finite dimensionless `t`; extrapolation is allowed. */
+  lerp(other: Vector2Input, t: number): Vector2;
+  /** Returns the scalar dot product. */
+  dot(other: Vector2Input): number;
+  /** Returns the signed scalar cross product; positive means the other vector is counterclockwise. */
+  cross(other: Vector2Input): number;
+  /** Returns Euclidean length in the vector's coordinate units. */
+  length(): number;
+  /** Returns Euclidean distance to another vector in the same coordinate units. */
+  distance(other: Vector2Input): number;
+  /** Returns this value's frozen readonly tuple for interchange; repeated calls do not allocate. */
+  toArray(): Vector2Tuple;
+}
+
+/**
+ * Creates immutable XY arithmetic from a finite tuple or vector, snapshotting the coordinates.
+ * Values and results are finite. Invalid dimensions throw `INVALID_ARGUMENT`; nonfinite coordinates
+ * and overflow throw `NON_FINITE_VALUE` GeometryError.
+ * Use transform2().applyDirection(value) for rotations and nonuniform scaling.
+ */
+export declare function vector2(input: Vector2Input): Vector2;
+
+/** An XY tuple or immutable fluent vector accepted by vector operations. */
+export declare type Vector2Input = Vector2Tuple | Vector2;
+
 /** A two-dimensional Cartesian vector or point. */
-export declare type Vector2 = readonly [x: number, y: number];
+export declare type Vector2Tuple = readonly [x: number, y: number];
+
+/** Immutable XYZ arithmetic; vector operations return new values and measurements return numbers. */
+export declare interface Vector3 {
+  /** X coordinate in the vector's coordinate units. */
+  readonly x: number;
+  /** Y coordinate in the vector's coordinate units. */
+  readonly y: number;
+  /** Z coordinate in the vector's coordinate units. */
+  readonly z: number;
+  /** Adds another vector component-wise. */
+  add(other: Vector3Input): Vector3;
+  /** Subtracts another vector component-wise. */
+  subtract(other: Vector3Input): Vector3;
+  /** Multiplies by a finite dimensionless scalar. */
+  scale(factor: number): Vector3;
+  /** Returns a unit vector; rejects length at or below finite nonnegative `epsilon` (default `1e-12`). */
+  normalize(epsilon?: number): Vector3;
+  /** Interpolates toward another vector by finite dimensionless `t`; extrapolation is allowed. */
+  lerp(other: Vector3Input, t: number): Vector3;
+  /** Returns the scalar dot product. */
+  dot(other: Vector3Input): number;
+  /** Returns the right-handed cross product as a new vector. */
+  cross(other: Vector3Input): Vector3;
+  /** Returns Euclidean length in the vector's coordinate units. */
+  length(): number;
+  /** Returns Euclidean distance to another vector in the same coordinate units. */
+  distance(other: Vector3Input): number;
+  /** Returns this value's frozen readonly tuple for interchange; repeated calls do not allocate. */
+  toArray(): Vector3Tuple;
+}
+
+/**
+ * Creates immutable XYZ arithmetic from a finite tuple or vector, snapshotting the coordinates.
+ * Values and results are finite. Invalid dimensions throw `INVALID_ARGUMENT`; nonfinite coordinates
+ * and overflow throw `NON_FINITE_VALUE` GeometryError.
+ * Use transform3().applyDirection(value) for rotations and nonuniform scaling.
+ *
+ * @example
+ * ```ts
+ * const direction = vector3([1, 2, 3]).add([4, 0, 0]).normalize().scale(10);
+ * const alignment = direction.dot([0, 0, 1]);
+ * ```
+ */
+export declare function vector3(input: Vector3Input): Vector3;
+
+/** An XYZ tuple or immutable fluent vector accepted by vector operations. */
+export declare type Vector3Input = Vector3Tuple | Vector3;
 
 /** A three-dimensional Cartesian vector or point. */
-export declare type Vector3 = readonly [x: number, y: number, z: number];
+export declare type Vector3Tuple = readonly [x: number, y: number, z: number];
 
 /** A circular baseline centered at the XY origin, with rigid shaped glyph groups. */
 export declare interface VectorTextArcBaseline {