@metamesh/modeling 0.7.0 → 0.9.0

package/dist/api/geometry.d.ts

@@ -425,6 +425,17 @@ export declare interface ArcCurve3 {
   */
  export declare const computeParallelTransportFrames: (path: readonly Vec3[], initialNormal?: Vec3, normalGuide?: PathNormalGuide, limits?: Partial<GeometrySamplingLimits>) => readonly PathFrame[];
 
+ /**
+  * Computes the uniform-density volume centroid of an oriented closed solid, including cavity shells.
+  * Coordinates are millimetres. Indexed closure and positive aggregate volume are required; callers
+  * may use validateSolidMesh first when geometric intersections and shell orientation are untrusted.
+  * Fresh mutable input is inspected on every call, and buffers are never changed.
+  *
+  * @param mesh - Consistently oriented closed mesh with positive enclosed volume.
+  * @returns A fresh immutable XYZ volume centroid.
+  */
+ export declare function computeTriangleMeshCentroid(mesh: TriangleMesh): Vec3;
+
  /** One sampled component retaining contour identities and logical point correspondence. */
  export declare interface CorrespondingComponent {
      /** Stable canonical lowercase identity; unique within the containing topology or output. */
@@ -509,6 +520,39 @@ export declare interface ArcCurve3 {
     */
    export declare const cross3: (a: Vec3, b: Vec3) => Vec3;
 
+   /** One explicitly closed planar contour, independent of editor metadata and parameter contracts. */
+   export declare interface CrossSectionCurve {
+       /** Initial anchor; coordinates may be any finite value. */
+       readonly start: CrossSectionPoint;
+       /** Ordered chain of 2–32 segments; the final end must exactly match start. */
+       readonly segments: readonly CrossSectionSegment[];
+   }
+
+   /** Planar X and upward Y in millimetres, or in units converted by sampling scales. */
+   export declare interface CrossSectionPoint {
+       /** Horizontal coordinate; physical scaling does not center the contour. */
+       readonly x: number;
+       /** Upward planar coordinate. */
+       readonly y: number;
+   }
+
+   /** Straight or cubic Bézier segment in one closed planar contour. */
+   export declare type CrossSectionSegment = {
+       /** Straight segment discriminator. */
+       readonly type: "line";
+       /** Next anchor; the final anchor repeats the curve start. */
+       readonly end: CrossSectionPoint;
+   } | {
+       /** Cubic Bézier segment discriminator. */
+       readonly type: "cubic";
+       /** Outgoing control from the previous anchor. */
+       readonly control1: CrossSectionPoint;
+       /** Incoming control at the next anchor. */
+       readonly control2: CrossSectionPoint;
+       /** Next anchor; the final anchor repeats the curve start. */
+       readonly end: CrossSectionPoint;
+   };
+
    /** 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. */
@@ -983,9 +1027,10 @@ export declare interface ArcCurve3 {
      export declare function getMetricFastenerStandard(size: MetricFastenerSize): MetricFastenerStandard;
 
      /**
-      * Builds a closed indexed solid from a regularly sampled top, matched boundary walls, and flat base.
-      * Heights are evaluated once per grid point after allocation preflight. Physical XY sizes and all
-      * output coordinates must fit Float32 storage. Shared wall vertices prevent cracks at the base.
+      * Builds a closed indexed mesh from a rectilinear top, matched boundary walls, and flat base.
+      * Heights run once per grid point after preflight; center-error adds one evaluation per cell.
+      * Top winding is +Z, the base is -Z, and sides face outward. Coordinates and heights must fit
+      * Float32 storage. Explicit axes are captured before sampling; shared wall vertices prevent cracks.
       *
       * @example Sample a closed wavy mesh
       * ```ts
@@ -1000,23 +1045,58 @@ export declare interface ArcCurve3 {
      /** Trusted output ceilings for pure construction; omitted fields use engine defaults. */
      export declare type HeightfieldMeshLimits = Partial<Pick<ModelingLimits, "maxVertices" | "maxTriangles" | "maxBytes">>;
 
-     /** A regularly sampled, closed heightfield above a flat base, in millimetres. */
-     export declare interface HeightfieldOptions {
-         /** Positive XY footprint. */
-         readonly size: Vec2;
-         /** Exact positive integer X/Y interval counts. */
-         readonly segments: readonly [x: number, y: number];
+     /**
+      * 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: Vec2) => 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: Vec2;
+         /** 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?: Vec2;
-     }
-
-     /** Predictable regular-grid allocation facts; this does not evaluate the height callback. */
+         /** 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;
+     });
+
+     /** Predictable rectilinear-grid allocation facts; this does not evaluate the height callback. */
      export declare interface HeightfieldPreflight {
-         /** Number of grid points and height callback evaluations. */
+         /** Number of top grid points; center-error also evaluates one height per cell. */
          readonly sampleCount: number;
          /** Number of allocated XYZ vertices. */
          readonly vertexCount: number;
@@ -1591,7 +1671,7 @@ export declare interface ArcCurve3 {
           readonly closed?: boolean;
       }
 
-      /** Checks regular-grid dimensions and bounds allocation before evaluating any height samples. */
+      /** Checks grid dimensions, coordinate precision, and allocation bounds before evaluating heights. */
       export declare function preflightHeightfield(options: HeightfieldOptions, limits?: HeightfieldMeshLimits): HeightfieldPreflight;
 
       /**
@@ -2148,989 +2228,1068 @@ export declare interface ArcCurve3 {
               readonly radius: number;
           }
 
-          /** Samples a planar curve with the same guarantees and policy as spatial sampling.
-           * @remarks Private spatial scratch math is shared, while only final planar vectors are copied and
-           * frozen. At stationary tangents, outgoing secants are preferred and endpoints use a backward fallback.
-           * @example
-           * ```ts
-           * const turn = sampleCurve2({kind: "arc", center: [0,0], radius: 10, sweepDegrees: 90});
-           * ```
-           */
-          export declare function sampleCurve2(curve: Curve2, options?: CurveSamplingOptions): SampledCurve2;
-
-          /**
-           * Samples a spatial curve, preserving endpoints and directed unit tangents.
-           * @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
-           * ```ts
-           * const path = sampleCurve3({kind: "cubic", start: [0,0,0], control1: [5,0,0], control2: [5,5,5], end: [10,5,5]});
-           * ```
-           */
-          export declare function sampleCurve3(curve: Curve3, 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): Loop2;
-
-          /** Immutable planar points and corresponding directed unit tangents. */
-          export declare interface SampledCurve2 {
-              /** Curves retain both endpoints, including full-circle seams; closed resampling omits its seam. */
-              readonly points: readonly Vec2[];
-              /** Directed unit vectors; stationary derivatives use the nearest usable direction. */
-              readonly tangents: readonly Vec2[];
-          }
-
-          /**
-           * 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 Vec3[];
-              /** Directed unit vectors; stationary derivatives use the nearest usable direction. */
-              readonly tangents: readonly Vec3[];
-          }
-
-          /** 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 Path3[];
-              /** 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.
-           * Integrated weights must remain finite. The maxPathPoints ceiling defaults to 100000; excessive
-           * exact counts reject before evaluating axial weights or allocating sample arrays.
-           */
-          export declare const sampleHelix: ({ turns, radius, height, segments, limits, axialWeight, }: SampleHelixOptions) => readonly Vec3[];
-
-          /** Options for a sampled +Z helix with millimetre dimensions. */
-          export declare interface SampleHelixOptions {
-              /** Number of complete rotations around +Z. */
-              readonly turns: number;
-              /** Explicit output allocation ceilings. */
-              readonly limits?: Partial<GeometrySamplingLimits>;
-              /** Constant radial distance from the +Z axis. */
-              readonly radius: number;
-              /** Total axial advance from the first point to the last. */
-              readonly height: number;
-              /** Number of sampled line segments; the result contains one additional endpoint. */
-              readonly segments: number;
-              /**
-               * Relative axial advance at a normalized turn position. Values are integrated
-               * and normalized, so the final endpoint is always exactly `height`.
-               */
-              readonly axialWeight?: (t: number) => number;
-          }
-
           /**
-           * Samples the center opening and tooth spaces used to subtract an internal ring gear.
+           * Samples 2–32 connected line/cubic segments into a simple, nonzero-area, immutable CCW XY loop.
+           * Physical scaling precedes adaptive curve sampling; the final end must repeat start exactly.
+           * Shared anchors and the closing seam are emitted once. Winding normalization may change the
+           * starting vertex. The sampled loop is checked for self-intersection and degeneracy by
+           * `normalizeLoop2`; 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.
            *
-           * 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): Loop2;
-
-          /**
-           * Samples 1–31 line/cubic segments into a deeply immutable open [radius,height] polyline.
-           * Anchors must progress strictly upward; nonnegative-radius cubic controls must have ordered
-           * heights between their endpoints. Cubics use de Casteljau subdivision with a conservative
-           * control-hull chord-error bound. Lines also obey the optional physical edge-length ceiling.
-           * 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 4096 vertices.
-           * @returns Frozen open polyline in millimetres, ordered from lowest to highest anchor.
-           * @throws {@link GeometryError} for invalid coordinates, order, scale, or exceeded subdivision budget.
+           * @param curve - Closed contour in millimetres unless positive scales convert its coordinates.
+           * @param options - Physical resolution and unique vertex budget; defaults to 4096 vertices.
+           * @returns Frozen counterclockwise loop in millimetres, without a repeated seam endpoint.
+           * @throws {@link GeometryError} for invalid data, topology, scale, or exceeded sampling budgets.
                *
                * @example
                * ```ts
-               * const side = sampleOpenProfile({
-               *   start: { radius: 0.5, height: 0 },
-               *   segments: [{ type: "line", end: { radius: 1, height: 1 } }],
-               * }, { radiusScale: 12, heightScale: 30 });
+               * const section = sampleCrossSection({
+               *   start: { x: 0, y: 0 },
+               *   segments: [
+               *     { type: "line", end: { x: 1, y: 0 } },
+               *     { type: "line", end: { x: 0.5, y: 1 } },
+               *     { type: "line", end: { x: 0, y: 0 } },
+               *   ],
+               * }, { widthScale: 20, heightScale: 12 });
                * ```
                */
-           export declare function sampleOpenProfile(curve: OpenProfileCurve, options?: SampleOpenProfileOptions): readonly Vec2[];
+           export declare function sampleCrossSection(curve: CrossSectionCurve, options?: SampleCrossSectionOptions): Loop2;
 
-           /** Physical scaling and bounded adaptive subdivision for an open profile. */
-           export declare interface SampleOpenProfileOptions {
-               /** Positive radius scale; use the desired maximum radius for normalized coordinates. Defaults to 1. */
-               readonly radiusScale?: number;
-               /** Positive height scale; use the desired total height for normalized coordinates. Defaults to 1. */
+           /** Physical scaling, subdivision policy, and output ceilings for one closed contour. */
+           export declare interface SampleCrossSectionOptions {
+               /** Positive horizontal scale; normalized inputs span this width envelope. Defaults to 1. */
+               readonly widthScale?: number;
+               /** Positive vertical scale; normalized inputs span this height envelope. Defaults to 1. */
                readonly heightScale?: number;
-               /** Shared physical policy, evaluated after scaling; exact circular counts do not affect curves. */
+               /** Physical policy evaluated after scaling, using the shared curve sampler. */
                readonly resolution?: GeometryResolution;
-               /** Maximum output vertex count within maxProfilePoints. Defaults to the smaller of 4096 and that ceiling. */
+               /** Unique output vertex ceiling, at least three, within maxProfilePoints. Defaults to min(4096, maxProfilePoints). */
                readonly maximumVertices?: number;
-               /** Explicit profile and circular allocation ceilings. */
+               /** Selected profile and per-segment path ceilings; omitted values use package defaults. */
                readonly limits?: Partial<GeometrySamplingLimits>;
            }
 
-           /**
-            * 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>): Path2;
-
-           /**
-            * Samples a prepared text layout without shaping text again or loading a font.
-            *
-            * @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.
-            * @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.
-            */
-           export declare function sampleTextContours(layout: VectorTextLayout, resolution?: GeometryResolution, limits?: Partial<GeometrySamplingLimits>): readonly Loop2[];
-
-           /**
-            * Samples evenly phased thread helices with finite `lead = pitch * starts`.
-            * All starts together respect maxPathPoints (default 100000); excessive counts fail before allocation.
+           /** Samples a planar curve with the same guarantees and policy as spatial sampling.
+            * @remarks Private spatial scratch math is shared, while only final planar vectors are copied and
+            * frozen. At stationary tangents, outgoing secants are preferred and endpoints use a backward fallback.
+            * @example
+            * ```ts
+            * const turn = sampleCurve2({kind: "arc", center: [0,0], radius: 10, sweepDegrees: 90});
+            * ```
             */
-           export declare function sampleThreadHelices(options: ThreadHelixOptions): SampledThreadHelices;
+           export declare function sampleCurve2(curve: Curve2, options?: CurveSamplingOptions): SampledCurve2;
 
            /**
-            * Multiplies a vector by a dimensionless scalar.
+            * Samples a spatial curve, preserving endpoints and directed unit tangents.
+            * @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
             * ```ts
-            * scale3([1, 2, 3], 2); // [2, 4, 6]
+            * const path = sampleCurve3({kind: "cubic", start: [0,0,0], control1: [5,0,0], control2: [5,5,5], end: [10,5,5]});
             * ```
             */
-           export declare const scale3: (vector: Vec3, scale: number) => Vec3;
+           export declare function sampleCurve3(curve: Curve3, options?: CurveSamplingOptions): SampledCurve3;
 
            /**
-            * Creates an immutable axis-aligned scale transform.
-            *
-            * Negative components are reflections. Zero components are rejected because
-            * they collapse volume and cannot be inverted.
+            * Samples a complete external involute gear boundary in the XY plane.
             *
-            * @param factors - Finite, non-zero XYZ scale factors.
-            * @returns A frozen row-major transform.
+            * 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 scaleTransform3(factors: Vec3): Transform3;
-
-           /** Returns the signed area of a non-duplicated loop; positive means CCW. */
-           export declare function signedAreaLoop2(loop: Loop2): number;
-
-           /** A cubic corner transition with zero curvature at its straight tangent joins. */
-           export declare interface SmoothEdgeTreatment {
-               /** Selects continuous-curvature cubic rounding, rather than a circular radius. */
-               readonly kind: "smooth";
-               /** Positive tangent setbacks, equal or [first, second], in millimetres. */
-               readonly distance: number | readonly [first: number, second: number];
-               /** Exact cubic interval count, positive; overrides physical sampling. */
-               readonly segments?: number;
-               /** Physical chord/edge-length sampling; circularSegments does not describe a cubic. */
-               readonly resolution?: GeometryResolution;
-               /** Explicit sampling ceilings, bounded by the host policy. */
-               readonly limits?: Partial<GeometrySamplingLimits>;
-           }
+           export declare function sampleCylindricalGearOutline(spec: CylindricalGearSpec, options?: CylindricalGearOutlineOptions): Loop2;
 
-           /**
-            * Exactly one radius or diameter, placement, and tessellation for an origin-centered sphere.
-            */
-           export declare type SphereOptions = CircularPrimitiveOptions & PrimitivePlacement & ({
-               /** 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;
-           });
-
-           /** 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;
+           /** Immutable planar points and corresponding directed unit tangents. */
+           export declare interface SampledCurve2 {
+               /** Curves retain both endpoints, including full-circle seams; closed resampling omits its seam. */
+               readonly points: readonly Vec2[];
+               /** Directed unit vectors; stationary derivatives use the nearest usable direction. */
+               readonly tangents: readonly Vec2[];
            }
 
            /**
-            * Creates a centered CCW alternating-radius star within the selected profile sampling ceiling.
-            *
-            * @example Five-point outline
-            * ```ts
-            * starLoop(12, 5, 6);
-            * ```
-            */
-           export declare const starLoop: (outerRadius: number, points: number, innerRadius?: number, limits?: Partial<GeometrySamplingLimits>) => readonly Vec2[];
-
-           /** End-cap treatment for an open stroked path. */
-           export declare type StrokePathCap = "butt" | "round" | "square";
-
-           /** Join treatment where adjacent stroked path segments meet. */
-           export declare type StrokePathJoin = "bevel" | "miter" | "round";
-
-           /**
-            * Converts a sampled millimetre path into the filled region covered by a centered stroke.
-            *
-            * Closed paths omit a duplicated seam point. Zero-length sampled segments are ignored, while the
-            * effective path must still contain visible length. Round caps and joins use deterministic physical
-            * resolution. Bevels fill the outer corner triangle; miters extend the outer edges to their
-            * intersection, falling back to bevels above SVG's default miter limit of 4.
+            * Immutable spatial points and corresponding directed unit tangents.
             */
-           export declare function strokePathRegion(path: Path2, options: StrokePathRegionOptions): Region2;
+           export declare interface SampledCurve3 {
+               /** Curves retain both endpoints, including full-circle seams; closed resampling omits its seam. */
+               readonly points: readonly Vec3[];
+               /** Directed unit vectors; stationary derivatives use the nearest usable direction. */
+               readonly tangents: readonly Vec3[];
+           }
 
-           /** Physical stroke and topology controls for {@link strokePathRegion}. */
-           export declare interface StrokePathRegionOptions {
-               /** Explicit path, circular and expanded-profile allocation ceilings. */
-               readonly limits?: Partial<GeometrySamplingLimits>;
-               /** Treat the path as a closed non-duplicated loop. Default: `false`. */
-               readonly closed?: boolean;
-               /** End-cap treatment for an open path. Ignored for closed paths. Default: `butt`. */
-               readonly cap?: StrokePathCap;
-               /** Corner treatment; miters exceeding SVG's default limit of 4 become bevels. Default: `miter`. */
-               readonly join?: StrokePathJoin;
-               /** Physical tessellation policy for round caps and joins. */
-               readonly resolution?: GeometryResolution;
-               /** Positive total stroke width in millimetres, centered on the sampled path. */
-               readonly width: number;
+           /** 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 Path3[];
+               /** Adjacent axial thread spacing in millimetres. */
+               readonly pitch: number;
+               /** Number of revolutions represented by each path. */
+               readonly turns: number;
            }
 
            /**
-            * Subtracts `b` from `a`.
-            * @example
-            * ```ts
-            * subtract3([4, 5, 6], [1, 2, 3]); // [3, 3, 3]
-            * ```
+            * Creates `segments + 1` points including exact helix endpoints from finite positive dimensions.
+            * Integrated weights must remain finite. The maxPathPoints ceiling defaults to 100000; excessive
+            * exact counts reject before evaluating axial weights or allocating sample arrays.
             */
-           export declare const subtract3: (a: Vec3, b: Vec3) => Vec3;
+           export declare const sampleHelix: ({ turns, radius, height, segments, limits, axialWeight, }: SampleHelixOptions) => readonly Vec3[];
 
-           /** Sampling controls for deterministic SVG-to-region conversion. */
-           export declare interface SvgImportOptions {
-               /** Explicit profile and circular allocation ceilings; bounded SVG source/work limits remain fixed. */
+           /** Options for a sampled +Z helix with millimetre dimensions. */
+           export declare interface SampleHelixOptions {
+               /** Number of complete rotations around +Z. */
+               readonly turns: number;
+               /** Explicit output allocation ceilings. */
                readonly limits?: Partial<GeometrySamplingLimits>;
-               /** Exact segments for a complete ellipse or round stroke feature. */
-               readonly circularSegments?: number;
-               /** Operation-level physical tessellation policy over the active model-wide policy. */
-               readonly resolution?: GeometryResolution;
+               /** Constant radial distance from the +Z axis. */
+               readonly radius: number;
+               /** Total axial advance from the first point to the last. */
+               readonly height: number;
+               /** Number of sampled line segments; the result contains one additional endpoint. */
+               readonly segments: number;
                /**
-                * `"center"` places the viewport center at the origin. `"document"` places its converted
-                * lower-left corner at the origin. Default: `"center"`.
+                * Relative axial advance at a normalized turn position. Values are integrated
+                * and normalized, so the final endpoint is always exactly `height`.
                 */
-               readonly origin?: "center" | "document";
-           }
-
-           /** Exact normalized SVG region plus bounded source, geometry, and safe-repair diagnostics. */
-           export declare interface SvgRegionPreflight {
-               /** Physical and final-topology measurements of `region`. */
-               readonly geometry: SvgRegionPreflightGeometryMetrics;
-               /** Appearance-preserving cleanup observed during parsing and normalization. */
-               readonly repairs: SvgRegionPreflightRepairs;
-               /** Canonical millimetre, Y-up geometry. */
-               readonly region: Region2;
-               /** Bounded source and flattening complexity measurements. */
-               readonly source: SvgRegionPreflightSourceMetrics;
-           }
-
-           /** Physical and final-topology facts for a normalized imported SVG region. */
-           export declare interface SvgRegionPreflightGeometryMetrics {
-               /** Filled area in square millimetres. */
-               readonly area: number;
-               /** Millimetre bounds, or `null` when no painted region remains. */
-               readonly bounds: Bounds2 | null;
-               /** Disconnected filled polygons in the final region. */
-               readonly components: number;
-               /** Exterior and hole boundary count in the final region. */
-               readonly contours: number;
-               /** Interior boundary count in the final region. */
-               readonly holes: number;
-               /** Shortest final boundary edge in millimetres, or `null` for an empty region. */
-               readonly minEdgeLength: number | null;
-               /** Final boundary edges shorter than the conservative 0.01 mm indicator. */
-               readonly shortEdges: number;
-               /** Components with less than 0.01 square millimetres of filled area. */
-               readonly tinyIslands: number;
-               /** Non-duplicated boundary vertices in the final normalized region. */
-               readonly vertices: number;
-           }
-
-           /** Visible, appearance-preserving cleanup counters from bounded SVG import. */
-           export declare interface SvgRegionPreflightRepairs {
-               /** Graphics elements with neither a visible fill nor a positive-width visible stroke. */
-               readonly invisibleElements: number;
-               /** Open filled subpaths closed by SVG fill semantics without closing their strokes. */
-               readonly implicitFilledClosures: number;
-               /** Visibly painted elements whose fill and stroke both resolved to empty geometry. */
-               readonly emptyElements: number;
-               /** Consecutive repeated flattened vertices discarded before topology resolution. */
-               readonly removedDuplicateVertices: number;
-               /** Explicit repeated seam vertices removed from otherwise closed contours. */
-               readonly removedSeamVertices: number;
-           }
-
-           /** Bounded source-complexity facts collected while parsing one SVG document. */
-           export declare interface SvgRegionPreflightSourceMetrics {
-               /** UTF-8 source size, capped at 256 KiB before parsing. */
-               readonly bytes: number;
-               /** Renderable shape elements, capped at 500; containers and metadata are excluded. */
-               readonly elements: number;
-               /** Flattened vertices emitted before fill, stroke, and clipping operations. */
-               readonly emittedVertices: number;
-               /** Path endpoints and control vertices parsed before adaptive flattening. */
-               readonly parsedVertices: number;
+               readonly axialWeight?: (t: number) => number;
            }
 
            /**
-            * Sweeps one explicitly ordered point loop, with caps or a geometrically matching closed seam.
+            * Samples the center opening and tooth spaces used to subtract an internal ring gear.
             *
-            * @example Sweep point data along a bent path
-            * ```ts
-            * const profile = rectangleLoop({ size: [6, 3] });
-            * sweepMesh(profile, [[0, 0, 0], [0, 0, 15], [10, 0, 25]], {
-            *   orientation: { kind: "transport", initialNormal: [0, 1, 0] },
-            * });
-            * ```
+            * 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 sweepMesh(profile: Loop2, path: readonly Vec3[], options?: SweepOptions): TriangleMesh;
+           export declare function sampleInternalCylindricalGearSpaceOutline(spec: CylindricalGearSpec, options?: CylindricalGearOutlineOptions): Loop2;
 
            /**
-            * Controls shared by pure mesh construction and filled modeling sweeps.
-            */
-           export declare interface SweepOptions {
-               /** Join the path's last station to its first. Open paths retain watertight end caps. */
-               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 twistDegrees?: 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 | Vec2 | readonly Vec2[];
-               /** 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?: Vec3;
-           } | {
-               /** 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: Vec3;
-           } | {
-               /** 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";
-           };
-
-           /** End bevel controls shared by threaded rods and cutters. */
-           export declare interface ThreadBevelOptions {
-               /** Apply a 45-degree bevel at Z=0. */
-               readonly bevelBottom?: boolean;
-               /**
-                * Axial bevel extent in millimetres. Active blunt ends default to one sixth of the compensated
-                * male minor radius or female major radius; other ends default to the profile depth.
-                */
-               readonly bevelSize?: number;
-               /** Apply a 45-degree bevel at Z=length. */
-               readonly bevelTop?: boolean;
-           }
-
-           /** 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`.
+            * Samples 1–31 line/cubic segments into a deeply immutable open [radius,height] polyline.
+            * Anchors must progress strictly upward; nonnegative-radius cubic controls must have ordered
+            * heights between their endpoints. Cubics use de Casteljau subdivision with a conservative
+            * control-hull chord-error bound. Lines also obey the optional physical edge-length ceiling.
+            * 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 4096 vertices.
+            * @returns Frozen open polyline in millimetres, ordered from lowest to highest anchor.
+            * @throws {@link GeometryError} for invalid coordinates, order, scale, or exceeded subdivision budget.
+                *
+                * @example
+                * ```ts
+                * const side = sampleOpenProfile({
+                *   start: { radius: 0.5, height: 0 },
+                *   segments: [{ type: "line", end: { radius: 1, height: 1 } }],
+                * }, { radiusScale: 12, heightScale: 30 });
+                * ```
                 */
-               readonly maximumRadialOutset?: 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;
-           }
-
-           /** Nut-edge bevel selection. */
-           export declare type ThreadedNutBevel = "automatic" | "both" | "inside" | "none" | "outside";
-
-           /**
-            * Options for a compensated nut with an internal thread.
-            */
-           export declare interface ThreadedNutOptions extends Omit<InternalThreadCutterOptions, "bevelBottom" | "bevelSize" | "bevelTop" | "length"> {
-               /** Nut body bevel selection. Default: `automatic`. */
-               readonly bevel?: ThreadedNutBevel;
-               /** Optional physical policy for a round body, independent of the thread's matched facet grid. */
-               readonly bodyResolution?: GeometryResolution;
-               /** 45-degree body chamfer extent. Default: `min(profile.depth, thickness/4)`. */
-               readonly chamferSize?: number;
-               /** Leave the bottom outside edge flat for build-plate adhesion. Default: `false`. */
-               readonly flushBuildPlateBottom?: boolean;
-               /** 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;
-           }
+            export declare function sampleOpenProfile(curve: OpenProfileCurve, options?: SampleOpenProfileOptions): readonly Vec2[];
+
+            /** Physical scaling and bounded adaptive subdivision for an open profile. */
+            export declare interface SampleOpenProfileOptions {
+                /** Positive radius scale; use the desired maximum radius for normalized coordinates. Defaults to 1. */
+                readonly radiusScale?: number;
+                /** Positive height scale; use the desired total height for normalized coordinates. Defaults to 1. */
+                readonly heightScale?: number;
+                /** Shared physical policy, evaluated after scaling; exact circular counts do not affect curves. */
+                readonly resolution?: GeometryResolution;
+                /** Maximum output vertex count within maxProfilePoints. Defaults to the smaller of 4096 and that ceiling. */
+                readonly maximumVertices?: number;
+                /** Explicit profile and circular allocation ceilings. */
+                readonly limits?: Partial<GeometrySamplingLimits>;
+            }
 
-           /** Allocation-free body, cutter, and end-face facts resolved for a threaded nut. */
-           export declare interface ThreadedNutPreflight {
-               /** Polygon segment count used by the nut body. */
-               readonly bodySegments: number;
-               /** Shared 45-degree chamfer size applied to the selected body and cutter edges. */
-               readonly chamferSize: 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 facts for the exact extended internal-thread cutter mesh. */
-               readonly thread: HelicalThreadSolidMeshPreflight;
-               /** Start-aligned circular facet count used by the compensated thread cutter. */
-               readonly threadCircularSegments: number;
-           }
+            /**
+             * 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>): Path2;
 
-           /**
-            * Supported printable nut body shapes.
-            */
-           export declare type ThreadedNutShape = "hex" | "round" | "square";
+            /**
+             * Samples a prepared text layout without shaping text again or loading a font.
+             *
+             * @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.
+             * @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.
+             */
+            export declare function sampleTextContours(layout: VectorTextLayout, resolution?: GeometryResolution, limits?: Partial<GeometrySamplingLimits>): readonly Loop2[];
 
-           /**
-            * Options for a compensated external threaded rod along +Z.
-            */
-           export declare interface ThreadedRodOptions extends Omit<HelicalThreadRidgeMeshOptions, "majorDiameter">, ThreadBevelOptions {
-               /** Printable fit or caller-calibrated allowances. Default: `normal`. */
-               readonly fit?: PrintableThreadFit | PrintableThreadFitPolicy;
-               /** Nominal major diameter before male compensation. */
-               readonly nominalMajorDiameter: number;
-           }
+            /**
+             * 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;
 
-           /** End shape of a generated helical ridge. */
-           export declare type ThreadEndStyle = "blunt" | "standard" | "tapered";
+            /**
+             * Multiplies a vector by a dimensionless scalar.
+             * @example
+             * ```ts
+             * scale3([1, 2, 3], 2); // [2, 4, 6]
+             * ```
+             */
+            export declare const scale3: (vector: Vec3, scale: number) => Vec3;
 
-           /** 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;
-           }
+            /**
+             * 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: Vec3): Transform3;
+
+            /** Returns the signed area of a non-duplicated loop; positive means CCW. */
+            export declare function signedAreaLoop2(loop: Loop2): number;
+
+            /** A cubic corner transition with zero curvature at its straight tangent joins. */
+            export declare interface SmoothEdgeTreatment {
+                /** Selects continuous-curvature cubic rounding, rather than a circular radius. */
+                readonly kind: "smooth";
+                /** Positive tangent setbacks, equal or [first, second], in millimetres. */
+                readonly distance: number | readonly [first: number, second: number];
+                /** Exact cubic interval count, positive; overrides physical sampling. */
+                readonly segments?: number;
+                /** Physical chord/edge-length sampling; circularSegments does not describe a cubic. */
+                readonly resolution?: GeometryResolution;
+                /** Explicit sampling ceilings, bounded by the host policy. */
+                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 maximumTests?: number;
+                /** Distance comparison policy in millimetres; near contacts reject conservatively. */
+                readonly tolerance?: GeometryToleranceOptions;
+            }
 
-           /**
-            * Direction in which a conventional helical thread advances around +Z.
-            */
-           export declare type ThreadHandedness = "left" | "right";
+            /**
+             * Exactly one radius or diameter, placement, and tessellation for an origin-centered sphere.
+             */
+            export declare type SphereOptions = CircularPrimitiveOptions & PrimitivePlacement & ({
+                /** 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;
+            });
+
+            /** 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;
+            }
 
-           /** 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 phaseDegrees?: 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;
-           }
+            /**
+             * Creates a centered CCW alternating-radius star within the selected profile sampling ceiling.
+             *
+             * @example Five-point outline
+             * ```ts
+             * starLoop(12, 5, 6);
+             * ```
+             */
+            export declare const starLoop: (outerRadius: number, points: number, innerRadius?: number, limits?: Partial<GeometrySamplingLimits>) => readonly Vec2[];
 
-           /** Radial envelope toward which a blunt lead-in collapses. */
-           export declare type ThreadLeadInEnvelope = "major" | "minor";
+            /** End-cap treatment for an open stroked path. */
+            export declare type StrokePathCap = "butt" | "round" | "square";
 
-           /** BOSL2-compatible cross-section scaling curve for a blunt thread lead-in. */
-           export declare type ThreadLeadInShape = "cut" | "linear" | "smooth" | "sqrt";
+            /** Join treatment where adjacent stroked path segments meet. */
+            export declare type StrokePathJoin = "bevel" | "miter" | "round";
 
-           /**
-            * 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 Vec2[];
-               /** Axial width of the flat at the minor envelope. */
-               readonly rootFlatWidth: number;
-           }
+            /**
+             * Converts a sampled millimetre path into the filled region covered by a centered stroke.
+             *
+             * Closed paths omit a duplicated seam point. Zero-length sampled segments are ignored, while the
+             * effective path must still contain visible length. Round caps and joins use deterministic physical
+             * resolution. Bevels fill the outer corner triangle; miters extend the outer edges to their
+             * intersection, falling back to bevels above SVG's default miter limit of 4.
+             */
+            export declare function strokePathRegion(path: Path2, options: StrokePathRegionOptions): Region2;
+
+            /** Physical stroke and topology controls for {@link strokePathRegion}. */
+            export declare interface StrokePathRegionOptions {
+                /** Explicit path, circular and expanded-profile allocation ceilings. */
+                readonly limits?: Partial<GeometrySamplingLimits>;
+                /** Treat the path as a closed non-duplicated loop. Default: `false`. */
+                readonly closed?: boolean;
+                /** End-cap treatment for an open path. Ignored for closed paths. Default: `butt`. */
+                readonly cap?: StrokePathCap;
+                /** Corner treatment; miters exceeding SVG's default limit of 4 become bevels. Default: `miter`. */
+                readonly join?: StrokePathJoin;
+                /** Physical tessellation policy for round caps and joins. */
+                readonly resolution?: GeometryResolution;
+                /** Positive total stroke width in millimetres, centered on the sampled path. */
+                readonly width: number;
+            }
 
-           /** 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;
-           }
+            /**
+             * Subtracts `b` from `a`.
+             * @example
+             * ```ts
+             * subtract3([4, 5, 6], [1, 2, 3]); // [3, 3, 3]
+             * ```
+             */
+            export declare const subtract3: (a: Vec3, b: Vec3) => Vec3;
+
+            /** Sampling controls for deterministic SVG-to-region conversion. */
+            export declare interface SvgImportOptions {
+                /** 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. */
+                readonly circularSegments?: number;
+                /** Operation-level physical tessellation policy over the active model-wide policy. */
+                readonly resolution?: GeometryResolution;
+                /**
+                 * `"center"` places the viewport center at the origin. `"document"` places its converted
+                 * lower-left corner at the origin. Default: `"center"`.
+                 */
+                readonly origin?: "center" | "document";
+            }
+
+            /** Exact normalized SVG region plus bounded source, geometry, and safe-repair diagnostics. */
+            export declare interface SvgRegionPreflight {
+                /** Physical and final-topology measurements of `region`. */
+                readonly geometry: SvgRegionPreflightGeometryMetrics;
+                /** Appearance-preserving cleanup observed during parsing and normalization. */
+                readonly repairs: SvgRegionPreflightRepairs;
+                /** Canonical millimetre, Y-up geometry. */
+                readonly region: Region2;
+                /** Bounded source and flattening complexity measurements. */
+                readonly source: SvgRegionPreflightSourceMetrics;
+            }
+
+            /** Physical and final-topology facts for a normalized imported SVG region. */
+            export declare interface SvgRegionPreflightGeometryMetrics {
+                /** Filled area in square millimetres. */
+                readonly area: number;
+                /** Millimetre bounds, or `null` when no painted region remains. */
+                readonly bounds: Bounds2 | null;
+                /** Disconnected filled polygons in the final region. */
+                readonly components: number;
+                /** Exterior and hole boundary count in the final region. */
+                readonly contours: number;
+                /** Interior boundary count in the final region. */
+                readonly holes: number;
+                /** Shortest final boundary edge in millimetres, or `null` for an empty region. */
+                readonly minEdgeLength: number | null;
+                /** Final boundary edges shorter than the conservative 0.01 mm indicator. */
+                readonly shortEdges: number;
+                /** Components with less than 0.01 square millimetres of filled area. */
+                readonly tinyIslands: number;
+                /** Non-duplicated boundary vertices in the final normalized region. */
+                readonly vertices: number;
+            }
+
+            /** Visible, appearance-preserving cleanup counters from bounded SVG import. */
+            export declare interface SvgRegionPreflightRepairs {
+                /** Graphics elements with neither a visible fill nor a positive-width visible stroke. */
+                readonly invisibleElements: number;
+                /** Open filled subpaths closed by SVG fill semantics without closing their strokes. */
+                readonly implicitFilledClosures: number;
+                /** Visibly painted elements whose fill and stroke both resolved to empty geometry. */
+                readonly emptyElements: number;
+                /** Consecutive repeated flattened vertices discarded before topology resolution. */
+                readonly removedDuplicateVertices: number;
+                /** Explicit repeated seam vertices removed from otherwise closed contours. */
+                readonly removedSeamVertices: number;
+            }
+
+            /** Bounded source-complexity facts collected while parsing one SVG document. */
+            export declare interface SvgRegionPreflightSourceMetrics {
+                /** UTF-8 source size, capped at 256 KiB before parsing. */
+                readonly bytes: number;
+                /** Renderable shape elements, capped at 500; containers and metadata are excluded. */
+                readonly elements: number;
+                /** Flattened vertices emitted before fill, stroke, and clipping operations. */
+                readonly emittedVertices: number;
+                /** Path endpoints and control vertices parsed before adaptive flattening. */
+                readonly parsedVertices: number;
+            }
 
-           /**
-            * Supported built-in and caller-defined thread profiles.
-            */
-           export declare type ThreadProfileSpec = AcmeThreadProfileSpec | ButtressThreadProfileSpec | CustomThreadProfileSpec | SquareThreadProfileSpec | TrapezoidalThreadProfileSpec | TriangularThreadProfileSpec;
+            /**
+             * Sweeps one explicitly ordered point loop, with caps or a geometrically matching closed seam.
+             *
+             * @example Sweep point data along a bent path
+             * ```ts
+             * const profile = rectangleLoop({ size: [6, 3] });
+             * sweepMesh(profile, [[0, 0, 0], [0, 0, 15], [10, 0, 25]], {
+             *   orientation: { kind: "transport", initialNormal: [0, 1, 0] },
+             * });
+             * ```
+             */
+            export declare function sweepMesh(profile: Loop2, path: readonly Vec3[], options?: SweepOptions): TriangleMesh;
 
-           /** Whether compensation is being applied to an external or internal thread. */
-           export declare type ThreadRole = "male" | "female";
+            /**
+             * Controls shared by pure mesh construction and filled modeling sweeps.
+             */
+            export declare interface SweepOptions {
+                /** Join the path's last station to its first. Open paths retain watertight end caps. */
+                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 twistDegrees?: 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 | Vec2 | readonly Vec2[];
+                /** Corresponding point-index advance at a rotationally equivalent closed seam. */
+                readonly seamProfileOffset?: number;
+            }
 
-           /**
-            * Dimensions and independent ring/profile tessellation for a torus around the Z axis.
-            */
-           export declare interface TorusOptions extends PrimitivePlacement {
-               /** 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;
-           }
+            /**
+             * 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?: Vec3;
+            } | {
+                /** 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: Vec3;
+            } | {
+                /** 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";
+            };
+
+            /** End bevel controls shared by threaded rods and cutters. */
+            export declare interface ThreadBevelOptions {
+                /** Apply a 45-degree bevel at Z=0. */
+                readonly bevelBottom?: boolean;
+                /**
+                 * Axial bevel extent in millimetres. Active blunt ends default to one sixth of the compensated
+                 * male minor radius or female major radius; other ends default to the profile depth.
+                 */
+                readonly bevelSize?: number;
+                /** Apply a 45-degree bevel at Z=length. */
+                readonly bevelTop?: boolean;
+            }
+
+            /** 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 maximumRadialOutset?: 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;
+            }
+
+            /** Nut-edge bevel selection. */
+            export declare type ThreadedNutBevel = "automatic" | "both" | "inside" | "none" | "outside";
 
-           /**
-            * A row-major affine 4x4 matrix applied to column vectors.
-            *
-            * Translation occupies indices 3, 7, and 11. The final row must be
-            * `[0, 0, 0, 1]` within the active geometry tolerance.
-            */
-           export declare type Transform3 = readonly [
-           m00: number,
-           m01: number,
-           m02: number,
-           m03: number,
-           m10: number,
-           m11: number,
-           m12: number,
-           m13: number,
-           m20: number,
-           m21: number,
-           m22: number,
-           m23: number,
-           m30: number,
-           m31: number,
-           m32: number,
-           m33: number
-           ];
+            /**
+             * Options for a compensated nut with an internal thread.
+             */
+            export declare interface ThreadedNutOptions extends Omit<InternalThreadCutterOptions, "bevelBottom" | "bevelSize" | "bevelTop" | "length"> {
+                /** Nut body bevel selection. Default: `automatic`. */
+                readonly bevel?: ThreadedNutBevel;
+                /** Optional physical policy for a round body, independent of the thread's matched facet grid. */
+                readonly bodyResolution?: GeometryResolution;
+                /** 45-degree body chamfer extent. Default: `min(profile.depth, thickness/4)`. */
+                readonly chamferSize?: number;
+                /** Leave the bottom outside edge flat for build-plate adhesion. Default: `false`. */
+                readonly flushBuildPlateBottom?: boolean;
+                /** 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;
+            }
+
+            /** Allocation-free body, cutter, and end-face facts resolved for a threaded nut. */
+            export declare interface ThreadedNutPreflight {
+                /** Polygon segment count used by the nut body. */
+                readonly bodySegments: number;
+                /** Shared 45-degree chamfer size applied to the selected body and cutter edges. */
+                readonly chamferSize: 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 facts for the exact extended internal-thread cutter mesh. */
+                readonly thread: HelicalThreadSolidMeshPreflight;
+                /** Start-aligned circular facet count used by the compensated thread cutter. */
+                readonly threadCircularSegments: number;
+            }
 
-           /**
-            * 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: Transform3): number;
+            /**
+             * Supported printable nut body shapes.
+             */
+            export declare type ThreadedNutShape = "hex" | "round" | "square";
 
-           /**
-            * Transforms a closed loop and preserves its original winding convention.
-            *
-            * Reflections reverse the point order automatically through normalization.
-            */
-           export declare function transformLoop2(loop: Loop2, transform: Transform3, tolerance?: GeometryToleranceOptions): Loop2;
+            /**
+             * Options for a compensated external threaded rod along +Z.
+             */
+            export declare interface ThreadedRodOptions extends Omit<HelicalThreadRidgeMeshOptions, "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;
+            }
 
-           /** Applies an XY-plane-preserving affine transform to a 2D path. */
-           export declare function transformPath2(path: Path2, transform: Transform3, tolerance?: GeometryToleranceOptions): Path2;
+            /**
+             * 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 phaseDegrees?: 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";
 
-           /** Applies an affine transform to a 3D path without mutating its points. */
-           export declare function transformPath3(path: Path3, transform: Transform3): Path3;
+            /**
+             * 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 Vec2[];
+                /** Axial width of the flat at the minor envelope. */
+                readonly rootFlatWidth: number;
+            }
+
+            /** 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;
+            }
 
-           /** Transforms an explicit outer/hole region with reflection-safe winding correction. */
-           export declare function transformRegion2(region: Region2, transform: Transform3, tolerance?: GeometryToleranceOptions): Region2;
+            /**
+             * Supported built-in and caller-defined thread profiles.
+             */
+            export declare type ThreadProfileSpec = AcmeThreadProfileSpec | ButtressThreadProfileSpec | CustomThreadProfileSpec | SquareThreadProfileSpec | TrapezoidalThreadProfileSpec | TriangularThreadProfileSpec;
 
-           /**
-            * Applies an affine transform to a mesh and preserves outward face orientation.
-            *
-            * A transform with a negative linear determinant reflects space, so this helper
-            * automatically reverses every triangle. Singular transforms are rejected.
-            *
-            * @param mesh - Mesh to transform without mutation.
-            * @param transform - Row-major affine transform.
-            * @returns A mesh with fresh transformed positions and copied or reversed indices.
-            */
-           export declare function transformTriangleMesh(mesh: TriangleMesh, transform: Transform3): TriangleMesh;
+            /** Whether compensation is being applied to an external or internal thread. */
+            export declare type ThreadRole = "male" | "female";
 
-           /**
-            * Creates an immutable translation transform.
-            *
-            * @param offset - Finite XYZ translation in model units.
-            * @returns A frozen row-major transform.
-            */
-           export declare function translationTransform3(offset: Vec3): Transform3;
+            /**
+             * Dimensions and independent ring/profile tessellation for a torus around the Z axis.
+             */
+            export declare interface TorusOptions extends PrimitivePlacement {
+                /** 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;
+            }
 
-           /** 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;
-               /**
-                * Included flank angle in degrees. Use `90` for printable 45-degree slopes.
-                * @defaultValue `30`
-                */
-               readonly threadAngle?: number;
-           }
+            /**
+             * A row-major affine 4x4 matrix applied to column vectors.
+             *
+             * Translation occupies indices 3, 7, and 11. The final row must be
+             * `[0, 0, 0, 1]` within the active geometry tolerance.
+             */
+            export declare type Transform3 = readonly [
+            m00: number,
+            m01: number,
+            m02: number,
+            m03: number,
+            m10: number,
+            m11: number,
+            m12: number,
+            m13: number,
+            m20: number,
+            m21: number,
+            m22: number,
+            m23: number,
+            m30: number,
+            m31: number,
+            m32: number,
+            m33: number
+            ];
 
-           /**
-            * A topology-preserving indexed triangle mesh with XYZ vertex positions.
-            */
-           export declare interface TriangleMesh {
-               /** Three unsigned vertex indices per triangle. */
-               readonly indices: Uint32Array;
-               /** Flat XYZ coordinates, three finite values per vertex. */
-               readonly positions: Float32Array;
-           }
+            /**
+             * 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: Transform3): number;
 
-           /**
-            * Measurements and optional edge-connected topology from one validated mesh traversal.
-            */
-           export declare interface TriangleMeshAnalysis extends TriangleMeshMeasurements {
-               /** Number of referenced edge-connected components when `includeTopology` is requested. */
-               readonly connectedComponentCount?: number;
-               /** Number of distinct indexed undirected edges when `includeTopology` is requested. */
-               readonly edgeCount?: number;
-           }
+            /**
+             * Transforms a closed loop and preserves its original winding convention.
+             *
+             * Reflections reverse the point order automatically through normalization.
+             */
+            export declare function transformLoop2(loop: Loop2, transform: Transform3, tolerance?: GeometryToleranceOptions): Loop2;
 
-           /**
-            * Validation and optional connectivity controls for a shared mesh analysis.
-            */
-           export declare interface TriangleMeshAnalysisOptions extends TriangleMeshValidationOptions {
-               /** Compute indexed edge/component counts and reject unreferenced vertices; defaults to false. */
-               readonly includeTopology?: boolean;
-           }
+            /** Applies an XY-plane-preserving affine transform to a 2D path. */
+            export declare function transformPath2(path: Path2, transform: Transform3, tolerance?: GeometryToleranceOptions): Path2;
 
-           /**
-            * Geometric measurements derived from a validated, non-empty triangle mesh.
-            */
-           export declare interface TriangleMeshMeasurements {
-               /** Axis-aligned bounds. */
-               readonly bounds: MeshBounds;
-               /** 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;
-           }
+            /** Applies an affine transform to a 3D path without mutating its points. */
+            export declare function transformPath3(path: Path3, transform: Transform3): Path3;
 
-           /** Options controlling bounded triangle-mesh quality analysis. */
-           export declare interface TriangleMeshQualityOptions {
-               /** Maximum number of triangles inspected. Defaults to `200000`. */
-               readonly maximumTriangleCount?: number;
-               /** Numeric comparison overrides; model coordinates are interpreted in their existing units. */
-               readonly tolerance?: GeometryToleranceOptions;
-           }
+            /** Transforms an explicit outer/hole region with reflection-safe winding correction. */
+            export declare function transformRegion2(region: Region2, transform: Transform3, tolerance?: GeometryToleranceOptions): Region2;
 
-           /** 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;
-           }
+            /**
+             * Applies an affine transform to a mesh and preserves outward face orientation.
+             *
+             * A transform with a negative linear determinant reflects space, so this helper
+             * automatically reverses every triangle. Singular transforms are rejected.
+             *
+             * @param mesh - Mesh to transform without mutation.
+             * @param transform - Row-major affine transform.
+             * @returns A mesh with fresh transformed positions and copied or reversed indices.
+             */
+            export declare function transformTriangleMesh(mesh: TriangleMesh, transform: Transform3): TriangleMesh;
 
-           /** Immutable deterministic measurements for a closed, oriented triangle mesh. */
-           export declare interface TriangleMeshSignature {
-               /** Axis-aligned bounds quantized by `tolerances.position`. */
-               readonly bounds: MeshBounds;
-               /** Number of edge-connected closed components. */
-               readonly connectedComponentCount: 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;
-           }
+            /**
+             * Creates an immutable translation transform.
+             *
+             * @param offset - Finite XYZ translation in model units.
+             * @returns A frozen row-major transform.
+             */
+            export declare function translationTransform3(offset: Vec3): Transform3;
+
+            /** 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;
+                /**
+                 * Included flank angle in degrees. Use `90` for printable 45-degree slopes.
+                 * @defaultValue `30`
+                 */
+                readonly threadAngle?: number;
+            }
 
-           /** Options controlling deterministic triangle-mesh regression signatures. */
-           export declare interface TriangleMeshSignatureOptions {
-               /** Maximum accepted triangle count. Defaults to 200,000. */
-               readonly maximumTriangleCount?: 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;
-           }
+            /**
+             * A topology-preserving indexed triangle mesh with XYZ vertex positions.
+             */
+            export declare interface TriangleMesh {
+                /** Three unsigned vertex indices per triangle. */
+                readonly indices: Uint32Array;
+                /** Flat XYZ coordinates, three finite values per vertex. */
+                readonly positions: Float32Array;
+            }
 
-           /** 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;
-           }
+            /**
+             * Measurements and optional edge-connected topology from one validated mesh traversal.
+             */
+            export declare interface TriangleMeshAnalysis extends TriangleMeshMeasurements {
+                /** Number of referenced edge-connected components when `includeTopology` is requested. */
+                readonly connectedComponentCount?: number;
+                /** Number of distinct indexed undirected edges when `includeTopology` is requested. */
+                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;
-           }
+            /**
+             * Validation and optional connectivity controls for a shared mesh analysis.
+             */
+            export declare interface TriangleMeshAnalysisOptions extends TriangleMeshValidationOptions {
+                /** Compute indexed edge/component counts and reject unreferenced vertices; defaults to false. */
+                readonly includeTopology?: boolean;
+            }
 
-           /**
-            * 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;
-           }
+            /**
+             * Geometric measurements derived from a validated, non-empty triangle mesh.
+             */
+            export declare interface TriangleMeshMeasurements {
+                /** Axis-aligned bounds. */
+                readonly bounds: MeshBounds;
+                /** 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 maximumTriangleCount?: 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: MeshBounds;
+                /** Number of edge-connected closed components. */
+                readonly connectedComponentCount: 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 maximumTriangleCount?: 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;
+            }
+
+            /** 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;
+            }
 
-           /** Ear-clips one normalized simple CCW loop into stable local vertex indices. */
-           export declare function triangulateLoop2(loop: Loop2): Uint32Array;
+            /**
+             * 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;
+            }
 
-           /**
-            * Dimensions, placement, and tessellation for a hollow Z-axis tube.
-            */
-           export declare interface TubeOptions extends CircularPrimitiveOptions, PrimitivePlacement {
-               /**
-                * 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;
-               /** Positive inner radius in millimetres. */
-               readonly innerRadius: number;
-               /** Outer radius in millimetres; greater than {@link TubeOptions.innerRadius}. */
-               readonly outerRadius: number;
-           }
+            /** Ear-clips one normalized simple CCW loop into stable local vertex indices. */
+            export declare function triangulateLoop2(loop: Loop2): Uint32Array;
 
-           /**
-            * 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: Transform3, tolerance?: GeometryToleranceOptions): Transform3;
+            /**
+             * Dimensions, placement, and tessellation for a hollow Z-axis tube.
+             */
+            export declare interface TubeOptions extends CircularPrimitiveOptions, PrimitivePlacement {
+                /**
+                 * 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;
+                /** Positive inner radius in millimetres. */
+                readonly innerRadius: number;
+                /** Outer radius in millimetres; greater than {@link TubeOptions.innerRadius}. */
+                readonly outerRadius: number;
+            }
 
             /**
-             * Validates mesh buffers, indices, triangle area, and optionally closed topology.
+             * Checks closed indexed topology, triangle intersections, and alternating nested shell orientation.
+             * Outward exterior shells and inward cavity shells are accepted. Separate shells must not touch,
+             * intersect, or overlap as material. Indexed neighbours may share their own vertex or edge.
              *
-             * Closed validation requires each edge to occur exactly twice with opposite
-             * directions, rejecting boundary and non-manifold edges. Validation does not
-             * mutate or copy the mesh. This establishes edge connectivity, not the absence
-             * of geometric self-intersections between faces.
+             * Uses bounded floating-point tests, not exact predicates or repair. Contacts within the selected
+             * tolerance reject conservatively. At most 200,000 triangles and 2,000,000 spatial/containment tests
+             * are supported; exhausting a ceiling throws COMPLEXITY_LIMIT rather than claiming validity.
+             * Input buffers are freshly inspected and never modified; units are millimetres.
              *
-             * @param mesh - Mesh to inspect.
-             * @param options - Empty-mesh, topology, and tolerance policy.
-             * @returns The original mesh after successful validation.
-             * @throws {@link GeometryError} When any requested invariant fails.
-                 */
-             export declare function validateTriangleMesh(mesh: TriangleMesh, options?: TriangleMeshValidationOptions): TriangleMesh;
-
-             /** A two-dimensional Cartesian vector or point. */
-             export declare type Vec2 = readonly [x: number, y: number];
-
-             /** A three-dimensional Cartesian vector or point. */
-             export declare type Vec3 = readonly [x: number, y: number, z: number];
+             * @param mesh - Closed triangle mesh to inspect.
+             * @param options - Optional lower work ceiling and numeric comparison policy.
+             * @returns The original mesh after every requested check succeeds.
+             */
+            export declare function validateSolidMesh(mesh: TriangleMesh, options?: SolidMeshValidationOptions): TriangleMesh;
 
-             /** Exact curve bounds in millimetres; positive Y points upward. */
-             export declare interface VectorTextBounds {
-                 /** Minimum X and Y of visible outlines, including accents, descenders, and overhangs. */
-                 readonly min: readonly [number, number];
-                 /** Maximum X and Y of visible outlines. */
-                 readonly max: readonly [number, number];
-             }
+            /**
+             * 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: Transform3, tolerance?: GeometryToleranceOptions): Transform3;
 
              /**
-              * 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[];
-                 /** Exact measurements of these paths and their logical text layout. */
-                 readonly metrics: VectorTextMetrics;
-             }
+              * Validates mesh buffers, indices, triangle area, and optionally closed topology.
+              *
+              * Closed validation requires each edge to occur exactly twice with opposite
+              * directions, rejecting boundary and non-manifold edges. Validation does not
+              * mutate or copy the mesh. This establishes edge connectivity, not the absence
+              * of geometric self-intersections between faces.
+              *
+              * @param mesh - Mesh to inspect.
+              * @param options - Empty-mesh, topology, and tolerance policy.
+              * @returns The original mesh after successful validation.
+              * @throws {@link GeometryError} When any requested invariant fails.
+                  */
+              export declare function validateTriangleMesh(mesh: TriangleMesh, options?: TriangleMeshValidationOptions): TriangleMesh;
+
+              /** A two-dimensional Cartesian vector or point. */
+              export declare type Vec2 = readonly [x: number, y: number];
+
+              /** A three-dimensional Cartesian vector or point. */
+              export declare type Vec3 = readonly [x: number, y: number, z: number];
+
+              /** 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 centerAngleDegrees?: number;
+                  /** Reading direction around the circle; defaults to clockwise. */
+                  readonly direction?: "clockwise" | "counterclockwise";
+              }
+
+              /** Exact curve bounds in millimetres; positive Y points upward. */
+              export declare interface VectorTextBounds {
+                  /** Minimum X and Y of visible outlines, including accents, descenders, and overhangs. */
+                  readonly min: readonly [number, number];
+                  /** Maximum X and Y of visible outlines. */
+                  readonly max: readonly [number, number];
+              }
 
-             /**
-              * Horizontal multiline text, bounded to 512 UTF-16 units and 16 lines without wrapping.
-              */
-             export declare interface VectorTextLayoutOptions extends VectorTextOptions {
-                 /** Place each line's advance at the origin; defaults to left. Ink overhang is preserved. */
-                 readonly align?: "left" | "center" | "right";
-                 /** Baseline spacing in ems, 0.5–5; omitted uses the selected face's natural vertical metrics. */
-                 readonly lineHeight?: number;
-                 /** Place the first baseline or the complete ink bounds at Y=0; defaults to 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. */
-                 readonly bounds: VectorTextBounds | null;
-                 /** Unaligned pen displacement: final line advance and negative baseline displacement, in mm. */
-                 readonly advance: readonly [number, number];
-                 /** Maximum line advance in millimetres, including spaces; distinct from visible ink width. */
-                 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. */
-                 readonly descent: number;
-                 /** Actual distance between baselines in millimetres. */
-                 readonly lineHeight: number;
-                 /** Number of lines, including empty and trailing lines; empty text occupies one line. */
-                 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 { }
+              /**
+               * 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[];
+                  /** Exact measurements of these paths and their logical text layout. */
+                  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. */
+                  readonly bounds: VectorTextBounds | null;
+                  /** Unaligned logical advance and negative baseline displacement in mm; arcs retain [arc length, 0]. */
+                  readonly advance: readonly [number, number];
+                  /** Maximum logical line advance in millimetres, including spaces; arc length on circular baselines. */
+                  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. */
+                  readonly descent: number;
+                  /** Actual distance between baselines in millimetres. */
+                  readonly lineHeight: number;
+                  /** Number of lines, including empty and trailing lines; empty text occupies one line. */
+                  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 { }