@metamesh/modeling 0.18.0 → 0.20.0

package/dist/api/geometry.d.ts

@@ -1,34 +1,11 @@
-/** Pure geometry foundations without host initialization. @packageDocumentation */
-
-/** ACME 29-degree included-angle profile. */
-export declare interface AcmeThreadProfileSpec extends ThreadProfileBaseSpec {
-  /** Selects the 29-degree ACME profile family. */
-  readonly kind: "acme";
-  /**
-   * Radial depth in millimetres.
-   * @defaultValue `pitch / 2`
-   */
-  readonly depth?: number;
-}
-
-/** Adds two finite XY vectors component-wise. */
-export declare const add2: (a: Vector2Data, b: Vector2Data) => Vector2Data;
-
-/**
- * Adds two finite XYZ vectors component-wise.
- * @example
- * ```ts
- * add3([1, 2, 3], [4, 5, 6]); // [5, 7, 9]
- * ```
- */
-export declare const add3: (a: Vector3Data, b: Vector3Data) => Vector3Data;
+/** Pure geometry values, descriptors, and algorithms without host initialization. @packageDocumentation */
 
 /** Controls full-circle sampling that must satisfy one or more topology alignments. */
 export declare interface AlignedCircularSegmentsOptions {
   /** Radial sizing used by adaptive error and edge-length checks. Defaults to vertex. */
   readonly sizing?: RadialSizing;
   /**
-   * Non-empty alignment factors. Every value must be a positive safe integer; the returned count
+   * Nonempty alignment factors. Every value must be a positive safe integer; the returned count
    * is divisible by their checked least common multiple.
    */
   readonly alignTo: readonly number[];
@@ -46,7 +23,7 @@ export declare interface AlignedCircularSegmentsOptions {
    * already satisfy every alignment factor and `minSegments`.
    */
   readonly segments?: number;
-  /** Operation-level physical tessellation policy over the active model-wide policy. */
+  /** Explicit physical tessellation policy; omitted fields use package defaults. */
   readonly resolution?: GeometryResolution;
 }
 
@@ -71,19 +48,23 @@ export declare interface Anchor3 {
  * `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.
+ * @param options - Finite position, orientation guides, and 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;
+ * @throws {@link GeometryError} For nonfinite or degenerate inputs.
+ */
+export declare function anchor3(options: Anchor3Options): Anchor3;
+
+/** Attachment position in millimetres and orientation guides in local coordinates. */
+export declare interface Anchor3Options {
+  /** Finite attachment position in millimetres. */
+  readonly position: Vector3Input;
+  /** Nonzero outward normal; its magnitude is ignored. */
+  readonly direction: Vector3Input;
+  /** Nonparallel roll reference projected onto the attachment plane; defaults to +Y. */
+  readonly up?: Vector3Input;
+  /** Optional numeric comparison overrides. */
+  readonly tolerance?: GeometryToleranceOptions;
+}
 
 /**
  * Converts an anchor into a right-handed frame with direction as local +Z.
@@ -97,32 +78,6 @@ export declare function anchorFrame3(
   tolerance?: GeometryToleranceOptions,
 ): Frame3;
 
-/**
- * Applies only the linear component of an affine transform to a direction.
- *
- * The result is not normalized, preserving scale information.
- *
- * @param transform - Valid row-major affine transform.
- * @param direction - Finite XYZ direction.
- * @returns A fresh transformed direction.
- */
-export declare function applyTransformDirection3(
-  transform: Transform3Data,
-  direction: Vector3Data,
-): Vector3Data;
-
-/**
- * Applies an affine transform to a point, including translation.
- *
- * @param transform - Valid row-major affine transform.
- * @param point - Finite XYZ point.
- * @returns A fresh transformed point.
- */
-export declare function applyTransformPoint3(
-  transform: Transform3Data,
-  point: Vector3Data,
-): Vector3Data;
-
 /** Planar circular arc with counterclockwise degree angles. */
 export declare interface ArcCurve2 {
   /** Selects a circular arc in the XY plane. */
@@ -166,14 +121,14 @@ export declare interface ArcCurve3 {
  * @param source - Anchor expressed in the moving object's local coordinates.
  * @param target - Desired anchor pose in destination coordinates.
  * @param options - Alignment, gap, spin, and tolerance policy.
- * @returns A frozen affine transform for the moving object.
- * @throws {@link GeometryError} For invalid anchors or non-finite options.
+ * @returns An immutable affine transform for the moving object.
+ * @throws {@link GeometryError} For invalid anchors or nonfinite options.
  */
 export declare function attachmentTransform3(
   source: Anchor3,
   target: Anchor3,
   options?: AttachOptions,
-): Transform3Data;
+): Transform3;
 
 /** Options controlling how one anchor is attached to another. */
 export declare interface AttachOptions {
@@ -187,32 +142,12 @@ export declare interface AttachOptions {
   readonly tolerance?: GeometryToleranceOptions;
 }
 
-/**
- * One explicitly unit-labelled right-handed axis-angle rotation.
- */
-export declare type AxisAngleRotation3 =
-  | {
-      /** Finite right-handed angle in degrees. */
-      readonly degrees: number;
-      /** Excluded when the angle is expressed in degrees. */
-      readonly radians?: never;
-    }
-  | {
-      /** Finite right-handed angle in radians. */
-      readonly radians: number;
-      /** Excluded when the angle is expressed in radians. */
-      readonly degrees?: never;
-    };
-
-/** One size for both ends, or independent sizes in bottom/top order. Zero disables an end. */
-export declare type Bevel =
-  BevelSize | readonly [bottom: BevelSize, top: BevelSize];
-
-/** Nonnegative 45-degree axial/radial bevel size in millimetres, or factory automatic sizing. */
-export declare type BevelSize = number | "auto";
-
-/** Immutable finite XY bounds in millimetres, with tuple coordinates for data interoperability. */
-export declare interface Bounds2 extends Bounds2Data {
+/** Immutable finite XY bounds in millimetres, with fluent extrema and measurements. */
+export declare interface Bounds2 {
+  /** Inclusive minimum XY coordinates. */
+  readonly min: Vector2;
+  /** Inclusive maximum XY coordinates. */
+  readonly max: Vector2;
   /** Returns nonnegative X/Y dimensions in millimetres, including zero extents. */
   size(): Vector2;
   /** Returns the midpoint in millimetres. */
@@ -229,8 +164,10 @@ export declare interface Bounds2 extends Bounds2Data {
  * Zero extents are valid. Invalid dimensions, nonfinite coordinates, reversed bounds and
  * overflowing extents throw `INVALID_ARGUMENT` GeometryError. Use `toData()` for plain records.
  * Size construction centers on the origin unless `center` is false. Size and extrema are exclusive.
- * Compiled Generator packages passing these values to host recipes or computed data require
- * runtime 10.0.0 or newer in major 10.
+ * Compiled Generator packages passing these values to host recipes or memo data require
+ * the current Modeling runtime.
+ *
+ * @param input - Ordered extrema, nonnegative size, or an existing XY bounds value to snapshot.
  */
 export declare function bounds2(input: Bounds2Options | Bounds2): Bounds2;
 
@@ -268,8 +205,12 @@ export declare type Bounds2Options =
       readonly max?: never;
     };
 
-/** Immutable finite XYZ bounds in millimetres, with tuple coordinates for data interoperability. */
-export declare interface Bounds3 extends Bounds3Data {
+/** Immutable finite XYZ bounds in millimetres, with fluent extrema and measurements. */
+export declare interface Bounds3 {
+  /** Inclusive minimum XYZ coordinates. */
+  readonly min: Vector3;
+  /** Inclusive maximum XYZ coordinates. */
+  readonly max: Vector3;
   /** Returns nonnegative X/Y/Z dimensions in millimetres, including zero extents. */
   size(): Vector3;
   /** Returns the midpoint in millimetres. */
@@ -286,8 +227,10 @@ export declare interface Bounds3 extends Bounds3Data {
  * Zero extents are valid. Invalid dimensions, nonfinite coordinates, reversed bounds and
  * overflowing extents throw `INVALID_ARGUMENT` GeometryError. Use `toData()` for plain records.
  * Size construction centers on the origin unless `center` is false. Size and extrema are exclusive.
- * Compiled Generator packages passing these values to host recipes or computed data require
- * runtime 10.0.0 or newer in major 10.
+ * Compiled Generator packages passing these values to host recipes or memo data require
+ * the current Modeling runtime.
+ *
+ * @param input - Ordered extrema, nonnegative size, or an existing XYZ bounds value to snapshot.
  */
 export declare function bounds3(input: Bounds3Options | Bounds3): Bounds3;
 
@@ -363,7 +306,9 @@ export declare function boundsSize(bounds: Bounds2Data): Vector2Data;
 /** Inclusive XYZ dimensions in millimetres; zero extents are retained. */
 export declare function boundsSize(bounds: Bounds3Data): Vector3Data;
 
-/** Creates an outward face-center anchor using the same local origin convention as box().
+/**
+ * Creates an outward face-center anchor using the same local origin convention as box().
+ *
  * @remarks origin applies an explicit translation. For rotated components, transform the
  * resulting anchor frame explicitly; no anchor is inherited from a Boolean result.
  */
@@ -385,69 +330,7 @@ export declare interface BoxAnchorOptions {
   readonly origin?: Vector3Input;
 }
 
-/** Box edges use +Z top, +Y front and +X right; vertical names list front/back first. */
-export declare type BoxEdge =
-  | "top-front"
-  | "top-back"
-  | "top-left"
-  | "top-right"
-  | "bottom-front"
-  | "bottom-back"
-  | "bottom-left"
-  | "bottom-right"
-  | "front-left"
-  | "front-right"
-  | "back-left"
-  | "back-right";
-
-/** Named individual edges or top/bottom rims and all four vertical edges. */
-export declare type BoxEdgeSelection = BoxEdge | "top" | "bottom" | "vertical";
-
-/** Independent treatments for disjoint named edge selections; overlapping selections fail. */
-export declare type BoxEdgeTreatments = Readonly<
-  Partial<Record<BoxEdgeSelection, EdgeTreatment>>
->;
-
-/**
- * Dimensions, placement, and uniform or independently selected finishing for an axis-aligned box.
- */
-export declare interface BoxOptions extends PrimitiveAttachment {
-  /** Explicit sampling ceilings for edge treatments, bounded by the host policy. */
-  readonly limits?: Partial<GeometrySamplingLimits>;
-  /**
-   * Centers the box on the XYZ origin when `true`; otherwise its minimum corner is at the origin.
-   * @defaultValue `true`
-   */
-  readonly center?: boolean;
-  /** Positive uniform size or explicit `[X, Y, Z]` extents in millimetres. */
-  readonly size: number | Vector3Input;
-  /** Uniform treatment or independent disjoint nominal edge/group treatments. */
-  readonly treatment?: EdgeTreatment | BoxEdgeTreatments;
-}
-
-/** Axial side carrying the near-normal pressure flank of a buttress thread. */
-export declare type ButtressPressureFlankSide = "negative" | "positive";
-
-/** Asymmetric printable buttress profile with 7/45-degree flanks. */
-export declare interface ButtressThreadProfileSpec extends ThreadProfileBaseSpec {
-  /** Selects the asymmetric printable buttress profile family. */
-  readonly kind: "buttress";
-  /**
-   * Radial depth in millimetres.
-   * @defaultValue `0.66271 * pitch`
-   */
-  readonly depth?: number;
-  /**
-   * Axial side of each tooth carrying the 7-degree pressure flank. The opposite side uses the
-   * 45-degree clearance flank.
-   * @defaultValue `"positive"`
-   */
-  readonly pressureFlankSide?: ButtressPressureFlankSide;
-}
-
-/**
- * A planar edge or corner chamfer with equal or independent surface setbacks.
- */
+/** A straight transverse edge or corner bevel with equal or independent surface setbacks. */
 export declare interface ChamferedEdgeTreatment {
   /** Selects a straight bevel between adjoining surfaces. */
   readonly kind: "chamfer";
@@ -483,9 +366,7 @@ export declare type CircleContourOptions = CircularPrimitiveOptions &
       }
   );
 
-/**
- * Tessellation controls shared by circular primitives across Geometry entry points.
- */
+/** Tessellation controls shared by circular primitives across Geometry entry points. */
 export declare interface CircularPrimitiveOptions {
   /** Explicit sampling ceilings; bound modeling operations may only lower the host policy. */
   readonly limits?: Partial<GeometrySamplingLimits>;
@@ -519,19 +400,6 @@ export declare interface CircularSampling {
 /** Nominal circle size and explicit physical sampling; supply exactly one radius or diameter. */
 export declare type CircularSamplingOptions = CircleContourOptions;
 
-/** Close, normal, and loose metric clearance-hole diameters in millimetres. */
-export declare interface ClearanceHoleDimensions {
-  /** Close-fit clearance-hole diameter. */
-  readonly close: number;
-  /** Loose-fit clearance-hole diameter. */
-  readonly loose: number;
-  /** Normal-fit clearance-hole diameter. */
-  readonly normal: number;
-}
-
-/** Common clearance-hole fit categories, ordered from smallest to largest. */
-export declare type ClearanceHoleFit = "close" | "normal" | "loose";
-
 /**
  * Closes an open, strictly upward [radius, height] side outline to the radius-zero axis.
  *
@@ -539,89 +407,26 @@ export declare type ClearanceHoleFit = "close" | "normal" | "loose";
  * 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.
+ *
+ * @param side - [radius, height] points in millimetres, with increasing heights.
+ * @param limits - Point limits, including any added axis endpoints.
  */
 export declare function closeToAxis(
   side: readonly Vector2Data[],
   limits?: Partial<GeometrySamplingLimits>,
 ): Contour;
 
-/** Compensated major/minor envelopes and the policy values used. */
-export declare interface CompensatedThreadDiameters {
-  /** Axial backlash from the selected policy. */
-  readonly axialBacklash: number;
-  /** Compensated major diameter in millimetres. */
-  readonly majorDiameter: number;
-  /** Compensated minor diameter in millimetres. */
-  readonly minorDiameter: number;
-  /** Signed radial shift: negative for male inset, positive for female outset. */
-  readonly radialShift: number;
-}
-
-/**
- * Applies role-specific radial compensation while preserving thread depth.
- *
- * Male envelopes move inward by the policy inset; female envelopes move
- * outward by the policy outset. Combining both parts produces the sum of those
- * allowances as radial mating clearance.
- */
-export declare function compensateThreadDiameters(
-  options: ThreadCompensationOptions,
-): CompensatedThreadDiameters;
-
-/**
- * Applies axial fit allowance to a validated periodic profile.
- *
- * Male crests/ridges narrow by the requested backlash; female cutter ridges
- * widen by it. Periodic root endpoints remain fixed so pitch and lead do not
- * change. The returned profile is a new deeply immutable value.
- */
-export declare function compensateThreadProfileAxially(
-  profile: ThreadProfile,
-  axialBacklash: number,
-  role: "female" | "male",
-): ThreadProfile;
-
-/**
- * Applies printable axial fit plus the conservative phase allowance required by circular facets.
- *
- * One triangulated facet spans `pitch * starts / circularSegments` axially. A directed zipper
- * triangle can expose either end of that complete span when independently faceted parts rotate.
- * This helper distributes the full conservative flank clearance between the male crest and female
- * root according to their available flat widths, and rejects a resolution that cannot represent
- * it exactly.
- */
-export declare function compensateThreadProfileForFaceting(
-  profile: ThreadProfile,
-  axialBacklash: number,
-  role: "female" | "male",
-  starts: number,
-  circularSegments: number,
-): ThreadProfile;
-
-/**
- * Composes two affine transforms without mutating either matrix.
- *
- * `composeTransform3(after, before)` applies `before` first and `after` second.
- *
- * @param after - Transform applied second.
- * @param before - Transform applied first.
- * @returns A new frozen transform equal to `after * before`.
- */
-export declare function composeTransform3(
-  after: Transform3Data,
-  before: Transform3Data,
-): Transform3Data;
-
 /**
  * Builds rotation-minimizing frames for a non-duplicated closed path.
  *
  * Centered cyclic tangents are parallel-transported around the loop. Transporting the last
  * 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.
+ *
+ * @param input - Closed XYZ path or points in millimetres, with no repeated seam.
+ * @param initialNormal - Preferred profile X direction at the seam.
+ * @param limits - Limits on input points and output frames.
  */
 export declare const computeClosedParallelTransportFrames: (
   input: Path3Input,
@@ -633,9 +438,13 @@ 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.
+ * Nonfinite guides and unusable path tangents throw GeometryError. A finite initial guide
+ * parallel to the tangent selects a canonical fallback.
+ *
+ * @param input - Open XYZ path or points in millimetres; at least two points.
+ * @param initialNormal - Preferred starting X direction; the first normalGuide result wins.
+ * @param normalGuide - Profile X guide at each point; its sign follows the transported normal.
+ * @param limits - Point limits, checked before creating frames or calling guides.
  */
 export declare const computeParallelTransportFrames: (
   input: Path3Input,
@@ -647,16 +456,21 @@ export declare const computeParallelTransportFrames: (
 /**
  * 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
+ * Polygon exteriors are counterclockwise 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 [PolygonData](/docs/reference/geometry/PolygonData)
  * @see [ProfileContour2](/docs/reference/geometry/ProfileContour2)
  */
 export declare type Contour = readonly Vector2Data[];
 
-/** Returns true when a point lies inside or on the boundary of a loop. */
+/**
+ * Returns true when a point lies inside or on the boundary of a loop.
+ *
+ * @param loop - Simple XY loop with either winding.
+ * @param point - Query in the loop's coordinate system.
+ */
 export declare function contourContainsPoint(
   loop: Contour,
   point: Vector2Data,
@@ -723,24 +537,12 @@ export declare interface CorrespondingProfile {
   readonly components: readonly CorrespondingComponent[];
 }
 
-/** One already matched profile at an explicit height or right-handed spatial frame. */
+/** One already matched profile at a horizontal height or explicit affine transform. */
 export declare type CorrespondingProfileStation = LoftPlacement & {
   /** Already corresponding filled contours with authoritative landmark slots. */
   readonly profile: CorrespondingProfile;
 };
 
-/** Returns the signed scalar cross product; positive means `b` is counter-clockwise from `a`. */
-export declare const cross2: (a: Vector2Data, b: Vector2Data) => number;
-
-/**
- * Returns the right-handed cross product.
- * @example
- * ```ts
- * cross3([1, 0, 0], [0, 1, 0]); // [0, 0, 1]
- * ```
- */
-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. */
@@ -755,9 +557,7 @@ export declare interface CubicBezierCurve2 {
   readonly end: Vector2Data;
 }
 
-/**
- * Spatial cubic Bézier with explicit endpoint and control coordinates.
- */
+/** Spatial cubic Bézier with explicit endpoint and control coordinates. */
 export declare interface CubicBezierCurve3 {
   /** Selects a cubic Bézier through two endpoints and two controls. */
   readonly kind: "cubic";
@@ -774,14 +574,10 @@ export declare interface CubicBezierCurve3 {
 /** Reusable planar curve definition. */
 export declare type Curve2 = LineCurve2 | ArcCurve2 | CubicBezierCurve2;
 
-/**
- * Reusable spatial curve definition.
- */
+/** Reusable spatial curve definition. */
 export declare type Curve3 = LineCurve3 | ArcCurve3 | CubicBezierCurve3;
 
-/**
- * Explicit physical sampling and allocation policy for reusable curves.
- */
+/** Explicit physical sampling and allocation policy for reusable curves. */
 export declare interface CurveSamplingOptions {
   /** Exact segment count overrides physical criteria; curve parameters are spaced uniformly. */
   readonly segments?: number;
@@ -793,19 +589,10 @@ export declare interface CurveSamplingOptions {
   readonly limits?: Partial<GeometrySamplingLimits>;
 }
 
-/** Caller-defined periodic axial/radial profile in millimetres. */
-export declare interface CustomThreadProfileSpec extends ThreadProfileBaseSpec {
-  /** Selects a caller-defined periodic profile. */
-  readonly kind: "custom";
-  /**
-   * 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 Vector2Data[];
-}
-
-/** Creates a cap-center or radial-side anchor using cylinder()'s construction origin.
- * @remarks Both centered and noncentered cylinders extend along +Z. Side angle uses degrees;
+/**
+ * Creates a cap-center or radial-side anchor using cylinder()'s construction origin.
+ *
+ * @remarks Cylinders use the local Z axis. Side angle uses degrees;
  * origin applies an explicit translation, and arbitrary component transforms remain explicit.
  */
 export declare function cylinderAnchor3(
@@ -823,7 +610,7 @@ export declare interface CylinderAnchorOptions {
   readonly height: number;
   /** Named outward face; side anchors lie halfway up the cylinder. */
   readonly face: CylinderAnchorFace;
-  /** Side angle counter-clockwise from +X, in degrees; defaults to zero. */
+  /** Side angle counterclockwise from +X, in degrees; defaults to zero. */
   readonly angle?: number;
   /** Centers the cylinder along Z; defaults to true, matching cylinder(). */
   readonly center?: boolean;
@@ -831,166 +618,6 @@ export declare interface CylinderAnchorOptions {
   readonly origin?: Vector3Input;
 }
 
-/**
- * Dimensions, placement, independent end finishing, and tessellation for a Z-axis cylinder or frustum.
- */
-export declare type CylinderOptions = CircularPrimitiveOptions &
-  RadialSizingOptions &
-  PrimitiveAttachment & {
-    /**
-     * Centers the solid on the Z origin when `true`; otherwise its bottom is at `Z = 0`.
-     * @defaultValue `true`
-     */
-    readonly center?: boolean;
-    /** Independent end treatments; first setback is cap inset and second follows the sloped side. */
-    readonly ends?: EndTreatments;
-    /** Total height along +Z in millimetres. */
-    readonly height: number;
-  } & (
-    | {
-        /** Positive uniform radius or nonnegative `[bottom, top]` radii in millimetres; one must be positive. */
-        readonly radius: number | readonly [bottom: number, top: number];
-        /** Full diameter is unavailable when radius is supplied. */
-        readonly diameter?: never;
-      }
-    | {
-        /** Positive uniform diameter or nonnegative `[bottom, top]` diameters in millimetres; one must be positive. */
-        readonly diameter: number | readonly [bottom: number, top: number];
-        /** Radius is unavailable when diameter is supplied. */
-        readonly radius?: never;
-      }
-  );
-
-/**
- * Resolved transverse pitch-plane dimensions for one cylindrical gear.
- */
-export declare interface CylindricalGearDimensions {
-  /** Addendum above the pitch circle, in millimetres. */
-  readonly addendum: number;
-  /** Angular pitch between adjacent teeth, in radians. */
-  readonly angularPitchRadians: number;
-  /** Tangential backlash applied to this gear, in millimetres. */
-  readonly backlash: number;
-  /** Base-circle radius used by the involute, in millimetres. */
-  readonly baseRadius: number;
-  /** Dedendum below the pitch circle, in millimetres. */
-  readonly dedendum: number;
-  /** Signed helix angle, in radians. */
-  readonly helixAngleRadians: number;
-  /** Caller-supplied normal module, in millimetres. */
-  readonly module: number;
-  /** Minimum physical tooth count for this unshifted full-depth external profile. */
-  readonly minimumToothCountWithoutUndercut: number;
-  /** Outside radius at the tooth tips, in millimetres. */
-  readonly outsideRadius: number;
-  /** Pitch-circle radius, in millimetres. */
-  readonly pitchRadius: number;
-  /** Normal pressure angle, in radians. */
-  readonly pressureAngleRadians: number;
-  /** Root radius at the bottom lands, in millimetres. */
-  readonly rootRadius: number;
-  /** Integer number of teeth. */
-  readonly toothCount: number;
-  /** Tangential tooth thickness at the pitch circle, in millimetres. */
-  readonly toothThicknessAtPitch: number;
-  /** Module measured in the transverse pitch plane, in millimetres. */
-  readonly transverseModule: number;
-  /** Pressure angle measured in the transverse pitch plane, in radians. */
-  readonly transversePressureAngleRadians: number;
-  /** Helical equivalent spur tooth count, `toothCount / cos³(helixAngle)`. */
-  readonly virtualToothCount: number;
-}
-
-/**
- * Whether two cylindrical gears mesh on their outside teeth or as a pinion inside a ring.
- */
-export declare type CylindricalGearMeshKind = "external" | "internal";
-
-/** Sampling controls for a complete non-duplicated gear outline. */
-export declare interface CylindricalGearOutlineOptions {
-  /** Exact samples per involute flank, at least two, within the aggregate profile ceiling. */
-  readonly flankSamples?: number;
-  /** Exact samples along each bottom land, at least one, within selected circular/profile ceilings. */
-  readonly rootArcSamples?: number;
-  /** Explicit profile and circular allocation ceilings. */
-  readonly limits?: Partial<GeometrySamplingLimits>;
-  /** Explicit physical sampling policy for adaptive defaults. */
-  readonly resolution?: GeometryResolution;
-  /** Exact samples along each tooth tip, at least one, within selected circular/profile ceilings. */
-  readonly tipArcSamples?: number;
-}
-
-/**
- * Pitch solution for a coordinated cylindrical gear pair.
- */
-export declare interface CylindricalGearPairDimensions {
-  /** Nominal distance between the two +Z gear axes, in millimetres. */
-  readonly centerDistance: number;
-  /** Resolved driver dimensions. */
-  readonly driver: CylindricalGearDimensions;
-  /** `-1` for opposite external rotation and `1` for same-direction internal rotation. */
-  readonly drivenDirection: -1 | 1;
-  /** Resolved driven dimensions. */
-  readonly driven: CylindricalGearDimensions;
-  /** Absolute driven-to-driver tooth-count ratio. */
-  readonly ratio: number;
-  /** Helix angle required on the driven member for conjugate teeth, in degrees. */
-  readonly requiredDrivenHelixAngle: number;
-}
-
-/** Sampling controls for one coupled internal-gear tooth cycle. */
-export declare interface CylindricalGearPairMotionOptions {
-  /** Optional deterministic outline sampling overrides. */
-  readonly outline?: CylindricalGearOutlineOptions;
-  /** Coupled poses sampled over one driver tooth pitch. Defaults to 24. */
-  readonly samples?: number;
-}
-
-/** Maximum sampled planar overlap for an external pinion inside an internal ring. */
-export declare interface CylindricalGearPairMotionReport {
-  /** Driver phase at the maximum overlap, in radians. */
-  readonly driverPhaseRadians: number;
-  /** Maximum pinion area lying inside ring material, in square millimetres. */
-  readonly maximumOverlapArea: number;
-  /** Number of evenly spaced coupled poses inspected. */
-  readonly samples: number;
-}
-
-/**
- * Inputs for resolving a coordinated cylindrical gear pair.
- */
-export declare interface CylindricalGearPairSpec {
-  /** Driving gear or pinion. */
-  readonly driver: CylindricalGearSpec;
-  /** Driven external gear or internal ring gear. */
-  readonly driven: CylindricalGearSpec;
-  /** External/external or external/internal mesh. */
-  readonly mesh: CylindricalGearMeshKind;
-}
-
-/**
- * Nominal dimensions for a standard full-depth cylindrical involute gear.
- *
- * 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.
- */
-export declare interface CylindricalGearSpec {
-  /** Tangential tooth-thickness reduction at the pitch circle, in millimetres. */
-  readonly backlash?: number;
-  /** 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 helixAngle?: number;
-  /** Normal module in millimetres per tooth. */
-  readonly module: number;
-  /** Normal pressure angle in degrees; defaults to 20 degrees. */
-  readonly pressureAngle?: number;
-  /** Integer tooth count from 6 through 1,000; external profiles also enforce the no-undercut limit. */
-  readonly toothCount: number;
-}
-
 /** Default absolute, relative, and angular tolerances for millimetre-scale models. */
 export declare const DEFAULT_GEOMETRY_TOLERANCE: Readonly<{
   /** Default absolute distance floor in model units. */
@@ -1004,44 +631,26 @@ export declare const DEFAULT_GEOMETRY_TOLERANCE: Readonly<{
 /** Conservative defaults; trusted callers can supply larger explicit ceilings. */
 export declare const defaultGeometrySamplingLimits: GeometrySamplingLimits;
 
-/** Returns Euclidean point distance without allocating an intermediate difference vector. */
-export declare const distance2: (a: Vector2Data, b: Vector2Data) => number;
-
-/** Returns Euclidean point distance without allocating an intermediate difference vector. */
-export declare const distance3: (a: Vector3Data, b: Vector3Data) => number;
-
 /**
- * Places an exact item count at equal arc-length intervals along a sampled path.
- *
- * Coordinates are unit-agnostic. Closed paths must omit their duplicated seam;
- * 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.
+ * Places an exact item count at equal arc-length intervals along a sampled XYZ path.
+ *
+ * Open paths retain both endpoints when count exceeds one; closed paths omit the seam endpoint.
+ * Zero-length edges are skipped. Invalid counts, repeated closed seams, nonfinite lengths,
+ * zero-length paths, and exhausted budgets throw GeometryError.
+ *
+ * @param input - XYZ path or points in millimetres.
+ * @param count - Positive placement count; one selects the path start.
+ * @param closed - Raw-point closure, false by default; must match a path value.
+ * @param limits - Limits on input points and output placements.
  */
-export declare const distributeAlongPath: (
+export declare function distributeAlongPath(
   input: Path3Input,
   count: number,
   closed?: boolean,
   limits?: Partial<GeometrySamplingLimits>,
-) => readonly PathPlacement[];
-
-/** Returns the scalar dot product. */
-export declare const dot2: (a: Vector2Data, b: Vector2Data) => number;
-
-/**
- * Returns the scalar dot product.
- * @example
- * ```ts
- * dot3([1, 0, 0], [0, 1, 0]); // 0
- * ```
- */
-export declare const dot3: (a: Vector3Data, b: Vector3Data) => number;
+): readonly PathPlacement[];
 
-/**
- * Uniform finishing vocabulary shared by applicable solid edges and profile corners.
- */
+/** Uniform finishing vocabulary shared by applicable solid edges and profile corners. */
 export declare type EdgeTreatment =
   | ChamferedEdgeTreatment
   | RoundedEdgeTreatment
@@ -1058,9 +667,7 @@ export declare type EdgeTreatment =
  */
 export declare function ellipseContour(options: EllipseContourOptions): Contour;
 
-/**
- * Ellipse dimensions with exactly one XY radii or full-size tuple and explicit sampling.
- */
+/** Ellipse dimensions with exactly one XY radii or full-size tuple and explicit sampling. */
 export declare type EllipseContourOptions = CircularPrimitiveOptions &
   (
     | {
@@ -1077,69 +684,38 @@ export declare type EllipseContourOptions = CircularPrimitiveOptions &
       }
   );
 
-/**
- * Independent inward finishing on primitive or straight convex extrusion ends.
- * Zero amounts leave the end untreated, including when all ends are disabled.
- */
-export declare interface EndTreatments {
-  /** Bottom cap and adjoining side; omitted leaves the end untreated. */
-  readonly bottom?: EdgeTreatment;
-  /** Top cap and adjoining side; omitted leaves the end untreated. */
-  readonly top?: EdgeTreatment;
-}
-
-/**
- * Creates an immutable right-handed XYZ Euler rotation transform.
- *
- * Rotations are applied about global X first, then Y, then Z. This matches the
- * degree-based Euler convention used by the Manifold adapters.
- *
- * @param rotationDegrees - Finite `[x, y, z]` rotation angles in degrees.
- * @returns A frozen row-major transform.
- * @throws {@link GeometryError} When an angle is non-finite.
- */
-export declare function eulerTransform3(
-  rotationDegrees: Vector3Data,
-): Transform3Data;
-
-/**
- * Dimensions and sampling for pure +Z mesh extrusion, without end treatments.
- */
-export declare interface ExtrudeMeshOptions extends ExtrusionSamplingOptions {
-  /** Positive extrusion height in millimetres. */
-  readonly height: number;
-  /** Center the extrusion on Z; otherwise its bottom is at zero. Defaults to false. */
-  readonly center?: boolean;
-}
-
-/** Native +Z extrusion with optional inward end treatments. */
-export declare interface ExtrudeOptions extends ExtrudeMeshOptions {
-  /** Independent inward end treatments on straight convex single-contour extrusions. */
-  readonly ends?: EndTreatments;
-}
-
 /** Shared sampling controls for a twisted or scaled linear extrusion. */
 export declare interface ExtrusionSamplingOptions {
-  /** Exact number of intermediate profiles, nonnegative; overrides physical sampling. */
-  readonly divisions?: number;
+  /** Positive longitudinal interval count; n slices create n + 1 profile layers. Overrides ordinary extrusion's physical sampling. */
+  readonly slices?: number;
   /** Explicit output and sampling allocation ceilings. */
   readonly limits?: Partial<ModelingLimits>;
   /** 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 | Vector2Input;
+  /** Final profile-local uniform or XY scale, interpolated from one before twisting. Both components must be positive or both zero for an apex of one simple boundary. Defaults to one. */
+  readonly scale?: number | Vector2Input;
   /** Finite rotation of the top profile about +Z, in degrees; defaults to zero. */
   readonly twist?: number;
 }
 
-/** Fits XY bounds uniformly and centers them in the target; zero source axes do not constrain scale. */
+/**
+ * Fits XY bounds uniformly and centers them in the target; zero source axes do not constrain scale.
+ *
+ * @param source - Source bounds in millimetres, with at least one positive extent.
+ * @param target - Target bounds in the same dimension and coordinate system.
+ */
 export declare function fitBounds(
   source: Bounds2Data,
   target: Bounds2Data,
   options?: BoundsFitOptions,
 ): BoundsFit2;
 
-/** Fits XYZ bounds uniformly and centers them in the target; zero source axes do not constrain scale. */
+/**
+ * Fits XYZ bounds uniformly and centers them in the target; zero source axes do not constrain scale.
+ *
+ * @param source - Source bounds in millimetres, with at least one positive extent.
+ * @param target - Target bounds in the same dimension and coordinate system.
+ */
 export declare function fitBounds(
   source: Bounds3Data,
   target: Bounds3Data,
@@ -1170,7 +746,7 @@ export declare interface FittedTextLayout extends VectorTextLayout {
  */
 export declare function fitTextLayout(
   layout: VectorTextLayout,
-  target: Bounds2Data,
+  target: Bounds2Input,
   options?: BoundsFitOptions,
 ): FittedTextLayout;
 
@@ -1187,17 +763,35 @@ export declare interface Frame3 {
 }
 
 /**
- * Converts a right-handed orthonormal frame into a local-to-world transform.
+ * Creates a copied, deeply frozen plain coordinate frame in world space.
+ * Axes must be right-handed, unit length, and mutually orthogonal. Only accepted numerical
+ * roundoff is normalized; scale, shear, reflection, and materially invalid bases reject.
+ * Frames are placement inputs; use transform3(frame) when affine methods are needed.
  *
- * @param frame - Frame whose axes become the transform columns.
- * @param tolerance - Optional orthonormality comparison overrides.
- * @returns A frozen rigid transform.
- * @throws {@link GeometryError} When axes are non-unit, non-orthogonal, or left-handed.
+ * @example Place an XY profile using an analytic radial frame
+ * ```ts
+ * const radial = frame3({
+ *   origin: [20, 0, 5],
+ *   xAxis: [0, 1, 0],
+ *   yAxis: [0, 0, 1],
+ *   zAxis: [1, 0, 0],
+ * });
+ * const placed = transform3(radial).applyPoint([2, 3, 0]).toData(); // [20, 2, 8]
+ * ```
  */
-export declare function frameTransform3(
-  frame: Frame3,
-  tolerance?: GeometryToleranceOptions,
-): Transform3Data;
+export declare function frame3(options: Frame3Options): Frame3;
+
+/** An origin in millimetres and a right-handed orthonormal basis in world coordinates. */
+export declare interface Frame3Options {
+  /** World-space origin of the local coordinate system, in millimetres. */
+  readonly origin: Vector3Input;
+  /** Unit vector defining local +X. */
+  readonly xAxis: Vector3Input;
+  /** Unit vector defining local +Y. */
+  readonly yAxis: Vector3Input;
+  /** Unit vector defining local +Z. */
+  readonly zAxis: Vector3Input;
+}
 
 /**
  * Error raised when a geometry precondition or invariant is not satisfied.
@@ -1253,9 +847,7 @@ export declare interface GeometryErrorContext {
   readonly operation: string;
 }
 
-/**
- * Tessellation policy for sampled geometry measured in millimetres.
- */
+/** Tessellation policy for sampled geometry measured in millimetres. */
 export declare interface GeometryResolution {
   /** Optional exact full-circle segment count, of at least three, bounded by the selected circular ceiling. */
   readonly circularSegments?: number;
@@ -1287,21 +879,10 @@ export declare interface GeometryToleranceOptions {
   readonly absolute?: number;
   /** Angular comparison threshold in radians. Must be finite and greater than zero. */
   readonly angular?: number;
-  /** Dimensionless scale multiplier. Must be finite and non-negative. */
+  /** Dimensionless scale multiplier. Must be finite and nonnegative. */
   readonly relative?: number;
 }
 
-/** Returns one recommended metric clearance-hole diameter in millimetres. */
-export declare function getMetricClearanceHoleDiameter(
-  size: MetricFastenerSize,
-  fit?: ClearanceHoleFit,
-): number;
-
-/** Returns the immutable standards record for one supported metric size. */
-export declare function getMetricFastenerStandard(
-  size: MetricFastenerSize,
-): MetricFastenerStandard;
-
 /**
  * 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.
@@ -1316,94 +897,22 @@ export declare type GridPatternOptions<Dimension extends 2 | 3 = 3> = {
       /** Positive integer counts on X and Y. */
       readonly count: Vector2Data;
       /** Signed millimetres between adjacent copies on X and Y. */
-      readonly spacing: Vector2Data;
+      readonly spacing: Vector2Input;
     }
   | (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;
+          readonly spacing: Vector3Input;
         }
       : never)
 );
 
-/** Spatial XYZ matrices for an XY or XYZ grid, in X-fastest order. */
+/** Immutable XYZ placements for an XY or XYZ grid, in X-fastest order. */
 export declare function gridPatternTransforms(
   options: GridPatternOptions,
-): readonly Transform3Data[];
-
-/** Trusted output ceilings for pure construction; omitted fields use engine defaults. */
-export declare type HeightfieldMeshLimits = Partial<
-  Pick<ModelingLimits, "maxVertices" | "maxTriangles" | "maxBytes">
->;
-
-/**
- * A closed rectilinear heightfield above a flat base, with uniform or explicit XY samples in millimetres.
- *
- * Uniform sampling requires positive `size: [width, depth]` and positive integer `segments: [x, y]`.
- * Optional `origin` sets the lower-left XY corner; omitting it centres the footprint on XY.
- * Alternatively, supply `coordinates: { x, y }` with at least two strictly increasing finite
- * absolute samples per axis, distinct in Float32. This infers the footprint and interval counts;
- * `size`, `segments`, and `origin` cannot be combined with explicit coordinates.
- */
-export declare type HeightfieldOptions = {
-  /** Absolute top Z at the supplied XY point. Every sample must be above baseZ. */
-  readonly height: (point: Vector2Data) => number;
-  /** Flat bottom Z. Defaults to zero. */
-  readonly baseZ?: number;
-  /**
-   * Top-cell diagonal policy. Defaults to fixed (lower-left to upper-right).
-   * min-edge selects the shorter 3D diagonal; center-error selects the diagonal whose endpoint
-   * average is closest to one extra height sample at the physical cell centre. Ties use fixed.
-   * All policies retain two triangles per cell; neither estimates error elsewhere in the cell.
-   */
-  readonly triangulation?: "fixed" | "min-edge" | "center-error";
-} & (
-  | {
-      /** Positive XY footprint for uniform sampling. */
-      readonly size: Vector2Input;
-      /** 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?: Vector2Input;
-      /** Explicit coordinates cannot be combined with uniform sampling. */
-      readonly coordinates?: never;
-    }
-  | {
-      /**
-       * Absolute XY coordinates, each with at least two strictly increasing finite values that
-       * remain distinct in Float32. Uneven spacing permits caller-owned local refinement.
-       */
-      readonly coordinates: {
-        /** Absolute X samples in ascending order. */
-        readonly x: readonly number[];
-        /** Absolute Y samples in ascending order. */
-        readonly y: readonly number[];
-      };
-      /** The footprint is inferred from explicit coordinates. */
-      readonly size?: never;
-      /** Interval counts are inferred from explicit coordinates. */
-      readonly segments?: never;
-      /** Explicit coordinates already include their origin. */
-      readonly origin?: never;
-    }
-);
-
-/** Exact grid and mesh buffer allocation counts resolved without evaluating the height callback. */
-export declare interface HeightfieldPreflight {
-  /** 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, excluding temporary storage. */
-  readonly byteCount: number;
-}
-
-/** Identity transform, safe to share because it is frozen. */
-export declare const IDENTITY_TRANSFORM3: Transform3Data;
+): readonly Transform3[];
 
 /** Owned immutable numeric data. Iterate without copying; use copy() for mutable storage. */
 export declare interface ImmutableBuffer<
@@ -1423,9 +932,12 @@ export declare interface ImmutableBuffer<
 
 /**
  * Copies numeric data once into private storage. This pure helper needs no active generation.
+ *
+ * @param source - Caller-owned numeric data; copied into private storage.
+ *
  * @example
  * ```ts
- * import { immutableBuffer } from "@metamesh/modeling";
+ * import { immutableBuffer } from "@metamesh/modeling/geometry";
  * const heights = immutableBuffer(new Float32Array([2, 4, 6]));
  * const count = heights.length;
  * const first = heights.at(0);
@@ -1440,33 +952,6 @@ export declare function immutableBuffer<T extends NumericArray>(
 
 declare const immutableBufferBrand: unique symbol;
 
-/** Immutable local XYZ positions and triangle indices, suitable for a computed value or part. */
-export declare interface ImmutableTriangleMesh {
-  /** Packed XYZ coordinates in millimetres. */
-  readonly positions: ImmutableBuffer<Float32Array>;
-  /** Zero-based vertex indices, three per triangle. */
-  readonly indices: ImmutableBuffer<Uint32Array>;
-}
-
-/** Options for a compensated internal-thread subtraction tool along +Z. */
-export declare interface InternalThreadCutterOptions
-  extends Omit<ThreadRidgeOptions, "majorDiameter">, ThreadBevelOptions {
-  /** Printable fit or caller-calibrated allowances. Default: `normal`. */
-  readonly fit?: PrintableThreadFit | PrintableThreadFitPolicy;
-  /** Nominal major diameter before female compensation and faceting correction. */
-  readonly nominalMajorDiameter: number;
-}
-
-/**
- * Inverts a finite, non-singular affine transform.
- *
- * @param transform - Transform to invert.
- * @returns A new frozen transform whose composition with the input is identity.
- */
-export declare function inverseTransform3(
-  transform: Transform3Data,
-): Transform3Data;
-
 /**
  * Recognizes structured geometry errors from separately bundled Modeling copies in the same realm.
  *
@@ -1475,129 +960,19 @@ export declare function inverseTransform3(
  */
 export declare function isGeometryError(value: unknown): value is GeometryError;
 
-/** 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 [].
+ *
+ * @param bounds - XYZ bounds in row order, after any part rotation.
  */
 export declare function layoutRow(
   bounds: readonly Bounds3Data[],
   options?: RowLayoutOptions,
 ): readonly Vector3Data[];
 
-/** Returns Euclidean vector length in the vector's coordinate units. */
-export declare const length2: (vector: Vector2Data) => number;
-
-/** Returns Euclidean vector length in the vector's coordinate units. */
-export declare const length3: (vector: Vector3Data) => number;
-
-/** Linearly interpolates two vectors; `t` is dimensionless and may extrapolate. */
-export declare const lerp2: (
-  a: Vector2Data,
-  b: Vector2Data,
-  t: number,
-) => Vector2Data;
-
-/** Linearly interpolates two vectors; `t` is dimensionless and may extrapolate. */
-export declare const lerp3: (
-  a: Vector3Data,
-  b: Vector3Data,
-  t: number,
-) => 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.
@@ -1632,10 +1007,10 @@ export declare type LinearPatternOptions<Dimension extends 2 | 3 = 3> = {
     }
 );
 
-/** Spatial XYZ matrix placements in millimetres, including the original at the origin. */
+/** Immutable XYZ placements in millimetres, including the original at the origin. */
 export declare function linearPatternTransforms(
   options: LinearPatternOptions,
-): readonly Transform3Data[];
+): readonly Transform3[];
 
 /** Straight planar curve in millimetres. */
 export declare interface LineCurve2 {
@@ -1657,60 +1032,18 @@ export declare interface LineCurve3 {
   readonly end: Vector3Data;
 }
 
-/**
- * Associates ordered loft contours without inferring component identities or repairing topology.
- *
- * - `direct` preserves seams and subdivides edges to a common count without dropping vertices.
- * - `reindex` applies direct subdivision, then selects the next contour's cyclic phase with the
- *   least total world-space connection length.
- * - `fast-distance` preserves supplied seams and minimizes connection length over ordered closed
- *   vertex associations, repeating vertices for triangular fans.
- * - `distance` runs the same ordered optimization over every cyclic phase of the next contour.
- *
- * Components and holes are paired by their existing order. Use identified profiles when semantic
- * correspondence must remain authoritative.
- */
-export declare type LoftCorrespondence =
-  "direct" | "reindex" | "fast-distance" | "distance";
-
-/** One point-data profile at a height or explicit right-handed spatial frame. */
-export declare type LoftMeshStation = LoftPlacement & {
-  /** Closed Path2 or ordered finite XY boundary points with an implicit closing edge. */
-  readonly profile: Path2Input;
-};
-
-/**
- * Shared controls for native and pure lofts. Point data and arbitrary Sections default to direct correspondence.
- */
-export declare interface LoftOptions {
-  /** One method or one per consecutive station gap. Omitted preserves known primitive landmarks, including circle/ellipse-to-rectangle corners, and otherwise uses direct correspondence with the supplied seams. */
-  readonly correspondence?: LoftCorrespondence | readonly LoftCorrespondence[];
-  /** Extra points follow edge length or distribute equally across existing segments. Defaults to perimeter for direct/reindex, or segments when any distance method is selected; distance methods require segments. */
-  readonly distribution?: "perimeter" | "segments";
-  /** Positive integer point-density multiplier, uniformly or per input profile. Original vertices are retained. Defaults to one. */
-  readonly refine?: number | readonly number[];
-  /** Nonnegative count of world-linearly interpolated profiles, uniformly or per gap. Defaults to zero. */
-  readonly slices?: number | readonly number[];
-  /** Physical curve policy for retained primitives, and maximum edge length for point data. Exact primitive curve counts take precedence. */
-  readonly resolution?: GeometryResolution;
-  /** Explicit output and sampling budgets; native operations may only lower host ceilings. */
-  readonly limits?: Partial<ModelingLimits>;
-}
-
-/**
- * A horizontal XY station height, or an explicit right-handed spatial frame, never both.
- */
+/** A horizontal XY station height, or an explicit affine transform, never both. */
 export declare type LoftPlacement =
   | {
       /** Horizontal XY station height in millimetres. */
       readonly z: number;
       /** Excluded when a horizontal height is supplied. */
-      readonly frame?: never;
+      readonly transform?: never;
     }
   | {
-      /** Right-handed orthonormal station frame in world coordinates. */
-      readonly frame: Frame3;
-      /** Excluded when an explicit spatial frame is supplied. */
+      /** Non-singular affine placement of the profile's XY plane in world coordinates. */
+      readonly transform: Transform3Input;
+      /** Excluded when an explicit transform is supplied. */
       readonly z?: never;
     };
 
@@ -1722,6 +1055,8 @@ export declare type LoftPlacement =
  * Input order and winding are preserved. Collapsed spans retain repeated logical slots, which
  * the engine maps to shared physical vertices while omitting degenerate faces.
  *
+ * @param profiles - 1–1000 profiles with matching component, contour, and span IDs, in order.
+ *
  * @example Match named rectangle landmarks
  * ```ts
  * matchProfiles([
@@ -1743,95 +1078,6 @@ export declare interface MatchProfilesOptions {
   readonly limits?: Partial<GeometrySamplingLimits>;
 }
 
-/**
- * Measures sampled kinematic interference over one tooth cycle of an internal gear pair.
- *
- * The driver and ring start with half-tooth offsets for odd tooth counts, then rotate in the
- * same direction at their resolved tooth-count ratio. Each
- * sampled pinion outline is subtracted from the ring's center-and-space opening; remaining area is
- * solid overlap. This catches involute, tip, and trimming interference that a single assembled pose
- * misses. It is a deterministic model check, not a certified gear-rating calculation.
- */
-export declare function measureInternalCylindricalGearPairMotion(
-  spec: CylindricalGearPairSpec,
-  options?: CylindricalGearPairMotionOptions,
-): CylindricalGearPairMotionReport;
-
-/**
- * Curated metric modeling dimensions for clearance holes, regular hex nuts,
- * and socket-head cap screws.
- *
- * Values are nominal reference dimensions intended for parametric envelopes.
- * Manufacturing tolerances, coatings, and printer compensation remain caller
- * responsibilities.
- */
-export declare const METRIC_FASTENER_STANDARDS: Readonly<{
-  /** Nominal M2 coarse-thread modeling dimensions. */
-  M2: MetricFastenerStandard;
-  /** Nominal M2.5 coarse-thread modeling dimensions. */
-  "M2.5": MetricFastenerStandard;
-  /** Nominal M3 coarse-thread modeling dimensions. */
-  M3: MetricFastenerStandard;
-  /** Nominal M4 coarse-thread modeling dimensions. */
-  M4: MetricFastenerStandard;
-  /** Nominal M5 coarse-thread modeling dimensions. */
-  M5: MetricFastenerStandard;
-  /** Nominal M6 coarse-thread modeling dimensions. */
-  M6: MetricFastenerStandard;
-  /** Nominal M8 coarse-thread modeling dimensions. */
-  M8: MetricFastenerStandard;
-  /** Nominal M10 coarse-thread modeling dimensions. */
-  M10: MetricFastenerStandard;
-  /** Nominal M12 coarse-thread modeling dimensions. */
-  M12: MetricFastenerStandard;
-}>;
-
-/** Supported metric fastener sizes. */
-export declare type MetricFastenerSize =
-  "M2" | "M2.5" | "M3" | "M4" | "M5" | "M6" | "M8" | "M10" | "M12";
-
-/** Small immutable metric fastener record for modeling common mating features. */
-export declare interface MetricFastenerStandard {
-  /** Coarse thread pitch in millimetres. */
-  readonly coarsePitch: number;
-  /** Recommended clearance-hole diameters. */
-  readonly clearanceHoles: ClearanceHoleDimensions;
-  /** Regular hex-nut envelope. */
-  readonly hexNut: MetricHexNutDimensions;
-  /** Nominal fastener diameter in millimetres. */
-  readonly nominalDiameter: number;
-  /** Socket-head cap screw envelope and drive size. */
-  readonly socketCapHead: MetricSocketCapHeadDimensions;
-}
-
-/** Regular hex-nut envelope dimensions in millimetres. */
-export declare interface MetricHexNutDimensions {
-  /** Nominal wrench size across flats. */
-  readonly acrossFlats: number;
-  /** Nominal full-nut thickness. */
-  readonly thickness: number;
-}
-
-/** Socket-head cap screw head and drive dimensions in millimetres. */
-export declare interface MetricSocketCapHeadDimensions {
-  /** Nominal cylindrical head diameter. */
-  readonly diameter: number;
-  /** Nominal head height. */
-  readonly height: number;
-  /** Nominal internal hex key size across flats. */
-  readonly hexKey: number;
-}
-
-/**
- * Returns the smallest unshifted full-depth external tooth count that avoids rack-cutter undercut.
- *
- * The normal-plane limit is `2 / sin²(alpha_n)`. Helical gears use the standard virtual tooth
- * count `z_v = z / cos³(beta)`, so increasing helix angle can reduce the physical tooth count.
- */
-export declare function minimumCylindricalGearToothCountWithoutUndercut(
-  spec?: Readonly<Pick<CylindricalGearSpec, "helixAngle" | "pressureAngle">>,
-): number;
-
 /** Aggregate manufacturing output ceilings selected by a trusted host. */
 export declare interface ModelingLimits extends GeometrySamplingLimits {
   /** Maximum number of named finalized parts. */
@@ -1844,35 +1090,16 @@ export declare interface ModelingLimits extends GeometrySamplingLimits {
   readonly maxBytes: number;
 }
 
-/**
- * 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: Vector2Data,
-  epsilon?: number,
-) => 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: Vector3Data,
-  epsilon?: number,
-) => Vector3Data;
-
 /**
  * Cleans and validates one closed loop.
  *
  * Adjacent duplicates and a repeated seam point are removed. Coordinates must
  * be finite, the effective loop must contain at least three points, and the
- * result must be simple and have non-zero area. Previously validated immutable results may be
+ * result must be simple and have nonzero area. Previously validated immutable results may be
  * returned unchanged when their winding and tolerance policy match.
+ *
+ * @param input - XY loop in millimetres; caller data is preserved.
+ * @param counterClockwise - true for an exterior, false for a hole.
  */
 export declare function normalizeContour(
   input: readonly Vector2Data[],
@@ -1886,6 +1113,8 @@ export declare function normalizeContour(
  * Exteriors become CCW and holes clockwise. Every hole must lie strictly
  * within its exterior and boundaries may not intersect. Previously validated immutable results
  * may be returned unchanged under the same tolerance policy.
+ *
+ * @param polygon - Millimetre exterior and holes; boundaries must be disjoint.
  */
 export declare function normalizePolygon(
   polygon: PolygonData,
@@ -1895,6 +1124,8 @@ export declare function normalizePolygon(
 /**
  * Validates a disjoint explicit region and returns immutable normalized data.
  * Previously validated immutable results may be returned unchanged under the same tolerance policy.
+ *
+ * @param region - Disjoint millimetre polygons; empty input is valid.
  */
 export declare function normalizeRegion(
   region: RegionData,
@@ -1919,6 +1150,23 @@ export declare interface Path2 {
   bounds(): Bounds2 | undefined;
   /** Finds the nearest edge location; requires at least two vertices. */
   closestPoint(point: Vector2Input): PathLocation<Vector2>;
+  /** Queries a finite distance in [0, length()]. Skips zero-length edges; closed length() selects the outgoing seam. Rejects zero-length paths. */
+  atDistance(distance: number): PathStation<Vector2>;
+  /** Queries finite whole-path progress in [0, 1] using arc length, with the same edge rules as atDistance(). */
+  atFraction(fraction: number): PathStation<Vector2>;
+  /** Splits strictly inside one traversal into two open paths. Original interior vertices survive; limits bound each input/output path. */
+  splitAt(
+    distance: number,
+    limits?: Partial<GeometrySamplingLimits>,
+  ): readonly [Path2, Path2];
+  /** Extracts increasing distances in [0, length()] as an open path, retaining original interior vertices. Closed paths use their authored seam. */
+  trim(
+    startDistance: number,
+    endDistance: number,
+    limits?: Partial<GeometrySamplingLimits>,
+  ): Path2;
+  /** Refines each edge independently without bridging corners or removing original vertices. Closure and repeated adjacent vertices survive. */
+  subdivide(options: PathSubdivisionOptions): Path2;
   /** 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. */
@@ -1937,6 +1185,9 @@ export declare interface Path2 {
  * 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.
+ *
+ * @param input - XY path or finite millimetre coordinates to copy.
+ * @param options - Closure for raw points and construction limits.
  */
 export declare function path2(input: Path2Input, options?: PathOptions): Path2;
 
@@ -1967,6 +1218,23 @@ export declare interface Path3 {
   bounds(): Bounds3 | undefined;
   /** Finds the nearest edge location; requires at least two vertices. */
   closestPoint(point: Vector3Input): PathLocation<Vector3>;
+  /** Queries a finite distance in [0, length()]. Skips zero-length edges; closed length() selects the outgoing seam. Rejects zero-length paths. */
+  atDistance(distance: number): PathStation<Vector3>;
+  /** Queries finite whole-path progress in [0, 1] using arc length, with the same edge rules as atDistance(). */
+  atFraction(fraction: number): PathStation<Vector3>;
+  /** Splits strictly inside one traversal into two open paths. Original interior vertices survive; limits bound each input/output path. */
+  splitAt(
+    distance: number,
+    limits?: Partial<GeometrySamplingLimits>,
+  ): readonly [Path3, Path3];
+  /** Extracts increasing distances in [0, length()] as an open path, retaining original interior vertices. Closed paths use their authored seam. */
+  trim(
+    startDistance: number,
+    endDistance: number,
+    limits?: Partial<GeometrySamplingLimits>,
+  ): Path3;
+  /** Refines each edge independently without bridging corners or removing original vertices. Closure and repeated adjacent vertices survive. */
+  subdivide(options: PathSubdivisionOptions): Path3;
   /** Applies an XYZ placement without changing traversal order or closure. */
   transform(placement: Transform3Input): Path3;
   /** Reverses vertex order and traversal without mutating the source. */
@@ -1981,6 +1249,9 @@ export declare interface Path3 {
  *
  * Use `toData()` for a frozen record that restores coordinates, closure, and dimension together.
  *
+ * @param input - XYZ path or finite millimetre coordinates to copy.
+ * @param options - Closure for raw points and construction limits.
+ *
  * @see {@link path2} for shared construction rules.
  */
 export declare function path3(input: Path3Input, options?: PathOptions): Path3;
@@ -2023,7 +1294,7 @@ export declare interface PathLocation<Point extends Vector2 | Vector3> {
 /**
  * Supplies a profile-X orientation guide for each original normalized sweep station.
  *
- * @param point - Current XYZ path point in model units.
+ * @param point - Current XYZ path point in millimetres.
  * @param index - Zero-based index of `point` in the normalized authored sweep path.
  * @returns A finite guide vector that is not parallel to the local path tangent.
  */
@@ -2046,28 +1317,31 @@ export declare interface PathPatternOptions {
   readonly count: number;
   /** Raw point closure defaults to false; a path value supplies closure and rejects conflicts. */
   readonly closed?: boolean;
-  /** Preserve orientation, or align local +X for Sections / +Z for Solids to the tangent. Defaults to fixed. */
+  /** Preserve orientation, or align local +X for Sections / +Z for Solids to the outgoing edge tangent. An open final endpoint uses its incoming edge. Defaults to fixed. */
   readonly orientation?: "fixed" | "tangent";
 }
 
 /**
  * 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.
+ * 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.
+ *
+ * @param path - XYZ path or points in millimetres; path values supply closure.
+ * @param limits - Limits on input points and output placements.
  */
 export declare function pathPatternTransforms(
   path: Path3Input,
   options: PathPatternOptions,
   limits?: Partial<GeometrySamplingLimits>,
-): readonly Transform3Data[];
+): readonly Transform3[];
 
-/** Position and unit tangent for one path-distributed item. */
+/** Position and directed unit edge tangent for one path-distributed item. */
 export declare interface PathPlacement {
   /** Interpolated point on the sampled path. */
   readonly position: Vector3Data;
-  /** Unit tangent of the path segment containing the placement. */
+  /** Outgoing unit tangent at vertices; an open final endpoint uses its incoming edge. */
   readonly tangent: Vector3Data;
 }
 
@@ -2077,6 +1351,28 @@ export declare interface PathResamplingOptions extends CurveSamplingOptions {
   readonly segments?: number;
 }
 
+/** Directed location at an arc-length offset along a sampled path. */
+export declare interface PathStation<Point extends Vector2 | Vector3> {
+  /** Immutable position on the sampled boundary. */
+  readonly point: Point;
+  /** Unit outgoing edge tangent; an open final endpoint uses its incoming edge. */
+  readonly tangent: Point;
+  /** Distance from the path's first vertex in model units, including a closing edge when closed. */
+  readonly offset: number;
+  /** Original starting vertex of the selected nonzero edge. */
+  readonly edgeIndex: number;
+  /** Fraction within that edge, independent of normalized whole-path progress. */
+  readonly fraction: number;
+}
+
+/** Corner-preserving edge refinement; the original vertices remain in traversal order. */
+export declare interface PathSubdivisionOptions {
+  /** Positive maximum output edge length in model units; each source edge is divided independently. */
+  readonly maxSegmentLength: number;
+  /** Input and output point ceilings; omitted values use package defaults. */
+  readonly limits?: Partial<GeometrySamplingLimits>;
+}
+
 /** 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. */
@@ -2089,99 +1385,10 @@ export declare interface Pivot3Options {
   readonly pivot?: Vector3Input;
 }
 
-/** Stable reason why planar optimization returned the original mesh unchanged. */
-export declare type PlanarMeshOptimizationFallbackReason =
-  | "candidate-boundary-changed"
-  | "candidate-measurements-changed"
-  | "candidate-not-closed-oriented-manifold"
-  | "candidate-quality-regressed"
-  | "input-not-closed-oriented-manifold";
-
-/** Options controlling bounded, connectivity-only optimization of planar triangle patches. */
-export declare interface PlanarMeshOptimizationOptions extends TriangleMeshQualityOptions {
-  /**
-   * Maximum attempted edge evaluations. By default this is twenty times the initial candidate
-   * edge count, capped at `1000000`.
-   */
-  readonly maxFlipAttempts?: number;
-  /** Maximum times one edge may be reconsidered after neighbouring flips. Defaults to `12`. */
-  readonly maxEdgeRevisits?: number;
-  /** Maximum triangles allowed in one selected patch. Defaults to `50000`. */
-  readonly maxPatchTriangles?: number;
-  /** Maximum cumulative triangles across selected patches. Defaults to `200000`. */
-  readonly maxProcessedTriangles?: number;
-  /** Minimum triangles required before a planar patch is eligible. Defaults to `8`. */
-  readonly minPatchTriangles?: number;
-  /** Select patches whose worst normalized aspect ratio exceeds this value. Defaults to `12`. */
-  readonly triggerMaxAspectRatio?: number;
-  /** Select patches whose largest per-vertex triangle share exceeds this ratio. Defaults to `0.2`. */
-  readonly triggerMaxFanRatio?: number;
-  /** Select patches whose largest vertex triangle incidence exceeds this value. Defaults to `16`. */
-  readonly triggerMaxVertexTriangleIncidence?: number;
-  /** Select patches whose smallest interior angle is below this many degrees. Defaults to `8`. */
-  readonly triggerMinAngleDegrees?: number;
-}
-
-/** Outcome of bounded planar-patch optimization, including before/after diagnostics. */
-export declare interface PlanarMeshOptimizationResult {
-  /** Quality report for the returned mesh; equal to `before` on unchanged or fallback results. */
-  readonly after: TriangleMeshQualityReport;
-  /** Quality report for the supplied mesh. */
-  readonly before: TriangleMeshQualityReport;
-  /** Whether a work bound stopped evaluation while eligible work remained. */
-  readonly budgetExhausted: boolean;
-  /** Whether the returned mesh has different triangle connectivity. */
-  readonly changed: boolean;
-  /** Safety reason when candidate validation rejected optimization or input topology was unsupported. */
-  readonly fallbackReason?: PlanarMeshOptimizationFallbackReason;
-  /** Number of accepted legal diagonal flips. */
-  readonly flipCount: number;
-  /** Returned mesh; unchanged results preserve the exact input object. */
-  readonly mesh: TriangleMesh;
-  /** Number of planar patches in which at least one edge was flipped. */
-  readonly optimizedPatchCount: number;
-  /** Number of triggered patches omitted because a configured triangle bound would be exceeded. */
-  readonly skippedPatchCount: number;
-}
-
-/** Quality measurements for one edge-connected coplanar triangle patch. */
-export declare interface PlanarPatchQuality {
-  /** Number of edges separating this patch from another plane or the mesh boundary. */
-  readonly boundaryEdgeCount: number;
-  /** Number of connected boundary loops; holes contribute additional loops. */
-  readonly boundaryLoopCount: number;
-  /** Maximum ratio of one vertex's incident patch triangles to the patch triangle count. */
-  readonly fanRatio: number;
-  /** Lowest source triangle index in this deterministic patch. */
-  readonly firstTriangleIndex: number;
-  /** Stable zero-based patch identifier in first-triangle order. */
-  readonly id: number;
-  /** Number of edges shared by two triangles within this patch. */
-  readonly internalEdgeCount: number;
-  /** Largest normalized triangle aspect ratio; an equilateral triangle has ratio `1`. */
-  readonly maximumTriangleAspectRatio: number;
-  /** Largest number of patch triangles incident to one vertex. */
-  readonly maximumVertexTriangleIncidence: number;
-  /** Largest number of distinct patch neighbours connected to one vertex. */
-  readonly maximumVertexValence: number;
-  /** Smallest interior triangle angle in degrees. */
-  readonly minimumTriangleAngleDegrees: number;
-  /** Consistently wound unit normal for the patch plane. */
-  readonly normal: Vector3Data;
-  /** Plane offset in `dot(normal, position) = planeOffset` form, in model units. */
-  readonly planeOffset: number;
-  /** Total patch area in squared model units. */
-  readonly surfaceArea: number;
-  /** Number of triangles in this patch. */
-  readonly triangleCount: number;
-  /** Number of distinct indexed vertices referenced by this patch. */
-  readonly vertexCount: number;
-}
-
 /**
  * One filled two-dimensional polygon with an exterior and optional holes.
  *
- * `outer` is counter-clockwise and each hole is clockwise. Boundary arrays omit
+ * `outer` is counterclockwise 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.
  *
@@ -2195,9 +1402,7 @@ export declare interface PolygonData {
   readonly outer: Contour;
 }
 
-/**
- * Equal arc-length sampling of an open path or an implicitly closed loop.
- */
+/** Equal arc-length sampling of an open path or an implicitly closed loop. */
 export declare interface PolylineResamplingOptions extends CurveSamplingOptions {
   /** Exact equal arc-length intervals; closed paths require at least three. */
   readonly segments?: number;
@@ -2205,21 +1410,6 @@ export declare interface PolylineResamplingOptions extends CurveSamplingOptions
   readonly closed?: boolean;
 }
 
-/**
- * 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 `mesh.preflightThreadSolid` for standalone mesh estimates.
- * See `mesh.threadSolid` for standalone mesh construction.
- */
-export declare function preflightInternalThreadCutter(
-  options: InternalThreadCutterOptions,
-): ThreadSolidPreflight;
-
 /**
  * Parses and validates bounded SVG input, constructing its normalized sampled region and diagnostics.
  *
@@ -2232,7 +1422,7 @@ export declare function preflightInternalThreadCutter(
  * 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.
+ * @param options - Physical sampling, viewport origin, and optional fitting to millimetre bounds.
  * @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.
  */
@@ -2241,90 +1431,12 @@ export declare function preflightSvgRegion(
   options?: SvgImportOptions,
 ): SvgRegionPreflight;
 
-/**
- * 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 `mesh.preflightThreadSolid` for standalone mesh estimates.
- */
-export declare function preflightThreadedNut(
-  options: ThreadedNutOptions,
-): ThreadedNutPreflight;
-
-/**
- * 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 `mesh.preflightThreadSolid` for standalone mesh estimates.
- * See `mesh.threadSolid` for standalone mesh construction.
- */
-export declare function preflightThreadedRod(
-  options: ThreadedRodOptions,
-): ThreadSolidPreflight;
-
-/** 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 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;
-}
-
-/**
- * Conservative baseline print-fit policies in millimetres.
- *
- * These are modeling defaults, not manufacturing guarantees. A caller should
- * calibrate them for its printer, material, layer height, and thread scale.
- */
-export declare const PRINTABLE_THREAD_FIT_POLICIES: Readonly<{
-  /** Small baseline clearance for calibrated, accurate printers. */
-  tight: PrintableThreadFitPolicy;
-  /** General-purpose baseline clearance. */
-  normal: PrintableThreadFitPolicy;
-  /** Generous baseline clearance for rougher prints or easy assembly. */
-  loose: PrintableThreadFitPolicy;
-}>;
-
-/**
- * Named baseline fit policies for calibrated FDM-style printed threads.
- */
-export declare type PrintableThreadFit = "tight" | "normal" | "loose";
-
-/**
- * Explicit radial and axial allowances for a mating printed thread pair.
- *
- * Male and female radial values are applied independently, so their sum is the
- * assembled radial clearance. Values are millimetres and intentionally do not
- * encode printer, material, or process calibration.
- */
-export declare interface PrintableThreadFitPolicy {
-  /** Nominal axial backlash available between opposing flanks. */
-  readonly axialBacklash: number;
-  /** Radial increase applied to an internal thread envelope. */
-  readonly femaleRadialOutset: number;
-  /** Radial reduction applied to an external thread envelope. */
-  readonly maleRadialInset: number;
-}
-
 /**
  * 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}
+ * @see [matchProfiles](/docs/reference/geometry/matchProfiles)
  */
 export declare interface Profile {
   /** Ordered components with explicit contour identities. */
@@ -2361,8 +1473,9 @@ export declare interface ProfiledEdgeTreatment {
   readonly kind: "profile";
   /**
    * Millimetre setbacks on adjoining surfaces, from [positive, 0] to [0, positive].
-   * First coordinates decrease and second coordinates increase. Cylinder/extrusion ends use
-   * cap inset first, side setback second; planar corners use incoming then outgoing edges.
+   * First coordinates decrease and second coordinates increase. Cylinder/tube/extrusion ends
+   * use cap inset then side setback; hole openings use mouth expansion then axial depth.
+   * Planar corners and edge cutters use the first then second adjoining surface direction.
    */
   readonly profile: readonly Vector2Data[];
 }
@@ -2410,53 +1523,7 @@ export declare type ProfileSpan2 = {
     }
 );
 
-/** Removes the component parallel to a normalized plane normal. */
-export declare const projectOntoPlane3: (
-  vector: Vector3Data,
-  normal: Vector3Data,
-) => Vector3Data;
-
-/** Resolved pitch-line dimensions for a finite rack segment. */
-export declare interface RackPitchDimensions {
-  /** Tooth height above the pitch line, in millimetres. */
-  readonly addendum: number;
-  /** Tooth root depth below the pitch line, in millimetres. */
-  readonly dedendum: number;
-  /** Signed helix angle, in radians. */
-  readonly helixAngleRadians: number;
-  /** Total pitch-line length for the requested tooth count, in millimetres. */
-  readonly length: number;
-  /** Transverse linear pitch between teeth, in millimetres. */
-  readonly pitch: number;
-  /** Transverse pressure angle, in radians. */
-  readonly pressureAngleRadians: number;
-  /** Tangential tooth thickness at the pitch line, in millimetres. */
-  readonly toothThicknessAtPitch: number;
-  /** Number of complete teeth represented by the segment. */
-  readonly toothCount: number;
-  /** Normal module supplied by the caller, in millimetres. */
-  readonly module: number;
-}
-
-/** Normal-plane inputs for a finite rack pitch segment. */
-export declare interface RackPitchSpec {
-  /** Tangential tooth-thickness reduction at the pitch line, in millimetres. */
-  readonly backlash?: number;
-  /** 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 helixAngle?: number;
-  /** Normal module in millimetres per tooth. */
-  readonly module: number;
-  /** Normal pressure angle in degrees; defaults to 20 degrees. */
-  readonly pressureAngle?: number;
-  /** Number of complete rack teeth represented by the segment. */
-  readonly toothCount: number;
-}
-
-/**
- * Degree rotations about a fixed world-space pivot; XY patterns use the implicit +Z axis.
- */
+/** Degree rotations about a fixed world-space pivot; XY patterns use the implicit +Z axis. */
 export declare type RadialPatternOptions<Dimension extends 2 | 3 = 3> = {
   /** Number of shapes to return, including the original. */
   readonly count: number;
@@ -2477,14 +1544,12 @@ export declare type RadialPatternOptions<Dimension extends 2 | 3 = 3> = {
 /** Rotations about an explicit axis; angles use degrees and the first placement is identity. */
 export declare function radialPatternTransforms(
   options: RadialPatternOptions,
-): readonly Transform3Data[];
+): readonly Transform3[];
 
 /** Radial dimensions refer to polygon vertices or compensate faceting to meet polygon faces. */
 export declare type RadialSizing = "vertex" | "face";
 
-/**
- * Nominal radial sizing shared by circular and regular polygon construction.
- */
+/** Nominal radial sizing shared by circular and regular polygon construction. */
 export declare interface RadialSizingOptions {
   /** Explicit sampling ceilings; bound modeling operations may only lower the host policy. */
   readonly limits?: Partial<GeometrySamplingLimits>;
@@ -2512,9 +1577,7 @@ export declare function rectangleContour(
   options: RectangleContourOptions,
 ): Contour;
 
-/**
- * Shared rectangle dimensions, origin and uniform or per-corner treatment.
- */
+/** Shared rectangle dimensions, origin and uniform or per-corner treatment. */
 export declare interface RectangleContourOptions {
   /** Positive uniform size or explicit XY extents in millimetres. */
   readonly size: number | Vector2Input;
@@ -2547,7 +1610,7 @@ export declare type RectangleCornerTreatments = readonly [
  *
  * Use [rectangle](/docs/reference/model/rectangle) for a filled Section.
  *
- * @see {@link matchProfiles} to sample a family with shared landmark correspondence.
+ * @see [matchProfiles](/docs/reference/geometry/matchProfiles) to sample a family with shared landmark correspondence.
  * @see {@link rectangleContour} for sampled boundary coordinates.
  *
  * @example Retain rectangle landmarks
@@ -2577,14 +1640,18 @@ export declare interface RectangleProfileOptions extends RectangleContourOptions
  */
 export declare function regionArea(region: RegionData): number;
 
-/** Returns finite axis-aligned bounds for a non-empty region. */
+/**
+ * Returns finite axis-aligned bounds for a nonempty region.
+ *
+ * @param region - Nonempty region with finite millimetre exterior coordinates.
+ */
 export declare function regionBounds(region: RegionData): Bounds2Data;
 
 /**
  * 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}
+ * @see [PolygonData](/docs/reference/geometry/PolygonData)
  */
 export declare type RegionData = readonly PolygonData[];
 
@@ -2610,7 +1677,12 @@ export declare interface RegularPolygonContourOptions extends RadialSizingOption
   readonly rotation?: number;
 }
 
-/** Resamples a planar polyline with the same point, tangent, seam and budget guarantees as 3D.
+/**
+ * Resamples a planar polyline with the same point, tangent, seam and budget guarantees as 3D.
+ *
+ * @param path - XY points in millimetres; duplicate neighbors are removed.
+ * @param options - Closure and exact intervals or physical edge spacing.
+ *
  * @remarks Only final 2D output vectors are copied and frozen. No immutable 3D intermediate is built.
  * @example
  * ```ts
@@ -2624,6 +1696,10 @@ export declare function resamplePolyline2(
 
 /**
  * Resamples a spatial polyline at equal arc lengths with directed outgoing tangents.
+ *
+ * @param path - XYZ points in millimetres; duplicate neighbors are removed.
+ * @param options - Closure and exact intervals or physical edge spacing.
+ *
  * @remarks Open paths retain both endpoints; closed paths include the closing edge and omit the
  * repeated seam. Repeated adjacent inputs and explicit closing duplicates are removed. Physical
  * maxSegmentLength bounds arc-length intervals; exact counts override that policy. Output edges
@@ -2641,7 +1717,7 @@ export declare function resamplePolyline3(
 /**
  * Resolves a deterministic full-circle count aligned to reusable topology factors.
  *
- * `alignTo` must be non-empty and contain only positive safe integers. Its checked least common
+ * `alignTo` must be nonempty 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 `minSegments`. Adaptive counts are rounded upward and fail with
@@ -2667,12 +1743,13 @@ export declare function resolveAlignedCircularSegments(
 /**
  * Resolves the number of segments needed for a circular arc.
  *
- * Full-circle limits and exact circular counts are scaled to the requested angular span, matching
- * the reusable BOSL2-style convention while retaining at least one segment.
+ * Full-circle limits and exact circular counts are scaled to the requested angular span,
+ * retaining at least one segment.
  *
  * @param radius - Arc radius in millimetres.
- * @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.
+ * @param angle - Nonzero signed sweep angle no greater than 360 degrees in magnitude.
+ * @param policy - Explicit physical sampling policy; omitted fields use package defaults.
+ * @param limits - Full-circle segment limit, applied before scaling to the arc.
  * @returns Segment count for the requested arc span.
  * @throws {@link GeometryError} when radius, angle, or resolution policy is invalid, or the
  * corresponding full-circle tolerance exceeds the configured safety limit.
@@ -2718,7 +1795,8 @@ export declare function resolveCircularSampling(
  * `COMPLEXITY_LIMIT` rather than silently reducing quality.
  *
  * @param radius - Circle radius in millimetres.
- * @param policy - Optional operation-level policy under explicit sampling ceilings.
+ * @param policy - Optional operation-level policy under explicit sampling limits.
+ * @param limits - Full-circle segment limits; omitted fields use defaults.
  * @returns Full-circle segment count.
  * @throws {@link GeometryError} when radius or policy is invalid, or the requested tolerance
  * exceeds the configured segment safety limit.
@@ -2736,27 +1814,19 @@ export declare function resolveCircularSegments(
   limits?: Partial<GeometrySamplingLimits>,
 ): number;
 
-/**
- * Resolves a validated unshifted full-depth external cylindrical gear.
- *
- * The gear axis is +Z and the returned radii describe its XY pitch plane. Inputs below the
- * pressure- and helix-dependent no-undercut tooth count are rejected because profile shift is not
- * currently supported.
- */
-export declare function resolveCylindricalGear(
-  spec: CylindricalGearSpec,
-): CylindricalGearDimensions;
-
-/**
- * Resolves ratio, center distance, and helix relationship for a gear pair.
- *
- * Both gears must use the same normal module, pressure angle, and helix-angle
- * magnitude. An external pair uses opposite helix hands; an internal pair uses
- * the same hand. The function validates those conjugate pitch invariants.
- */
-export declare function resolveCylindricalGearPair(
-  spec: CylindricalGearPairSpec,
-): CylindricalGearPairDimensions;
+/** Fully populated physical tessellation policy used by adaptive samplers. */
+export declare interface ResolvedGeometryResolution {
+  /** Optional exact full-circle segment count; overrides adaptive sampling. */
+  readonly circularSegments?: number;
+  /** Maximum physical chord error in millimetres. */
+  readonly maxChordError: number;
+  /** Optional maximum physical sampled edge length in millimetres. */
+  readonly maxSegmentLength?: number;
+  /** Maximum allowed full-circle segment count within the selected allocation ceiling. */
+  readonly maxSegments: number;
+  /** Minimum full-circle segment count used by adaptive sampling. */
+  readonly minSegments: number;
+}
 
 /** Fully resolved tolerances for one operation and model scale. */
 export declare interface ResolvedGeometryTolerance {
@@ -2773,26 +1843,31 @@ export declare interface ResolvedGeometryTolerance {
 }
 
 /**
- * Resolves intermediate profile copies for linear extrusion from physical curve resolution.
+ * Resolves longitudinal intervals for ordinary linear extrusion from physical curve resolution.
  *
  * Accepts one XY loop or a filled XY region, including every hole and disconnected component.
- * Exact `divisions`, including zero, override physical sampling. Otherwise chord error bounds
+ * End treatments are unsupported; native finishing inserts its own treatment stations.
+ * Explicit positive `slices` override physical sampling. Otherwise chord error bounds
  * the triangulated side surface, including rotation across each profile edge. Optional segment
- * length bounds station travel including Z. Straight extrusions need no intermediate copies by default.
+ * length bounds station travel including Z. Straight extrusions use one interval by default.
  * Exceeding the selected maxPathPoints ceiling raises `COMPLEXITY_LIMIT` instead of reducing fidelity.
  *
  * @param profile - Ordered XY millimetre contours with implicit closing edges.
  * @param height - Positive extrusion height in millimetres.
- * @param options - Twist, scale, exact divisions, and physical resolution controls.
- * @returns Number of intermediate copies, excluding the two end profiles.
+ * @param options - Twist, scale, exact slices, and physical resolution controls.
+ * @returns Positive interval count, creating one more profile layer than intervals.
  */
-export declare function resolveExtrusionDivisions(
+export declare function resolveExtrusionSlices(
   profile: Contour | RegionData,
   height: number,
   options?: ExtrusionSamplingOptions,
 ): number;
 
-/** Resolves finite positive safe-integer allocation ceilings without ambient state. */
+/**
+ * Resolves finite positive safe-integer allocation ceilings without ambient state.
+ *
+ * @param overrides - Trusted overrides that may raise defaults; omitted fields keep them.
+ */
 export declare function resolveGeometrySamplingLimits(
   overrides?: Partial<GeometrySamplingLimits>,
 ): GeometrySamplingLimits;
@@ -2814,83 +1889,6 @@ 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,
-): PrintableThreadFitPolicy;
-
-/** Resolves a rack segment that is conjugate with the same normal cylindrical pitch system. */
-export declare function resolveRackPitch(
-  spec: RackPitchSpec,
-): RackPitchDimensions;
-
-/**
- * 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 `maxSegments`.
- */
-export declare function resolveThreadCircularSegments(
-  options: ThreadCircularSegmentsOptions,
-): number;
-
-/**
- * Circumferential sampling and degree sweep shared by pure and filled revolution.
- */
-export declare interface RevolveOptions extends CircularPrimitiveOptions {
-  /**
-   * 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 mesh.revolve supports one interval.
-   * @defaultValue `360`
-   */
-  readonly degrees?: number;
-  /** Explicit output and sampling allocation ceilings. */
-  readonly limits?: Partial<ModelingLimits>;
-}
-
-/**
- * Rotates a finite vector counter-clockwise in XY by `degrees` about the origin.
- * Throws `NON_FINITE_VALUE` for nonfinite coordinates, angles, or derived coordinates.
- */
-export declare const rotate2: (
-  vector: Vector2Data,
-  degrees: number,
-) => Vector2Data;
-
-/**
- * Creates a right-handed axis-angle rotation transform.
- *
- * @param axis - Rotation axis; normalization is performed internally.
- * @param angle - Finite right-handed angle with exactly one explicit unit.
- * @param tolerance - Optional zero-length comparison overrides.
- * @returns A frozen row-major transform.
- */
-export declare function rotationTransform3(
-  axis: Vector3Data,
-  angle: AxisAngleRotation3,
-  tolerance?: GeometryToleranceOptions,
-): Transform3Data;
-
 /**
  * Replaces each vertex of a non-duplicated closed polyline with a sampled
  * quadratic corner in the same coordinate system as the input.
@@ -2898,8 +1896,12 @@ export declare function rotationTransform3(
  * `radius` is the desired tangent distance for a right angle and is capped to
  * 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.
+ * Invalid coordinates, topology, dimensions, or exhausted budgets throw GeometryError.
+ *
+ * @param input - Closed XYZ path or points in millimetres, without a repeated seam.
+ * @param radius - Positive right-angle tangent distance in millimetres.
+ * @param segmentsPerCorner - Quadratic intervals per corner; a positive integer.
+ * @param limits - Limits on input and rounded path points.
  */
 export declare const roundClosedPolylinePath: (
   input: Path3Input,
@@ -2908,9 +1910,7 @@ export declare const roundClosedPolylinePath: (
   limits?: Partial<GeometrySamplingLimits>,
 ) => readonly Vector3Data[];
 
-/**
- * A circular edge or corner roundover with explicit physical sampling.
- */
+/** A circular edge or corner roundover with explicit physical sampling. */
 export declare interface RoundedEdgeTreatment extends CircularPrimitiveOptions {
   /** Selects circular corners or spherical all-edge roundovers. */
   readonly kind: "round";
@@ -2933,8 +1933,8 @@ export declare interface RowLayoutOptions {
  * `normalizeContour`; this is a single contour without holes. No editor modes or normalized
  * 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 min(4096, maxProfilePoints).
+ * @param curve - Closed contour in millimetres, or coordinates converted by the selected scales.
+ * @param options - Coordinate scales, physical sampling, and vertex limits.
  * @returns Frozen counterclockwise loop in millimetres, without a repeated seam endpoint.
  * @throws {@link GeometryError} for invalid data, topology, scale, or exceeded sampling budgets.
  *
@@ -2969,7 +1969,12 @@ export declare interface SampleContourOptions {
   readonly limits?: Partial<GeometrySamplingLimits>;
 }
 
-/** Samples a planar curve with the same guarantees and policy as spatial sampling.
+/**
+ * Samples a planar curve with the same guarantees and policy as spatial sampling.
+ *
+ * @param curve - XY curve in millimetres; arc angles use degrees.
+ * @param options - Physical sampling or an exact interval count, within vertex limits.
+ *
  * @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
@@ -2983,6 +1988,10 @@ export declare function sampleCurve2(
 
 /**
  * Samples a spatial curve, preserving endpoints and directed unit tangents.
+ *
+ * @param curve - XYZ curve in millimetres; arc angles use degrees.
+ * @param options - Physical sampling or an exact interval count, within vertex limits.
+ *
  * @remarks Exact counts use uniform curve parameters, not equal physical distances. Adaptive cubics
  * bound the full control hull. Full-circle arcs repeat their endpoint; closed polylines do not.
  * @example
@@ -2995,18 +2004,6 @@ export declare function sampleCurve3(
   options?: CurveSamplingOptions,
 ): SampledCurve3;
 
-/**
- * Samples a complete external involute gear boundary in the XY plane.
- *
- * The returned loop is counter-clockwise, closed implicitly without a repeated
- * seam point, and contains no holes. Its center is the origin and its axis is
- * +Z. Bore, hub, keyway, twist, and face-width choices remain generator-owned.
- */
-export declare function sampleCylindricalGearOutline(
-  spec: CylindricalGearSpec,
-  options?: CylindricalGearOutlineOptions,
-): Contour;
-
 /** 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. */
@@ -3015,9 +2012,7 @@ export declare interface SampledCurve2 {
   readonly tangents: readonly Vector2Data[];
 }
 
-/**
- * Immutable spatial points and corresponding directed unit tangents.
- */
+/** Immutable spatial points and corresponding directed unit tangents. */
 export declare interface SampledCurve3 {
   /** Curves retain both endpoints, including full-circle seams; closed resampling omits its seam. */
   readonly points: readonly Vector3Data[];
@@ -3025,18 +2020,6 @@ export declare interface SampledCurve3 {
   readonly tangents: readonly Vector3Data[];
 }
 
-/** Sampled paths plus conventional pitch and lead measurements. */
-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 (readonly Vector3Data[])[];
-  /** Adjacent axial thread spacing in millimetres. */
-  readonly pitch: number;
-  /** Number of revolutions represented by each path. */
-  readonly turns: number;
-}
-
 /**
  * Creates `segments + 1` points including exact helix endpoints from finite positive dimensions.
  *
@@ -3072,32 +2055,6 @@ export declare interface SampleHelixOptions {
   readonly axialWeight?: (t: number) => number;
 }
 
-/**
- * Samples the center opening and tooth spaces used to subtract an internal ring gear.
- *
- * Internal tooth tips lie one addendum below the pitch radius and their roots lie one
- * dedendum above it. At the pitch circle, positive backlash widens each sampled space
- * tangentially. The returned CCW loop encloses the center and is intended to be reversed
- * when used as a region hole.
- */
-export declare function sampleInternalCylindricalGearSpaceOutline(
-  spec: CylindricalGearSpec,
-  options?: CylindricalGearOutlineOptions,
-): Contour;
-
-/**
- * Samples the open top boundary of a finite rack in its XY pitch plane.
- *
- * X follows rack travel, Y is tooth height, and the pitch line is `Y = 0`.
- * The path begins and ends on the root line, omits duplicate adjacent points,
- * and leaves base thickness, mounting features, extrusion, and helical sweep to
- * the owning generator.
- */
-export declare function sampleRackToothPath(
-  spec: RackPitchSpec,
-  limits?: Partial<GeometrySamplingLimits>,
-): readonly Vector2Data[];
-
 /**
  * Samples 1–31 line/cubic segments into a deeply immutable open [radius,height] polyline.
  *
@@ -3107,8 +2064,8 @@ export declare function sampleRackToothPath(
  * Neither normalized coordinates nor editor metadata are required. Endpoints are retained once;
  * 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 min(4096, maxProfilePoints).
+ * @param curve - Open outline in millimetres, or coordinates converted by the selected scales.
+ * @param options - Coordinate scales, physical sampling, and vertex limits.
  * @returns Frozen open polyline in millimetres, ordered from lowest to highest anchor.
  * @throws {@link GeometryError} for invalid coordinates, order, scale, or exceeded subdivision budget.
  *
@@ -3144,7 +2101,7 @@ export declare interface SampleSideProfileOptions {
  *
  * @param layout - Immutable millimetre paths and measurements retained from text preparation.
  * @param resolution - Explicit curve sampling policy; omitted uses the pure default policy.
- * @param limits - Explicit profile and circular allocation ceilings.
+ * @param limits - Profile-point and circle-segment limits.
  * @returns Frozen contours with original glyph winding and no repeated closing vertex.
  * @throws GeometryError for empty outlines, invalid paths or policies, over 1000 paths or selected sampling ceilings.
  */
@@ -3154,43 +2111,6 @@ export declare function sampleTextContours(
   limits?: Partial<GeometrySamplingLimits>,
 ): readonly Contour[];
 
-/**
- * Samples evenly phased thread helices with finite `lead = pitch * starts`.
- * All starts together respect maxPathPoints (default 100000); excessive counts fail before allocation.
- */
-export declare function sampleThreadHelices(
-  options: ThreadHelixOptions,
-): SampledThreadHelices;
-
-/** Multiplies a vector by a dimensionless scalar. */
-export declare const scale2: (
-  vector: Vector2Data,
-  scale: number,
-) => Vector2Data;
-
-/**
- * Multiplies a vector by a dimensionless scalar.
- * @example
- * ```ts
- * scale3([1, 2, 3], 2); // [2, 4, 6]
- * ```
- */
-export declare const scale3: (
-  vector: Vector3Data,
-  scale: number,
-) => Vector3Data;
-
-/**
- * Creates an immutable axis-aligned scale transform.
- *
- * Negative components are reflections. Zero components are rejected because
- * they collapse volume and cannot be inverted.
- *
- * @param factors - Finite, non-zero XYZ scale factors.
- * @returns A frozen row-major transform.
- */
-export declare function scaleTransform3(factors: Vector3Data): Transform3Data;
-
 /** An open radius/height outline; consumers own closure, mounting geometry, and wall policy. */
 export declare interface SideProfileCurve {
   /** Initial radius/height anchor. */
@@ -3226,7 +2146,11 @@ export declare type SideProfileSegment =
       readonly end: SideProfilePoint;
     };
 
-/** Returns the signed area of a non-duplicated loop; positive means CCW. */
+/**
+ * Returns the signed area of a non-duplicated loop; positive means CCW.
+ *
+ * @param loop - XY loop in millimetres, with implicit closure; not validated.
+ */
 export declare function signedContourArea(loop: Contour): number;
 
 /** A cubic corner transition with zero curvature at its straight tangent joins. */
@@ -3243,43 +2167,45 @@ export declare interface SmoothEdgeTreatment {
   readonly limits?: Partial<GeometrySamplingLimits>;
 }
 
-/** 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 maxTests?: number;
-  /** Distance comparison policy in millimetres; near contacts reject conservatively. */
-  readonly tolerance?: GeometryToleranceOptions;
-}
+/**
+ * Samples an immutable XY centripetal Catmull–Rom path through every waypoint in traversal order.
+ * Open endpoints use one-sided secants; closed paths are periodic and omit their repeated seam.
+ * Adjacent duplicate waypoints reject. The default physical policy bounds each cubic control hull;
+ * segmentsPerSpan instead selects exact uniform parameters per span. Sampling never coarsens to fit
+ * maxPathPoints. Invalid topology, nonfinite arithmetic, and exhausted budgets throw GeometryError.
+ *
+ * @param input - XY waypoints in millimetres; path values retain closure.
+ *
+ * @example
+ * ```ts
+ * const route = spline2([[0, 0], [10, 8], [25, 0]], { resolution: { maxChordError: 0.02 } });
+ * ```
+ */
+export declare function spline2(
+  input: Path2Input,
+  options?: SplineOptions,
+): Path2;
 
 /**
- * Exactly one radius or diameter, placement, and tessellation for an origin-centered sphere.
+ * Samples an immutable XYZ centripetal Catmull–Rom path with the same interpolation, seam, sampling, and ceiling rules as spline2.
+ *
+ * @param input - XYZ waypoints in millimetres; path values retain closure.
  */
-export declare type SphereOptions = CircularPrimitiveOptions &
-  PrimitiveAttachment &
-  (
-    | {
-        /** Positive radius in millimetres; mutually exclusive with diameter. */
-        readonly radius: number;
-        /** Full diameter is unavailable when radius is supplied. */
-        readonly diameter?: never;
-      }
-    | {
-        /** Positive full diameter in millimetres; mutually exclusive with radius. */
-        readonly diameter: number;
-        /** Radius is unavailable when diameter is supplied. */
-        readonly radius?: never;
-      }
-  );
+export declare function spline3(
+  input: Path3Input,
+  options?: SplineOptions,
+): Path3;
 
-/** Square profile with equal crest and root widths. */
-export declare interface SquareThreadProfileSpec extends ThreadProfileBaseSpec {
-  /** Selects the square profile family. */
-  readonly kind: "square";
-  /**
-   * Radial depth in millimetres.
-   * @defaultValue `pitch / 2`
-   */
-  readonly depth?: number;
+/** Physical or exact sampling of a centripetal Catmull–Rom spline through authored waypoints. */
+export declare interface SplineOptions {
+  /** Closure defaults to path metadata or false for tuples. Closed inputs omit the repeated seam. */
+  readonly closed?: boolean;
+  /** Exact parameter intervals per waypoint span; overrides physical sampling. Must be a positive safe integer. */
+  readonly segmentsPerSpan?: number;
+  /** Millimetre chord-error and maximum-segment-length policy, applied to every cubic control hull. */
+  readonly resolution?: GeometryResolution;
+  /** Input and aggregate output ceilings; maxPathPoints defaults to 100000. */
+  readonly limits?: Partial<GeometrySamplingLimits>;
 }
 
 /**
@@ -3324,7 +2250,7 @@ export declare interface StrokeOptions {
   readonly cap?: StrokeCap;
   /** Corner treatment; miters exceeding SVG's default limit of 4 become bevels. Default: `miter`. */
   readonly join?: StrokeJoin;
-  /** Physical tessellation policy for round caps and joins. */
+  /** Physical tessellation for round features; caps use tangent-aligned 180-degree arcs. */
   readonly resolution?: GeometryResolution;
   /** Positive total stroke width in millimetres, centered on the sampled path. */
   readonly width: number;
@@ -3335,26 +2261,17 @@ export declare interface StrokeOptions {
  *
  * 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.
+ * resolution. Caps are tangent-aligned semicircles with `ceil(circularSegments / 2)` intervals,
+ * following {@link resolveArcSegments}. 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.
+ *
+ * @param path - Sampled XY path in millimetres; path values supply closure.
  */
 export declare function strokeRegionData(
   path: Path2Input,
   options: StrokeOptions,
 ): RegionData;
 
-/** Subtracts `b` from `a` component-wise. */
-export declare const subtract2: (a: Vector2Data, b: Vector2Data) => Vector2Data;
-
-/**
- * Subtracts `b` from `a`.
- * @example
- * ```ts
- * subtract3([4, 5, 6], [1, 2, 3]); // [3, 3, 3]
- * ```
- */
-export declare const subtract3: (a: Vector3Data, b: Vector3Data) => Vector3Data;
-
 /** Sampling controls for deterministic SVG-to-region conversion. */
 export declare interface SvgImportOptions {
   /**
@@ -3365,9 +2282,9 @@ export declare interface SvgImportOptions {
   readonly fit?: Bounds2Input;
   /** Explicit profile and circular allocation ceilings; bounded SVG source/work limits remain fixed. */
   readonly limits?: Partial<GeometrySamplingLimits>;
-  /** Exact segments for a complete ellipse or round stroke feature. */
+  /** Exact full-circle sampling count; semicircular stroke caps use `ceil(count / 2)` intervals. */
   readonly circularSegments?: number;
-  /** Operation-level physical tessellation policy over the active model-wide policy. */
+  /** Explicit physical tessellation policy; omitted fields use package defaults. */
   readonly resolution?: GeometryResolution;
   /**
    * `"center"` places the viewport center at the origin. `"document"` places its converted
@@ -3442,350 +2359,6 @@ export declare interface SvgRegionPreflightSourceMetrics {
   readonly parsedVertexCount: number;
 }
 
-/**
- * Controls shared by pure mesh construction and filled modeling sweeps.
- */
-export declare interface SweepOptions {
-  /** 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>;
-  /** Explicit frame policy; default transport minimizes rotations, initially projecting +X then +Y then +Z. */
-  readonly orientation?: SweepOrientation;
-  /** 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 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 | Vector2Input | readonly Vector2Input[];
-  /** Corresponding point-index advance at a rotationally equivalent closed seam. */
-  readonly seamProfileOffset?: number;
-}
-
-/**
- * Explicit profile-X frame policy; all normals are directed, and selected singular policies reject.
- */
-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?: 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: Vector3Input;
-    }
-  | {
-      /** Uses an explicitly directed normal callback at each original normalized station. */
-      readonly kind: "guide";
-      /** Finite profile +X guide callback, evaluated once per original path station. */
-      readonly normal: PathNormalGuide;
-    }
-  | {
-      /** Uses sampled curvature normals; zero-curvature stations reject. */
-      readonly kind: "frenet";
-    };
-
-/** 45-degree end bevels for compensated rods and cutters. */
-export declare interface ThreadBevelOptions {
-  /** Bottom/top sizes in millimetres. Omitted disables both. Auto uses profile depth for standard/tapered ends,
-   * or one sixth of the compensated male minor/female major radius for blunt ends. */
-  readonly bevel?: Bevel;
-}
-
-/** Inputs for resolving one shared circular facet count for a mating thread pair. */
-export declare interface ThreadCircularSegmentsOptions {
-  /** Explicit circular allocation ceiling for the shared mating grid. */
-  readonly limits?: Partial<GeometrySamplingLimits>;
-  /** Printable fit whose larger compensated female envelope governs tessellation. */
-  readonly fit?: PrintableThreadFit | PrintableThreadFitPolicy;
-  /** Nominal major diameter before role-specific compensation. */
-  readonly nominalMajorDiameter: number;
-  /**
-   * Maximum active female face outset beyond the compensated major envelope, in millimetres.
-   * This keeps a compensated male/female pair on one role-independent grid when an internal
-   * cutter has an enlarged entrance bevel. Default: `0`.
-   */
-  readonly maxRadialOutset?: number;
-  /** Validated mating profile whose pitch and flank capacities govern tessellation. */
-  readonly profile: ThreadProfile;
-  /** Physical or exact circular resolution policy. */
-  readonly resolution?: GeometryResolution;
-  /** Number of phased starts. Default: `1`. */
-  readonly starts?: number;
-}
-
-/** Options for compensating nominal male or female thread diameters. */
-export declare interface ThreadCompensationOptions {
-  /** Named policy or explicit caller-calibrated allowances. */
-  readonly fit?: PrintableThreadFit | PrintableThreadFitPolicy;
-  /** Nominal sharp or truncated major diameter in millimetres. */
-  readonly nominalMajorDiameter: number;
-  /** Male or female geometry being compensated. */
-  readonly role: ThreadRole;
-  /** Radial depth from major to minor envelope in millimetres. */
-  readonly threadDepth: number;
-  /** Optional numerical tolerance overrides. */
-  readonly tolerance?: GeometryToleranceOptions;
-}
-
-/**
- * Options for a compensated nut with an internal thread.
- */
-export declare interface ThreadedNutOptions extends Omit<
-  InternalThreadCutterOptions,
-  "bevel" | "length"
-> {
-  /** Opening bevels in [bottom, top] order. Omitted or auto uses min(profile.depth, thickness/4); zero disables. */
-  readonly innerBevel?: Bevel;
-  /** Body bevels in [bottom, top] order. Omitted or auto uses min(profile.depth, thickness/4).
-   * Use [0, "auto"] to keep the outside bottom flat without disabling its inner opening bevel. */
-  readonly outerBevel?: Bevel;
-  /** Optional physical policy for a round body, independent of the thread's matched facet grid. */
-  readonly bodyResolution?: GeometryResolution;
-  /** Nut body shape. */
-  readonly shape: ThreadedNutShape;
-  /** Nut thickness along +Z in millimetres. */
-  readonly thickness: number;
-  /** Across-flats width for hex/square or diameter for round, in millimetres. */
-  readonly width: number;
-}
-
-/** 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;
-  /** Resolved opening bevel sizes in millimetres, [bottom, top]. */
-  readonly innerBevel: readonly [bottom: number, top: number];
-  /** Resolved body bevel sizes in millimetres, [bottom, top]. */
-  readonly outerBevel: readonly [bottom: number, top: number];
-  /** Maximum compensated cutter radius at either requested face. */
-  readonly cutterFaceRadius: number;
-  /** Minimum nut-body inradius across the requested top and bottom faces. */
-  readonly minimumBodyFaceInradius: number;
-  /** Smallest radial wall left between the body and cutter at either requested face. */
-  readonly minimumFaceWall: number;
-  /** Conservative allocation estimates for the extended cutter; excludes the body and Boolean result. */
-  readonly thread: ThreadSolidPreflight;
-  /** Start-aligned circular facet count used by the compensated thread cutter. */
-  readonly threadCircularSegments: number;
-}
-
-/**
- * Supported printable nut body shapes.
- */
-export declare type ThreadedNutShape = "hex" | "round" | "square";
-
-/**
- * Options for a compensated external threaded rod along +Z.
- */
-export declare interface ThreadedRodOptions
-  extends Omit<ThreadRidgeOptions, "majorDiameter">, ThreadBevelOptions {
-  /** Printable fit or caller-calibrated allowances. Default: `normal`. */
-  readonly fit?: PrintableThreadFit | PrintableThreadFitPolicy;
-  /** Nominal major diameter before male compensation. */
-  readonly nominalMajorDiameter: number;
-}
-
-/** End shape of a generated helical ridge. */
-export declare type ThreadEndStyle = "blunt" | "standard" | "tapered";
-
-/** Axial end controls for a generated ridge. */
-export declare interface ThreadEndTreatmentOptions {
-  /**
-   * Ridge shape at the lower working boundary. `blunt` ends at full profile height, `standard`
-   * clips the periodic profile at the face, and `tapered` ramps out from the minor envelope.
-   * @defaultValue `"blunt"`
-   */
-  readonly bottom?: ThreadEndStyle;
-  /**
-   * Non-negative unthreaded envelope length reserved at each non-standard end, in millimetres.
-   * Active blunt bevels may raise this reservation to the effective bevel size.
-   * @defaultValue `0`
-   */
-  readonly endLength?: number;
-  /**
-   * Radial envelope toward which a blunt lead-in collapses.
-   * @defaultValue `"minor"`
-   */
-  readonly leadInEnvelope?: ThreadLeadInEnvelope;
-  /**
-   * Physical circumferential lead-in length in millimetres.
-   * @defaultValue The profile depth.
-   */
-  readonly leadInLength?: number;
-  /**
-   * Cross-section scaling curve used by blunt ends. `cut` switches abruptly to the full profile.
-   * @defaultValue `"cut"`
-   */
-  readonly leadInShape?: ThreadLeadInShape;
-  /**
-   * Ridge shape at the upper working boundary. `blunt` ends at full profile height, `standard`
-   * clips the periodic profile at the face, and `tapered` ramps into the minor envelope.
-   * @defaultValue `"blunt"`
-   */
-  readonly top?: ThreadEndStyle;
-}
-
-/**
- * Direction in which a conventional helical thread advances around +Z.
- */
-export declare type ThreadHandedness = "left" | "right";
-
-/** Conventional helix options: `pitch` is adjacent spacing and lead is `pitch * starts`. */
-export declare interface ThreadHelixOptions {
-  /** Helix direction. Default: `right`. */
-  readonly handedness?: ThreadHandedness;
-  /** Explicit aggregate path allocation ceilings across all starts. */
-  readonly limits?: Partial<GeometrySamplingLimits>;
-  /** Total sampled axial length in millimetres. */
-  readonly length: number;
-  /** Angular offset of the first start in degrees. Default: `0`. */
-  readonly phase?: number;
-  /** Adjacent axial thread spacing in millimetres. */
-  readonly pitch: number;
-  /** Radial distance from the +Z axis in millimetres. */
-  readonly radius: number;
-  /** Angular sampling density for each revolution. Default: `32`. */
-  readonly segmentsPerTurn?: number;
-  /** Number of evenly phased helices. Default: `1`. */
-  readonly starts?: number;
-  /** Optional numerical tolerance overrides. */
-  readonly tolerance?: GeometryToleranceOptions;
-}
-
-/** Radial envelope toward which a blunt lead-in collapses. */
-export declare type ThreadLeadInEnvelope = "major" | "minor";
-
-/** BOSL2-compatible cross-section scaling curve for a blunt thread lead-in. */
-export declare type ThreadLeadInShape = "cut" | "linear" | "smooth" | "sqrt";
-
-/**
- * A validated immutable periodic thread profile in `[axial, radial]` millimetres.
- */
-export declare interface ThreadProfile {
-  /** Axial width of the flat at the major envelope. */
-  readonly crestFlatWidth: number;
-  /** Radial distance from the major envelope to the root. */
-  readonly depth: number;
-  /** Profile family that produced this validated profile. */
-  readonly kind: ThreadProfileSpec["kind"];
-  /** Adjacent axial thread spacing in millimetres. */
-  readonly pitch: number;
-  /** Immutable open `[axial, radial]` path spanning one pitch. */
-  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. */
-  readonly pitch: number;
-  /** Optional numerical tolerance overrides. */
-  readonly tolerance?: GeometryToleranceOptions;
-}
-
-/**
- * Supported built-in and caller-defined thread profiles.
- */
-export declare type ThreadProfileSpec =
-  | AcmeThreadProfileSpec
-  | ButtressThreadProfileSpec
-  | CustomThreadProfileSpec
-  | SquareThreadProfileSpec
-  | TrapezoidalThreadProfileSpec
-  | TriangularThreadProfileSpec;
-
-/** Runtime-neutral options for the dedicated helical ridge mesher. */
-export declare interface ThreadRidgeOptions {
-  /**
-   * Optional bottom/top ridge-end treatments. Standalone ridges honor the requested boundaries;
-   * BOSL2-style non-cut lead-in scaling is available on complete thread solids.
-   */
-  readonly ends?: ThreadEndTreatmentOptions;
-  /** Helix direction. Default: `right`. */
-  readonly handedness?: ThreadHandedness;
-  /** Total threaded axial length in millimetres. */
-  readonly length: number;
-  /** Explicit output and circular allocation ceilings. */
-  readonly limits?: Partial<ModelingLimits>;
-  /** Nominal major diameter before any caller-owned fit compensation. */
-  readonly majorDiameter: number;
-  /** Angular offset of the first start in degrees. Default: `0`. */
-  readonly phase?: number;
-  /** Validated periodic profile repeated around the shaft. */
-  readonly profile: ThreadProfile;
-  /** Optional circular-resolution policy. */
-  readonly resolution?: GeometryResolution;
-  /** Number of evenly phased starts. Default: `1`. */
-  readonly starts?: number;
-  /** Optional numerical tolerance overrides. */
-  readonly tolerance?: GeometryToleranceOptions;
-}
-
-/** Whether compensation is being applied to an external or internal thread. */
-export declare type ThreadRole = "male" | "female";
-
-/** Options for a complete threaded-cylinder mesh; base semantics match the ridge builder. */
-export declare interface ThreadSolidOptions extends ThreadRidgeOptions {
-  /** Independent 45-degree bottom/top bevels; omitted disables both. Auto uses profile depth. */
-  readonly bevel?: Bevel;
-  /** Distance of each bevel target face inward from the corresponding mesh end. */
-  readonly bevelOffset?: number;
-  /** `inset` trims an external rod; `outset` expands an internal cutter. */
-  readonly bevelMode?: "inset" | "outset";
-}
-
-/** Selected sampling counts and conservative allocation estimates, before thread mesh construction. */
-export declare interface ThreadSolidPreflight {
-  /** Uniform axial intervals required only by a requested physical segment-length limit. */
-  readonly axialIntervals: number;
-  /** Start-aligned full-circle segment count used by the surface mesh. */
-  readonly circularSegments: number;
-  /** Conservative surface-row count across profile breaks, ends, and bevel stations. */
-  readonly estimatedRows: number;
-  /** Conservative triangle count used by the selected output allocation policy. */
-  readonly estimatedTriangles: number;
-}
-
-/**
- * Dimensions and independent ring/profile tessellation for a torus around the Z axis.
- */
-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`. */
-  readonly majorRadius: number;
-  /** Exact segment count around the Z axis; omitted uses adaptive resolution. */
-  readonly majorSegments?: number;
-  /** Radius of the swept circular profile in millimetres. */
-  readonly minorRadius: number;
-  /** Exact segment count around the swept profile; omitted uses adaptive resolution. */
-  readonly minorSegments?: number;
-  /** Operation-level physical tessellation policy over the active model-wide policy. */
-  readonly resolution?: GeometryResolution;
-}
-
 /** Immutable reusable XY placement. Methods apply in written order; angles are degrees. */
 export declare interface Transform2 {
   /** Applies a translation in model units after this placement. */
@@ -3819,6 +2392,8 @@ export declare interface Transform2 {
  *
  * Use `toData()` for frozen matrix interchange.
  *
+ * @param input - XY affine value or row-major 3x3 matrix; copied. Defaults to identity.
+ *
  * @example
  * ```ts
  * const placement = transform2().rotate(90).translate([10, 0]);
@@ -3860,7 +2435,7 @@ export declare interface Transform3 {
   ): Transform3;
   /** Scales about an optional world-space pivot; finite nonzero factors may reflect. */
   scale(factors: number | Vector3Input, options?: Pivot3Options): Transform3;
-  /** Applies this placement first, then `next`; equivalent to composeTransform3(next, current). */
+  /** Applies this placement first, then `next`; equivalent to multiplyTransform3(next, current). */
   andThen(next: Transform3Input): Transform3;
   /** Returns the inverse; singular and numerically unstable transforms throw GeometryError. */
   inverse(): Transform3;
@@ -3879,19 +2454,35 @@ export declare interface Transform3 {
 /**
  * Creates an immutable XYZ transform, identity by default.
  *
- * Values and data are copied and validated.
+ * Values, matrices, and frames 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.
+ * A frame supplies its origin in millimetres and right-handed orthonormal axes as local-to-world
+ * columns. Invalid axes reject; unit-length roundoff is normalized within geometry tolerance.
  *
  * Use `toData()` for frozen matrix interchange.
- * [composeTransform3](/docs/reference/geometry/composeTransform3) takes matrices in after, before order.
+ * [multiplyTransform3](/docs/reference/math/multiplyTransform3) multiplies left and right matrices;
+ * the right factor acts first on column vectors.
+ *
+ * @param input - XYZ affine value, row-major 4x4 matrix, or frame; copied. Defaults to identity.
  *
  * @example
  * ```ts
  * const placement = transform3().rotate([0, 0, 90]).translate([10, 0, 0]);
  * placement.applyPoint([1, 0, 0]).toData(); // approximately [10, 1, 0]
  * ```
+ *
+ * @example Convert a coordinate frame to an affine value
+ * ```ts
+ * const local = frame3({
+ *   origin: [10, 0, 0],
+ *   xAxis: [0, 1, 0],
+ *   yAxis: [-1, 0, 0],
+ *   zAxis: [0, 0, 1],
+ * });
+ * const placement = transform3(local);
+ * placement.applyPoint([2, 0, 0]).toData(); // [10, 2, 0]
+ * ```
  */
 export declare function transform3(input?: Transform3Input): Transform3;
 
@@ -3920,24 +2511,15 @@ export declare type Transform3Data = readonly [
   m33: number,
 ];
 
-/** 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.
- *
- * A negative result identifies a reflection; zero is rejected as singular.
- *
- * @param transform - Valid affine transform.
- * @returns Signed linear determinant.
- */
-export declare function transformDeterminant3(
-  transform: Transform3Data,
-): number;
+/** An immutable XYZ transform, canonical row-major matrix, or right-handed orthonormal frame. */
+export declare type Transform3Input = Transform3 | Transform3Data | Frame3;
 
 /**
  * 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.
+ *
+ * @param region - Millimetre polygons whose boundaries are normalized before placement.
+ * @param transform - Planar affine placement; reflections preserve winding.
  */
 export declare function transformRegionData(
   region: RegionData,
@@ -3946,260 +2528,12 @@ export declare function transformRegionData(
 ): RegionData;
 
 /**
- * Creates an immutable translation transform.
+ * Triangulates one simple loop into indices of its normalized CCW vertex order.
  *
- * @param offset - Finite XYZ translation in model units.
- * @returns A frozen row-major transform.
- */
-export declare function translationTransform3(
-  offset: Vector3Data,
-): Transform3Data;
-
-/** Trapezoidal thread profile with a configurable included angle. */
-export declare interface TrapezoidalThreadProfileSpec extends ThreadProfileBaseSpec {
-  /** Selects the trapezoidal profile family. */
-  readonly kind: "trapezoidal";
-  /**
-   * Radial depth in millimetres.
-   * @defaultValue `pitch / 2`
-   */
-  readonly depth?: number;
-  /**
-   * 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 includedAngle?: number;
-}
-
-/** A topology-preserving indexed triangle mesh with mutable owned XYZ buffers. */
-export declare interface TriangleMesh {
-  /** Three unsigned vertex indices per triangle. */
-  readonly indices: Uint32Array;
-  /** Flat XYZ coordinates in millimetres. */
-  readonly positions: Float32Array;
-}
-
-/**
- * Measurements and optional edge-connected topology from one validated mesh traversal.
- */
-export declare interface TriangleMeshAnalysis extends TriangleMeshMeasurements {
-  /** Number of surface shells connected by shared indexed edges when includeTopology is requested.
-   * Cavities count separately; shells may be open unless requireClosed is enabled. Coordinates are not welded. */
-  readonly shellCount?: number;
-  /** Number of distinct indexed undirected edges when `includeTopology` is requested. */
-  readonly edgeCount?: number;
-}
-
-/**
- * Validation and optional connectivity controls for a shared mesh analysis.
+ * @param loop - Boundary to normalize; indices address its cleaned CCW order.
  */
-export declare interface TriangleMeshAnalysisOptions extends TriangleMeshValidationOptions {
-  /** Compute indexed edge/shell counts and reject unreferenced vertices; defaults to false. */
-  readonly includeTopology?: boolean;
-}
-
-/** Raw construction buffers or immutable captured geometry accepted by mesh utilities. */
-export declare type TriangleMeshInput = TriangleMesh | ImmutableTriangleMesh;
-
-/**
- * Geometric measurements derived from a validated, non-empty triangle mesh.
- */
-export declare interface TriangleMeshMeasurements {
-  /** Axis-aligned bounds. */
-  readonly bounds: Bounds3Data;
-  /** Signed enclosed volume; positive values correspond to outward winding. */
-  readonly signedVolume: number;
-  /** Sum of all triangle areas in squared model units. */
-  readonly surfaceArea: number;
-  /** Number of indexed triangles. */
-  readonly triangleCount: number;
-  /** Number of distinct entries in the position buffer. */
-  readonly vertexCount: number;
-}
-
-/** Options controlling bounded triangle-mesh quality analysis. */
-export declare interface TriangleMeshQualityOptions {
-  /** Maximum number of triangles inspected. Defaults to `200000`. */
-  readonly maxTriangles?: number;
-  /** Numeric comparison overrides; model coordinates are interpreted in their existing units. */
-  readonly tolerance?: GeometryToleranceOptions;
-}
-
-/** Structural, topological, and planar-patch measurements for one indexed triangle mesh. */
-export declare interface TriangleMeshQualityReport {
-  /** Number of duplicate triangles beyond their first unordered occurrence. */
-  readonly duplicateTriangleCount: number;
-  /** Number of two-face edges whose incident triangles use the same direction. */
-  readonly inconsistentWindingEdgeCount: number;
-  /** Whether the mesh has valid faces and exactly two oppositely wound faces at every edge. */
-  readonly isClosedOrientedManifold: boolean;
-  /** Largest normalized triangle aspect ratio; an equilateral triangle has ratio `1`. */
-  readonly maximumTriangleAspectRatio: number;
-  /** Largest number of triangles incident to one indexed vertex. */
-  readonly maximumVertexTriangleIncidence: number;
-  /** Largest number of distinct neighbours connected to one indexed vertex. */
-  readonly maximumVertexValence: number;
-  /** Smallest interior triangle angle in degrees. */
-  readonly minimumTriangleAngleDegrees: number;
-  /** Number of triangles at or below the scale-aware zero-area threshold. */
-  readonly nearZeroAreaTriangleCount: number;
-  /** Number of edges with more than two incident triangles. */
-  readonly nonManifoldEdgeCount: number;
-  /** Number of edges with exactly one incident triangle. */
-  readonly openEdgeCount: number;
-  /** Edge-connected coplanar patches in deterministic first-triangle order. */
-  readonly planarPatches: readonly PlanarPatchQuality[];
-  /** Signed enclosed volume in cubic model units; positive values indicate outward winding. */
-  readonly signedVolume: number;
-  /** Total triangle area in squared model units. */
-  readonly surfaceArea: number;
-  /** Number of indexed triangles. */
-  readonly triangleCount: number;
-  /** Number of entries in the position buffer. */
-  readonly vertexCount: number;
-}
-
-/** Immutable deterministic measurements for a closed, oriented triangle mesh. */
-export declare interface TriangleMeshSignature {
-  /** Axis-aligned bounds quantized by `tolerances.position`. */
-  readonly bounds: Bounds3Data;
-  /** Number of edge-connected closed boundary shells; cavities count separately. */
-  readonly shellCount: number;
-  /** Total orientable genus across all connected components. */
-  readonly genus: number;
-  /** Order-independent hash of quantized vertices and oriented triangles. */
-  readonly fingerprint: string;
-  /** Signed enclosed volume quantized by `tolerances.signedVolume`. */
-  readonly signedVolume: number;
-  /** Quantization used to make the signature stable across insignificant numeric drift. */
-  readonly tolerances: TriangleMeshSignatureTolerances;
-  /** Number of indexed triangles. */
-  readonly triangleCount: number;
-  /** Number of referenced position-buffer vertices. */
-  readonly vertexCount: number;
-}
-
-/** Options controlling deterministic triangle-mesh regression signatures. */
-export declare interface TriangleMeshSignatureOptions {
-  /** Maximum accepted triangle count. Defaults to 200,000. */
-  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`. */
-  readonly volumeTolerance?: number;
-}
-
-/** Absolute tolerances recorded in a triangle-mesh regression signature. */
-export declare interface TriangleMeshSignatureTolerances {
-  /** Position and bounds quantization in model units. */
-  readonly position: number;
-  /** Signed-volume quantization in cubic model units. */
-  readonly signedVolume: number;
-}
-
-/** Mesh measurements with the indexed surface-shell and edge counts requested by includeTopology. */
-export declare interface TriangleMeshTopologyAnalysis extends TriangleMeshAnalysis {
-  /** Number of surface shells connected by shared indexed edges; cavities count separately. */
-  readonly shellCount: number;
-  /** Number of distinct indexed undirected edges. */
-  readonly edgeCount: number;
-}
-
-/** Options controlling structural and manufacturing validation of a mesh. */
-export declare interface TriangleMeshValidationOptions {
-  /** Permit an empty position and index buffer. Defaults to `false`. */
-  readonly allowEmpty?: boolean;
-  /** Require two oppositely wound faces per edge; geometric self-intersections are not detected. */
-  readonly requireClosed?: boolean;
-  /** Numeric comparison overrides used for zero-area triangle detection. */
-  readonly tolerance?: GeometryToleranceOptions;
-}
-
-/**
- * ISO/UTS-like 60-degree truncated triangular profile.
- */
-export declare interface TriangularThreadProfileSpec extends ThreadProfileBaseSpec {
-  /** Selects the 60-degree triangular profile family. */
-  readonly kind: "triangular";
-  /**
-   * Crest width divided by pitch.
-   * @defaultValue `1 / 8`
-   */
-  readonly crestFlatRatio?: number;
-  /**
-   * Root width divided by pitch.
-   * @defaultValue `1 / 4`
-   */
-  readonly rootFlatRatio?: number;
-}
-
-/** Ear-clips one normalized simple CCW loop into stable local vertex indices. */
 export declare function triangulateContour(loop: Contour): Uint32Array;
 
-/**
- * Dimensions, placement, and tessellation for a hollow Z-axis tube.
- */
-export declare type TubeOptions = CircularPrimitiveOptions &
-  PrimitiveAttachment & {
-    /**
-     * Centers the tube on the Z origin when `true`; otherwise its bottom is at `Z = 0`.
-     * @defaultValue `true`
-     */
-    readonly center?: boolean;
-    /** Total height along Z in millimetres. */
-    readonly height: number;
-    /** Inner nominal dimension meets polygon vertices or faces; defaults to vertex. */
-    readonly innerSizing?: RadialSizing;
-    /** Outer nominal dimension meets polygon vertices or faces; defaults to vertex. */
-    readonly outerSizing?: RadialSizing;
-  } & (
-    | {
-        /** Positive nominal inner radius in millimetres. */
-        readonly innerRadius: number;
-        /** Nominal outer radius in millimetres, greater than innerRadius. */
-        readonly outerRadius: number;
-        /** Diameter dimensions cannot be combined with radius dimensions. */
-        readonly innerDiameter?: never;
-        /** Diameter dimensions cannot be combined with radius dimensions. */
-        readonly outerDiameter?: never;
-      }
-    | {
-        /** Positive nominal inner diameter in millimetres. */
-        readonly innerDiameter: number;
-        /** Nominal outer diameter in millimetres, greater than innerDiameter. */
-        readonly outerDiameter: number;
-        /** Radius dimensions cannot be combined with diameter dimensions. */
-        readonly innerRadius?: never;
-        /** Radius dimensions cannot be combined with diameter dimensions. */
-        readonly outerRadius?: never;
-      }
-  );
-
-/**
- * Validates a proper rigid transform: finite translation and a right-handed orthonormal rotation.
- * Scale, shear, reflection, and perspective are rejected within the default angular tolerance.
- * Returns the original row-major 4x4 matrix without copying or normalizing it.
- *
- * @throws {@link GeometryError} For a malformed, non-finite, or non-rigid matrix.
- */
-export declare function validateRigidTransform3(
-  transform: Transform3Data,
-): Transform3Data;
-
-/**
- * Validates that a transform is finite, affine, and non-singular.
- *
- * @param transform - Row-major matrix to validate.
- * @param tolerance - Optional comparison overrides.
- * @returns The original transform after successful validation.
- * @throws {@link GeometryError} For non-finite, non-affine, or singular matrices.
- */
-export declare function validateTransform3(
-  transform: Transform3Data,
-  tolerance?: GeometryToleranceOptions,
-): Transform3Data;
-
 /** Immutable XY arithmetic; vector operations return new values and measurements return numbers. */
 export declare interface Vector2 {
   /** X coordinate in the vector's coordinate units. */
@@ -4236,7 +2570,9 @@ export declare interface Vector2 {
  * 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.
+ * [normalize2](/docs/reference/math/normalize2) for tuple-based normalization in numerical loops.
+ *
+ * @param input - Finite XY tuple or vector; coordinates are copied without changing their units.
  */
 export declare function vector2(input: Vector2Input): Vector2;
 
@@ -4268,6 +2604,8 @@ export declare interface Vector3 {
   dot(other: Vector3Input): number;
   /** Returns the right-handed cross product as a new vector. */
   cross(other: Vector3Input): Vector3;
+  /** Projects onto the plane through the origin; finite nonzero normals are normalized first. */
+  projectOntoPlane(normal: Vector3Input): Vector3;
   /** Returns Euclidean length in the vector's coordinate units. */
   length(): number;
   /** Returns Euclidean distance to another vector in the same coordinate units. */
@@ -4284,10 +2622,14 @@ export declare interface Vector3 {
  * 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.
+ * [normalize3](/docs/reference/math/normalize3) for tuple-based normalization in numerical loops.
+ *
+ * @param input - Finite XYZ tuple or vector; coordinates are copied without changing their units.
  *
  * @example
  * ```ts
+ * import { vector3 } from "@metamesh/modeling/geometry";
+ *
  * const direction = vector3([1, 2, 3]).add([4, 0, 0]).normalize().scale(10);
  * const alignment = direction.dot([0, 0, 1]);
  * ```
@@ -4300,21 +2642,7 @@ 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 {
-  /** Selects a circular baseline; glyph outlines rotate without bending or stretching. */
-  readonly kind: "arc";
-  /** 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 centerAngle?: number;
-  /** Reading direction around the circle; defaults to clockwise. */
-  readonly direction?: "clockwise" | "counterclockwise";
-}
-
-/**
- * Immutable vector layout with no browser, font parser, or kernel ownership.
- */
+/** Immutable vector layout with no browser, font parser, or kernel ownership. */
 export declare interface VectorTextLayout {
   /** Nonzero-filled path data in millimetres, positive Y upward; empty for text with no ink. */
   readonly paths: readonly string[];
@@ -4322,20 +2650,6 @@ export declare interface VectorTextLayout {
   readonly metrics: VectorTextMetrics;
 }
 
-/**
- * Text bounded to 512 UTF-16 units: horizontal lines or one circular line without wrapping.
- */
-export declare interface VectorTextLayoutOptions extends VectorTextOptions {
-  /** Place the advance's start, midpoint or end at the datum; defaults to center on arcs, otherwise left. */
-  readonly align?: "left" | "center" | "right";
-  /** Omitted uses horizontal lines. Arcs require one line and baseline vertical alignment. */
-  readonly baseline?: VectorTextArcBaseline;
-  /** Baseline spacing in ems, 0.5–5; omitted uses the selected face's natural vertical metrics. */
-  readonly lineHeight?: number;
-  /** Place the first baseline or complete ink bounds at Y=0; arcs only accept baseline. */
-  readonly verticalAlign?: "baseline" | "top" | "center" | "bottom";
-}
-
 /** 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. */
@@ -4346,7 +2660,7 @@ export declare interface VectorTextMetrics {
   readonly logicalWidth: number;
   /** Selected font's ascender distance above a baseline in millimetres, independent of the text. */
   readonly ascent: number;
-  /** Selected font's descender distance below a baseline in millimetres, a non-negative value. */
+  /** Selected font's descender distance below a baseline in millimetres, a nonnegative value. */
   readonly descent: number;
   /** Actual distance between baselines in millimetres. */
   readonly lineHeight: number;
@@ -4354,14 +2668,4 @@ export declare interface VectorTextMetrics {
   readonly lineCount: number;
 }
 
-/** Shaping controls for a prepared exact font face; all lengths are in millimetres. */
-export declare interface VectorTextOptions {
-  /** Em size in millimetres, greater than zero and at most 10000; not the visible glyph height. */
-  readonly fontSize: number;
-  /** Actual static or variable weight, 1–1000; defaults to the prepared face's static weight. */
-  readonly fontWeight?: number;
-  /** Tracking between glyph clusters in millimetres, -100–100; defaults to zero. */
-  readonly letterSpacing?: number;
-}
-
 export {};