@metamesh/modeling 0.16.0 → 0.18.0

package/dist/api/geometry.d.ts

@@ -50,37 +50,6 @@ export declare interface AlignedCircularSegmentsOptions {
   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.
  *
@@ -235,6 +204,13 @@ export declare type AxisAngleRotation3 =
       readonly degrees?: never;
     };
 
+/** One size for both ends, or independent sizes in bottom/top order. Zero disables an end. */
+export declare type Bevel =
+  BevelSize | readonly [bottom: BevelSize, top: BevelSize];
+
+/** Nonnegative 45-degree axial/radial bevel size in millimetres, or factory automatic sizing. */
+export declare type BevelSize = number | "auto";
+
 /** Immutable finite XY bounds in millimetres, with tuple coordinates for data interoperability. */
 export declare interface Bounds2 extends Bounds2Data {
   /** Returns nonnegative X/Y dimensions in millimetres, including zero extents. */
@@ -248,14 +224,15 @@ export declare interface Bounds2 extends Bounds2Data {
 }
 
 /**
- * Snapshots finite ordered XY bounds in millimetres as an immutable fluent value.
+ * Constructs immutable finite XY bounds from ordered extrema or nonnegative size in millimetres.
  *
  * Zero extents are valid. Invalid dimensions, nonfinite coordinates, reversed bounds and
  * overflowing extents throw `INVALID_ARGUMENT` GeometryError. Use `toData()` for plain records.
+ * Size construction centers on the origin unless `center` is false. Size and extrema are exclusive.
  * Compiled Generator packages passing these values to host recipes or computed data require
- * runtime 8.0.0 or newer in major 8.
+ * runtime 10.0.0 or newer in major 10.
  */
-export declare function bounds2(input: Bounds2Input): Bounds2;
+export declare function bounds2(input: Bounds2Options | Bounds2): Bounds2;
 
 /** Plain axis-aligned XY bounds for interchange; use bounds2 for immutable measurement methods. */
 export declare interface Bounds2Data {
@@ -268,6 +245,29 @@ export declare interface Bounds2Data {
 /** An immutable XY bounds value or its plain min/max representation. */
 export declare type Bounds2Input = Bounds2 | Bounds2Data;
 
+/** XY bounds construction from existing extrema or nonnegative dimensions, never both. */
+export declare type Bounds2Options =
+  | {
+      /** Inclusive minimum XY coordinates in millimetres. */
+      readonly min: Vector2Input;
+      /** Inclusive maximum XY coordinates in millimetres. */
+      readonly max: Vector2Input;
+      /** Size construction cannot be combined with extrema. */
+      readonly size?: never;
+      /** Center applies only to size construction. */
+      readonly center?: never;
+    }
+  | {
+      /** Nonnegative XY dimensions in millimetres. */
+      readonly size: Vector2Input;
+      /** Center on the origin; false starts at the origin. Defaults to true. */
+      readonly center?: boolean;
+      /** Minimum coordinates are unavailable when size is supplied. */
+      readonly min?: never;
+      /** Maximum coordinates are unavailable when size is supplied. */
+      readonly max?: never;
+    };
+
 /** Immutable finite XYZ bounds in millimetres, with tuple coordinates for data interoperability. */
 export declare interface Bounds3 extends Bounds3Data {
   /** Returns nonnegative X/Y/Z dimensions in millimetres, including zero extents. */
@@ -281,14 +281,15 @@ export declare interface Bounds3 extends Bounds3Data {
 }
 
 /**
- * Snapshots finite ordered XYZ bounds in millimetres as an immutable fluent value.
+ * Constructs immutable finite XYZ bounds from ordered extrema or nonnegative size in millimetres.
  *
  * Zero extents are valid. Invalid dimensions, nonfinite coordinates, reversed bounds and
  * overflowing extents throw `INVALID_ARGUMENT` GeometryError. Use `toData()` for plain records.
+ * Size construction centers on the origin unless `center` is false. Size and extrema are exclusive.
  * Compiled Generator packages passing these values to host recipes or computed data require
- * runtime 8.0.0 or newer in major 8.
+ * runtime 10.0.0 or newer in major 10.
  */
-export declare function bounds3(input: Bounds3Input): Bounds3;
+export declare function bounds3(input: Bounds3Options | Bounds3): Bounds3;
 
 /** Plain axis-aligned XYZ bounds for interchange; use bounds3 for immutable measurement methods. */
 export declare interface Bounds3Data {
@@ -301,6 +302,29 @@ export declare interface Bounds3Data {
 /** An immutable XYZ bounds value or its plain min/max representation. */
 export declare type Bounds3Input = Bounds3 | Bounds3Data;
 
+/** XYZ bounds construction from existing extrema or nonnegative dimensions, never both. */
+export declare type Bounds3Options =
+  | {
+      /** Inclusive minimum XYZ coordinates in millimetres. */
+      readonly min: Vector3Input;
+      /** Inclusive maximum XYZ coordinates in millimetres. */
+      readonly max: Vector3Input;
+      /** Size construction cannot be combined with extrema. */
+      readonly size?: never;
+      /** Center applies only to size construction. */
+      readonly center?: never;
+    }
+  | {
+      /** Nonnegative XYZ dimensions in millimetres. */
+      readonly size: Vector3Input;
+      /** Center on the origin; false starts at the origin. Defaults to true. */
+      readonly center?: boolean;
+      /** Minimum coordinates are unavailable when size is supplied. */
+      readonly min?: never;
+      /** Maximum coordinates are unavailable when size is supplied. */
+      readonly max?: never;
+    };
+
 /** Midpoint of finite XY bounds in millimetres. */
 export declare function boundsCenter(bounds: Bounds2Data): Vector2Data;
 
@@ -333,24 +357,6 @@ export declare interface BoundsFitOptions {
   readonly maxScale?: number;
 }
 
-/** Creates immutable centered XY bounds from nonnegative dimensions in millimetres. */
-export declare function boundsFromSize(
-  size: Vector2Data,
-  options?: BoundsFromSizeOptions,
-): Bounds2Data;
-
-/** Creates immutable centered XYZ bounds from nonnegative dimensions in millimetres. */
-export declare function boundsFromSize(
-  size: Vector3Data,
-  options?: BoundsFromSizeOptions,
-): Bounds3Data;
-
-/** Placement of bounds constructed from nonnegative millimetre dimensions. */
-export declare interface BoundsFromSizeOptions {
-  /** Center on the origin; false starts at the origin. Defaults to true. */
-  readonly center?: boolean;
-}
-
 /** Inclusive XY dimensions in millimetres; zero extents are retained. */
 export declare function boundsSize(bounds: Bounds2Data): Vector2Data;
 
@@ -370,13 +376,13 @@ export declare type BoxAnchorFace =
 /** Box dimensions and construction origin for one named face anchor. */
 export declare interface BoxAnchorOptions {
   /** XYZ dimensions, or one uniform dimension, in millimetres. */
-  readonly size: number | Vector3Data;
+  readonly size: number | Vector3Input;
   /** 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?: Vector3Data;
+  readonly origin?: Vector3Input;
 }
 
 /** Box edges use +Z top, +Y front and +X right; vertical names list front/back first. */
@@ -414,7 +420,7 @@ export declare interface BoxOptions extends PrimitiveAttachment {
    */
   readonly center?: boolean;
   /** Positive uniform size or explicit `[X, Y, Z]` extents in millimetres. */
-  readonly size: number | Vector3Data;
+  readonly size: number | Vector3Input;
   /** Uniform treatment or independent disjoint nominal edge/group treatments. */
   readonly treatment?: EdgeTreatment | BoxEdgeTreatments;
 }
@@ -459,20 +465,18 @@ export declare interface ChamferedEdgeTreatment {
  */
 export declare const circleContour: (options: CircleContourOptions) => Contour;
 
-/**
- * Circular profile dimensions with exactly one radius or diameter and explicit sampling.
- */
+/** Circular profile dimensions with exactly one radius or diameter and explicit sampling. */
 export declare type CircleContourOptions = CircularPrimitiveOptions &
   RadialSizingOptions &
   (
     | {
-        /** Positive nominal radius in millimetres; mutually exclusive with diameter. */
+        /** Positive nominal radius in millimetres. */
         readonly radius: number;
-        /** Full diameter is unavailable when radius is supplied. */
+        /** Diameter is unavailable when radius is supplied. */
         readonly diameter?: never;
       }
     | {
-        /** Positive full diameter in millimetres; mutually exclusive with radius. */
+        /** Positive nominal diameter in millimetres. */
         readonly diameter: number;
         /** Radius is unavailable when diameter is supplied. */
         readonly radius?: never;
@@ -502,6 +506,19 @@ export declare interface CircularResolutionOptions extends GeometryResolution {
   readonly sizing?: RadialSizing;
 }
 
+/** Full-circle count and radial envelopes of its regular sampled polygon, in millimetres. */
+export declare interface CircularSampling {
+  /** Exact resolved full-circle segment count. */
+  readonly segments: number;
+  /** Distance from the origin to every sampled vertex. */
+  readonly vertexRadius: number;
+  /** Minimum distance from the origin to each straight sampled edge. */
+  readonly faceRadius: number;
+}
+
+/** Nominal circle size and explicit physical sampling; supply exactly one radius or diameter. */
+export declare type CircularSamplingOptions = CircleContourOptions;
+
 /** Close, normal, and loose metric clearance-hole diameters in millimetres. */
 export declare interface ClearanceHoleDimensions {
   /** Close-fit clearance-hole diameter. */
@@ -627,49 +644,6 @@ export declare const computeParallelTransportFrames: (
   limits?: Partial<GeometrySamplingLimits>,
 ) => readonly PathFrame[];
 
-/**
- * Computes the uniform-density volume centroid of an oriented closed solid, including cavity shells.
- *
- * Coordinates are millimetres. Indexed closure and positive aggregate volume are required; callers
- * may use validateSolidMesh first when geometric intersections and shell orientation are untrusted.
- * Fresh mutable input is inspected on every call, and buffers are never changed.
- *
- * @param mesh - Consistently oriented closed mesh with positive enclosed volume.
- * @returns A fresh immutable XYZ volume centroid.
- */
-export declare function computeTriangleMeshCentroid(
-  mesh: TriangleMesh,
-): Vector3Data;
-
-/**
- * Creates an order-independent regression signature for a manufacturing mesh.
- *
- * The input must be non-empty, closed, consistently wound, and have no unreferenced vertices.
- * Vertex and triangle order do not affect the fingerprint; winding, quantized geometry, and
- * connectivity metrics do. The fingerprint is a regression aid, not a cryptographic digest.
- *
- * @param mesh - Closed oriented mesh to measure without mutation.
- * @param options - Absolute quantization and complexity limits.
- * @returns Compact counts, bounds, volume, topology, tolerances, and canonical fingerprint.
- * @throws {@link GeometryError} When validation, topology, tolerance, or complexity checks fail.
- */
-export declare function computeTriangleMeshSignature(
-  mesh: TriangleMesh,
-  options?: TriangleMeshSignatureOptions,
-): TriangleMeshSignature;
-
-/** Tests actual XY containment, including touching boundaries; dimensions must match. */
-export declare function containsBounds(
-  outer: Bounds2Data,
-  inner: Bounds2Data,
-): boolean;
-
-/** Tests actual XYZ containment, including touching boundaries; dimensions must match. */
-export declare function containsBounds(
-  outer: Bounds3Data,
-  inner: Bounds3Data,
-): boolean;
-
 /**
  * A sampled closed two-dimensional boundary whose first point is not repeated at the end.
  *
@@ -854,7 +828,7 @@ export declare interface CylinderAnchorOptions {
   /** 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?: Vector3Data;
+  readonly origin?: Vector3Input;
 }
 
 /**
@@ -1091,13 +1065,13 @@ export declare type EllipseContourOptions = CircularPrimitiveOptions &
   (
     | {
         /** Positive XY radii in millimetres; mutually exclusive with size. */
-        readonly radius: Vector2Data;
+        readonly radius: Vector2Input;
         /** Full XY extents are unavailable when radius is supplied. */
         readonly size?: never;
       }
     | {
         /** Positive full XY extents in millimetres; mutually exclusive with radius. */
-        readonly size: Vector2Data;
+        readonly size: Vector2Input;
         /** XY radii are unavailable when size is supplied. */
         readonly radius?: never;
       }
@@ -1129,28 +1103,17 @@ export declare function eulerTransform3(
 ): Transform3Data;
 
 /**
- * Linearly extrudes one simple profile along +Z with robust ear-clipped caps.
- * Path2 profiles must be closed; raw point collections have an implicit closing edge.
- *
- * @example Extrude point data without an engine
- * ```ts
- * const outline = rectangleContour({ size: [30, 20], treatment: { kind: "round", radius: 3 } });
- * extrudeMesh(outline, { height: 8 });
- * ```
+ * Dimensions and sampling for pure +Z mesh extrusion, without end treatments.
  */
-export declare function extrudeMesh(
-  input: Path2Input,
-  options: ExtrudeOptions,
-): TriangleMesh;
-
-/**
- * Dimensions and sampling shared by native and pure +Z extrusion.
- */
-export declare interface ExtrudeOptions extends ExtrusionSamplingOptions {
+export declare interface ExtrudeMeshOptions extends ExtrusionSamplingOptions {
   /** Positive extrusion height in millimetres. */
   readonly height: number;
   /** Center the extrusion on Z; otherwise its bottom is at zero. Defaults to false. */
   readonly center?: boolean;
+}
+
+/** Native +Z extrusion with optional inward end treatments. */
+export declare interface ExtrudeOptions extends ExtrudeMeshOptions {
   /** Independent inward end treatments on straight convex single-contour extrusions. */
   readonly ends?: EndTreatments;
 }
@@ -1370,28 +1333,6 @@ export declare function gridPatternTransforms(
   options: GridPatternOptions,
 ): readonly Transform3Data[];
 
-/**
- * Builds a closed indexed mesh from a rectilinear top, matched boundary walls, and flat base.
- *
- * Heights run once per grid point after preflight; center-error adds one evaluation per cell.
- * Top winding is +Z, the base is -Z, and sides face outward. Coordinates and heights must fit
- * Float32 storage. Explicit axes are captured before sampling; shared wall vertices prevent cracks.
- *
- * @see {@link preflightHeightfield}
- *
- * @example Sample a closed wavy mesh
- * ```ts
- * heightfieldMesh({
- *   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">
@@ -1421,11 +1362,11 @@ export declare type HeightfieldOptions = {
 } & (
   | {
       /** Positive XY footprint for uniform sampling. */
-      readonly size: Vector2Data;
+      readonly size: Vector2Input;
       /** Exact positive integer X/Y interval counts. */
       readonly segments: readonly [x: number, y: number];
       /** Lower-left footprint XY. Omitted centers the footprint on XY. */
-      readonly origin?: Vector2Data;
+      readonly origin?: Vector2Input;
       /** Explicit coordinates cannot be combined with uniform sampling. */
       readonly coordinates?: never;
     }
@@ -1461,93 +1402,55 @@ export declare interface HeightfieldPreflight {
   readonly byteCount: number;
 }
 
-/**
- * Builds closed thread-ridge components with every profile locked to the
- * shaft's radial/axial frame. The mesh is intended for union with its
- * minor-envelope cylinder and never owns WASM objects.
- */
-export declare function helicalThreadRidgeMesh(
-  options: HelicalThreadRidgeMeshOptions,
-): TriangleMesh;
+/** Identity transform, safe to share because it is frozen. */
+export declare const IDENTITY_TRANSFORM3: Transform3Data;
 
-/** 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. */
+/** Owned immutable numeric data. Iterate without copying; use copy() for mutable storage. */
+export declare interface ImmutableBuffer<
+  T extends NumericArray,
+> extends Iterable<number> {
+  /** Opaque element-storage brand; construct buffers with immutableBuffer(). */
+  readonly [immutableBufferBrand]: T;
+  /** Number of numeric elements, independent of their byte width. */
   readonly length: number;
-  /** Explicit output and circular allocation ceilings. */
-  readonly limits?: Partial<ModelingLimits>;
-  /** Nominal major diameter before any caller-owned fit compensation. */
-  readonly majorDiameter: number;
-  /** Angular offset of the first start in degrees. Default: `0`. */
-  readonly phase?: number;
-  /** Validated periodic profile repeated around the shaft. */
-  readonly profile: ThreadProfile;
-  /** Optional circular-resolution policy. */
-  readonly resolution?: GeometryResolution;
-  /** Number of evenly phased starts. Default: `1`. */
-  readonly starts?: number;
-  /** Optional numerical tolerance overrides. */
-  readonly tolerance?: GeometryToleranceOptions;
+  /** Reads an integer offset; negative offsets count from the end. Invalid offsets return undefined. */
+  at(this: void, index: number): number | undefined;
+  /** Returns a fresh mutable array of the original numeric type; never exposes cached storage. */
+  copy(this: void): T;
+  /** Returns an independent read-only iterator over the numeric elements without copying them. */
+  [Symbol.iterator](this: void): IterableIterator<number>;
 }
 
 /**
- * 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.
+ * Copies numeric data once into private storage. This pure helper needs no active generation.
+ * @example
+ * ```ts
+ * import { immutableBuffer } from "@metamesh/modeling";
+ * const heights = immutableBuffer(new Float32Array([2, 4, 6]));
+ * const count = heights.length;
+ * const first = heights.at(0);
+ * const doubled = Array.from(heights, (height) => height * 2);
+ * const editable = heights.copy();
+ * editable[0] = 8; // heights still contains 2, 4, 6.
+ * ```
  */
-export declare function helicalThreadSolidMesh(
-  options: HelicalThreadSolidMeshOptions,
-): TriangleMesh;
+export declare function immutableBuffer<T extends NumericArray>(
+  source: T,
+): ImmutableBuffer<T>;
 
-/** 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;
-}
+declare const immutableBufferBrand: unique symbol;
 
-/** Selected sampling counts and conservative allocation estimates, before thread mesh construction. */
-export declare interface HelicalThreadSolidMeshPreflight {
-  /** Uniform axial intervals required only by a requested physical segment-length limit. */
-  readonly axialIntervals: number;
-  /** 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;
+/** Immutable local XYZ positions and triangle indices, suitable for a computed value or part. */
+export declare interface ImmutableTriangleMesh {
+  /** Packed XYZ coordinates in millimetres. */
+  readonly positions: ImmutableBuffer<Float32Array>;
+  /** Zero-based vertex indices, three per triangle. */
+  readonly indices: ImmutableBuffer<Uint32Array>;
 }
 
-/** Identity transform, safe to share because it is frozen. */
-export declare const IDENTITY_TRANSFORM3: Transform3Data;
-
 /** Options for a compensated internal-thread subtraction tool along +Z. */
 export declare interface InternalThreadCutterOptions
-  extends
-    Omit<HelicalThreadRidgeMeshOptions, "majorDiameter">,
-    ThreadBevelOptions {
+  extends Omit<ThreadRidgeOptions, "majorDiameter">, ThreadBevelOptions {
   /** Printable fit or caller-calibrated allowances. Default: `normal`. */
   readonly fit?: PrintableThreadFit | PrintableThreadFitPolicy;
   /** Nominal major diameter before female compensation and faceting correction. */
@@ -1572,19 +1475,6 @@ export declare function inverseTransform3(
  */
 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;
-
 /** Shared knuckle-joint dimensions in millimetres, independent of mounting geometry. */
 export declare interface KnuckleHingeBaseSpec {
   /** Total extent along the +X pin axis, centered at the origin. */
@@ -1783,28 +1673,6 @@ export declare interface LineCurve3 {
 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.
- * Path2 profiles must be closed; raw point collections are interpreted as closed.
- *
- * @example Loft with explicit point correspondence
- * ```ts
- * const bottom = rectangleContour({ size: [20, 12] });
- * const top = rectangleContour({ 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 & {
   /** Closed Path2 or ordered finite XY boundary points with an implicit closing edge. */
@@ -1812,10 +1680,10 @@ export declare type LoftMeshStation = LoftPlacement & {
 };
 
 /**
- * Shared controls for native and pure lofts. Point data and arbitrary Sections require explicit correspondence.
+ * Shared controls for native and pure lofts. Point data and arbitrary Sections default to direct correspondence.
  */
 export declare interface LoftOptions {
-  /** One method or one per consecutive station gap. Omitted preserves known landmarks, including circle/ellipse-to-rectangle corners, or maps other unlike primitive seams directly. */
+  /** One method or one per consecutive station gap. Omitted preserves known primitive landmarks, including circle/ellipse-to-rectangle corners, and otherwise uses direct correspondence with the supplied seams. */
   readonly correspondence?: LoftCorrespondence | readonly LoftCorrespondence[];
   /** Extra points follow edge length or distribute equally across existing segments. Defaults to perimeter for direct/reindex, or segments when any distance method is selected; distance methods require segments. */
   readonly distribution?: "perimeter" | "segments";
@@ -1889,15 +1757,6 @@ export declare function measureInternalCylindricalGearPairMotion(
   options?: CylindricalGearPairMotionOptions,
 ): CylindricalGearPairMotionReport;
 
-/**
- * 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) => Bounds3Data;
-
 /**
  * Curated metric modeling dimensions for clearance holes, regular hex nuts,
  * and socket-head cap screws.
@@ -2042,23 +1901,9 @@ export declare function normalizeRegion(
   tolerance?: GeometryToleranceOptions,
 ): RegionData;
 
-/**
- * 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;
+/** Numeric storage supported by immutable generation buffers. */
+export declare type NumericArray =
+  Float32Array | Float64Array | Uint32Array | Uint8Array | Int32Array;
 
 /** Immutable directed XY polyline. Closure is explicit and does not imply a filled Section. */
 export declare interface Path2 {
@@ -2360,33 +2205,6 @@ export declare interface PolylineResamplingOptions extends CurveSamplingOptions
   readonly closed?: boolean;
 }
 
-/**
- * Checks grid options, Float32 axis precision, and output limits; returns exact mesh buffer counts.
- *
- * This pure operation needs no engine and neither evaluates `height` nor allocates mesh buffers.
- * Successful preflight leaves height values, Float32 base storage, and generated mesh validity to
- * construction. `byteCount` covers position and index buffers, not total working memory.
- *
- * @see {@link heightfieldMesh}
- */
-export declare function preflightHeightfield(
-  options: HeightfieldOptions,
-  limits?: HeightfieldMeshLimits,
-): HeightfieldPreflight;
-
-/**
- * Checks thread dimensions, profile, end treatments, sampling, and conservative estimates against output limits.
- *
- * This pure operation needs no engine and constructs planning data without vertex or index buffers.
- * `circularSegments` is the selected count; row and triangle counts are conservative estimates.
- * Successful preflight leaves generated coordinate and topology checks to mesh construction.
- *
- * @see {@link helicalThreadSolidMesh}
- */
-export declare function preflightHelicalThreadSolidMesh(
-  options: HelicalThreadSolidMeshOptions,
-): HelicalThreadSolidMeshPreflight;
-
 /**
  * Resolves compensated cutter dimensions and checks extended mesh estimates against output limits.
  *
@@ -2395,20 +2213,23 @@ export declare function preflightHelicalThreadSolidMesh(
  * creates planning data without mesh buffers or native objects. Row and triangle counts are
  * estimates; mesh validity and native construction are checked later.
  *
- * @see {@link preflightHelicalThreadSolidMesh}
- * @see {@link helicalThreadSolidMesh}
+ * See `mesh.preflightThreadSolid` for standalone mesh estimates.
+ * See `mesh.threadSolid` for standalone mesh construction.
  */
 export declare function preflightInternalThreadCutter(
   options: InternalThreadCutterOptions,
-): HelicalThreadSolidMeshPreflight;
+): ThreadSolidPreflight;
 
 /**
  * Parses and validates bounded SVG input, constructing its normalized sampled region and diagnostics.
  *
  * This pure operation performs curve flattening, fill and stroke construction, and polygon union;
  * it needs no browser or engine. Geometry counts measure the returned region at the selected
- * resolution, rather than predicting later mesh allocation. The region may be empty; tiny-island
- * and short-edge indicators do not establish manufacturability or later solid validity.
+ * resolution, rather than predicting later mesh allocation. With `fit`, painted bounds are
+ * uniformly centered inside the target and adaptive sampling remains in final millimetres.
+ * Refinement runs at most eight bounded import passes; exact circular counts retain precedence.
+ * Without `fit` the region may be empty. Tiny-island and short-edge indicators do not establish
+ * manufacturability or later solid validity.
  *
  * @param svg - Complete SVG XML source, limited to 256 KiB of UTF-8.
  * @param options - Physical flattening and viewport-origin controls.
@@ -2428,7 +2249,7 @@ export declare function preflightSvgRegion(
  * `thread` contains conservative cutter estimates, excluding the body and Boolean result.
  * Successful preflight leaves mesh validity, native construction, and manufacturing fit to later checks.
  *
- * @see {@link preflightHelicalThreadSolidMesh}
+ * See `mesh.preflightThreadSolid` for standalone mesh estimates.
  */
 export declare function preflightThreadedNut(
   options: ThreadedNutOptions,
@@ -2441,12 +2262,12 @@ export declare function preflightThreadedNut(
  * host execution. It creates planning data without mesh buffers or native objects; returned row
  * and triangle counts are estimates. Mesh validity and native construction are checked later.
  *
- * @see {@link preflightHelicalThreadSolidMesh}
- * @see {@link helicalThreadSolidMesh}
+ * See `mesh.preflightThreadSolid` for standalone mesh estimates.
+ * See `mesh.threadSolid` for standalone mesh construction.
  */
 export declare function preflightThreadedRod(
   options: ThreadedRodOptions,
-): HelicalThreadSolidMeshPreflight;
+): ThreadSolidPreflight;
 
 /** Anchor attachment shared by solid and filled-section factories. */
 export declare interface PrimitiveAttachment {
@@ -2672,7 +2493,11 @@ export declare interface RadialSizingOptions {
 }
 
 /**
- * Creates an immutable sampled CCW rectangle boundary. Round radius zero is square; tangent saturated endpoints occur once.
+ * Creates an immutable sampled CCW rectangle boundary.
+ *
+ * @remarks
+ * A zero round radius leaves square corners. When rounded corners meet, their shared endpoints
+ * appear once.
  *
  * Use [rectangle](/docs/reference/model/rectangle) for a filled Section.
  *
@@ -2692,7 +2517,7 @@ export declare function rectangleContour(
  */
 export declare interface RectangleContourOptions {
   /** Positive uniform size or explicit XY extents in millimetres. */
-  readonly size: number | Vector2Data;
+  readonly size: number | Vector2Input;
   /** 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. */
@@ -2764,7 +2589,7 @@ export declare function regionBounds(region: RegionData): Bounds2Data;
 export declare type RegionData = readonly PolygonData[];
 
 /**
- * Creates a centered CCW point loop with vertex or face radial sizing and an implicit seam.
+ * Creates an immutable centered CCW point loop with vertex or face radial sizing and an implicit seam.
  *
  * @example Hexagon sized to its faces
  * ```ts
@@ -2865,6 +2690,25 @@ export declare function resolveArcSegments(
   limits?: Partial<GeometrySamplingLimits>,
 ): number;
 
+/**
+ * Resolves circular sampling and its actual radial envelopes without allocating boundary points.
+ *
+ * Vertex sizing retains the nominal vertex radius; face sizing retains the nominal face radius.
+ * Exact `segments` override resolution, while allocation ceilings still apply. Adaptive sampling
+ * uses the same count calculation as `resolveCircularSegments` and `circleContour` and rejects
+ * exhausted limits rather than coarsening. The returned record is immutable and needs no engine.
+ *
+ * @example Check a nominal 8 mm face-sized bore
+ * ```ts
+ * const bore = resolveCircularSampling({ diameter: 8, segments: 64, sizing: "face" });
+ * bore.faceRadius; // 4 mm
+ * bore.vertexRadius; // slightly larger than 4 mm
+ * ```
+ */
+export declare function resolveCircularSampling(
+  options: CircularSamplingOptions,
+): CircularSampling;
+
 /**
  * Resolves a deterministic full-circle segment count for one radius.
  *
@@ -3007,40 +2851,6 @@ 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.
- * Path2 profiles must be closed; raw point collections have an implicit closing edge.
- *
- * @param profile - Closed CCW `[radius, z]` profile without a duplicated seam point.
- * @param options - Optional physical or exact circumferential sampling controls. Defaults to `{}`.
- * @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]], { degrees: 270 });
- * ```
- */
-export declare const revolveMesh: (
-  input: Path2Input,
-  options?: RevolveOptions,
-) => TriangleMesh;
-
 /**
  * Circumferential sampling and degree sweep shared by pure and filled revolution.
  */
@@ -3050,7 +2860,7 @@ export declare interface RevolveOptions extends CircularPrimitiveOptions {
    * smaller sweeps form partial revolutions with end caps.
    * Segment counts describe a complete circle and scale to this angular span. Native filled
    * revolutions require at least three sweep intervals: adaptive sampling refines to that floor,
-   * while exact counts that imply fewer intervals reject. Pure revolveMesh supports one interval.
+   * while exact counts that imply fewer intervals reject. Pure mesh.revolve supports one interval.
    * @defaultValue `360`
    */
   readonly degrees?: number;
@@ -3473,20 +3283,31 @@ export declare interface SquareThreadProfileSpec extends ThreadProfileBaseSpec {
 }
 
 /**
- * Creates a centered CCW alternating-radius star within the selected profile sampling ceiling.
+ * Creates an immutable centered CCW alternating-radius star within the selected profile sampling ceiling.
  *
  * @example Five-point outline
  * ```ts
- * starContour(12, 5, 6);
+ * starContour({ outerRadius: 12, innerRadius: 6, points: 5 });
  * ```
  */
 export declare const starContour: (
-  outerRadius: number,
-  points: number,
-  innerRadius?: number,
-  limits?: Partial<GeometrySamplingLimits>,
+  options: StarContourOptions,
 ) => readonly Vector2Data[];
 
+/** Alternating vertex radii and exact point count for a centered XY star. */
+export declare interface StarContourOptions {
+  /** Positive outer vertex radius in millimetres. */
+  readonly outerRadius: number;
+  /** Positive inner vertex radius in millimetres, smaller than the outer radius. */
+  readonly innerRadius: number;
+  /** Integer outer point count, at least three; output contains twice as many vertices. */
+  readonly points: number;
+  /** Counterclockwise rotation in degrees; defaults to zero with an outer vertex on +X. */
+  readonly rotation?: number;
+  /** Explicit sampling ceilings, bounded by the host policy during modeling. */
+  readonly limits?: Partial<GeometrySamplingLimits>;
+}
+
 /** End-cap treatment for an open stroked path. */
 export declare type StrokeCap = "butt" | "round" | "square";
 
@@ -3536,6 +3357,12 @@ export declare const subtract3: (a: Vector3Data, b: Vector3Data) => Vector3Data;
 
 /** Sampling controls for deterministic SVG-to-region conversion. */
 export declare interface SvgImportOptions {
+  /**
+   * Uniformly fit painted bounds inside this positioned XY target in millimetres.
+   * Adaptive resolution describes the fitted size; exact circular counts retain precedence.
+   * Empty painted geometry cannot be fitted. Omitted preserves the document's physical size.
+   */
+  readonly fit?: Bounds2Input;
   /** Explicit profile and circular allocation ceilings; bounded SVG source/work limits remain fixed. */
   readonly limits?: Partial<GeometrySamplingLimits>;
   /** Exact segments for a complete ellipse or round stroke feature. */
@@ -3551,6 +3378,12 @@ export declare interface SvgImportOptions {
 
 /** Normalized sampled SVG region plus bounded source, geometry, and safe-repair diagnostics. */
 export declare interface SvgRegionPreflight {
+  /**
+   * Applied scale and translation from origin-normalized SVG millimetres to final model
+   * millimetres, present only when a fit target was supplied. Reuse it for registered layers
+   * imported with the same origin and document coordinate system.
+   */
+  readonly fit?: BoundsFit2;
   /** Physical and final-topology measurements of `region`. */
   readonly geometry: SvgRegionPreflightGeometryMetrics;
   /** Appearance-preserving cleanup observed during parsing and normalization. */
@@ -3609,23 +3442,6 @@ export declare interface SvgRegionPreflightSourceMetrics {
   readonly parsedVertexCount: 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 = rectangleContour({ 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: Path2Input,
-  path: Path3Input,
-  options?: SweepOptions,
-): TriangleMesh;
-
 /**
  * Controls shared by pure mesh construction and filled modeling sweeps.
  */
@@ -3675,17 +3491,11 @@ export declare type SweepOrientation =
       readonly kind: "frenet";
     };
 
-/** End bevel controls shared by threaded rods and cutters. */
+/** 45-degree end bevels for compensated 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;
+  /** Bottom/top sizes in millimetres. Omitted disables both. Auto uses profile depth for standard/tapered ends,
+   * or one sixth of the compensated male minor/female major radius for blunt ends. */
+  readonly bevel?: Bevel;
 }
 
 /** Inputs for resolving one shared circular facet count for a mating thread pair. */
@@ -3724,25 +3534,20 @@ export declare interface ThreadCompensationOptions {
   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"
+  "bevel" | "length"
 > {
-  /** Nut body bevel selection. Default: `automatic`. */
-  readonly bevel?: ThreadedNutBevel;
+  /** Opening bevels in [bottom, top] order. Omitted or auto uses min(profile.depth, thickness/4); zero disables. */
+  readonly innerBevel?: Bevel;
+  /** Body bevels in [bottom, top] order. Omitted or auto uses min(profile.depth, thickness/4).
+   * Use [0, "auto"] to keep the outside bottom flat without disabling its inner opening bevel. */
+  readonly outerBevel?: Bevel;
   /** Optional physical policy for a round body, independent of the thread's matched facet grid. */
   readonly bodyResolution?: GeometryResolution;
-  /** 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. */
@@ -3755,8 +3560,10 @@ export declare interface ThreadedNutOptions extends Omit<
 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;
+  /** Resolved opening bevel sizes in millimetres, [bottom, top]. */
+  readonly innerBevel: readonly [bottom: number, top: number];
+  /** Resolved body bevel sizes in millimetres, [bottom, top]. */
+  readonly outerBevel: readonly [bottom: number, top: number];
   /** Maximum compensated cutter radius at either requested face. */
   readonly cutterFaceRadius: number;
   /** Minimum nut-body inradius across the requested top and bottom faces. */
@@ -3764,7 +3571,7 @@ export declare interface ThreadedNutPreflight {
   /** Smallest radial wall left between the body and cutter at either requested face. */
   readonly minimumFaceWall: number;
   /** Conservative allocation estimates for the extended cutter; excludes the body and Boolean result. */
-  readonly thread: HelicalThreadSolidMeshPreflight;
+  readonly thread: ThreadSolidPreflight;
   /** Start-aligned circular facet count used by the compensated thread cutter. */
   readonly threadCircularSegments: number;
 }
@@ -3778,9 +3585,7 @@ 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 {
+  extends Omit<ThreadRidgeOptions, "majorDiameter">, ThreadBevelOptions {
   /** Printable fit or caller-calibrated allowances. Default: `normal`. */
   readonly fit?: PrintableThreadFit | PrintableThreadFitPolicy;
   /** Nominal major diameter before male compensation. */
@@ -3911,9 +3716,58 @@ export declare type ThreadProfileSpec =
   | TrapezoidalThreadProfileSpec
   | TriangularThreadProfileSpec;
 
+/** Runtime-neutral options for the dedicated helical ridge mesher. */
+export declare interface ThreadRidgeOptions {
+  /**
+   * Optional bottom/top ridge-end treatments. Standalone ridges honor the requested boundaries;
+   * BOSL2-style non-cut lead-in scaling is available on complete thread solids.
+   */
+  readonly ends?: ThreadEndTreatmentOptions;
+  /** Helix direction. Default: `right`. */
+  readonly handedness?: ThreadHandedness;
+  /** Total threaded axial length in millimetres. */
+  readonly length: number;
+  /** Explicit output and circular allocation ceilings. */
+  readonly limits?: Partial<ModelingLimits>;
+  /** Nominal major diameter before any caller-owned fit compensation. */
+  readonly majorDiameter: number;
+  /** Angular offset of the first start in degrees. Default: `0`. */
+  readonly phase?: number;
+  /** Validated periodic profile repeated around the shaft. */
+  readonly profile: ThreadProfile;
+  /** Optional circular-resolution policy. */
+  readonly resolution?: GeometryResolution;
+  /** Number of evenly phased starts. Default: `1`. */
+  readonly starts?: number;
+  /** Optional numerical tolerance overrides. */
+  readonly tolerance?: GeometryToleranceOptions;
+}
+
 /** Whether compensation is being applied to an external or internal thread. */
 export declare type ThreadRole = "male" | "female";
 
+/** Options for a complete threaded-cylinder mesh; base semantics match the ridge builder. */
+export declare interface ThreadSolidOptions extends ThreadRidgeOptions {
+  /** Independent 45-degree bottom/top bevels; omitted disables both. Auto uses profile depth. */
+  readonly bevel?: Bevel;
+  /** Distance of each bevel target face inward from the corresponding mesh end. */
+  readonly bevelOffset?: number;
+  /** `inset` trims an external rod; `outset` expands an internal cutter. */
+  readonly bevelMode?: "inset" | "outset";
+}
+
+/** Selected sampling counts and conservative allocation estimates, before thread mesh construction. */
+export declare interface ThreadSolidPreflight {
+  /** Uniform axial intervals required only by a requested physical segment-length limit. */
+  readonly axialIntervals: number;
+  /** Start-aligned full-circle segment count used by the surface mesh. */
+  readonly circularSegments: number;
+  /** Conservative surface-row count across profile breaks, ends, and bevel stations. */
+  readonly estimatedRows: number;
+  /** Conservative triangle count used by the selected output allocation policy. */
+  readonly estimatedTriangles: number;
+}
+
 /**
  * Dimensions and independent ring/profile tessellation for a torus around the Z axis.
  */
@@ -4091,21 +3945,6 @@ export declare function transformRegionData(
   tolerance?: GeometryToleranceOptions,
 ): RegionData;
 
-/**
- * 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 placement - Immutable spatial placement or canonical row-major affine matrix.
- * @returns A mesh with fresh transformed positions and copied or reversed indices.
- */
-export declare function transformTriangleMesh(
-  mesh: TriangleMesh,
-  placement: Transform3Input,
-): TriangleMesh;
-
 /**
  * Creates an immutable translation transform.
  *
@@ -4133,13 +3972,11 @@ export declare interface TrapezoidalThreadProfileSpec extends ThreadProfileBaseS
   readonly includedAngle?: number;
 }
 
-/**
- * A topology-preserving indexed triangle mesh with XYZ vertex positions.
- */
+/** A topology-preserving indexed triangle mesh with mutable owned XYZ buffers. */
 export declare interface TriangleMesh {
   /** Three unsigned vertex indices per triangle. */
   readonly indices: Uint32Array;
-  /** Flat XYZ coordinates, three finite values per vertex. */
+  /** Flat XYZ coordinates in millimetres. */
   readonly positions: Float32Array;
 }
 
@@ -4147,8 +3984,9 @@ export declare interface TriangleMesh {
  * Measurements and optional edge-connected topology from one validated mesh traversal.
  */
 export declare interface TriangleMeshAnalysis extends TriangleMeshMeasurements {
-  /** Number of referenced edge-connected boundary shells when `includeTopology` is requested; cavities count separately. */
-  readonly connectedComponentCount?: number;
+  /** Number of surface shells connected by shared indexed edges when includeTopology is requested.
+   * Cavities count separately; shells may be open unless requireClosed is enabled. Coordinates are not welded. */
+  readonly shellCount?: number;
   /** Number of distinct indexed undirected edges when `includeTopology` is requested. */
   readonly edgeCount?: number;
 }
@@ -4157,10 +3995,13 @@ export declare interface TriangleMeshAnalysis extends TriangleMeshMeasurements {
  * 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. */
+  /** Compute indexed edge/shell counts and reject unreferenced vertices; defaults to false. */
   readonly includeTopology?: boolean;
 }
 
+/** Raw construction buffers or immutable captured geometry accepted by mesh utilities. */
+export declare type TriangleMeshInput = TriangleMesh | ImmutableTriangleMesh;
+
 /**
  * Geometric measurements derived from a validated, non-empty triangle mesh.
  */
@@ -4224,7 +4065,7 @@ export declare interface TriangleMeshSignature {
   /** Axis-aligned bounds quantized by `tolerances.position`. */
   readonly bounds: Bounds3Data;
   /** Number of edge-connected closed boundary shells; cavities count separately. */
-  readonly connectedComponentCount: number;
+  readonly shellCount: number;
   /** Total orientable genus across all connected components. */
   readonly genus: number;
   /** Order-independent hash of quantized vertices and oriented triangles. */
@@ -4257,6 +4098,14 @@ export declare interface TriangleMeshSignatureTolerances {
   readonly signedVolume: number;
 }
 
+/** Mesh measurements with the indexed surface-shell and edge counts requested by includeTopology. */
+export declare interface TriangleMeshTopologyAnalysis extends TriangleMeshAnalysis {
+  /** Number of surface shells connected by shared indexed edges; cavities count separately. */
+  readonly shellCount: number;
+  /** Number of distinct indexed undirected edges. */
+  readonly edgeCount: number;
+}
+
 /** Options controlling structural and manufacturing validation of a mesh. */
 export declare interface TriangleMeshValidationOptions {
   /** Permit an empty position and index buffer. Defaults to `false`. */
@@ -4291,40 +4140,52 @@ export declare function triangulateContour(loop: Contour): Uint32Array;
 /**
  * Dimensions, placement, and tessellation for a hollow Z-axis tube.
  */
-export declare interface TubeOptions
-  extends CircularPrimitiveOptions, PrimitiveAttachment {
-  /**
-   * Centers the tube on the Z origin when `true`; otherwise its bottom is at `Z = 0`.
-   * @defaultValue `true`
-   */
-  readonly center?: boolean;
-  /** Total height along Z in millimetres. */
-  readonly height: number;
-  /** Positive inner radius in millimetres. */
-  readonly innerRadius: number;
-  /** Outer radius in millimetres; greater than {@link TubeOptions.innerRadius}. */
-  readonly outerRadius: number;
-}
+export declare type TubeOptions = CircularPrimitiveOptions &
+  PrimitiveAttachment & {
+    /**
+     * Centers the tube on the Z origin when `true`; otherwise its bottom is at `Z = 0`.
+     * @defaultValue `true`
+     */
+    readonly center?: boolean;
+    /** Total height along Z in millimetres. */
+    readonly height: number;
+    /** Inner nominal dimension meets polygon vertices or faces; defaults to vertex. */
+    readonly innerSizing?: RadialSizing;
+    /** Outer nominal dimension meets polygon vertices or faces; defaults to vertex. */
+    readonly outerSizing?: RadialSizing;
+  } & (
+    | {
+        /** Positive nominal inner radius in millimetres. */
+        readonly innerRadius: number;
+        /** Nominal outer radius in millimetres, greater than innerRadius. */
+        readonly outerRadius: number;
+        /** Diameter dimensions cannot be combined with radius dimensions. */
+        readonly innerDiameter?: never;
+        /** Diameter dimensions cannot be combined with radius dimensions. */
+        readonly outerDiameter?: never;
+      }
+    | {
+        /** Positive nominal inner diameter in millimetres. */
+        readonly innerDiameter: number;
+        /** Nominal outer diameter in millimetres, greater than innerDiameter. */
+        readonly outerDiameter: number;
+        /** Radius dimensions cannot be combined with diameter dimensions. */
+        readonly innerRadius?: never;
+        /** Radius dimensions cannot be combined with diameter dimensions. */
+        readonly outerRadius?: never;
+      }
+  );
 
 /**
- * Checks closed indexed topology, triangle intersections, and alternating nested shell orientation.
- *
- * Outward exterior shells and inward cavity shells are accepted. Separate shells must not touch,
- * intersect, or overlap as material. Indexed neighbours may share their own vertex or edge.
+ * Validates a proper rigid transform: finite translation and a right-handed orthonormal rotation.
+ * Scale, shear, reflection, and perspective are rejected within the default angular tolerance.
+ * Returns the original row-major 4x4 matrix without copying or normalizing it.
  *
- * Uses bounded floating-point tests, not exact predicates or repair. Contacts within the selected
- * tolerance reject conservatively. At most 200,000 triangles and 2,000,000 spatial/containment tests
- * are supported; exhausting a ceiling throws COMPLEXITY_LIMIT rather than claiming validity.
- * Input buffers are freshly inspected and never modified; units are millimetres.
- *
- * @param mesh - Closed triangle mesh to inspect.
- * @param options - Optional lower work ceiling and numeric comparison policy.
- * @returns The original mesh after every requested check succeeds.
+ * @throws {@link GeometryError} For a malformed, non-finite, or non-rigid matrix.
  */
-export declare function validateSolidMesh(
-  mesh: TriangleMesh,
-  options?: SolidMeshValidationOptions,
-): TriangleMesh;
+export declare function validateRigidTransform3(
+  transform: Transform3Data,
+): Transform3Data;
 
 /**
  * Validates that a transform is finite, affine, and non-singular.
@@ -4339,23 +4200,6 @@ export declare function validateTransform3(
   tolerance?: GeometryToleranceOptions,
 ): Transform3Data;
 
-/**
- * Validates mesh buffers, indices, triangle area, and optionally closed topology.
- *
- * Closed validation requires exactly two oppositely directed uses per edge, rejecting boundary
- * and non-manifold edges. It establishes edge connectivity without detecting geometric
- * self-intersections between faces. The mesh is neither mutated nor copied.
- *
- * @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;
-
 /** Immutable XY arithmetic; vector operations return new values and measurements return numbers. */
 export declare interface Vector2 {
   /** X coordinate in the vector's coordinate units. */