@metamesh/modeling 0.13.0 → 0.15.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.
@@ -33,12 +38,12 @@ export declare interface AlignedCircularSegmentsOptions {
    * Additional full-circle segment floor, as a safe integer of at least three.
    * @defaultValue `3`
    */
-  readonly minimumSegments?: number;
+  readonly minSegments?: number;
   /**
    * Exact full-circle segment count.
    *
    * This takes precedence over `resolution.circularSegments` and adaptive sampling, and must
-   * already satisfy every alignment factor and `minimumSegments`.
+   * already satisfy every alignment factor and `minSegments`.
    */
   readonly segments?: number;
   /** Operation-level physical tessellation policy over the active model-wide policy. */
@@ -84,17 +89,37 @@ 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;
 }
 
+/**
+ * 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 declare function anchor3(
+  position: Vector3Input,
+  direction: Vector3Input,
+  up?: Vector3Input,
+  tolerance?: GeometryToleranceOptions,
+): Anchor3;
+
 /**
  * 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 anchor - Anchor created by {@link anchor3} or equivalent valid data.
  * @param tolerance - Optional comparison overrides.
  * @returns A normalized right-handed frame at the anchor position.
  */
@@ -113,9 +138,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,22 +150,22 @@ 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. */
-  readonly startDegrees?: number;
+  readonly startAngle?: number;
   /** Nonzero signed sweep in degrees, bounded to one complete turn. */
-  readonly sweepDegrees: number;
+  readonly sweepAngle: number;
 }
 
 /** Spatial circular arc in the plane of two orthogonal unit directions. */
@@ -148,17 +173,17 @@ 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;
+  readonly startAngle?: number;
   /** Nonzero signed sweep in degrees, bounded to one complete turn. */
-  readonly sweepDegrees: number;
+  readonly sweepAngle: number;
 }
 
 /**
@@ -175,20 +200,20 @@ export declare interface ArcCurve3 {
  * @returns A frozen affine transform for the moving object.
  * @throws {@link GeometryError} For invalid anchors or non-finite options.
  */
-export declare function attachTransform(
+export declare function attachmentTransform3(
   source: Anchor3,
   target: Anchor3,
-  options?: AttachTransformOptions,
-): Transform3;
+  options?: AttachOptions,
+): Transform3Matrix;
 
 /** Options controlling how one anchor is attached to another. */
-export declare interface AttachTransformOptions {
+export declare interface AttachOptions {
   /** Align outward directions face-to-face (`opposed`) or in parallel (`same`). */
   readonly alignment?: "opposed" | "same";
   /** Separation along the target anchor's outward direction in model units. */
   readonly gap?: number;
-  /** Additional right-handed roll about the attached direction, in radians. */
-  readonly spinRadians?: number;
+  /** Additional right-handed roll about the attached direction, in degrees. */
+  readonly spin?: number;
   /** Optional numeric comparison overrides. */
   readonly tolerance?: GeometryToleranceOptions;
 }
@@ -213,31 +238,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 +272,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 +285,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 +302,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 +320,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. */
@@ -330,7 +355,7 @@ export declare type BoxEdgeTreatments = Readonly<
 /**
  * Dimensions, placement, and uniform or independently selected finishing for an axis-aligned box.
  */
-export declare interface BoxOptions extends PrimitivePlacement {
+export declare interface BoxOptions extends PrimitiveAttachment {
   /** Explicit sampling ceilings for edge treatments, bounded by the host policy. */
   readonly limits?: Partial<GeometrySamplingLimits>;
   /**
@@ -339,33 +364,11 @@ 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;
 }
 
-/**
- * Builds closed thread-ridge components with every profile locked to the
- * shaft's radial/axial frame. The mesh is intended for union with its
- * minor-envelope cylinder and never owns WASM objects.
- */
-export declare function buildHelicalThreadRidgeMesh(
-  options: HelicalThreadRidgeMeshOptions,
-): TriangleMesh;
-
-/**
- * Builds one closed threaded cylinder without a ridge/core Boolean seam.
- *
- * Each circular facet includes its exact phase-shifted profile breakpoints, including duplicate-Z
- * samples for vertical flanks and blunt transitions. Adjacent variable grids are stitched as a
- * monotone strip, with optional intermediate rows bounded by physical `maxSegmentLength`. A
- * conservative pre-allocation estimate rejects excessive meshes before constructing position
- * arrays.
- */
-export declare function buildHelicalThreadSolidMesh(
-  options: HelicalThreadSolidMeshOptions,
-): TriangleMesh;
-
 /** Axial side carrying the near-normal pressure flank of a buttress thread. */
 export declare type ButtressPressureFlankSide = "negative" | "positive";
 
@@ -443,6 +446,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. */
@@ -464,7 +473,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 +540,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.
@@ -542,10 +551,13 @@ export declare function composeTransform3(
  * normal back to the first tangent measures seam holonomy; distributing that residual rotation
  * uniformly over all path intervals avoids a visible seam or accumulated frame flip.
  * The maxPathPoints ceiling (default 100000) bounds path points and frames.
+ * Requires closed path values; raw tuples are interpreted as closed and must omit their seam point.
+ * Invalid paths throw GeometryError.
+ * Nonfinite initial normals reject; finite parallel preferences select a canonical fallback.
  */
 export declare const computeClosedParallelTransportFrames: (
-  path: readonly Vector3[],
-  initialNormal?: Vector3,
+  input: Path3Input,
+  initialNormal?: Vector3Input,
   limits?: Partial<GeometrySamplingLimits>,
 ) => readonly PathFrame[];
 
@@ -553,10 +565,12 @@ export declare const computeClosedParallelTransportFrames: (
  * Builds rotation-minimizing frames by parallel-transporting the previous normal.
  * This avoids the sudden profile flips produced by picking a fresh up-vector per ring.
  * Paths exceeding maxPathPoints (default 100000) reject before frame allocation or guide evaluation.
+ * Requires open path values; raw tuples are interpreted as an open path. Invalid paths throw GeometryError.
+ * Nonfinite normals and guide results reject. A finite initial guide parallel to the tangent selects a canonical fallback.
  */
 export declare const computeParallelTransportFrames: (
-  path: readonly Vector3[],
-  initialNormal?: Vector3,
+  input: Path3Input,
+  initialNormal?: Vector3Input,
   normalGuide?: PathNormalGuide,
   limits?: Partial<GeometrySamplingLimits>,
 ) => readonly PathFrame[];
@@ -572,7 +586,24 @@ export declare const computeParallelTransportFrames: (
  */
 export declare function computeTriangleMeshCentroid(
   mesh: TriangleMesh,
-): Vector3;
+): Vector3Tuple;
+
+/**
+ * Creates an order-independent regression signature for a manufacturing mesh.
+ *
+ * The input must be non-empty, closed, consistently wound, and have no unreferenced vertices.
+ * Vertex and triangle order do not affect the fingerprint; winding, quantized geometry, and
+ * connectivity metrics do. The fingerprint is a regression aid, not a cryptographic digest.
+ *
+ * @param mesh - Closed oriented mesh to measure without mutation.
+ * @param options - Absolute quantization and complexity limits.
+ * @returns Compact counts, bounds, volume, topology, tolerances, and canonical fingerprint.
+ * @throws {@link GeometryError} When validation, topology, tolerance, or complexity checks fail.
+ */
+export declare function computeTriangleMeshSignature(
+  mesh: TriangleMesh,
+  options?: TriangleMeshSignatureOptions,
+): TriangleMeshSignature;
 
 /** Tests actual XY containment, including touching boundaries; dimensions must match. */
 export declare function containsBounds(outer: Bounds2, inner: Bounds2): boolean;
@@ -586,12 +617,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. */
@@ -661,58 +692,8 @@ export declare type CorrespondingProfileStation = LoftPlacement & {
   readonly profile: CorrespondingProfile;
 };
 
-/**
- * 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 declare function createAnchor3(
-  position: Vector3,
-  direction: Vector3,
-  up?: Vector3,
-  tolerance?: GeometryToleranceOptions,
-): Anchor3;
-
-/**
- * Creates a periodic thread profile for the shaft-locked helical mesher.
- *
- * The open path spans one pitch. Radial zero is the major envelope; negative
- * values point toward the shaft. Custom paths must be finite, axially
- * non-decreasing, periodic at their endpoints, and reach radial zero.
- *
- * @example Printable triangular thread profile
- * ```ts
- * createThreadProfile({ kind: "triangular", pitch: 1.75 });
- * ```
- */
-export declare function createThreadProfile(
-  spec: ThreadProfileSpec,
-): ThreadProfile;
-
-/**
- * Creates an order-independent regression signature for a manufacturing mesh.
- *
- * The input must be non-empty, closed, consistently wound, and have no unreferenced vertices.
- * Vertex and triangle order do not affect the fingerprint; winding, quantized geometry, and
- * connectivity metrics do. The fingerprint is a regression aid, not a cryptographic digest.
- *
- * @param mesh - Closed oriented mesh to measure without mutation.
- * @param options - Absolute quantization and complexity limits.
- * @returns Compact counts, bounds, volume, topology, tolerances, and canonical fingerprint.
- * @throws {@link GeometryError} When validation, topology, tolerance, or complexity checks fail.
- */
-export declare function createTriangleMeshSignature(
-  mesh: TriangleMesh,
-  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.
@@ -721,20 +702,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,21 +725,15 @@ 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[],
-  limits?: Partial<GeometrySamplingLimits>,
-) => readonly number[];
-
 /** Reusable planar curve definition. */
 export declare type Curve2 = LineCurve2 | ArcCurve2 | CubicBezierCurve2;
 
@@ -776,7 +751,7 @@ export declare interface CurveSamplingOptions {
   /** Millimetre sampling policy; circularSegments applies only to arcs. */
   readonly resolution?: GeometryResolution;
   /** Output vertex ceiling of at least two; may only lower limits.maxPathPoints. */
-  readonly maximumVertices?: number;
+  readonly maxVertices?: number;
   /** Explicit sampling ceilings; omitted values use package defaults without ambient state. */
   readonly limits?: Partial<GeometrySamplingLimits>;
 }
@@ -789,7 +764,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.
@@ -812,11 +787,11 @@ export declare interface CylinderAnchorOptions {
   /** Named outward face; side anchors lie halfway up the cylinder. */
   readonly face: CylinderAnchorFace;
   /** Side angle counter-clockwise from +X, in degrees; defaults to zero. */
-  readonly angleDegrees?: number;
+  readonly angle?: number;
   /** 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;
 }
 
 /**
@@ -824,7 +799,7 @@ export declare interface CylinderAnchorOptions {
  */
 export declare type CylinderOptions = CircularPrimitiveOptions &
   RadialSizingOptions &
-  PrimitivePlacement & {
+  PrimitiveAttachment & {
     /**
      * Centers the solid on the Z origin when `true`; otherwise its bottom is at `Z = 0`.
      * @defaultValue `true`
@@ -856,7 +831,7 @@ export declare interface CylindricalGearDimensions {
   /** Addendum above the pitch circle, in millimetres. */
   readonly addendum: number;
   /** Angular pitch between adjacent teeth, in radians. */
-  readonly angularPitch: number;
+  readonly angularPitchRadians: number;
   /** Tangential backlash applied to this gear, in millimetres. */
   readonly backlash: number;
   /** Base-circle radius used by the involute, in millimetres. */
@@ -923,7 +898,7 @@ export declare interface CylindricalGearPairDimensions {
   /** Absolute driven-to-driver tooth-count ratio. */
   readonly ratio: number;
   /** Helix angle required on the driven member for conjugate teeth, in degrees. */
-  readonly requiredDrivenHelixAngleDegrees: number;
+  readonly requiredDrivenHelixAngle: number;
 }
 
 /** Sampling controls for one coupled internal-gear tooth cycle. */
@@ -959,7 +934,7 @@ export declare interface CylindricalGearPairSpec {
 /**
  * Nominal dimensions for a standard full-depth cylindrical involute gear.
  *
- * Lengths use millimetres. `module` and `pressureAngleDegrees` are measured in
+ * Lengths use millimetres. `module` and `pressureAngle` are measured in
  * the normal plane; a non-zero signed helix angle is converted to transverse
  * pitch-plane dimensions. Positive and negative helix angles identify
  * opposite hands but produce the same 2D pitch geometry.
@@ -970,11 +945,11 @@ export declare interface CylindricalGearSpec {
   /** Dedendum clearance as a multiple of normal module; defaults to `0.25`. */
   readonly clearanceFactor?: number;
   /** Signed helix angle in degrees; zero creates a spur pitch system. */
-  readonly helixAngleDegrees?: number;
+  readonly helixAngle?: number;
   /** Normal module in millimetres per tooth. */
   readonly module: number;
   /** Normal pressure angle in degrees; defaults to 20 degrees. */
-  readonly pressureAngleDegrees?: number;
+  readonly pressureAngle?: number;
   /** Integer tooth count from 6 through 1,000; external profiles also enforce the no-undercut limit. */
   readonly toothCount: number;
 }
@@ -992,6 +967,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.
  *
@@ -999,14 +980,19 @@ export declare const defaultGeometrySamplingLimits: GeometrySamplingLimits;
  * open paths include both endpoints when `count` is greater than one.
  * Coordinates and total length must be finite. Input points and output placements are each
  * limited by maxPathPoints (default 100000); exact counts exceeding that ceiling reject before length calculation.
+ * Closure defaults to the path value's metadata, or false for tuples. An explicit conflicting closure rejects.
+ * Invalid arguments and degenerate paths throw GeometryError.
  */
 export declare const distributeAlongPath: (
-  path: readonly Vector3[],
+  input: Path3Input,
   count: number,
-  closed: boolean,
+  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 +1000,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 +1028,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,10 +1061,13 @@ 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.
+ * Path2 profiles must be closed; raw point collections have an implicit closing edge.
  *
  * @example Extrude point data without an engine
  * ```ts
@@ -1087,7 +1076,7 @@ export declare function eulerTransform3(rotationDegrees: Vector3): Transform3;
  * ```
  */
 export declare function extrudeMesh(
-  profile: Contour,
+  input: Path2Input,
   options: ExtrudeOptions,
 ): TriangleMesh;
 
@@ -1112,9 +1101,9 @@ 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 | Vector2Input;
   /** Finite rotation of the top profile about +Z, in degrees; defaults to zero. */
-  readonly twistDegrees?: number;
+  readonly twist?: number;
 }
 
 /** Fits XY bounds uniformly and centers them in the target; zero source axes do not constrain scale. */
@@ -1161,13 +1150,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 +1170,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.
@@ -1248,9 +1237,9 @@ export declare interface GeometryResolution {
   /** Optional maximum sampled edge length in millimetres. */
   readonly maxSegmentLength?: number;
   /** Upper safety bound for a full circle; defaults to the selected maxCircularSegments (512 by default). */
-  readonly maximumSegments?: number;
+  readonly maxSegments?: number;
   /** Lower full-circle segment count; defaults to 16 or a lower selected circular ceiling. */
-  readonly minimumSegments?: number;
+  readonly minSegments?: number;
 }
 
 /** Explicit allocation ceilings for pure sampling and host-owned modeling operations. */
@@ -1276,7 +1265,7 @@ export declare interface GeometryToleranceOptions {
 }
 
 /** Returns one recommended metric clearance-hole diameter in millimetres. */
-export declare function getMetricClearanceHole(
+export declare function getMetricClearanceHoleDiameter(
   size: MetricFastenerSize,
   fit?: ClearanceHoleFit,
 ): number;
@@ -1288,8 +1277,9 @@ export declare function getMetricFastenerStandard(
 
 /**
  * XY or XYZ grid with X varying fastest. The first item starts at the local origin.
+ * Dimension 2 restricts counts and spacing to XY; any frame must preserve the XY plane.
  */
-export declare type GridPatternOptions = {
+export declare type GridPatternOptions<Dimension extends 2 | 3 = 3> = {
   /** Center the complete distribution around its local origin; defaults to false. */
   readonly center?: boolean;
   /** Optional right-handed local axes and origin for the grid. */
@@ -1297,22 +1287,24 @@ 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;
-    }
-  | {
-      /** Positive integer counts on X, Y and Z. */
-      readonly count: Vector3;
-      /** Signed millimetres between adjacent copies on X, Y and Z. */
-      readonly spacing: Vector3;
+      readonly spacing: Vector2Tuple;
     }
+  | (Dimension extends 3
+      ? {
+          /** Positive integer counts on X, Y and Z. */
+          readonly count: Vector3Tuple;
+          /** Signed millimetres between adjacent copies on X, Y and Z. */
+          readonly spacing: Vector3Tuple;
+        }
+      : never)
 );
 
-/** XY or XYZ grid placements in millimetres, in X-fastest order. */
+/** Spatial XYZ matrices for an XY or XYZ grid, 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 +1341,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 +1354,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;
     }
@@ -1402,6 +1394,15 @@ export declare interface HeightfieldPreflight {
   readonly byteCount: number;
 }
 
+/**
+ * Builds closed thread-ridge components with every profile locked to the
+ * shaft's radial/axial frame. The mesh is intended for union with its
+ * minor-envelope cylinder and never owns WASM objects.
+ */
+export declare function helicalThreadRidgeMesh(
+  options: HelicalThreadRidgeMeshOptions,
+): TriangleMesh;
+
 /** Runtime-neutral options for the dedicated helical ridge mesher. */
 export declare interface HelicalThreadRidgeMeshOptions {
   /**
@@ -1418,7 +1419,7 @@ export declare interface HelicalThreadRidgeMeshOptions {
   /** Nominal major diameter before any caller-owned fit compensation. */
   readonly majorDiameter: number;
   /** Angular offset of the first start in degrees. Default: `0`. */
-  readonly phaseDegrees?: number;
+  readonly phase?: number;
   /** Validated periodic profile repeated around the shaft. */
   readonly profile: ThreadProfile;
   /** Optional circular-resolution policy. */
@@ -1429,6 +1430,19 @@ export declare interface HelicalThreadRidgeMeshOptions {
   readonly tolerance?: GeometryToleranceOptions;
 }
 
+/**
+ * Builds one closed threaded cylinder without a ridge/core Boolean seam.
+ *
+ * Each circular facet includes its exact phase-shifted profile breakpoints, including duplicate-Z
+ * samples for vertical flanks and blunt transitions. Adjacent variable grids are stitched as a
+ * monotone strip, with optional intermediate rows bounded by physical `maxSegmentLength`. A
+ * conservative pre-allocation estimate rejects excessive meshes before constructing position
+ * arrays.
+ */
+export declare function helicalThreadSolidMesh(
+  options: HelicalThreadSolidMeshOptions,
+): TriangleMesh;
+
 /** Options for a complete threaded-cylinder mesh; base semantics match the ridge builder. */
 export declare interface HelicalThreadSolidMeshOptions extends HelicalThreadRidgeMeshOptions {
   /** Apply a 45-degree radial bevel at the lower target face. */
@@ -1460,7 +1474,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 +1493,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 +1525,35 @@ 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 length2: (vector: Vector2Tuple) => number;
 
 /** Returns Euclidean vector length in the vector's coordinate units. */
-export declare const length3: (vector: Vector3) => number;
+export declare const length3: (vector: Vector3Tuple) => number;
 
 /** Linearly interpolates two vectors; `t` is dimensionless and may extrapolate. */
-export declare const lerp3: (a: Vector3, b: Vector3, t: number) => Vector3;
+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: Vector3Tuple,
+  b: Vector3Tuple,
+  t: number,
+) => Vector3Tuple;
 
 /**
  * Equal linear intervals determined by exactly two of count, spacing and total length.
+ * Dimension defaults to 3; Section patterns use 2 and accept XY vector directions.
  */
-export declare type LinearPatternOptions = {
+export declare type LinearPatternOptions<Dimension extends 2 | 3 = 3> = {
   /** Direction of repetition; magnitude is ignored. Defaults to +X. */
-  readonly direction?: Vector3;
+  readonly direction?: Dimension extends 2 ? Vector2Input : Vector3Input;
 } & (
   | {
       /** Positive copy count, including the original. */
@@ -1550,19 +1581,19 @@ export declare type LinearPatternOptions = {
     }
 );
 
-/** Equal linear placements in millimetres, including the original at the origin. */
+/** Spatial XYZ matrix 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 +1601,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;
 }
 
 /**
@@ -1599,6 +1630,7 @@ export declare type LoftCorrespondence =
  * Both ends use ear-clipped caps, supporting concave profiles without center fans.
  * Intermediate slices interpolate placed world vertices, never frame axes.
  * Transformed coordinates must fit finite Float32 mesh storage.
+ * Path2 profiles must be closed; raw point collections are interpreted as closed.
  *
  * @example Loft with explicit point correspondence
  * ```ts
@@ -1614,8 +1646,8 @@ export declare function loftMesh(
 
 /** One point-data profile at a height or explicit right-handed spatial frame. */
 export declare type LoftMeshStation = LoftPlacement & {
-  /** Ordered finite XY boundary points with an implicit closing edge. */
-  readonly profile: Contour;
+  /** Closed Path2 or ordered finite XY boundary points with an implicit closing edge. */
+  readonly profile: Path2Input;
 };
 
 /**
@@ -1684,7 +1716,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.
@@ -1694,21 +1727,6 @@ export declare function measureInternalCylindricalGearPairMotion(
   options?: CylindricalGearPairMotionOptions,
 ): CylindricalGearPairMotionReport;
 
-/**
- * Measures bounds, surface area, and signed volume without changing the mesh.
- *
- * Signed volume is meaningful for a consistently wound closed mesh. Set
- * `requireClosed` when measurements will be used as manufacturing assertions.
- *
- * @param mesh - Mesh to validate and measure.
- * @param options - Validation policy applied before measurement.
- * @returns Immutable deterministic scalar and bounds measurements.
- */
-export declare function measureTriangleMesh(
-  mesh: TriangleMesh,
-  options?: TriangleMeshValidationOptions,
-): TriangleMeshMeasurements;
-
 /**
  * Computes axis-aligned bounds for a non-empty mesh.
  *
@@ -1790,9 +1808,7 @@ export declare interface MetricSocketCapHeadDimensions {
  * count `z_v = z / cos³(beta)`, so increasing helix angle can reduce the physical tooth count.
  */
 export declare function minimumCylindricalGearToothCountWithoutUndercut(
-  spec?: Readonly<
-    Pick<CylindricalGearSpec, "helixAngleDegrees" | "pressureAngleDegrees">
-  >,
+  spec?: Readonly<Pick<CylindricalGearSpec, "helixAngle" | "pressureAngle">>,
 ): number;
 
 /** Aggregate manufacturing output ceilings selected by a trusted host. */
@@ -1807,8 +1823,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 +1852,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 +1865,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.
@@ -1863,31 +1896,101 @@ export declare function optimizePlanarPatches(
   options?: PlanarMeshOptimizationOptions,
 ): PlanarMeshOptimizationResult;
 
-/** An ordered, open sequence of two-dimensional points. */
-export declare type Path2 = readonly Vector2[];
-
-/**
- * An ordered, open sequence of three-dimensional points.
- */
-export declare type Path3 = readonly Vector3[];
+/** Immutable directed XY polyline. Closure is explicit and does not imply a filled Section. */
+export declare interface Path2 {
+  /** Coordinate dimension; identifies planar paths even when empty. */
+  readonly dimension: 2;
+  /** Whether traversal includes the last-to-first edge. */
+  readonly closed: boolean;
+  /** Returns frozen tuple coordinates; closure remains separate metadata. Repeated calls do not allocate. */
+  toArray(): Path2Data;
+  /** Total sampled edge length in model units, including the closing edge when closed. */
+  length(): number;
+  /** Axis-aligned bounds, or undefined for an empty path. */
+  bounds(): Bounds2 | undefined;
+  /** Finds the nearest edge location; requires at least two vertices. */
+  closestPoint(point: Vector2Input): PathLocation<Vector2>;
+  /** Applies an XY placement without reordering traversal, including after reflection. */
+  transform(placement: Transform2Input): Path2;
+  /** Reverses vertex order and traversal; neither the source nor its coordinates are mutated. */
+  reverse(): Path2;
+  /** Returns a path sampled at equal arc lengths. Corners may be bridged; closure is preserved. */
+  resample(options?: PathResamplingOptions): Path2;
+}
+
+/**
+ * Snapshots finite XY coordinates as an immutable sampled path, independent of engine initialization.
+ * Open paths may be empty or have one point; closed paths need three vertices and omit a duplicated
+ * seam. Repeated adjacent vertices are retained. No winding normalization or filling is performed.
+ * Malformed dimensions or topology throw INVALID_ARGUMENT; nonfinite coordinates or measurement
+ * overflow throw NON_FINITE_VALUE; exhausted allocation ceilings throw COMPLEXITY_LIMIT GeometryError.
+ * A path input retains its closure. Limits bound construction only; resampling takes its own limits.
+ */
+export declare function path2(input: Path2Input, options?: PathOptions): Path2;
+
+/** XY point tuples for interchange; closure is supplied by the consuming operation or Path2 value. */
+export declare type Path2Data = readonly Vector2Tuple[];
+
+/** An immutable XY sampled path or a collection of XY tuples and fluent vectors. */
+export declare type Path2Input = Path2 | readonly Vector2Input[];
+
+/** Immutable directed XYZ polyline; it represents sampled edges, not an analytic curve. */
+export declare interface Path3 {
+  /** Coordinate dimension; identifies spatial paths even when empty. */
+  readonly dimension: 3;
+  /** Whether traversal includes the last-to-first edge. */
+  readonly closed: boolean;
+  /** Returns frozen tuple coordinates; closure remains separate metadata. Repeated calls do not allocate. */
+  toArray(): Path3Data;
+  /** Total sampled edge length in model units, including the closing edge when closed. */
+  length(): number;
+  /** Axis-aligned bounds, or undefined for an empty path. */
+  bounds(): Bounds3 | undefined;
+  /** Finds the nearest edge location; requires at least two vertices. */
+  closestPoint(point: Vector3Input): PathLocation<Vector3>;
+  /** Applies an XYZ placement without changing traversal order or closure. */
+  transform(placement: Transform3Input): Path3;
+  /** Reverses vertex order and traversal without mutating the source. */
+  reverse(): Path3;
+  /** Returns a path sampled at equal arc lengths. Corners may be bridged; closure is preserved. */
+  resample(options?: PathResamplingOptions): Path3;
+}
+
+/**
+ * Snapshots finite XYZ coordinates as an immutable sampled path with the same closure, seam,
+ * allocation and error rules as path2. Analytic curves must be sampled explicitly first.
+ */
+export declare function path3(input: Path3Input, options?: PathOptions): Path3;
+
+/**
+ * XYZ point tuples for interchange; closure is supplied by the consuming operation or Path3 value.
+ */
+export declare type Path3Data = readonly Vector3Tuple[];
+
+/** An immutable XYZ sampled path or a collection of XYZ tuples and fluent vectors. */
+export declare type Path3Input = Path3 | readonly Vector3Input[];
 
 /** 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[],
-  limits?: Partial<GeometrySamplingLimits>,
-) => number;
+/** Nearest location on a sampled boundary, rather than inside a filled shape or on an analytic curve. */
+export declare interface PathLocation<Point extends Vector2 | Vector3> {
+  /** Immutable position on the selected edge. */
+  readonly point: Point;
+  /** Euclidean distance from the query in model units. */
+  readonly distance: number;
+  /** Starting vertex of the selected edge; ties keep the first edge in traversal order. */
+  readonly edgeIndex: number;
+  /** Clamped fraction along that edge, not the whole path's normalized arc length. */
+  readonly fraction: number;
+}
 
 /**
  * Supplies a profile-X orientation guide for each original normalized sweep station.
@@ -1897,17 +2000,25 @@ 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;
+) => Vector3Input;
+
+/** Topology and allocation ceiling for an immutable sampled path. */
+export declare interface PathOptions {
+  /** Connects the last vertex to the first; closed paths omit the repeated seam. Defaults to false. */
+  readonly closed?: boolean;
+  /** Construction point ceiling; defaults to package sampling limits. Later sampling has its own options. */
+  readonly limits?: Partial<GeometrySamplingLimits>;
+}
 
 /** Equal physical arc-length placements along an open or implicitly closed sampled path. */
 export declare interface PathPatternOptions {
   /** Positive number of copies; open paths include both endpoints when greater than one. */
   readonly count: number;
-  /** Include the closing edge without duplicating the seam; defaults to false. */
+  /** Raw point closure defaults to false; a path value supplies closure and rejects conflicts. */
   readonly closed?: boolean;
-  /** Preserve the source orientation, or align its +Z to the path tangent; defaults to fixed. */
+  /** Preserve orientation, or align local +X for Sections / +Z for Solids to the tangent. Defaults to fixed. */
   readonly orientation?: "fixed" | "tangent";
 }
 
@@ -1917,17 +2028,35 @@ export declare interface PathPatternOptions {
  * Explicit sampling ceilings bound both input points and output placements.
  */
 export declare function pathPatternTransforms(
-  path: readonly Vector3[],
+  path: Path3Input,
   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;
+}
+
+/** Equal arc-length sampling; the path itself owns whether its closing edge is included. */
+export declare interface PathResamplingOptions extends CurveSamplingOptions {
+  /** Exact arc-length intervals; closed paths need at least three. Otherwise physical resolution or the effective source edge count controls sampling. */
+  readonly segments?: number;
+}
+
+/** 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. */
@@ -1944,23 +2073,23 @@ export declare interface PlanarMeshOptimizationOptions extends TriangleMeshQuali
    * Maximum attempted edge evaluations. By default this is twenty times the initial candidate
    * edge count, capped at `1000000`.
    */
-  readonly maximumFlipAttempts?: number;
+  readonly maxFlipAttempts?: number;
   /** Maximum times one edge may be reconsidered after neighbouring flips. Defaults to `12`. */
-  readonly maximumEdgeRevisits?: number;
+  readonly maxEdgeRevisits?: number;
   /** Maximum triangles allowed in one selected patch. Defaults to `50000`. */
-  readonly maximumPatchTriangleCount?: number;
+  readonly maxPatchTriangles?: number;
   /** Maximum cumulative triangles across selected patches. Defaults to `200000`. */
-  readonly maximumProcessedTriangleCount?: number;
+  readonly maxProcessedTriangles?: number;
   /** Minimum triangles required before a planar patch is eligible. Defaults to `8`. */
-  readonly minimumPatchTriangleCount?: number;
+  readonly minPatchTriangles?: number;
   /** Select patches whose worst normalized aspect ratio exceeds this value. Defaults to `12`. */
-  readonly triggerMaximumAspectRatio?: number;
+  readonly triggerMaxAspectRatio?: number;
   /** Select patches whose largest per-vertex triangle share exceeds this ratio. Defaults to `0.2`. */
-  readonly triggerMaximumFanRatio?: number;
+  readonly triggerMaxFanRatio?: number;
   /** Select patches whose largest vertex triangle incidence exceeds this value. Defaults to `16`. */
-  readonly triggerMaximumVertexTriangleIncidence?: number;
+  readonly triggerMaxVertexTriangleIncidence?: number;
   /** Select patches whose smallest interior angle is below this many degrees. Defaults to `8`. */
-  readonly triggerMinimumAngleDegrees?: number;
+  readonly triggerMinAngleDegrees?: number;
 }
 
 /** Outcome of bounded planar-patch optimization, including before/after diagnostics. */
@@ -2008,7 +2137,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 +2155,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. */
@@ -2087,26 +2216,18 @@ export declare function preflightThreadedRod(
   options: ThreadedRodOptions,
 ): HelicalThreadSolidMeshPreflight;
 
-/** Placement shared by solid and filled-section factories. */
-export declare interface PrimitivePlacement {
-  /** Applied after local construction; Section placement must preserve the XY plane. */
-  readonly placement?: PrimitivePlacementOptions;
+/** Anchor attachment shared by solid and filled-section factories. */
+export declare interface PrimitiveAttachment {
+  /** Applied after local construction; Section attachment must preserve the XY plane. */
+  readonly attachment?: PrimitiveAttachmentOptions;
 }
 
 /** Maps an explicit or named shape-local attachment anchor onto a world-space anchor. */
-export declare interface PrimitivePlacementOptions {
+export declare interface PrimitiveAttachmentOptions extends AttachOptions {
   /** Shape-local source frame or a named primitive anchor such as bottom. */
   readonly source: Anchor3 | string;
   /** World-space target frame in millimetres. */
   readonly target: Anchor3;
-  /** Align outward directions face-to-face or in parallel. Defaults to opposed. */
-  readonly alignment?: "opposed" | "same";
-  /** Finite separation along the target direction in millimetres. Defaults to zero. */
-  readonly gap?: number;
-  /** Finite additional roll around the attached direction in degrees. Defaults to zero. */
-  readonly spinDegrees?: number;
-  /** Explicit numeric comparison overrides for anchor normalization. */
-  readonly tolerance?: GeometryToleranceOptions;
 }
 
 /**
@@ -2178,7 +2299,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,41 +2315,41 @@ 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. */
-      readonly startDegrees: number;
+      readonly startAngle: number;
       /** Signed counterclockwise angular sweep in degrees. */
-      readonly sweepDegrees: number;
+      readonly sweepAngle: number;
     }
   | {
       /** 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 {
@@ -2259,37 +2380,41 @@ export declare interface RackPitchSpec {
   /** Dedendum clearance as a multiple of normal module; defaults to `0.25`. */
   readonly clearanceFactor?: number;
   /** Signed helix angle in degrees; zero creates a straight rack. */
-  readonly helixAngleDegrees?: number;
+  readonly helixAngle?: number;
   /** Normal module in millimetres per tooth. */
   readonly module: number;
   /** Normal pressure angle in degrees; defaults to 20 degrees. */
-  readonly pressureAngleDegrees?: number;
+  readonly pressureAngle?: number;
   /** Number of complete rack teeth represented by the segment. */
   readonly toothCount: number;
 }
 
 /**
- * Options for repeating one solid around an axis through a center point.
+ * Degree rotations about a fixed world-space pivot; XY patterns use the implicit +Z axis.
  */
-export declare interface RadialPatternOptions {
-  /** Number of solids to return, including the original. */
+export declare type RadialPatternOptions<Dimension extends 2 | 3 = 3> = {
+  /** Number of shapes to return, including the original. */
   readonly count: number;
-  /** Axis of the right-handed rotation. Its magnitude is ignored. */
-  readonly axis: Vector3;
   /** 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 angle: number;
+  /** Fixed world-space rotation pivot; defaults to the coordinate origin. */
+  readonly pivot?: Dimension extends 2 ? Vector2Input : Vector3Input;
+} & (Dimension extends 2
+  ? {
+      /** XY rotation uses +Z; an explicit spatial axis is unavailable. */
+      readonly axis?: never;
+    }
+  : {
+      /** Axis of the right-handed rotation. Its nonzero magnitude is ignored. */
+      readonly axis: Vector3Input;
+    });
 
 /** 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 +2444,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 +2487,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 +2497,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 +2515,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 {
@@ -2399,7 +2524,7 @@ export declare interface RegularPolygonContourOptions extends RadialSizingOption
   /** Exact side count from three through the selected profile sampling ceiling. */
   readonly sides: number;
   /** Counterclockwise rotation in degrees; defaults to zero with a vertex on +X. */
-  readonly rotationDegrees?: number;
+  readonly rotation?: number;
 }
 
 /** Resamples a planar polyline with the same point, tangent, seam and budget guarantees as 3D.
@@ -2410,7 +2535,7 @@ export declare interface RegularPolygonContourOptions extends RadialSizingOption
  * ```
  */
 export declare function resamplePolyline2(
-  path: readonly Vector2[],
+  path: readonly Vector2Tuple[],
   options?: PolylineResamplingOptions,
 ): SampledCurve2;
 
@@ -2426,7 +2551,7 @@ export declare function resamplePolyline2(
  * ```
  */
 export declare function resamplePolyline3(
-  path: readonly Vector3[],
+  path: readonly Vector3Tuple[],
   options?: PolylineResamplingOptions,
 ): SampledCurve3;
 
@@ -2436,7 +2561,7 @@ export declare function resamplePolyline3(
  * `alignTo` must be non-empty and contain only positive safe integers. Its checked least common
  * multiple defines the alignment grid. An exact `segments` value wins over
  * `resolution.circularSegments` and adaptive sampling, but is never rounded: it must already be
- * aligned and meet `minimumSegments`. Adaptive counts are rounded upward and fail with
+ * aligned and meet `minSegments`. Adaptive counts are rounded upward and fail with
  * `COMPLEXITY_LIMIT` when the aligned result exceeds the configured safety cap.
  *
  * @param radius - Positive circle radius in millimetres used for adaptive physical sampling.
@@ -2463,7 +2588,7 @@ export declare function resolveAlignedCircularSegments(
  * the reusable BOSL2-style convention while retaining at least one segment.
  *
  * @param radius - Arc radius in millimetres.
- * @param angleDegrees - Non-zero signed sweep angle no greater than 360 degrees in magnitude.
+ * @param angle - Non-zero signed sweep angle no greater than 360 degrees in magnitude.
  * @param policy - Optional operation-level policy over the active model scope.
  * @returns Segment count for the requested arc span.
  * @throws {@link GeometryError} when radius, angle, or resolution policy is invalid, or the
@@ -2477,8 +2602,8 @@ export declare function resolveAlignedCircularSegments(
  */
 export declare function resolveArcSegments(
   radius: number,
-  angleDegrees: number,
-  policy?: GeometryResolution,
+  angle: number,
+  policy?: CircularResolutionOptions,
   limits?: Partial<GeometrySamplingLimits>,
 ): number;
 
@@ -2486,7 +2611,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 +2630,7 @@ export declare function resolveArcSegments(
  */
 export declare function resolveCircularSegments(
   radius: number,
-  policy?: GeometryResolution,
+  policy?: CircularResolutionOptions,
   limits?: Partial<GeometrySamplingLimits>,
 ): number;
 
@@ -2559,7 +2685,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;
@@ -2600,7 +2726,7 @@ export declare function resolveRackPitch(
  * Resolves a role-independent, start-aligned facet count from the larger female mating envelope.
  *
  * An exact `circularSegments` value must already be divisible by `starts`; it is never silently
- * raised. Adaptive policies align upward and fail if that would exceed `maximumSegments`.
+ * raised. Adaptive policies align upward and fail if that would exceed `maxSegments`.
  */
 export declare function resolveThreadCircularSegments(
   options: ThreadCircularSegmentsOptions,
@@ -2623,6 +2749,7 @@ export declare function reverseTriangleMesh(mesh: TriangleMesh): TriangleMesh;
  * vertices and zero-area quads. Profile edges that lie entirely on the axis
  * collapse to the solid's interior and are intentionally omitted.
  * Profile coordinates must fit finite Float32 mesh storage.
+ * Path2 profiles must be closed; raw point collections have an implicit closing edge.
  *
  * @param profile - Closed CCW `[radius, z]` profile without a duplicated seam point.
  * @param options - Optional physical or exact circumferential sampling controls. Defaults to `{}`.
@@ -2631,11 +2758,11 @@ export declare function reverseTriangleMesh(mesh: TriangleMesh): TriangleMesh;
  * @example Partial revolution with end caps
  * ```ts
  * // Each point is [radius, Z]; the profile seam is implicit.
- * revolveMesh([[0, 0], [12, 0], [8, 20], [0, 20]], { revolveDegrees: 270 });
+ * revolveMesh([[0, 0], [12, 0], [8, 20], [0, 20]], { degrees: 270 });
  * ```
  */
 export declare const revolveMesh: (
-  profile: readonly Vector2[],
+  input: Path2Input,
   options?: RevolveOptions,
 ) => TriangleMesh;
 
@@ -2644,22 +2771,26 @@ export declare const revolveMesh: (
  */
 export declare interface RevolveOptions extends CircularPrimitiveOptions {
   /**
-   * Positive angular sweep no greater than 360 degrees; partial revolutions have end caps.
+   * Positive sweep in degrees, no greater than 360. Defaults to a full revolution;
+   * smaller sweeps form partial revolutions with end caps.
    * Segment counts describe a complete circle and scale to this angular span. Native filled
    * revolutions require at least three sweep intervals: adaptive sampling refines to that floor,
    * while exact counts that imply fewer intervals reject. Pure revolveMesh supports one interval.
+   * @defaultValue `360`
    */
-  readonly revolveDegrees?: number;
+  readonly degrees?: number;
   /** Explicit output and sampling allocation ceilings. */
   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 +2801,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
@@ -2683,13 +2814,14 @@ export declare function rotationTransform3(
  * 45% of adjacent segment lengths to prevent neighboring corners from crossing.
  * The returned path does not duplicate its closing point.
  * Coordinates and radius must be finite; input and output are each limited by maxPathPoints (default 100000).
+ * Requires a closed path value; raw tuples are interpreted as closed. Invalid inputs throw GeometryError.
  */
 export declare const roundClosedPolylinePath: (
-  points: readonly Vector3[],
+  input: Path3Input,
   radius: number,
   segmentsPerCorner: number,
   limits?: Partial<GeometrySamplingLimits>,
-) => readonly Vector3[];
+) => readonly Vector3Tuple[];
 
 /**
  * A circular edge or corner roundover with explicit physical sampling.
@@ -2716,7 +2848,7 @@ export declare interface RowLayoutOptions {
  * coordinate range are required. No native engine, SDK, or ambient resolution is used.
  *
  * @param curve - Closed contour in millimetres unless positive scales convert its coordinates.
- * @param options - Physical resolution and unique vertex budget; defaults to 4096 vertices.
+ * @param options - Physical resolution and unique vertex budget; defaults to min(4096, maxProfilePoints).
  * @returns Frozen counterclockwise loop in millimetres, without a repeated seam endpoint.
  * @throws {@link GeometryError} for invalid data, topology, scale, or exceeded sampling budgets.
  *
@@ -2746,7 +2878,7 @@ export declare interface SampleContourOptions {
   /** Physical policy evaluated after scaling, using the shared curve sampler. */
   readonly resolution?: GeometryResolution;
   /** Unique output vertex ceiling, at least three, within maxProfilePoints. Defaults to min(4096, maxProfilePoints). */
-  readonly maximumVertices?: number;
+  readonly maxVertices?: number;
   /** Selected profile and per-segment path ceilings; omitted values use package defaults. */
   readonly limits?: Partial<GeometrySamplingLimits>;
 }
@@ -2756,7 +2888,7 @@ export declare interface SampleContourOptions {
  * frozen. At stationary tangents, outgoing secants are preferred and endpoints use a backward fallback.
  * @example
  * ```ts
- * const turn = sampleCurve2({kind: "arc", center: [0,0], radius: 10, sweepDegrees: 90});
+ * const turn = sampleCurve2({kind: "arc", center: [0,0], radius: 10, sweepAngle: 90});
  * ```
  */
 export declare function sampleCurve2(
@@ -2793,9 +2925,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 +2935,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. */
@@ -2813,7 +2945,7 @@ export declare interface SampledThreadHelices {
   /** Axial advance over one revolution, equal to `pitch * starts`. */
   readonly lead: number;
   /** One immutable sampled path for each thread start. */
-  readonly paths: readonly Path3[];
+  readonly paths: readonly Path3Data[];
   /** Adjacent axial thread spacing in millimetres. */
   readonly pitch: number;
   /** Number of revolutions represented by each path. */
@@ -2824,6 +2956,7 @@ export declare interface SampledThreadHelices {
  * Creates `segments + 1` points including exact helix endpoints from finite positive dimensions.
  * Integrated weights must remain finite. The maxPathPoints ceiling defaults to 100000; excessive
  * exact counts reject before evaluating axial weights or allocating sample arrays.
+ * Invalid inputs use GeometryError; exceptions thrown by axialWeight propagate unchanged.
  */
 export declare const sampleHelix: ({
   turns,
@@ -2832,7 +2965,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 {
@@ -2877,7 +3010,7 @@ export declare function sampleInternalCylindricalGearSpaceOutline(
 export declare function sampleRackToothPath(
   spec: RackPitchSpec,
   limits?: Partial<GeometrySamplingLimits>,
-): Path2;
+): Path2Data;
 
 /**
  * Samples 1–31 line/cubic segments into a deeply immutable open [radius,height] polyline.
@@ -2888,7 +3021,7 @@ export declare function sampleRackToothPath(
  * no axis closure, winding normalization, or manufacturing repair is performed.
  *
  * @param curve - Open outline in millimetres unless the positive scales convert its coordinates.
- * @param options - Physical resolution and output budget; defaults to 4096 vertices.
+ * @param options - Physical resolution and output budget; defaults to min(4096, maxProfilePoints).
  * @returns Frozen open polyline in millimetres, ordered from lowest to highest anchor.
  * @throws {@link GeometryError} for invalid coordinates, order, scale, or exceeded subdivision budget.
  *
@@ -2903,7 +3036,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 {
@@ -2914,7 +3047,7 @@ export declare interface SampleSideProfileOptions {
   /** Shared physical policy, evaluated after scaling; exact circular counts do not affect curves. */
   readonly resolution?: GeometryResolution;
   /** Maximum output vertex count within maxProfilePoints. Defaults to the smaller of 4096 and that ceiling. */
-  readonly maximumVertices?: number;
+  readonly maxVertices?: number;
   /** Explicit profile and circular allocation ceilings. */
   readonly limits?: Partial<GeometrySamplingLimits>;
 }
@@ -2942,6 +3075,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 +3088,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 +3102,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 {
@@ -3017,7 +3161,7 @@ export declare interface SmoothEdgeTreatment {
 /** Bounded floating-point intersection and shell-orientation validation settings. */
 export declare interface SolidMeshValidationOptions {
   /** Work ceiling for spatial comparisons and containment tests; defaults to 2,000,000 and may only lower it. */
-  readonly maximumTests?: number;
+  readonly maxTests?: number;
   /** Distance comparison policy in millimetres; near contacts reject conservatively. */
   readonly tolerance?: GeometryToleranceOptions;
 }
@@ -3026,7 +3170,7 @@ export declare interface SolidMeshValidationOptions {
  * Exactly one radius or diameter, placement, and tessellation for an origin-centered sphere.
  */
 export declare type SphereOptions = CircularPrimitiveOptions &
-  PrimitivePlacement &
+  PrimitiveAttachment &
   (
     | {
         /** Positive radius in millimetres; mutually exclusive with diameter. */
@@ -3066,43 +3210,49 @@ 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";
+export declare type StrokeCap = "butt" | "round" | "square";
 
 /** Join treatment where adjacent stroked path segments meet. */
-export declare type StrokePathJoin = "bevel" | "miter" | "round";
-
-/**
- * Converts a sampled millimetre path into the filled region covered by a centered stroke.
- *
- * Closed paths omit a duplicated seam point. Zero-length sampled segments are ignored, while the
- * effective path must still contain visible length. Round caps and joins use deterministic physical
- * resolution. Bevels fill the outer corner triangle; miters extend the outer edges to their
- * intersection, falling back to bevels above SVG's default miter limit of 4.
- */
-export declare function strokePathRegion(
-  path: Path2,
-  options: StrokePathRegionOptions,
-): Region;
+export declare type StrokeJoin = "bevel" | "miter" | "round";
 
-/** Physical stroke and topology controls for {@link strokePathRegion}. */
-export declare interface StrokePathRegionOptions {
+/** Physical stroke and topology controls shared by pure regions and native Sections. */
+export declare interface StrokeOptions {
   /** Explicit path, circular and expanded-profile allocation ceilings. */
   readonly limits?: Partial<GeometrySamplingLimits>;
-  /** Treat the path as a closed non-duplicated loop. Default: `false`. */
+  /** Raw point closure defaults to false; a Path2 supplies its closure and rejects conflicts. */
   readonly closed?: boolean;
   /** End-cap treatment for an open path. Ignored for closed paths. Default: `butt`. */
-  readonly cap?: StrokePathCap;
+  readonly cap?: StrokeCap;
   /** Corner treatment; miters exceeding SVG's default limit of 4 become bevels. Default: `miter`. */
-  readonly join?: StrokePathJoin;
+  readonly join?: StrokeJoin;
   /** Physical tessellation policy for round caps and joins. */
   readonly resolution?: GeometryResolution;
   /** Positive total stroke width in millimetres, centered on the sampled path. */
   readonly width: number;
 }
 
+/**
+ * Converts a sampled millimetre path into the filled region covered by a centered stroke.
+ *
+ * Closed paths omit a duplicated seam point. Zero-length sampled segments are ignored, while the
+ * effective path must still contain visible length. Round caps and joins use deterministic physical
+ * resolution. Bevels fill the outer corner triangle; miters extend the outer edges to their
+ * intersection, falling back to bevels above SVG's default miter limit of 4.
+ */
+export declare function strokeRegionData(
+  path: Path2Input,
+  options: StrokeOptions,
+): RegionData;
+
+/** Subtracts `b` from `a` component-wise. */
+export declare const subtract2: (
+  a: Vector2Tuple,
+  b: Vector2Tuple,
+) => Vector2Tuple;
+
 /**
  * Subtracts `b` from `a`.
  * @example
@@ -3110,7 +3260,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 +3287,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;
 }
@@ -3146,45 +3299,45 @@ export declare interface SvgRegionPreflightGeometryMetrics {
   /** Millimetre bounds, or `null` when no painted region remains. */
   readonly bounds: Bounds2 | null;
   /** Disconnected filled polygons in the final region. */
-  readonly components: number;
+  readonly componentCount: number;
   /** Exterior and hole boundary count in the final region. */
-  readonly contours: number;
+  readonly contourCount: number;
   /** Interior boundary count in the final region. */
-  readonly holes: number;
+  readonly holeCount: number;
   /** Shortest final boundary edge in millimetres, or `null` for an empty region. */
   readonly minEdgeLength: number | null;
   /** Final boundary edges shorter than the conservative 0.01 mm indicator. */
-  readonly shortEdges: number;
+  readonly shortEdgeCount: number;
   /** Components with less than 0.01 square millimetres of filled area. */
-  readonly tinyIslands: number;
+  readonly tinyIslandCount: number;
   /** Non-duplicated boundary vertices in the final normalized region. */
-  readonly vertices: number;
+  readonly vertexCount: number;
 }
 
 /** Visible, appearance-preserving cleanup counters from bounded SVG import. */
 export declare interface SvgRegionPreflightRepairs {
   /** Graphics elements with neither a visible fill nor a positive-width visible stroke. */
-  readonly invisibleElements: number;
+  readonly invisibleElementCount: number;
   /** Open filled subpaths closed by SVG fill semantics without closing their strokes. */
-  readonly implicitFilledClosures: number;
+  readonly implicitFilledClosureCount: number;
   /** Visibly painted elements whose fill and stroke both resolved to empty geometry. */
-  readonly emptyElements: number;
+  readonly emptyElementCount: number;
   /** Consecutive repeated flattened vertices discarded before topology resolution. */
-  readonly removedDuplicateVertices: number;
+  readonly removedDuplicateVertexCount: number;
   /** Explicit repeated seam vertices removed from otherwise closed contours. */
-  readonly removedSeamVertices: number;
+  readonly removedSeamVertexCount: number;
 }
 
 /** Bounded source-complexity facts collected while parsing one SVG document. */
 export declare interface SvgRegionPreflightSourceMetrics {
   /** UTF-8 source size, capped at 256 KiB before parsing. */
-  readonly bytes: number;
+  readonly byteCount: number;
   /** Renderable shape elements, capped at 500; containers and metadata are excluded. */
-  readonly elements: number;
+  readonly elementCount: number;
   /** Flattened vertices emitted before fill, stroke, and clipping operations. */
-  readonly emittedVertices: number;
+  readonly emittedVertexCount: number;
   /** Path endpoints and control vertices parsed before adaptive flattening. */
-  readonly parsedVertices: number;
+  readonly parsedVertexCount: number;
 }
 
 /**
@@ -3199,8 +3352,8 @@ export declare interface SvgRegionPreflightSourceMetrics {
  * ```
  */
 export declare function sweepMesh(
-  profile: Contour,
-  path: readonly Vector3[],
+  profile: Path2Input,
+  path: Path3Input,
   options?: SweepOptions,
 ): TriangleMesh;
 
@@ -3208,7 +3361,7 @@ export declare function sweepMesh(
  * Controls shared by pure mesh construction and filled modeling sweeps.
  */
 export declare interface SweepOptions {
-  /** Join the path's last station to its first. Open paths retain watertight end caps. */
+  /** Raw point closure defaults to false; a Path3 supplies its closure and rejects conflicts. */
   readonly closed?: boolean;
   /** Explicit output and sampling allocation ceilings. */
   readonly limits?: Partial<ModelingLimits>;
@@ -3217,11 +3370,11 @@ export declare interface SweepOptions {
   /** Physical sampling of nonzero twist; inserted stations retain authored station controls. */
   readonly resolution?: GeometryResolution;
   /** Total additional profile rotation in degrees, with progression selected by twistBy. */
-  readonly twistDegrees?: number;
+  readonly twist?: number;
   /** 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 | Vector2Input | readonly Vector2Input[];
   /** Corresponding point-index advance at a rotationally equivalent closed seam. */
   readonly seamProfileOffset?: number;
 }
@@ -3234,13 +3387,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?: Vector3Input;
     }
   | {
       /** 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: Vector3Input;
     }
   | {
       /** Uses an explicitly directed normal callback at each original normalized station. */
@@ -3279,7 +3432,7 @@ export declare interface ThreadCircularSegmentsOptions {
    * This keeps a compensated male/female pair on one role-independent grid when an internal
    * cutter has an enlarged entrance bevel. Default: `0`.
    */
-  readonly maximumRadialOutset?: number;
+  readonly maxRadialOutset?: number;
   /** Validated mating profile whose pitch and flank capacities govern tessellation. */
   readonly profile: ThreadProfile;
   /** Physical or exact circular resolution policy. */
@@ -3419,7 +3572,7 @@ export declare interface ThreadHelixOptions {
   /** Total sampled axial length in millimetres. */
   readonly length: number;
   /** Angular offset of the first start in degrees. Default: `0`. */
-  readonly phaseDegrees?: number;
+  readonly phase?: number;
   /** Adjacent axial thread spacing in millimetres. */
   readonly pitch: number;
   /** Radial distance from the +Z axis in millimetres. */
@@ -3451,11 +3604,25 @@ 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;
 }
 
+/**
+ * Creates a periodic thread profile for the shaft-locked helical mesher.
+ *
+ * The open path spans one pitch. Radial zero is the major envelope; negative
+ * values point toward the shaft. Custom paths must be finite, axially
+ * non-decreasing, periodic at their endpoints, and reach radial zero.
+ *
+ * @example Printable triangular thread profile
+ * ```ts
+ * threadProfile({ kind: "triangular", pitch: 1.75 });
+ * ```
+ */
+export declare function threadProfile(spec: ThreadProfileSpec): ThreadProfile;
+
 /** Fields shared by all thread profile specifications. */
 export declare interface ThreadProfileBaseSpec {
   /** Adjacent axial thread spacing in millimetres. */
@@ -3481,7 +3648,7 @@ export declare type ThreadRole = "male" | "female";
 /**
  * Dimensions and independent ring/profile tessellation for a torus around the Z axis.
  */
-export declare interface TorusOptions extends PrimitivePlacement {
+export declare interface TorusOptions extends PrimitiveAttachment {
   /** Explicit sampling ceilings, bounded by the host policy. */
   readonly limits?: Partial<GeometrySamplingLimits>;
   /** Radius from the Z axis to the profile center, in millimetres; greater than `minorRadius`. */
@@ -3496,13 +3663,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,
@@ -3521,17 +3791,6 @@ export declare type Transform3 = readonly [
   m33: number,
 ];
 
-/**
- * Transforms a closed loop and preserves its original winding convention.
- *
- * Reflections reverse the point order automatically through normalization.
- */
-export declare function transformContour(
-  loop: Contour,
-  transform: Transform3,
-  tolerance?: GeometryToleranceOptions,
-): Contour;
-
 /**
  * Returns the determinant of a transform's linear 3x3 component.
  *
@@ -3540,27 +3799,19 @@ 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. */
-export declare function transformPath2(
-  path: Path2,
-  transform: Transform3,
-  tolerance?: GeometryToleranceOptions,
-): Path2;
-
-/** Applies an affine transform to a 3D path without mutating its points. */
-export declare function transformPath3(
-  path: Path3,
-  transform: Transform3,
-): 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.
@@ -3569,12 +3820,12 @@ export declare function transformRegion(
  * automatically reverses every triangle. Singular transforms are rejected.
  *
  * @param mesh - Mesh to transform without mutation.
- * @param transform - Row-major affine transform.
+ * @param placement - Immutable spatial placement or canonical row-major affine matrix.
  * @returns A mesh with fresh transformed positions and copied or reversed indices.
  */
 export declare function transformTriangleMesh(
   mesh: TriangleMesh,
-  transform: Transform3,
+  placement: Transform3Input,
 ): TriangleMesh;
 
 /**
@@ -3583,7 +3834,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 {
@@ -3595,10 +3848,11 @@ export declare interface TrapezoidalThreadProfileSpec extends ThreadProfileBaseS
    */
   readonly depth?: number;
   /**
-   * Included flank angle in degrees. Use `90` for printable 45-degree slopes.
+   * Full angle between the flanks in degrees, from `0` inclusive to `180` exclusive.
+   * Each flank uses half this angle from the radial direction; `90` gives 45-degree slopes.
    * @defaultValue `30`
    */
-  readonly threadAngle?: number;
+  readonly includedAngle?: number;
 }
 
 /**
@@ -3615,7 +3869,7 @@ export declare interface TriangleMesh {
  * Measurements and optional edge-connected topology from one validated mesh traversal.
  */
 export declare interface TriangleMeshAnalysis extends TriangleMeshMeasurements {
-  /** Number of referenced edge-connected components when `includeTopology` is requested. */
+  /** Number of referenced edge-connected boundary shells when `includeTopology` is requested; cavities count separately. */
   readonly connectedComponentCount?: number;
   /** Number of distinct indexed undirected edges when `includeTopology` is requested. */
   readonly edgeCount?: number;
@@ -3648,7 +3902,7 @@ export declare interface TriangleMeshMeasurements {
 /** Options controlling bounded triangle-mesh quality analysis. */
 export declare interface TriangleMeshQualityOptions {
   /** Maximum number of triangles inspected. Defaults to `200000`. */
-  readonly maximumTriangleCount?: number;
+  readonly maxTriangles?: number;
   /** Numeric comparison overrides; model coordinates are interpreted in their existing units. */
   readonly tolerance?: GeometryToleranceOptions;
 }
@@ -3691,7 +3945,7 @@ export declare interface TriangleMeshQualityReport {
 export declare interface TriangleMeshSignature {
   /** Axis-aligned bounds quantized by `tolerances.position`. */
   readonly bounds: Bounds3;
-  /** Number of edge-connected closed components. */
+  /** Number of edge-connected closed boundary shells; cavities count separately. */
   readonly connectedComponentCount: number;
   /** Total orientable genus across all connected components. */
   readonly genus: number;
@@ -3710,7 +3964,7 @@ export declare interface TriangleMeshSignature {
 /** Options controlling deterministic triangle-mesh regression signatures. */
 export declare interface TriangleMeshSignatureOptions {
   /** Maximum accepted triangle count. Defaults to 200,000. */
-  readonly maximumTriangleCount?: number;
+  readonly maxTriangles?: number;
   /** Position and bounds quantization in model units. Defaults to `1e-5`. */
   readonly positionTolerance?: number;
   /** Signed-volume quantization in cubic model units. Defaults to `1e-4`. */
@@ -3760,7 +4014,7 @@ export declare function triangulateContour(loop: Contour): Uint32Array;
  * Dimensions, placement, and tessellation for a hollow Z-axis tube.
  */
 export declare interface TubeOptions
-  extends CircularPrimitiveOptions, PrimitivePlacement {
+  extends CircularPrimitiveOptions, PrimitiveAttachment {
   /**
    * Centers the tube on the Z origin when `true`; otherwise its bottom is at `Z = 0`.
    * @defaultValue `true`
@@ -3802,9 +4056,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 +4077,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 {
@@ -3836,7 +4176,7 @@ export declare interface VectorTextArcBaseline {
   /** Baseline radius in millimetres, greater than zero and at most 10000. */
   readonly radius: number;
   /** Alignment datum in degrees counterclockwise from +X; defaults to 90. */
-  readonly centerAngleDegrees?: number;
+  readonly centerAngle?: number;
   /** Reading direction around the circle; defaults to clockwise. */
   readonly direction?: "clockwise" | "counterclockwise";
 }