@metamesh/modeling 0.18.0 → 0.20.0

package/dist/api/index.d.ts

@@ -1,173 +1,115 @@
 import type {
+  AcmeThreadProfileSpec,
+  Bevel,
+  BevelSize,
+  ButtressPressureFlankSide,
+  ButtressThreadProfileSpec,
+  CustomThreadProfileSpec,
+  InternalThreadCutterOptions as InternalThreadCutterSolidOptions,
+  KnuckleHingeBaseSpec,
+  KnuckleHingeSamplingOptions,
+  KnuckleHingeSpec,
+  PrintableThreadFit,
+  PrintableThreadFitPolicy,
+  SquareThreadProfileSpec,
+  ThreadBevelOptions,
+  ThreadEndStyle,
+  ThreadEndTreatmentOptions,
+  ThreadHandedness,
+  ThreadLeadInEnvelope,
+  ThreadLeadInShape,
+  ThreadProfile,
+  ThreadProfileBaseSpec,
+  ThreadProfileSpec,
+  ThreadRidgeOptions,
+  ThreadedNutOptions as ThreadedNutSolidOptions,
+  ThreadedNutShape,
+  ThreadedRodOptions as ThreadedRodSolidOptions,
+  TrapezoidalThreadProfileSpec,
+  TriangularThreadProfileSpec,
+} from "@metamesh/modeling/geometry/mechanical";
+import type {
+  Anchor3,
+  AttachOptions,
+  Bounds2,
+  Bounds2Data,
+  Bounds2Input,
+  Bounds3,
+  Bounds3Data,
+  Bounds3Input,
+  ChamferedEdgeTreatment,
+  CircleContourOptions,
+  CircularPrimitiveOptions,
+  Contour,
+  CorrespondingComponent,
+  CorrespondingContour,
+  CorrespondingProfile,
+  CorrespondingProfileStation,
+  CurveSamplingOptions,
+  EdgeTreatment,
+  EllipseContourOptions,
+  ExtrusionSamplingOptions,
+  Frame3,
+  GeometryResolution,
+  GeometrySamplingLimits,
+  GeometryToleranceOptions,
+  GridPatternOptions,
   ImmutableBuffer,
-  ImmutableTriangleMesh,
+  LinearPatternOptions,
+  LoftPlacement,
+  ModelingLimits,
   NumericArray,
+  Path2,
+  Path2Data,
+  Path2Input,
+  Path3,
+  Path3Data,
+  Path3Input,
+  PathLocation,
+  PathNormalGuide,
+  PathPatternOptions,
+  PathResamplingOptions,
+  PathStation,
+  PathSubdivisionOptions,
+  Pivot2Options,
+  Pivot3Options,
+  PolygonData,
+  ProfiledEdgeTreatment,
+  RadialPatternOptions,
+  RadialSizing,
+  RadialSizingOptions,
+  RectangleContourOptions,
+  RectangleCornerTreatment,
+  RectangleCornerTreatments,
+  RegionData,
+  RegularPolygonContourOptions,
+  ResolvedGeometryResolution,
+  RoundedEdgeTreatment,
+  SmoothEdgeTreatment,
+  StarContourOptions,
+  StrokeCap,
+  StrokeJoin,
+  StrokeOptions,
+  Transform2,
+  Transform2Data,
+  Transform2Input,
+  Transform3,
+  Transform3Data,
+  Transform3Input,
+  Vector2,
+  Vector2Data,
+  Vector2Input,
+  Vector3,
+  Vector3Data,
+  Vector3Input,
+  VectorTextLayout,
+  VectorTextMetrics,
 } from "@metamesh/modeling/geometry";
-export type {
-  ImmutableBuffer,
+import type {
+  ExtrudeMeshOptions,
   ImmutableTriangleMesh,
-  NumericArray,
-} from "@metamesh/modeling/geometry";
-/** Immutable modeling recipes and math values; the host owns geometry evaluation. @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;
-}
-
-/**
- * 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: Vector3Data;
-  /** World-space attachment position. */
-  readonly position: Vector3Data;
-  /** Roll guide projected into the plane perpendicular to `direction`. */
-  readonly up: Vector3Data;
-}
-
-/** Options controlling how one anchor is attached to another. */
-export declare interface AttachOptions {
-  /** Align outward directions face-to-face (`opposed`) or in parallel (`same`). */
-  readonly alignment?: "opposed" | "same";
-  /** Separation along the target anchor's outward direction in model units. */
-  readonly gap?: number;
-  /** Additional right-handed roll about the attached direction, in degrees. */
-  readonly spin?: number;
-  /** Optional numeric comparison overrides. */
-  readonly tolerance?: GeometryToleranceOptions;
-}
-
-/** 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. */
-  size(): Vector2;
-  /** Returns the midpoint in millimetres. */
-  center(): Vector2;
-  /** Tests positioned XY containment, including touching boundaries. */
-  containsBounds(other: Bounds2Input): boolean;
-  /** Returns this value's frozen plain record; repeated calls do not allocate. */
-  toData(): Bounds2Data;
-}
-
-/**
- * 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 10.0.0 or newer in major 10.
- */
-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 {
-  /** Inclusive maximum X/Y coordinates. */
-  readonly max: Vector2Data;
-  /** Inclusive minimum X/Y coordinates. */
-  readonly min: Vector2Data;
-}
-
-/** 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. */
-  size(): Vector3;
-  /** Returns the midpoint in millimetres. */
-  center(): Vector3;
-  /** Tests positioned XYZ containment, including touching boundaries. */
-  containsBounds(other: Bounds3Input): boolean;
-  /** Returns this value's frozen plain record; repeated calls do not allocate. */
-  toData(): Bounds3Data;
-}
-
-/**
- * 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 10.0.0 or newer in major 10.
- */
-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 {
-  /** Inclusive maximum X/Y/Z coordinates. */
-  readonly max: Vector3Data;
-  /** Inclusive minimum X/Y/Z coordinates. */
-  readonly min: Vector3Data;
-}
-
-/** 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;
-    };
+  TriangleMesh,
+} from "@metamesh/modeling/geometry/mesh";
 
 /**
  * Axis-aligned box with uniform or disjoint named edge/group treatments.
@@ -219,166 +161,79 @@ export declare interface BoxOptions extends PrimitiveAttachment {
   readonly treatment?: EdgeTreatment | BoxEdgeTreatments;
 }
 
-/** Axial side carrying the near-normal pressure flank of a buttress thread. */
-export declare type ButtressPressureFlankSide = "negative" | "positive";
-
-/** Asymmetric printable buttress profile with 7/45-degree flanks. */
-export declare interface ButtressThreadProfileSpec extends ThreadProfileBaseSpec {
-  /** Selects the asymmetric printable buttress profile family. */
-  readonly kind: "buttress";
-  /**
-   * Radial depth in millimetres.
-   * @defaultValue `0.66271 * pitch`
-   */
-  readonly depth?: number;
-  /**
-   * Axial side of each tooth carrying the 7-degree pressure flank. The opposite side uses the
-   * 45-degree clearance flank.
-   * @defaultValue `"positive"`
-   */
-  readonly pressureFlankSide?: ButtressPressureFlankSide;
-}
-
-/**
- * A planar edge or corner chamfer with equal or independent surface setbacks.
- */
-export declare interface ChamferedEdgeTreatment {
-  /** Selects a straight bevel between adjoining surfaces. */
-  readonly kind: "chamfer";
-  /** Millimetre setbacks, equal or [first surface, second surface]. Zero or [0, 0] leaves the edge untreated; otherwise both must be positive and fit without overlap. */
-  readonly distance: number | readonly [first: number, second: number];
-}
-
 /**
  * Centered circular section.
  *
  * @example Size to polygon faces
  * ```ts
- * circle({ diameter: 12, sizing: "face" });
+ * circle({ diameter: 12, sizing: "face" }).extrude({ height: 3 });
  * ```
  */
 export declare function circle(options: CircleOptions): Section;
 
-/** Circular profile dimensions with exactly one radius or diameter and explicit sampling. */
-export declare type CircleContourOptions = CircularPrimitiveOptions &
-  RadialSizingOptions &
-  (
-    | {
-        /** Positive nominal radius in millimetres. */
-        readonly radius: number;
-        /** Diameter is unavailable when radius is supplied. */
-        readonly diameter?: never;
-      }
-    | {
-        /** Positive nominal diameter in millimetres. */
-        readonly diameter: number;
-        /** Radius is unavailable when diameter is supplied. */
-        readonly radius?: never;
-      }
-  );
-
-/**
- * Circular dimensions with exactly one nominal radius or diameter.
- */
+/** Circular dimensions with exactly one nominal radius or diameter. */
 export declare type CircleOptions = CircleContourOptions & PrimitiveAttachment;
 
 /**
- * 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;
-}
-
-/** A lazy session-owned reader. Calling it tracks its output in the current computation. */
-export declare interface Computed<T> {
-  /** Compile-time ownership brand; readers are created by the engine's context helper. */
-  readonly [computedBrand]: "Computed";
-  /** Reads immutable data or a deferred recipe; evaluation is synchronous and cached. */
-  (): ImmutableValue<T>;
-}
-
-declare const computedBrand: unique symbol;
-
-/** A value supplied immediately or by a lazy computed reader. */
-export declare type ComputedValue<T> = T | Computed<T>;
-
-/**
- * A sampled closed two-dimensional boundary whose first point is not repeated at the end.
- *
- * Polygon exteriors are counter-clockwise and holes are clockwise. Algorithms
- * may reject duplicate adjacent points or fewer than three effective vertices.
- * Use PolygonData to assign an exterior and its holes, or ProfileContour2 for identified curve spans.
+ * Creates a round or chamfer cutter at the origin for three perpendicular positive-axis faces.
+ * Complements matching edge cutters; construction, placement, and subtraction remain explicit.
  *
- * @see {@link PolygonData}
- * @see [ProfileContour2](/docs/reference/geometry/ProfileContour2)
+ * @example Amber corner cutter · Blue three-edge junction
+ * ```ts
+ * import { box, cornerCutter, edgeCutter, generate } from "@metamesh/modeling";
+ * import { transform3 } from "@metamesh/modeling/geometry";
+ *
+ * const treatment = { kind: "round", radius: 5 } as const;
+ * const cutter = cornerCutter({ treatment, excess: 0 });
+ * const edge = edgeCutter({ length: 12, treatment, excess: 0 });
+ * const result = box({ size: 12, center: false }).subtract([
+ *   edge,
+ *   edge.rotate([0, -90, 0]).translate([12, 0, 0]),
+ *   edge.rotate([90, 0, 0]).translate([0, 12, 0]),
+ *   cutter,
+ * ]);
+ * // Display the concave mask and completed upper junction from opposite sides.
+ * const view = (shape: typeof result, center: number, height: number) =>
+ *   shape.translate([-center, -center, 0]).mirror([0, 0, 1]).translate([0, 0, height]).rotate([0, 0, 90]);
+ * export default generate(({ part }) => [
+ *   part("cutter", { geometry: cutter.translate([-2.5, -2.5, 0]).rotate([0, 0, -90]), color: "#f6ad55", transform: transform3().translate([-8, -8, 0]) }),
+ *   part("result", { geometry: view(result, 6, 12), color: "#4f83a6", transform: transform3().translate([8, 8, 0]) }),
+ * ]);
+ * ```
  */
-export declare type Contour = readonly Vector2Data[];
-
-/** 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: Contour;
-  /** 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;
-};
+export declare function cornerCutter(options: CornerCutterOptions): Solid;
 
 /**
- * Explicit physical sampling and allocation policy for reusable curves.
+ * A subtractive corner transition for material occupying the positive XYZ octant.
+ * Round treatments share their lattice with right-angle edge cutters; full-circle segment requests round up to a multiple of four.
  */
-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. */
+export declare interface CornerCutterOptions extends PrimitiveAttachment {
+  /** Round sphere or triangular chamfer meeting three equal perpendicular edge treatments. */
+  readonly treatment: CornerCutterTreatment;
+  /** Numerical extension outside the three material faces, in millimetres; defaults to 0.05. */
+  readonly excess?: number;
+  /** Physical sphere sampling; explicit round-treatment sampling takes precedence. */
   readonly resolution?: GeometryResolution;
-  /** Output vertex ceiling of at least two; may only lower limits.maxPathPoints. */
-  readonly maxVertices?: number;
-  /** Explicit sampling ceilings; omitted values use package defaults without ambient state. */
-  readonly limits?: Partial<GeometrySamplingLimits>;
+  /** Local allocation ceilings may only lower the evaluating host's limits. */
+  readonly limits?: Partial<ModelingLimits>;
 }
 
-/** Caller-defined periodic axial/radial profile in millimetres. */
-export declare interface CustomThreadProfileSpec extends ThreadProfileBaseSpec {
-  /** Selects a caller-defined periodic profile. */
-  readonly kind: "custom";
-  /**
-   * Open path spanning exactly `[-pitch/2, pitch/2]`, with both endpoints on the minor envelope,
-   * one connected ridge, one contiguous crest, and radial zero at the major envelope.
-   */
-  readonly points: readonly Vector2Data[];
+/** Symmetric trihedral treatments that meet three matching perpendicular edge treatments. */
+export declare type CornerCutterTreatment =
+  | RoundedEdgeTreatment
+  | {
+      /** Selects a flat triangular corner transition. */
+      readonly kind: "chamfer";
+      /** Equal adjoining edge setbacks in millimetres; zero disables the cutter. */
+      readonly distance: number;
+    };
+
+/** Numerical cutter extension outside its nominal +Z interval, in millimetres. */
+export declare interface CutterOverrun {
+  /** Nonnegative extension below Z=0; defaults to zero. */
+  readonly bottom?: number;
+  /** Nonnegative extension above the nominal height or length; defaults to zero. */
+  readonly top?: number;
 }
 
 /**
@@ -438,51 +293,62 @@ export declare interface DiagnosticOptions<P> {
 }
 
 /**
- * Uniform finishing vocabulary shared by applicable solid edges and profile corners.
+ * Creates a cutter for one straight convex edge along +Z, with its sharp reference at XY=0.
+ * Position it explicitly before subtraction; the included material angle defaults to 90 degrees.
+ *
+ * @example Amber cutter · Blue rounded edge
+ * ```ts
+ * import { box, edgeCutter, generate } from "@metamesh/modeling";
+ * import { transform3 } from "@metamesh/modeling/geometry";
+ *
+ * const cutter = edgeCutter({ length: 18, treatment: { kind: "round", radius: 6 }, excess: 0 });
+ * const result = box({ size: 18, center: false }).subtract(cutter);
+ * // Turn the concave mask and convex result toward the viewer independently.
+ * export default generate(({ part }) => [
+ *   part("cutter", { geometry: cutter.translate([-3, -3, 0]).rotate([0, 0, -90]), color: "#f6ad55", transform: transform3().translate([-11, -11, 0]) }),
+ *   part("result", { geometry: result.translate([-9, -9, 0]).rotate([0, 0, 90]), color: "#4f83a6", transform: transform3().translate([11, 11, 0]) }),
+ * ]);
+ * ```
  */
-export declare type EdgeTreatment =
-  | ChamferedEdgeTreatment
-  | RoundedEdgeTreatment
-  | SmoothEdgeTreatment
-  | ProfiledEdgeTreatment;
+export declare function edgeCutter(options: EdgeCutterOptions): Solid;
+
+/**
+ * A subtractive treatment along one explicitly positioned straight convex edge.
+ * Right-angle rounds share the corner sphere's sampling lattice; full-circle segment requests round up to a multiple of four.
+ */
+export declare interface EdgeCutterOptions extends PrimitiveAttachment {
+  /** Positive nominal edge length along +Z from Z=0, in millimetres. */
+  readonly length: number;
+  /** Material angle counterclockwise from +X toward +Y, strictly between 0° and 180°; defaults to 90°. */
+  readonly angle?: number;
+  /** Profile from the first material face to the second; uses the shared surface-setback vocabulary. */
+  readonly treatment: EdgeTreatment;
+  /** Numerical extension outside the two material faces, in millimetres; defaults to 0.05. Does not change the treatment. */
+  readonly excess?: number;
+  /** Numerical longitudinal extension; both ends default to zero. */
+  readonly overrun?: CutterOverrun;
+  /** Physical curve sampling; explicit treatment sampling overrides these defaults. */
+  readonly resolution?: GeometryResolution;
+  /** Local allocation ceilings may only lower the evaluating host's limits. */
+  readonly limits?: Partial<ModelingLimits>;
+}
 
 /**
  * Centered elliptical section.
  *
  * @example Ellipse by full dimensions
  * ```ts
- * ellipse({ size: [30, 20] });
+ * ellipse({ size: [30, 20] }).extrude({ height: 3 });
  * ```
  */
 export declare function ellipse(options: EllipseOptions): Section;
 
-/**
- * Ellipse dimensions with exactly one XY radii or full-size tuple and explicit sampling.
- */
-export declare type EllipseContourOptions = CircularPrimitiveOptions &
-  (
-    | {
-        /** Positive XY radii in millimetres; mutually exclusive with size. */
-        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: Vector2Input;
-        /** XY radii are unavailable when size is supplied. */
-        readonly radius?: never;
-      }
-  );
-
-/**
- * Ellipse dimensions in local XY, with exactly one radii or full-size tuple.
- */
+/** Ellipse dimensions in local XY, with exactly one radii or full-size tuple. */
 export declare type EllipseOptions = EllipseContourOptions &
   PrimitiveAttachment;
 
 /**
- * Independent inward finishing on primitive or straight convex extrusion ends.
+ * Independent inward finishing on primitive or source-corresponding extrusion ends.
  * Zero amounts leave the end untreated, including when all ends are disabled.
  */
 export declare interface EndTreatments {
@@ -496,10 +362,12 @@ export declare interface EndTreatments {
  * Extrudes a filled Section or explicit corresponding contours along +Z with degree twist and top scaling.
  * Use `section.extrude(options)` in fluent sequences, or this function for generic profile inputs.
  *
+ * @param shape - Filled XY profile in millimetres.
+ *
  * @example Extrude
  * ```ts
- * import { extrude, matchProfiles } from "@metamesh/modeling";
- * import { rectangleProfile } from "@metamesh/modeling/geometry";
+ * import { extrude } from "@metamesh/modeling";
+ * import { matchProfiles, rectangleProfile } from "@metamesh/modeling/geometry";
  *
  * const [profile] = matchProfiles([rectangleProfile({ size: [30, 20] })]);
  * extrude(profile!, { height: 8 });
@@ -510,52 +378,18 @@ export declare function extrude(
   options: ExtrudeOptions,
 ): Solid;
 
-/**
- * Dimensions and sampling for pure +Z mesh extrusion, without end treatments.
- */
-export declare interface ExtrudeMeshOptions extends ExtrusionSamplingOptions {
-  /** Positive extrusion height in millimetres. */
-  readonly height: number;
-  /** Center the extrusion on Z; otherwise its bottom is at zero. Defaults to false. */
-  readonly center?: boolean;
-}
-
 /** Native +Z extrusion with optional inward end treatments. */
 export declare interface ExtrudeOptions extends ExtrudeMeshOptions {
-  /** Independent inward end treatments on straight convex single-contour extrusions. */
+  /** Independent inward treatments on every material rim. Twisted extrusions admit chamfers with cap and normal-section wall setbacks; other treatments require zero twist. Enabled treatments require unit scale and preserve boundary topology. The base slices grid is retained, with additional treatment/refinement rings where necessary. */
   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 | Vector2Input;
-  /** Finite rotation of the top profile about +Z, in degrees; defaults to zero. */
-  readonly twist?: number;
-}
-
-/** A right-handed orthonormal coordinate frame expressed in world coordinates. */
-export declare interface Frame3 {
-  /** World-space origin of the local frame. */
-  readonly origin: Vector3Data;
-  /** Unit vector defining the local +X axis. */
-  readonly xAxis: Vector3Data;
-  /** Unit vector defining the local +Y axis. */
-  readonly yAxis: Vector3Data;
-  /** Unit vector defining the local +Z axis. */
-  readonly zAxis: Vector3Data;
-}
-
 /**
  * Defines a typed model without executing it. Parameters are an object map of capturable data;
  * runtime capture rejects arrays at the root, ordinary class instances, mutable buffers, and functions.
- * Supply live capabilities through services. Use `computed` only for work worth reusing.
+ * Supply live capabilities through services. Use `memo` only for work worth reusing.
+ *
+ * @param callback - Synchronous callback returning one part or a readonly part array.
  *
  * @example A simple model
  * ```ts
@@ -577,7 +411,7 @@ export declare type GenerateCallback<
   context: GenerateContext<P, S>,
 ) => PartDeclaration | readonly PartDeclaration[];
 
-/** The sole synchronous authoring context, supplied independently of Studio. */
+/** Synchronous authoring context with immutable parameters and host-prepared services. */
 export declare interface GenerateContext<
   P extends object,
   S = Record<never, never>,
@@ -586,20 +420,16 @@ export declare interface GenerateContext<
   readonly params: ImmutableValue<P>;
   /** Host-prepared readonly synchronous capabilities, fixed for the session. */
   readonly services: Readonly<S>;
-  /**
-   * Registers a lazy pure calculation and automatically tracks parameter and computed-reader reads.
-   * Optional dependencies add changing outer captures; entries compare with Object.is. Objects and
-   * arrays must be deeply immutable. An empty list still tracks reads inside the callback.
-   */
-  readonly computed: <T>(
-    id: string,
-    callback: () => T,
-    dependencies?: readonly unknown[],
-  ) => Computed<T>;
+  /** Effective immutable sampling defaults, fixed for this session; pass explicitly to pure geometry operations. */
+  readonly resolution: Readonly<ResolvedGeometryResolution>;
+  /** Effective immutable resource limits after host ceilings and session overrides are applied. */
+  readonly limits: Readonly<ModelingLimits>;
+  /** Reuses a pure synchronous function; pass changing inputs as arguments and keep helpers stable. */
+  readonly memo: Memo;
   /** Declares a semantic part with identity placement, or explicit placement and appearance. */
   readonly part: (
     id: string,
-    input: ComputedValue<PartGeometry> | PartOptions,
+    input: PartGeometry | PartOptions,
   ) => PartDeclaration;
   /** Immediately aborts on false; geometry observations in the condition run first.
    * This diagnostic helper does not narrow TypeScript types; use an explicit conditional guard when needed.
@@ -624,7 +454,7 @@ export declare interface GenerationDiagnostic {
   readonly path?: readonly (string | number)[] | undefined;
 }
 
-/** A user-correctable assertion failure. Successful computation caches never retain failures. */
+/** A user-correctable assertion failure. Successful memo caches never retain failures. */
 export declare class GenerationError extends Error {
   /** Issues reached in normal JavaScript order, ending with the first failed assertion. */
   readonly diagnostics: readonly GenerationDiagnostic[];
@@ -632,101 +462,11 @@ export declare class GenerationError extends Error {
   constructor(diagnostics: readonly GenerationDiagnostic[]);
 }
 
-/**
- * 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 `normalizeContour` 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 maxSegments?: number;
-  /** Lower full-circle segment count; defaults to 16 or a lower selected circular ceiling. */
-  readonly minSegments?: 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;
-}
-
 /**
  * XY or XYZ copies, optionally centered or placed in an explicit frame.
  *
+ * @param source - Recipe or factory called once per copy, in zero-based order.
+ *
  * @example Centered XY grid
  * ```ts
  * gridPattern(box({ size: 4 }), { count: [3, 2], spacing: [10, 10], center: true });
@@ -737,38 +477,16 @@ export declare function gridPattern(
   options: GridPatternOptions,
 ): readonly Solid[];
 
-/** Repeats a filled Section on an XY grid; any explicit frame must preserve the XY plane. */
+/**
+ * Repeats a filled Section on an XY grid; any explicit frame must preserve the XY plane.
+ *
+ * @param source - Recipe or factory called once per copy, in zero-based order.
+ */
 export declare function gridPattern(
   source: PatternSource<Section>,
   options: GridPatternOptions<2>,
 ): readonly Section[];
 
-/**
- * XY or XYZ grid with X varying fastest. The first item starts at the local origin.
- * Dimension 2 restricts counts and spacing to XY; any frame must preserve the XY plane.
- */
-export declare type GridPatternOptions<Dimension extends 2 | 3 = 3> = {
-  /** Center the complete distribution around its local origin; defaults to false. */
-  readonly center?: boolean;
-  /** Optional right-handed local axes and origin for the grid. */
-  readonly frame?: Frame3;
-} & (
-  | {
-      /** Positive integer counts on X and Y. */
-      readonly count: Vector2Data;
-      /** Signed millimetres between adjacent copies on X and Y. */
-      readonly spacing: Vector2Data;
-    }
-  | (Dimension extends 3
-      ? {
-          /** Positive integer counts on X, Y and Z. */
-          readonly count: Vector3Data;
-          /** Signed millimetres between adjacent copies on X, Y and Z. */
-          readonly spacing: Vector3Data;
-        }
-      : never)
-);
-
 /**
  * Closed rectilinear top above a flat base, with uniform or explicit XY coordinates.
  *
@@ -838,40 +556,58 @@ export declare type HeightfieldOptions = {
 );
 
 /**
- * Declares a +Z hole or blind-pocket cutter with explicit end overrun in millimetres.
+ * Declares a +Z hole or blind-pocket cutter with independent opening treatments.
  *
  * @remarks
- * Choose exactly one circular diameter or existing Section. A 45-degree entry chamfer
- * supports one strictly convex contour without holes; plain profiles may have any topology.
- * Circular entries retain nominal frustum radii; profile entries offset the supplied polygon edges.
- * Circular head recesses are mutually exclusive with entryChamfer. Both overrun ends default
- * to zero, so the nominal bottom remains at Z=0 and blind pocket floors are preserved.
+ * Choose exactly one circular diameter or existing Section. Finished profiles require one
+ * strictly convex contour without holes; plain profiles may have any topology. Opening treatments
+ * widen the mouth while retaining a positive nominal throat. Circular openings also admit
+ * counterbores and countersinks. An omitted opening leaves that end unchanged.
+ * Overrun extends each terminal cross section outside Z=0..height; both ends default to zero,
+ * preserving blind-pocket floors. It is independent of manufacturing clearance.
  * Existing Section samples are authoritative; limits and unspecified circular sampling belong
  * to the evaluating host.
  *
- * @example A blind hex pocket with an open top
+ * @example Amber cutter · Blue blind hex pocket
  * ```ts
- * holeCutter({
- *   profile: regularPolygon({ sides: 6, radius: 3.5, sizing: "face", rotation: 30 }),
- *   height: 12, entryChamfer: 0.5, overrun: { top: 0.05 },
+ * import { box, generate, holeCutter, regularPolygon } from "@metamesh/modeling";
+ * import { transform3 } from "@metamesh/modeling/geometry";
+ *
+ * const cutter = holeCutter({
+ *   profile: regularPolygon({ sides: 6, radius: 5, sizing: "face", rotation: 30 }),
+ *   height: 5,
+ *   openings: { top: { kind: "chamfer", distance: 1.5 } },
+ *   overrun: { top: 0.05 },
  * });
+ * // A 3 mm floor remains beneath the pocket. Display the cutter separately on the left.
+ * const stock = box({ size: [22, 20, 8] }).translate([0, 0, 4]);
+ * const result = stock.subtract(cutter.translate([0, 0, 3]));
+ * export default generate(({ part }) => [
+ *   part("cutter", { geometry: cutter, color: "#f6ad55", transform: transform3().translate([-12, -12, 0]) }),
+ *   part("result", { geometry: result, color: "#4f83a6", transform: transform3().translate([12, 12, 0]) }),
+ * ]);
  * ```
  */
 export declare function holeCutter(options: HoleCutterOptions): Solid;
 
+/**
+ * A finished circular opening: outward edge treatment or screw seat, one per end.
+ * Treatment setbacks measure radial expansion first and axial depth second. A round radius is
+ * circular in that radial/axial section. Profile points run from [mouth expansion, 0] to [0, depth].
+ */
+export declare type HoleCutterOpening = EdgeTreatment | HoleCutterRecess;
+
 /**
  * A deferred +Z hole or pocket cutter, with exactly one circular diameter or existing Section.
- * Profile entry chamfers expand one strictly convex contour without holes by parallel-edge offsets;
- * the supplied sampled boundary remains authoritative. Plain profile cutters accept any Section.
- * Circular entry chamfers retain nominal circular/frustum radii under the selected radial sizing.
+ * Openings widen nominal ends without changing the untreated bore. Both depths together must
+ * leave a positive untreated interval. Overrun extends the terminal mouth unchanged; omitted
+ * ends and overrun preserve blind-pocket floors. No support surface or printer fit is inferred.
  */
 export declare type HoleCutterOptions = {
-  /** Positive nominal depth along +Z, starting exactly at Z=0. */
+  /** Positive nominal depth in millimetres along +Z, starting exactly at Z=0. */
   readonly height: number;
-  /** Opening carrying the recess or entry chamfer; defaults to top. */
-  readonly face?: "bottom" | "top";
   /** Extra length outside each nominal face; both ends default to zero. */
-  readonly overrun?: HoleCutterOverrun;
+  readonly overrun?: CutterOverrun;
   /** Operation-level physical sampling; an existing Section retains its sampled boundary. */
   readonly resolution?: GeometryResolution;
   /** Local allocation ceilings may only lower the evaluating host's limits. */
@@ -883,44 +619,36 @@ export declare type HoleCutterOptions = {
         readonly diameter: number;
         /** Unavailable in this input form. */
         readonly profile?: never;
-      } & (
-        | {
-            /** Nonnegative 45-degree entry setback; must be smaller than height. Defaults to zero. */
-            readonly entryChamfer?: number;
-            /** Unavailable in this input form. */
-            readonly recess?: never;
-          }
-        | {
-            /** Circular head seating; mutually exclusive with entryChamfer. */
-            readonly recess: HoleCutterRecess;
-            /** Unavailable in this input form. */
-            readonly entryChamfer?: never;
-          }
-      ))
+        /** Independent nominal mouths at Z=0 and Z=height; omitted ends remain plain. */
+        readonly openings?: {
+          /** Opening at Z=0, expanding outward while its treatment reaches toward +Z. */
+          readonly bottom?: HoleCutterOpening;
+          /** Opening at Z=height, expanding outward while its treatment reaches toward -Z. */
+          readonly top?: HoleCutterOpening;
+        };
+      })
   | {
       /** Local XY material to remove, retaining its position, orientation and physical sampling. */
       readonly profile: Section;
       /** Unavailable in this input form. */
       readonly diameter?: never;
       /** Unavailable in this input form. */
-      readonly recess?: never;
-      /** Unavailable in this input form. */
       readonly segments?: never;
       /** Unavailable in this input form. */
       readonly sizing?: never;
-      /** Nonnegative 45-degree entry setback for a strictly convex single contour without holes. */
-      readonly entryChamfer?: number;
+      /**
+       * Parallel-edge opening offsets on one strictly convex contour without holes.
+       * Plain or zero-treated profiles accept any Section topology. Existing samples remain authoritative.
+       */
+      readonly openings?: {
+        /** Opening at Z=0; first setback expands the contour and second reaches toward +Z. */
+        readonly bottom?: EdgeTreatment;
+        /** Opening at Z=height; first setback expands the contour and second reaches toward -Z. */
+        readonly top?: EdgeTreatment;
+      };
     }
 );
 
-/** Explicit extra cutter length outside the nominal Z=0..height interval, in millimetres. */
-export declare interface HoleCutterOverrun {
-  /** Extension below Z=0. Omitted means zero, preserving a blind pocket's floor. */
-  readonly bottom?: number;
-  /** Extension above Z=height. Omitted means zero. */
-  readonly top?: number;
-}
-
 /** Circular screw seating dimensions in millimetres; allowances belong to the caller. */
 export declare type HoleCutterRecess =
   | {
@@ -928,7 +656,7 @@ export declare type HoleCutterRecess =
       readonly kind: "counterbore";
       /** Positive seat diameter greater than the bore, in millimetres. */
       readonly diameter: number;
-      /** Positive seat depth no greater than height, in millimetres. */
+      /** Positive seat depth in millimetres; both openings must leave an untreated bore interval. */
       readonly depth: number;
     }
   | {
@@ -936,7 +664,7 @@ export declare type HoleCutterRecess =
       readonly kind: "countersink";
       /** Positive mouth diameter greater than the bore, in millimetres. */
       readonly diameter: number;
-      /** Full included angle strictly between zero and 180 degrees; derived depth must fit height. */
+      /** Full included angle strictly between zero and 180 degrees; derived depth must fit. */
       readonly includedAngle: number;
     };
 
@@ -970,22 +698,7 @@ export declare type HullOptions =
       readonly points?: never;
     };
 
-/**
- * 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 immutableBuffer<T extends NumericArray>(
-  source: T,
-): ImmutableBuffer<T>;
+declare const immutableBufferBrand: unique symbol;
 
 /**
  * Deeply readonly view of captured generation data, including nested arrays and tuples.
@@ -1008,7 +721,7 @@ export declare function implicit(options: ImplicitOptions): Solid;
 
 /** Positive-inside sampling, bounded to 4M native BCC grid slots and 8M field calls. */
 export declare interface ImplicitOptions {
-  /** Positive-inside scalar field evaluated at finite XYZ points. */
+  /** Positive-inside scalar field evaluated at finite XYZ points in millimetres. */
   readonly field: (point: Vector3Data) => number;
   /** Axis-aligned XYZ bounds in millimetres. */
   readonly bounds: Bounds3Data;
@@ -1023,32 +736,33 @@ export declare interface ImplicitOptions {
 /**
  * Compensated internal threaded cutter.
  *
- * @example Internal thread
+ * @example Amber thread cutter · Blue cutaway result
  * ```ts
- * import { cylinder, internalThreadCutter } from "@metamesh/modeling";
- * import { threadProfile } from "@metamesh/modeling/geometry";
+ * import { box, cylinder, generate, internalThreadCutter } from "@metamesh/modeling";
+ * import { transform3 } from "@metamesh/modeling/geometry";
+ * import { threadProfile } from "@metamesh/modeling/geometry/mechanical";
+ *
  * const profile = threadProfile({ kind: "triangular", pitch: 1.75 });
  * const body = cylinder({ diameter: 20, height: 12, center: false });
  * const cutter = internalThreadCutter({ nominalMajorDiameter: 12, length: 12, profile });
- * body.subtract([cutter]);
+ * // Remove the front quarter of the stock to expose the actual internal thread.
+ * const cutaway = box({ size: [11, 11, 14], center: false }).translate([0, -11, -1]);
+ * const result = body.subtract([cutter, cutaway]);
+ * export default generate(({ part }) => [
+ *   part("cutter", { geometry: cutter, color: "#f6ad55", transform: transform3().translate([-12, -12, 0]) }),
+ *   part("result", { geometry: result, color: "#4f83a6", transform: transform3().translate([12, 12, 0]) }),
+ * ]);
  * ```
  */
 export declare function internalThreadCutter(
-  options: InternalThreadCutterOptions,
+  options: InternalThreadCutterSolidOptions,
 ): Solid;
 
-/** Options for a compensated internal-thread subtraction tool along +Z. */
-export declare interface InternalThreadCutterOptions
-  extends Omit<ThreadRidgeOptions, "majorDiameter">, ThreadBevelOptions {
-  /** Printable fit or caller-calibrated allowances. Default: `normal`. */
-  readonly fit?: PrintableThreadFit | PrintableThreadFitPolicy;
-  /** Nominal major diameter before female compensation and faceting correction. */
-  readonly nominalMajorDiameter: number;
-}
-
 /**
  * Robust intersection of one or more shapes; empty input rejects during declaration.
  *
+ * @param solids - Operands in shared modeling coordinates.
+ *
  * @example Intersect
  * ```ts
  * intersect([box({ size: 20 }), sphere({ radius: 12 })]);
@@ -1056,16 +770,65 @@ export declare interface InternalThreadCutterOptions
  */
 export declare function intersect(solids: readonly Solid[]): Solid;
 
-/** Native filled section intersection; dimensions cannot be mixed. */
+/**
+ * Filled Section intersection; dimensions cannot be mixed.
+ *
+ * @param sections - Operands in shared XY coordinates.
+ */
 export declare function intersect(sections: readonly Section[]): Section;
 
 /**
- * Recognizes structured geometry errors from separately bundled Modeling copies in the same realm.
+ * Fuses two positioned solids with a dimensioned transition at the feature's source datum.
+ *
+ * Requires a local straight feature collar and a continuous support patch single-valued along
+ * that collar's axis. Angled and curved sampled supports are admitted when those proofs hold.
+ * Width is a parallel-edge offset; height is axial rise above local contact, both in millimetres.
+ * The default smooth profile matches tangents; kind "straight" gives a linear bevel profile.
+ * Neither operand moves, loses material, or changes sampling. The result has no inherited anchors.
+ * This operation promises neither a circular radius, a constant bevel angle, nor global curvature continuity.
  *
- * 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.
+ * @param base - Support solid in shared modeling coordinates.
+ * @param feature - Positioned feature that owns the source datum.
+ *
+ * @example Join a mounting boss
+ * ```ts
+ * const base = box({ size: [50, 40, 6] });
+ * const feature = cylinder({ diameter: 12, height: 14, center: false }).translate([0, 0, 2]);
+ * base.join(feature, { source: "bottom", transition: { width: 2, height: 3 } });
+ * ```
  */
-export declare function isGeometryError(value: unknown): value is GeometryError;
+export declare function join(
+  base: Solid,
+  feature: Solid,
+  options: JoinOptions,
+): Solid;
+
+/** Options for joining two positioned solids through a validated local straight feature collar. */
+export declare interface JoinOptions {
+  /**
+   * Outward feature-root datum, pointing toward the base. Names resolve lazily on the feature;
+   * explicit anchors use the operands' shared modeling coordinates. The collar grows opposite
+   * this direction, with its roll fixed by the anchor's up vector. Every collar section cut
+   * by the source plane participates, including disconnected roots.
+   */
+  readonly source: string | Anchor3;
+  /** Both dimensions must be positive, or both zero to validate contact and fuse without a blend. */
+  readonly transition: JoinTransition;
+  /** Physical connection sampling. Input solids retain their own captured sampling. */
+  readonly resolution?: GeometryResolution;
+  /** Local allocation ceilings may only lower the evaluating host's limits. */
+  readonly limits?: Partial<ModelingLimits>;
+}
+
+/** Connection profile and setbacks, independent of feature construction. */
+export declare interface JoinTransition {
+  /** Tangent-matching cubic or linear profile. Defaults to "smooth"; neither specifies a radius. */
+  readonly kind?: "smooth" | "straight";
+  /** Nonnegative parallel-edge normal offset in millimetres perpendicular to the feature collar axis. */
+  readonly width: number;
+  /** Nonnegative axial rise in millimetres above the local support contact. */
+  readonly height: number;
+}
 
 /** Portable local geometry; consumers own plates, holes, part declarations, and final placement. */
 export declare interface KnuckleHinge {
@@ -1087,7 +850,6 @@ export declare interface KnuckleHinge {
  * Each half's `chamfer` bevels its barrel outer rims and all web edges. Consumers own plates, screw holes,
  * pin retention, fit policy, and part placement. Added mounting material must preserve the bores.
  * No opening range or collision freedom is implied for arbitrary caller attachments.
- * Compiled Generator packages using this operation require runtime 10.0.0 or newer in major 10.
  *
  * @example Integral-pin hinge with two mounting webs
  * ```ts
@@ -1103,22 +865,6 @@ export declare function knuckleHinge(
   options: KnuckleHingeOptions,
 ): KnuckleHinge;
 
-/** Shared knuckle-joint dimensions in millimetres, independent of mounting geometry. */
-export declare interface KnuckleHingeBaseSpec {
-  /** Total extent along the +X pin axis, centered at the origin. */
-  readonly length: number;
-  /** Number of equal alternating intervals, starting with half A. */
-  readonly knuckleCount: number;
-  /** Outside vertex-sized barrel diameter. */
-  readonly barrelDiameter: number;
-  /** Vertex-sized shaft diameter, including an externally supplied shaft. */
-  readonly pinDiameter: number;
-  /** Nonnegative per-side radial allowance; bores circumscribe this running envelope. */
-  readonly radialClearance: number;
-  /** Nonnegative total air gap between each neighboring pair of knuckle ends. */
-  readonly axialGap: number;
-}
-
 /** Optional mounting and edge treatment for one knuckle owner. */
 export declare interface KnuckleHingeHalfOptions {
   /** Omit for barrels only. Each interval receives one web; disconnected intervals need caller geometry. */
@@ -1142,41 +888,6 @@ export declare type KnuckleHingeOptions = KnuckleHingeSpec &
     readonly halfB?: KnuckleHingeHalfOptions;
   };
 
-/** Shared circular sampling for barrels, shafts, and bores. */
-export declare interface KnuckleHingeSamplingOptions {
-  /** Exact full-circle count, divisible by four and at least four; overrides adaptive sampling. */
-  readonly segments?: number;
-  /** Physical tessellation policy. Exact circular counts must also be divisible by four. */
-  readonly resolution?: GeometryResolution;
-  /** Explicit allocation ceilings; defaults to the pure geometry sampling limits. */
-  readonly limits?: Partial<GeometrySamplingLimits>;
-}
-
-/**
- * Knuckle-joint construction modes and interval ownership.
- *
- * Print-in-place requires an odd count of at least three: A owns both
- * end anchors and the entire shaft. Inserted-pin bores both halves and supplies no shaft.
- * Lift-off requires exactly two intervals; A's integral pin enters B without a far anchor.
- */
-export declare type KnuckleHingeSpec = KnuckleHingeBaseSpec &
-  (
-    | {
-        /** Captive integral shaft or bores for an externally supplied pin. */
-        readonly mode: "print-in-place" | "inserted-pin";
-        /** Engagement applies only to lift-off construction. */
-        readonly pinEngagement?: never;
-      }
-    | {
-        /** Detachable socket on a finite integral pin. */
-        readonly mode: "lift-off";
-        /** Lift-off has one fixed interval and one removable interval. */
-        readonly knuckleCount: 2;
-        /** Positive axial engagement into B, no greater than its knuckle length. */
-        readonly pinEngagement: number;
-      }
-  );
-
 /** Rectangular connection from the axis into a caller-owned mounting body, in millimetres. */
 export declare interface KnuckleHingeWeb {
   /** Direction from the pin axis; independently chosen for each half. */
@@ -1192,6 +903,8 @@ export declare interface KnuckleHingeWeb {
 /**
  * Repeats one solid along a normalized direction.
  *
+ * @param source - Recipe or factory called once per copy, in zero-based order.
+ *
  * @example Three copies along X
  * ```ts
  * linearPattern(box({ size: 4 }), { count: 3, spacing: 10 });
@@ -1202,50 +915,22 @@ export declare function linearPattern(
   options: LinearPatternOptions,
 ): readonly Solid[];
 
-/** Repeats a filled Section along an XY direction, defaulting to +X. */
+/**
+ * Repeats a filled Section along an XY direction, defaulting to +X.
+ *
+ * @param source - Recipe or factory called once per copy, in zero-based order.
+ */
 export declare function linearPattern(
   source: PatternSource<Section>,
   options: LinearPatternOptions<2>,
 ): readonly Section[];
 
 /**
- * Equal linear intervals determined by exactly two of count, spacing and total length.
- * Dimension defaults to 3; Section patterns use 2 and accept XY vector directions.
- */
-export declare type LinearPatternOptions<Dimension extends 2 | 3 = 3> = {
-  /** Direction of repetition; magnitude is ignored. Defaults to +X. */
-  readonly direction?: Dimension extends 2 ? Vector2Input : Vector3Input;
-} & (
-  | {
-      /** Positive copy count, including the original. */
-      readonly count: number;
-      /** Signed nonzero millimetres between adjacent copies. */
-      readonly spacing: number;
-      /** Determined by count and spacing. */
-      readonly length?: never;
-    }
-  | {
-      /** Positive copy count, including the original. */
-      readonly count: number;
-      /** Signed millimetres from first to last copy; zero only for one copy. */
-      readonly length: number;
-      /** Determined by count and length. */
-      readonly spacing?: never;
-    }
-  | {
-      /** Signed nonzero millimetres between adjacent copies. */
-      readonly spacing: number;
-      /** Signed first-to-last millimetres; a nonnegative whole multiple of spacing. */
-      readonly length: number;
-      /** Determined by spacing and length. */
-      readonly count?: never;
-    }
-);
-
-/**
- * Lofts Sections and point loops at z heights or frames. Known primitive landmarks are retained;
+ * Lofts Sections and point contours at z heights or affine transforms. Known primitive landmarks are retained;
  * other profiles default to direct correspondence, preserving their supplied seams.
  *
+ * @param stations - Ordered profiles at millimetre Z heights or affine placements.
+ *
  * @example Loft
  * ```ts
  * loft([
@@ -1259,7 +944,11 @@ export declare function loft(
   options?: LoftOptions,
 ): Solid;
 
-/** Lofts explicit corresponding contours, including holes and collapsed logical slots. */
+/**
+ * Lofts explicit corresponding contours, including holes and collapsed logical slots.
+ *
+ * @param stations - Ordered profiles at millimetre Z heights or affine placements.
+ */
 export declare function loft(
   stations: readonly CorrespondingProfileStation[],
   options?: LoftOptions,
@@ -1291,7 +980,7 @@ export declare interface LoftOptions {
   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. */
+  /** Positive longitudinal interval count, uniformly or per supplied station gap. Each gap with n slices has n - 1 inserted profiles. Defaults to one; placed world vertices interpolate linearly. */
   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;
@@ -1299,63 +988,29 @@ export declare interface LoftOptions {
   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 Section or point loop at an explicit height or frame.
- */
+/** A Section or point loop at a horizontal height or explicit affine transform. */
 export declare type LoftStation = LoftPlacement & {
   /** Filled Section recipe or ordered XY boundary point data. */
   readonly profile: Section | Path2Input;
 };
 
-/**
- * Matches a profile family using operation settings over host resolution and limits.
- * Requires active synchronous model execution. Use Geometry's matchProfiles for standalone preparation.
- */
-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>;
+/** Eagerly reuses pure synchronous functions by function identity and immutable arguments. */
+export declare interface Memo {
+  /**
+   * Invokes fn(...args) and returns captured immutable data. Stable helpers reuse work across runs.
+   * Arguments compare with Object.is and must be deeply immutable; the exact current params or
+   * generation context instead tracks parameter fields read by the function. Functions must be
+   * pure: supply changing inputs explicitly, and do not read changing globals or ambient state.
+   */
+  <Args extends readonly unknown[], Result>(
+    fn: (...args: Args) => Result,
+    ...args: Args
+  ): ImmutableValue<Result>;
 }
 
-/** Three-dimensional Minkowski sum. */
+/** Declares the three-dimensional Minkowski sum of two Solid recipes. */
 export declare function minkowskiSum(a: Solid, b: Solid): Solid;
 
-/** 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;
-}
-
 /** Stateless portable program descriptor. Execution and caches belong to an engine session. */
 export declare interface ModelProgram<
   P extends object,
@@ -1378,144 +1033,22 @@ export declare type PartGeometry = Solid | TriangleMesh | ImmutableTriangleMesh;
 
 /** Appearance and rigid placement of a finished local manufacturing part. */
 export declare interface PartOptions {
-  /** Local geometry or a lazy reader; native objects never cross a revision. */
-  readonly geometry: ComputedValue<PartGeometry>;
+  /** Local manufacturing geometry; native objects never cross a revision. */
+  readonly geometry: PartGeometry;
   /** Rigid local-to-world transform; translation uses millimetres. Defaults to identity.
-   * Accepts a fluent transform or row-major 4x4 matrix. Scale, shear, and reflection are invalid.
+   * Accepts a Frame3, fluent transform, or row-major 4x4 matrix. Scale, shear, and reflection are invalid.
    */
-  readonly transform?: ComputedValue<Transform3Input>;
-  /** Optional six-digit hexadecimal semantic part color. */
+  readonly transform?: Transform3Input;
+  /** Optional six-digit hexadecimal display color. */
   readonly color?: string;
 }
 
-/** Immutable directed XY polyline. Closure is explicit and does not imply a filled Section. */
-export declare interface Path2 {
-  /** Coordinate dimension; identifies planar paths even when empty. */
-  readonly dimension: 2;
-  /** Whether traversal includes the last-to-first edge. */
-  readonly closed: boolean;
-  /** Returns complete deeply frozen path data, including dimension and closure. Repeated calls do not allocate. */
-  toData(): Path2Data;
-  /** Total sampled edge length in model units, including the closing edge when closed. */
-  length(): number;
-  /** Immutable axis-aligned bounds, or undefined for an empty path. */
-  bounds(): Bounds2 | undefined;
-  /** Finds the nearest edge location; requires at least two vertices. */
-  closestPoint(point: Vector2Input): PathLocation<Vector2>;
-  /** Applies an XY placement without reordering traversal, including after reflection. */
-  transform(placement: Transform2Input): Path2;
-  /** Reverses vertex order and traversal; neither the source nor its coordinates are mutated. */
-  reverse(): Path2;
-  /** Returns a path sampled at equal arc lengths. Corners may be bridged; closure is preserved. */
-  resample(options?: PathResamplingOptions): Path2;
-}
-
-/**
- * Snapshots finite XY coordinates as an immutable sampled path, independent of engine initialization.
- *
- * Open paths may be empty or have one point; closed paths need three vertices and omit a duplicated
- * seam. Repeated adjacent vertices are retained. No winding normalization or filling is performed.
- * Malformed dimensions or topology throw INVALID_ARGUMENT; nonfinite coordinates or measurement
- * overflow throw NON_FINITE_VALUE; exhausted allocation ceilings throw COMPLEXITY_LIMIT GeometryError.
- * A path input retains its closure. Limits bound construction only; resampling takes its own limits.
- *
- * Use `toData()` for a frozen record that restores coordinates, closure, and dimension together.
- */
-export declare function path2(input: Path2Input, options?: PathOptions): Path2;
-
-/** Complete plain XY path representation, including topology and empty-path dimensional identity. */
-export declare interface Path2Data {
-  /** Coordinate dimension, retained even when points is empty. */
-  readonly dimension: 2;
-  /** Frozen or caller-owned XY coordinates; closed paths omit a duplicated seam. */
-  readonly points: readonly Vector2Data[];
-  /** Whether traversal includes the last-to-first edge. */
-  readonly closed: boolean;
-}
-
-/** A matching path value, complete plain path data, or a collection of vectors. */
-export declare type Path2Input = Path2 | Path2Data | readonly Vector2Input[];
-
-/** Immutable directed XYZ polyline; it represents sampled edges, not an analytic curve. */
-export declare interface Path3 {
-  /** Coordinate dimension; identifies spatial paths even when empty. */
-  readonly dimension: 3;
-  /** Whether traversal includes the last-to-first edge. */
-  readonly closed: boolean;
-  /** Returns complete deeply frozen path data, including dimension and closure. Repeated calls do not allocate. */
-  toData(): Path3Data;
-  /** Total sampled edge length in model units, including the closing edge when closed. */
-  length(): number;
-  /** Immutable axis-aligned bounds, or undefined for an empty path. */
-  bounds(): Bounds3 | undefined;
-  /** Finds the nearest edge location; requires at least two vertices. */
-  closestPoint(point: Vector3Input): PathLocation<Vector3>;
-  /** Applies an XYZ placement without changing traversal order or closure. */
-  transform(placement: Transform3Input): Path3;
-  /** Reverses vertex order and traversal without mutating the source. */
-  reverse(): Path3;
-  /** Returns a path sampled at equal arc lengths. Corners may be bridged; closure is preserved. */
-  resample(options?: PathResamplingOptions): Path3;
-}
-
-/**
- * Snapshots finite XYZ coordinates as an immutable sampled path with the same closure, seam,
- * allocation and error rules as path2. Analytic curves must be sampled explicitly first.
- *
- * Use `toData()` for a frozen record that restores coordinates, closure, and dimension together.
- *
- * @see {@link path2} for shared construction rules.
- */
-export declare function path3(input: Path3Input, options?: PathOptions): Path3;
-
-/** Complete plain XYZ path representation, including topology and empty-path dimensional identity. */
-export declare interface Path3Data {
-  /** Coordinate dimension, retained even when points is empty. */
-  readonly dimension: 3;
-  /** Frozen or caller-owned XYZ coordinates; closed paths omit a duplicated seam. */
-  readonly points: readonly Vector3Data[];
-  /** Whether traversal includes the last-to-first edge. */
-  readonly closed: boolean;
-}
-
-/** A matching path value, complete plain path data, or a collection of vectors. */
-export declare type Path3Input = Path3 | Path3Data | readonly Vector3Input[];
-
-/** Nearest location on a sampled boundary, rather than inside a filled shape or on an analytic curve. */
-export declare interface PathLocation<Point extends Vector2 | Vector3> {
-  /** Immutable position on the selected edge. */
-  readonly point: Point;
-  /** Euclidean distance from the query in model units. */
-  readonly distance: number;
-  /** Starting vertex of the selected edge; ties keep the first edge in traversal order. */
-  readonly edgeIndex: number;
-  /** Clamped fraction along that edge, not the whole path's normalized arc length. */
-  readonly fraction: number;
-}
-
-/**
- * Supplies a profile-X orientation guide for each original normalized sweep station.
- *
- * @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: Vector3Data,
-  index: number,
-) => Vector3Input;
-
-/** Topology and allocation ceiling for an immutable sampled path. */
-export declare interface PathOptions {
-  /** Connects the last vertex to the first; closed paths omit the repeated seam. Defaults to false. */
-  readonly closed?: boolean;
-  /** Construction point ceiling; defaults to package sampling limits. Later sampling has its own options. */
-  readonly limits?: Partial<GeometrySamplingLimits>;
-}
-
 /**
  * Physical arc-length copies along a sampled path, with optional tangent orientation.
  *
+ * @param source - Recipe or factory called once per copy, in zero-based order.
+ * @param path - Path in millimetres; spacing uses arc length.
+ *
  * @example Copies along a bent path
  * ```ts
  * pathPattern(box({ size: 4 }), [[0, 0, 0], [20, 0, 0], [20, 20, 0]], { count: 5 });
@@ -1530,6 +1063,9 @@ export declare function pathPattern(
 /**
  * Repeats a filled Section along a sampled XY path. Tangent orientation maps local +X
  * to the path tangent counterclockwise, preserving the XY plane.
+ *
+ * @param source - Recipe or factory called once per copy, in zero-based order.
+ * @param path - Path in millimetres; spacing uses arc length.
  */
 export declare function pathPattern(
   source: PatternSource<Section>,
@@ -1537,41 +1073,11 @@ export declare function pathPattern(
   options: PathPatternOptions,
 ): readonly Section[];
 
-/** Equal physical arc-length placements along an open or implicitly closed sampled path. */
-export declare interface PathPatternOptions {
-  /** Positive number of copies; open paths include both endpoints when greater than one. */
-  readonly count: number;
-  /** Raw point closure defaults to false; a path value supplies closure and rejects conflicts. */
-  readonly closed?: boolean;
-  /** Preserve orientation, or align local +X for Sections / +Z for Solids to the tangent. Defaults to fixed. */
-  readonly orientation?: "fixed" | "tangent";
-}
-
-/** Equal arc-length sampling; the path itself owns whether its closing edge is included. */
-export declare interface PathResamplingOptions extends CurveSamplingOptions {
-  /** Exact arc-length intervals; closed paths need at least three. Otherwise physical resolution or the effective source edge count controls sampling. */
-  readonly segments?: number;
-}
-
-/**
- * One immutable shape, or a synchronous factory called once per copy in index order.
- */
+/** One immutable shape, or a synchronous factory called once per copy in zero-based index order. */
 export declare type PatternSource<T extends Solid | Section = Solid> =
   T | ((index: number) => T);
 
-/** A fixed XY point in world coordinates; omitted pivots use the coordinate origin. */
-export declare interface Pivot2Options {
-  /** World-space point left fixed by rotation or scaling. */
-  readonly pivot?: Vector2Input;
-}
-
-/** A fixed XYZ point in world coordinates; omitted pivots use the coordinate origin. */
-export declare interface Pivot3Options {
-  /** World-space point left fixed by rotation or scaling. */
-  readonly pivot?: Vector3Input;
-}
-
-/** A world-space cutting plane, retaining the half-space in the normal's direction. */
+/** A world-space cutting plane defined by a normal and signed millimetre offset. */
 export declare interface PlaneOptions {
   /** Finite nonzero plane normal; magnitude does not affect the plane. */
   readonly normal: Vector3Input;
@@ -1585,6 +1091,8 @@ export declare interface PlaneOptions {
  * Closing edges are implicit. Compound contours use nonzero fill unless selected otherwise.
  * Explicit topology must be simple and disjoint; compound winding may resolve overlaps.
  *
+ * @param input - XY outline in millimetres, or explicit or compound topology.
+ *
  * @example Extrude a triangular plate
  * ```ts
  * polygon([[0, 0], [20, 0], [10, 12]]).extrude({ height: 3 });
@@ -1592,23 +1100,6 @@ export declare interface PlaneOptions {
  */
 export declare function polygon(input: Path2Input | PolygonOptions): Section;
 
-/**
- * One filled two-dimensional polygon with an exterior and optional holes.
- *
- * `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.
- *
- * @see {@link Contour}
- * @see {@link RegionData}
- */
-export declare interface PolygonData {
-  /** Clockwise interior boundaries, each omitting its duplicated closing point. */
-  readonly holes: readonly Contour[];
-  /** Counter-clockwise exterior boundary, omitting its duplicated closing point. */
-  readonly outer: Contour;
-}
-
 /** Explicit polygon topology or compound contours; all closing edges are implicit. */
 export declare type PolygonOptions =
   | {
@@ -1648,45 +1139,6 @@ export declare type PolygonOptions =
       readonly fillRule?: never;
     };
 
-/**
- * Checks compensated cutter dimensions and conservative mesh estimates against host output limits.
- *
- * Requires active synchronous model execution and uses its resolution and limits. Estimates include
- * the one-pitch extension beyond each requested face, without mesh buffers or native objects.
- * Mesh validity, native construction, and aggregate output limits are checked later.
- *
- * @see {@link internalThreadCutter}
- */
-export declare function preflightInternalThreadCutter(
-  options: InternalThreadCutterOptions,
-): ThreadSolidPreflight;
-
-/**
- * Checks nut dimensions, chamfers, end-face wall, and the extended compensated cutter's allocation plan.
- *
- * Requires active synchronous model execution and uses its resolution and limits, without mesh
- * buffers or native objects. Returned thread estimates cover the cutter, excluding the body and
- * Boolean result. Mesh validity, native construction, and aggregate output limits are checked later.
- *
- * @see {@link threadedNut}
- */
-export declare function preflightThreadedNut(
-  options: ThreadedNutOptions,
-): ThreadedNutPreflight;
-
-/**
- * Checks compensated rod dimensions and conservative mesh estimates against host output limits.
- *
- * Requires active synchronous model execution and uses its resolution and limits. Returns selected
- * sampling and conservative row/triangle estimates without mesh buffers or native objects.
- * Mesh validity, native construction, and aggregate output limits are checked later.
- *
- * @see {@link threadedRod}
- */
-export declare function preflightThreadedRod(
-  options: ThreadedRodOptions,
-): ThreadSolidPreflight;
-
 /** Anchor attachment shared by solid and filled-section factories. */
 export declare interface PrimitiveAttachment {
   /** Applied after local construction; Section attachment must preserve the XY plane. */
@@ -1695,127 +1147,17 @@ export declare interface PrimitiveAttachment {
 
 /** Maps an explicit or named shape-local attachment anchor onto a world-space anchor. */
 export declare interface PrimitiveAttachmentOptions extends AttachOptions {
-  /** Shape-local source frame or a named primitive anchor such as bottom. */
-  readonly source: Anchor3 | string;
-  /** World-space target frame in millimetres. */
-  readonly target: Anchor3;
-}
-
-/**
- * Named baseline fit policies for calibrated FDM-style printed threads.
- */
-export declare type PrintableThreadFit = "tight" | "normal" | "loose";
-
-/**
- * Explicit radial and axial allowances for a mating printed thread pair.
- *
- * Male and female radial values are applied independently, so their sum is the
- * assembled radial clearance. Values are millimetres and intentionally do not
- * encode printer, material, or process calibration.
- */
-export declare interface PrintableThreadFitPolicy {
-  /** Nominal axial backlash available between opposing flanks. */
-  readonly axialBacklash: number;
-  /** Radial increase applied to an internal thread envelope. */
-  readonly femaleRadialOutset: number;
-  /** Radial reduction applied to an external thread envelope. */
-  readonly maleRadialInset: number;
-}
-
-/**
- * An explicit component/contour/span topology, before shared family sampling with matchProfiles.
- * Component, contour and span identities establish correspondence across a loft or sweep family.
- *
- * @see {@link CorrespondingProfile}
- * @see {@link matchProfiles}
- */
-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[];
-}
-
-/**
- * An identified closed boundary of curve spans, before shared family sampling.
- * Outer winding is CCW and hole winding is CW. matchProfiles retains span identities in sampled contours.
- *
- * @see {@link Contour} for sampled point coordinates.
- * @see {@link CorrespondingContour} for sampled coordinates with correspondence metadata.
- */
-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 Vector2Data[];
-}
-
-/** 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: Vector2Data;
-      /** End point in millimetres. */
-      readonly end: Vector2Data;
-    }
-  | {
-      /** Selects the geometric curve or span family. */
-      readonly kind: "arc";
-      /** Center point in millimetres. */
-      readonly center: Vector2Data;
-      /** Circular radius in millimetres. */
-      readonly radius: number;
-      /** Initial counterclockwise angle in degrees. */
-      readonly startAngle: number;
-      /** Signed counterclockwise angular sweep in degrees. */
-      readonly sweepAngle: number;
-    }
-  | {
-      /** Selects a cubic Bézier span with the same coordinates as CubicBezierCurve2. */
-      readonly kind: "cubic";
-      /** Start point in millimetres. */
-      readonly start: Vector2Data;
-      /** First control point in millimetres. */
-      readonly control1: Vector2Data;
-      /** Second control point in millimetres. */
-      readonly control2: Vector2Data;
-      /** End point in millimetres. */
-      readonly end: Vector2Data;
-    }
-);
+  /** 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;
+}
 
 /**
  * Repeats one solid about an axis.
  *
+ * @param source - Recipe or factory called once per copy, in zero-based order.
+ *
  * @example Six copies around Z
  * ```ts
  * const pin = cylinder({ height: 6, radius: 2 }).translate([12, 0, 0]);
@@ -1827,45 +1169,16 @@ export declare function radialPattern(
   options: RadialPatternOptions,
 ): readonly Solid[];
 
-/** Repeats a filled Section counterclockwise about a fixed XY pivot, using the implicit +Z axis. */
+/**
+ * Repeats a filled Section counterclockwise about a fixed XY pivot, using the implicit +Z axis.
+ *
+ * @param source - Recipe or factory called once per copy, in zero-based order.
+ */
 export declare function radialPattern(
   source: PatternSource<Section>,
   options: RadialPatternOptions<2>,
 ): readonly Section[];
 
-/**
- * Degree rotations about a fixed world-space pivot; XY patterns use the implicit +Z axis.
- */
-export declare type RadialPatternOptions<Dimension extends 2 | 3 = 3> = {
-  /** Number of shapes to return, including the original. */
-  readonly count: number;
-  /** Signed rotation from one copy to the next, in degrees. */
-  readonly angle: number;
-  /** Fixed world-space rotation pivot; defaults to the coordinate origin. */
-  readonly pivot?: Dimension extends 2 ? Vector2Input : Vector3Input;
-} & (Dimension extends 2
-  ? {
-      /** XY rotation uses +Z; an explicit spatial axis is unavailable. */
-      readonly axis?: never;
-    }
-  : {
-      /** Axis of the right-handed rotation. Its nonzero magnitude is ignored. */
-      readonly axis: Vector3Input;
-    });
-
-/** 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;
-}
-
 /**
  * Filled rectangular section with uniform or independently treated corners.
  *
@@ -1874,86 +1187,39 @@ export declare interface RadialSizingOptions {
  *
  * @example Round the corners
  * ```ts
- * rectangle({ size: [30, 20], treatment: { kind: "round", radius: 3 } });
+ * rectangle({ size: [30, 20], treatment: { kind: "round", radius: 3 } }).extrude({ height: 3 });
  * ```
  */
 export declare function rectangle(options: RectangleOptions): Section;
 
-/**
- * Shared rectangle dimensions, origin and uniform or per-corner treatment.
- */
-export declare interface RectangleContourOptions {
-  /** Positive uniform size or explicit XY extents in millimetres. */
-  readonly size: number | Vector2Input;
-  /** 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>;
-}
-
-/** 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,
-];
-
-/**
- * Rectangle dimensions, placement and uniform or per-corner treatment.
- */
+/** Rectangle dimensions, placement and uniform or per-corner treatment. */
 export declare interface RectangleOptions
   extends RectangleContourOptions, PrimitiveAttachment {}
 
-/**
- * A two-dimensional region represented by disjoint filled polygons.
- * Each PolygonData owns one exterior and its holes; an empty region contains no material.
- *
- * @see {@link PolygonData}
- */
-export declare type RegionData = readonly PolygonData[];
-
 /**
  * Regular polygon with a vertex on +X.
  *
  * @example Hexagonal section
  * ```ts
- * regularPolygon({ radius: 10, sides: 6, sizing: "face" });
+ * regularPolygon({ radius: 10, sides: 6, sizing: "face" }).extrude({ height: 3 });
  * ```
  */
 export declare function regularPolygon(options: RegularPolygonOptions): Section;
 
-/**
- * Regular polygon dimensions, radial convention and degree rotation.
- */
-export declare type RegularPolygonOptions = RadialSizingOptions &
-  PrimitiveAttachment & {
-    /** Positive nominal radius in millimetres, interpreted according to sizing. */
-    readonly radius: number;
-    /** Exact integer side count from three through 100000. */
-    readonly sides: number;
-    /** Counterclockwise rotation in degrees; defaults to zero with a vertex on +X. */
-    readonly rotation?: number;
-  };
+/** Regular polygon dimensions, radial convention and degree rotation. */
+export declare type RegularPolygonOptions = RegularPolygonContourOptions &
+  PrimitiveAttachment;
 
 /**
  * Revolves a filled Section or explicit corresponding radial/Z contours around +Z, with caps for partial sweeps.
  * Use `section.revolve(options)` in fluent sequences, or this function for generic profile inputs.
  *
+ * @param shape - Profile coordinates are [radius, Z] in millimetres.
+ *
  * @example Revolve
  * ```ts
- * import { matchProfiles, revolve } from "@metamesh/modeling";
- * import { rectangleProfile } from "@metamesh/modeling/geometry";
+ * import { revolve } from "@metamesh/modeling";
+ * import { matchProfiles, rectangleProfile } from "@metamesh/modeling/geometry";
  *
  * // Contour coordinates are [radius, Z].
  * const [profile] = matchProfiles([rectangleProfile({ size: [4, 16], center: false })]);
@@ -1965,9 +1231,7 @@ export declare function revolve(
   options?: RevolveOptions,
 ): Solid;
 
-/**
- * Circumferential sampling and degree sweep shared by pure and filled revolution.
- */
+/** Circumferential sampling and degree sweep shared by pure and filled revolution. */
 export declare interface RevolveOptions extends CircularPrimitiveOptions {
   /**
    * Positive sweep in degrees, no greater than 360. Defaults to a full revolution;
@@ -1982,16 +1246,6 @@ export declare interface RevolveOptions extends CircularPrimitiveOptions {
   readonly limits?: Partial<ModelingLimits>;
 }
 
-/**
- * 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";
-  /** Nonnegative millimetre radius; zero leaves the edge or corner untreated. Positive values must fit adjoining dimensions. */
-  readonly radius: number;
-}
-
 /**
  * Immutable deferred filled XY section recipe.
  *
@@ -2008,6 +1262,7 @@ export declare interface RoundedEdgeTreatment extends CircularPrimitiveOptions {
  *   .subtract(rectangle({ size: [16, 8] }))
  *   .offset(0.5)
  *   .extrude({ height: 4 });
+ * body;
  * ```
  */
 export declare interface Section {
@@ -2029,7 +1284,11 @@ export declare interface Section {
     factors: number | Vector2Input,
     options?: Pivot2Options,
   ): Section;
-  /** Reflection across an origin line/plane. */
+  /**
+   * Reflects across a line through the XY origin.
+   *
+   * @param normal - Nonzero XY line normal; length has no effect.
+   */
   mirror(this: Section, normal: Vector2Input): Section;
   /** Applies a reusable XY placement or canonical row-major matrix. */
   transform(this: Section, placement: Transform2Input): Section;
@@ -2050,33 +1309,41 @@ export declare interface Section {
    * than selecting a lower rendering quality; fine features may be removed.
    */
   simplify(this: Section, tolerance: number): Section;
-  /**
-   * Returns a new recipe with copied named anchors; existing names may be replaced.
-   */
+  /** Returns a new recipe with copied named anchors; existing names may be replaced. */
   withAnchors(
     this: Section,
     anchors: Readonly<Record<string, Anchor3>>,
   ): Section;
   /**
    * Native millimetre offset preserving holes.
+   *
+   * @param distance - Millimetres: positive expands material; negative erodes it.
    */
   offset(
     this: Section,
     distance: number,
     options?: SectionOffsetOptions,
   ): Section;
-  /**
-   * Extrudes along +Z with degree twist and top scaling.
-   */
+  /** Extrudes along +Z with degree twist and top scaling. */
   extrude(this: Section, options: ExtrudeOptions): Solid;
-  /**
-   * Revolves a filled radial/Z shape around +Z, with caps for partial sweeps.
-   */
+  /** Revolves a filled radial/Z shape around +Z, with caps for partial sweeps. */
   revolve(this: Section, options?: RevolveOptions): Solid;
   /**
-   * Sweeps this filled section using the selected frame policy and degree twist.
+   * Sweeps this filled section along a path or through explicit affine placements.
+   *
+   * @param path - XYZ path in millimetres.
    */
   sweep(this: Section, path: Path3Input, options?: SweepOptions): Solid;
+  /**
+   * Connects this section through exactly the supplied affine placements.
+   *
+   * @param transforms - Ordered local-to-model placements.
+   */
+  sweep(
+    this: Section,
+    transforms: readonly Transform3Input[],
+    options?: SweepTransformOptions,
+  ): Solid;
   /** Reads immutable bounds, filled area in mm², and component/contour/vertex counts.
    * Requires active synchronous model execution; repeated reads share scoped native results.
    */
@@ -2143,20 +1410,6 @@ export declare interface SectionOffsetOptions {
   readonly resolution?: GeometryResolution;
 }
 
-/** 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";
-  /** Millimetre setbacks, equal or [first, second]; zero or [0, 0] leaves the edge untreated, otherwise both must be positive. */
-  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>;
-}
-
 /**
  * Immutable deferred solid recipe.
  *
@@ -2172,14 +1425,13 @@ export declare interface SmoothEdgeTreatment {
  * const body = box({ size: [30, 20, 6] })
  *   .subtract(cylinder({ height: 8, radius: 3 }))
  *   .rotate([0, 0, 45]);
+ * body;
  * ```
  */
 export declare interface Solid {
   /** Compile-time identity brand for an immutable solid recipe. */
   readonly [solidBrand]: "Solid";
-  /**
-   * Translates XYZ coordinates in millimetres.
-   */
+  /** Translates XYZ coordinates in millimetres. */
   translate(this: Solid, offset: Vector3Input): Solid;
   /**
    * Rotates about global X, then Y, then Z in degrees.
@@ -2196,10 +1448,12 @@ export declare interface Solid {
     options?: Pivot3Options,
   ): Solid;
   /**
-   * Reflection across an origin line/plane.
+   * Reflects across a plane through the origin.
+   *
+   * @param normal - Nonzero XYZ plane normal; length has no effect.
    */
   mirror(this: Solid, normal: Vector3Input): Solid;
-  /** Applies a reusable XYZ placement or canonical row-major matrix. */
+  /** Applies an XYZ frame, transform value, or canonical row-major affine matrix. */
   transform(this: Solid, placement: Transform3Input): Solid;
   /** Copies indexed Float32 XYZ and Uint32 triangle buffers in millimetres for interchange.
    * Requires an active synchronous model execution; the returned TriangleMesh is caller-owned.
@@ -2207,6 +1461,15 @@ export declare interface Solid {
   toMesh(this: Solid): TriangleMesh;
   /** Robust union with one or more solids; an empty operand array preserves this solid. */
   union(this: Solid, operands: Solid | readonly Solid[]): Solid;
+  /**
+   * Fuses an already positioned feature with a smooth (default) or straight width/height transition.
+   * The source datum belongs to the feature; neither input moves or loses material.
+   * Requires a verified local straight collar and continuous sampled support patch.
+   * The result has no inherited anchors. This is not a rolling-ball fillet.
+   *
+   * @param feature - Positioned feature that owns the source datum.
+   */
+  join(this: Solid, feature: Solid, options: JoinOptions): Solid;
   /** Robust intersection with every supplied solid; an empty operand array preserves this solid. */
   intersect(this: Solid, operands: Solid | readonly Solid[]): Solid;
   /**
@@ -2221,12 +1484,13 @@ export declare interface Solid {
    * and the solid's existing native tolerance. Choose it from the detail you can afford to lose.
    */
   simplify(this: Solid, tolerance: number): Solid;
-  /**
-   * Returns a new recipe with copied named anchors; existing names may be replaced.
-   */
+  /** Returns a new recipe with copied named anchors; existing names may be replaced. */
   withAnchors(this: Solid, anchors: Readonly<Record<string, Anchor3>>): Solid;
   /**
    * Places an explicit or named source anchor against an explicit target anchor.
+   *
+   * @param source - Anchor on this solid, supplied directly or by name.
+   * @param target - Anchor in shared modeling coordinates.
    */
   attach(
     this: Solid,
@@ -2261,6 +1525,9 @@ export declare interface Solid {
   distance(this: Solid, other: Solid): number;
   /** Copies intersections along the finite directed origin-to-endpoint segment in millimetres.
    * Requires active synchronous model execution.
+   *
+   * @param origin - Segment start in modeling coordinates.
+   * @param endpoint - Segment end in modeling coordinates.
    */
   castSegment(
     this: Solid,
@@ -2283,6 +1550,8 @@ declare const solidBrand: unique symbol;
 /**
  * Imports a bounded closed indexed mesh.
  *
+ * @param mesh - Closed, oriented mesh in millimetres; ownership stays with the caller.
+ *
  * @example Mesh import
  * ```ts
  * import { solidFromMesh } from "@metamesh/modeling";
@@ -2329,7 +1598,8 @@ export declare interface SolidSegmentHit {
 }
 
 /**
- * Origin-centered sphere.
+ * Origin-centered sphere with adaptive sampling that bounds spherical triangle error.
+ * Explicit segment requests select octahedral refinement and round up to a multiple of four.
  *
  * @example Sphere
  * ```ts
@@ -2338,9 +1608,7 @@ export declare interface SolidSegmentHit {
  */
 export declare function sphere(options: SphereOptions): Solid;
 
-/**
- * Exactly one radius or diameter, placement, and tessellation for an origin-centered sphere.
- */
+/** Exactly one radius or diameter, placement, and tessellation for an origin-centered sphere. */
 export declare type SphereOptions = CircularPrimitiveOptions &
   PrimitiveAttachment &
   (
@@ -2358,54 +1626,29 @@ export declare type SphereOptions = CircularPrimitiveOptions &
       }
   );
 
-/** 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;
-}
-
 /**
  * Alternating outer/inner star vertices.
  *
  * @example Five-point section
  * ```ts
- * star({ outerRadius: 12, innerRadius: 6, points: 5 });
+ * star({ outerRadius: 12, innerRadius: 6, points: 5 }).extrude({ height: 3 });
  * ```
  */
 export declare function star(options: StarOptions): Section;
 
-/** 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>;
-}
-
-/**
- * Alternating outer and inner vertices, centered on the XY origin.
- */
+/** Alternating outer and inner vertices, centered on the XY origin. */
 export declare interface StarOptions
   extends StarContourOptions, PrimitiveAttachment {}
 
 /**
- * Creates a centered-width native Section along a sampled XY path.
+ * Declares a centered-width Section recipe along a sampled XY path.
  *
- * Shares caps, joins and physical sampling with Geometry's strokeRegionData. Native union
- * resolves overlapping stroke primitives. Session resolution and resource ceilings apply;
+ * Shares caps, joins and physical sampling with Geometry's strokeRegionData. During evaluation,
+ * union resolves overlapping stroke primitives. Session resolution and resource ceilings apply;
  * closed paths omit the duplicated seam. Returns an immutable deferred recipe.
  *
+ * @param path - XY path in millimetres.
+ *
  * @example Extrude a rounded track
  * ```ts
  * stroke([[0, 0], [20, 0], [20, 10]], { width: 3, join: "round", cap: "round" }).extrude({ height: 2 });
@@ -2416,37 +1659,17 @@ export declare function stroke(
   options: StrokeOptions,
 ): Section;
 
-/** End-cap treatment for an open stroked path. */
-export declare type StrokeCap = "butt" | "round" | "square";
-
-/** Join treatment where adjacent stroked path segments meet. */
-export declare type StrokeJoin = "bevel" | "miter" | "round";
-
-/** Physical stroke and topology controls shared by pure regions and native Sections. */
-export declare interface StrokeOptions {
-  /** Explicit path, circular and expanded-profile allocation ceilings. */
-  readonly limits?: Partial<GeometrySamplingLimits>;
-  /** Raw point closure defaults to false; a Path2 supplies its closure and rejects conflicts. */
-  readonly closed?: boolean;
-  /** End-cap treatment for an open path. Ignored for closed paths. Default: `butt`. */
-  readonly cap?: StrokeCap;
-  /** Corner treatment; miters exceeding SVG's default limit of 4 become bevels. Default: `miter`. */
-  readonly join?: StrokeJoin;
-  /** Physical tessellation policy for round caps and joins. */
-  readonly resolution?: GeometryResolution;
-  /** Positive total stroke width in millimetres, centered on the sampled path. */
-  readonly width: number;
-}
-
 /** Placement of painted SVG geometry after SVG Y-axis inversion. */
 export declare type SvgOrigin = "center" | "document";
 
 /**
  * Imports bounded filled SVG path data.
  *
+ * @param path - SVG path data, at most 1 MiB of UTF-8; omit the XML wrapper.
+ *
  * @example Fill an SVG path in millimetres
  * ```ts
- * svgPathSection("M0 0H20V12H0Z", { origin: "center", scale: 1 });
+ * svgPathSection("M0 0H20V12H0Z", { origin: "center", scale: 1 }).extrude({ height: 3 });
  * ```
  */
 export declare function svgPathSection(
@@ -2462,7 +1685,7 @@ export declare interface SvgPathSectionOptions {
   readonly fillRule?: "evenodd" | "nonzero";
   /** Local physical sampling policy; exact interval counts take precedence. */
   readonly resolution?: GeometryResolution;
-  /** Center the painted bounds or preserve original path coordinates. */
+  /** Center painted bounds (default), or preserve original path coordinates. */
   readonly origin?: SvgOrigin;
   /** Positive uniform factor converting SVG user units to millimetres; defaults to one. */
   readonly scale?: number;
@@ -2471,12 +1694,14 @@ export declare interface SvgPathSectionOptions {
 /**
  * Imports bounded painted SVG document geometry.
  *
+ * @param svg - Complete SVG XML, at most 256 KiB of UTF-8.
+ *
  * @example Import a physical SVG rectangle
  * ```ts
  * svgSection(
  *   '<svg xmlns="http://www.w3.org/2000/svg" width="30mm" height="20mm" viewBox="0 0 30 20"><rect width="30" height="20"/></svg>',
  *   { origin: "center" },
- * );
+ * ).extrude({ height: 3 });
  * ```
  */
 export declare function svgSection(
@@ -2484,9 +1709,7 @@ export declare function svgSection(
   options?: SvgSectionOptions,
 ): Section;
 
-/**
- * Bounded SVG document sampling. Center origin uses the final painted bounds.
- */
+/** Bounded SVG document sampling. Center origin uses the final painted bounds. */
 export declare interface SvgSectionOptions {
   /** Fit painted bounds uniformly inside positioned XY millimetre bounds; adaptive resolution applies at the fitted size. */
   readonly fit?: Bounds2Input;
@@ -2496,18 +1719,21 @@ export declare interface SvgSectionOptions {
   readonly circularSegments?: number;
   /** Local physical sampling policy; exact interval counts take precedence. */
   readonly resolution?: GeometryResolution;
-  /** Place the painted bounds around the origin or preserve document coordinates. */
+  /** Center painted bounds (default), or preserve document coordinates. */
   readonly origin?: SvgOrigin;
 }
 
 /**
- * Sweeps a filled Section or explicit corresponding contours using the selected frame policy.
+ * Sweeps a filled Section or corresponding contours along a path or explicit affine placements.
  * Use `section.sweep(path, options)` in fluent sequences, or this function for generic profile inputs.
  *
+ * @param shape - Profile in local XY millimetres.
+ * @param path - XYZ path in millimetres.
+ *
  * @example Sweep
  * ```ts
- * import { matchProfiles, sweep } from "@metamesh/modeling";
- * import { rectangleProfile } from "@metamesh/modeling/geometry";
+ * import { sweep } from "@metamesh/modeling";
+ * import { matchProfiles, rectangleProfile } from "@metamesh/modeling/geometry";
  *
  * const [profile] = matchProfiles([rectangleProfile({ size: [6, 3] })]);
  * sweep(profile!, [[0, 0, 0], [0, 0, 15], [10, 0, 25]], {
@@ -2522,25 +1748,33 @@ export declare function sweep(
 ): Solid;
 
 /**
- * Controls shared by pure mesh construction and filled modeling sweeps.
+ * Connects one profile through exactly the supplied affine placements.
+ *
+ * @param shape - Profile in local XY millimetres.
+ * @param transforms - Ordered local-to-model placements.
  */
+export declare function sweep(
+  shape: Section | CorrespondingProfile,
+  transforms: readonly Transform3Input[],
+  options?: SweepTransformOptions,
+): Solid;
+
+/** Path-driven sweep orientation, deformation, and physical refinement controls. */
 export declare interface SweepOptions {
   /** Raw point closure defaults to false; a Path3 supplies its closure and rejects conflicts. */
   readonly closed?: boolean;
   /** Explicit output and sampling allocation ceilings. */
   readonly limits?: Partial<ModelingLimits>;
-  /** Explicit frame policy; default transport minimizes rotations, initially projecting +X then +Y then +Z. */
+  /** 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. */
+  /** Physical sampling of twist and varying scale, plus optional segment-length limits. Inserted stations retain authored controls. */
   readonly resolution?: GeometryResolution;
-  /** Total additional profile rotation in degrees, with progression selected by twistBy. */
+  /** Total additional profile rotation in degrees; compatible closed boundaries are aligned automatically. */
   readonly twist?: number;
   /** Twist advances by physical path length (default), or normalized authored station position, including a closed seam gap. */
   readonly twistBy?: "length" | "stations";
-  /** Positive uniform/XY scale, or one XY pair per path station. Defaults to one. */
+  /** Positive final uniform/XY scale on open paths, interpolated from one by path length. Closed paths use a uniform scale. Explicit XY pairs set each original station; omitted is one. */
   readonly scale?: number | Vector2Input | readonly Vector2Input[];
-  /** Corresponding point-index advance at a rotationally equivalent closed seam. */
-  readonly seamProfileOffset?: number;
 }
 
 /**
@@ -2570,11 +1804,34 @@ export declare type SweepOrientation =
       readonly kind: "frenet";
     };
 
+/** Explicit-transform sweeps connect exactly the supplied stations, with no inferred rotation or refinement. */
+export declare interface SweepTransformOptions {
+  /** Connect the last supplied station to the first without caps. Defaults to false. */
+  readonly closed?: boolean;
+  /** Explicit output and station allocation ceilings. */
+  readonly limits?: Partial<ModelingLimits>;
+  /** Encoded by the explicit transforms. */
+  readonly orientation?: never;
+  /** Explicit stations are never refined. */
+  readonly resolution?: never;
+  /** Encoded by the explicit transforms. */
+  readonly twist?: never;
+  /** Encoded by the explicit transforms. */
+  readonly twistBy?: never;
+  /** Encoded by the explicit transforms. */
+  readonly scale?: never;
+}
+
 /**
  * Consumes a previously prepared layout; never shapes or fetches a font.
  *
+ * @param layout - Prepared millimetre outlines; create the layout before generation.
+ *
  * @example Use a prepared text layout
  * ```ts
+ * import { textSection } from "@metamesh/modeling";
+ * import type { VectorTextLayout } from "@metamesh/modeling/geometry";
+ *
  * // Prepare the exact font and layout before entering build.
  * function labelSection(layout: VectorTextLayout) {
  *   return textSection(layout);
@@ -2586,9 +1843,7 @@ export declare function textSection(
   options?: TextSectionOptions,
 ): Section;
 
-/**
- * Physical curve sampling applied to already prepared vector text.
- */
+/** Physical curve sampling applied to already prepared vector text. */
 export declare interface TextSectionOptions {
   /** Local allocation ceilings may only lower the configured engine policy. */
   readonly limits?: Partial<GeometrySamplingLimits>;
@@ -2596,73 +1851,19 @@ export declare interface TextSectionOptions {
   readonly resolution?: GeometryResolution;
 }
 
-/** 45-degree end bevels for compensated rods and cutters. */
-export declare interface ThreadBevelOptions {
-  /** Bottom/top sizes in millimetres. Omitted disables both. Auto uses profile depth for standard/tapered ends,
-   * or one sixth of the compensated male minor/female major radius for blunt ends. */
-  readonly bevel?: Bevel;
-}
-
 /**
  * Compensated threaded nut.
  *
  * @example Threaded nut
  * ```ts
  * import { threadedNut } from "@metamesh/modeling";
- * import { threadProfile } from "@metamesh/modeling/geometry";
+ * import { threadProfile } from "@metamesh/modeling/geometry/mechanical";
  *
  * const profile = threadProfile({ kind: "triangular", pitch: 1.75 });
  * threadedNut({ nominalMajorDiameter: 12, thickness: 8, width: 20, shape: "hex", profile, fit: "normal" });
  * ```
  */
-export declare function threadedNut(options: ThreadedNutOptions): Solid;
-
-/**
- * Options for a compensated nut with an internal thread.
- */
-export declare interface ThreadedNutOptions extends Omit<
-  InternalThreadCutterOptions,
-  "bevel" | "length"
-> {
-  /** Opening bevels in [bottom, top] order. Omitted or auto uses min(profile.depth, thickness/4); zero disables. */
-  readonly innerBevel?: Bevel;
-  /** Body bevels in [bottom, top] order. Omitted or auto uses min(profile.depth, thickness/4).
-   * Use [0, "auto"] to keep the outside bottom flat without disabling its inner opening bevel. */
-  readonly outerBevel?: Bevel;
-  /** Optional physical policy for a round body, independent of the thread's matched facet grid. */
-  readonly bodyResolution?: GeometryResolution;
-  /** Nut body shape. */
-  readonly shape: ThreadedNutShape;
-  /** Nut thickness along +Z in millimetres. */
-  readonly thickness: number;
-  /** Across-flats width for hex/square or diameter for round, in millimetres. */
-  readonly width: number;
-}
-
-/** Resolved body and end-face dimensions plus conservative allocation estimates for the thread cutter. */
-export declare interface ThreadedNutPreflight {
-  /** Polygon segment count used by the nut body. */
-  readonly bodySegments: number;
-  /** Resolved opening bevel sizes in millimetres, [bottom, top]. */
-  readonly innerBevel: readonly [bottom: number, top: number];
-  /** Resolved body bevel sizes in millimetres, [bottom, top]. */
-  readonly outerBevel: readonly [bottom: number, top: number];
-  /** Maximum compensated cutter radius at either requested face. */
-  readonly cutterFaceRadius: number;
-  /** Minimum nut-body inradius across the requested top and bottom faces. */
-  readonly minimumBodyFaceInradius: number;
-  /** Smallest radial wall left between the body and cutter at either requested face. */
-  readonly minimumFaceWall: number;
-  /** Conservative allocation estimates for the extended cutter; excludes the body and Boolean result. */
-  readonly thread: ThreadSolidPreflight;
-  /** Start-aligned circular facet count used by the compensated thread cutter. */
-  readonly threadCircularSegments: number;
-}
-
-/**
- * Supported printable nut body shapes.
- */
-export declare type ThreadedNutShape = "hex" | "round" | "square";
+export declare function threadedNut(options: ThreadedNutSolidOptions): Solid;
 
 /**
  * Compensated external threaded rod.
@@ -2670,155 +1871,17 @@ export declare type ThreadedNutShape = "hex" | "round" | "square";
  * @example Threaded rod
  * ```ts
  * import { threadedRod } from "@metamesh/modeling";
- * import { threadProfile } from "@metamesh/modeling/geometry";
+ * import { threadProfile } from "@metamesh/modeling/geometry/mechanical";
  *
  * const profile = threadProfile({ kind: "triangular", pitch: 1.75 });
  * threadedRod({ nominalMajorDiameter: 12, length: 24, profile, fit: "normal" });
  * ```
  */
-export declare function threadedRod(options: ThreadedRodOptions): Solid;
-
-/**
- * Options for a compensated external threaded rod along +Z.
- */
-export declare interface ThreadedRodOptions
-  extends Omit<ThreadRidgeOptions, "majorDiameter">, ThreadBevelOptions {
-  /** Printable fit or caller-calibrated allowances. Default: `normal`. */
-  readonly fit?: PrintableThreadFit | PrintableThreadFitPolicy;
-  /** Nominal major diameter before male compensation. */
-  readonly nominalMajorDiameter: number;
-}
-
-/** End shape of a generated helical ridge. */
-export declare type ThreadEndStyle = "blunt" | "standard" | "tapered";
-
-/** Axial end controls for a generated ridge. */
-export declare interface ThreadEndTreatmentOptions {
-  /**
-   * Ridge shape at the lower working boundary. `blunt` ends at full profile height, `standard`
-   * clips the periodic profile at the face, and `tapered` ramps out from the minor envelope.
-   * @defaultValue `"blunt"`
-   */
-  readonly bottom?: ThreadEndStyle;
-  /**
-   * Non-negative unthreaded envelope length reserved at each non-standard end, in millimetres.
-   * Active blunt bevels may raise this reservation to the effective bevel size.
-   * @defaultValue `0`
-   */
-  readonly endLength?: number;
-  /**
-   * Radial envelope toward which a blunt lead-in collapses.
-   * @defaultValue `"minor"`
-   */
-  readonly leadInEnvelope?: ThreadLeadInEnvelope;
-  /**
-   * Physical circumferential lead-in length in millimetres.
-   * @defaultValue The profile depth.
-   */
-  readonly leadInLength?: number;
-  /**
-   * Cross-section scaling curve used by blunt ends. `cut` switches abruptly to the full profile.
-   * @defaultValue `"cut"`
-   */
-  readonly leadInShape?: ThreadLeadInShape;
-  /**
-   * Ridge shape at the upper working boundary. `blunt` ends at full profile height, `standard`
-   * clips the periodic profile at the face, and `tapered` ramps into the minor envelope.
-   * @defaultValue `"blunt"`
-   */
-  readonly top?: ThreadEndStyle;
-}
-
-/**
- * Direction in which a conventional helical thread advances around +Z.
- */
-export declare type ThreadHandedness = "left" | "right";
-
-/** Radial envelope toward which a blunt lead-in collapses. */
-export declare type ThreadLeadInEnvelope = "major" | "minor";
-
-/** BOSL2-compatible cross-section scaling curve for a blunt thread lead-in. */
-export declare type ThreadLeadInShape = "cut" | "linear" | "smooth" | "sqrt";
-
-/**
- * A validated immutable periodic thread profile in `[axial, radial]` millimetres.
- */
-export declare interface ThreadProfile {
-  /** Axial width of the flat at the major envelope. */
-  readonly crestFlatWidth: number;
-  /** Radial distance from the major envelope to the root. */
-  readonly depth: number;
-  /** Profile family that produced this validated profile. */
-  readonly kind: ThreadProfileSpec["kind"];
-  /** Adjacent axial thread spacing in millimetres. */
-  readonly pitch: number;
-  /** Immutable open `[axial, radial]` path spanning one pitch. */
-  readonly points: readonly Vector2Data[];
-  /** Axial width of the flat at the minor envelope. */
-  readonly rootFlatWidth: number;
-}
-
-/** 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;
-}
+export declare function threadedRod(options: ThreadedRodSolidOptions): Solid;
 
-/**
- * Supported built-in and caller-defined thread profiles.
- */
-export declare type ThreadProfileSpec =
-  | AcmeThreadProfileSpec
-  | ButtressThreadProfileSpec
-  | CustomThreadProfileSpec
-  | SquareThreadProfileSpec
-  | TrapezoidalThreadProfileSpec
-  | TriangularThreadProfileSpec;
-
-/** Helical ridge mesh construction. */
+/** Declares a helical ridge Solid recipe along +Z, with lengths in millimetres. */
 export declare function threadRidge(options: ThreadRidgeOptions): Solid;
 
-/** 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;
-}
-
-/** 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;
-}
-
 /**
  * Torus around +Z.
  *
@@ -2829,9 +1892,7 @@ export declare interface ThreadSolidPreflight {
  */
 export declare function torus(options: TorusOptions): Solid;
 
-/**
- * Dimensions and independent ring/profile tessellation for a torus around the Z axis.
- */
+/** Dimensions and independent ring/profile tessellation for a torus around the Z axis. */
 export declare interface TorusOptions extends PrimitiveAttachment {
   /** Explicit sampling ceilings, bounded by the host policy. */
   readonly limits?: Partial<GeometrySamplingLimits>;
@@ -2847,221 +1908,6 @@ export declare interface TorusOptions extends PrimitiveAttachment {
   readonly resolution?: GeometryResolution;
 }
 
-/** Immutable reusable XY placement. Methods apply in written order; angles are degrees. */
-export declare interface Transform2 {
-  /** Applies a translation in model units after this placement. */
-  translate(offset: Vector2Input): Transform2;
-  /** Rotates counterclockwise in degrees about an optional world-space pivot (default origin). */
-  rotate(degrees: number, options?: Pivot2Options): Transform2;
-  /** Scales about an optional world-space pivot; finite nonzero factors may reflect. */
-  scale(factors: number | Vector2Input, options?: Pivot2Options): Transform2;
-  /** Applies this placement first, then `next`; neither operand is mutated. */
-  andThen(next: Transform2Input): Transform2;
-  /** Returns the inverse; singular and numerically unstable transforms throw GeometryError. */
-  inverse(): Transform2;
-  /** Transforms a finite point, including translation. Returns a fresh immutable vector. */
-  applyPoint(point: Vector2Input): Vector2;
-  /** Transforms a finite direction, excluding translation and retaining scale. This is not a normal transform. */
-  applyDirection(direction: Vector2Input): Vector2;
-  /** Applies the inverse transpose and normalizes. Ignores translation; rejects zero normals. */
-  applyNormal(normal: Vector2Input): Vector2;
-  /** Returns the frozen canonical row-major 3x3 matrix for interchange. */
-  toData(): Transform2Data;
-  /** Embeds this placement in XYZ, leaving Z unchanged, for solids and 3D paths. */
-  to3D(): Transform3;
-}
-
-/**
- * Creates an immutable XY transform, identity by default.
- *
- * Values and data are copied and validated.
- * Pass it directly to Section.transform() and planar data helpers; to3D() explicitly crosses into XYZ.
- * Zero scales and singular matrices throw GeometryError; negative scales reflect.
- *
- * Use `toData()` for frozen matrix interchange.
- *
- * @example
- * ```ts
- * const placement = transform2().rotate(90).translate([10, 0]);
- * placement.applyPoint([1, 0]).toData(); // approximately [10, 1]
- * ```
- */
-export declare function transform2(input?: Transform2Input): Transform2;
-
-/**
- * A row-major affine 3x3 XY matrix applied to column vectors.
- * Translation occupies indices 2 and 5; the final row is `[0, 0, 1]`.
- */
-export declare type Transform2Data = readonly [
-  m00: number,
-  m01: number,
-  m02: number,
-  m10: number,
-  m11: number,
-  m12: number,
-  m20: number,
-  m21: number,
-  m22: number,
-];
-
-/** An immutable XY transform or its canonical row-major matrix for interchange. */
-export declare type Transform2Input = Transform2 | Transform2Data;
-
-/** Immutable reusable XYZ placement. Methods apply in written order; angles are degrees. */
-export declare interface Transform3 {
-  /** Applies a translation in model units after this placement. */
-  translate(offset: Vector3Input): Transform3;
-  /** Rotates about global X, then Y, then Z in degrees, about an optional world-space pivot. */
-  rotate(degrees: Vector3Input, options?: Pivot3Options): Transform3;
-  /** Rotates right-handed in degrees about a nonzero axis and optional world-space pivot. */
-  rotateAxis(
-    axis: Vector3Input,
-    degrees: number,
-    options?: Pivot3Options,
-  ): Transform3;
-  /** Scales about an optional world-space pivot; finite nonzero factors may reflect. */
-  scale(factors: number | Vector3Input, options?: Pivot3Options): Transform3;
-  /** Applies this placement first, then `next`; equivalent to composeTransform3(next, current). */
-  andThen(next: Transform3Input): Transform3;
-  /** Returns the inverse; singular and numerically unstable transforms throw GeometryError. */
-  inverse(): Transform3;
-  /** Transforms a finite point, including translation. Returns a fresh immutable vector. */
-  applyPoint(point: Vector3Input): Vector3;
-  /** Transforms a finite direction, excluding translation and retaining scale. This is not a normal transform. */
-  applyDirection(direction: Vector3Input): Vector3;
-  /** Applies the inverse transpose and normalizes. Ignores translation; rejects zero normals. */
-  applyNormal(normal: Vector3Input): Vector3;
-  /** Returns the frozen canonical row-major 4x4 matrix for interchange. */
-  toData(): Transform3Data;
-  /** Restricts to XY; throws GeometryError for a plane change or singular XY restriction. */
-  to2D(): Transform2;
-}
-
-/**
- * Creates an immutable XYZ transform, identity by default.
- *
- * Values and data are copied and validated.
- * Calls apply in written order; rotations use degrees and pivots use current world coordinates.
- * Zero scales, singular matrices, nonfinite inputs and zero rotation axes throw GeometryError.
- * Use frameTransform3(frame) as the input for existing orthonormal frame placement.
- *
- * Use `toData()` for frozen matrix interchange.
- * [composeTransform3](/docs/reference/geometry/composeTransform3) takes matrices in after, before order.
- *
- * @example
- * ```ts
- * const placement = transform3().rotate([0, 0, 90]).translate([10, 0, 0]);
- * placement.applyPoint([1, 0, 0]).toData(); // approximately [10, 1, 0]
- * ```
- */
-export declare function transform3(input?: Transform3Input): Transform3;
-
-/**
- * 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 Transform3Data = 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,
-];
-
-/** An immutable XYZ transform or its canonical row-major matrix for interchange. */
-export declare type Transform3Input = Transform3 | Transform3Data;
-
-/** Trapezoidal thread profile with a configurable included angle. */
-export declare interface TrapezoidalThreadProfileSpec extends ThreadProfileBaseSpec {
-  /** Selects the trapezoidal profile family. */
-  readonly kind: "trapezoidal";
-  /**
-   * Radial depth in millimetres.
-   * @defaultValue `pitch / 2`
-   */
-  readonly depth?: number;
-  /**
-   * Full angle between the flanks in degrees, from `0` inclusive to `180` exclusive.
-   * Each flank uses half this angle from the radial direction; `90` gives 45-degree slopes.
-   * @defaultValue `30`
-   */
-  readonly includedAngle?: number;
-}
-
-/** A topology-preserving indexed triangle mesh with mutable owned XYZ buffers. */
-export declare interface TriangleMesh {
-  /** Three unsigned vertex indices per triangle. */
-  readonly indices: Uint32Array;
-  /** Flat XYZ coordinates in millimetres. */
-  readonly positions: Float32Array;
-}
-
-/**
- * Measurements and optional edge-connected topology from one validated mesh traversal.
- */
-export declare interface TriangleMeshAnalysis extends TriangleMeshMeasurements {
-  /** Number of surface shells connected by shared indexed edges when includeTopology is requested.
-   * Cavities count separately; shells may be open unless requireClosed is enabled. Coordinates are not welded. */
-  readonly shellCount?: number;
-  /** Number of distinct indexed undirected edges when `includeTopology` is requested. */
-  readonly edgeCount?: number;
-}
-
-/**
- * Geometric measurements derived from a validated, non-empty triangle mesh.
- */
-export declare interface TriangleMeshMeasurements {
-  /** Axis-aligned bounds. */
-  readonly bounds: Bounds3Data;
-  /** Signed enclosed volume; positive values correspond to outward winding. */
-  readonly signedVolume: number;
-  /** Sum of all triangle areas in squared model units. */
-  readonly surfaceArea: number;
-  /** Number of indexed triangles. */
-  readonly triangleCount: number;
-  /** Number of distinct entries in the position buffer. */
-  readonly vertexCount: number;
-}
-
-/** 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;
-}
-
-/**
- * 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;
-}
-
 /**
  * Hollow +Z tube.
  *
@@ -3072,9 +1918,7 @@ export declare interface TriangularThreadProfileSpec extends ThreadProfileBaseSp
  */
 export declare function tube(options: TubeOptions): Solid;
 
-/**
- * Dimensions, placement, and tessellation for a hollow Z-axis tube.
- */
+/** Dimensions, placement, and tessellation for a hollow Z-axis tube. */
 export declare type TubeOptions = CircularPrimitiveOptions &
   PrimitiveAttachment & {
     /**
@@ -3082,6 +1926,8 @@ export declare type TubeOptions = CircularPrimitiveOptions &
      * @defaultValue `true`
      */
     readonly center?: boolean;
+    /** Independent end treatments trim both the outer rim and bore mouth; first setback is cap inset, second is axial depth. */
+    readonly ends?: EndTreatments;
     /** Total height along Z in millimetres. */
     readonly height: number;
     /** Inner nominal dimension meets polygon vertices or faces; defaults to vertex. */
@@ -3114,6 +1960,8 @@ export declare type TubeOptions = CircularPrimitiveOptions &
 /**
  * Robust union of one or more shapes; empty input rejects during declaration.
  *
+ * @param solids - Operands in shared modeling coordinates.
+ *
  * @example Union
  * ```ts
  * const block = box({ size: 20 });
@@ -3123,135 +1971,11 @@ export declare type TubeOptions = CircularPrimitiveOptions &
  */
 export declare function union(solids: readonly Solid[]): Solid;
 
-/** Native filled section union; dimensions cannot be mixed. */
-export declare function union(sections: readonly Section[]): Section;
-
-/** Immutable XY arithmetic; vector operations return new values and measurements return numbers. */
-export declare interface Vector2 {
-  /** X coordinate in the vector's coordinate units. */
-  readonly x: number;
-  /** Y coordinate in the vector's coordinate units. */
-  readonly y: number;
-  /** Adds another vector component-wise. */
-  add(other: Vector2Input): Vector2;
-  /** Subtracts another vector component-wise. */
-  subtract(other: Vector2Input): Vector2;
-  /** Multiplies by a finite dimensionless scalar. */
-  scale(factor: number): Vector2;
-  /** Returns a unit vector; rejects length at or below finite nonnegative `epsilon` (default `1e-12`). */
-  normalize(epsilon?: number): Vector2;
-  /** Interpolates toward another vector by finite dimensionless `t`; extrapolation is allowed. */
-  lerp(other: Vector2Input, t: number): Vector2;
-  /** Returns the scalar dot product. */
-  dot(other: Vector2Input): number;
-  /** Returns the signed scalar cross product; positive means the other vector is counterclockwise. */
-  cross(other: Vector2Input): number;
-  /** Returns Euclidean length in the vector's coordinate units. */
-  length(): number;
-  /** Returns Euclidean distance to another vector in the same coordinate units. */
-  distance(other: Vector2Input): number;
-  /** Returns this value's frozen readonly tuple for interchange; repeated calls do not allocate. */
-  toData(): Vector2Data;
-}
-
-/**
- * Creates immutable XY arithmetic from a finite tuple or vector, snapshotting the coordinates.
- *
- * Values and results are finite. Invalid dimensions throw `INVALID_ARGUMENT`; nonfinite coordinates
- * and overflow throw `NON_FINITE_VALUE` GeometryError.
- * Use transform2().applyDirection(value) for rotations and nonuniform scaling.
- *
- * Use `toData()` for frozen tuple interchange, or
- * [normalize2](/docs/reference/geometry/normalize2) for tuple-based normalization in numerical loops.
- */
-export declare function vector2(input: Vector2Input): Vector2;
-
-/** A two-dimensional Cartesian vector or point. */
-export declare type Vector2Data = readonly [x: number, y: number];
-
-/** An XY tuple or immutable fluent vector accepted by vector operations. */
-export declare type Vector2Input = Vector2Data | Vector2;
-
-/** Immutable XYZ arithmetic; vector operations return new values and measurements return numbers. */
-export declare interface Vector3 {
-  /** X coordinate in the vector's coordinate units. */
-  readonly x: number;
-  /** Y coordinate in the vector's coordinate units. */
-  readonly y: number;
-  /** Z coordinate in the vector's coordinate units. */
-  readonly z: number;
-  /** Adds another vector component-wise. */
-  add(other: Vector3Input): Vector3;
-  /** Subtracts another vector component-wise. */
-  subtract(other: Vector3Input): Vector3;
-  /** Multiplies by a finite dimensionless scalar. */
-  scale(factor: number): Vector3;
-  /** Returns a unit vector; rejects length at or below finite nonnegative `epsilon` (default `1e-12`). */
-  normalize(epsilon?: number): Vector3;
-  /** Interpolates toward another vector by finite dimensionless `t`; extrapolation is allowed. */
-  lerp(other: Vector3Input, t: number): Vector3;
-  /** Returns the scalar dot product. */
-  dot(other: Vector3Input): number;
-  /** Returns the right-handed cross product as a new vector. */
-  cross(other: Vector3Input): Vector3;
-  /** Returns Euclidean length in the vector's coordinate units. */
-  length(): number;
-  /** Returns Euclidean distance to another vector in the same coordinate units. */
-  distance(other: Vector3Input): number;
-  /** Returns this value's frozen readonly tuple for interchange; repeated calls do not allocate. */
-  toData(): Vector3Data;
-}
-
 /**
- * Creates immutable XYZ arithmetic from a finite tuple or vector, snapshotting the coordinates.
- *
- * Values and results are finite. Invalid dimensions throw `INVALID_ARGUMENT`; nonfinite coordinates
- * and overflow throw `NON_FINITE_VALUE` GeometryError.
- * Use transform3().applyDirection(value) for rotations and nonuniform scaling.
+ * Filled Section union; dimensions cannot be mixed.
  *
- * Use `toData()` for frozen tuple interchange, or
- * [normalize3](/docs/reference/geometry/normalize3) for tuple-based normalization in numerical loops.
- *
- * @example
- * ```ts
- * const direction = vector3([1, 2, 3]).add([4, 0, 0]).normalize().scale(10);
- * const alignment = direction.dot([0, 0, 1]);
- * ```
- */
-export declare function vector3(input: Vector3Input): Vector3;
-
-/** A three-dimensional Cartesian vector or point. */
-export declare type Vector3Data = readonly [x: number, y: number, z: number];
-
-/** An XYZ tuple or immutable fluent vector accepted by vector operations. */
-export declare type Vector3Input = Vector3Data | Vector3;
-
-/**
- * Immutable vector layout with no browser, font parser, or kernel ownership.
+ * @param sections - Operands in shared XY coordinates.
  */
-export declare interface VectorTextLayout {
-  /** Nonzero-filled path data in millimetres, positive Y upward; empty for text with no ink. */
-  readonly paths: readonly string[];
-  /** Exact measurements of these paths and their logical text layout. */
-  readonly metrics: VectorTextMetrics;
-}
-
-/** Text 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: Bounds2Data | null;
-  /** Unaligned logical advance and negative baseline displacement in mm; arcs retain [arc length, 0]. */
-  readonly advance: readonly [number, number];
-  /** Maximum logical line advance in millimetres, including spaces; arc length on circular baselines. */
-  readonly logicalWidth: number;
-  /** Selected font's ascender distance above a baseline in millimetres, independent of the text. */
-  readonly ascent: number;
-  /** Selected font's descender distance below a baseline in millimetres, a non-negative value. */
-  readonly descent: number;
-  /** Actual distance between baselines in millimetres. */
-  readonly lineHeight: number;
-  /** Number of lines, including empty and trailing lines; empty text occupies one line. */
-  readonly lineCount: number;
-}
+export declare function union(sections: readonly Section[]): Section;
 
 export {};