@metamesh/modeling 0.14.0 → 0.16.0

package/dist/api/geometry.d.ts

@@ -12,7 +12,7 @@ export declare interface AcmeThreadProfileSpec extends ThreadProfileBaseSpec {
 }
 
 /** Adds two finite XY vectors component-wise. */
-export declare const add2: (a: Vector2Tuple, b: Vector2Tuple) => Vector2Tuple;
+export declare const add2: (a: Vector2Data, b: Vector2Data) => Vector2Data;
 
 /**
  * Adds two finite XYZ vectors component-wise.
@@ -21,7 +21,7 @@ export declare const add2: (a: Vector2Tuple, b: Vector2Tuple) => Vector2Tuple;
  * add3([1, 2, 3], [4, 5, 6]); // [5, 7, 9]
  * ```
  */
-export declare const add3: (a: Vector3Tuple, b: Vector3Tuple) => Vector3Tuple;
+export declare const add3: (a: Vector3Data, b: Vector3Data) => Vector3Data;
 
 /** Controls full-circle sampling that must satisfy one or more topology alignments. */
 export declare interface AlignedCircularSegmentsOptions {
@@ -38,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. */
@@ -89,17 +89,37 @@ export declare function analyzeTriangleMeshQuality(
  */
 export declare interface Anchor3 {
   /** Unit outward normal used as the anchor's local +Z direction. */
-  readonly direction: Vector3Tuple;
+  readonly direction: Vector3Data;
   /** World-space attachment position. */
-  readonly position: Vector3Tuple;
+  readonly position: Vector3Data;
   /** Roll guide projected into the plane perpendicular to `direction`. */
-  readonly up: Vector3Tuple;
+  readonly up: Vector3Data;
 }
 
+/**
+ * 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.
  */
@@ -118,9 +138,9 @@ export declare function anchorFrame3(
  * @returns A fresh transformed direction.
  */
 export declare function applyTransformDirection3(
-  transform: Transform3Matrix,
-  direction: Vector3Tuple,
-): Vector3Tuple;
+  transform: Transform3Data,
+  direction: Vector3Data,
+): Vector3Data;
 
 /**
  * Applies an affine transform to a point, including translation.
@@ -130,22 +150,22 @@ export declare function applyTransformDirection3(
  * @returns A fresh transformed point.
  */
 export declare function applyTransformPoint3(
-  transform: Transform3Matrix,
-  point: Vector3Tuple,
-): Vector3Tuple;
+  transform: Transform3Data,
+  point: Vector3Data,
+): Vector3Data;
 
 /** 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: Vector2Tuple;
+  readonly center: Vector2Data;
   /** 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. */
@@ -153,17 +173,17 @@ export declare interface ArcCurve3 {
   /** Selects a circular arc in the supplied plane. */
   readonly kind: "arc";
   /** Circle center in millimetres. */
-  readonly center: Vector3Tuple;
+  readonly center: Vector3Data;
   /** Positive circular radius in millimetres. */
   readonly radius: number;
   /** Orthogonal unit direction at zero degrees. */
-  readonly xAxis: Vector3Tuple;
+  readonly xAxis: Vector3Data;
   /** Orthogonal unit direction at positive ninety degrees. */
-  readonly yAxis: Vector3Tuple;
+  readonly yAxis: Vector3Data;
   /** 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;
 }
 
 /**
@@ -180,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,
-): Transform3Matrix;
+  options?: AttachOptions,
+): Transform3Data;
 
 /** 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;
 }
@@ -215,36 +235,86 @@ export declare type AxisAngleRotation3 =
       readonly degrees?: never;
     };
 
-/** Axis-aligned bounds in two-dimensional model space. */
-export declare interface Bounds2 {
+/** Immutable finite XY bounds in millimetres, with tuple coordinates for data interoperability. */
+export declare interface Bounds2 extends Bounds2Data {
+  /** Returns nonnegative X/Y dimensions in millimetres, including zero extents. */
+  size(): Vector2;
+  /** Returns the midpoint in millimetres. */
+  center(): Vector2;
+  /** Tests positioned XY containment, including touching boundaries. */
+  containsBounds(other: Bounds2Input): boolean;
+  /** Returns this value's frozen plain record; repeated calls do not allocate. */
+  toData(): Bounds2Data;
+}
+
+/**
+ * Snapshots finite ordered XY bounds in millimetres as an immutable fluent value.
+ *
+ * Zero extents are valid. Invalid dimensions, nonfinite coordinates, reversed bounds and
+ * overflowing extents throw `INVALID_ARGUMENT` GeometryError. Use `toData()` for plain records.
+ * Compiled Generator packages passing these values to host recipes or computed data require
+ * runtime 8.0.0 or newer in major 8.
+ */
+export declare function bounds2(input: Bounds2Input): Bounds2;
+
+/** Plain axis-aligned XY bounds for interchange; use bounds2 for immutable measurement methods. */
+export declare interface Bounds2Data {
   /** Inclusive maximum X/Y coordinates. */
-  readonly max: Vector2Tuple;
+  readonly max: Vector2Data;
   /** Inclusive minimum X/Y coordinates. */
-  readonly min: Vector2Tuple;
+  readonly min: Vector2Data;
 }
 
-/** Axis-aligned bounds in three-dimensional model space. */
-export declare interface Bounds3 {
+/** An immutable XY bounds value or its plain min/max representation. */
+export declare type Bounds2Input = Bounds2 | Bounds2Data;
+
+/** Immutable finite XYZ bounds in millimetres, with tuple coordinates for data interoperability. */
+export declare interface Bounds3 extends Bounds3Data {
+  /** Returns nonnegative X/Y/Z dimensions in millimetres, including zero extents. */
+  size(): Vector3;
+  /** Returns the midpoint in millimetres. */
+  center(): Vector3;
+  /** Tests positioned XYZ containment, including touching boundaries. */
+  containsBounds(other: Bounds3Input): boolean;
+  /** Returns this value's frozen plain record; repeated calls do not allocate. */
+  toData(): Bounds3Data;
+}
+
+/**
+ * Snapshots finite ordered XYZ bounds in millimetres as an immutable fluent value.
+ *
+ * Zero extents are valid. Invalid dimensions, nonfinite coordinates, reversed bounds and
+ * overflowing extents throw `INVALID_ARGUMENT` GeometryError. Use `toData()` for plain records.
+ * Compiled Generator packages passing these values to host recipes or computed data require
+ * runtime 8.0.0 or newer in major 8.
+ */
+export declare function bounds3(input: Bounds3Input): Bounds3;
+
+/** Plain axis-aligned XYZ bounds for interchange; use bounds3 for immutable measurement methods. */
+export declare interface Bounds3Data {
   /** Inclusive maximum X/Y/Z coordinates. */
-  readonly max: Vector3Tuple;
+  readonly max: Vector3Data;
   /** Inclusive minimum X/Y/Z coordinates. */
-  readonly min: Vector3Tuple;
+  readonly min: Vector3Data;
 }
 
+/** An immutable XYZ bounds value or its plain min/max representation. */
+export declare type Bounds3Input = Bounds3 | Bounds3Data;
+
 /** Midpoint of finite XY bounds in millimetres. */
-export declare function boundsCenter(bounds: Bounds2): Vector2Tuple;
+export declare function boundsCenter(bounds: Bounds2Data): Vector2Data;
 
 /** Midpoint of finite XYZ bounds in millimetres. */
-export declare function boundsCenter(bounds: Bounds3): Vector3Tuple;
+export declare function boundsCenter(bounds: Bounds3Data): Vector3Data;
 
 /** 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: Vector2Tuple;
+  readonly position: Vector2Data;
   /** Bounds after scaling and translation. */
-  readonly bounds: Bounds2;
+  readonly bounds: Bounds2Data;
 }
 
 /** A uniform XYZ scale followed by translation, and the resulting bounds. */
@@ -252,9 +322,9 @@ export declare interface BoundsFit3 {
   /** Positive uniform scale. */
   readonly scale: number;
   /** Millimetre translation applied after scaling around the origin. */
-  readonly position: Vector3Tuple;
+  readonly position: Vector3Data;
   /** Bounds after scaling and translation. */
-  readonly bounds: Bounds3;
+  readonly bounds: Bounds3Data;
 }
 
 /** Uniform fitting controls; fitting centers the source inside the target. */
@@ -265,15 +335,15 @@ export declare interface BoundsFitOptions {
 
 /** Creates immutable centered XY bounds from nonnegative dimensions in millimetres. */
 export declare function boundsFromSize(
-  size: Vector2Tuple,
+  size: Vector2Data,
   options?: BoundsFromSizeOptions,
-): Bounds2;
+): Bounds2Data;
 
 /** Creates immutable centered XYZ bounds from nonnegative dimensions in millimetres. */
 export declare function boundsFromSize(
-  size: Vector3Tuple,
+  size: Vector3Data,
   options?: BoundsFromSizeOptions,
-): Bounds3;
+): Bounds3Data;
 
 /** Placement of bounds constructed from nonnegative millimetre dimensions. */
 export declare interface BoundsFromSizeOptions {
@@ -282,10 +352,10 @@ export declare interface BoundsFromSizeOptions {
 }
 
 /** Inclusive XY dimensions in millimetres; zero extents are retained. */
-export declare function boundsSize(bounds: Bounds2): Vector2Tuple;
+export declare function boundsSize(bounds: Bounds2Data): Vector2Data;
 
 /** Inclusive XYZ dimensions in millimetres; zero extents are retained. */
-export declare function boundsSize(bounds: Bounds3): Vector3Tuple;
+export declare function boundsSize(bounds: Bounds3Data): Vector3Data;
 
 /** 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
@@ -300,13 +370,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 | Vector3Tuple;
+  readonly size: number | Vector3Data;
   /** 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?: Vector3Tuple;
+  readonly origin?: Vector3Data;
 }
 
 /** Box edges use +Z top, +Y front and +X right; vertical names list front/back first. */
@@ -335,7 +405,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>;
   /**
@@ -344,33 +414,11 @@ export declare interface BoxOptions extends PrimitivePlacement {
    */
   readonly center?: boolean;
   /** Positive uniform size or explicit `[X, Y, Z]` extents in millimetres. */
-  readonly size: number | Vector3Tuple;
+  readonly size: number | Vector3Data;
   /** 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";
 
@@ -467,63 +515,16 @@ export declare interface ClearanceHoleDimensions {
 /** Common clearance-hole fit categories, ordered from smallest to largest. */
 export declare type ClearanceHoleFit = "close" | "normal" | "loose";
 
-/**
- * Finds the closest position anywhere on an open XY path or closed contour.
- *
- * Open paths need two points; closed paths need three and omit the duplicated seam.
- * Repeated vertices are treated as zero-length edges. Inputs and derived distances must be
- * finite. Only the final result is allocated, so scanning a dense boundary creates no per-edge objects.
- * This measures the sampled boundary, not its filled interior or an underlying analytic curve.
- *
- * @example Find a point on a closed boundary
- * ```ts
- * closestPointOnPath([[0, 0], [10, 0], [10, 10]], [4, -2], { closed: true });
- * ```
- */
-export declare function closestPointOnPath(
-  path: Path2,
-  point: Vector2Tuple,
-  options?: ClosestPointOnPathOptions,
-): ClosestPointOnPathResult<Vector2Tuple>;
-
-/** Finds the closest position on an open XYZ path or explicitly closed spatial loop. */
-export declare function closestPointOnPath(
-  path: Path3,
-  point: Vector3Tuple,
-  options?: ClosestPointOnPathOptions,
-): ClosestPointOnPathResult<Vector3Tuple>;
-
-/** Topology and work ceiling for a closest-point query on a sampled path. */
-export declare interface ClosestPointOnPathOptions {
-  /** Include the last-to-first edge without duplicating the seam point. Defaults to false. */
-  readonly closed?: boolean;
-  /** Explicit path point ceiling; defaults to the package sampling limits. */
-  readonly limits?: Partial<GeometrySamplingLimits>;
-}
-
-/** Closest position on a sampled path, measured in millimetres. */
-export declare interface ClosestPointOnPathResult<
-  Point extends Vector2Tuple | Vector3Tuple,
-> {
-  /** Copied position on the selected edge. */
-  readonly point: Point;
-  /** Euclidean distance from the query point to the path. */
-  readonly distance: number;
-  /** Zero-based starting vertex of the selected edge. Equal distances keep the first edge. */
-  readonly edgeIndex: number;
-  /** Clamped interpolation fraction from the edge's start to its end. */
-  readonly fraction: number;
-}
-
 /**
  * Closes an open, strictly upward [radius, height] side outline to the radius-zero axis.
+ *
  * Adds horizontal bottom/top edges at the endpoint heights, retaining axis endpoints once.
  * Returns a counterclockwise filled-boundary contour without a repeated seam vertex.
  * Radii must be nonnegative; the result must enclose nonzero area without touching itself.
  * This is a solid-body closure, not a hollow-wall or mounting-bore construction.
  */
 export declare function closeToAxis(
-  side: readonly Vector2Tuple[],
+  side: readonly Vector2Data[],
   limits?: Partial<GeometrySamplingLimits>,
 ): Contour;
 
@@ -590,9 +591,9 @@ export declare function compensateThreadProfileForFaceting(
  * @returns A new frozen transform equal to `after * before`.
  */
 export declare function composeTransform3(
-  after: Transform3Matrix,
-  before: Transform3Matrix,
-): Transform3Matrix;
+  after: Transform3Data,
+  before: Transform3Data,
+): Transform3Data;
 
 /**
  * Builds rotation-minimizing frames for a non-duplicated closed path.
@@ -601,27 +602,34 @@ 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 Vector3Tuple[],
-  initialNormal?: Vector3Tuple,
+  input: Path3Input,
+  initialNormal?: Vector3Input,
   limits?: Partial<GeometrySamplingLimits>,
 ) => readonly PathFrame[];
 
 /**
  * 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 Vector3Tuple[],
-  initialNormal?: Vector3Tuple,
+  input: Path3Input,
+  initialNormal?: Vector3Input,
   normalGuide?: PathNormalGuide,
   limits?: Partial<GeometrySamplingLimits>,
 ) => readonly PathFrame[];
 
 /**
  * Computes the uniform-density volume centroid of an oriented closed solid, including cavity shells.
+ *
  * Coordinates are millimetres. Indexed closure and positive aggregate volume are required; callers
  * may use validateSolidMesh first when geometric intersections and shell orientation are untrusted.
  * Fresh mutable input is inspected on every call, and buffers are never changed.
@@ -631,26 +639,53 @@ export declare const computeParallelTransportFrames: (
  */
 export declare function computeTriangleMeshCentroid(
   mesh: TriangleMesh,
-): Vector3Tuple;
+): Vector3Data;
+
+/**
+ * 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;
+export declare function containsBounds(
+  outer: Bounds2Data,
+  inner: Bounds2Data,
+): boolean;
 
 /** Tests actual XYZ containment, including touching boundaries; dimensions must match. */
-export declare function containsBounds(outer: Bounds3, inner: Bounds3): boolean;
+export declare function containsBounds(
+  outer: Bounds3Data,
+  inner: Bounds3Data,
+): boolean;
 
 /**
- * A closed two-dimensional boundary whose first point is not repeated at the end.
+ * A sampled closed two-dimensional boundary whose first point is not repeated at the end.
  *
  * Polygon exteriors are counter-clockwise and holes are clockwise. Algorithms
  * may reject duplicate adjacent points or fewer than three effective vertices.
+ * Use PolygonData to assign an exterior and its holes, or ProfileContour2 for identified curve spans.
+ *
+ * @see {@link PolygonData}
+ * @see [ProfileContour2](/docs/reference/geometry/ProfileContour2)
  */
-export declare type Contour = readonly Vector2Tuple[];
+export declare type Contour = readonly Vector2Data[];
 
 /** Returns true when a point lies inside or on the boundary of a loop. */
 export declare function contourContainsPoint(
   loop: Contour,
-  point: Vector2Tuple,
+  point: Vector2Data,
 ): boolean;
 
 /** One explicitly closed planar contour, independent of editor metadata and parameter contracts. */
@@ -720,61 +755,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: Vector3Tuple,
-  direction: Vector3Tuple,
-  up?: Vector3Tuple,
-  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;
+export declare const cross2: (a: Vector2Data, b: Vector2Data) => number;
 
 /**
  * Returns the right-handed cross product.
@@ -783,20 +765,20 @@ export declare const cross2: (a: Vector2Tuple, b: Vector2Tuple) => number;
  * cross3([1, 0, 0], [0, 1, 0]); // [0, 0, 1]
  * ```
  */
-export declare const cross3: (a: Vector3Tuple, b: Vector3Tuple) => Vector3Tuple;
+export declare const cross3: (a: Vector3Data, b: Vector3Data) => Vector3Data;
 
 /** 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: Vector2Tuple;
+  readonly start: Vector2Data;
   /** First XY control point in millimetres. */
-  readonly control1: Vector2Tuple;
+  readonly control1: Vector2Data;
   /** Second XY control point in millimetres. */
-  readonly control2: Vector2Tuple;
+  readonly control2: Vector2Data;
   /** Final XY point in millimetres. */
-  readonly end: Vector2Tuple;
+  readonly end: Vector2Data;
 }
 
 /**
@@ -806,21 +788,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: Vector3Tuple;
+  readonly start: Vector3Data;
   /** First XYZ control point in millimetres. */
-  readonly control1: Vector3Tuple;
+  readonly control1: Vector3Data;
   /** Second XYZ control point in millimetres. */
-  readonly control2: Vector3Tuple;
+  readonly control2: Vector3Data;
   /** Final XYZ point in millimetres. */
-  readonly end: Vector3Tuple;
+  readonly end: Vector3Data;
 }
 
-/** Returns cumulative arc length for finite points under maxPathPoints (default 100000); rejects overflowing length. */
-export declare const cumulativePathLengths: (
-  path: readonly Vector3Tuple[],
-  limits?: Partial<GeometrySamplingLimits>,
-) => readonly number[];
-
 /** Reusable planar curve definition. */
 export declare type Curve2 = LineCurve2 | ArcCurve2 | CubicBezierCurve2;
 
@@ -838,7 +814,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>;
 }
@@ -851,7 +827,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 Vector2Tuple[];
+  readonly points: readonly Vector2Data[];
 }
 
 /** Creates a cap-center or radial-side anchor using cylinder()'s construction origin.
@@ -874,11 +850,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?: Vector3Tuple;
+  readonly origin?: Vector3Data;
 }
 
 /**
@@ -886,7 +862,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`
@@ -918,7 +894,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. */
@@ -985,7 +961,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. */
@@ -1021,7 +997,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.
@@ -1032,11 +1008,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;
 }
@@ -1055,10 +1031,10 @@ export declare const DEFAULT_GEOMETRY_TOLERANCE: Readonly<{
 export declare const defaultGeometrySamplingLimits: GeometrySamplingLimits;
 
 /** Returns Euclidean point distance without allocating an intermediate difference vector. */
-export declare const distance2: (a: Vector2Tuple, b: Vector2Tuple) => number;
+export declare const distance2: (a: Vector2Data, b: Vector2Data) => number;
 
 /** Returns Euclidean point distance without allocating an intermediate difference vector. */
-export declare const distance3: (a: Vector3Tuple, b: Vector3Tuple) => number;
+export declare const distance3: (a: Vector3Data, b: Vector3Data) => number;
 
 /**
  * Places an exact item count at equal arc-length intervals along a sampled path.
@@ -1067,16 +1043,18 @@ export declare const distance3: (a: Vector3Tuple, b: Vector3Tuple) => number;
  * 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 Vector3Tuple[],
+  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;
+export declare const dot2: (a: Vector2Data, b: Vector2Data) => number;
 
 /**
  * Returns the scalar dot product.
@@ -1085,7 +1063,7 @@ export declare const dot2: (a: Vector2Tuple, b: Vector2Tuple) => number;
  * dot3([1, 0, 0], [0, 1, 0]); // 0
  * ```
  */
-export declare const dot3: (a: Vector3Tuple, b: Vector3Tuple) => number;
+export declare const dot3: (a: Vector3Data, b: Vector3Data) => number;
 
 /**
  * Uniform finishing vocabulary shared by applicable solid edges and profile corners.
@@ -1113,13 +1091,13 @@ export declare type EllipseContourOptions = CircularPrimitiveOptions &
   (
     | {
         /** Positive XY radii in millimetres; mutually exclusive with size. */
-        readonly radius: Vector2Tuple;
+        readonly radius: Vector2Data;
         /** Full XY extents are unavailable when radius is supplied. */
         readonly size?: never;
       }
     | {
         /** Positive full XY extents in millimetres; mutually exclusive with radius. */
-        readonly size: Vector2Tuple;
+        readonly size: Vector2Data;
         /** XY radii are unavailable when size is supplied. */
         readonly radius?: never;
       }
@@ -1147,11 +1125,12 @@ export declare interface EndTreatments {
  * @throws {@link GeometryError} When an angle is non-finite.
  */
 export declare function eulerTransform3(
-  rotationDegrees: Vector3Tuple,
-): Transform3Matrix;
+  rotationDegrees: Vector3Data,
+): Transform3Data;
 
 /**
  * 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
@@ -1160,7 +1139,7 @@ export declare function eulerTransform3(
  * ```
  */
 export declare function extrudeMesh(
-  profile: Contour,
+  input: Path2Input,
   options: ExtrudeOptions,
 ): TriangleMesh;
 
@@ -1185,22 +1164,22 @@ 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 | Vector2Tuple;
+  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. */
 export declare function fitBounds(
-  source: Bounds2,
-  target: Bounds2,
+  source: Bounds2Data,
+  target: Bounds2Data,
   options?: BoundsFitOptions,
 ): BoundsFit2;
 
 /** Fits XYZ bounds uniformly and centers them in the target; zero source axes do not constrain scale. */
 export declare function fitBounds(
-  source: Bounds3,
-  target: Bounds3,
+  source: Bounds3Data,
+  target: Bounds3Data,
   options?: BoundsFitOptions,
 ): BoundsFit3;
 
@@ -1209,12 +1188,13 @@ export declare interface FittedTextLayout extends VectorTextLayout {
   /** Transformed physical measurements, including nonempty visible ink bounds. */
   readonly metrics: VectorTextMetrics & {
     /** Finite positive-area ink bounds in final millimetres. */
-    readonly bounds: Bounds2;
+    readonly bounds: Bounds2Data;
   };
 }
 
 /**
  * Uniformly fits visible text ink inside finite XY bounds, centering it on the target.
+ *
  * Transforms retained vector paths before sampling, so later textSection/sampleTextContours
  * resolution remains in final millimetres. Logical advances scale without translation;
  * line count is unchanged. The input layout is preserved.
@@ -1227,20 +1207,20 @@ export declare interface FittedTextLayout extends VectorTextLayout {
  */
 export declare function fitTextLayout(
   layout: VectorTextLayout,
-  target: Bounds2,
+  target: Bounds2Data,
   options?: BoundsFitOptions,
 ): FittedTextLayout;
 
 /** A right-handed orthonormal coordinate frame expressed in world coordinates. */
 export declare interface Frame3 {
   /** World-space origin of the local frame. */
-  readonly origin: Vector3Tuple;
+  readonly origin: Vector3Data;
   /** Unit vector defining the local +X axis. */
-  readonly xAxis: Vector3Tuple;
+  readonly xAxis: Vector3Data;
   /** Unit vector defining the local +Y axis. */
-  readonly yAxis: Vector3Tuple;
+  readonly yAxis: Vector3Data;
   /** Unit vector defining the local +Z axis. */
-  readonly zAxis: Vector3Tuple;
+  readonly zAxis: Vector3Data;
 }
 
 /**
@@ -1254,7 +1234,7 @@ export declare interface Frame3 {
 export declare function frameTransform3(
   frame: Frame3,
   tolerance?: GeometryToleranceOptions,
-): Transform3Matrix;
+): Transform3Data;
 
 /**
  * Error raised when a geometry precondition or invariant is not satisfied.
@@ -1321,9 +1301,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. */
@@ -1349,7 +1329,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;
@@ -1361,8 +1341,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. */
@@ -1370,29 +1351,34 @@ export declare type GridPatternOptions = {
 } & (
   | {
       /** Positive integer counts on X and Y. */
-      readonly count: Vector2Tuple;
+      readonly count: Vector2Data;
       /** Signed millimetres between adjacent copies on X and Y. */
-      readonly spacing: Vector2Tuple;
-    }
-  | {
-      /** Positive integer counts on X, Y and Z. */
-      readonly count: Vector3Tuple;
-      /** Signed millimetres between adjacent copies on X, Y and Z. */
-      readonly spacing: Vector3Tuple;
+      readonly spacing: Vector2Data;
     }
+  | (Dimension extends 3
+      ? {
+          /** Positive integer counts on X, Y and Z. */
+          readonly count: Vector3Data;
+          /** Signed millimetres between adjacent copies on X, Y and Z. */
+          readonly spacing: Vector3Data;
+        }
+      : 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 Transform3Matrix[];
+): readonly Transform3Data[];
 
 /**
  * Builds a closed indexed mesh from a rectilinear top, matched boundary walls, and flat base.
+ *
  * Heights run once per grid point after preflight; center-error adds one evaluation per cell.
  * Top winding is +Z, the base is -Z, and sides face outward. Coordinates and heights must fit
  * Float32 storage. Explicit axes are captured before sampling; shared wall vertices prevent cracks.
  *
+ * @see {@link preflightHeightfield}
+ *
  * @example Sample a closed wavy mesh
  * ```ts
  * heightfieldMesh({
@@ -1422,7 +1408,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: Vector2Tuple) => number;
+  readonly height: (point: Vector2Data) => number;
   /** Flat bottom Z. Defaults to zero. */
   readonly baseZ?: number;
   /**
@@ -1435,11 +1421,11 @@ export declare type HeightfieldOptions = {
 } & (
   | {
       /** Positive XY footprint for uniform sampling. */
-      readonly size: Vector2Tuple;
+      readonly size: Vector2Data;
       /** 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?: Vector2Tuple;
+      readonly origin?: Vector2Data;
       /** Explicit coordinates cannot be combined with uniform sampling. */
       readonly coordinates?: never;
     }
@@ -1463,18 +1449,27 @@ export declare type HeightfieldOptions = {
     }
 );
 
-/** Predictable rectilinear-grid allocation facts; this does not evaluate the height callback. */
+/** Exact grid and mesh buffer allocation counts resolved without evaluating the height callback. */
 export declare interface HeightfieldPreflight {
-  /** Number of top grid points; center-error also evaluates one height per cell. */
+  /** Number of top grid points; excludes the extra per-cell height evaluations for center-error. */
   readonly sampleCount: number;
   /** Number of allocated XYZ vertices. */
   readonly vertexCount: number;
   /** Number of allocated indexed triangles. */
   readonly triangleCount: number;
-  /** Total bytes of Float32 positions and Uint32 indices. */
+  /** Total bytes of Float32 positions and Uint32 indices, excluding temporary storage. */
   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 {
   /**
@@ -1491,7 +1486,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. */
@@ -1502,6 +1497,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. */
@@ -1520,7 +1528,7 @@ export declare interface HelicalThreadSolidMeshOptions extends HelicalThreadRidg
   readonly bevelTopSize?: number;
 }
 
-/** Conservative allocation facts resolved before constructing a direct thread solid mesh. */
+/** Selected sampling counts and conservative allocation estimates, before thread mesh construction. */
 export declare interface HelicalThreadSolidMeshPreflight {
   /** Uniform axial intervals required only by a requested physical segment-length limit. */
   readonly axialIntervals: number;
@@ -1533,7 +1541,7 @@ export declare interface HelicalThreadSolidMeshPreflight {
 }
 
 /** Identity transform, safe to share because it is frozen. */
-export declare const IDENTITY_TRANSFORM3: Transform3Matrix;
+export declare const IDENTITY_TRANSFORM3: Transform3Data;
 
 /** Options for a compensated internal-thread subtraction tool along +Z. */
 export declare interface InternalThreadCutterOptions
@@ -1553,11 +1561,12 @@ export declare interface InternalThreadCutterOptions
  * @returns A new frozen transform whose composition with the input is identity.
  */
 export declare function inverseTransform3(
-  transform: Transform3Matrix,
-): Transform3Matrix;
+  transform: Transform3Data,
+): Transform3Data;
 
 /**
  * Recognizes structured geometry errors from separately bundled Modeling copies in the same realm.
+ *
  * Ordinary errors and unmarked code-shaped objects are rejected. The marker is execution-local and
  * does not survive structured cloning; worker protocols carry their own serialized error envelope.
  */
@@ -1576,42 +1585,136 @@ export declare function joinTriangleMeshes(
   meshes: readonly TriangleMesh[],
 ): TriangleMesh;
 
+/** Shared knuckle-joint dimensions in millimetres, independent of mounting geometry. */
+export declare interface KnuckleHingeBaseSpec {
+  /** Total extent along the +X pin axis, centered at the origin. */
+  readonly length: number;
+  /** Number of equal alternating intervals, starting with half A. */
+  readonly knuckleCount: number;
+  /** Outside vertex-sized barrel diameter. */
+  readonly barrelDiameter: number;
+  /** Vertex-sized shaft diameter, including an externally supplied shaft. */
+  readonly pinDiameter: number;
+  /** Nonnegative per-side radial allowance; bores circumscribe this running envelope. */
+  readonly radialClearance: number;
+  /** Nonnegative total air gap between each neighboring pair of knuckle ends. */
+  readonly axialGap: number;
+}
+
+/** Immutable joint layout and conservative faceted envelopes; no engine initialization. */
+export declare interface KnuckleHingeDimensions {
+  /** Validated, copied nominal inputs. */
+  readonly spec: KnuckleHingeSpec;
+  /** Nominal outside barrel radius. */
+  readonly barrelRadius: number;
+  /** Maximum shaft radius under any rotation. */
+  readonly pinRadius: number;
+  /** Minimum face-sized bore radius, including radial clearance. */
+  readonly boreRadius: number;
+  /** Maximum radius at the faceted bore vertices. */
+  readonly boreOuterRadius: number;
+  /** Conservative radial wall before outer end chamfers, accounting for both polygons. */
+  readonly minimumBarrelWall: number;
+  /** Equal length of every interval. */
+  readonly knuckleLength: number;
+  /** Common exact full-circle segment count. */
+  readonly segments: number;
+  /** Alternating schedule ordered from negative to positive X. */
+  readonly knuckles: readonly KnuckleHingeInterval[];
+  /** Integral pin interval; null when the consumer supplies an inserted pin. */
+  readonly pin: Readonly<{
+    /** Start coordinate along X, in millimetres. */
+    start: number;
+    /** Total integral shaft length, including material inside A. */
+    length: number;
+  }> | null;
+  /** Origin at the joint center, direction +X, roll guide +Z. */
+  readonly axis: Anchor3;
+}
+
+/** One equal-length barrel interval in the shared pin-centered frame. */
+export declare interface KnuckleHingeInterval {
+  /** Alternating owner, beginning with A at the negative end of X. */
+  readonly side: "a" | "b";
+  /** Start along X, in millimetres. */
+  readonly start: number;
+  /** Axial length, excluding the neighboring gaps. */
+  readonly length: number;
+}
+
+/** Shared circular sampling for barrels, shafts, and bores. */
+export declare interface KnuckleHingeSamplingOptions {
+  /** Exact full-circle count, divisible by four and at least four; overrides adaptive sampling. */
+  readonly segments?: number;
+  /** Physical tessellation policy. Exact circular counts must also be divisible by four. */
+  readonly resolution?: GeometryResolution;
+  /** Explicit allocation ceilings; defaults to the pure geometry sampling limits. */
+  readonly limits?: Partial<GeometrySamplingLimits>;
+}
+
+/**
+ * Knuckle-joint construction modes and interval ownership.
+ *
+ * Print-in-place requires an odd count of at least three: A owns both
+ * end anchors and the entire shaft. Inserted-pin bores both halves and supplies no shaft.
+ * Lift-off requires exactly two intervals; A's integral pin enters B without a far anchor.
+ */
+export declare type KnuckleHingeSpec = KnuckleHingeBaseSpec &
+  (
+    | {
+        /** Captive integral shaft or bores for an externally supplied pin. */
+        readonly mode: "print-in-place" | "inserted-pin";
+        /** Engagement applies only to lift-off construction. */
+        readonly pinEngagement?: never;
+      }
+    | {
+        /** Detachable socket on a finite integral pin. */
+        readonly mode: "lift-off";
+        /** Lift-off has one fixed interval and one removable interval. */
+        readonly knuckleCount: 2;
+        /** Positive axial engagement into B, no greater than its knuckle length. */
+        readonly pinEngagement: number;
+      }
+  );
+
 /**
  * Returns immutable translations for a +X row of finite XYZ bounds with a nonnegative gap.
+ *
  * Each minimum Y/Z becomes zero, and the first minimum X becomes zero. Supply bounds after
  * any intended part rotation; translations apply to those bounds. An empty input returns [].
  */
 export declare function layoutRow(
-  bounds: readonly Bounds3[],
+  bounds: readonly Bounds3Data[],
   options?: RowLayoutOptions,
-): readonly Vector3Tuple[];
+): readonly Vector3Data[];
 
 /** Returns Euclidean vector length in the vector's coordinate units. */
-export declare const length2: (vector: Vector2Tuple) => number;
+export declare const length2: (vector: Vector2Data) => number;
 
 /** Returns Euclidean vector length in the vector's coordinate units. */
-export declare const length3: (vector: Vector3Tuple) => number;
+export declare const length3: (vector: Vector3Data) => number;
 
 /** Linearly interpolates two vectors; `t` is dimensionless and may extrapolate. */
 export declare const lerp2: (
-  a: Vector2Tuple,
-  b: Vector2Tuple,
+  a: Vector2Data,
+  b: Vector2Data,
   t: number,
-) => Vector2Tuple;
+) => Vector2Data;
 
 /** Linearly interpolates two vectors; `t` is dimensionless and may extrapolate. */
 export declare const lerp3: (
-  a: Vector3Tuple,
-  b: Vector3Tuple,
+  a: Vector3Data,
+  b: Vector3Data,
   t: number,
-) => Vector3Tuple;
+) => Vector3Data;
 
 /**
  * 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?: Vector3Tuple;
+  readonly direction?: Dimension extends 2 ? Vector2Input : Vector3Input;
 } & (
   | {
       /** Positive copy count, including the original. */
@@ -1639,19 +1742,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 Transform3Matrix[];
+): readonly Transform3Data[];
 
 /** 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: Vector2Tuple;
+  readonly start: Vector2Data;
   /** Final XY point in millimetres. */
-  readonly end: Vector2Tuple;
+  readonly end: Vector2Data;
 }
 
 /** Straight spatial curve in millimetres. */
@@ -1659,9 +1762,9 @@ export declare interface LineCurve3 {
   /** Selects straight interpolation between the two endpoints. */
   readonly kind: "line";
   /** Initial XYZ point in millimetres. */
-  readonly start: Vector3Tuple;
+  readonly start: Vector3Data;
   /** Final XYZ point in millimetres. */
-  readonly end: Vector3Tuple;
+  readonly end: Vector3Data;
 }
 
 /**
@@ -1688,6 +1791,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
@@ -1703,8 +1807,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;
 };
 
 /**
@@ -1744,6 +1848,7 @@ export declare type LoftPlacement =
 
 /**
  * Explicitly matches identified component/contour/span topology across a family.
+ *
  * Every paired span uses the maximum physical subdivision count requested by any member.
  * Cubics share a checked uniform parameter grid, including grids selected by exact paired requests.
  * Input order and winding are preserved. Collapsed spans retain repeated logical slots, which
@@ -1784,21 +1889,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.
  *
@@ -1806,7 +1896,7 @@ export declare function measureTriangleMesh(
  * @returns Fresh immutable minimum and maximum XYZ tuples.
  * @throws {@link GeometryError} When the mesh is structurally invalid.
  */
-export declare const meshBounds: (mesh: TriangleMesh) => Bounds3;
+export declare const meshBounds: (mesh: TriangleMesh) => Bounds3Data;
 
 /**
  * Curated metric modeling dimensions for clearance holes, regular hex nuts,
@@ -1837,7 +1927,7 @@ export declare const METRIC_FASTENER_STANDARDS: Readonly<{
   M12: MetricFastenerStandard;
 }>;
 
-/** Metric fastener sizes included in the first mechanical standards table. */
+/** Supported metric fastener sizes. */
 export declare type MetricFastenerSize =
   "M2" | "M2.5" | "M3" | "M4" | "M5" | "M6" | "M8" | "M10" | "M12";
 
@@ -1880,9 +1970,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. */
@@ -1899,23 +1987,25 @@ export declare interface ModelingLimits extends GeometrySamplingLimits {
 
 /**
  * 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,
+  vector: Vector2Data,
   epsilon?: number,
-) => Vector2Tuple;
+) => Vector2Data;
 
 /**
  * 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,
+  vector: Vector3Data,
   epsilon?: number,
-) => Vector3Tuple;
+) => Vector3Data;
 
 /**
  * Cleans and validates one closed loop.
@@ -1926,7 +2016,7 @@ export declare const normalize3: (
  * returned unchanged when their winding and tolerance policy match.
  */
 export declare function normalizeContour(
-  input: readonly Vector2Tuple[],
+  input: readonly Vector2Data[],
   counterClockwise: boolean,
   tolerance?: GeometryToleranceOptions,
 ): Contour;
@@ -1970,31 +2060,120 @@ export declare function optimizePlanarPatches(
   options?: PlanarMeshOptimizationOptions,
 ): PlanarMeshOptimizationResult;
 
-/** An ordered, open sequence of two-dimensional points. */
-export declare type Path2 = readonly Vector2Tuple[];
+/** 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 complete deeply frozen path data, including dimension and closure. Repeated calls do not allocate. */
+  toData(): Path2Data;
+  /** Total sampled edge length in model units, including the closing edge when closed. */
+  length(): number;
+  /** Immutable 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.
+ *
+ * Use `toData()` for a frozen record that restores coordinates, closure, and dimension together.
+ */
+export declare function path2(input: Path2Input, options?: PathOptions): Path2;
+
+/** Complete plain XY path representation, including topology and empty-path dimensional identity. */
+export declare interface Path2Data {
+  /** Coordinate dimension, retained even when points is empty. */
+  readonly dimension: 2;
+  /** Frozen or caller-owned XY coordinates; closed paths omit a duplicated seam. */
+  readonly points: readonly Vector2Data[];
+  /** Whether traversal includes the last-to-first edge. */
+  readonly closed: boolean;
+}
+
+/** A matching path value, complete plain path data, or a collection of vectors. */
+export declare type Path2Input = Path2 | Path2Data | 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 complete deeply frozen path data, including dimension and closure. Repeated calls do not allocate. */
+  toData(): Path3Data;
+  /** Total sampled edge length in model units, including the closing edge when closed. */
+  length(): number;
+  /** Immutable 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;
+}
 
 /**
- * An ordered, open sequence of three-dimensional points.
+ * 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.
+ *
+ * Use `toData()` for a frozen record that restores coordinates, closure, and dimension together.
+ *
+ * @see {@link path2} for shared construction rules.
  */
-export declare type Path3 = readonly Vector3Tuple[];
+export declare function path3(input: Path3Input, options?: PathOptions): Path3;
+
+/** Complete plain XYZ path representation, including topology and empty-path dimensional identity. */
+export declare interface Path3Data {
+  /** Coordinate dimension, retained even when points is empty. */
+  readonly dimension: 3;
+  /** Frozen or caller-owned XYZ coordinates; closed paths omit a duplicated seam. */
+  readonly points: readonly Vector3Data[];
+  /** Whether traversal includes the last-to-first edge. */
+  readonly closed: boolean;
+}
+
+/** A matching path value, complete plain path data, or a collection of vectors. */
+export declare type Path3Input = Path3 | Path3Data | readonly Vector3Input[];
 
 /** Orthonormal right-handed frame sampled along a path. */
 export declare interface PathFrame {
   /** Unit path tangent. */
-  readonly tangent: Vector3Tuple;
+  readonly tangent: Vector3Data;
   /** Unit transported profile X axis. */
-  readonly normal: Vector3Tuple;
+  readonly normal: Vector3Data;
   /** Unit profile Y axis equal to tangent × normal. */
-  readonly binormal: Vector3Tuple;
+  readonly binormal: Vector3Data;
 }
 
-/**
- * Returns total sampled 3D path length, or zero for an empty path.
- */
-export declare const pathLength: (
-  path: readonly Vector3Tuple[],
-  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.
@@ -2004,37 +2183,53 @@ export declare const pathLength: (
  * @returns A finite guide vector that is not parallel to the local path tangent.
  */
 export declare type PathNormalGuide = (
-  point: Vector3Tuple,
+  point: Vector3Data,
   index: number,
-) => Vector3Tuple;
+) => 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";
 }
 
 /**
- * Equal physical arc-length placements along a sampled XYZ path. Tangent orientation maps +Z
+ * Equal physical arc-length placements along a sampled XYZ path.
+ *
+ * Tangent orientation maps +Z
  * onto the local path tangent; fixed orientation only translates. Closed paths omit a repeated seam.
  * Explicit sampling ceilings bound both input points and output placements.
  */
 export declare function pathPatternTransforms(
-  path: readonly Vector3Tuple[],
+  path: Path3Input,
   options: PathPatternOptions,
   limits?: Partial<GeometrySamplingLimits>,
-): readonly Transform3Matrix[];
+): readonly Transform3Data[];
 
 /** Position and unit tangent for one path-distributed item. */
 export declare interface PathPlacement {
   /** Interpolated point on the sampled path. */
-  readonly position: Vector3Tuple;
+  readonly position: Vector3Data;
   /** Unit tangent of the path segment containing the placement. */
-  readonly tangent: Vector3Tuple;
+  readonly tangent: Vector3Data;
+}
+
+/** 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. */
@@ -2063,23 +2258,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. */
@@ -2127,7 +2322,7 @@ export declare interface PlanarPatchQuality {
   /** Smallest interior triangle angle in degrees. */
   readonly minimumTriangleAngleDegrees: number;
   /** Consistently wound unit normal for the patch plane. */
-  readonly normal: Vector3Tuple;
+  readonly normal: Vector3Data;
   /** Plane offset in `dot(normal, position) = planeOffset` form, in model units. */
   readonly planeOffset: number;
   /** Total patch area in squared model units. */
@@ -2139,11 +2334,14 @@ export declare interface PlanarPatchQuality {
 }
 
 /**
- * One bounded two-dimensional polygon.
+ * One filled two-dimensional polygon with an exterior and optional holes.
  *
  * `outer` is counter-clockwise and each hole is clockwise. Boundary arrays omit
  * their duplicated closing point. Holes must lie inside `outer` and must not
  * intersect each other or the exterior.
+ *
+ * @see {@link Contour}
+ * @see {@link RegionData}
  */
 export declare interface PolygonData {
   /** Clockwise interior boundaries, each omitting its duplicated closing point. */
@@ -2162,31 +2360,60 @@ export declare interface PolylineResamplingOptions extends CurveSamplingOptions
   readonly closed?: boolean;
 }
 
-/** Checks grid dimensions, coordinate precision, and allocation bounds before evaluating heights. */
+/**
+ * Checks grid options, Float32 axis precision, and output limits; returns exact mesh buffer counts.
+ *
+ * This pure operation needs no engine and neither evaluates `height` nor allocates mesh buffers.
+ * Successful preflight leaves height values, Float32 base storage, and generated mesh validity to
+ * construction. `byteCount` covers position and index buffers, not total working memory.
+ *
+ * @see {@link heightfieldMesh}
+ */
 export declare function preflightHeightfield(
   options: HeightfieldOptions,
   limits?: HeightfieldMeshLimits,
 ): HeightfieldPreflight;
 
 /**
- * Validates a direct thread solid and returns its conservative allocation estimate without
- * constructing vertex or index buffers.
+ * Checks thread dimensions, profile, end treatments, sampling, and conservative estimates against output limits.
+ *
+ * This pure operation needs no engine and constructs planning data without vertex or index buffers.
+ * `circularSegments` is the selected count; row and triangle counts are conservative estimates.
+ * Successful preflight leaves generated coordinate and topology checks to mesh construction.
+ *
+ * @see {@link helicalThreadSolidMesh}
  */
 export declare function preflightHelicalThreadSolidMesh(
   options: HelicalThreadSolidMeshOptions,
 ): HelicalThreadSolidMeshPreflight;
 
-/** Preflights the exact extended mesh used by the internal thread cutter constructor. */
+/**
+ * Resolves compensated cutter dimensions and checks extended mesh estimates against output limits.
+ *
+ * This pure operation uses explicit resolution and limits or package defaults, without an active
+ * host execution. It includes the cutter's one-pitch extension beyond each requested face and
+ * creates planning data without mesh buffers or native objects. Row and triangle counts are
+ * estimates; mesh validity and native construction are checked later.
+ *
+ * @see {@link preflightHelicalThreadSolidMesh}
+ * @see {@link helicalThreadSolidMesh}
+ */
 export declare function preflightInternalThreadCutter(
   options: InternalThreadCutterOptions,
 ): HelicalThreadSolidMeshPreflight;
 
 /**
- * Preflights bounded SVG geometry without browser or Manifold dependencies.
+ * Parses and validates bounded SVG input, constructing its normalized sampled region and diagnostics.
+ *
+ * This pure operation performs curve flattening, fill and stroke construction, and polygon union;
+ * it needs no browser or engine. Geometry counts measure the returned region at the selected
+ * resolution, rather than predicting later mesh allocation. The region may be empty; tiny-island
+ * and short-edge indicators do not establish manufacturability or later solid validity.
  *
  * @param svg - Complete SVG XML source, limited to 256 KiB of UTF-8.
  * @param options - Physical flattening and viewport-origin controls.
  * @returns The canonical normalized region plus bounded source, topology, and safe-repair facts.
+ * @throws {@link GeometryError} When XML, supported-feature, geometry, or complexity checks fail.
  */
 export declare function preflightSvgRegion(
   svg: string,
@@ -2194,38 +2421,45 @@ export declare function preflightSvgRegion(
 ): SvgRegionPreflight;
 
 /**
- * Resolves a nut's exact body/cutter chamfer and preflights its extended thread mesh without
- * allocating Manifold WASM objects.
+ * Checks nut dimensions, chamfers, end-face wall, and the extended compensated cutter's allocation plan.
+ *
+ * This pure operation uses explicit resolution and limits or package defaults, without an active
+ * host execution. It resolves body/cutter dimensions without mesh buffers or native objects.
+ * `thread` contains conservative cutter estimates, excluding the body and Boolean result.
+ * Successful preflight leaves mesh validity, native construction, and manufacturing fit to later checks.
+ *
+ * @see {@link preflightHelicalThreadSolidMesh}
  */
 export declare function preflightThreadedNut(
   options: ThreadedNutOptions,
 ): ThreadedNutPreflight;
 
-/** Preflights the exact compensated direct mesh used by the threaded rod constructor. */
+/**
+ * Resolves compensated rod dimensions and checks conservative mesh estimates against output limits.
+ *
+ * This pure operation uses explicit resolution and limits or package defaults, without an active
+ * host execution. It creates planning data without mesh buffers or native objects; returned row
+ * and triangle counts are estimates. Mesh validity and native construction are checked later.
+ *
+ * @see {@link preflightHelicalThreadSolidMesh}
+ * @see {@link helicalThreadSolidMesh}
+ */
 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;
 }
 
 /**
@@ -2264,7 +2498,13 @@ export declare interface PrintableThreadFitPolicy {
   readonly maleRadialInset: number;
 }
 
-/** An explicit component/contour/span topology, before shared family sampling. */
+/**
+ * An explicit component/contour/span topology, before shared family sampling with matchProfiles.
+ * Component, contour and span identities establish correspondence across a loft or sweep family.
+ *
+ * @see {@link CorrespondingProfile}
+ * @see {@link matchProfiles}
+ */
 export declare interface Profile {
   /** Ordered components with explicit contour identities. */
   readonly components: readonly ProfileComponent2[];
@@ -2280,7 +2520,13 @@ export declare interface ProfileComponent2 {
   readonly holes: readonly ProfileContour2[];
 }
 
-/** Ordered, closed spans. Outer winding is CCW and hole winding is CW. */
+/**
+ * An identified closed boundary of curve spans, before shared family sampling.
+ * Outer winding is CCW and hole winding is CW. matchProfiles retains span identities in sampled contours.
+ *
+ * @see {@link Contour} for sampled point coordinates.
+ * @see {@link CorrespondingContour} for sampled coordinates with correspondence metadata.
+ */
 export declare interface ProfileContour2 {
   /** Stable canonical lowercase identity; unique within the containing topology or output. */
   readonly id: string;
@@ -2297,7 +2543,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 Vector2Tuple[];
+  readonly profile: readonly Vector2Data[];
 }
 
 /** An identified line, circular arc, or cubic Bézier between corresponding landmarks. */
@@ -2313,41 +2559,41 @@ export declare type ProfileSpan2 = {
       /** Selects a straight span. */
       readonly kind: "line";
       /** Start point in millimetres. */
-      readonly start: Vector2Tuple;
+      readonly start: Vector2Data;
       /** End point in millimetres. */
-      readonly end: Vector2Tuple;
+      readonly end: Vector2Data;
     }
   | {
       /** Selects the geometric curve or span family. */
       readonly kind: "arc";
       /** Center point in millimetres. */
-      readonly center: Vector2Tuple;
+      readonly center: Vector2Data;
       /** 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: Vector2Tuple;
+      readonly start: Vector2Data;
       /** First control point in millimetres. */
-      readonly control1: Vector2Tuple;
+      readonly control1: Vector2Data;
       /** Second control point in millimetres. */
-      readonly control2: Vector2Tuple;
+      readonly control2: Vector2Data;
       /** End point in millimetres. */
-      readonly end: Vector2Tuple;
+      readonly end: Vector2Data;
     }
 );
 
 /** Removes the component parallel to a normalized plane normal. */
 export declare const projectOntoPlane3: (
-  vector: Vector3Tuple,
-  normal: Vector3Tuple,
-) => Vector3Tuple;
+  vector: Vector3Data,
+  normal: Vector3Data,
+) => Vector3Data;
 
 /** Resolved pitch-line dimensions for a finite rack segment. */
 export declare interface RackPitchDimensions {
@@ -2378,33 +2624,39 @@ 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: Vector3Tuple;
   /** Signed rotation from one copy to the next, in degrees. */
-  readonly angleDegrees: number;
-  /** Rotation center in world coordinates. Defaults to the origin. */
-  readonly center?: Vector3Tuple;
-}
+  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 Transform3Matrix[];
+): readonly Transform3Data[];
 
 /** Radial dimensions refer to polygon vertices or compensate faceting to meet polygon faces. */
 export declare type RadialSizing = "vertex" | "face";
@@ -2420,7 +2672,11 @@ export declare interface RadialSizingOptions {
 }
 
 /**
- * Creates an immutable CCW rectangle loop. Round radius zero is square; tangent saturated endpoints occur once.
+ * Creates an immutable sampled CCW rectangle boundary. Round radius zero is square; tangent saturated endpoints occur once.
+ *
+ * Use [rectangle](/docs/reference/model/rectangle) for a filled Section.
+ *
+ * @see {@link rectangleProfile} for identified edge/corner spans used by matchProfiles.
  *
  * @example Rounded rectangle outline
  * ```ts
@@ -2436,7 +2692,7 @@ export declare function rectangleContour(
  */
 export declare interface RectangleContourOptions {
   /** Positive uniform size or explicit XY extents in millimetres. */
-  readonly size: number | Vector2Tuple;
+  readonly size: number | Vector2Data;
   /** 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. */
@@ -2464,6 +2720,11 @@ export declare type RectangleCornerTreatments = readonly [
 /**
  * Creates an identified rectangle whose edge/corner spans survive zero and saturated round radii. Outer winding is CCW.
  *
+ * Use [rectangle](/docs/reference/model/rectangle) for a filled Section.
+ *
+ * @see {@link matchProfiles} to sample a family with shared landmark correspondence.
+ * @see {@link rectangleContour} for sampled boundary coordinates.
+ *
  * @example Retain rectangle landmarks
  * ```ts
  * rectangleProfile({ size: [30, 20], treatment: { kind: "round", radius: 3 } });
@@ -2492,9 +2753,14 @@ export declare interface RectangleProfileOptions extends RectangleContourOptions
 export declare function regionArea(region: RegionData): number;
 
 /** Returns finite axis-aligned bounds for a non-empty region. */
-export declare function regionBounds(region: RegionData): Bounds2;
+export declare function regionBounds(region: RegionData): Bounds2Data;
 
-/** A two-dimensional region represented by disjoint filled polygons. */
+/**
+ * A two-dimensional region represented by disjoint filled polygons.
+ * Each PolygonData owns one exterior and its holes; an empty region contains no material.
+ *
+ * @see {@link PolygonData}
+ */
 export declare type RegionData = readonly PolygonData[];
 
 /**
@@ -2507,7 +2773,7 @@ export declare type RegionData = readonly PolygonData[];
  */
 export declare const regularPolygonContour: (
   options: RegularPolygonContourOptions,
-) => readonly Vector2Tuple[];
+) => readonly Vector2Data[];
 
 /** Exact regular polygon dimensions and counterclockwise degree rotation. */
 export declare interface RegularPolygonContourOptions extends RadialSizingOptions {
@@ -2516,7 +2782,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.
@@ -2527,7 +2793,7 @@ export declare interface RegularPolygonContourOptions extends RadialSizingOption
  * ```
  */
 export declare function resamplePolyline2(
-  path: readonly Vector2Tuple[],
+  path: readonly Vector2Data[],
   options?: PolylineResamplingOptions,
 ): SampledCurve2;
 
@@ -2543,7 +2809,7 @@ export declare function resamplePolyline2(
  * ```
  */
 export declare function resamplePolyline3(
-  path: readonly Vector3Tuple[],
+  path: readonly Vector3Data[],
   options?: PolylineResamplingOptions,
 ): SampledCurve3;
 
@@ -2553,7 +2819,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.
@@ -2580,7 +2846,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
@@ -2594,7 +2860,7 @@ export declare function resolveAlignedCircularSegments(
  */
 export declare function resolveArcSegments(
   radius: number,
-  angleDegrees: number,
+  angle: number,
   policy?: CircularResolutionOptions,
   limits?: Partial<GeometrySamplingLimits>,
 ): number;
@@ -2704,6 +2970,23 @@ export declare function resolveGeometryTolerance(
   options?: GeometryToleranceOptions,
 ): ResolvedGeometryTolerance;
 
+/**
+ * Resolves equal alternating knuckles along +X, centered at the origin, in millimetres.
+ *
+ * Both faces of each running pair use a common polygon count; face-sized bores contain the
+ * shaft's complete rotational envelope. Adaptive sampling satisfies both face and vertex error
+ * bounds; an insufficient ceiling rejects instead of reducing quality. Exact counts are intentional
+ * facets. Zero allowances describe ideal contact, not a printable running fit.
+ *
+ * Rejects nonfinite or nonpositive dimensions, invalid mode/count combinations, exhausted axial
+ * length, missing/excessive lift-off engagement, and nonpositive conservative faceted barrel walls.
+ * Manufacturing minima, strength, mounting, retention, handedness, and motion remain caller policy.
+ */
+export declare function resolveKnuckleHinge(
+  spec: KnuckleHingeSpec,
+  options?: KnuckleHingeSamplingOptions,
+): KnuckleHingeDimensions;
+
 /** Resolves and validates a named or caller-defined print-fit policy. */
 export declare function resolvePrintableThreadFitPolicy(
   fit?: PrintableThreadFit | PrintableThreadFitPolicy,
@@ -2718,7 +3001,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,
@@ -2741,6 +3024,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 `{}`.
@@ -2749,11 +3033,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 Vector2Tuple[],
+  input: Path2Input,
   options?: RevolveOptions,
 ) => TriangleMesh;
 
@@ -2762,12 +3046,14 @@ 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>;
 }
@@ -2777,9 +3063,9 @@ export declare interface RevolveOptions extends CircularPrimitiveOptions {
  * Throws `NON_FINITE_VALUE` for nonfinite coordinates, angles, or derived coordinates.
  */
 export declare const rotate2: (
-  vector: Vector2Tuple,
+  vector: Vector2Data,
   degrees: number,
-) => Vector2Tuple;
+) => Vector2Data;
 
 /**
  * Creates a right-handed axis-angle rotation transform.
@@ -2790,10 +3076,10 @@ export declare const rotate2: (
  * @returns A frozen row-major transform.
  */
 export declare function rotationTransform3(
-  axis: Vector3Tuple,
+  axis: Vector3Data,
   angle: AxisAngleRotation3,
   tolerance?: GeometryToleranceOptions,
-): Transform3Matrix;
+): Transform3Data;
 
 /**
  * Replaces each vertex of a non-duplicated closed polyline with a sampled
@@ -2803,13 +3089,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 Vector3Tuple[],
+  input: Path3Input,
   radius: number,
   segmentsPerCorner: number,
   limits?: Partial<GeometrySamplingLimits>,
-) => readonly Vector3Tuple[];
+) => readonly Vector3Data[];
 
 /**
  * A circular edge or corner roundover with explicit physical sampling.
@@ -2829,6 +3116,7 @@ export declare interface RowLayoutOptions {
 
 /**
  * Samples 2–32 connected line/cubic segments into a simple, nonzero-area, immutable CCW XY loop.
+ *
  * Physical scaling precedes adaptive curve sampling; the final end must repeat start exactly.
  * Shared anchors and the closing seam are emitted once. Winding normalization may change the
  * starting vertex. The sampled loop is checked for self-intersection and degeneracy by
@@ -2836,7 +3124,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.
  *
@@ -2866,17 +3154,16 @@ 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>;
 }
 
 /** Samples a planar curve with the same guarantees and policy as spatial sampling.
- * @remarks Private spatial scratch math is shared, while only final planar vectors are copied and
- * frozen. At stationary tangents, outgoing secants are preferred and endpoints use a backward fallback.
+ * @remarks Returned planar points and tangents are copied and 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(
@@ -2913,9 +3200,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 Vector2Tuple[];
+  readonly points: readonly Vector2Data[];
   /** Directed unit vectors; stationary derivatives use the nearest usable direction. */
-  readonly tangents: readonly Vector2Tuple[];
+  readonly tangents: readonly Vector2Data[];
 }
 
 /**
@@ -2923,9 +3210,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 Vector3Tuple[];
+  readonly points: readonly Vector3Data[];
   /** Directed unit vectors; stationary derivatives use the nearest usable direction. */
-  readonly tangents: readonly Vector3Tuple[];
+  readonly tangents: readonly Vector3Data[];
 }
 
 /** Sampled paths plus conventional pitch and lead measurements. */
@@ -2933,7 +3220,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 (readonly Vector3Data[])[];
   /** Adjacent axial thread spacing in millimetres. */
   readonly pitch: number;
   /** Number of revolutions represented by each path. */
@@ -2942,8 +3229,10 @@ 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,
@@ -2952,7 +3241,7 @@ export declare const sampleHelix: ({
   segments,
   limits,
   axialWeight,
-}: SampleHelixOptions) => readonly Vector3Tuple[];
+}: SampleHelixOptions) => readonly Vector3Data[];
 
 /** Options for a sampled +Z helix with millimetre dimensions. */
 export declare interface SampleHelixOptions {
@@ -2997,10 +3286,11 @@ export declare function sampleInternalCylindricalGearSpaceOutline(
 export declare function sampleRackToothPath(
   spec: RackPitchSpec,
   limits?: Partial<GeometrySamplingLimits>,
-): Path2;
+): readonly Vector2Data[];
 
 /**
  * Samples 1–31 line/cubic segments into a deeply immutable open [radius,height] polyline.
+ *
  * Anchors must progress strictly upward; nonnegative-radius cubic controls must have ordered
  * heights between their endpoints. Cubics use de Casteljau subdivision with a conservative
  * control-hull chord-error bound. Lines also obey the optional physical edge-length ceiling.
@@ -3008,7 +3298,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.
  *
@@ -3023,7 +3313,7 @@ export declare function sampleRackToothPath(
 export declare function sampleSideProfile(
   curve: SideProfileCurve,
   options?: SampleSideProfileOptions,
-): readonly Vector2Tuple[];
+): readonly Vector2Data[];
 
 /** Physical scaling and bounded adaptive subdivision for an open profile. */
 export declare interface SampleSideProfileOptions {
@@ -3034,7 +3324,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>;
 }
@@ -3064,9 +3354,9 @@ export declare function sampleThreadHelices(
 
 /** Multiplies a vector by a dimensionless scalar. */
 export declare const scale2: (
-  vector: Vector2Tuple,
+  vector: Vector2Data,
   scale: number,
-) => Vector2Tuple;
+) => Vector2Data;
 
 /**
  * Multiplies a vector by a dimensionless scalar.
@@ -3076,9 +3366,9 @@ export declare const scale2: (
  * ```
  */
 export declare const scale3: (
-  vector: Vector3Tuple,
+  vector: Vector3Data,
   scale: number,
-) => Vector3Tuple;
+) => Vector3Data;
 
 /**
  * Creates an immutable axis-aligned scale transform.
@@ -3089,9 +3379,7 @@ export declare const scale3: (
  * @param factors - Finite, non-zero XYZ scale factors.
  * @returns A frozen row-major transform.
  */
-export declare function scaleTransform3(
-  factors: Vector3Tuple,
-): Transform3Matrix;
+export declare function scaleTransform3(factors: Vector3Data): Transform3Data;
 
 /** An open radius/height outline; consumers own closure, mounting geometry, and wall policy. */
 export declare interface SideProfileCurve {
@@ -3148,7 +3436,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;
 }
@@ -3157,7 +3445,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. */
@@ -3197,48 +3485,45 @@ export declare const starContour: (
   points: number,
   innerRadius?: number,
   limits?: Partial<GeometrySamplingLimits>,
-) => readonly Vector2Tuple[];
+) => readonly Vector2Data[];
 
 /** 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,
-): RegionData;
+export declare type StrokeJoin = "bevel" | "miter" | "round";
 
 /** Physical stroke and topology controls shared by pure regions and native Sections. */
-export declare interface StrokePathRegionOptions {
+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;
+export declare const subtract2: (a: Vector2Data, b: Vector2Data) => Vector2Data;
 
 /**
  * Subtracts `b` from `a`.
@@ -3247,10 +3532,7 @@ export declare const subtract2: (
  * subtract3([4, 5, 6], [1, 2, 3]); // [3, 3, 3]
  * ```
  */
-export declare const subtract3: (
-  a: Vector3Tuple,
-  b: Vector3Tuple,
-) => Vector3Tuple;
+export declare const subtract3: (a: Vector3Data, b: Vector3Data) => Vector3Data;
 
 /** Sampling controls for deterministic SVG-to-region conversion. */
 export declare interface SvgImportOptions {
@@ -3267,7 +3549,7 @@ export declare interface SvgImportOptions {
   readonly origin?: "center" | "document";
 }
 
-/** Exact normalized SVG region plus bounded source, geometry, and safe-repair diagnostics. */
+/** Normalized sampled SVG region plus bounded source, geometry, and safe-repair diagnostics. */
 export declare interface SvgRegionPreflight {
   /** Physical and final-topology measurements of `region`. */
   readonly geometry: SvgRegionPreflightGeometryMetrics;
@@ -3284,47 +3566,47 @@ export declare interface SvgRegionPreflightGeometryMetrics {
   /** Filled area in square millimetres. */
   readonly area: number;
   /** Millimetre bounds, or `null` when no painted region remains. */
-  readonly bounds: Bounds2 | null;
+  readonly bounds: Bounds2Data | 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;
 }
 
 /**
@@ -3339,8 +3621,8 @@ export declare interface SvgRegionPreflightSourceMetrics {
  * ```
  */
 export declare function sweepMesh(
-  profile: Contour,
-  path: readonly Vector3Tuple[],
+  profile: Path2Input,
+  path: Path3Input,
   options?: SweepOptions,
 ): TriangleMesh;
 
@@ -3348,7 +3630,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>;
@@ -3357,11 +3639,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 | Vector2Tuple | readonly Vector2Tuple[];
+  readonly scale?: number | Vector2Input | readonly Vector2Input[];
   /** Corresponding point-index advance at a rotationally equivalent closed seam. */
   readonly seamProfileOffset?: number;
 }
@@ -3374,13 +3656,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?: Vector3Tuple;
+      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: Vector3Tuple;
+      readonly normal: Vector3Input;
     }
   | {
       /** Uses an explicitly directed normal callback at each original normalized station. */
@@ -3419,7 +3701,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. */
@@ -3469,7 +3751,7 @@ export declare interface ThreadedNutOptions extends Omit<
   readonly width: number;
 }
 
-/** Allocation-free body, cutter, and end-face facts resolved for a threaded nut. */
+/** Resolved body and end-face dimensions plus conservative allocation estimates for the thread cutter. */
 export declare interface ThreadedNutPreflight {
   /** Polygon segment count used by the nut body. */
   readonly bodySegments: number;
@@ -3481,7 +3763,7 @@ export declare interface ThreadedNutPreflight {
   readonly minimumBodyFaceInradius: number;
   /** Smallest radial wall left between the body and cutter at either requested face. */
   readonly minimumFaceWall: number;
-  /** Conservative allocation facts for the exact extended internal-thread cutter mesh. */
+  /** Conservative allocation estimates for the extended cutter; excludes the body and Boolean result. */
   readonly thread: HelicalThreadSolidMeshPreflight;
   /** Start-aligned circular facet count used by the compensated thread cutter. */
   readonly threadCircularSegments: number;
@@ -3559,7 +3841,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. */
@@ -3591,11 +3873,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 Vector2Tuple[];
+  readonly points: readonly Vector2Data[];
   /** 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. */
@@ -3621,7 +3917,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`. */
@@ -3655,32 +3951,33 @@ export declare interface Transform2 {
   /** 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;
+  toData(): Transform2Data;
   /** 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.
+ * Creates an immutable XY transform, identity by default.
+ *
+ * Values and data 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.
  *
+ * Use `toData()` for frozen matrix interchange.
+ *
  * @example
  * ```ts
  * const placement = transform2().rotate(90).translate([10, 0]);
- * placement.applyPoint([1, 0]).toArray(); // approximately [10, 1]
+ * placement.applyPoint([1, 0]).toData(); // 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;
+export declare function transform2(input?: Transform2Input): Transform2;
 
 /**
  * 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 [
+export declare type Transform2Data = readonly [
   m00: number,
   m01: number,
   m02: number,
@@ -3692,6 +3989,9 @@ export declare type Transform2Matrix = readonly [
   m22: number,
 ];
 
+/** An immutable XY transform or its canonical row-major matrix for interchange. */
+export declare type Transform2Input = Transform2 | Transform2Data;
+
 /** 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. */
@@ -3717,27 +4017,29 @@ export declare interface Transform3 {
   /** 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;
+  toData(): Transform3Data;
   /** 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.
+ * Creates an immutable XYZ transform, identity by default.
+ *
+ * Values and data 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.
  *
+ * Use `toData()` for frozen matrix interchange.
+ * [composeTransform3](/docs/reference/geometry/composeTransform3) takes matrices in after, before order.
+ *
  * @example
  * ```ts
  * const placement = transform3().rotate([0, 0, 90]).translate([10, 0, 0]);
- * placement.applyPoint([1, 0, 0]).toArray(); // approximately [10, 1, 0]
+ * placement.applyPoint([1, 0, 0]).toData(); // 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;
+export declare function transform3(input?: Transform3Input): Transform3;
 
 /**
  * A row-major affine 4x4 matrix applied to column vectors.
@@ -3745,7 +4047,7 @@ export declare type Transform3Input = Transform3 | Transform3Matrix;
  * Translation occupies indices 3, 7, and 11. The final row must be
  * `[0, 0, 0, 1]` within the active geometry tolerance.
  */
-export declare type Transform3Matrix = readonly [
+export declare type Transform3Data = readonly [
   m00: number,
   m01: number,
   m02: number,
@@ -3764,16 +4066,8 @@ export declare type Transform3Matrix = readonly [
   m33: number,
 ];
 
-/**
- * Applies a canonical affine XY transform to a closed loop and preserves its original winding.
- *
- * Reflections reverse the point order automatically through normalization.
- */
-export declare function transformContour(
-  loop: Contour,
-  transform: Transform2Input,
-  tolerance?: GeometryToleranceOptions,
-): Contour;
+/** An immutable XYZ transform or its canonical row-major matrix for interchange. */
+export declare type Transform3Input = Transform3 | Transform3Data;
 
 /**
  * Returns the determinant of a transform's linear 3x3 component.
@@ -3784,22 +4078,9 @@ export declare function transformContour(
  * @returns Signed linear determinant.
  */
 export declare function transformDeterminant3(
-  transform: Transform3Matrix,
+  transform: Transform3Data,
 ): number;
 
-/** Applies a canonical affine XY transform to a 2D path without changing point order. */
-export declare function transformPath2(
-  path: Path2,
-  transform: Transform2Input,
-  tolerance?: GeometryToleranceOptions,
-): Path2;
-
-/** Applies an affine transform to a 3D path without mutating its points. */
-export declare function transformPath3(
-  path: Path3,
-  placement: Transform3Input,
-): Path3;
-
 /**
  * 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.
@@ -3817,12 +4098,12 @@ export declare function transformRegionData(
  * 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: Transform3Matrix,
+  placement: Transform3Input,
 ): TriangleMesh;
 
 /**
@@ -3832,8 +4113,8 @@ export declare function transformTriangleMesh(
  * @returns A frozen row-major transform.
  */
 export declare function translationTransform3(
-  offset: Vector3Tuple,
-): Transform3Matrix;
+  offset: Vector3Data,
+): Transform3Data;
 
 /** Trapezoidal thread profile with a configurable included angle. */
 export declare interface TrapezoidalThreadProfileSpec extends ThreadProfileBaseSpec {
@@ -3845,10 +4126,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;
 }
 
 /**
@@ -3865,7 +4147,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;
@@ -3884,7 +4166,7 @@ export declare interface TriangleMeshAnalysisOptions extends TriangleMeshValidat
  */
 export declare interface TriangleMeshMeasurements {
   /** Axis-aligned bounds. */
-  readonly bounds: Bounds3;
+  readonly bounds: Bounds3Data;
   /** Signed enclosed volume; positive values correspond to outward winding. */
   readonly signedVolume: number;
   /** Sum of all triangle areas in squared model units. */
@@ -3898,7 +4180,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;
 }
@@ -3940,8 +4222,8 @@ export declare interface TriangleMeshQualityReport {
 /** Immutable deterministic measurements for a closed, oriented triangle mesh. */
 export declare interface TriangleMeshSignature {
   /** Axis-aligned bounds quantized by `tolerances.position`. */
-  readonly bounds: Bounds3;
-  /** Number of edge-connected closed components. */
+  readonly bounds: Bounds3Data;
+  /** Number of edge-connected closed boundary shells; cavities count separately. */
   readonly connectedComponentCount: number;
   /** Total orientable genus across all connected components. */
   readonly genus: number;
@@ -3960,7 +4242,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`. */
@@ -4010,7 +4292,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`
@@ -4026,6 +4308,7 @@ export declare interface TubeOptions
 
 /**
  * Checks closed indexed topology, triangle intersections, and alternating nested shell orientation.
+ *
  * Outward exterior shells and inward cavity shells are accepted. Separate shells must not touch,
  * intersect, or overlap as material. Indexed neighbours may share their own vertex or edge.
  *
@@ -4052,9 +4335,9 @@ export declare function validateSolidMesh(
  * @throws {@link GeometryError} For non-finite, non-affine, or singular matrices.
  */
 export declare function validateTransform3(
-  transform: Transform3Matrix,
+  transform: Transform3Data,
   tolerance?: GeometryToleranceOptions,
-): Transform3Matrix;
+): Transform3Data;
 
 /**
  * Validates mesh buffers, indices, triangle area, and optionally closed topology.
@@ -4098,22 +4381,26 @@ export declare interface Vector2 {
   /** 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;
+  toData(): Vector2Data;
 }
 
 /**
  * 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.
+ *
+ * Use `toData()` for frozen tuple interchange, or
+ * [normalize2](/docs/reference/geometry/normalize2) for tuple-based normalization in numerical loops.
  */
 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 Vector2Tuple = readonly [x: number, y: number];
+export declare type Vector2Data = readonly [x: number, y: number];
+
+/** An XY tuple or immutable fluent vector accepted by vector operations. */
+export declare type Vector2Input = Vector2Data | Vector2;
 
 /** Immutable XYZ arithmetic; vector operations return new values and measurements return numbers. */
 export declare interface Vector3 {
@@ -4142,15 +4429,19 @@ export declare interface Vector3 {
   /** 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;
+  toData(): Vector3Data;
 }
 
 /**
  * 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.
  *
+ * Use `toData()` for frozen tuple interchange, or
+ * [normalize3](/docs/reference/geometry/normalize3) for tuple-based normalization in numerical loops.
+ *
  * @example
  * ```ts
  * const direction = vector3([1, 2, 3]).add([4, 0, 0]).normalize().scale(10);
@@ -4159,11 +4450,11 @@ export declare interface Vector3 {
  */
 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 Vector3Tuple = readonly [x: number, y: number, z: number];
+export declare type Vector3Data = readonly [x: number, y: number, z: number];
+
+/** An XYZ tuple or immutable fluent vector accepted by vector operations. */
+export declare type Vector3Input = Vector3Data | Vector3;
 
 /** A circular baseline centered at the XY origin, with rigid shaped glyph groups. */
 export declare interface VectorTextArcBaseline {
@@ -4172,7 +4463,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";
 }
@@ -4204,7 +4495,7 @@ export declare interface VectorTextLayoutOptions extends VectorTextOptions {
 /** Text measurements from the same immutable layout that supplies geometry and SVG outlines. */
 export declare interface VectorTextMetrics {
   /** Visible curve bounds after alignment, or null when the text has no ink. */
-  readonly bounds: Bounds2 | null;
+  readonly bounds: Bounds2Data | null;
   /** Unaligned logical advance and negative baseline displacement in mm; arcs retain [arc length, 0]. */
   readonly advance: readonly [number, number];
   /** Maximum logical line advance in millimetres, including spaces; arc length on circular baselines. */