@metamesh/modeling 0.14.0 → 0.15.0

package/dist/api/geometry.d.ts

@@ -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. */
@@ -96,10 +96,30 @@ export declare interface Anchor3 {
   readonly up: Vector3Tuple;
 }
 
+/**
+ * Constructs a normalized immutable attachment anchor.
+ *
+ * `up` is projected onto the plane perpendicular to `direction`, removing small
+ * input drift while preserving its roll intent.
+ *
+ * @param position - Finite anchor point in model coordinates.
+ * @param direction - Non-zero outward attachment normal.
+ * @param up - Non-parallel roll reference; defaults to +Y.
+ * @param tolerance - Optional comparison overrides.
+ * @returns A frozen anchor with unit, orthogonal direction and up vectors.
+ * @throws {@link GeometryError} For non-finite or degenerate inputs.
+ */
+export declare function anchor3(
+  position: Vector3Input,
+  direction: Vector3Input,
+  up?: Vector3Input,
+  tolerance?: GeometryToleranceOptions,
+): Anchor3;
+
 /**
  * Converts an anchor into a right-handed frame with direction as local +Z.
  *
- * @param anchor - Anchor created by {@link createAnchor3} or equivalent valid data.
+ * @param anchor - Anchor created by {@link anchor3} or equivalent valid data.
  * @param tolerance - Optional comparison overrides.
  * @returns A normalized right-handed frame at the anchor position.
  */
@@ -143,9 +163,9 @@ export declare interface ArcCurve2 {
   /** 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. */
@@ -161,9 +181,9 @@ export declare interface ArcCurve3 {
   /** Orthogonal unit direction at positive ninety degrees. */
   readonly yAxis: Vector3Tuple;
   /** Initial angle in degrees; defaults to zero. */
-  readonly startDegrees?: number;
+  readonly startAngle?: number;
   /** Nonzero signed sweep in degrees, bounded to one complete turn. */
-  readonly sweepDegrees: number;
+  readonly sweepAngle: number;
 }
 
 /**
@@ -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,
+  options?: AttachOptions,
 ): Transform3Matrix;
 
 /** Options controlling how one anchor is attached to another. */
-export declare interface AttachTransformOptions {
+export declare interface AttachOptions {
   /** Align outward directions face-to-face (`opposed`) or in parallel (`same`). */
   readonly alignment?: "opposed" | "same";
   /** Separation along the target anchor's outward direction in model units. */
   readonly gap?: number;
-  /** Additional right-handed roll about the attached direction, in radians. */
-  readonly spinRadians?: number;
+  /** Additional right-handed roll about the attached direction, in degrees. */
+  readonly spin?: number;
   /** Optional numeric comparison overrides. */
   readonly tolerance?: GeometryToleranceOptions;
 }
@@ -335,7 +355,7 @@ export declare type BoxEdgeTreatments = Readonly<
 /**
  * Dimensions, placement, and uniform or independently selected finishing for an axis-aligned box.
  */
-export declare interface BoxOptions extends PrimitivePlacement {
+export declare interface BoxOptions extends PrimitiveAttachment {
   /** Explicit sampling ceilings for edge treatments, bounded by the host policy. */
   readonly limits?: Partial<GeometrySamplingLimits>;
   /**
@@ -349,28 +369,6 @@ export declare interface BoxOptions extends PrimitivePlacement {
   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,54 +465,6 @@ 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.
@@ -601,10 +551,13 @@ export declare function composeTransform3(
  * normal back to the first tangent measures seam holonomy; distributing that residual rotation
  * uniformly over all path intervals avoids a visible seam or accumulated frame flip.
  * The maxPathPoints ceiling (default 100000) bounds path points and frames.
+ * Requires closed path values; raw tuples are interpreted as closed and must omit their seam point.
+ * Invalid paths throw GeometryError.
+ * Nonfinite initial normals reject; finite parallel preferences select a canonical fallback.
  */
 export declare const computeClosedParallelTransportFrames: (
-  path: readonly Vector3Tuple[],
-  initialNormal?: Vector3Tuple,
+  input: Path3Input,
+  initialNormal?: Vector3Input,
   limits?: Partial<GeometrySamplingLimits>,
 ) => readonly PathFrame[];
 
@@ -612,10 +565,12 @@ export declare const computeClosedParallelTransportFrames: (
  * Builds rotation-minimizing frames by parallel-transporting the previous normal.
  * This avoids the sudden profile flips produced by picking a fresh up-vector per ring.
  * Paths exceeding maxPathPoints (default 100000) reject before frame allocation or guide evaluation.
+ * Requires open path values; raw tuples are interpreted as an open path. Invalid paths throw GeometryError.
+ * Nonfinite normals and guide results reject. A finite initial guide parallel to the tangent selects a canonical fallback.
  */
 export declare const computeParallelTransportFrames: (
-  path: readonly Vector3Tuple[],
-  initialNormal?: Vector3Tuple,
+  input: Path3Input,
+  initialNormal?: Vector3Input,
   normalGuide?: PathNormalGuide,
   limits?: Partial<GeometrySamplingLimits>,
 ) => readonly PathFrame[];
@@ -633,6 +588,23 @@ export declare function computeTriangleMeshCentroid(
   mesh: TriangleMesh,
 ): Vector3Tuple;
 
+/**
+ * Creates an order-independent regression signature for a manufacturing mesh.
+ *
+ * The input must be non-empty, closed, consistently wound, and have no unreferenced vertices.
+ * Vertex and triangle order do not affect the fingerprint; winding, quantized geometry, and
+ * connectivity metrics do. The fingerprint is a regression aid, not a cryptographic digest.
+ *
+ * @param mesh - Closed oriented mesh to measure without mutation.
+ * @param options - Absolute quantization and complexity limits.
+ * @returns Compact counts, bounds, volume, topology, tolerances, and canonical fingerprint.
+ * @throws {@link GeometryError} When validation, topology, tolerance, or complexity checks fail.
+ */
+export declare function computeTriangleMeshSignature(
+  mesh: TriangleMesh,
+  options?: TriangleMeshSignatureOptions,
+): TriangleMeshSignature;
+
 /** Tests actual XY containment, including touching boundaries; dimensions must match. */
 export declare function containsBounds(outer: Bounds2, inner: Bounds2): boolean;
 
@@ -720,59 +692,6 @@ 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;
 
@@ -815,12 +734,6 @@ export declare interface CubicBezierCurve3 {
   readonly end: Vector3Tuple;
 }
 
-/** 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 +751,7 @@ export declare interface CurveSamplingOptions {
   /** Millimetre sampling policy; circularSegments applies only to arcs. */
   readonly resolution?: GeometryResolution;
   /** Output vertex ceiling of at least two; may only lower limits.maxPathPoints. */
-  readonly maximumVertices?: number;
+  readonly maxVertices?: number;
   /** Explicit sampling ceilings; omitted values use package defaults without ambient state. */
   readonly limits?: Partial<GeometrySamplingLimits>;
 }
@@ -874,7 +787,7 @@ 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. */
@@ -886,7 +799,7 @@ export declare interface CylinderAnchorOptions {
  */
 export declare type CylinderOptions = CircularPrimitiveOptions &
   RadialSizingOptions &
-  PrimitivePlacement & {
+  PrimitiveAttachment & {
     /**
      * Centers the solid on the Z origin when `true`; otherwise its bottom is at `Z = 0`.
      * @defaultValue `true`
@@ -918,7 +831,7 @@ export declare interface CylindricalGearDimensions {
   /** Addendum above the pitch circle, in millimetres. */
   readonly addendum: number;
   /** Angular pitch between adjacent teeth, in radians. */
-  readonly angularPitch: number;
+  readonly angularPitchRadians: number;
   /** Tangential backlash applied to this gear, in millimetres. */
   readonly backlash: number;
   /** Base-circle radius used by the involute, in millimetres. */
@@ -985,7 +898,7 @@ export declare interface CylindricalGearPairDimensions {
   /** Absolute driven-to-driver tooth-count ratio. */
   readonly ratio: number;
   /** Helix angle required on the driven member for conjugate teeth, in degrees. */
-  readonly requiredDrivenHelixAngleDegrees: number;
+  readonly requiredDrivenHelixAngle: number;
 }
 
 /** Sampling controls for one coupled internal-gear tooth cycle. */
@@ -1021,7 +934,7 @@ export declare interface CylindricalGearPairSpec {
 /**
  * Nominal dimensions for a standard full-depth cylindrical involute gear.
  *
- * Lengths use millimetres. `module` and `pressureAngleDegrees` are measured in
+ * Lengths use millimetres. `module` and `pressureAngle` are measured in
  * the normal plane; a non-zero signed helix angle is converted to transverse
  * pitch-plane dimensions. Positive and negative helix angles identify
  * opposite hands but produce the same 2D pitch geometry.
@@ -1032,11 +945,11 @@ export declare interface CylindricalGearSpec {
   /** Dedendum clearance as a multiple of normal module; defaults to `0.25`. */
   readonly clearanceFactor?: number;
   /** Signed helix angle in degrees; zero creates a spur pitch system. */
-  readonly helixAngleDegrees?: number;
+  readonly helixAngle?: number;
   /** Normal module in millimetres per tooth. */
   readonly module: number;
   /** Normal pressure angle in degrees; defaults to 20 degrees. */
-  readonly pressureAngleDegrees?: number;
+  readonly pressureAngle?: number;
   /** Integer tooth count from 6 through 1,000; external profiles also enforce the no-undercut limit. */
   readonly toothCount: number;
 }
@@ -1067,11 +980,13 @@ 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[];
 
@@ -1152,6 +1067,7 @@ export declare function eulerTransform3(
 
 /**
  * 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 +1076,7 @@ export declare function eulerTransform3(
  * ```
  */
 export declare function extrudeMesh(
-  profile: Contour,
+  input: Path2Input,
   options: ExtrudeOptions,
 ): TriangleMesh;
 
@@ -1185,9 +1101,9 @@ export declare interface ExtrusionSamplingOptions {
   /** Operation-level physical policy over the nearest model scope. */
   readonly resolution?: GeometryResolution;
   /** Finite uniform or XY scale of the top profile; defaults to one. */
-  readonly scaleTop?: number | 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. */
@@ -1321,9 +1237,9 @@ export declare interface GeometryResolution {
   /** Optional maximum sampled edge length in millimetres. */
   readonly maxSegmentLength?: number;
   /** Upper safety bound for a full circle; defaults to the selected maxCircularSegments (512 by default). */
-  readonly maximumSegments?: number;
+  readonly maxSegments?: number;
   /** Lower full-circle segment count; defaults to 16 or a lower selected circular ceiling. */
-  readonly minimumSegments?: number;
+  readonly minSegments?: number;
 }
 
 /** Explicit allocation ceilings for pure sampling and host-owned modeling operations. */
@@ -1349,7 +1265,7 @@ export declare interface GeometryToleranceOptions {
 }
 
 /** Returns one recommended metric clearance-hole diameter in millimetres. */
-export declare function getMetricClearanceHole(
+export declare function getMetricClearanceHoleDiameter(
   size: MetricFastenerSize,
   fit?: ClearanceHoleFit,
 ): number;
@@ -1361,8 +1277,9 @@ export declare function getMetricFastenerStandard(
 
 /**
  * XY or XYZ grid with X varying fastest. The first item starts at the local origin.
+ * Dimension 2 restricts counts and spacing to XY; any frame must preserve the XY plane.
  */
-export declare type GridPatternOptions = {
+export declare type GridPatternOptions<Dimension extends 2 | 3 = 3> = {
   /** Center the complete distribution around its local origin; defaults to false. */
   readonly center?: boolean;
   /** Optional right-handed local axes and origin for the grid. */
@@ -1374,15 +1291,17 @@ export declare type GridPatternOptions = {
       /** 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;
-    }
+  | (Dimension extends 3
+      ? {
+          /** Positive integer counts on X, Y and Z. */
+          readonly count: Vector3Tuple;
+          /** Signed millimetres between adjacent copies on X, Y and Z. */
+          readonly spacing: Vector3Tuple;
+        }
+      : never)
 );
 
-/** XY or XYZ grid placements in millimetres, in X-fastest order. */
+/** Spatial XYZ matrices for an XY or XYZ grid, in X-fastest order. */
 export declare function gridPatternTransforms(
   options: GridPatternOptions,
 ): readonly Transform3Matrix[];
@@ -1475,6 +1394,15 @@ export declare interface HeightfieldPreflight {
   readonly byteCount: number;
 }
 
+/**
+ * Builds closed thread-ridge components with every profile locked to the
+ * shaft's radial/axial frame. The mesh is intended for union with its
+ * minor-envelope cylinder and never owns WASM objects.
+ */
+export declare function helicalThreadRidgeMesh(
+  options: HelicalThreadRidgeMeshOptions,
+): TriangleMesh;
+
 /** Runtime-neutral options for the dedicated helical ridge mesher. */
 export declare interface HelicalThreadRidgeMeshOptions {
   /**
@@ -1491,7 +1419,7 @@ export declare interface HelicalThreadRidgeMeshOptions {
   /** Nominal major diameter before any caller-owned fit compensation. */
   readonly majorDiameter: number;
   /** Angular offset of the first start in degrees. Default: `0`. */
-  readonly phaseDegrees?: number;
+  readonly phase?: number;
   /** Validated periodic profile repeated around the shaft. */
   readonly profile: ThreadProfile;
   /** Optional circular-resolution policy. */
@@ -1502,6 +1430,19 @@ export declare interface HelicalThreadRidgeMeshOptions {
   readonly tolerance?: GeometryToleranceOptions;
 }
 
+/**
+ * Builds one closed threaded cylinder without a ridge/core Boolean seam.
+ *
+ * Each circular facet includes its exact phase-shifted profile breakpoints, including duplicate-Z
+ * samples for vertical flanks and blunt transitions. Adjacent variable grids are stitched as a
+ * monotone strip, with optional intermediate rows bounded by physical `maxSegmentLength`. A
+ * conservative pre-allocation estimate rejects excessive meshes before constructing position
+ * arrays.
+ */
+export declare function helicalThreadSolidMesh(
+  options: HelicalThreadSolidMeshOptions,
+): TriangleMesh;
+
 /** Options for a complete threaded-cylinder mesh; base semantics match the ridge builder. */
 export declare interface HelicalThreadSolidMeshOptions extends HelicalThreadRidgeMeshOptions {
   /** Apply a 45-degree radial bevel at the lower target face. */
@@ -1608,10 +1549,11 @@ export declare const lerp3: (
 
 /**
  * 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,7 +1581,7 @@ 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[];
@@ -1688,6 +1630,7 @@ export declare type LoftCorrespondence =
  * Both ends use ear-clipped caps, supporting concave profiles without center fans.
  * Intermediate slices interpolate placed world vertices, never frame axes.
  * Transformed coordinates must fit finite Float32 mesh storage.
+ * Path2 profiles must be closed; raw point collections are interpreted as closed.
  *
  * @example Loft with explicit point correspondence
  * ```ts
@@ -1703,8 +1646,8 @@ export declare function loftMesh(
 
 /** One point-data profile at a height or explicit right-handed spatial frame. */
 export declare type LoftMeshStation = LoftPlacement & {
-  /** Ordered finite XY boundary points with an implicit closing edge. */
-  readonly profile: Contour;
+  /** Closed Path2 or ordered finite XY boundary points with an implicit closing edge. */
+  readonly profile: Path2Input;
 };
 
 /**
@@ -1784,21 +1727,6 @@ export declare function measureInternalCylindricalGearPairMotion(
   options?: CylindricalGearPairMotionOptions,
 ): CylindricalGearPairMotionReport;
 
-/**
- * Measures bounds, surface area, and signed volume without changing the mesh.
- *
- * Signed volume is meaningful for a consistently wound closed mesh. Set
- * `requireClosed` when measurements will be used as manufacturing assertions.
- *
- * @param mesh - Mesh to validate and measure.
- * @param options - Validation policy applied before measurement.
- * @returns Immutable deterministic scalar and bounds measurements.
- */
-export declare function measureTriangleMesh(
-  mesh: TriangleMesh,
-  options?: TriangleMeshValidationOptions,
-): TriangleMeshMeasurements;
-
 /**
  * Computes axis-aligned bounds for a non-empty mesh.
  *
@@ -1880,9 +1808,7 @@ export declare interface MetricSocketCapHeadDimensions {
  * count `z_v = z / cos³(beta)`, so increasing helix angle can reduce the physical tooth count.
  */
 export declare function minimumCylindricalGearToothCountWithoutUndercut(
-  spec?: Readonly<
-    Pick<CylindricalGearSpec, "helixAngleDegrees" | "pressureAngleDegrees">
-  >,
+  spec?: Readonly<Pick<CylindricalGearSpec, "helixAngle" | "pressureAngle">>,
 ): number;
 
 /** Aggregate manufacturing output ceilings selected by a trusted host. */
@@ -1970,13 +1896,79 @@ 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 frozen tuple coordinates; closure remains separate metadata. Repeated calls do not allocate. */
+  toArray(): Path2Data;
+  /** Total sampled edge length in model units, including the closing edge when closed. */
+  length(): number;
+  /** Axis-aligned bounds, or undefined for an empty path. */
+  bounds(): Bounds2 | undefined;
+  /** Finds the nearest edge location; requires at least two vertices. */
+  closestPoint(point: Vector2Input): PathLocation<Vector2>;
+  /** Applies an XY placement without reordering traversal, including after reflection. */
+  transform(placement: Transform2Input): Path2;
+  /** Reverses vertex order and traversal; neither the source nor its coordinates are mutated. */
+  reverse(): Path2;
+  /** Returns a path sampled at equal arc lengths. Corners may be bridged; closure is preserved. */
+  resample(options?: PathResamplingOptions): Path2;
+}
+
+/**
+ * Snapshots finite XY coordinates as an immutable sampled path, independent of engine initialization.
+ * Open paths may be empty or have one point; closed paths need three vertices and omit a duplicated
+ * seam. Repeated adjacent vertices are retained. No winding normalization or filling is performed.
+ * Malformed dimensions or topology throw INVALID_ARGUMENT; nonfinite coordinates or measurement
+ * overflow throw NON_FINITE_VALUE; exhausted allocation ceilings throw COMPLEXITY_LIMIT GeometryError.
+ * A path input retains its closure. Limits bound construction only; resampling takes its own limits.
+ */
+export declare function path2(input: Path2Input, options?: PathOptions): Path2;
+
+/** XY point tuples for interchange; closure is supplied by the consuming operation or Path2 value. */
+export declare type Path2Data = readonly Vector2Tuple[];
+
+/** An immutable XY sampled path or a collection of XY tuples and fluent vectors. */
+export declare type Path2Input = Path2 | readonly Vector2Input[];
+
+/** Immutable directed XYZ polyline; it represents sampled edges, not an analytic curve. */
+export declare interface Path3 {
+  /** Coordinate dimension; identifies spatial paths even when empty. */
+  readonly dimension: 3;
+  /** Whether traversal includes the last-to-first edge. */
+  readonly closed: boolean;
+  /** Returns frozen tuple coordinates; closure remains separate metadata. Repeated calls do not allocate. */
+  toArray(): Path3Data;
+  /** Total sampled edge length in model units, including the closing edge when closed. */
+  length(): number;
+  /** Axis-aligned bounds, or undefined for an empty path. */
+  bounds(): Bounds3 | undefined;
+  /** Finds the nearest edge location; requires at least two vertices. */
+  closestPoint(point: Vector3Input): PathLocation<Vector3>;
+  /** Applies an XYZ placement without changing traversal order or closure. */
+  transform(placement: Transform3Input): Path3;
+  /** Reverses vertex order and traversal without mutating the source. */
+  reverse(): Path3;
+  /** Returns a path sampled at equal arc lengths. Corners may be bridged; closure is preserved. */
+  resample(options?: PathResamplingOptions): Path3;
+}
 
 /**
- * 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.
  */
-export declare type Path3 = readonly Vector3Tuple[];
+export declare function path3(input: Path3Input, options?: PathOptions): Path3;
+
+/**
+ * XYZ point tuples for interchange; closure is supplied by the consuming operation or Path3 value.
+ */
+export declare type Path3Data = readonly Vector3Tuple[];
+
+/** An immutable XYZ sampled path or a collection of XYZ tuples and fluent vectors. */
+export declare type Path3Input = Path3 | readonly Vector3Input[];
 
 /** Orthonormal right-handed frame sampled along a path. */
 export declare interface PathFrame {
@@ -1988,13 +1980,17 @@ export declare interface PathFrame {
   readonly binormal: Vector3Tuple;
 }
 
-/**
- * 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.
@@ -2006,15 +2002,23 @@ export declare const pathLength: (
 export declare type PathNormalGuide = (
   point: Vector3Tuple,
   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";
 }
 
@@ -2024,7 +2028,7 @@ export declare interface PathPatternOptions {
  * 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[];
@@ -2037,6 +2041,12 @@ export declare interface PathPlacement {
   readonly tangent: Vector3Tuple;
 }
 
+/** Equal arc-length sampling; the path itself owns whether its closing edge is included. */
+export declare interface PathResamplingOptions extends CurveSamplingOptions {
+  /** Exact arc-length intervals; closed paths need at least three. Otherwise physical resolution or the effective source edge count controls sampling. */
+  readonly segments?: number;
+}
+
 /** A fixed XY point in world coordinates; omitted pivots use the coordinate origin. */
 export declare interface Pivot2Options {
   /** World-space point left fixed by rotation or scaling. */
@@ -2063,23 +2073,23 @@ export declare interface PlanarMeshOptimizationOptions extends TriangleMeshQuali
    * Maximum attempted edge evaluations. By default this is twenty times the initial candidate
    * edge count, capped at `1000000`.
    */
-  readonly maximumFlipAttempts?: number;
+  readonly maxFlipAttempts?: number;
   /** Maximum times one edge may be reconsidered after neighbouring flips. Defaults to `12`. */
-  readonly maximumEdgeRevisits?: number;
+  readonly maxEdgeRevisits?: number;
   /** Maximum triangles allowed in one selected patch. Defaults to `50000`. */
-  readonly maximumPatchTriangleCount?: number;
+  readonly maxPatchTriangles?: number;
   /** Maximum cumulative triangles across selected patches. Defaults to `200000`. */
-  readonly maximumProcessedTriangleCount?: number;
+  readonly maxProcessedTriangles?: number;
   /** Minimum triangles required before a planar patch is eligible. Defaults to `8`. */
-  readonly minimumPatchTriangleCount?: number;
+  readonly minPatchTriangles?: number;
   /** Select patches whose worst normalized aspect ratio exceeds this value. Defaults to `12`. */
-  readonly triggerMaximumAspectRatio?: number;
+  readonly triggerMaxAspectRatio?: number;
   /** Select patches whose largest per-vertex triangle share exceeds this ratio. Defaults to `0.2`. */
-  readonly triggerMaximumFanRatio?: number;
+  readonly triggerMaxFanRatio?: number;
   /** Select patches whose largest vertex triangle incidence exceeds this value. Defaults to `16`. */
-  readonly triggerMaximumVertexTriangleIncidence?: number;
+  readonly triggerMaxVertexTriangleIncidence?: number;
   /** Select patches whose smallest interior angle is below this many degrees. Defaults to `8`. */
-  readonly triggerMinimumAngleDegrees?: number;
+  readonly triggerMinAngleDegrees?: number;
 }
 
 /** Outcome of bounded planar-patch optimization, including before/after diagnostics. */
@@ -2206,26 +2216,18 @@ export declare function preflightThreadedRod(
   options: ThreadedRodOptions,
 ): HelicalThreadSolidMeshPreflight;
 
-/** Placement shared by solid and filled-section factories. */
-export declare interface PrimitivePlacement {
-  /** Applied after local construction; Section placement must preserve the XY plane. */
-  readonly placement?: PrimitivePlacementOptions;
+/** Anchor attachment shared by solid and filled-section factories. */
+export declare interface PrimitiveAttachment {
+  /** Applied after local construction; Section attachment must preserve the XY plane. */
+  readonly attachment?: PrimitiveAttachmentOptions;
 }
 
 /** Maps an explicit or named shape-local attachment anchor onto a world-space anchor. */
-export declare interface PrimitivePlacementOptions {
+export declare interface PrimitiveAttachmentOptions extends AttachOptions {
   /** Shape-local source frame or a named primitive anchor such as bottom. */
   readonly source: Anchor3 | string;
   /** World-space target frame in millimetres. */
   readonly target: Anchor3;
-  /** Align outward directions face-to-face or in parallel. Defaults to opposed. */
-  readonly alignment?: "opposed" | "same";
-  /** Finite separation along the target direction in millimetres. Defaults to zero. */
-  readonly gap?: number;
-  /** Finite additional roll around the attached direction in degrees. Defaults to zero. */
-  readonly spinDegrees?: number;
-  /** Explicit numeric comparison overrides for anchor normalization. */
-  readonly tolerance?: GeometryToleranceOptions;
 }
 
 /**
@@ -2325,9 +2327,9 @@ export declare type ProfileSpan2 = {
       /** 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. */
@@ -2378,28 +2380,34 @@ 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(
@@ -2516,7 +2524,7 @@ export declare interface RegularPolygonContourOptions extends RadialSizingOption
   /** Exact side count from three through the selected profile sampling ceiling. */
   readonly sides: number;
   /** Counterclockwise rotation in degrees; defaults to zero with a vertex on +X. */
-  readonly rotationDegrees?: number;
+  readonly rotation?: number;
 }
 
 /** Resamples a planar polyline with the same point, tangent, seam and budget guarantees as 3D.
@@ -2553,7 +2561,7 @@ export declare function resamplePolyline3(
  * `alignTo` must be non-empty and contain only positive safe integers. Its checked least common
  * multiple defines the alignment grid. An exact `segments` value wins over
  * `resolution.circularSegments` and adaptive sampling, but is never rounded: it must already be
- * aligned and meet `minimumSegments`. Adaptive counts are rounded upward and fail with
+ * aligned and meet `minSegments`. Adaptive counts are rounded upward and fail with
  * `COMPLEXITY_LIMIT` when the aligned result exceeds the configured safety cap.
  *
  * @param radius - Positive circle radius in millimetres used for adaptive physical sampling.
@@ -2580,7 +2588,7 @@ export declare function resolveAlignedCircularSegments(
  * the reusable BOSL2-style convention while retaining at least one segment.
  *
  * @param radius - Arc radius in millimetres.
- * @param angleDegrees - Non-zero signed sweep angle no greater than 360 degrees in magnitude.
+ * @param angle - Non-zero signed sweep angle no greater than 360 degrees in magnitude.
  * @param policy - Optional operation-level policy over the active model scope.
  * @returns Segment count for the requested arc span.
  * @throws {@link GeometryError} when radius, angle, or resolution policy is invalid, or the
@@ -2594,7 +2602,7 @@ export declare function resolveAlignedCircularSegments(
  */
 export declare function resolveArcSegments(
   radius: number,
-  angleDegrees: number,
+  angle: number,
   policy?: CircularResolutionOptions,
   limits?: Partial<GeometrySamplingLimits>,
 ): number;
@@ -2718,7 +2726,7 @@ export declare function resolveRackPitch(
  * Resolves a role-independent, start-aligned facet count from the larger female mating envelope.
  *
  * An exact `circularSegments` value must already be divisible by `starts`; it is never silently
- * raised. Adaptive policies align upward and fail if that would exceed `maximumSegments`.
+ * raised. Adaptive policies align upward and fail if that would exceed `maxSegments`.
  */
 export declare function resolveThreadCircularSegments(
   options: ThreadCircularSegmentsOptions,
@@ -2741,6 +2749,7 @@ export declare function reverseTriangleMesh(mesh: TriangleMesh): TriangleMesh;
  * vertices and zero-area quads. Profile edges that lie entirely on the axis
  * collapse to the solid's interior and are intentionally omitted.
  * Profile coordinates must fit finite Float32 mesh storage.
+ * Path2 profiles must be closed; raw point collections have an implicit closing edge.
  *
  * @param profile - Closed CCW `[radius, z]` profile without a duplicated seam point.
  * @param options - Optional physical or exact circumferential sampling controls. Defaults to `{}`.
@@ -2749,11 +2758,11 @@ export declare function reverseTriangleMesh(mesh: TriangleMesh): TriangleMesh;
  * @example Partial revolution with end caps
  * ```ts
  * // Each point is [radius, Z]; the profile seam is implicit.
- * revolveMesh([[0, 0], [12, 0], [8, 20], [0, 20]], { revolveDegrees: 270 });
+ * revolveMesh([[0, 0], [12, 0], [8, 20], [0, 20]], { degrees: 270 });
  * ```
  */
 export declare const revolveMesh: (
-  profile: readonly Vector2Tuple[],
+  input: Path2Input,
   options?: RevolveOptions,
 ) => TriangleMesh;
 
@@ -2762,12 +2771,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>;
 }
@@ -2803,9 +2814,10 @@ 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>,
@@ -2836,7 +2848,7 @@ export declare interface RowLayoutOptions {
  * coordinate range are required. No native engine, SDK, or ambient resolution is used.
  *
  * @param curve - Closed contour in millimetres unless positive scales convert its coordinates.
- * @param options - Physical resolution and unique vertex budget; defaults to 4096 vertices.
+ * @param options - Physical resolution and unique vertex budget; defaults to min(4096, maxProfilePoints).
  * @returns Frozen counterclockwise loop in millimetres, without a repeated seam endpoint.
  * @throws {@link GeometryError} for invalid data, topology, scale, or exceeded sampling budgets.
  *
@@ -2866,7 +2878,7 @@ export declare interface SampleContourOptions {
   /** Physical policy evaluated after scaling, using the shared curve sampler. */
   readonly resolution?: GeometryResolution;
   /** Unique output vertex ceiling, at least three, within maxProfilePoints. Defaults to min(4096, maxProfilePoints). */
-  readonly maximumVertices?: number;
+  readonly maxVertices?: number;
   /** Selected profile and per-segment path ceilings; omitted values use package defaults. */
   readonly limits?: Partial<GeometrySamplingLimits>;
 }
@@ -2876,7 +2888,7 @@ export declare interface SampleContourOptions {
  * frozen. At stationary tangents, outgoing secants are preferred and endpoints use a backward fallback.
  * @example
  * ```ts
- * const turn = sampleCurve2({kind: "arc", center: [0,0], radius: 10, sweepDegrees: 90});
+ * const turn = sampleCurve2({kind: "arc", center: [0,0], radius: 10, sweepAngle: 90});
  * ```
  */
 export declare function sampleCurve2(
@@ -2933,7 +2945,7 @@ export declare interface SampledThreadHelices {
   /** Axial advance over one revolution, equal to `pitch * starts`. */
   readonly lead: number;
   /** One immutable sampled path for each thread start. */
-  readonly paths: readonly Path3[];
+  readonly paths: readonly Path3Data[];
   /** Adjacent axial thread spacing in millimetres. */
   readonly pitch: number;
   /** Number of revolutions represented by each path. */
@@ -2944,6 +2956,7 @@ export declare interface SampledThreadHelices {
  * Creates `segments + 1` points including exact helix endpoints from finite positive dimensions.
  * Integrated weights must remain finite. The maxPathPoints ceiling defaults to 100000; excessive
  * exact counts reject before evaluating axial weights or allocating sample arrays.
+ * Invalid inputs use GeometryError; exceptions thrown by axialWeight propagate unchanged.
  */
 export declare const sampleHelix: ({
   turns,
@@ -2997,7 +3010,7 @@ export declare function sampleInternalCylindricalGearSpaceOutline(
 export declare function sampleRackToothPath(
   spec: RackPitchSpec,
   limits?: Partial<GeometrySamplingLimits>,
-): Path2;
+): Path2Data;
 
 /**
  * Samples 1–31 line/cubic segments into a deeply immutable open [radius,height] polyline.
@@ -3008,7 +3021,7 @@ export declare function sampleRackToothPath(
  * no axis closure, winding normalization, or manufacturing repair is performed.
  *
  * @param curve - Open outline in millimetres unless the positive scales convert its coordinates.
- * @param options - Physical resolution and output budget; defaults to 4096 vertices.
+ * @param options - Physical resolution and output budget; defaults to min(4096, maxProfilePoints).
  * @returns Frozen open polyline in millimetres, ordered from lowest to highest anchor.
  * @throws {@link GeometryError} for invalid coordinates, order, scale, or exceeded subdivision budget.
  *
@@ -3034,7 +3047,7 @@ export declare interface SampleSideProfileOptions {
   /** Shared physical policy, evaluated after scaling; exact circular counts do not affect curves. */
   readonly resolution?: GeometryResolution;
   /** Maximum output vertex count within maxProfilePoints. Defaults to the smaller of 4096 and that ceiling. */
-  readonly maximumVertices?: number;
+  readonly maxVertices?: number;
   /** Explicit profile and circular allocation ceilings. */
   readonly limits?: Partial<GeometrySamplingLimits>;
 }
@@ -3148,7 +3161,7 @@ export declare interface SmoothEdgeTreatment {
 /** Bounded floating-point intersection and shell-orientation validation settings. */
 export declare interface SolidMeshValidationOptions {
   /** Work ceiling for spatial comparisons and containment tests; defaults to 2,000,000 and may only lower it. */
-  readonly maximumTests?: number;
+  readonly maxTests?: number;
   /** Distance comparison policy in millimetres; near contacts reject conservatively. */
   readonly tolerance?: GeometryToleranceOptions;
 }
@@ -3157,7 +3170,7 @@ export declare interface SolidMeshValidationOptions {
  * Exactly one radius or diameter, placement, and tessellation for an origin-centered sphere.
  */
 export declare type SphereOptions = CircularPrimitiveOptions &
-  PrimitivePlacement &
+  PrimitiveAttachment &
   (
     | {
         /** Positive radius in millimetres; mutually exclusive with diameter. */
@@ -3200,40 +3213,40 @@ export declare const starContour: (
 ) => readonly Vector2Tuple[];
 
 /** End-cap treatment for an open stroked path. */
-export declare type StrokePathCap = "butt" | "round" | "square";
+export declare type StrokeCap = "butt" | "round" | "square";
 
 /** Join treatment where adjacent stroked path segments meet. */
-export declare type StrokePathJoin = "bevel" | "miter" | "round";
-
-/**
- * Converts a sampled millimetre path into the filled region covered by a centered stroke.
- *
- * Closed paths omit a duplicated seam point. Zero-length sampled segments are ignored, while the
- * effective path must still contain visible length. Round caps and joins use deterministic physical
- * resolution. Bevels fill the outer corner triangle; miters extend the outer edges to their
- * intersection, falling back to bevels above SVG's default miter limit of 4.
- */
-export declare function strokePathRegion(
-  path: Path2,
-  options: StrokePathRegionOptions,
-): 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,
@@ -3286,45 +3299,45 @@ export declare interface SvgRegionPreflightGeometryMetrics {
   /** Millimetre bounds, or `null` when no painted region remains. */
   readonly bounds: Bounds2 | null;
   /** Disconnected filled polygons in the final region. */
-  readonly components: number;
+  readonly componentCount: number;
   /** Exterior and hole boundary count in the final region. */
-  readonly contours: number;
+  readonly contourCount: number;
   /** Interior boundary count in the final region. */
-  readonly holes: number;
+  readonly holeCount: number;
   /** Shortest final boundary edge in millimetres, or `null` for an empty region. */
   readonly minEdgeLength: number | null;
   /** Final boundary edges shorter than the conservative 0.01 mm indicator. */
-  readonly shortEdges: number;
+  readonly shortEdgeCount: number;
   /** Components with less than 0.01 square millimetres of filled area. */
-  readonly tinyIslands: number;
+  readonly tinyIslandCount: number;
   /** Non-duplicated boundary vertices in the final normalized region. */
-  readonly vertices: number;
+  readonly vertexCount: number;
 }
 
 /** Visible, appearance-preserving cleanup counters from bounded SVG import. */
 export declare interface SvgRegionPreflightRepairs {
   /** Graphics elements with neither a visible fill nor a positive-width visible stroke. */
-  readonly invisibleElements: number;
+  readonly invisibleElementCount: number;
   /** Open filled subpaths closed by SVG fill semantics without closing their strokes. */
-  readonly implicitFilledClosures: number;
+  readonly implicitFilledClosureCount: number;
   /** Visibly painted elements whose fill and stroke both resolved to empty geometry. */
-  readonly emptyElements: number;
+  readonly emptyElementCount: number;
   /** Consecutive repeated flattened vertices discarded before topology resolution. */
-  readonly removedDuplicateVertices: number;
+  readonly removedDuplicateVertexCount: number;
   /** Explicit repeated seam vertices removed from otherwise closed contours. */
-  readonly removedSeamVertices: number;
+  readonly removedSeamVertexCount: number;
 }
 
 /** Bounded source-complexity facts collected while parsing one SVG document. */
 export declare interface SvgRegionPreflightSourceMetrics {
   /** UTF-8 source size, capped at 256 KiB before parsing. */
-  readonly bytes: number;
+  readonly byteCount: number;
   /** Renderable shape elements, capped at 500; containers and metadata are excluded. */
-  readonly elements: number;
+  readonly elementCount: number;
   /** Flattened vertices emitted before fill, stroke, and clipping operations. */
-  readonly emittedVertices: number;
+  readonly emittedVertexCount: number;
   /** Path endpoints and control vertices parsed before adaptive flattening. */
-  readonly parsedVertices: number;
+  readonly parsedVertexCount: number;
 }
 
 /**
@@ -3339,8 +3352,8 @@ export declare interface SvgRegionPreflightSourceMetrics {
  * ```
  */
 export declare function sweepMesh(
-  profile: Contour,
-  path: readonly Vector3Tuple[],
+  profile: Path2Input,
+  path: Path3Input,
   options?: SweepOptions,
 ): TriangleMesh;
 
@@ -3348,7 +3361,7 @@ export declare function sweepMesh(
  * Controls shared by pure mesh construction and filled modeling sweeps.
  */
 export declare interface SweepOptions {
-  /** Join the path's last station to its first. Open paths retain watertight end caps. */
+  /** Raw point closure defaults to false; a Path3 supplies its closure and rejects conflicts. */
   readonly closed?: boolean;
   /** Explicit output and sampling allocation ceilings. */
   readonly limits?: Partial<ModelingLimits>;
@@ -3357,11 +3370,11 @@ export declare interface SweepOptions {
   /** Physical sampling of nonzero twist; inserted stations retain authored station controls. */
   readonly resolution?: GeometryResolution;
   /** Total additional profile rotation in degrees, with progression selected by twistBy. */
-  readonly twistDegrees?: number;
+  readonly twist?: number;
   /** Twist advances by physical path length (default), or normalized authored station position, including a closed seam gap. */
   readonly twistBy?: "length" | "stations";
   /** Positive uniform/XY scale, or one XY pair per path station. Defaults to one. */
-  readonly scale?: number | Vector2Tuple | readonly Vector2Tuple[];
+  readonly scale?: number | Vector2Input | readonly Vector2Input[];
   /** Corresponding point-index advance at a rotationally equivalent closed seam. */
   readonly seamProfileOffset?: number;
 }
@@ -3374,13 +3387,13 @@ export declare type SweepOrientation =
       /** Minimizes frame rotation by parallel transport. */
       readonly kind: "transport";
       /** Initial profile +X guide, projected perpendicular to the first tangent. */
-      readonly initialNormal?: 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 +3432,7 @@ export declare interface ThreadCircularSegmentsOptions {
    * This keeps a compensated male/female pair on one role-independent grid when an internal
    * cutter has an enlarged entrance bevel. Default: `0`.
    */
-  readonly maximumRadialOutset?: number;
+  readonly maxRadialOutset?: number;
   /** Validated mating profile whose pitch and flank capacities govern tessellation. */
   readonly profile: ThreadProfile;
   /** Physical or exact circular resolution policy. */
@@ -3559,7 +3572,7 @@ export declare interface ThreadHelixOptions {
   /** Total sampled axial length in millimetres. */
   readonly length: number;
   /** Angular offset of the first start in degrees. Default: `0`. */
-  readonly phaseDegrees?: number;
+  readonly phase?: number;
   /** Adjacent axial thread spacing in millimetres. */
   readonly pitch: number;
   /** Radial distance from the +Z axis in millimetres. */
@@ -3596,6 +3609,20 @@ export declare interface ThreadProfile {
   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 +3648,7 @@ export declare type ThreadRole = "male" | "female";
 /**
  * Dimensions and independent ring/profile tessellation for a torus around the Z axis.
  */
-export declare interface TorusOptions extends PrimitivePlacement {
+export declare interface TorusOptions extends PrimitiveAttachment {
   /** Explicit sampling ceilings, bounded by the host policy. */
   readonly limits?: Partial<GeometrySamplingLimits>;
   /** Radius from the Z axis to the profile center, in millimetres; greater than `minorRadius`. */
@@ -3764,17 +3791,6 @@ 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;
-
 /**
  * Returns the determinant of a transform's linear 3x3 component.
  *
@@ -3787,19 +3803,6 @@ export declare function transformDeterminant3(
   transform: Transform3Matrix,
 ): 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 +3820,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;
 
 /**
@@ -3845,10 +3848,11 @@ export declare interface TrapezoidalThreadProfileSpec extends ThreadProfileBaseS
    */
   readonly depth?: number;
   /**
-   * Included flank angle in degrees. Use `90` for printable 45-degree slopes.
+   * Full angle between the flanks in degrees, from `0` inclusive to `180` exclusive.
+   * Each flank uses half this angle from the radial direction; `90` gives 45-degree slopes.
    * @defaultValue `30`
    */
-  readonly threadAngle?: number;
+  readonly includedAngle?: number;
 }
 
 /**
@@ -3865,7 +3869,7 @@ export declare interface TriangleMesh {
  * Measurements and optional edge-connected topology from one validated mesh traversal.
  */
 export declare interface TriangleMeshAnalysis extends TriangleMeshMeasurements {
-  /** Number of referenced edge-connected components when `includeTopology` is requested. */
+  /** Number of referenced edge-connected boundary shells when `includeTopology` is requested; cavities count separately. */
   readonly connectedComponentCount?: number;
   /** Number of distinct indexed undirected edges when `includeTopology` is requested. */
   readonly edgeCount?: number;
@@ -3898,7 +3902,7 @@ export declare interface TriangleMeshMeasurements {
 /** Options controlling bounded triangle-mesh quality analysis. */
 export declare interface TriangleMeshQualityOptions {
   /** Maximum number of triangles inspected. Defaults to `200000`. */
-  readonly maximumTriangleCount?: number;
+  readonly maxTriangles?: number;
   /** Numeric comparison overrides; model coordinates are interpreted in their existing units. */
   readonly tolerance?: GeometryToleranceOptions;
 }
@@ -3941,7 +3945,7 @@ export declare interface TriangleMeshQualityReport {
 export declare interface TriangleMeshSignature {
   /** Axis-aligned bounds quantized by `tolerances.position`. */
   readonly bounds: Bounds3;
-  /** Number of edge-connected closed components. */
+  /** Number of edge-connected closed boundary shells; cavities count separately. */
   readonly connectedComponentCount: number;
   /** Total orientable genus across all connected components. */
   readonly genus: number;
@@ -3960,7 +3964,7 @@ export declare interface TriangleMeshSignature {
 /** Options controlling deterministic triangle-mesh regression signatures. */
 export declare interface TriangleMeshSignatureOptions {
   /** Maximum accepted triangle count. Defaults to 200,000. */
-  readonly maximumTriangleCount?: number;
+  readonly maxTriangles?: number;
   /** Position and bounds quantization in model units. Defaults to `1e-5`. */
   readonly positionTolerance?: number;
   /** Signed-volume quantization in cubic model units. Defaults to `1e-4`. */
@@ -4010,7 +4014,7 @@ export declare function triangulateContour(loop: Contour): Uint32Array;
  * Dimensions, placement, and tessellation for a hollow Z-axis tube.
  */
 export declare interface TubeOptions
-  extends CircularPrimitiveOptions, PrimitivePlacement {
+  extends CircularPrimitiveOptions, PrimitiveAttachment {
   /**
    * Centers the tube on the Z origin when `true`; otherwise its bottom is at `Z = 0`.
    * @defaultValue `true`
@@ -4172,7 +4176,7 @@ export declare interface VectorTextArcBaseline {
   /** Baseline radius in millimetres, greater than zero and at most 10000. */
   readonly radius: number;
   /** Alignment datum in degrees counterclockwise from +X; defaults to 90. */
-  readonly centerAngleDegrees?: number;
+  readonly centerAngle?: number;
   /** Reading direction around the circle; defaults to clockwise. */
   readonly direction?: "clockwise" | "counterclockwise";
 }