@metamesh/modeling 0.0.0-stage → 0.7.0

package/dist/api/geometry.d.ts

@@ -0,0 +1,3136 @@
+/** Pure geometry foundations without host initialization. @packageDocumentation */
+
+/** ACME 29-degree included-angle profile. */
+export declare interface AcmeThreadProfileSpec extends ThreadProfileBaseSpec {
+    /** Selects the 29-degree ACME profile family. */
+    readonly kind: "acme";
+    /**
+     * Radial depth in millimetres.
+     * @defaultValue `pitch / 2`
+     */
+    readonly depth?: number;
+}
+
+/**
+ * Adds two finite XYZ vectors component-wise.
+ * @example
+ * ```ts
+ * add3([1, 2, 3], [4, 5, 6]); // [5, 7, 9]
+ * ```
+ */
+export declare const add3: (a: Vec3, b: Vec3) => Vec3;
+
+/** Controls full-circle sampling that must satisfy one or more topology alignments. */
+export declare interface AlignedCircularSegmentsOptions {
+    /**
+     * Non-empty alignment factors. Every value must be a positive safe integer; the returned count
+     * is divisible by their checked least common multiple.
+     */
+    readonly alignTo: readonly number[];
+    /** Explicit sampling allocation ceilings. */
+    readonly limits?: Partial<GeometrySamplingLimits>;
+    /**
+     * Additional full-circle segment floor, as a safe integer of at least three.
+     * @defaultValue `3`
+     */
+    readonly minimumSegments?: number;
+    /**
+     * Exact full-circle segment count.
+     *
+     * This takes precedence over `resolution.circularSegments` and adaptive sampling, and must
+     * already satisfy every alignment factor and `minimumSegments`.
+     */
+    readonly segments?: number;
+    /** Operation-level physical tessellation policy over the active model-wide policy. */
+    readonly resolution?: GeometryResolution;
+}
+
+/**
+ * Validates and measures a mesh in one position and one triangle traversal.
+ *
+ * Bounds, area in square model units and signed volume in cubic model units are computed without
+ * copying or changing the input buffers. Volume is meaningful for consistently wound closed
+ * geometry; `requireClosed` checks oriented edge closure. Optional indexed topology counts require
+ * every position vertex to be referenced and do not establish freedom from self-intersections.
+ * Results and nested bounds are immutable snapshots. Caller-owned mutable meshes are freshly
+ * inspected on every call, never cached.
+ */
+export declare function analyzeTriangleMesh(mesh: TriangleMesh, options?: TriangleMeshAnalysisOptions): TriangleMeshAnalysis;
+
+/**
+ * Measures triangle shape, edge topology, vertex concentration, and connected planar patches.
+ *
+ * Positions are never welded: valence and manifold status describe the supplied indexed topology.
+ * Degenerate triangles are reported rather than rejected, while malformed buffers, non-finite
+ * positions, missing vertex references, and the configured complexity limit throw.
+ *
+ * @param mesh - Indexed triangle mesh in arbitrary consistent model units.
+ * @param options - Scale-aware tolerance and analysis budget.
+ * @returns A deterministic report without mutating or copying the mesh.
+ */
+export declare function analyzeTriangleMeshQuality(mesh: TriangleMesh, options?: TriangleMeshQualityOptions): TriangleMeshQualityReport;
+
+/**
+ * An attachment pose on a solid or assembly.
+ *
+ * `direction` is the outward attachment normal. `up` controls roll and must not
+ * be parallel to `direction`; anchor construction projects and normalizes it.
+ */
+export declare interface Anchor3 {
+    /** Unit outward normal used as the anchor's local +Z direction. */
+    readonly direction: Vec3;
+    /** World-space attachment position. */
+    readonly position: Vec3;
+    /** Roll guide projected into the plane perpendicular to `direction`. */
+    readonly up: Vec3;
+}
+
+/**
+ * Converts an anchor into a right-handed frame with direction as local +Z.
+ *
+ * @param anchor - Anchor created by {@link createAnchor3} or equivalent valid data.
+ * @param tolerance - Optional comparison overrides.
+ * @returns A normalized right-handed frame at the anchor position.
+ */
+export declare function anchorFrame3(anchor: Anchor3, tolerance?: GeometryToleranceOptions): Frame3;
+
+/**
+ * Applies only the linear component of an affine transform to a direction.
+ *
+ * The result is not normalized, preserving scale information.
+ *
+ * @param transform - Valid row-major affine transform.
+ * @param direction - Finite XYZ direction.
+ * @returns A fresh transformed direction.
+ */
+export declare function applyTransformDirection3(transform: Transform3, direction: Vec3): Vec3;
+
+/**
+ * Applies an affine transform to a point, including translation.
+ *
+ * @param transform - Valid row-major affine transform.
+ * @param point - Finite XYZ point.
+ * @returns A fresh transformed point.
+ */
+export declare function applyTransformPoint3(transform: Transform3, point: Vec3): Vec3;
+
+/** Planar circular arc with counterclockwise degree angles. */
+export declare interface ArcCurve2 {
+    /** Selects a circular arc in the XY plane. */
+    readonly kind: "arc";
+    /** Circle center in millimetres. */
+    readonly center: Vec2;
+    /** Positive circular radius in millimetres. */
+    readonly radius: number;
+    /** Initial angle in degrees; defaults to zero. */
+    readonly startDegrees?: number;
+    /** Nonzero signed sweep in degrees, bounded to one complete turn. */
+    readonly sweepDegrees: number;
+}
+
+/** Spatial circular arc in the plane of two orthogonal unit directions. */
+export declare interface ArcCurve3 {
+    /** Selects a circular arc in the supplied plane. */
+    readonly kind: "arc";
+    /** Circle center in millimetres. */
+    readonly center: Vec3;
+    /** Positive circular radius in millimetres. */
+    readonly radius: number;
+    /** Orthogonal unit direction at zero degrees. */
+    readonly xAxis: Vec3;
+    /** Orthogonal unit direction at positive ninety degrees. */
+    readonly yAxis: Vec3;
+    /** Initial angle in degrees; defaults to zero. */
+    readonly startDegrees?: number;
+    /** Nonzero signed sweep in degrees, bounded to one complete turn. */
+    readonly sweepDegrees: number;
+}
+
+/**
+ * Builds the transform that moves a source anchor onto a target anchor.
+ *
+ * The default `opposed` alignment points the source outward normal against the
+ * target outward normal, producing face-to-face mating. A positive gap moves the
+ * attachment point along the target's outward direction. Spin is applied after
+ * alignment around the final source direction.
+ *
+ * @param source - Anchor expressed in the moving object's local coordinates.
+ * @param target - Desired anchor pose in destination coordinates.
+ * @param options - Alignment, gap, spin, and tolerance policy.
+ * @returns A frozen affine transform for the moving object.
+ * @throws {@link GeometryError} For invalid anchors or non-finite options.
+     */
+ export declare function attachTransform(source: Anchor3, target: Anchor3, options?: AttachTransformOptions): Transform3;
+
+ /** Options controlling how one anchor is attached to another. */
+ export declare interface AttachTransformOptions {
+     /** Align outward directions face-to-face (`opposed`) or in parallel (`same`). */
+     readonly alignment?: "opposed" | "same";
+     /** Separation along the target anchor's outward direction in model units. */
+     readonly gap?: number;
+     /** Additional right-handed roll about the attached direction, in radians. */
+     readonly spinRadians?: number;
+     /** Optional numeric comparison overrides. */
+     readonly tolerance?: GeometryToleranceOptions;
+ }
+
+ /**
+  * One explicitly unit-labelled right-handed axis-angle rotation.
+  */
+ export declare type AxisAngleRotation3 = {
+     /** Finite right-handed angle in degrees. */
+     readonly degrees: number;
+     /** Excluded when the angle is expressed in degrees. */
+     readonly radians?: never;
+ } | {
+     /** Finite right-handed angle in radians. */
+     readonly radians: number;
+     /** Excluded when the angle is expressed in radians. */
+     readonly degrees?: never;
+ };
+
+ /** Axis-aligned bounds in two-dimensional model space. */
+ export declare interface Bounds2 {
+     /** Inclusive maximum X/Y coordinates. */
+     readonly max: Vec2;
+     /** Inclusive minimum X/Y coordinates. */
+     readonly min: Vec2;
+ }
+
+ /** Axis-aligned bounds in three-dimensional model space. */
+ export declare interface Bounds3 {
+     /** Inclusive maximum X/Y/Z coordinates. */
+     readonly max: Vec3;
+     /** Inclusive minimum X/Y/Z coordinates. */
+     readonly min: Vec3;
+ }
+
+ /** Creates an outward face-center anchor using the same local origin convention as box().
+  * @remarks origin applies an explicit translation. For rotated components, transform the
+  * resulting anchor frame explicitly; no anchor is inherited from a Boolean result.
+  */
+ export declare function boxAnchor3(options: BoxAnchorOptions): Anchor3;
+
+ /** Named face on an axis-aligned box. */
+ export declare type BoxAnchorFace = "back" | "bottom" | "front" | "left" | "right" | "top";
+
+ /** Box dimensions and construction origin for one named face anchor. */
+ export declare interface BoxAnchorOptions {
+     /** XYZ dimensions, or one uniform dimension, in millimetres. */
+     readonly size: number | Vec3;
+     /** Named outward face whose center is the attachment point. */
+     readonly face: BoxAnchorFace;
+     /** Centers the box around its construction origin; defaults to true, matching box(). */
+     readonly center?: boolean;
+     /** Construction origin; centered-box center or noncentered minimum corner. Defaults to zero. */
+     readonly origin?: Vec3;
+ }
+
+ /** Box edges use +Z top, +Y front and +X right; vertical names list front/back first. */
+ export declare type BoxEdge = "top-front" | "top-back" | "top-left" | "top-right" | "bottom-front" | "bottom-back" | "bottom-left" | "bottom-right" | "front-left" | "front-right" | "back-left" | "back-right";
+
+ /** Named individual edges or top/bottom rims and all four vertical edges. */
+ export declare type BoxEdgeSelection = BoxEdge | "top" | "bottom" | "vertical";
+
+ /** Independent treatments for disjoint named edge selections; overlapping selections fail. */
+ export declare type BoxEdgeTreatments = Readonly<Partial<Record<BoxEdgeSelection, EdgeTreatment>>>;
+
+ /**
+  * Dimensions, placement, and uniform or independently selected finishing for an axis-aligned box.
+  */
+ export declare interface BoxOptions extends PrimitivePlacement {
+     /** Explicit sampling ceilings for edge treatments, bounded by the host policy. */
+     readonly limits?: Partial<GeometrySamplingLimits>;
+     /**
+      * Centers the box on the XYZ origin when `true`; otherwise its minimum corner is at the origin.
+      * @defaultValue `true`
+      */
+     readonly center?: boolean;
+     /** Positive uniform size or explicit `[X, Y, Z]` extents in millimetres. */
+     readonly size: number | Vec3;
+     /** Uniform treatment or independent disjoint nominal edge/group treatments. */
+     readonly treatment?: EdgeTreatment | BoxEdgeTreatments;
+ }
+
+ /**
+  * Builds closed thread-ridge components with every profile locked to the
+  * shaft's radial/axial frame. The mesh is intended for union with its
+  * minor-envelope cylinder and never owns WASM objects.
+  */
+ export declare function buildHelicalThreadRidgeMesh(options: HelicalThreadRidgeMeshOptions): TriangleMesh;
+
+ /**
+  * Builds one closed threaded cylinder without a ridge/core Boolean seam.
+  *
+  * Each circular facet includes its exact phase-shifted profile breakpoints, including duplicate-Z
+  * samples for vertical flanks and blunt transitions. Adjacent variable grids are stitched as a
+  * monotone strip, with optional intermediate rows bounded by physical `maxSegmentLength`. A
+  * conservative pre-allocation estimate rejects excessive meshes before constructing position
+  * arrays.
+  */
+ export declare function buildHelicalThreadSolidMesh(options: HelicalThreadSolidMeshOptions): TriangleMesh;
+
+ /** Axial side carrying the near-normal pressure flank of a buttress thread. */
+ export declare type ButtressPressureFlankSide = "negative" | "positive";
+
+ /** Asymmetric printable buttress profile with 7/45-degree flanks. */
+ export declare interface ButtressThreadProfileSpec extends ThreadProfileBaseSpec {
+     /** Selects the asymmetric printable buttress profile family. */
+     readonly kind: "buttress";
+     /**
+      * Radial depth in millimetres.
+      * @defaultValue `0.66271 * pitch`
+      */
+     readonly depth?: number;
+     /**
+      * Axial side of each tooth carrying the 7-degree pressure flank. The opposite side uses the
+      * 45-degree clearance flank.
+      * @defaultValue `"positive"`
+      */
+     readonly pressureFlankSide?: ButtressPressureFlankSide;
+ }
+
+ /**
+  * A planar edge or corner chamfer with equal or independent surface setbacks.
+  */
+ export declare interface ChamferedEdgeTreatment {
+     /** Selects a straight bevel between adjoining surfaces. */
+     readonly kind: "chamfer";
+     /** Positive tangent setbacks in millimetres, equal or [first surface, second surface]; selected treatments must fit without overlap. */
+     readonly distance: number | readonly [first: number, second: number];
+ }
+
+ /**
+  * Creates an immutable centered CCW circle with +X seam and vertex or face radial sizing.
+  *
+  * @example Explicit circular point data
+  * ```ts
+  * circleLoop({ diameter: 20, segments: 32 });
+  * ```
+  */
+ export declare const circleLoop: (options: CircleLoopOptions) => Loop2;
+
+ /**
+  * Circular profile dimensions with exactly one radius or diameter and explicit sampling.
+  */
+ export declare type CircleLoopOptions = CircularPrimitiveOptions & RadialSizingOptions & ({
+     /** Positive nominal 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;
+ });
+
+ /**
+  * Tessellation controls shared by circular primitives across Geometry entry points.
+  */
+ export declare interface CircularPrimitiveOptions {
+     /** Explicit sampling ceilings; bound modeling operations may only lower the host policy. */
+     readonly limits?: Partial<GeometrySamplingLimits>;
+     /**
+      * Exact circumferential segment count from three through the configured safety limit.
+      *
+      * This local topology override takes precedence over {@link CircularPrimitiveOptions.resolution}
+      * and any active model-wide resolution policy.
+      */
+     readonly segments?: number;
+     /** Operation-level physical tessellation policy over the active model-wide policy. */
+     readonly resolution?: GeometryResolution;
+ }
+
+ /** Close, normal, and loose metric clearance-hole diameters in millimetres. */
+ export declare interface ClearanceHoleDimensions {
+     /** Close-fit clearance-hole diameter. */
+     readonly close: number;
+     /** Loose-fit clearance-hole diameter. */
+     readonly loose: number;
+     /** Normal-fit clearance-hole diameter. */
+     readonly normal: number;
+ }
+
+ /** Common clearance-hole fit categories, ordered from smallest to largest. */
+ export declare type ClearanceHoleFit = "close" | "normal" | "loose";
+
+ /** Compensated major/minor envelopes and the policy values used. */
+ export declare interface CompensatedThreadDiameters {
+     /** Axial backlash from the selected policy. */
+     readonly axialBacklash: number;
+     /** Compensated major diameter in millimetres. */
+     readonly majorDiameter: number;
+     /** Compensated minor diameter in millimetres. */
+     readonly minorDiameter: number;
+     /** Signed radial shift: negative for male inset, positive for female outset. */
+     readonly radialShift: number;
+ }
+
+ /**
+  * Applies role-specific radial compensation while preserving thread depth.
+  *
+  * Male envelopes move inward by the policy inset; female envelopes move
+  * outward by the policy outset. Combining both parts produces the sum of those
+  * allowances as radial mating clearance.
+  */
+ export declare function compensateThreadDiameters(options: ThreadCompensationOptions): CompensatedThreadDiameters;
+
+ /**
+  * Applies axial fit allowance to a validated periodic profile.
+  *
+  * Male crests/ridges narrow by the requested backlash; female cutter ridges
+  * widen by it. Periodic root endpoints remain fixed so pitch and lead do not
+  * change. The returned profile is a new deeply immutable value.
+  */
+ export declare function compensateThreadProfileAxially(profile: ThreadProfile, axialBacklash: number, role: "female" | "male"): ThreadProfile;
+
+ /**
+  * Applies printable axial fit plus the conservative phase allowance required by circular facets.
+  *
+  * One triangulated facet spans `pitch * starts / circularSegments` axially. A directed zipper
+  * triangle can expose either end of that complete span when independently faceted parts rotate.
+  * This helper distributes the full conservative flank clearance between the male crest and female
+  * root according to their available flat widths, and rejects a resolution that cannot represent
+  * it exactly.
+  */
+ export declare function compensateThreadProfileForFaceting(profile: ThreadProfile, axialBacklash: number, role: "female" | "male", starts: number, circularSegments: number): ThreadProfile;
+
+ /**
+  * Composes two affine transforms without mutating either matrix.
+  *
+  * `composeTransform3(after, before)` applies `before` first and `after` second.
+  *
+  * @param after - Transform applied second.
+  * @param before - Transform applied first.
+  * @returns A new frozen transform equal to `after * before`.
+  */
+ export declare function composeTransform3(after: Transform3, before: Transform3): Transform3;
+
+ /**
+  * Builds rotation-minimizing frames for a non-duplicated closed path.
+  *
+  * Centered cyclic tangents are parallel-transported around the loop. The seam
+  * holonomy is measured by transporting the last normal back to the first
+  * tangent, then its residual rotation is distributed uniformly over all path
+  * intervals. This avoids a single visible seam or an accumulated frame flip.
+  * The maxPathPoints ceiling (default100000) bounds path points and frames.
+  */
+ export declare const computeClosedParallelTransportFrames: (path: readonly Vec3[], initialNormal?: Vec3, limits?: Partial<GeometrySamplingLimits>) => readonly PathFrame[];
+
+ /**
+  * Builds rotation-minimizing frames by parallel-transporting the previous normal.
+  * This avoids the sudden profile flips produced by picking a fresh up-vector per ring.
+  * Paths exceeding maxPathPoints (default 100000) reject before frame allocation or guide evaluation.
+  */
+ export declare const computeParallelTransportFrames: (path: readonly Vec3[], initialNormal?: Vec3, normalGuide?: PathNormalGuide, limits?: Partial<GeometrySamplingLimits>) => readonly PathFrame[];
+
+ /** 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. */
+     readonly id: string;
+     /** Counterclockwise outer contour. */
+     readonly outer: CorrespondingContour;
+     /** Clockwise hole contours belonging to this component. */
+     readonly holes: readonly CorrespondingContour[];
+ }
+
+ /** A sampled contour retaining logical slots, including intentionally collapsed spans. */
+ export declare interface CorrespondingContour {
+     /** Stable canonical lowercase identity; unique within the containing topology or output. */
+     readonly id: string;
+     /** Ordered sampled points in millimetres; closing vertices are implicit. */
+     readonly points: Loop2;
+     /** One span identity per point; indices correspond between every matched family member. */
+     readonly spans: readonly string[];
+ }
+
+ /** Shared logical contour sampling suitable for a loft or hollow sweep. */
+ export declare interface CorrespondingProfile {
+     /** Ordered components with explicit contour identities. */
+     readonly components: readonly CorrespondingComponent[];
+ }
+
+ /** One already matched profile at an explicit height or right-handed spatial frame. */
+ export declare type CorrespondingProfileStation = LoftPlacement & {
+     /** Already corresponding filled contours with authoritative landmark slots. */
+     readonly profile: CorrespondingProfile;
+ };
+
+ /**
+  * Constructs a normalized immutable attachment anchor.
+  *
+  * `up` is projected onto the plane perpendicular to `direction`, removing small
+  * input drift while preserving its roll intent.
+  *
+  * @param position - Finite anchor point in model coordinates.
+  * @param direction - Non-zero outward attachment normal.
+  * @param up - Non-parallel roll reference; defaults to +Y.
+  * @param tolerance - Optional comparison overrides.
+  * @returns A frozen anchor with unit, orthogonal direction and up vectors.
+  * @throws {@link GeometryError} For non-finite or degenerate inputs.
+      */
+  export declare function createAnchor3(position: Vec3, direction: Vec3, up?: Vec3, tolerance?: GeometryToleranceOptions): Anchor3;
+
+  /**
+   * Creates a periodic thread profile for the shaft-locked helical mesher.
+   *
+   * The open path spans one pitch. Radial zero is the major envelope; negative
+   * values point toward the shaft. Custom paths must be finite, axially
+   * non-decreasing, periodic at their endpoints, and reach radial zero.
+   *
+   * @example Printable triangular thread profile
+   * ```ts
+   * createThreadProfile({ kind: "triangular", pitch: 1.75 });
+   * ```
+   */
+  export declare function createThreadProfile(spec: ThreadProfileSpec): ThreadProfile;
+
+  /**
+   * Creates an order-independent regression signature for a manufacturing mesh.
+   *
+   * The input must be non-empty, closed, consistently wound, and have no unreferenced vertices.
+   * Vertex and triangle order do not affect the fingerprint; winding, quantized geometry, and
+   * connectivity metrics do. The fingerprint is a regression aid, not a cryptographic digest.
+   *
+   * @param mesh - Closed oriented mesh to measure without mutation.
+   * @param options - Absolute quantization and complexity limits.
+   * @returns Compact counts, bounds, volume, topology, tolerances, and canonical fingerprint.
+   * @throws {@link GeometryError} When validation, topology, tolerance, or complexity checks fail.
+       */
+   export declare function createTriangleMeshSignature(mesh: TriangleMesh, options?: TriangleMeshSignatureOptions): TriangleMeshSignature;
+
+   /**
+    * Returns the right-handed cross product.
+    * @example
+    * ```ts
+    * cross3([1, 0, 0], [0, 1, 0]); // [0, 0, 1]
+    * ```
+    */
+   export declare const cross3: (a: Vec3, b: Vec3) => Vec3;
+
+   /** Planar cubic Bézier with explicit endpoint and control coordinates. */
+   export declare interface CubicBezierCurve2 {
+       /** Selects a cubic Bézier through two endpoints and two controls. */
+       readonly kind: "cubic";
+       /** Initial XY point in millimetres. */
+       readonly start: Vec2;
+       /** First XY control point in millimetres. */
+       readonly control1: Vec2;
+       /** Second XY control point in millimetres. */
+       readonly control2: Vec2;
+       /** Final XY point in millimetres. */
+       readonly end: Vec2;
+   }
+
+   /**
+    * Spatial cubic Bézier with explicit endpoint and control coordinates.
+    */
+   export declare interface CubicBezierCurve3 {
+       /** Selects a cubic Bézier through two endpoints and two controls. */
+       readonly kind: "cubic";
+       /** Initial XYZ point in millimetres. */
+       readonly start: Vec3;
+       /** First XYZ control point in millimetres. */
+       readonly control1: Vec3;
+       /** Second XYZ control point in millimetres. */
+       readonly control2: Vec3;
+       /** Final XYZ point in millimetres. */
+       readonly end: Vec3;
+   }
+
+   /** Returns cumulative arc length for finite points under maxPathPoints (default 100000); rejects overflowing length. */
+   export declare const cumulativePathLengths: (path: readonly Vec3[], limits?: Partial<GeometrySamplingLimits>) => readonly number[];
+
+   /** Reusable planar curve definition. */
+   export declare type Curve2 = LineCurve2 | ArcCurve2 | CubicBezierCurve2;
+
+   /**
+    * Reusable spatial curve definition.
+    */
+   export declare type Curve3 = LineCurve3 | ArcCurve3 | CubicBezierCurve3;
+
+   /**
+    * Explicit physical sampling and allocation policy for reusable curves.
+    */
+   export declare interface CurveSamplingOptions {
+       /** Exact segment count overrides physical criteria; curve parameters are spaced uniformly. */
+       readonly segments?: number;
+       /** Millimetre sampling policy; circularSegments applies only to arcs. */
+       readonly resolution?: GeometryResolution;
+       /** Output vertex ceiling of at least two; may only lower limits.maxPathPoints. */
+       readonly maximumVertices?: number;
+       /** Explicit sampling ceilings; omitted values use package defaults without ambient state. */
+       readonly limits?: Partial<GeometrySamplingLimits>;
+   }
+
+   /** Caller-defined periodic axial/radial profile in millimetres. */
+   export declare interface CustomThreadProfileSpec extends ThreadProfileBaseSpec {
+       /** Selects a caller-defined periodic profile. */
+       readonly kind: "custom";
+       /**
+        * Open path spanning exactly `[-pitch/2, pitch/2]`, with both endpoints on the minor envelope,
+        * one connected ridge, one contiguous crest, and radial zero at the major envelope.
+        */
+       readonly points: readonly Vec2[];
+   }
+
+   /** Creates a cap-center or radial-side anchor using cylinder()'s construction origin.
+    * @remarks Both centered and noncentered cylinders extend along +Z. Side angle uses degrees;
+    * origin applies an explicit translation, and arbitrary component transforms remain explicit.
+    */
+   export declare function cylinderAnchor3(options: CylinderAnchorOptions): Anchor3;
+
+   /** Named face on a cylinder parallel to +Z. */
+   export declare type CylinderAnchorFace = "bottom" | "side" | "top";
+
+   /** Cylinder dimensions and construction origin for one named face anchor. */
+   export declare interface CylinderAnchorOptions {
+       /** Constant cylinder radius in millimetres. */
+       readonly radius: number;
+       /** Full axial height in millimetres. */
+       readonly height: number;
+       /** Named outward face; side anchors lie halfway up the cylinder. */
+       readonly face: CylinderAnchorFace;
+       /** Side angle counter-clockwise from +X, in degrees; defaults to zero. */
+       readonly angleDegrees?: number;
+       /** Centers the cylinder along Z; defaults to true, matching cylinder(). */
+       readonly center?: boolean;
+       /** Construction origin; centered-axis midpoint or noncentered bottom axis. Defaults to zero. */
+       readonly origin?: Vec3;
+   }
+
+   /**
+    * Dimensions, placement, independent end finishing, and tessellation for a Z-axis cylinder or frustum.
+    */
+   export declare type CylinderOptions = CircularPrimitiveOptions & RadialSizingOptions & PrimitivePlacement & {
+       /**
+        * Centers the solid on the Z origin when `true`; otherwise its bottom is at `Z = 0`.
+        * @defaultValue `true`
+        */
+       readonly center?: boolean;
+       /** Independent end treatments; first setback is cap inset and second follows the sloped side. */
+       readonly ends?: EndTreatments;
+       /** Total height along +Z in millimetres. */
+       readonly height: number;
+   } & ({
+       /** Positive uniform radius or nonnegative `[bottom, top]` radii in millimetres; one must be positive. */
+       readonly radius: number | readonly [bottom: number, top: number];
+       /** Full diameter is unavailable when radius is supplied. */
+       readonly diameter?: never;
+   } | {
+       /** Positive uniform diameter or nonnegative `[bottom, top]` diameters in millimetres; one must be positive. */
+       readonly diameter: number | readonly [bottom: number, top: number];
+       /** Radius is unavailable when diameter is supplied. */
+       readonly radius?: never;
+   });
+
+   /**
+    * Resolved transverse pitch-plane dimensions for one cylindrical gear.
+    */
+   export declare interface CylindricalGearDimensions {
+       /** Addendum above the pitch circle, in millimetres. */
+       readonly addendum: number;
+       /** Angular pitch between adjacent teeth, in radians. */
+       readonly angularPitch: number;
+       /** Tangential backlash applied to this gear, in millimetres. */
+       readonly backlash: number;
+       /** Base-circle radius used by the involute, in millimetres. */
+       readonly baseRadius: number;
+       /** Dedendum below the pitch circle, in millimetres. */
+       readonly dedendum: number;
+       /** Signed helix angle, in radians. */
+       readonly helixAngleRadians: number;
+       /** Caller-supplied normal module, in millimetres. */
+       readonly module: number;
+       /** Minimum physical tooth count for this unshifted full-depth external profile. */
+       readonly minimumToothCountWithoutUndercut: number;
+       /** Outside radius at the tooth tips, in millimetres. */
+       readonly outsideRadius: number;
+       /** Pitch-circle radius, in millimetres. */
+       readonly pitchRadius: number;
+       /** Normal pressure angle, in radians. */
+       readonly pressureAngleRadians: number;
+       /** Root radius at the bottom lands, in millimetres. */
+       readonly rootRadius: number;
+       /** Integer number of teeth. */
+       readonly toothCount: number;
+       /** Tangential tooth thickness at the pitch circle, in millimetres. */
+       readonly toothThicknessAtPitch: number;
+       /** Module measured in the transverse pitch plane, in millimetres. */
+       readonly transverseModule: number;
+       /** Pressure angle measured in the transverse pitch plane, in radians. */
+       readonly transversePressureAngleRadians: number;
+       /** Helical equivalent spur tooth count, `toothCount / cos³(helixAngle)`. */
+       readonly virtualToothCount: number;
+   }
+
+   /**
+    * Whether two cylindrical gears mesh on their outside teeth or as a pinion inside a ring.
+    */
+   export declare type CylindricalGearMeshKind = "external" | "internal";
+
+   /** Sampling controls for a complete non-duplicated gear outline. */
+   export declare interface CylindricalGearOutlineOptions {
+       /** Exact samples per involute flank, at least two, within the aggregate profile ceiling. */
+       readonly flankSamples?: number;
+       /** Exact samples along each bottom land, at least one, within selected circular/profile ceilings. */
+       readonly rootArcSamples?: number;
+       /** Explicit profile and circular allocation ceilings. */
+       readonly limits?: Partial<GeometrySamplingLimits>;
+       /** Explicit physical sampling policy for adaptive defaults. */
+       readonly resolution?: GeometryResolution;
+       /** Exact samples along each tooth tip, at least one, within selected circular/profile ceilings. */
+       readonly tipArcSamples?: number;
+   }
+
+   /**
+    * Pitch solution for a coordinated cylindrical gear pair.
+    */
+   export declare interface CylindricalGearPairDimensions {
+       /** Nominal distance between the two +Z gear axes, in millimetres. */
+       readonly centerDistance: number;
+       /** Resolved driver dimensions. */
+       readonly driver: CylindricalGearDimensions;
+       /** `-1` for opposite external rotation and `1` for same-direction internal rotation. */
+       readonly drivenDirection: -1 | 1;
+       /** Resolved driven dimensions. */
+       readonly driven: CylindricalGearDimensions;
+       /** Absolute driven-to-driver tooth-count ratio. */
+       readonly ratio: number;
+       /** Helix angle required on the driven member for conjugate teeth, in degrees. */
+       readonly requiredDrivenHelixAngleDegrees: number;
+   }
+
+   /** Sampling controls for one coupled internal-gear tooth cycle. */
+   export declare interface CylindricalGearPairMotionOptions {
+       /** Optional deterministic outline sampling overrides. */
+       readonly outline?: CylindricalGearOutlineOptions;
+       /** Coupled poses sampled over one driver tooth pitch. Defaults to 24. */
+       readonly samples?: number;
+   }
+
+   /** Maximum sampled planar overlap for an external pinion inside an internal ring. */
+   export declare interface CylindricalGearPairMotionReport {
+       /** Driver phase at the maximum overlap, in radians. */
+       readonly driverPhaseRadians: number;
+       /** Maximum pinion area lying inside ring material, in square millimetres. */
+       readonly maximumOverlapArea: number;
+       /** Number of evenly spaced coupled poses inspected. */
+       readonly samples: number;
+   }
+
+   /**
+    * Inputs for resolving a coordinated cylindrical gear pair.
+    */
+   export declare interface CylindricalGearPairSpec {
+       /** Driving gear or pinion. */
+       readonly driver: CylindricalGearSpec;
+       /** Driven external gear or internal ring gear. */
+       readonly driven: CylindricalGearSpec;
+       /** External/external or external/internal mesh. */
+       readonly mesh: CylindricalGearMeshKind;
+   }
+
+   /**
+    * Nominal dimensions for a standard full-depth cylindrical involute gear.
+    *
+    * Lengths use millimetres. `module` and `pressureAngleDegrees` are measured in
+    * the normal plane; a non-zero signed helix angle is converted to transverse
+    * pitch-plane dimensions. Positive and negative helix angles identify
+    * opposite hands but produce the same 2D pitch geometry.
+    */
+   export declare interface CylindricalGearSpec {
+       /** Tangential tooth-thickness reduction at the pitch circle, in millimetres. */
+       readonly backlash?: number;
+       /** Dedendum clearance as a multiple of normal module; defaults to `0.25`. */
+       readonly clearanceFactor?: number;
+       /** Signed helix angle in degrees; zero creates a spur pitch system. */
+       readonly helixAngleDegrees?: number;
+       /** Normal module in millimetres per tooth. */
+       readonly module: number;
+       /** Normal pressure angle in degrees; defaults to 20 degrees. */
+       readonly pressureAngleDegrees?: number;
+       /** Integer tooth count from 6 through 1,000; external profiles also enforce the no-undercut limit. */
+       readonly toothCount: number;
+   }
+
+   /** Default absolute, relative, and angular tolerances for millimetre-scale models. */
+   export declare const DEFAULT_GEOMETRY_TOLERANCE: Readonly<{
+       /** Default absolute distance floor in model units. */
+       absolute: 1e-9;
+       /** Default angular comparison threshold in radians. */
+       angular: 1e-10;
+       /** Default dimensionless model-scale multiplier. */
+       relative: 1e-12;
+   }>;
+
+   /** Conservative defaults; trusted callers can supply larger explicit ceilings. */
+   export declare const defaultGeometrySamplingLimits: GeometrySamplingLimits;
+
+   /**
+    * Places an exact item count at equal arc-length intervals along a sampled path.
+    *
+    * Coordinates are unit-agnostic. Closed paths must omit their duplicated seam;
+    * open paths include both endpoints when `count` is greater than one.
+    * Coordinates and total length must be finite. Input points and output placements are each
+    * limited by maxPathPoints (default 100000); exact counts exceeding that ceiling reject before length calculation.
+    */
+   export declare const distributeAlongPath: (path: readonly Vec3[], count: number, closed: boolean, limits?: Partial<GeometrySamplingLimits>) => readonly PathPlacement[];
+
+   /**
+    * Returns the scalar dot product.
+    * @example
+    * ```ts
+    * dot3([1, 0, 0], [0, 1, 0]); // 0
+    * ```
+    */
+   export declare const dot3: (a: Vec3, b: Vec3) => number;
+
+   /**
+    * Uniform finishing vocabulary shared by applicable solid edges and profile corners.
+    */
+   export declare type EdgeTreatment = ChamferedEdgeTreatment | RoundedEdgeTreatment | SmoothEdgeTreatment | ProfiledEdgeTreatment;
+
+   /**
+    * Creates an immutable centered CCW ellipse with +X seam within the selected sampling ceiling.
+    *
+    * @example Ellipse by full dimensions
+    * ```ts
+    * ellipseLoop({ size: [30, 20] });
+    * ```
+    */
+   export declare function ellipseLoop(options: EllipseLoopOptions): Loop2;
+
+   /**
+    * Ellipse dimensions with exactly one XY radii or full-size tuple and explicit sampling.
+    */
+   export declare type EllipseLoopOptions = CircularPrimitiveOptions & ({
+       /** Positive XY radii in millimetres; mutually exclusive with size. */
+       readonly radius: Vec2;
+       /** Full XY extents are unavailable when radius is supplied. */
+       readonly size?: never;
+   } | {
+       /** Positive full XY extents in millimetres; mutually exclusive with radius. */
+       readonly size: Vec2;
+       /** XY radii are unavailable when size is supplied. */
+       readonly radius?: never;
+   });
+
+   /**
+    * Independent inward finishing on primitive or straight convex extrusion ends.
+    */
+   export declare interface EndTreatments {
+       /** Bottom cap and adjoining side; omitted leaves the end untreated. */
+       readonly bottom?: EdgeTreatment;
+       /** Top cap and adjoining side; omitted leaves the end untreated. */
+       readonly top?: EdgeTreatment;
+   }
+
+   /**
+    * Creates an immutable right-handed XYZ Euler rotation transform.
+    *
+    * Rotations are applied about global X first, then Y, then Z. This matches the
+    * degree-based Euler convention used by the Manifold adapters.
+    *
+    * @param rotationDegrees - Finite `[x, y, z]` rotation angles in degrees.
+    * @returns A frozen row-major transform.
+    * @throws {@link GeometryError} When an angle is non-finite.
+        */
+    export declare function eulerTransform3(rotationDegrees: Vec3): Transform3;
+
+    /**
+     * Linearly extrudes one simple profile along +Z with robust ear-clipped caps.
+     *
+     * @example Extrude point data without an engine
+     * ```ts
+     * const outline = rectangleLoop({ size: [30, 20], treatment: { kind: "round", radius: 3 } });
+     * extrudeMesh(outline, { height: 8 });
+     * ```
+     */
+    export declare function extrudeMesh(profile: Loop2, options: ExtrudeOptions): TriangleMesh;
+
+    /**
+     * Dimensions and sampling shared by native and pure +Z extrusion.
+     */
+    export declare interface ExtrudeOptions extends ExtrusionSamplingOptions {
+        /** Positive extrusion height in millimetres. */
+        readonly height: number;
+        /** Center the extrusion on Z; otherwise its bottom is at zero. Defaults to false. */
+        readonly center?: boolean;
+        /** Independent inward end treatments on straight convex single-contour extrusions. */
+        readonly ends?: EndTreatments;
+    }
+
+    /** Shared sampling controls for a twisted or scaled linear extrusion. */
+    export declare interface ExtrusionSamplingOptions {
+        /** Exact number of intermediate profiles, nonnegative; overrides physical sampling. */
+        readonly divisions?: number;
+        /** Explicit output and sampling allocation ceilings. */
+        readonly limits?: Partial<ModelingLimits>;
+        /** Operation-level physical policy over the nearest model scope. */
+        readonly resolution?: GeometryResolution;
+        /** Finite uniform or XY scale of the top profile; defaults to one. */
+        readonly scaleTop?: number | Vec2;
+        /** Finite rotation of the top profile about +Z, in degrees; defaults to zero. */
+        readonly twistDegrees?: number;
+    }
+
+    /** A right-handed orthonormal coordinate frame expressed in world coordinates. */
+    export declare interface Frame3 {
+        /** World-space origin of the local frame. */
+        readonly origin: Vec3;
+        /** Unit vector defining the local +X axis. */
+        readonly xAxis: Vec3;
+        /** Unit vector defining the local +Y axis. */
+        readonly yAxis: Vec3;
+        /** Unit vector defining the local +Z axis. */
+        readonly zAxis: Vec3;
+    }
+
+    /**
+     * Converts a right-handed orthonormal frame into a local-to-world transform.
+     *
+     * @param frame - Frame whose axes become the transform columns.
+     * @param tolerance - Optional orthonormality comparison overrides.
+     * @returns A frozen rigid transform.
+     * @throws {@link GeometryError} When axes are non-unit, non-orthogonal, or left-handed.
+         */
+     export declare function frameTransform3(frame: Frame3, tolerance?: GeometryToleranceOptions): Transform3;
+
+     /**
+      * Error raised when a geometry precondition or invariant is not satisfied.
+      *
+      * Callers may use `code` for coarse recovery decisions. Human-facing details
+      * remain in `message`; messages are descriptive but are not a stable API.
+      *
+      * @example
+      * ```ts
+      * const error = new GeometryError("INVALID_ARGUMENT", "Radius must be positive.", {
+      *   operation: "example",
+      *   details: { radius: 0 },
+      * });
+      * ```
+      */
+     export declare class GeometryError extends Error {
+         /** Machine-readable failure category. */
+         readonly code: GeometryErrorCode;
+         /** Operation and scalar facts associated with the failure. */
+         readonly context: GeometryErrorContext;
+         /**
+          * Creates a geometry error with a stable category, operation, and descriptive message.
+          *
+          * @param code - Machine-readable failure category.
+          * @param message - Human-readable diagnostic message.
+          * @param context - Operation and optional scalar facts. Defaults to `{ operation: "geometry" }`.
+          */
+         constructor(code: GeometryErrorCode, message: string, context?: GeometryErrorContext);
+     }
+
+     /** Stable categories for invalid inputs, topology, allocation, and runtime failures. */
+     export declare type GeometryErrorCode = "COMPLEXITY_LIMIT" | "DEGENERATE_GEOMETRY" | "INVALID_ARGUMENT" | "INVALID_MESH" | "INVALID_TOPOLOGY" | "INVALID_TOLERANCE" | "NON_FINITE_VALUE" | "SELF_INTERSECTION" | "SINGULAR_TRANSFORM" | "UNSUPPORTED_RUNTIME";
+
+     /** Serializable context attached to a geometry failure. */
+     export declare interface GeometryErrorContext {
+         /** Optional scalar facts useful for diagnostics without parsing the message. */
+         readonly details?: Readonly<Record<string, boolean | number | string>>;
+         /** Stable operation name, such as `normalizeLoop2` or `extrude`. */
+         readonly operation: string;
+     }
+
+     /**
+      * Tessellation policy for sampled geometry measured in millimetres.
+      */
+     export declare interface GeometryResolution {
+         /** Optional exact full-circle segment count, of at least three, bounded by the selected circular ceiling. */
+         readonly circularSegments?: number;
+         /** Maximum radial chord error in millimetres; defaults to 0.05. */
+         readonly maxChordError?: number;
+         /** Optional maximum sampled edge length in millimetres. */
+         readonly maxSegmentLength?: number;
+         /** Upper safety bound for a full circle; defaults to the selected maxCircularSegments (512 by default). */
+         readonly maximumSegments?: number;
+         /** Lower full-circle segment count; defaults to 16 or a lower selected circular ceiling. */
+         readonly minimumSegments?: number;
+     }
+
+     /** Explicit allocation ceilings for pure sampling and host-owned modeling operations. */
+     export declare interface GeometrySamplingLimits {
+         /** Maximum points in one sampled path or placement/frame result. */
+         readonly maxPathPoints: number;
+         /** Maximum aggregate points in one sampled profile or Section. */
+         readonly maxProfilePoints: number;
+         /** Maximum points in one profile swept along a path. */
+         readonly maxSweepProfilePoints: number;
+         /** Maximum segments around one complete circle. */
+         readonly maxCircularSegments: number;
+     }
+
+     /** Optional overrides for MetaMesh's geometry comparison policy. */
+     export declare interface GeometryToleranceOptions {
+         /** Absolute distance floor in model units. Must be finite and greater than zero. */
+         readonly absolute?: number;
+         /** Angular comparison threshold in radians. Must be finite and greater than zero. */
+         readonly angular?: number;
+         /** Dimensionless scale multiplier. Must be finite and non-negative. */
+         readonly relative?: number;
+     }
+
+     /** Returns one recommended metric clearance-hole diameter in millimetres. */
+     export declare function getMetricClearanceHole(size: MetricFastenerSize, fit?: ClearanceHoleFit): number;
+
+     /** Returns the immutable standards record for one supported metric size. */
+     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.
+      *
+      * @example Sample a closed wavy mesh
+      * ```ts
+      * heightfieldMesh({
+      *   size: [30, 20], segments: [24, 16],
+      *   height: ([x, y]) => 3 + Math.cos(x / 5) * Math.cos(y / 5),
+      * });
+      * ```
+      */
+     export declare function heightfieldMesh(options: HeightfieldOptions, limits?: HeightfieldMeshLimits): TriangleMesh;
+
+     /** 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];
+         /** 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;
+         /** 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. */
+     export declare interface HeightfieldPreflight {
+         /** Number of grid points and height callback evaluations. */
+         readonly sampleCount: number;
+         /** Number of allocated XYZ vertices. */
+         readonly vertexCount: number;
+         /** Number of allocated indexed triangles. */
+         readonly triangleCount: number;
+         /** Total bytes of Float32 positions and Uint32 indices. */
+         readonly byteCount: number;
+     }
+
+     /** Runtime-neutral options for the dedicated helical ridge mesher. */
+     export declare interface HelicalThreadRidgeMeshOptions {
+         /**
+          * Optional bottom/top ridge-end treatments. Standalone ridges honor the requested boundaries;
+          * BOSL2-style non-cut lead-in scaling is available on complete thread solids.
+          */
+         readonly ends?: ThreadEndTreatmentOptions;
+         /** Helix direction. Default: `right`. */
+         readonly handedness?: ThreadHandedness;
+         /** Total threaded axial length in millimetres. */
+         readonly length: number;
+         /** Explicit output and circular allocation ceilings. */
+         readonly limits?: Partial<ModelingLimits>;
+         /** Nominal major diameter before any caller-owned fit compensation. */
+         readonly majorDiameter: number;
+         /** Angular offset of the first start in degrees. Default: `0`. */
+         readonly phaseDegrees?: number;
+         /** Validated periodic profile repeated around the shaft. */
+         readonly profile: ThreadProfile;
+         /** Optional circular-resolution policy. */
+         readonly resolution?: GeometryResolution;
+         /** Number of evenly phased starts. Default: `1`. */
+         readonly starts?: number;
+         /** Optional numerical tolerance overrides. */
+         readonly tolerance?: GeometryToleranceOptions;
+     }
+
+     /** Options for a complete threaded-cylinder mesh; base semantics match the ridge builder. */
+     export declare interface HelicalThreadSolidMeshOptions extends HelicalThreadRidgeMeshOptions {
+         /** Apply a 45-degree radial bevel at the lower target face. */
+         readonly bevelBottom?: boolean;
+         /** Lower bevel size override. Takes precedence over `bevelSize`. */
+         readonly bevelBottomSize?: number;
+         /** Distance of each bevel target face inward from the corresponding mesh end. */
+         readonly bevelOffset?: number;
+         /** `inset` trims an external rod; `outset` expands an internal cutter. */
+         readonly bevelMode?: "inset" | "outset";
+         /** Axial and radial bevel size. Defaults to the profile depth. */
+         readonly bevelSize?: number;
+         /** Apply a 45-degree radial bevel at the upper target face. */
+         readonly bevelTop?: boolean;
+         /** Upper bevel size override. Takes precedence over `bevelSize`. */
+         readonly bevelTopSize?: number;
+     }
+
+     /** Conservative allocation facts resolved before constructing a direct thread solid mesh. */
+     export declare interface HelicalThreadSolidMeshPreflight {
+         /** Uniform axial intervals required only by a requested physical segment-length limit. */
+         readonly axialIntervals: number;
+         /** Start-aligned full-circle segment count used by the surface mesh. */
+         readonly circularSegments: number;
+         /** Conservative surface-row count across profile breaks, ends, and bevel stations. */
+         readonly estimatedRows: number;
+         /** Conservative triangle count used by the selected output allocation policy. */
+         readonly estimatedTriangles: number;
+     }
+
+     /** Identity transform, safe to share because it is frozen. */
+     export declare const IDENTITY_TRANSFORM3: Transform3;
+
+     /** Options for a compensated internal-thread subtraction tool along +Z. */
+     export declare interface InternalThreadCutterOptions extends Omit<HelicalThreadRidgeMeshOptions, "majorDiameter">, ThreadBevelOptions {
+         /** Printable fit or caller-calibrated allowances. Default: `normal`. */
+         readonly fit?: PrintableThreadFit | PrintableThreadFitPolicy;
+         /** Nominal major diameter before female compensation and faceting correction. */
+         readonly nominalMajorDiameter: number;
+     }
+
+     /**
+      * Inverts a finite, non-singular affine transform.
+      *
+      * @param transform - Transform to invert.
+      * @returns A new frozen transform whose composition with the input is identity.
+      */
+     export declare function inverseTransform3(transform: Transform3): Transform3;
+
+     /**
+      * Recognizes structured geometry errors from separately bundled Modeling copies in the same realm.
+      * Ordinary errors and unmarked code-shaped objects are rejected. The marker is execution-local and
+      * does not survive structured cloning; worker protocols carry their own serialized error envelope.
+      */
+     export declare function isGeometryError(value: unknown): value is GeometryError;
+
+     /**
+      * Concatenates meshes into one indexed mesh without welding coincident vertices.
+      *
+      * Inputs are validated and never mutated. Face order and winding remain stable.
+      *
+      * @param meshes - One or more meshes to concatenate.
+      * @returns Fresh typed arrays with indices offset to their source vertex ranges.
+      * @throws {@link GeometryError} When no mesh is supplied or an input is invalid.
+          */
+      export declare function joinTriangleMeshes(meshes: readonly TriangleMesh[]): TriangleMesh;
+
+      /** Returns Euclidean vector length in the vector's coordinate units. */
+      export declare const length3: (vector: Vec3) => number;
+
+      /** Linearly interpolates two vectors; `t` is dimensionless and may extrapolate. */
+      export declare const lerp3: (a: Vec3, b: Vec3, t: number) => Vec3;
+
+      /** Straight planar curve in millimetres. */
+      export declare interface LineCurve2 {
+          /** Selects straight interpolation between the two endpoints. */
+          readonly kind: "line";
+          /** Initial XY point in millimetres. */
+          readonly start: Vec2;
+          /** Final XY point in millimetres. */
+          readonly end: Vec2;
+      }
+
+      /** Straight spatial curve in millimetres. */
+      export declare interface LineCurve3 {
+          /** Selects straight interpolation between the two endpoints. */
+          readonly kind: "line";
+          /** Initial XYZ point in millimetres. */
+          readonly start: Vec3;
+          /** Final XYZ point in millimetres. */
+          readonly end: Vec3;
+      }
+
+      /** Deterministic ordered edge subdivision or bounded geometric vertex association. */
+      export declare type LoftCorrespondence = "direct" | "reindex" | "fast-distance" | "distance";
+
+      /**
+       * Lofts simple point loops at z heights or explicit right-handed frames, in input order.
+       *
+       * An explicit correspondence method is required. CCW-normalized loops retain their
+       * seam and original vertices; unequal counts gain subdivisions or repeated fan slots.
+       * Both ends use ear-clipped caps, supporting concave profiles without center fans.
+       * Intermediate slices interpolate placed world vertices, never frame axes.
+       * Transformed coordinates must fit finite Float32 mesh storage.
+       *
+       * @example Loft with explicit point correspondence
+       * ```ts
+       * const bottom = rectangleLoop({ size: [20, 12] });
+       * const top = rectangleLoop({ size: [30, 20], treatment: { kind: "round", radius: 3 } });
+       * loftMesh([{ profile: bottom, z: 0 }, { profile: top, z: 30 }], { correspondence: "reindex" });
+       * ```
+       */
+      export declare function loftMesh(stations: readonly LoftMeshStation[], options: LoftOptions): TriangleMesh;
+
+      /** One point-data profile at a height or explicit right-handed spatial frame. */
+      export declare type LoftMeshStation = LoftPlacement & {
+          /** Ordered finite XY boundary points with an implicit closing edge. */
+          readonly profile: Loop2;
+      };
+
+      /**
+       * Shared controls for native and pure lofts. Point data and arbitrary Sections require explicit correspondence.
+       */
+      export declare interface LoftOptions {
+          /** One method or one per consecutive station gap. Omitted preserves known landmarks, including circle/ellipse-to-rectangle corners, or maps other unlike primitive seams directly. */
+          readonly correspondence?: LoftCorrespondence | readonly LoftCorrespondence[];
+          /** Extra points follow edge length or distribute equally across existing segments. Defaults to perimeter for direct/reindex, or segments when any distance method is selected; distance methods require segments. */
+          readonly distribution?: "perimeter" | "segments";
+          /** Positive integer point-density multiplier, uniformly or per input profile. Original vertices are retained. Defaults to one. */
+          readonly refine?: number | readonly number[];
+          /** Nonnegative count of world-linearly interpolated profiles, uniformly or per gap. Defaults to zero. */
+          readonly slices?: number | readonly number[];
+          /** Physical curve policy for retained primitives, and maximum edge length for point data. Exact primitive curve counts take precedence. */
+          readonly resolution?: GeometryResolution;
+          /** Explicit output and sampling budgets; native operations may only lower host ceilings. */
+          readonly limits?: Partial<ModelingLimits>;
+      }
+
+      /**
+       * A horizontal XY station height, or an explicit right-handed spatial frame, never both.
+       */
+      export declare type LoftPlacement = {
+          /** Horizontal XY station height in millimetres. */
+          readonly z: number;
+          /** Excluded when a horizontal height is supplied. */
+          readonly frame?: never;
+      } | {
+          /** Right-handed orthonormal station frame in world coordinates. */
+          readonly frame: Frame3;
+          /** Excluded when an explicit spatial frame is supplied. */
+          readonly z?: never;
+      };
+
+      /**
+       * A closed two-dimensional boundary whose first point is not repeated at the end.
+       *
+       * Polygon exteriors are counter-clockwise and holes are clockwise. Algorithms
+       * may reject duplicate adjacent points or fewer than three effective vertices.
+       */
+      export declare type Loop2 = readonly Vec2[];
+
+      /** Returns true when a point lies inside or on the boundary of a loop. */
+      export declare function loopContainsPoint(loop: Loop2, point: Vec2): boolean;
+
+      /**
+       * Explicitly matches identified component/contour/span topology across a family.
+       * Every paired span uses the maximum physical subdivision count requested by any member.
+       * Cubics share a checked uniform parameter grid, including grids selected by exact paired requests.
+       * Input order and winding are preserved. Collapsed spans retain repeated logical slots, which
+       * the engine maps to shared physical vertices while omitting degenerate faces.
+       *
+       * @example Match named rectangle landmarks
+       * ```ts
+       * matchProfiles([
+       *   rectangleProfile({ size: [20, 12] }),
+       *   rectangleProfile({ size: [30, 20], treatment: { kind: "round", radius: 3 } }),
+       * ]);
+       * ```
+       */
+      export declare function matchProfiles(profiles: readonly Profile[], options?: MatchProfilesOptions): readonly CorrespondingProfile[];
+
+      /** Explicit family sampling settings; omitted values use physical package defaults. */
+      export declare interface MatchProfilesOptions {
+          /** Local physical sampling policy; exact interval counts take precedence. */
+          readonly resolution?: GeometryResolution;
+          /** Explicit per-profile and circular ceilings; the family also has a one-million-slot work bound. */
+          readonly limits?: Partial<GeometrySamplingLimits>;
+      }
+
+      /**
+       * Measures sampled kinematic interference over one tooth cycle of an internal gear pair.
+       *
+       * The driver and ring rotate in the same direction at their resolved tooth-count ratio. Each
+       * sampled pinion outline is subtracted from the ring's center-and-space opening; remaining area is
+       * solid overlap. This catches involute, tip, and trimming interference that a single assembled pose
+       * misses. It is a deterministic model check, not a certified gear-rating calculation.
+       */
+      export declare function measureInternalCylindricalGearPairMotion(spec: CylindricalGearPairSpec, options?: CylindricalGearPairMotionOptions): CylindricalGearPairMotionReport;
+
+      /**
+       * Measures bounds, surface area, and signed volume without changing the mesh.
+       *
+       * Signed volume is meaningful for a consistently wound closed mesh. Set
+       * `requireClosed` when measurements will be used as manufacturing assertions.
+       *
+       * @param mesh - Mesh to validate and measure.
+       * @param options - Validation policy applied before measurement.
+       * @returns Immutable deterministic scalar and bounds measurements.
+       */
+      export declare function measureTriangleMesh(mesh: TriangleMesh, options?: TriangleMeshValidationOptions): TriangleMeshMeasurements;
+
+      /**
+       * Axis-aligned bounds of a non-empty triangle mesh.
+       */
+      export declare interface MeshBounds {
+          /** Inclusive minimum XYZ coordinates. */
+          readonly min: Vec3;
+          /** Inclusive maximum XYZ coordinates. */
+          readonly max: Vec3;
+      }
+
+      /**
+       * Computes axis-aligned bounds for a non-empty mesh.
+       *
+       * @param mesh - Mesh whose finite complete vertices will be measured.
+       * @returns Fresh immutable minimum and maximum XYZ tuples.
+       * @throws {@link GeometryError} When the mesh is structurally invalid.
+       */
+      export declare const meshBounds: (mesh: TriangleMesh) => MeshBounds;
+
+      /**
+       * Curated metric modeling dimensions for clearance holes, regular hex nuts,
+       * and socket-head cap screws.
+       *
+       * Values are nominal reference dimensions intended for parametric envelopes.
+       * Manufacturing tolerances, coatings, and printer compensation remain caller
+       * responsibilities.
+       */
+      export declare const METRIC_FASTENER_STANDARDS: Readonly<{
+          /** Nominal M2 coarse-thread modeling dimensions. */
+          M2: MetricFastenerStandard;
+          /** Nominal M2.5 coarse-thread modeling dimensions. */
+          "M2.5": MetricFastenerStandard;
+          /** Nominal M3 coarse-thread modeling dimensions. */
+          M3: MetricFastenerStandard;
+          /** Nominal M4 coarse-thread modeling dimensions. */
+          M4: MetricFastenerStandard;
+          /** Nominal M5 coarse-thread modeling dimensions. */
+          M5: MetricFastenerStandard;
+          /** Nominal M6 coarse-thread modeling dimensions. */
+          M6: MetricFastenerStandard;
+          /** Nominal M8 coarse-thread modeling dimensions. */
+          M8: MetricFastenerStandard;
+          /** Nominal M10 coarse-thread modeling dimensions. */
+          M10: MetricFastenerStandard;
+          /** Nominal M12 coarse-thread modeling dimensions. */
+          M12: MetricFastenerStandard;
+      }>;
+
+      /** Metric fastener sizes included in the first mechanical standards table. */
+      export declare type MetricFastenerSize = "M2" | "M2.5" | "M3" | "M4" | "M5" | "M6" | "M8" | "M10" | "M12";
+
+      /** Small immutable metric fastener record for modeling common mating features. */
+      export declare interface MetricFastenerStandard {
+          /** Coarse thread pitch in millimetres. */
+          readonly coarsePitch: number;
+          /** Recommended clearance-hole diameters. */
+          readonly clearanceHoles: ClearanceHoleDimensions;
+          /** Regular hex-nut envelope. */
+          readonly hexNut: MetricHexNutDimensions;
+          /** Nominal fastener diameter in millimetres. */
+          readonly nominalDiameter: number;
+          /** Socket-head cap screw envelope and drive size. */
+          readonly socketCapHead: MetricSocketCapHeadDimensions;
+      }
+
+      /** Regular hex-nut envelope dimensions in millimetres. */
+      export declare interface MetricHexNutDimensions {
+          /** Nominal wrench size across flats. */
+          readonly acrossFlats: number;
+          /** Nominal full-nut thickness. */
+          readonly thickness: number;
+      }
+
+      /** Socket-head cap screw head and drive dimensions in millimetres. */
+      export declare interface MetricSocketCapHeadDimensions {
+          /** Nominal cylindrical head diameter. */
+          readonly diameter: number;
+          /** Nominal head height. */
+          readonly height: number;
+          /** Nominal internal hex key size across flats. */
+          readonly hexKey: number;
+      }
+
+      /**
+       * Returns the smallest unshifted full-depth external tooth count that avoids rack-cutter undercut.
+       *
+       * The normal-plane limit is `2 / sin²(alpha_n)`. Helical gears use the standard virtual tooth
+       * count `z_v = z / cos³(beta)`, so increasing helix angle can reduce the physical tooth count.
+       */
+      export declare function minimumCylindricalGearToothCountWithoutUndercut(spec?: Readonly<Pick<CylindricalGearSpec, "helixAngleDegrees" | "pressureAngleDegrees">>): number;
+
+      /** Aggregate manufacturing output ceilings selected by a trusted host. */
+      export declare interface ModelingLimits extends GeometrySamplingLimits {
+          /** Maximum number of named finalized parts. */
+          readonly maxParts: number;
+          /** Maximum aggregate output vertex count. */
+          readonly maxVertices: number;
+          /** Maximum aggregate output triangle count. */
+          readonly maxTriangles: number;
+          /** Maximum unique transferable output backing-buffer bytes. */
+          readonly maxBytes: number;
+      }
+
+      /** Normalizes a finite vector and rejects nonfinite lengths or lengths at or below `epsilon`. */
+      export declare const normalize3: (vector: Vec3, epsilon?: number) => Vec3;
+
+      /**
+       * Cleans and validates one closed loop.
+       *
+       * Adjacent duplicates and a repeated seam point are removed. Coordinates must
+       * be finite, the effective loop must contain at least three points, and the
+       * result must be simple and have non-zero area. Previously validated immutable results may be
+       * returned unchanged when their winding and tolerance policy match.
+       */
+      export declare function normalizeLoop2(input: readonly Vec2[], counterClockwise: boolean, tolerance?: GeometryToleranceOptions): Loop2;
+
+      /**
+       * Validates explicit polygon topology and normalizes its winding.
+       *
+       * Exteriors become CCW and holes clockwise. Every hole must lie strictly
+       * within its exterior and boundaries may not intersect. Previously validated immutable results
+       * may be returned unchanged under the same tolerance policy.
+       */
+      export declare function normalizePolygon2(polygon: Polygon2, tolerance?: GeometryToleranceOptions): Polygon2;
+
+      /**
+       * Validates a disjoint explicit region and returns immutable normalized data.
+       * Previously validated immutable results may be returned unchanged under the same tolerance policy.
+       */
+      export declare function normalizeRegion2(region: Region2, tolerance?: GeometryToleranceOptions): Region2;
+
+      /** An open radius/height outline; consumers own closure, mounting geometry, and wall policy. */
+      export declare interface OpenProfileCurve {
+          /** Initial radius/height anchor. */
+          readonly start: OpenProfilePoint;
+          /** Ordered chain of 1–31 straight or cubic segments. */
+          readonly segments: readonly OpenProfileSegment[];
+      }
+
+      /** Radius and upward height in millimetres, or in units converted by sampling scales. */
+      export declare interface OpenProfilePoint {
+          /** Nonnegative distance from the revolution axis. */
+          readonly radius: number;
+          /** Upward axial coordinate; anchors progress strictly upward. */
+          readonly height: number;
+      }
+
+      /** One straight or cubic segment of an open, upward-progressing radius/height outline. */
+      export declare type OpenProfileSegment = {
+          /** Straight segment discriminator. */
+          readonly type: "line";
+          /** Next strictly higher anchor. */
+          readonly end: OpenProfilePoint;
+      } | {
+          /** Cubic Bézier segment discriminator. */
+          readonly type: "cubic";
+          /** Outgoing control, with height between the start and second control. */
+          readonly control1: OpenProfilePoint;
+          /** Incoming control, with height between the first control and end. */
+          readonly control2: OpenProfilePoint;
+          /** Next strictly higher anchor. */
+          readonly end: OpenProfilePoint;
+      };
+
+      /**
+       * Improves pathological planar triangulation with bounded legal diagonal flips.
+       *
+       * The operation changes indices only: it never moves, adds, welds, or removes vertices; never
+       * crosses a coplanar-patch boundary; and never changes the face count. Each accepted flip improves
+       * a deterministic ordering of triangle angles, aspect ratio, diagonal locality, and local
+       * incidence/valence concentration. Unsupported input or a failed final integrity check returns the
+       * exact original mesh object. Malformed buffers and the configured analysis complexity limit throw.
+       *
+       * @param mesh - Closed, consistently wound indexed triangle mesh in arbitrary consistent units.
+       * @param options - Patch eligibility, numeric tolerance, and deterministic work bounds.
+       * @returns Optimized connectivity and before/after diagnostics, or an unchanged safe fallback.
+       */
+      export declare function optimizePlanarPatches(mesh: TriangleMesh, options?: PlanarMeshOptimizationOptions): PlanarMeshOptimizationResult;
+
+      /** An ordered, open sequence of two-dimensional points. */
+      export declare type Path2 = readonly Vec2[];
+
+      /**
+       * An ordered, open sequence of three-dimensional points.
+       */
+      export declare type Path3 = readonly Vec3[];
+
+      /** Orthonormal right-handed frame sampled along a path. */
+      export declare interface PathFrame {
+          /** Unit path tangent. */
+          readonly tangent: Vec3;
+          /** Unit transported profile X axis. */
+          readonly normal: Vec3;
+          /** Unit profile Y axis equal to tangent × normal. */
+          readonly binormal: Vec3;
+      }
+
+      /**
+       * Returns total sampled 3D path length, or zero for an empty path.
+       */
+      export declare const pathLength: (path: readonly Vec3[], limits?: Partial<GeometrySamplingLimits>) => number;
+
+      /**
+       * Supplies a profile-X orientation guide for each original normalized sweep station.
+       *
+       * @param point - Current XYZ path point in model units.
+       * @param index - Zero-based index of `point` in the normalized authored sweep path.
+       * @returns A finite guide vector that is not parallel to the local path tangent.
+       */
+      export declare type PathNormalGuide = (point: Vec3, index: number) => Vec3;
+
+      /** Position and unit tangent for one path-distributed item. */
+      export declare interface PathPlacement {
+          /** Interpolated point on the sampled path. */
+          readonly position: Vec3;
+          /** Unit tangent of the path segment containing the placement. */
+          readonly tangent: Vec3;
+      }
+
+      /** Stable reason why planar optimization returned the original mesh unchanged. */
+      export declare type PlanarMeshOptimizationFallbackReason = "candidate-boundary-changed" | "candidate-measurements-changed" | "candidate-not-closed-oriented-manifold" | "candidate-quality-regressed" | "input-not-closed-oriented-manifold";
+
+      /** Options controlling bounded, connectivity-only optimization of planar triangle patches. */
+      export declare interface PlanarMeshOptimizationOptions extends TriangleMeshQualityOptions {
+          /**
+           * Maximum attempted edge evaluations. By default this is twenty times the initial candidate
+           * edge count, capped at `1000000`.
+           */
+          readonly maximumFlipAttempts?: number;
+          /** Maximum times one edge may be reconsidered after neighbouring flips. Defaults to `12`. */
+          readonly maximumEdgeRevisits?: number;
+          /** Maximum triangles allowed in one selected patch. Defaults to `50000`. */
+          readonly maximumPatchTriangleCount?: number;
+          /** Maximum cumulative triangles across selected patches. Defaults to `200000`. */
+          readonly maximumProcessedTriangleCount?: number;
+          /** Minimum triangles required before a planar patch is eligible. Defaults to `8`. */
+          readonly minimumPatchTriangleCount?: number;
+          /** Select patches whose worst normalized aspect ratio exceeds this value. Defaults to `12`. */
+          readonly triggerMaximumAspectRatio?: number;
+          /** Select patches whose largest per-vertex triangle share exceeds this ratio. Defaults to `0.2`. */
+          readonly triggerMaximumFanRatio?: number;
+          /** Select patches whose largest vertex triangle incidence exceeds this value. Defaults to `16`. */
+          readonly triggerMaximumVertexTriangleIncidence?: number;
+          /** Select patches whose smallest interior angle is below this many degrees. Defaults to `8`. */
+          readonly triggerMinimumAngleDegrees?: number;
+      }
+
+      /** Outcome of bounded planar-patch optimization, including before/after diagnostics. */
+      export declare interface PlanarMeshOptimizationResult {
+          /** Quality report for the returned mesh; equal to `before` on unchanged or fallback results. */
+          readonly after: TriangleMeshQualityReport;
+          /** Quality report for the supplied mesh. */
+          readonly before: TriangleMeshQualityReport;
+          /** Whether a work bound stopped evaluation while eligible work remained. */
+          readonly budgetExhausted: boolean;
+          /** Whether the returned mesh has different triangle connectivity. */
+          readonly changed: boolean;
+          /** Safety reason when candidate validation rejected optimization or input topology was unsupported. */
+          readonly fallbackReason?: PlanarMeshOptimizationFallbackReason;
+          /** Number of accepted legal diagonal flips. */
+          readonly flipCount: number;
+          /** Returned mesh; unchanged results preserve the exact input object. */
+          readonly mesh: TriangleMesh;
+          /** Number of planar patches in which at least one edge was flipped. */
+          readonly optimizedPatchCount: number;
+          /** Number of triggered patches omitted because a configured triangle bound would be exceeded. */
+          readonly skippedPatchCount: number;
+      }
+
+      /** Quality measurements for one edge-connected coplanar triangle patch. */
+      export declare interface PlanarPatchQuality {
+          /** Number of edges separating this patch from another plane or the mesh boundary. */
+          readonly boundaryEdgeCount: number;
+          /** Number of connected boundary loops; holes contribute additional loops. */
+          readonly boundaryLoopCount: number;
+          /** Maximum ratio of one vertex's incident patch triangles to the patch triangle count. */
+          readonly fanRatio: number;
+          /** Lowest source triangle index in this deterministic patch. */
+          readonly firstTriangleIndex: number;
+          /** Stable zero-based patch identifier in first-triangle order. */
+          readonly id: number;
+          /** Number of edges shared by two triangles within this patch. */
+          readonly internalEdgeCount: number;
+          /** Largest normalized triangle aspect ratio; an equilateral triangle has ratio `1`. */
+          readonly maximumTriangleAspectRatio: number;
+          /** Largest number of patch triangles incident to one vertex. */
+          readonly maximumVertexTriangleIncidence: number;
+          /** Largest number of distinct patch neighbours connected to one vertex. */
+          readonly maximumVertexValence: number;
+          /** Smallest interior triangle angle in degrees. */
+          readonly minimumTriangleAngleDegrees: number;
+          /** Consistently wound unit normal for the patch plane. */
+          readonly normal: Vec3;
+          /** Plane offset in `dot(normal, position) = planeOffset` form, in model units. */
+          readonly planeOffset: number;
+          /** Total patch area in squared model units. */
+          readonly surfaceArea: number;
+          /** Number of triangles in this patch. */
+          readonly triangleCount: number;
+          /** Number of distinct indexed vertices referenced by this patch. */
+          readonly vertexCount: number;
+      }
+
+      /**
+       * One bounded two-dimensional polygon.
+       *
+       * `outer` is counter-clockwise and each hole is clockwise. Boundary arrays omit
+       * their duplicated closing point. Holes must lie inside `outer` and must not
+       * intersect each other or the exterior.
+       */
+      export declare interface Polygon2 {
+          /** Clockwise interior boundaries, each omitting its duplicated closing point. */
+          readonly holes: readonly Loop2[];
+          /** Counter-clockwise exterior boundary, omitting its duplicated closing point. */
+          readonly outer: Loop2;
+      }
+
+      /**
+       * Equal arc-length sampling of an open path or an implicitly closed loop.
+       */
+      export declare interface PolylineResamplingOptions extends CurveSamplingOptions {
+          /** Exact equal arc-length intervals; closed paths require at least three. */
+          readonly segments?: number;
+          /** Includes the closing edge without repeating the first output point; defaults to false. */
+          readonly closed?: boolean;
+      }
+
+      /** Checks regular-grid dimensions and bounds allocation before evaluating any height samples. */
+      export declare function preflightHeightfield(options: HeightfieldOptions, limits?: HeightfieldMeshLimits): HeightfieldPreflight;
+
+      /**
+       * Validates a direct thread solid and returns its conservative allocation estimate without
+       * constructing vertex or index buffers.
+       */
+      export declare function preflightHelicalThreadSolidMesh(options: HelicalThreadSolidMeshOptions): HelicalThreadSolidMeshPreflight;
+
+      /** Preflights the exact extended mesh used by the internal thread cutter constructor. */
+      export declare function preflightInternalThreadCutter(options: InternalThreadCutterOptions): HelicalThreadSolidMeshPreflight;
+
+      /**
+       * Preflights bounded SVG geometry without browser or Manifold dependencies.
+       *
+       * @param svg - Complete SVG XML source, limited to 256 KiB of UTF-8.
+       * @param options - Physical flattening and viewport-origin controls.
+       * @returns The canonical normalized region plus bounded source, topology, and safe-repair facts.
+       */
+      export declare function preflightSvgRegion(svg: string, options?: SvgImportOptions): SvgRegionPreflight;
+
+      /**
+       * Resolves a nut's exact body/cutter chamfer and preflights its extended thread mesh without
+       * allocating Manifold WASM objects.
+       */
+      export declare function preflightThreadedNut(options: ThreadedNutOptions): ThreadedNutPreflight;
+
+      /** Preflights the exact compensated direct mesh used by the threaded rod constructor. */
+      export declare function preflightThreadedRod(options: ThreadedRodOptions): HelicalThreadSolidMeshPreflight;
+
+      /** Placement shared by solid and filled-section factories. */
+      export declare interface PrimitivePlacement {
+          /** Applied after local construction; Section placement must preserve the XY plane. */
+          readonly placement?: PrimitivePlacementOptions;
+      }
+
+      /** Maps an explicit or named shape-local attachment anchor onto a world-space anchor. */
+      export declare interface PrimitivePlacementOptions {
+          /** Shape-local source frame or a named primitive anchor such as bottom. */
+          readonly source: Anchor3 | string;
+          /** World-space target frame in millimetres. */
+          readonly target: Anchor3;
+          /** Align outward directions face-to-face or in parallel. Defaults to opposed. */
+          readonly alignment?: "opposed" | "same";
+          /** Finite separation along the target direction in millimetres. Defaults to zero. */
+          readonly gap?: number;
+          /** Finite additional roll around the attached direction in degrees. Defaults to zero. */
+          readonly spinDegrees?: number;
+          /** Explicit numeric comparison overrides for anchor normalization. */
+          readonly tolerance?: GeometryToleranceOptions;
+      }
+
+      /**
+       * Conservative baseline print-fit policies in millimetres.
+       *
+       * These are modeling defaults, not manufacturing guarantees. A caller should
+       * calibrate them for its printer, material, layer height, and thread scale.
+       */
+      export declare const PRINTABLE_THREAD_FIT_POLICIES: Readonly<{
+          /** Small baseline clearance for calibrated, accurate printers. */
+          tight: PrintableThreadFitPolicy;
+          /** General-purpose baseline clearance. */
+          normal: PrintableThreadFitPolicy;
+          /** Generous baseline clearance for rougher prints or easy assembly. */
+          loose: PrintableThreadFitPolicy;
+      }>;
+
+      /**
+       * Named baseline fit policies for calibrated FDM-style printed threads.
+       */
+      export declare type PrintableThreadFit = "tight" | "normal" | "loose";
+
+      /**
+       * Explicit radial and axial allowances for a mating printed thread pair.
+       *
+       * Male and female radial values are applied independently, so their sum is the
+       * assembled radial clearance. Values are millimetres and intentionally do not
+       * encode printer, material, or process calibration.
+       */
+      export declare interface PrintableThreadFitPolicy {
+          /** Nominal axial backlash available between opposing flanks. */
+          readonly axialBacklash: number;
+          /** Radial increase applied to an internal thread envelope. */
+          readonly femaleRadialOutset: number;
+          /** Radial reduction applied to an external thread envelope. */
+          readonly maleRadialInset: number;
+      }
+
+      /** An explicit component/contour/span topology, before shared family sampling. */
+      export declare interface Profile {
+          /** Ordered components with explicit contour identities. */
+          readonly components: readonly ProfileComponent2[];
+      }
+
+      /** One component and its explicitly identified holes. */
+      export declare interface ProfileComponent2 {
+          /** Stable canonical lowercase identity; unique within the containing topology or output. */
+          readonly id: string;
+          /** Counterclockwise outer contour. */
+          readonly outer: ProfileContour2;
+          /** Clockwise hole contours belonging to this component. */
+          readonly holes: readonly ProfileContour2[];
+      }
+
+      /** Ordered, closed spans. Outer winding is CCW and hole winding is CW. */
+      export declare interface ProfileContour2 {
+          /** Stable canonical lowercase identity; unique within the containing topology or output. */
+          readonly id: string;
+          /** Ordered identified spans; the last endpoint meets the first start. */
+          readonly spans: readonly ProfileSpan2[];
+      }
+
+      /** A deliberately sampled, inward-only corner profile with exact polyline geometry. */
+      export declare interface ProfiledEdgeTreatment {
+          /** Selects an explicit corner profile; no analytic curve is inferred from its samples. */
+          readonly kind: "profile";
+          /**
+           * Millimetre setbacks on adjoining surfaces, from [positive, 0] to [0, positive].
+           * First coordinates decrease and second coordinates increase. Cylinder/extrusion ends use
+           * cap inset first, side setback second; planar corners use incoming then outgoing edges.
+           */
+          readonly profile: readonly Vec2[];
+      }
+
+      /** An identified line, circular arc, or cubic Bézier between corresponding landmarks. */
+      export declare type ProfileSpan2 = {
+          /** Stable canonical lowercase identity; unique within the containing topology or output. */
+          readonly id: string;
+          /** Optional exact span interval count; the family uses the largest requested count. */
+          readonly segments?: number;
+          /** Optional span-local physical sampling over the family's resolution; exact intervals take precedence. */
+          readonly resolution?: GeometryResolution;
+      } & ({
+          /** Selects a straight span. */
+          readonly kind: "line";
+          /** Start point in millimetres. */
+          readonly start: Vec2;
+          /** End point in millimetres. */
+          readonly end: Vec2;
+      } | {
+          /** Selects the geometric curve or span family. */
+          readonly kind: "arc";
+          /** Center point in millimetres. */
+          readonly center: Vec2;
+          /** Circular radius in millimetres. */
+          readonly radius: number;
+          /** Initial counterclockwise angle in degrees. */
+          readonly startDegrees: number;
+          /** Signed counterclockwise angular sweep in degrees. */
+          readonly sweepDegrees: number;
+      } | {
+          /** Selects a cubic Bézier span with the same coordinates as CubicBezierCurve2. */
+          readonly kind: "cubic";
+          /** Start point in millimetres. */
+          readonly start: Vec2;
+          /** First control point in millimetres. */
+          readonly control1: Vec2;
+          /** Second control point in millimetres. */
+          readonly control2: Vec2;
+          /** End point in millimetres. */
+          readonly end: Vec2;
+      });
+
+      /** Removes the component parallel to a normalized plane normal. */
+      export declare const projectOntoPlane3: (vector: Vec3, normal: Vec3) => Vec3;
+
+      /** Resolved pitch-line dimensions for a finite rack segment. */
+      export declare interface RackPitchDimensions {
+          /** Tooth height above the pitch line, in millimetres. */
+          readonly addendum: number;
+          /** Tooth root depth below the pitch line, in millimetres. */
+          readonly dedendum: number;
+          /** Signed helix angle, in radians. */
+          readonly helixAngleRadians: number;
+          /** Total pitch-line length for the requested tooth count, in millimetres. */
+          readonly length: number;
+          /** Transverse linear pitch between teeth, in millimetres. */
+          readonly pitch: number;
+          /** Transverse pressure angle, in radians. */
+          readonly pressureAngleRadians: number;
+          /** Tangential tooth thickness at the pitch line, in millimetres. */
+          readonly toothThicknessAtPitch: number;
+          /** Number of complete teeth represented by the segment. */
+          readonly toothCount: number;
+          /** Normal module supplied by the caller, in millimetres. */
+          readonly module: number;
+      }
+
+      /** Normal-plane inputs for a finite rack pitch segment. */
+      export declare interface RackPitchSpec {
+          /** Tangential tooth-thickness reduction at the pitch line, in millimetres. */
+          readonly backlash?: number;
+          /** Dedendum clearance as a multiple of normal module; defaults to `0.25`. */
+          readonly clearanceFactor?: number;
+          /** Signed helix angle in degrees; zero creates a straight rack. */
+          readonly helixAngleDegrees?: number;
+          /** Normal module in millimetres per tooth. */
+          readonly module: number;
+          /** Normal pressure angle in degrees; defaults to 20 degrees. */
+          readonly pressureAngleDegrees?: number;
+          /** Number of complete rack teeth represented by the segment. */
+          readonly toothCount: number;
+      }
+
+      /**
+       * Radial dimensions refer to polygon vertices or compensate faceting to meet polygon faces.
+       */
+      export declare type RadialSizing = "vertex" | "face";
+
+      /**
+       * Nominal radial sizing shared by circular and regular polygon construction.
+       */
+      export declare interface RadialSizingOptions {
+          /** Explicit sampling ceilings; bound modeling operations may only lower the host policy. */
+          readonly limits?: Partial<GeometrySamplingLimits>;
+          /** Vertex sizing is inscribed; face sizing circumscribes the nominal radius. Defaults to vertex. */
+          readonly sizing?: RadialSizing;
+      }
+
+      /** A rectangle corner, including an explicitly untreated corner in a treatment tuple. */
+      export declare type RectangleCornerTreatment = EdgeTreatment | {
+          /** Leaves this corner untreated. */
+          readonly kind: "square";
+      };
+
+      /** Corner treatments ordered top-right, top-left, bottom-left, bottom-right. */
+      export declare type RectangleCornerTreatments = readonly [
+      topRight: RectangleCornerTreatment,
+      topLeft: RectangleCornerTreatment,
+      bottomLeft: RectangleCornerTreatment,
+      bottomRight: RectangleCornerTreatment
+      ];
+
+      /**
+       * Creates an immutable CCW rectangle loop. Round radius zero is square; tangent saturated endpoints occur once.
+       *
+       * @example Rounded rectangle outline
+       * ```ts
+       * rectangleLoop({ size: [30, 20], treatment: { kind: "round", radius: 3 } });
+       * ```
+       */
+      export declare function rectangleLoop(options: RectangleLoopOptions): Loop2;
+
+      /**
+       * Shared rectangle dimensions, origin and uniform or per-corner treatment.
+       */
+      export declare interface RectangleLoopOptions {
+          /** Positive uniform size or explicit XY extents in millimetres. */
+          readonly size: number | Vec2;
+          /** Center on XY; otherwise the minimum corner is the origin. Defaults to true. */
+          readonly center?: boolean;
+          /** Uniform treatment or four corner treatments. Exact round segments describe a complete circle and must divide by four. */
+          readonly treatment?: EdgeTreatment | RectangleCornerTreatments;
+          /** Explicit sampling ceiling for the complete output profile. */
+          readonly limits?: Partial<GeometrySamplingLimits>;
+      }
+
+      /**
+       * Creates an identified rectangle whose edge/corner spans survive zero and saturated round radii. Outer winding is CCW.
+       *
+       * @example Retain rectangle landmarks
+       * ```ts
+       * rectangleProfile({ size: [30, 20], treatment: { kind: "round", radius: 3 } });
+       * ```
+       */
+      export declare function rectangleProfile(options: RectangleProfileOptions): Profile;
+
+      /** Shared rectangle options with an identified component for explicit profile families. */
+      export declare interface RectangleProfileOptions extends RectangleLoopOptions {
+          /** Canonical component identity of at most 64 characters. Defaults to body. */
+          readonly id?: string;
+      }
+
+      /** A two-dimensional region represented by disjoint filled polygons. */
+      export declare type Region2 = readonly Polygon2[];
+
+      /**
+       * Returns the total filled area of a normalized region in square millimetres.
+       *
+       * Each polygon contributes its outer-loop area minus the areas of its holes. An empty region has
+       * zero area. Call {@link normalizeRegion2} first when input winding or topology is not already
+       * canonical.
+       *
+       * @param region - Normalized disjoint polygons with CCW outers and clockwise holes.
+       * @returns Total filled area in square millimetres.
+       */
+      export declare function regionArea(region: Region2): number;
+
+      /** Returns finite axis-aligned bounds for a non-empty region. */
+      export declare function regionBounds(region: Region2): Bounds2;
+
+      /**
+       * Creates a centered CCW point loop with vertex or face radial sizing and an implicit seam.
+       *
+       * @example Hexagon sized to its faces
+       * ```ts
+       * regularPolygonLoop({ radius: 10, sides: 6, sizing: "face" });
+       * ```
+       */
+      export declare const regularPolygonLoop: (options: RegularPolygonLoopOptions) => readonly Vec2[];
+
+      /** Exact regular polygon dimensions and counterclockwise degree rotation. */
+      export declare interface RegularPolygonLoopOptions extends RadialSizingOptions {
+          /** Positive nominal radius in millimetres, interpreted according to sizing. */
+          readonly radius: number;
+          /** Exact side count from three through the selected profile sampling ceiling. */
+          readonly sides: number;
+          /** Counterclockwise rotation in degrees; defaults to zero with a vertex on +X. */
+          readonly rotationDegrees?: number;
+      }
+
+      /** Resamples a planar polyline with the same point, tangent, seam and budget guarantees as 3D.
+       * @remarks Only final 2D output vectors are copied and frozen. No immutable 3D intermediate is built.
+       * @example
+       * ```ts
+       * const loop = resamplePolyline2([[0,0],[5,0],[5,5],[0,5]], {closed: true, segments: 20});
+       * ```
+       */
+      export declare function resamplePolyline2(path: readonly Vec2[], options?: PolylineResamplingOptions): SampledCurve2;
+
+      /**
+       * Resamples a spatial polyline at equal arc lengths with directed outgoing tangents.
+       * @remarks Open paths retain both endpoints; closed paths include the closing edge and omit the
+       * repeated seam. Repeated adjacent inputs and explicit closing duplicates are removed. Physical
+       * maxSegmentLength bounds arc-length intervals; exact counts override that policy. Output edges
+       * may bridge original corners. Sampling never silently lowers the requested detail to fit its budget.
+       * @example
+       * ```ts
+       * const path = resamplePolyline3([[0,0,0],[10,0,0],[10,10,0]], {segments: 8});
+       * ```
+       */
+      export declare function resamplePolyline3(path: readonly Vec3[], options?: PolylineResamplingOptions): SampledCurve3;
+
+      /**
+       * Resolves a deterministic full-circle count aligned to reusable topology factors.
+       *
+       * `alignTo` must be non-empty and contain only positive safe integers. Its checked least common
+       * multiple defines the alignment grid. An exact `segments` value wins over
+       * `resolution.circularSegments` and adaptive sampling, but is never rounded: it must already be
+       * aligned and meet `minimumSegments`. Adaptive counts are rounded upward and fail with
+       * `COMPLEXITY_LIMIT` when the aligned result exceeds the configured safety cap.
+       *
+       * @param radius - Positive circle radius in millimetres used for adaptive physical sampling.
+       * @param options - Required alignment factors plus optional floor, exact count, and resolution.
+       * @returns An aligned full-circle segment count.
+       * @throws {@link GeometryError} when radius, alignment factors, segment floors, or resolution are
+           * invalid, or alignment exceeds safe integer or configured complexity limits.
+           * @see {@link resolveCircularSegments}
+           *
+           * @example
+           * ```ts
+           * const alignedSegments = resolveAlignedCircularSegments(20, { alignTo: [4, 6] });
+           * ```
+           */
+       export declare function resolveAlignedCircularSegments(radius: number, options: AlignedCircularSegmentsOptions): number;
+
+       /**
+        * Resolves the number of segments needed for a circular arc.
+        *
+        * Full-circle limits and exact circular counts are scaled to the requested angular span, matching
+        * the reusable BOSL2-style convention while retaining at least one segment.
+        *
+        * @param radius - Arc radius in millimetres.
+        * @param angleDegrees - Non-zero signed sweep angle no greater than 360 degrees in magnitude.
+        * @param policy - Optional operation-level policy over the active model scope.
+        * @returns Segment count for the requested arc span.
+        * @throws {@link GeometryError} when radius, angle, or resolution policy is invalid, or the
+            * corresponding full-circle tolerance exceeds the configured safety limit.
+            * @see {@link resolveCircularSegments}
+            *
+            * @example
+            * ```ts
+            * const quarterTurnSegments = resolveArcSegments(10, 90);
+            * ```
+            */
+        export declare function resolveArcSegments(radius: number, angleDegrees: number, policy?: GeometryResolution, limits?: Partial<GeometrySamplingLimits>): number;
+
+        /**
+         * Resolves a deterministic full-circle segment count for one radius.
+         *
+         * An exact `circularSegments` value wins. Otherwise the smallest regular polygon satisfying both
+         * physical error criteria is used. A safety cap that would violate either criterion raises
+         * `COMPLEXITY_LIMIT` rather than silently reducing quality.
+         *
+         * @param radius - Circle radius in millimetres.
+         * @param policy - Optional operation-level policy under explicit sampling ceilings.
+         * @returns Full-circle segment count.
+         * @throws {@link GeometryError} when radius or policy is invalid, or the requested tolerance
+             * exceeds the configured segment safety limit.
+             * @see {@link resolveArcSegments}
+             * @see {@link resolveAlignedCircularSegments}
+             *
+             * @example
+             * ```ts
+             * const circleSegments = resolveCircularSegments(25, { maxChordError: 0.05 });
+             * ```
+             */
+         export declare function resolveCircularSegments(radius: number, policy?: GeometryResolution, limits?: Partial<GeometrySamplingLimits>): number;
+
+         /**
+          * Resolves a validated unshifted full-depth external cylindrical gear.
+          *
+          * The gear axis is +Z and the returned radii describe its XY pitch plane. Inputs below the
+          * pressure- and helix-dependent no-undercut tooth count are rejected because profile shift is not
+          * currently supported.
+          */
+         export declare function resolveCylindricalGear(spec: CylindricalGearSpec): CylindricalGearDimensions;
+
+         /**
+          * Resolves ratio, center distance, and helix relationship for a gear pair.
+          *
+          * Both gears must use the same normal module, pressure angle, and helix-angle
+          * magnitude. An external pair uses opposite helix hands; an internal pair uses
+          * the same hand. The function validates those conjugate pitch invariants.
+          */
+         export declare function resolveCylindricalGearPair(spec: CylindricalGearPairSpec): CylindricalGearPairDimensions;
+
+         /** Fully resolved tolerances for one operation and model scale. */
+         export declare interface ResolvedGeometryTolerance {
+             /** Configured absolute distance floor in model units. */
+             readonly absolute: number;
+             /** Configured angular threshold in radians. */
+             readonly angular: number;
+             /** Effective squared-distance threshold for area and cross-product comparisons. */
+             readonly area: number;
+             /** Effective distance threshold for the supplied model scale. */
+             readonly linear: number;
+             /** Configured dimensionless scale multiplier. */
+             readonly relative: number;
+         }
+
+         /**
+          * Resolves intermediate profile copies for linear extrusion from physical curve resolution.
+          *
+          * Accepts one XY loop or a filled XY region, including every hole and disconnected component.
+          * Exact `divisions`, including zero, override physical sampling. Otherwise chord error bounds
+          * the triangulated side surface, including rotation across each profile edge. Optional segment
+          * length bounds station travel including Z. Straight extrusions need no intermediate copies by default.
+          * Exceeding the selected maxPathPoints ceiling raises `COMPLEXITY_LIMIT` instead of reducing fidelity.
+          *
+          * @param profile - Ordered XY millimetre contours with implicit closing edges.
+          * @param height - Positive extrusion height in millimetres.
+          * @param options - Twist, scale, exact divisions, and physical resolution controls.
+          * @returns Number of intermediate copies, excluding the two end profiles.
+          */
+         export declare function resolveExtrusionDivisions(profile: Loop2 | Region2, height: number, options?: ExtrusionSamplingOptions): number;
+
+         /** Resolves finite positive safe-integer allocation ceilings without ambient state. */
+         export declare function resolveGeometrySamplingLimits(overrides?: Partial<GeometrySamplingLimits>): GeometrySamplingLimits;
+
+         /**
+          * Resolves comparison tolerances for a characteristic model scale.
+          *
+          * The effective linear tolerance is `max(absolute, relative * abs(scale))`.
+          * Supplying a scale of zero therefore retains the absolute floor. The function
+          * returns a new frozen value with finite distance and area thresholds and never mutates `options`.
+          *
+          * @param scale - Finite characteristic size in model units.
+          * @param options - Optional policy overrides.
+          * @returns A complete tolerance policy including the scale-resolved distance.
+          * @throws {@link GeometryError} When a scale or override is invalid.
+              */
+          export declare function resolveGeometryTolerance(scale?: number, options?: GeometryToleranceOptions): ResolvedGeometryTolerance;
+
+          /** Resolves and validates a named or caller-defined print-fit policy. */
+          export declare function resolvePrintableThreadFitPolicy(fit?: PrintableThreadFit | PrintableThreadFitPolicy): PrintableThreadFitPolicy;
+
+          /** Resolves a rack segment that is conjugate with the same normal cylindrical pitch system. */
+          export declare function resolveRackPitch(spec: RackPitchSpec): RackPitchDimensions;
+
+          /**
+           * Resolves a role-independent, start-aligned facet count from the larger female mating envelope.
+           *
+           * An exact `circularSegments` value must already be divisible by `starts`; it is never silently
+           * raised. Adaptive policies align upward and fail if that would exceed `maximumSegments`.
+           */
+          export declare function resolveThreadCircularSegments(options: ThreadCircularSegmentsOptions): number;
+
+          /**
+           * Returns a copy of a mesh with every triangle winding reversed.
+           *
+           * @param mesh - Mesh to copy and reverse.
+           * @returns Fresh position and index buffers; the input remains unchanged.
+           */
+          export declare function reverseTriangleMesh(mesh: TriangleMesh): TriangleMesh;
+
+          /**
+           * Revolves a non-duplicated closed `[radius, z]` profile around +Z.
+           *
+           * The profile is ordered counter-clockwise when radius points right and Z
+           * points up. Angular and profile seams wrap by index. A profile point on the
+           * axis is emitted once and joined as a triangle fan, avoiding coincident seam
+           * vertices and zero-area quads. Profile edges that lie entirely on the axis
+           * collapse to the solid's interior and are intentionally omitted.
+           * Profile coordinates must fit finite Float32 mesh storage.
+           *
+           * @param profile - Closed CCW `[radius, z]` profile without a duplicated seam point.
+           * @param options - Optional physical or exact circumferential sampling controls. Defaults to `{}`.
+           * @returns A closed indexed triangle mesh revolved counter-clockwise around +Z.
+           *
+           * @example Partial revolution with end caps
+           * ```ts
+           * // Each point is [radius, Z]; the profile seam is implicit.
+           * revolveMesh([[0, 0], [12, 0], [8, 20], [0, 20]], { revolveDegrees: 270 });
+           * ```
+           */
+          export declare const revolveMesh: (profile: readonly Vec2[], options?: RevolveOptions) => TriangleMesh;
+
+          /**
+           * Circumferential sampling and degree sweep shared by pure and filled revolution.
+           */
+          export declare interface RevolveOptions extends CircularPrimitiveOptions {
+              /**
+               * Positive angular sweep no greater than 360 degrees; partial revolutions have end caps.
+               * Segment counts describe a complete circle and scale to this angular span. Native filled
+               * revolutions require at least three sweep intervals: adaptive sampling refines to that floor,
+               * while exact counts that imply fewer intervals reject. Pure revolveMesh supports one interval.
+               */
+              readonly revolveDegrees?: number;
+              /** Explicit output and sampling allocation ceilings. */
+              readonly limits?: Partial<ModelingLimits>;
+          }
+
+          /** Rotates a vector right-handed around an axis by `angle` radians. */
+          export declare const rotateAroundAxis3: (vector: Vec3, axis: Vec3, angle: number) => Vec3;
+
+          /**
+           * Creates a right-handed axis-angle rotation transform.
+           *
+           * @param axis - Rotation axis; normalization is performed internally.
+           * @param angle - Finite right-handed angle with exactly one explicit unit.
+           * @param tolerance - Optional zero-length comparison overrides.
+           * @returns A frozen row-major transform.
+           */
+          export declare function rotationTransform3(axis: Vec3, angle: AxisAngleRotation3, tolerance?: GeometryToleranceOptions): Transform3;
+
+          /**
+           * Replaces each vertex of a non-duplicated closed polyline with a sampled
+           * quadratic corner in the same coordinate system as the input.
+           *
+           * `radius` is the desired tangent distance for a right angle and is capped to
+           * 45% of adjacent segment lengths to prevent neighboring corners from crossing.
+           * The returned path does not duplicate its closing point.
+           * Coordinates and radius must be finite; input and output are each limited by maxPathPoints (default 100000).
+           */
+          export declare const roundClosedPolylinePath: (points: readonly Vec3[], radius: number, segmentsPerCorner: number, limits?: Partial<GeometrySamplingLimits>) => readonly Vec3[];
+
+          /**
+           * A circular edge or corner roundover with explicit physical sampling.
+           */
+          export declare interface RoundedEdgeTreatment extends CircularPrimitiveOptions {
+              /** Selects circular corners or spherical all-edge roundovers. */
+              readonly kind: "round";
+              /** Radius in millimetres. Rectangles permit zero through half their smallest dimension; boxes require a positive smaller radius. */
+              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.
+           *
+           * 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.
+               *
+               * @example
+               * ```ts
+               * const side = sampleOpenProfile({
+               *   start: { radius: 0.5, height: 0 },
+               *   segments: [{ type: "line", end: { radius: 1, height: 1 } }],
+               * }, { radiusScale: 12, heightScale: 30 });
+               * ```
+               */
+           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>;
+           }
+
+           /**
+            * 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.
+            */
+           export declare function sampleThreadHelices(options: ThreadHelixOptions): SampledThreadHelices;
+
+           /**
+            * 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;
+
+           /**
+            * 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>;
+           }
+
+           /**
+            * 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;
+           }
+
+           /**
+            * 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.
+            */
+           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;
+           }
+
+           /**
+            * 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;
+           }
+
+           /**
+            * 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;
+
+           /**
+            * 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`.
+                */
+               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;
+           }
+
+           /** 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;
+           }
+
+           /**
+            * Supported printable nut body shapes.
+            */
+           export declare type ThreadedNutShape = "hex" | "round" | "square";
+
+           /**
+            * Options for a compensated external threaded rod along +Z.
+            */
+           export declare interface ThreadedRodOptions extends Omit<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;
+           }
+
+           /**
+            * 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";
+
+           /**
+            * 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;
+           }
+
+           /**
+            * Supported built-in and caller-defined thread profiles.
+            */
+           export declare type ThreadProfileSpec = AcmeThreadProfileSpec | ButtressThreadProfileSpec | CustomThreadProfileSpec | SquareThreadProfileSpec | TrapezoidalThreadProfileSpec | TriangularThreadProfileSpec;
+
+           /** Whether compensation is being applied to an external or internal thread. */
+           export declare type ThreadRole = "male" | "female";
+
+           /**
+            * Dimensions and independent ring/profile tessellation for a torus around the Z axis.
+            */
+           export declare interface TorusOptions extends PrimitivePlacement {
+               /** 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;
+           }
+
+           /**
+            * 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
+           ];
+
+           /**
+            * 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;
+
+           /**
+            * 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;
+
+           /** Applies an XY-plane-preserving affine transform to a 2D path. */
+           export declare function transformPath2(path: Path2, transform: Transform3, tolerance?: GeometryToleranceOptions): Path2;
+
+           /** Applies an affine transform to a 3D path without mutating its points. */
+           export declare function transformPath3(path: Path3, transform: Transform3): Path3;
+
+           /** Transforms an explicit outer/hole region with reflection-safe winding correction. */
+           export declare function transformRegion2(region: Region2, transform: Transform3, tolerance?: GeometryToleranceOptions): Region2;
+
+           /**
+            * 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;
+
+           /**
+            * 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;
+           }
+
+           /**
+            * 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;
+           }
+
+           /**
+            * 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;
+           }
+
+           /**
+            * 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;
+           }
+
+           /**
+            * 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;
+           }
+
+           /**
+            * ISO/UTS-like 60-degree truncated triangular profile.
+            */
+           export declare interface TriangularThreadProfileSpec extends ThreadProfileBaseSpec {
+               /** Selects the 60-degree triangular profile family. */
+               readonly kind: "triangular";
+               /**
+                * Crest width divided by pitch.
+                * @defaultValue `1 / 8`
+                */
+               readonly crestFlatRatio?: number;
+               /**
+                * Root width divided by pitch.
+                * @defaultValue `1 / 4`
+                */
+               readonly rootFlatRatio?: number;
+           }
+
+           /** Ear-clips one normalized simple CCW loop into stable local vertex indices. */
+           export declare function triangulateLoop2(loop: Loop2): Uint32Array;
+
+           /**
+            * 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 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;
+
+            /**
+             * 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];
+
+             /** 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];
+             }
+
+             /**
+              * 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;
+             }
+
+             /**
+              * 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 { }