@metamesh/modeling 0.12.0 → 0.13.0

package/dist/api/index.d.ts

@@ -1,2268 +1,2489 @@
-/** Imported modeling operations and opaque host-owned contracts. @packageDocumentation */
-
-/** ACME 29-degree included-angle profile. */
-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;
-}
-
-/**
- * Reads a copied, immutable named anchor from this exact active generation.
- *
- * @example Read the top datum
- * ```ts
- * const plate = box({ size: [30, 20, 6] });
- * anchor(plate, "top"); // position [0, 0, 3], direction [0, 0, 1]
- * ```
- */
-export declare function anchor(shape: Solid | Section, name: string): Anchor3;
-
-/**
- * An attachment pose on a solid or assembly.
- *
- * `direction` is the outward attachment normal. `up` controls roll and must not
- * be parallel to `direction`; anchor construction projects and normalizes it.
- */
-export declare interface Anchor3 {
-    /** Unit outward normal used as the anchor's local +Z direction. */
-    readonly direction: Vec3;
-    /** World-space attachment position. */
-    readonly position: Vec3;
-    /** Roll guide projected into the plane perpendicular to `direction`. */
-    readonly up: Vec3;
-}
-
-/**
- * Degree-based anchor attachment controls for a scoped solid.
- */
-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 millimetres. */
-    readonly gap?: number;
-    /** Additional right-handed roll about the attached direction, in degrees. */
-    readonly spinDegrees?: number;
-    /** Optional numeric comparison overrides. */
-    readonly tolerance?: GeometryToleranceOptions;
-}
-
-/**
- * Axis-aligned box with uniform or disjoint named edge/group treatments.
- *
- * @example Rounded box
- * ```ts
- * box({ size: [30, 20, 8], treatment: { kind: "round", radius: 2 } });
- * ```
- */
-export declare function box(options: BoxOptions): Solid;
-
-/** Box edges use +Z top, +Y front and +X right; vertical names list front/back first. */
-export declare type BoxEdge = "top-front" | "top-back" | "top-left" | "top-right" | "bottom-front" | "bottom-back" | "bottom-left" | "bottom-right" | "front-left" | "front-right" | "back-left" | "back-right";
-
-/** Named individual edges or top/bottom rims and all four vertical edges. */
-export declare type BoxEdgeSelection = BoxEdge | "top" | "bottom" | "vertical";
-
-/** Independent treatments for disjoint named edge selections; overlapping selections fail. */
-export declare type BoxEdgeTreatments = Readonly<Partial<Record<BoxEdgeSelection, EdgeTreatment>>>;
-
-/**
- * Dimensions, placement, and uniform or independently selected finishing for an axis-aligned box.
- */
-export declare interface BoxOptions extends PrimitivePlacement {
-    /** Explicit sampling ceilings for edge treatments, bounded by the host policy. */
-    readonly limits?: Partial<GeometrySamplingLimits>;
-    /**
-     * Centers the box on the XYZ origin when `true`; otherwise its minimum corner is at the origin.
-     * @defaultValue `true`
-     */
-    readonly center?: boolean;
-    /** Positive uniform size or explicit `[X, Y, Z]` extents in millimetres. */
-    readonly size: number | Vec3;
-    /** Uniform treatment or independent disjoint nominal edge/group treatments. */
-    readonly treatment?: EdgeTreatment | BoxEdgeTreatments;
-}
-
-/** Axial side carrying the near-normal pressure flank of a buttress thread. */
-declare type ButtressPressureFlankSide = "negative" | "positive";
-
-/** Asymmetric printable buttress profile with 7/45-degree flanks. */
-declare interface ButtressThreadProfileSpec extends ThreadProfileBaseSpec {
-    /** Selects the asymmetric printable buttress profile family. */
-    readonly kind: "buttress";
-    /**
-     * Radial depth in millimetres.
-     * @defaultValue `0.66271 * pitch`
-     */
-    readonly depth?: number;
-    /**
-     * Axial side of each tooth carrying the 7-degree pressure flank. The opposite side uses the
-     * 45-degree clearance flank.
-     * @defaultValue `"positive"`
-     */
-    readonly pressureFlankSide?: ButtressPressureFlankSide;
-}
-
-/**
- * A planar edge or corner chamfer with equal or independent surface setbacks.
- */
-export declare interface ChamferedEdgeTreatment {
-    /** Selects a straight bevel between adjoining surfaces. */
-    readonly kind: "chamfer";
-    /** Positive tangent setbacks in millimetres, equal or [first surface, second surface]; selected treatments must fit without overlap. */
-    readonly distance: number | readonly [first: number, second: number];
-}
-
-/**
- * Centered circular section.
- *
- * @example Size to polygon faces
- * ```ts
- * circle({ diameter: 12, sizing: "face" });
- * ```
- */
-export declare function circle(options: CircleOptions): Section;
-
-/**
- * Circular profile dimensions with exactly one radius or diameter and explicit sampling.
- */
-export declare type CircleLoopOptions = CircularPrimitiveOptions & RadialSizingOptions & ({
-    /** Positive nominal radius in millimetres; mutually exclusive with diameter. */
-    readonly radius: number;
-    /** Full diameter is unavailable when radius is supplied. */
-    readonly diameter?: never;
-} | {
-    /** Positive full diameter in millimetres; mutually exclusive with radius. */
-    readonly diameter: number;
-    /** Radius is unavailable when diameter is supplied. */
-    readonly radius?: never;
-});
-
-/**
- * Circular dimensions with exactly one nominal radius or diameter.
- */
-export declare type CircleOptions = CircleLoopOptions & PrimitivePlacement;
-
-/**
- * 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;
-}
-
-/**
- * Separates a solid's disconnected surface shells into same-session solid handles.
- *
- * For solids without enclosed cavities, these shells are the disconnected material islands.
- * Enclosed cavities produce separate inward shells with negative signed volume; these cannot
- * be finalized alone as manufacturing parts. This does not cut connected geometry.
- *
- * @example Move disconnected pieces independently
- * ```ts
- * const islands = union([box({ size: 8 }), box({ size: 8 }).translate([12, 0, 0])]);
- * const pieces = components(islands);
- * // Component order is unspecified; the index only sets a display height here.
- * union(pieces.map((piece, index) => piece.translate([0, 0, index * 6])));
- * ```
- */
-export declare function components(solid: Solid): readonly Solid[];
-
-/** Separates filled 2D islands into sections, retaining each island's holes; empty gives []. */
-export declare function components(section: Section): readonly Section[];
-
-/** Combines disjoint components without resolving overlap. */
-export declare function compose(solids: readonly Solid[]): Solid;
-
-/** 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. */
-    (): T;
-}
-
-declare const computedBrand: unique symbol;
-
-/** A value supplied immediately or by a lazy computed reader. */
-export declare type ComputedValue<T> = T | Computed<T>;
-
-/** One sampled component retaining contour identities and logical point correspondence. */
-export declare interface CorrespondingComponent {
-    /** Stable canonical lowercase identity; unique within the containing topology or output. */
-    readonly id: string;
-    /** Counterclockwise outer contour. */
-    readonly outer: CorrespondingContour;
-    /** Clockwise hole contours belonging to this component. */
-    readonly holes: readonly CorrespondingContour[];
-}
-
-/** A sampled contour retaining logical slots, including intentionally collapsed spans. */
-export declare interface CorrespondingContour {
-    /** Stable canonical lowercase identity; unique within the containing topology or output. */
-    readonly id: string;
-    /** Ordered sampled points in millimetres; closing vertices are implicit. */
-    readonly points: Loop2;
-    /** One span identity per point; indices correspond between every matched family member. */
-    readonly spans: readonly string[];
-}
-
-/** Shared logical contour sampling suitable for a loft or hollow sweep. */
-export declare interface CorrespondingProfile {
-    /** Ordered components with explicit contour identities. */
-    readonly components: readonly CorrespondingComponent[];
-}
-
-/** One already matched profile at an explicit height or right-handed spatial frame. */
-export declare type CorrespondingProfileStation = LoftPlacement & {
-    /** Already corresponding filled contours with authoritative landmark slots. */
-    readonly profile: CorrespondingProfile;
-};
-
-/** Caller-defined periodic axial/radial profile in millimetres. */
-declare interface CustomThreadProfileSpec extends ThreadProfileBaseSpec {
-    /** Selects a caller-defined periodic profile. */
-    readonly kind: "custom";
-    /**
-     * Open path spanning exactly `[-pitch/2, pitch/2]`, with both endpoints on the minor envelope,
-     * one connected ridge, one contiguous crest, and radial zero at the major envelope.
-     */
-    readonly points: readonly Vec2[];
-}
-
-/**
- * +Z cylinder or frustum. Face sizing compensates polygon faceting.
- *
- * @example Cylinder
- * ```ts
- * cylinder({ height: 20, radius: 10 });
- * ```
- *
- * @example Cone
- * ```ts
- * cylinder({ height: 20, radius: [10, 0] });
- * ```
- */
-export declare function cylinder(options: CylinderOptions): Solid;
-
-/**
- * Dimensions, placement, independent end finishing, and tessellation for a Z-axis cylinder or frustum.
- */
-export declare type CylinderOptions = CircularPrimitiveOptions & RadialSizingOptions & PrimitivePlacement & {
-    /**
-     * Centers the solid on the Z origin when `true`; otherwise its bottom is at `Z = 0`.
-     * @defaultValue `true`
-     */
-    readonly center?: boolean;
-    /** Independent end treatments; first setback is cap inset and second follows the sloped side. */
-    readonly ends?: EndTreatments;
-    /** Total height along +Z in millimetres. */
-    readonly height: number;
-} & ({
-    /** Positive uniform radius or nonnegative `[bottom, top]` radii in millimetres; one must be positive. */
-    readonly radius: number | readonly [bottom: number, top: number];
-    /** Full diameter is unavailable when radius is supplied. */
-    readonly diameter?: never;
-} | {
-    /** Positive uniform diameter or nonnegative `[bottom, top]` diameters in millimetres; one must be positive. */
-    readonly diameter: number | readonly [bottom: number, top: number];
-    /** Radius is unavailable when diameter is supplied. */
-    readonly radius?: never;
-});
-
-/** Typed parameter association for an assertion or warning. */
-export declare interface DiagnosticOptions<P> {
-    /** Existing top-level parameter key. */
-    readonly parameterId?: Extract<keyof P, string> | undefined;
-}
-
-/**
- * Measures the minimum separation between two nonempty solids in millimetres.
- *
- * Uses actual geometry, not bounding-box separation or distance between object origins.
- * Contact or overlapping material returns zero, including one solid inside another.
- * The kernel's search range is managed internally; the result is not capped at a caller limit.
- * Empty, expired or foreign-build handles reject. Results follow native numeric precision.
- *
- * @example Measure the gap between two blocks
- * ```ts
- * const left = box({ size: 10 });
- * const right = box({ size: 10 }).translate([13, 0, 0]);
- * const gap = distance(left, right); // 3 mm
- * ```
- */
-export declare function distance(solid: Solid, other: Solid): number;
-
-/**
- * Uniform finishing vocabulary shared by applicable solid edges and profile corners.
- */
-export declare type EdgeTreatment = ChamferedEdgeTreatment | RoundedEdgeTreatment | SmoothEdgeTreatment | ProfiledEdgeTreatment;
-
-/**
- * Centered elliptical section.
- *
- * @example Ellipse by full dimensions
- * ```ts
- * ellipse({ size: [30, 20] });
- * ```
- */
-export declare function ellipse(options: EllipseOptions): Section;
-
-/**
- * Ellipse dimensions with exactly one XY radii or full-size tuple and explicit sampling.
- */
-export declare type EllipseLoopOptions = CircularPrimitiveOptions & ({
-    /** Positive XY radii in millimetres; mutually exclusive with size. */
-    readonly radius: Vec2;
-    /** Full XY extents are unavailable when radius is supplied. */
-    readonly size?: never;
-} | {
-    /** Positive full XY extents in millimetres; mutually exclusive with radius. */
-    readonly size: Vec2;
-    /** XY radii are unavailable when size is supplied. */
-    readonly radius?: never;
-});
-
-/**
- * Ellipse dimensions in local XY, with exactly one radii or full-size tuple.
- */
-export declare type EllipseOptions = EllipseLoopOptions & PrimitivePlacement;
-
-/**
- * Independent inward finishing on primitive or straight convex extrusion ends.
- */
-export declare interface EndTreatments {
-    /** Bottom cap and adjoining side; omitted leaves the end untreated. */
-    readonly bottom?: EdgeTreatment;
-    /** Top cap and adjoining side; omitted leaves the end untreated. */
-    readonly top?: EdgeTreatment;
-}
-
-/**
- * Extrudes explicit corresponding contours along +Z with degree twist and top scaling.
- * Filled Sections use `section.extrude(options)`.
- *
- * @example Extrude
- * ```ts
- * import { extrude, matchProfiles } from "@metamesh/modeling";
- * import { rectangleProfile } from "@metamesh/modeling/geometry";
- *
- * const [profile] = matchProfiles([rectangleProfile({ size: [30, 20] })]);
- * extrude(profile!, { height: 8 });
- * ```
- */
-export declare function extrude(shape: CorrespondingProfile, options: ExtrudeOptions): Solid;
-
-/**
- * Dimensions and sampling shared by native and pure +Z extrusion.
- */
-export declare interface ExtrudeOptions extends ExtrusionSamplingOptions {
-    /** Positive extrusion height in millimetres. */
-    readonly height: number;
-    /** Center the extrusion on Z; otherwise its bottom is at zero. Defaults to false. */
-    readonly center?: boolean;
-    /** Independent inward end treatments on straight convex single-contour extrusions. */
-    readonly ends?: EndTreatments;
-}
-
-/** Shared sampling controls for a twisted or scaled linear extrusion. */
-declare interface ExtrusionSamplingOptions {
-    /** Exact number of intermediate profiles, nonnegative; overrides physical sampling. */
-    readonly divisions?: number;
-    /** Explicit output and sampling allocation ceilings. */
-    readonly limits?: Partial<ModelingLimits>;
-    /** Operation-level physical policy over the nearest model scope. */
-    readonly resolution?: GeometryResolution;
-    /** Finite uniform or XY scale of the top profile; defaults to one. */
-    readonly scaleTop?: number | Vec2;
-    /** Finite rotation of the top profile about +Z, in degrees; defaults to zero. */
-    readonly twistDegrees?: number;
-}
-
-/** Finalized manufacturing snapshot. Its arrays are independent of all native values. */
-export declare interface FinalizedModel {
-    /** Ordered finalized manufacturing parts with copied transferable arrays. */
-    readonly parts: readonly FinalizedPart[];
-    /** Axis-aligned XYZ bounds in millimetres. */
-    readonly bounds: MeshBounds;
-    /** Aggregate counts, unique backing storage, volume, and execution timings. */
-    readonly stats: {
-        /** Aggregate position-buffer vertex count. */
-        readonly vertices: number;
-        /** Aggregate indexed triangle count. */
-        readonly triangles: number;
-        /** Signed enclosed volume of all selected parts in cubic millimetres. */
-        readonly volumeMm3: number;
-        /** Unique transferable backing-buffer bytes, counted once across all parts. */
-        readonly bytes: number;
-        /** Synchronous callback duration in milliseconds. */
-        readonly buildMs: number;
-        /** Manufacturing validation and buffer finalization duration in milliseconds. */
-        readonly finalizationMs: number;
-        /** Total callback and finalization duration in milliseconds. */
-        readonly generationMs: number;
-    };
-}
-
-/** Copied manufacturing part with facts computed from the finalized mesh. */
-export declare interface FinalizedPart extends TriangleMesh {
-    /** Stable canonical lowercase identity; unique within the containing topology or output. */
-    readonly id: string;
-    /** Optional six-digit hex RGB display color. */
-    readonly color?: string;
-    /** Fresh validated facts for these exact finalized buffers. */
-    readonly measurements: TriangleMeshAnalysis;
-}
-
-/** A right-handed orthonormal coordinate frame expressed in world coordinates. */
-export declare interface Frame3 {
-    /** World-space origin of the local frame. */
-    readonly origin: Vec3;
-    /** Unit vector defining the local +X axis. */
-    readonly xAxis: Vec3;
-    /** Unit vector defining the local +Y axis. */
-    readonly yAxis: Vec3;
-    /** Unit vector defining the local +Z axis. */
-    readonly zAxis: Vec3;
-}
-
-/** Imports explicit region topology once. */
-export declare function fromRegion(region: Region2): Section;
-
-/**
- * Defines a typed model without executing it. Use `computed` only for work worth reusing.
- *
- * @example A simple model
- * ```ts
- * const model = generate<{ height: number }>(({ params, part, assert }) => {
- *   assert(params.height > 0, "Height must be positive.");
- *   return [part("body", box({ size: [10, 10, params.height] }))];
- * });
- * ```
- */
-export declare function generate<P, S = Record<never, never>>(callback: GenerateCallback<P, S>): ModelProgram<P, S>;
-
-/** Pure synchronous generation callback; caches are an optional performance optimization. */
-export declare type GenerateCallback<P, S = Record<never, never>> = (context: GenerateContext<P, S>) => readonly GeneratedPart[];
-
-/** The sole synchronous authoring context, supplied independently of Studio. */
-export declare interface GenerateContext<P, S = Record<never, never>> {
-    /** Frozen ordinary parameter values; synchronous top-level reads are tracked. */
-    readonly params: Readonly<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>;
-    /** Declares a semantic part with identity placement, or explicit placement and appearance. */
-    readonly part: {
-        (id: string, geometry: ComputedValue<PartGeometry>): GeneratedPart;
-        (id: string, options: PartOptions): GeneratedPart;
-    };
-    /** Immediately aborts on false; geometry observations in the condition run first. */
-    readonly assert: {
-        (condition: false, message: string, options?: DiagnosticOptions<P>): never;
-        (condition: boolean, message: string, options?: DiagnosticOptions<P>): void;
-    };
-    /** Records a nonblocking issue; call only in the outer generation callback. */
-    readonly warn: (message: string, options?: DiagnosticOptions<P>) => void;
-}
-
-/** One declared output part. Construct with the context's `part` helper. */
-export declare interface GeneratedPart extends PartOptions {
-    /** Unique canonical lowercase hyphen-separated identity, at most 64 characters. */
-    readonly id: string;
-}
-
-/** Structured user-facing issue associated with the attempted revision. */
-export declare interface GenerationDiagnostic {
-    /** An error aborts generation; a warning allows generation to continue. */
-    readonly severity: "error" | "warning";
-    /** Human-readable corrective guidance. */
-    readonly message: string;
-    /** Optional control identity, validated against the supplied parameters. */
-    readonly parameterId?: string | undefined;
-}
-
-/** A user-correctable assertion failure. Successful computation 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[];
-    /** Captures immutable diagnostics; unexpected author errors retain their original type. */
-    constructor(diagnostics: readonly GenerationDiagnostic[]);
-}
-
-/**
- * Tessellation policy for sampled geometry measured in millimetres.
- */
-export declare interface GeometryResolution {
-    /** Optional exact full-circle segment count, of at least three, bounded by the selected circular ceiling. */
-    readonly circularSegments?: number;
-    /** Maximum radial chord error in millimetres; defaults to 0.05. */
-    readonly maxChordError?: number;
-    /** Optional maximum sampled edge length in millimetres. */
-    readonly maxSegmentLength?: number;
-    /** Upper safety bound for a full circle; defaults to the selected maxCircularSegments (512 by default). */
-    readonly maximumSegments?: number;
-    /** Lower full-circle segment count; defaults to 16 or a lower selected circular ceiling. */
-    readonly minimumSegments?: number;
-}
-
-/** Explicit allocation ceilings for pure sampling and host-owned modeling operations. */
-export declare interface GeometrySamplingLimits {
-    /** Maximum points in one sampled path or placement/frame result. */
-    readonly maxPathPoints: number;
-    /** Maximum aggregate points in one sampled profile or Section. */
-    readonly maxProfilePoints: number;
-    /** Maximum points in one profile swept along a path. */
-    readonly maxSweepProfilePoints: number;
-    /** Maximum segments around one complete circle. */
-    readonly maxCircularSegments: number;
-}
-
-/** Optional overrides for MetaMesh's geometry comparison policy. */
-export declare interface GeometryToleranceOptions {
-    /** Absolute distance floor in model units. Must be finite and greater than zero. */
-    readonly absolute?: number;
-    /** Angular comparison threshold in radians. Must be finite and greater than zero. */
-    readonly angular?: number;
-    /** Dimensionless scale multiplier. Must be finite and non-negative. */
-    readonly relative?: number;
-}
-
-/**
- * XY or XYZ copies, optionally centered or placed in an explicit frame.
- *
- * @example Centered XY grid
- * ```ts
- * gridPattern(box({ size: 4 }), { count: [3, 2], spacing: [10, 10], center: true });
- * ```
- */
-export declare function gridPattern(source: PatternSource, options: GridPatternOptions): readonly Solid[];
-
-/**
- * XY or XYZ grid with X varying fastest. The first item starts at the local origin.
- */
-export declare type GridPatternOptions = {
-    /** 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: Vec2;
-    /** Signed millimetres between adjacent copies on X and Y. */
-    readonly spacing: Vec2;
-} | {
-    /** Positive integer counts on X, Y and Z. */
-    readonly count: Vec3;
-    /** Signed millimetres between adjacent copies on X, Y and Z. */
-    readonly spacing: Vec3;
-});
-
-/**
- * Closed rectilinear top above a flat base, with uniform or explicit XY coordinates.
- * Samples each grid height once; center-error triangulation also samples each cell centre.
- *
- * @example Heightfield
- * ```ts
- * heightfield({
- *   size: [30, 20], segments: [24, 16],
- *   height: ([x, y]) => 3 + Math.cos(x / 5) * Math.cos(y / 5),
- * });
- * ```
- */
-export declare function heightfield(options: HeightfieldOptions): Solid;
-
-/**
- * A closed rectilinear heightfield above a flat base, with uniform or explicit XY samples in millimetres.
- *
- * Uniform sampling requires positive `size: [width, depth]` and positive integer `segments: [x, y]`.
- * Optional `origin` sets the lower-left XY corner; omitting it centres the footprint on XY.
- * Alternatively, supply `coordinates: { x, y }` with at least two strictly increasing finite
- * absolute samples per axis, distinct in Float32. This infers the footprint and interval counts;
- * `size`, `segments`, and `origin` cannot be combined with explicit coordinates.
- */
-export declare type HeightfieldOptions = {
-    /** Absolute top Z at the supplied XY point. Every sample must be above baseZ. */
-    readonly height: (point: Vec2) => number;
-    /** Flat bottom Z. Defaults to zero. */
-    readonly baseZ?: number;
-    /**
-     * Top-cell diagonal policy. Defaults to fixed (lower-left to upper-right).
-     * min-edge selects the shorter 3D diagonal; center-error selects the diagonal whose endpoint
-     * average is closest to one extra height sample at the physical cell centre. Ties use fixed.
-     * All policies retain two triangles per cell; neither estimates error elsewhere in the cell.
-     */
-    readonly triangulation?: "fixed" | "min-edge" | "center-error";
-} & ({
-    /** Positive XY footprint for uniform sampling. */
-    readonly size: Vec2;
-    /** Exact positive integer X/Y interval counts. */
-    readonly segments: readonly [x: number, y: number];
-    /** Lower-left footprint XY. Omitted centers the footprint on XY. */
-    readonly origin?: Vec2;
-    /** Explicit coordinates cannot be combined with uniform sampling. */
-    readonly coordinates?: never;
-} | {
-    /**
-     * Absolute XY coordinates, each with at least two strictly increasing finite values that
-     * remain distinct in Float32. Uneven spacing permits caller-owned local refinement.
-     */
-    readonly coordinates: {
-        /** Absolute X samples in ascending order. */
-        readonly x: readonly number[];
-        /** Absolute Y samples in ascending order. */
-        readonly y: readonly number[];
-    };
-    /** The footprint is inferred from explicit coordinates. */
-    readonly size?: never;
-    /** Interval counts are inferred from explicit coordinates. */
-    readonly segments?: never;
-    /** Explicit coordinates already include their origin. */
-    readonly origin?: never;
-});
-
-/** Runtime-neutral options for the dedicated helical ridge mesher. */
-export declare interface HelicalThreadRidgeMeshOptions {
-    /**
-     * Optional bottom/top ridge-end treatments. Standalone ridges honor the requested boundaries;
-     * BOSL2-style non-cut lead-in scaling is available on complete thread solids.
-     */
-    readonly ends?: ThreadEndTreatmentOptions;
-    /** Helix direction. Default: `right`. */
-    readonly handedness?: ThreadHandedness;
-    /** Total threaded axial length in millimetres. */
-    readonly length: number;
-    /** Explicit output and circular allocation ceilings. */
-    readonly limits?: Partial<ModelingLimits>;
-    /** Nominal major diameter before any caller-owned fit compensation. */
-    readonly majorDiameter: number;
-    /** Angular offset of the first start in degrees. Default: `0`. */
-    readonly phaseDegrees?: number;
-    /** Validated periodic profile repeated around the shaft. */
-    readonly profile: ThreadProfile;
-    /** Optional circular-resolution policy. */
-    readonly resolution?: GeometryResolution;
-    /** Number of evenly phased starts. Default: `1`. */
-    readonly starts?: number;
-    /** Optional numerical tolerance overrides. */
-    readonly tolerance?: GeometryToleranceOptions;
-}
-
-/** Conservative allocation facts resolved before constructing a direct thread solid mesh. */
-export declare interface HelicalThreadSolidMeshPreflight {
-    /** Uniform axial intervals required only by a requested physical segment-length limit. */
-    readonly axialIntervals: number;
-    /** Start-aligned full-circle segment count used by the surface mesh. */
-    readonly circularSegments: number;
-    /** Conservative surface-row count across profile breaks, ends, and bevel stations. */
-    readonly estimatedRows: number;
-    /** Conservative triangle count used by the selected output allocation policy. */
-    readonly estimatedTriangles: number;
-}
-
-/**
- * Convex hull of points or solids.
- *
- * @example Hull
- * ```ts
- * const left = sphere({ radius: 5 }).translate([-10, 0, 0]);
- * const right = sphere({ radius: 5 }).translate([10, 0, 0]);
- * hull({ solids: [left, right] });
- * ```
- */
-export declare function hull(options: HullOptions): Solid;
-
-/** Convex filled XY hull of finite points or same-session sections. */
-export declare function hull(options: SectionHullOptions): Section;
-
-/** Hull inputs are either finite points or same-session solids. */
-export declare type HullOptions = {
-    /** Finite millimetre XYZ points to include in the convex hull. */
-    readonly points: readonly Vec3[];
-    /** Point input excludes solid input. */
-    readonly solids?: never;
-} | {
-    /** Same-build solids to include in the convex hull. */
-    readonly solids: readonly Solid[];
-    /** Solid input excludes point input. */
-    readonly points?: never;
-};
-
-/** Owned immutable numeric data. Use copy() to obtain mutable storage for numerical work. */
-export declare interface ImmutableBuffer<T extends NumericArray> {
-    /** Opaque element-storage brand; construct buffers with immutableBuffer(). */
-    readonly [immutableBufferBrand]: T;
-    /** Number of numeric elements, independent of their byte width. */
-    readonly length: number;
-    /** Reads an integer offset; negative offsets count from the end. Invalid offsets return undefined. */
-    at(this: void, index: number): number | undefined;
-    /** Returns a fresh mutable array of the original numeric type; never exposes cached storage. */
-    copy(this: void): T;
-}
-
-/**
- * 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 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;
-
-/**
- * Copies mesh buffers into immutable data; geometric validation still occurs when modeling or finalizing.
- * @example
- * ```ts
- * import { generate, immutableMesh } from "@metamesh/modeling";
- * import { heightfieldMesh } from "@metamesh/modeling/geometry";
- * const model = generate(({ computed, part }) => {
- *   const surface = computed("surface", () => immutableMesh(heightfieldMesh({
- *     size: [10, 10], segments: [8, 8], height: () => 2,
- *   })));
- *   return [part("surface", surface)];
- * });
- * ```
- */
-export declare function immutableMesh(mesh: TriangleMesh): ImmutableTriangleMesh;
-
-/** Immutable local XYZ positions and triangle indices, suitable for a computed value or part. */
-export declare interface ImmutableTriangleMesh {
-    /** Packed XYZ coordinates in millimetres. */
-    readonly positions: ImmutableBuffer<Float32Array>;
-    /** Zero-based vertex indices, three per triangle. */
-    readonly indices: ImmutableBuffer<Uint32Array>;
-}
-
-/** Bounded positive-inside implicit field constructor. */
-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. */
-    readonly field: (point: Vec3) => number;
-    /** Axis-aligned XYZ bounds in millimetres. */
-    readonly bounds: MeshBounds;
-    /** Positive sampling edge length in millimetres. */
-    readonly edgeLength: number;
-    /** Field isosurface value; defaults to zero. */
-    readonly level?: number;
-    /** Positive native geometric tolerance in millimetres; omitted uses interpolated grid crossings. */
-    readonly tolerance?: number;
-}
-
-/**
- * Copies lightweight section measurements.
- *
- * @example Check filled area
- * ```ts
- * const facts = inspectSection(rectangle({ size: [20, 10] }));
- * facts.area; // 200 mm²
- * ```
- */
-export declare function inspectSection(section: Section): SectionInspection;
-
-/**
- * Reads immutable native facts once per solid; temporary components are owned by the build.
- *
- * @example Check dimensions and volume
- * ```ts
- * const facts = inspectSolid(box({ size: [30, 20, 6] }));
- * facts.volume; // 3600 mm³
- * ```
- */
-export declare function inspectSolid(solid: Solid): SolidInspection;
-
-/**
- * Compensated internal threaded cutter.
- *
- * @example Internal thread
- * ```ts
- * import { cylinder, internalThreadCutter } from "@metamesh/modeling";
- * import { createThreadProfile } from "@metamesh/modeling/geometry";
- * const profile = createThreadProfile({ 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]);
- * ```
- */
-export declare function internalThreadCutter(options: InternalThreadCutterOptions): Solid;
-
-/** Options for a compensated internal-thread subtraction tool along +Z. */
-export declare interface InternalThreadCutterOptions extends Omit<HelicalThreadRidgeMeshOptions, "majorDiameter">, ThreadBevelOptions {
-    /** Printable fit or caller-calibrated allowances. Default: `normal`. */
-    readonly fit?: PrintableThreadFit | PrintableThreadFitPolicy;
-    /** Nominal major diameter before female compensation and faceting correction. */
-    readonly nominalMajorDiameter: number;
-}
-
-/**
- * Robust intersection.
- *
- * @example Intersect
- * ```ts
- * intersect([box({ size: 20 }), sphere({ radius: 12 })]);
- * ```
- */
-export declare function intersect(solids: readonly Solid[]): Solid;
-
-/** Native filled section intersection; dimensions cannot be mixed. */
-export declare function intersect(sections: readonly Section[]): Section;
-
-/**
- * Checks whether a same-session solid or filled section contains no geometry.
- *
- * Accepts a 3D Solid or 2D Section handle, not a finalized model or raw triangle mesh.
- * Useful after a Boolean operation whose inputs may not overlap; no mesh is extracted.
- *
- * @example Check a missed intersection
- * ```ts
- * const body = box({ size: 10 });
- * const distant = box({ size: 10 }).translate([30, 0, 0]);
- * const empty = intersect([body, distant]);
- * const missed = isEmpty(empty); // true
- * ```
- */
-export declare function isEmpty(shape: Solid | Section): boolean;
-
-/**
- * Repeats one solid along a normalized direction.
- *
- * @example Three copies along X
- * ```ts
- * linearPattern(box({ size: 4 }), { count: 3, spacing: 10 });
- * ```
- */
-export declare function linearPattern(source: PatternSource, options: LinearPatternOptions): readonly Solid[];
-
-/**
- * Equal linear intervals determined by exactly two of count, spacing and total length.
- */
-export declare type LinearPatternOptions = {
-    /** Direction of repetition; magnitude is ignored. Defaults to +X. */
-    readonly direction?: Vec3;
-} & ({
-    /** 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 primitive Sections at z heights or frames; arbitrary Sections and loops require an explicit correspondence method.
- *
- * @example Loft
- * ```ts
- * loft([
- *   { profile: circle({ diameter: 16 }), z: 0 },
- *   { profile: rectangle({ size: [30, 20], treatment: { kind: "round", radius: 3 } }), z: 30 },
- * ]);
- * ```
- */
-export declare function loft(stations: readonly LoftStation[], options?: LoftOptions): Solid;
-
-/** Lofts explicit corresponding contours, including holes and collapsed logical slots. */
-export declare function loft(stations: readonly CorrespondingProfileStation[], options?: LoftOptions): Solid;
-
-/**
- * Associates ordered loft contours without inferring component identities or repairing topology.
- *
- * - `direct` preserves seams and subdivides edges to a common count without dropping vertices.
- * - `reindex` applies direct subdivision, then selects the next contour's cyclic phase with the
- *   least total world-space connection length.
- * - `fast-distance` preserves supplied seams and minimizes connection length over ordered closed
- *   vertex associations, repeating vertices for triangular fans.
- * - `distance` runs the same ordered optimization over every cyclic phase of the next contour.
- *
- * Components and holes are paired by their existing order. Use identified profiles when semantic
- * correspondence must remain authoritative.
- */
-export declare type LoftCorrespondence = "direct" | "reindex" | "fast-distance" | "distance";
-
-/**
- * Shared controls for native and pure lofts. Point data and arbitrary Sections require explicit correspondence.
- */
-export declare interface LoftOptions {
-    /** One method or one per consecutive station gap. Omitted preserves known landmarks, including circle/ellipse-to-rectangle corners, or maps other unlike primitive seams directly. */
-    readonly correspondence?: LoftCorrespondence | readonly LoftCorrespondence[];
-    /** Extra points follow edge length or distribute equally across existing segments. Defaults to perimeter for direct/reindex, or segments when any distance method is selected; distance methods require segments. */
-    readonly distribution?: "perimeter" | "segments";
-    /** Positive integer point-density multiplier, uniformly or per input profile. Original vertices are retained. Defaults to one. */
-    readonly refine?: number | readonly number[];
-    /** Nonnegative count of world-linearly interpolated profiles, uniformly or per gap. Defaults to zero. */
-    readonly slices?: number | readonly number[];
-    /** Physical curve policy for retained primitives, and maximum edge length for point data. Exact primitive curve counts take precedence. */
-    readonly resolution?: GeometryResolution;
-    /** Explicit output and sampling budgets; native operations may only lower host ceilings. */
-    readonly limits?: Partial<ModelingLimits>;
-}
-
-/**
- * A horizontal XY station height, or an explicit right-handed spatial frame, never both.
- */
-export declare type LoftPlacement = {
-    /** Horizontal XY station height in millimetres. */
-    readonly z: number;
-    /** Excluded when a horizontal height is supplied. */
-    readonly frame?: never;
-} | {
-    /** Right-handed orthonormal station frame in world coordinates. */
-    readonly frame: Frame3;
-    /** Excluded when an explicit spatial frame is supplied. */
-    readonly z?: never;
-};
-
-/**
- * A Section or point loop at an explicit height or frame.
- */
-export declare type LoftStation = LoftPlacement & {
-    /** Same-build filled Section or ordered XY boundary point data. */
-    readonly profile: Section | Loop2;
-};
-
-/**
- * A closed two-dimensional boundary whose first point is not repeated at the end.
- *
- * Polygon exteriors are counter-clockwise and holes are clockwise. Algorithms
- * may reject duplicate adjacent points or fewer than three effective vertices.
- */
-export declare type Loop2 = readonly Vec2[];
-
-/** Explicit family matching on a shared physical span grid using session or operation resolution. */
-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>;
-}
-
-/**
- * Axis-aligned bounds of a non-empty triangle mesh.
- */
-export declare interface MeshBounds {
-    /** Inclusive minimum XYZ coordinates. */
-    readonly min: Vec3;
-    /** Inclusive maximum XYZ coordinates. */
-    readonly max: Vec3;
-}
-
-/** Three-dimensional Minkowski sum. */
-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, S = Record<never, never>> {
-    /** Exact generation protocol discriminator. */
-    readonly kind: "metamesh-model";
-    /** Typed synchronous declaration callback. */
-    readonly generate: GenerateCallback<P, S>;
-}
-
-/** Numeric storage supported by immutable generation buffers. */
-export declare type NumericArray = Float32Array | Float64Array | Uint32Array | Uint8Array | Int32Array;
-
-/** Manufacturing geometry; filled sections are intermediate construction values. */
-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>;
-    /** XYZ translation in millimetres, applied after rotation; defaults to zero. */
-    readonly position?: ComputedValue<Vec3>;
-    /** Fixed global X, Y, Z rotations in degrees; defaults to zero. */
-    readonly rotation?: ComputedValue<Vec3>;
-    /** Optional six-digit hexadecimal semantic part color. */
-    readonly color?: string;
-}
-
-/**
- * Supplies a profile-X orientation guide for each original normalized sweep station.
- *
- * @param point - Current XYZ path point in model units.
- * @param index - Zero-based index of `point` in the normalized authored sweep path.
- * @returns A finite guide vector that is not parallel to the local path tangent.
- */
-export declare type PathNormalGuide = (point: Vec3, index: number) => Vec3;
-
-/**
- * Physical arc-length copies along a sampled path, with optional tangent orientation.
- *
- * @example Copies along a bent path
- * ```ts
- * pathPattern(box({ size: 4 }), [[0, 0, 0], [20, 0, 0], [20, 20, 0]], { count: 5 });
- * ```
- */
-export declare function pathPattern(source: PatternSource, path: readonly Vec3[], options: PathPatternOptions): readonly Solid[];
-
-/** 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;
-    /** Include the closing edge without duplicating the seam; defaults to false. */
-    readonly closed?: boolean;
-    /** Preserve the source orientation, or align its +Z to the path tangent; defaults to fixed. */
-    readonly orientation?: "fixed" | "tangent";
-}
-
-/**
- * One same-session shape, or a synchronous factory called once per copy in index order.
- */
-export declare type PatternSource = Solid | ((index: number) => Solid);
-
-/** A world-space cutting plane, retaining the half-space in the normal's direction. */
-export declare interface PlaneOptions {
-    /** Finite nonzero plane normal; magnitude does not affect the plane. */
-    readonly normal: Vec3;
-    /** Signed millimetre distance from the origin along the unit normal. Defaults to zero. */
-    readonly offset?: number;
-}
-
-/**
- * One bounded two-dimensional polygon.
- *
- * `outer` is counter-clockwise and each hole is clockwise. Boundary arrays omit
- * their duplicated closing point. Holes must lie inside `outer` and must not
- * intersect each other or the exterior.
- */
-export declare interface Polygon2 {
-    /** Clockwise interior boundaries, each omitting its duplicated closing point. */
-    readonly holes: readonly Loop2[];
-    /** Counter-clockwise exterior boundary, omitting its duplicated closing point. */
-    readonly outer: Loop2;
-}
-
-/** Allocation-free internal-thread facts. */
-export declare function preflightInternalThreadCutter(options: InternalThreadCutterOptions): HelicalThreadSolidMeshPreflight;
-
-/** Allocation-free nut/cutter facts. */
-export declare function preflightThreadedNut(options: ThreadedNutOptions): ThreadedNutPreflight;
-
-/** Allocation-free external-thread facts. */
-export declare function preflightThreadedRod(options: ThreadedRodOptions): HelicalThreadSolidMeshPreflight;
-
-/** Placement shared by solid and filled-section factories. */
-export declare interface PrimitivePlacement {
-    /** Applied after local construction; Section placement must preserve the XY plane. */
-    readonly placement?: PrimitivePlacementOptions;
-}
-
-/** Maps an explicit or named shape-local attachment anchor onto a world-space anchor. */
-export declare interface PrimitivePlacementOptions {
-    /** Shape-local source frame or a named primitive anchor such as bottom. */
-    readonly source: Anchor3 | string;
-    /** World-space target frame in millimetres. */
-    readonly target: Anchor3;
-    /** Align outward directions face-to-face or in parallel. Defaults to opposed. */
-    readonly alignment?: "opposed" | "same";
-    /** Finite separation along the target direction in millimetres. Defaults to zero. */
-    readonly gap?: number;
-    /** Finite additional roll around the attached direction in degrees. Defaults to zero. */
-    readonly spinDegrees?: number;
-    /** Explicit numeric comparison overrides for anchor normalization. */
-    readonly tolerance?: GeometryToleranceOptions;
-}
-
-/**
- * Named baseline fit policies for calibrated FDM-style printed threads.
- */
-export declare type PrintableThreadFit = "tight" | "normal" | "loose";
-
-/**
- * Explicit radial and axial allowances for a mating printed thread pair.
- *
- * Male and female radial values are applied independently, so their sum is the
- * assembled radial clearance. Values are millimetres and intentionally do not
- * encode printer, material, or process calibration.
- */
-export declare interface PrintableThreadFitPolicy {
-    /** Nominal axial backlash available between opposing flanks. */
-    readonly axialBacklash: number;
-    /** Radial increase applied to an internal thread envelope. */
-    readonly femaleRadialOutset: number;
-    /** Radial reduction applied to an external thread envelope. */
-    readonly maleRadialInset: number;
-}
-
-/** An explicit component/contour/span topology, before shared family sampling. */
-export declare interface Profile {
-    /** Ordered components with explicit contour identities. */
-    readonly components: readonly ProfileComponent2[];
-}
-
-/** One component and its explicitly identified holes. */
-export declare interface ProfileComponent2 {
-    /** Stable canonical lowercase identity; unique within the containing topology or output. */
-    readonly id: string;
-    /** Counterclockwise outer contour. */
-    readonly outer: ProfileContour2;
-    /** Clockwise hole contours belonging to this component. */
-    readonly holes: readonly ProfileContour2[];
-}
-
-/** Ordered, closed spans. Outer winding is CCW and hole winding is CW. */
-export declare interface ProfileContour2 {
-    /** Stable canonical lowercase identity; unique within the containing topology or output. */
-    readonly id: string;
-    /** Ordered identified spans; the last endpoint meets the first start. */
-    readonly spans: readonly ProfileSpan2[];
-}
-
-/** A deliberately sampled, inward-only corner profile with exact polyline geometry. */
-export declare interface ProfiledEdgeTreatment {
-    /** Selects an explicit corner profile; no analytic curve is inferred from its samples. */
-    readonly kind: "profile";
-    /**
-     * Millimetre setbacks on adjoining surfaces, from [positive, 0] to [0, positive].
-     * First coordinates decrease and second coordinates increase. Cylinder/extrusion ends use
-     * cap inset first, side setback second; planar corners use incoming then outgoing edges.
-     */
-    readonly profile: readonly Vec2[];
-}
-
-/** An identified line, circular arc, or cubic Bézier between corresponding landmarks. */
-export declare type ProfileSpan2 = {
-    /** Stable canonical lowercase identity; unique within the containing topology or output. */
-    readonly id: string;
-    /** Optional exact span interval count; the family uses the largest requested count. */
-    readonly segments?: number;
-    /** Optional span-local physical sampling over the family's resolution; exact intervals take precedence. */
-    readonly resolution?: GeometryResolution;
-} & ({
-    /** Selects a straight span. */
-    readonly kind: "line";
-    /** Start point in millimetres. */
-    readonly start: Vec2;
-    /** End point in millimetres. */
-    readonly end: Vec2;
-} | {
-    /** Selects the geometric curve or span family. */
-    readonly kind: "arc";
-    /** Center point in millimetres. */
-    readonly center: Vec2;
-    /** Circular radius in millimetres. */
-    readonly radius: number;
-    /** Initial counterclockwise angle in degrees. */
-    readonly startDegrees: number;
-    /** Signed counterclockwise angular sweep in degrees. */
-    readonly sweepDegrees: number;
-} | {
-    /** Selects a cubic Bézier span with the same coordinates as CubicBezierCurve2. */
-    readonly kind: "cubic";
-    /** Start point in millimetres. */
-    readonly start: Vec2;
-    /** First control point in millimetres. */
-    readonly control1: Vec2;
-    /** Second control point in millimetres. */
-    readonly control2: Vec2;
-    /** End point in millimetres. */
-    readonly end: Vec2;
-});
-
-/**
- * Repeats one solid about an axis.
- *
- * @example Six copies around Z
- * ```ts
- * const pin = cylinder({ height: 6, radius: 2 }).translate([12, 0, 0]);
- * radialPattern(pin, { count: 6, axis: [0, 0, 1], angleDegrees: 60 });
- * ```
- */
-export declare function radialPattern(source: PatternSource, options: RadialPatternOptions): readonly Solid[];
-
-/**
- * Options for repeating one solid around an axis through a center point.
- */
-export declare interface RadialPatternOptions {
-    /** Number of solids to return, including the original. */
-    readonly count: number;
-    /** Axis of the right-handed rotation. Its magnitude is ignored. */
-    readonly axis: Vec3;
-    /** Signed rotation from one copy to the next, in degrees. */
-    readonly angleDegrees: number;
-    /** Rotation center in world coordinates. Defaults to the origin. */
-    readonly center?: Vec3;
-}
-
-/**
- * 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;
-}
-
-/** Copies intersections along the finite directed origin-to-endpoint segment. */
-export declare function rayCast(solid: Solid, origin: Vec3, endpoint: Vec3): readonly SolidRayHit[];
-
-/**
- * Filled rectangular section with uniform or independently treated corners.
- *
- * @example Round the corners
- * ```ts
- * rectangle({ size: [30, 20], treatment: { kind: "round", radius: 3 } });
- * ```
- */
-export declare function rectangle(options: RectangleOptions): Section;
-
-/** 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
-];
-
-/**
- * Shared rectangle dimensions, origin and uniform or per-corner treatment.
- */
-export declare interface RectangleLoopOptions {
-    /** Positive uniform size or explicit XY extents in millimetres. */
-    readonly size: number | Vec2;
-    /** Center on XY; otherwise the minimum corner is the origin. Defaults to true. */
-    readonly center?: boolean;
-    /** Uniform treatment or four corner treatments. Exact round segments describe a complete circle and must divide by four. */
-    readonly treatment?: EdgeTreatment | RectangleCornerTreatments;
-    /** Explicit sampling ceiling for the complete output profile. */
-    readonly limits?: Partial<GeometrySamplingLimits>;
-}
-
-/**
- * Rectangle dimensions, placement and uniform or per-corner treatment.
- */
-export declare interface RectangleOptions extends RectangleLoopOptions, PrimitivePlacement {
-}
-
-/** A two-dimensional region represented by disjoint filled polygons. */
-export declare type Region2 = readonly Polygon2[];
-
-/** Clipper2 join styles accepted by robust region offsets. */
-export declare type RegionOffsetJoin = "miter" | "round" | "square";
-
-/** Options controlling robust Clipper2 region offsets. */
-export declare interface RegionOffsetOptions {
-    /** Number of segments per full circle for round joins. */
-    readonly circularSegments?: number;
-    /** Corner treatment; defaults to `round`. */
-    readonly join?: RegionOffsetJoin;
-    /** Maximum miter extension in offset-distance multiples; at least two. */
-    readonly miterLimit?: number;
-    /** Operation-level physical tessellation policy over the active model-wide policy. */
-    readonly resolution?: GeometryResolution;
-}
-
-/**
- * Regular polygon with a vertex on +X.
- *
- * @example Hexagonal section
- * ```ts
- * regularPolygon({ radius: 10, sides: 6, sizing: "face" });
- * ```
- */
-export declare function regularPolygon(options: RegularPolygonOptions): Section;
-
-/**
- * Regular polygon dimensions, radial convention and degree rotation.
- */
-export declare type RegularPolygonOptions = RadialSizingOptions & PrimitivePlacement & {
-    /** 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 rotationDegrees?: number;
-};
-
-/**
- * Revolves explicit corresponding radial/Z contours around +Z, with caps for partial sweeps.
- * Filled Sections use `section.revolve(options)`.
- *
- * @example Revolve
- * ```ts
- * import { matchProfiles, revolve } from "@metamesh/modeling";
- * import { rectangleProfile } from "@metamesh/modeling/geometry";
- *
- * // Contour coordinates are [radius, Z].
- * const [profile] = matchProfiles([rectangleProfile({ size: [4, 16], center: false })]);
- * revolve(profile!, { revolveDegrees: 270 });
- * ```
- */
-export declare function revolve(shape: CorrespondingProfile, options?: RevolveOptions): Solid;
-
-/**
- * Circumferential sampling and degree sweep shared by pure and filled revolution.
- */
-export declare interface RevolveOptions extends CircularPrimitiveOptions {
-    /**
-     * Positive angular sweep no greater than 360 degrees; partial revolutions have end caps.
-     * Segment counts describe a complete circle and scale to this angular span. Native filled
-     * revolutions require at least three sweep intervals: adaptive sampling refines to that floor,
-     * while exact counts that imply fewer intervals reject. Pure revolveMesh supports one interval.
-     */
-    readonly revolveDegrees?: number;
-    /** Explicit output and sampling allocation ceilings. */
-    readonly limits?: Partial<ModelingLimits>;
-}
-
-/**
- * A circular edge or corner roundover with explicit physical sampling.
- */
-export declare interface RoundedEdgeTreatment extends CircularPrimitiveOptions {
-    /** Selects circular corners or spherical all-edge roundovers. */
-    readonly kind: "round";
-    /** Radius in millimetres. Rectangles permit zero through half their smallest dimension; boxes require a positive smaller radius. */
-    readonly radius: number;
-}
-
-/**
- * Immutable deferred filled XY section recipe belonging to exactly one model session.
- * Methods run during synchronous generation and preserve their receiver.
- * Distances use millimetres; rotations are counterclockwise degrees about the origin.
- * Construction uses the session resolution unless the operation supplies explicit options.
- *
- * @example Extrude an outline with a border
- * ```ts
- * const body = rectangle({ size: [20, 12] })
- *   .subtract([rectangle({ size: [16, 8] })])
- *   .offset(0.5)
- *   .extrude({ height: 4 });
- * ```
- */
-export declare interface Section {
-    /** Compile-time ownership brand for a same-session section. */
-    readonly [sectionBrand]: "Section";
-    /** Translates XY coordinates in millimetres. */
-    translate(this: Section, offset: Vec2): Section;
-    /** Rotates counterclockwise about the origin by a scalar angle in degrees. */
-    rotate(this: Section, degrees: number): Section;
-    /**
-     * Nonsingular scaling about the origin.
-     */
-    scale(this: Section, factors: number | Vec2): Section;
-    /** Reflection across an origin line/plane. */
-    mirror(this: Section, normal: Vec2): Section;
-    /** Row-major affine transform preserving dimensionality. */
-    transform(this: Section, matrix: Transform2): Section;
-    /** Native section difference; an empty cutter array preserves the source. */
-    subtract(this: Section, cutters: readonly Section[]): Section;
-    /**
-     * Simplifies filled 2D contours using an explicit positive millimetre tolerance.
-     *
-     * Useful for dense imported outlines before extrusion. This changes the outline rather
-     * than selecting a lower rendering quality; fine features may be removed.
-     */
-    simplify(this: Section, tolerance: number): Section;
-    /**
-     * Returns a new same-session handle with copied named anchors; existing names may be replaced.
-     */
-    withAnchors(this: Section, anchors: Readonly<Record<string, Anchor3>>): Section;
-    /**
-     * Native millimetre offset preserving holes.
-     */
-    offset(this: Section, distance: number, options?: RegionOffsetOptions): Section;
-    /**
-     * 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.
-     */
-    revolve(this: Section, options?: RevolveOptions): Solid;
-    /**
-     * Sweeps this filled section using the selected frame policy and degree twist.
-     */
-    sweep(this: Section, path: readonly Vec3[], options?: SweepOptions): Solid;
-}
-
-declare const sectionBrand: unique symbol;
-
-/**
- * Creates a native filled section without an intermediate Region2 conversion.
- */
-export declare function sectionFromContours(contours: readonly Loop2[], options?: SectionFromContoursOptions): Section;
-
-/**
- * Filled-contour resolution. Closing vertices are implicit.
- */
-export declare interface SectionFromContoursOptions {
-    /** Nonzero or even-odd filled-contour rule; defaults to nonzero. */
-    readonly fillRule?: "nonzero" | "evenodd";
-}
-
-/** Planar convex hull inputs are finite XY points or same-session filled sections. */
-export declare type SectionHullOptions = {
-    /** At least three finite millimetre XY points spanning positive area. */
-    readonly points: readonly Vec2[];
-    /** Point input excludes section input. */
-    readonly sections?: never;
-} | {
-    /** One through 1000 same-session sections to include in the convex hull. */
-    readonly sections: readonly Section[];
-    /** Section input excludes point input. */
-    readonly points?: never;
-};
-
-/**
- * Immutable native filled section facts in millimetres and square millimetres.
- * Repeated inspections of the same native shape share these facts within one revision.
- */
-export declare interface SectionInspection {
-    /** Whether this filled section has no area or boundary. */
-    readonly isEmpty: boolean;
-    /** Filled section area in square millimetres. */
-    readonly area: number;
-    /** Number of extracted outer and hole contours. */
-    readonly contours: number;
-    /** Inclusive maximum coordinates in millimetres. */
-    readonly max: Vec2;
-    /** Inclusive minimum coordinates in millimetres. */
-    readonly min: Vec2;
-    /** Number of disconnected filled section components. */
-    readonly parts: number;
-    /** Number of native section vertices. */
-    readonly vertices: number;
-}
-
-/** A cubic corner transition with zero curvature at its straight tangent joins. */
-export declare interface SmoothEdgeTreatment {
-    /** Selects continuous-curvature cubic rounding, rather than a circular radius. */
-    readonly kind: "smooth";
-    /** Positive tangent setbacks, equal or [first, second], in millimetres. */
-    readonly distance: number | readonly [first: number, second: number];
-    /** Exact cubic interval count, positive; overrides physical sampling. */
-    readonly segments?: number;
-    /** Physical chord/edge-length sampling; circularSegments does not describe a cubic. */
-    readonly resolution?: GeometryResolution;
-    /** Explicit sampling ceilings, bounded by the host policy. */
-    readonly limits?: Partial<GeometrySamplingLimits>;
-}
-
-/**
- * Immutable deferred solid recipe belonging to exactly one model session.
- * Methods run during synchronous generation, preserve their receiver, and use millimetres and degrees.
- * A no-op may reuse the receiver; final part placement belongs in `part` options.
- *
- * @example Shape a body with a through bore
- * ```ts
- * const body = box({ size: [30, 20, 6] })
- *   .subtract([cylinder({ height: 8, radius: 3 })])
- *   .rotate([0, 0, 45]);
- * ```
- */
-export declare interface Solid {
-    /** Compile-time ownership brand for a same-session solid. */
-    readonly [solidBrand]: "Solid";
-    /**
-     * Translates XYZ coordinates in millimetres.
-     */
-    translate(this: Solid, offset: Vec3): Solid;
-    /**
-     * Rotates about the origin using XYZ Euler angles in degrees.
-     */
-    rotate(this: Solid, degrees: Vec3): Solid;
-    /**
-     * Nonsingular scaling about the origin.
-     */
-    scale(this: Solid, factors: number | Vec3): Solid;
-    /**
-     * Reflection across an origin line/plane.
-     */
-    mirror(this: Solid, normal: Vec3): Solid;
-    /** Row-major affine transform preserving dimensionality. */
-    transform(this: Solid, matrix: Transform3): Solid;
-    /**
-     * Robust difference; an empty cutter array preserves the source.
-     */
-    subtract(this: Solid, cutters: readonly Solid[]): Solid;
-    /**
-     * Simplifies a solid using an explicit positive millimetre tolerance.
-     *
-     * Removes redundant vertices while keeping surfaces within the greater of this tolerance
-     * 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 same-session handle 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.
-     */
-    attach(this: Solid, source: Anchor3 | string, target: Anchor3, options?: AttachOptions): Solid;
-    /** Replaces native tolerance on an immutable copy; zero selects the kernel minimum. */
-    setTolerance(this: Solid, tolerance: number): Solid;
-    /** Projects this solid into a filled XY section. */
-    projectSection(this: Solid): Section;
-    /** Takes a filled horizontal slice at Z millimetres. */
-    sliceSection(this: Solid, z: number): Section;
-}
-
-declare const solidBrand: unique symbol;
-
-/**
- * Imports a bounded closed indexed mesh.
- *
- * @example Mesh import
- * ```ts
- * import { solidFromMesh } from "@metamesh/modeling";
- * import { extrudeMesh, rectangleLoop } from "@metamesh/modeling/geometry";
- *
- * const mesh = extrudeMesh(rectangleLoop({ size: [20, 12] }), { height: 6 });
- * solidFromMesh(mesh);
- * ```
- */
-export declare function solidFromMesh(mesh: TriangleMesh | ImmutableTriangleMesh): Solid;
-
-/**
- * Immutable solid bounds, emptiness, component count, volume, surface area and native tolerance.
- * Repeated inspections of the same native shape share these facts within one revision.
- */
-export declare interface SolidInspection {
-    /** Whether this native solid contains no material. */
-    readonly isEmpty: boolean;
-    /** Inclusive maximum coordinates in millimetres. */
-    readonly max: Vec3;
-    /** Inclusive minimum coordinates in millimetres. */
-    readonly min: Vec3;
-    /** Number of connected surface shells; inward cavity shells count separately. */
-    readonly parts: number;
-    /** Enclosed native solid volume in cubic millimetres. */
-    readonly volume: number;
-    /** Total native surface area in square millimetres. */
-    readonly surfaceArea: number;
-    /** Effective native geometric tolerance in millimetres. */
-    readonly tolerance: number;
-}
-
-/** Copied surface intersection from a finite directed segment. Distance is in millimetres. */
-export declare interface SolidRayHit {
-    /** Copied numeric native face identity. */
-    readonly faceId: number;
-    /** Distance from the ray origin in millimetres. */
-    readonly distance: number;
-    /** Intersection position in millimetres. */
-    readonly position: Vec3;
-    /** Outward unit surface normal at the intersection. */
-    readonly normal: Vec3;
-}
-
-/**
- * Origin-centered sphere.
- *
- * @example Sphere
- * ```ts
- * sphere({ diameter: 20 });
- * ```
- */
-export declare function sphere(options: SphereOptions): Solid;
-
-/**
- * Exactly one radius or diameter, placement, and tessellation for an origin-centered sphere.
- */
-export declare type SphereOptions = CircularPrimitiveOptions & PrimitivePlacement & ({
-    /** Positive radius in millimetres; mutually exclusive with diameter. */
-    readonly radius: number;
-    /** Full diameter is unavailable when radius is supplied. */
-    readonly diameter?: never;
-} | {
-    /** Positive full diameter in millimetres; mutually exclusive with radius. */
-    readonly diameter: number;
-    /** Radius is unavailable when diameter is supplied. */
-    readonly radius?: never;
-});
-
-/**
- * Splits a solid into [inside the cutter, outside the cutter].
- *
- * The first result is the intersection; the second is the subtraction. The cutter itself
- * is not returned. Either result may be empty or contain multiple disconnected components.
- *
- * @example Keep the plug and the surrounding body
- * ```ts
- * const body = box({ size: [30, 20, 8] });
- * const cutter = cylinder({ height: 10, diameter: 8 });
- * const [plug, remainder] = split(body, cutter);
- * // Move the plug beside the body to show both results.
- * union([plug.translate([0, -20, 0]), remainder]);
- * ```
- */
-export declare function split(solid: Solid, cutter: Solid): readonly [Solid, Solid];
-
-/**
- * Splits a solid into [positive-normal side, negative side] at a world-space plane.
- *
- * The nonzero normal is normalized; offset is the signed distance from the origin in
- * millimetres, defaulting to zero. Both cut faces are closed. Select either tuple result
- * to retain one side; either result may be empty.
- *
- * @example Separate two halves at X = 0
- * ```ts
- * const body = box({ size: [30, 20, 8] });
- * const [right, left] = splitByPlane(body, { normal: [1, 0, 0] });
- * // The gap is only for display; the cut itself removes no material.
- * union([right.translate([4, 0, 0]), left.translate([-4, 0, 0])]);
- * ```
- *
- * @example Keep only the positive half
- * ```ts
- * const [right] = splitByPlane(box({ size: [30, 20, 8] }), { normal: [1, 0, 0] });
- * right;
- * ```
- */
-export declare function splitByPlane(solid: Solid, plane: PlaneOptions): readonly [Solid, Solid];
-
-/** Square profile with equal crest and root widths. */
-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 });
- * ```
- */
-export declare function star(options: StarOptions): Section;
-
-/**
- * Alternating outer and inner vertices, centered on the XY origin.
- */
-export declare interface StarOptions extends PrimitivePlacement {
-    /** Explicit sampling ceilings, bounded by the host policy. */
-    readonly limits?: Partial<GeometrySamplingLimits>;
-    /** Positive outer vertex radius in millimetres. */
-    readonly outerRadius: number;
-    /** Positive inner vertex radius, smaller than the outer radius. */
-    readonly innerRadius: number;
-    /** Integer outer point count from three through 50000. */
-    readonly points: number;
-    /** Initial counterclockwise rotation in degrees; defaults to zero. */
-    readonly rotationDegrees?: number;
-}
-
-/** Placement of painted SVG geometry after SVG Y-axis inversion. */
-export declare type SvgOrigin = "center" | "document";
-
-/**
- * Imports bounded filled SVG path data.
- *
- * @example Fill an SVG path in millimetres
- * ```ts
- * svgPathSection("M0 0H20V12H0Z", { origin: "center", scale: 1 });
- * ```
- */
-export declare function svgPathSection(path: string, options?: SvgPathSectionOptions): Section;
-
-/** Bounded filled SVG path sampling. Path scale converts user units to millimetres. */
-export declare interface SvgPathSectionOptions {
-    /** Local allocation ceilings may only lower the configured engine policy. */
-    readonly limits?: Partial<GeometrySamplingLimits>;
-    /** Nonzero or even-odd filled-contour rule; defaults to nonzero. */
-    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. */
-    readonly origin?: SvgOrigin;
-    /** Positive uniform factor converting SVG user units to millimetres; defaults to one. */
-    readonly scale?: number;
-}
-
-/**
- * Imports bounded painted SVG document geometry.
- *
- * @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" },
- * );
- * ```
- */
-export declare function svgSection(svg: string, options?: SvgSectionOptions): Section;
-
-/**
- * Bounded SVG document sampling. Center origin uses the final painted bounds.
- */
-export declare interface SvgSectionOptions {
-    /** Local allocation ceilings may only lower the configured engine policy. */
-    readonly limits?: Partial<GeometrySamplingLimits>;
-    /** Exact circular tessellation count overriding physical sampling. */
-    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. */
-    readonly origin?: SvgOrigin;
-}
-
-/**
- * Sweeps explicit corresponding contours using the selected frame policy.
- * Filled Sections use `section.sweep(path, options)`.
- *
- * @example Sweep
- * ```ts
- * import { matchProfiles, sweep } from "@metamesh/modeling";
- * import { rectangleProfile } from "@metamesh/modeling/geometry";
- *
- * const [profile] = matchProfiles([rectangleProfile({ size: [6, 3] })]);
- * sweep(profile!, [[0, 0, 0], [0, 0, 15], [10, 0, 25]], {
- *   orientation: { kind: "transport", initialNormal: [0, 1, 0] },
- * });
- * ```
- */
-export declare function sweep(shape: CorrespondingProfile, path: readonly Vec3[], options?: SweepOptions): Solid;
-
-/**
- * Controls shared by pure mesh construction and filled modeling sweeps.
- */
-export declare interface SweepOptions {
-    /** Join the path's last station to its first. Open paths retain watertight end caps. */
-    readonly closed?: boolean;
-    /** Explicit output and sampling allocation ceilings. */
-    readonly limits?: Partial<ModelingLimits>;
-    /** Explicit frame policy; default transport minimizes rotations, initially projecting +X then +Y then +Z. */
-    readonly orientation?: SweepOrientation;
-    /** Physical sampling of nonzero twist; inserted stations retain authored station controls. */
-    readonly resolution?: GeometryResolution;
-    /** Total additional profile rotation in degrees, with progression selected by twistBy. */
-    readonly twistDegrees?: number;
-    /** Twist advances by physical path length (default), or normalized authored station position, including a closed seam gap. */
-    readonly twistBy?: "length" | "stations";
-    /** Positive uniform/XY scale, or one XY pair per path station. Defaults to one. */
-    readonly scale?: number | Vec2 | readonly Vec2[];
-    /** Corresponding point-index advance at a rotationally equivalent closed seam. */
-    readonly seamProfileOffset?: number;
-}
-
-/**
- * Explicit profile-X frame policy; all normals are directed, and selected singular policies reject.
- */
-export declare type SweepOrientation = {
-    /** Minimizes frame rotation by parallel transport. */
-    readonly kind: "transport";
-    /** Initial profile +X guide, projected perpendicular to the first tangent. */
-    readonly initialNormal?: Vec3;
-} | {
-    /** Projects one fixed world-space normal at every path station. */
-    readonly kind: "fixed-normal";
-    /** Directed profile +X guide; must not be parallel to any local tangent. */
-    readonly normal: Vec3;
-} | {
-    /** Uses an explicitly directed normal callback at each original normalized station. */
-    readonly kind: "guide";
-    /** Finite profile +X guide callback, evaluated once per original path station. */
-    readonly normal: PathNormalGuide;
-} | {
-    /** Uses sampled curvature normals; zero-curvature stations reject. */
-    readonly kind: "frenet";
-};
-
-/**
- * Consumes a previously prepared layout; never shapes or fetches a font.
- *
- * @example Use a prepared text layout
- * ```ts
- * // Prepare the exact font and layout before entering build.
- * function labelSection(layout: VectorTextLayout) {
- *   return textSection(layout);
- * }
- * ```
- */
-export declare function textSection(layout: VectorTextLayout, options?: TextSectionOptions): Section;
-
-/**
- * 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>;
-    /** Local physical sampling policy; exact interval counts take precedence. */
-    readonly resolution?: GeometryResolution;
-}
-
-/** End bevel controls shared by threaded rods and cutters. */
-declare interface ThreadBevelOptions {
-    /** Apply a 45-degree bevel at Z=0. */
-    readonly bevelBottom?: boolean;
-    /**
-     * Axial bevel extent in millimetres. Active blunt ends default to one sixth of the compensated
-     * male minor radius or female major radius; other ends default to the profile depth.
-     */
-    readonly bevelSize?: number;
-    /** Apply a 45-degree bevel at Z=length. */
-    readonly bevelTop?: boolean;
-}
-
-/**
- * Compensated threaded nut.
- *
- * @example Threaded nut
- * ```ts
- * import { threadedNut } from "@metamesh/modeling";
- * import { createThreadProfile } from "@metamesh/modeling/geometry";
- *
- * const profile = createThreadProfile({ kind: "triangular", pitch: 1.75 });
- * threadedNut({ nominalMajorDiameter: 12, thickness: 8, width: 20, shape: "hex", profile, fit: "normal" });
- * ```
- */
-export declare function threadedNut(options: ThreadedNutOptions): Solid;
-
-/** Nut-edge bevel selection. */
-export declare type ThreadedNutBevel = "automatic" | "both" | "inside" | "none" | "outside";
-
-/**
- * Options for a compensated nut with an internal thread.
- */
-export declare interface ThreadedNutOptions extends Omit<InternalThreadCutterOptions, "bevelBottom" | "bevelSize" | "bevelTop" | "length"> {
-    /** Nut body bevel selection. Default: `automatic`. */
-    readonly bevel?: ThreadedNutBevel;
-    /** Optional physical policy for a round body, independent of the thread's matched facet grid. */
-    readonly bodyResolution?: GeometryResolution;
-    /** 45-degree body chamfer extent. Default: `min(profile.depth, thickness/4)`. */
-    readonly chamferSize?: number;
-    /** Leave the bottom outside edge flat for build-plate adhesion. Default: `false`. */
-    readonly flushBuildPlateBottom?: boolean;
-    /** Nut body shape. */
-    readonly shape: ThreadedNutShape;
-    /** Nut thickness along +Z in millimetres. */
-    readonly thickness: number;
-    /** Across-flats width for hex/square or diameter for round, in millimetres. */
-    readonly width: number;
-}
-
-/** Allocation-free body, cutter, and end-face facts resolved for a threaded nut. */
-export declare interface ThreadedNutPreflight {
-    /** Polygon segment count used by the nut body. */
-    readonly bodySegments: number;
-    /** Shared 45-degree chamfer size applied to the selected body and cutter edges. */
-    readonly chamferSize: number;
-    /** Maximum compensated cutter radius at either requested face. */
-    readonly cutterFaceRadius: number;
-    /** Minimum nut-body inradius across the requested top and bottom faces. */
-    readonly minimumBodyFaceInradius: number;
-    /** Smallest radial wall left between the body and cutter at either requested face. */
-    readonly minimumFaceWall: number;
-    /** Conservative allocation facts for the exact extended internal-thread cutter mesh. */
-    readonly thread: HelicalThreadSolidMeshPreflight;
-    /** Start-aligned circular facet count used by the compensated thread cutter. */
-    readonly threadCircularSegments: number;
-}
-
-/**
- * Supported printable nut body shapes.
- */
-export declare type ThreadedNutShape = "hex" | "round" | "square";
-
-/**
- * Compensated external threaded rod.
- *
- * @example Threaded rod
- * ```ts
- * import { threadedRod } from "@metamesh/modeling";
- * import { createThreadProfile } from "@metamesh/modeling/geometry";
- *
- * const profile = createThreadProfile({ 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<HelicalThreadRidgeMeshOptions, "majorDiameter">, ThreadBevelOptions {
-    /** Printable fit or caller-calibrated allowances. Default: `normal`. */
-    readonly fit?: PrintableThreadFit | PrintableThreadFitPolicy;
-    /** Nominal major diameter before male compensation. */
-    readonly nominalMajorDiameter: number;
-}
-
-/** End shape of a generated helical ridge. */
-export declare type ThreadEndStyle = "blunt" | "standard" | "tapered";
-
-/** Axial end controls for a generated ridge. */
-export declare interface ThreadEndTreatmentOptions {
-    /**
-     * Ridge shape at the lower working boundary. `blunt` ends at full profile height, `standard`
-     * clips the periodic profile at the face, and `tapered` ramps out from the minor envelope.
-     * @defaultValue `"blunt"`
-     */
-    readonly bottom?: ThreadEndStyle;
-    /**
-     * Non-negative unthreaded envelope length reserved at each non-standard end, in millimetres.
-     * Active blunt bevels may raise this reservation to the effective bevel size.
-     * @defaultValue `0`
-     */
-    readonly endLength?: number;
-    /**
-     * Radial envelope toward which a blunt lead-in collapses.
-     * @defaultValue `"minor"`
-     */
-    readonly leadInEnvelope?: ThreadLeadInEnvelope;
-    /**
-     * Physical circumferential lead-in length in millimetres.
-     * @defaultValue The profile depth.
-     */
-    readonly leadInLength?: number;
-    /**
-     * Cross-section scaling curve used by blunt ends. `cut` switches abruptly to the full profile.
-     * @defaultValue `"cut"`
-     */
-    readonly leadInShape?: ThreadLeadInShape;
-    /**
-     * Ridge shape at the upper working boundary. `blunt` ends at full profile height, `standard`
-     * clips the periodic profile at the face, and `tapered` ramps into the minor envelope.
-     * @defaultValue `"blunt"`
-     */
-    readonly top?: ThreadEndStyle;
-}
-
-/**
- * Direction in which a conventional helical thread advances around +Z.
- */
-export declare type ThreadHandedness = "left" | "right";
-
-/** Radial envelope toward which a blunt lead-in collapses. */
-export declare type ThreadLeadInEnvelope = "major" | "minor";
-
-/** BOSL2-compatible cross-section scaling curve for a blunt thread lead-in. */
-export declare type ThreadLeadInShape = "cut" | "linear" | "smooth" | "sqrt";
-
-/**
- * A validated immutable periodic thread profile in `[axial, radial]` millimetres.
- */
-export declare interface ThreadProfile {
-    /** Axial width of the flat at the major envelope. */
-    readonly crestFlatWidth: number;
-    /** Radial distance from the major envelope to the root. */
-    readonly depth: number;
-    /** Profile family that produced this validated profile. */
-    readonly kind: ThreadProfileSpec["kind"];
-    /** Adjacent axial thread spacing in millimetres. */
-    readonly pitch: number;
-    /** Immutable open `[axial, radial]` path spanning one pitch. */
-    readonly points: readonly Vec2[];
-    /** Axial width of the flat at the minor envelope. */
-    readonly rootFlatWidth: number;
-}
-
-/** Fields shared by all thread profile specifications. */
-declare interface ThreadProfileBaseSpec {
-    /** Adjacent axial thread spacing in millimetres. */
-    readonly pitch: number;
-    /** Optional numerical tolerance overrides. */
-    readonly tolerance?: GeometryToleranceOptions;
-}
-
-/**
- * Supported built-in and caller-defined thread profiles.
- */
-declare type ThreadProfileSpec = AcmeThreadProfileSpec | ButtressThreadProfileSpec | CustomThreadProfileSpec | SquareThreadProfileSpec | TrapezoidalThreadProfileSpec | TriangularThreadProfileSpec;
-
-/** Helical ridge mesh construction. */
-export declare function threadRidge(options: ThreadRidgeOptions): Solid;
-
-/** Parameters for a helical ridge before solid construction. */
-export declare type ThreadRidgeOptions = HelicalThreadRidgeMeshOptions;
-
-/** Explicit copied topology inspection; not needed for section operations. */
-export declare function toRegion(section: Section): Region2;
-
-/**
- * Torus around +Z.
- *
- * @example Torus
- * ```ts
- * torus({ majorRadius: 12, minorRadius: 3 });
- * ```
- */
-export declare function torus(options: TorusOptions): Solid;
-
-/**
- * Dimensions and independent ring/profile tessellation for a torus around the Z axis.
- */
-export declare interface TorusOptions extends PrimitivePlacement {
-    /** Explicit sampling ceilings, bounded by the host policy. */
-    readonly limits?: Partial<GeometrySamplingLimits>;
-    /** Radius from the Z axis to the profile center, in millimetres; greater than `minorRadius`. */
-    readonly majorRadius: number;
-    /** Exact segment count around the Z axis; omitted uses adaptive resolution. */
-    readonly majorSegments?: number;
-    /** Radius of the swept circular profile in millimetres. */
-    readonly minorRadius: number;
-    /** Exact segment count around the swept profile; omitted uses adaptive resolution. */
-    readonly minorSegments?: number;
-    /** Operation-level physical tessellation policy over the active model-wide policy. */
-    readonly resolution?: GeometryResolution;
-}
-
-/** Copies a handle to manufacturing mesh buffers. */
-export declare function toTriangleMesh(solid: Solid): TriangleMesh;
-
-/** Row-major affine XY matrix. Translation occupies m02/m12; final row is [0, 0, 1]. */
-export declare type Transform2 = readonly [
-m00: number,
-m01: number,
-m02: number,
-m10: number,
-m11: number,
-m12: number,
-m20: number,
-m21: number,
-m22: number
-];
-
-/**
- * A row-major affine 4x4 matrix applied to column vectors.
- *
- * Translation occupies indices 3, 7, and 11. The final row must be
- * `[0, 0, 0, 1]` within the active geometry tolerance.
- */
-export declare type Transform3 = readonly [
-m00: number,
-m01: number,
-m02: number,
-m03: number,
-m10: number,
-m11: number,
-m12: number,
-m13: number,
-m20: number,
-m21: number,
-m22: number,
-m23: number,
-m30: number,
-m31: number,
-m32: number,
-m33: number
-];
-
-/** Trapezoidal thread profile with a configurable included angle. */
-declare interface TrapezoidalThreadProfileSpec extends ThreadProfileBaseSpec {
-    /** Selects the trapezoidal profile family. */
-    readonly kind: "trapezoidal";
-    /**
-     * Radial depth in millimetres.
-     * @defaultValue `pitch / 2`
-     */
-    readonly depth?: number;
-    /**
-     * Included flank angle in degrees. Use `90` for printable 45-degree slopes.
-     * @defaultValue `30`
-     */
-    readonly threadAngle?: number;
-}
-
-/**
- * A topology-preserving indexed triangle mesh with XYZ vertex positions.
- */
-export declare interface TriangleMesh {
-    /** Three unsigned vertex indices per triangle. */
-    readonly indices: Uint32Array;
-    /** Flat XYZ coordinates, three finite values per vertex. */
-    readonly positions: Float32Array;
-}
-
-/**
- * Measurements and optional edge-connected topology from one validated mesh traversal.
- */
-export declare interface TriangleMeshAnalysis extends TriangleMeshMeasurements {
-    /** Number of referenced edge-connected components when `includeTopology` is requested. */
-    readonly connectedComponentCount?: number;
-    /** Number of distinct indexed undirected edges when `includeTopology` is requested. */
-    readonly edgeCount?: number;
-}
-
-/**
- * Geometric measurements derived from a validated, non-empty triangle mesh.
- */
-export declare interface TriangleMeshMeasurements {
-    /** Axis-aligned bounds. */
-    readonly bounds: MeshBounds;
-    /** Signed enclosed volume; positive values correspond to outward winding. */
-    readonly signedVolume: number;
-    /** Sum of all triangle areas in squared model units. */
-    readonly surfaceArea: number;
-    /** Number of indexed triangles. */
-    readonly triangleCount: number;
-    /** Number of distinct entries in the position buffer. */
-    readonly vertexCount: number;
-}
-
-/**
- * ISO/UTS-like 60-degree truncated triangular profile.
- */
-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.
- *
- * @example Tube
- * ```ts
- * tube({ height: 20, outerRadius: 10, innerRadius: 6 });
- * ```
- */
-export declare function tube(options: TubeOptions): Solid;
-
-/**
- * Dimensions, placement, and tessellation for a hollow Z-axis tube.
- */
-export declare interface TubeOptions extends CircularPrimitiveOptions, PrimitivePlacement {
-    /**
-     * Centers the tube on the Z origin when `true`; otherwise its bottom is at `Z = 0`.
-     * @defaultValue `true`
-     */
-    readonly center?: boolean;
-    /** Total height along Z in millimetres. */
-    readonly height: number;
-    /** Positive inner radius in millimetres. */
-    readonly innerRadius: number;
-    /** Outer radius in millimetres; greater than {@link TubeOptions.innerRadius}. */
-    readonly outerRadius: number;
-}
-
-/**
- * Robust union.
- *
- * @example Union
- * ```ts
- * const block = box({ size: 20 });
- * const cap = sphere({ radius: 10 }).translate([0, 0, 10]);
- * union([block, cap]);
- * ```
- */
-export declare function union(solids: readonly Solid[]): Solid;
-
-/** Native filled section union; dimensions cannot be mixed. */
-export declare function union(sections: readonly Section[]): Section;
-
-/** A two-dimensional Cartesian vector or point. */
-export declare type Vec2 = readonly [x: number, y: number];
-
-/** A three-dimensional Cartesian vector or point. */
-export declare type Vec3 = readonly [x: number, y: number, z: number];
-
-/** Exact curve bounds in millimetres; positive Y points upward. */
-export declare interface VectorTextBounds {
-    /** Minimum X and Y of visible outlines, including accents, descenders, and overhangs. */
-    readonly min: readonly [number, number];
-    /** Maximum X and Y of visible outlines. */
-    readonly max: readonly [number, number];
-}
-
-/**
- * Immutable vector layout with no browser, font parser, or kernel ownership.
- */
-export declare interface VectorTextLayout {
-    /** Nonzero-filled path data in millimetres, positive Y upward; empty for text with no ink. */
-    readonly paths: readonly string[];
-    /** Exact measurements of these paths and their logical text layout. */
-    readonly metrics: VectorTextMetrics;
-}
-
-/** Text measurements from the same immutable layout that supplies geometry and SVG outlines. */
-export declare interface VectorTextMetrics {
-    /** Visible curve bounds after alignment, or null when the text has no ink. */
-    readonly bounds: VectorTextBounds | null;
-    /** Unaligned logical advance and negative baseline displacement in mm; arcs retain [arc length, 0]. */
-    readonly advance: readonly [number, number];
-    /** Maximum logical line advance in millimetres, including spaces; arc length on circular baselines. */
-    readonly logicalWidth: number;
-    /** Selected font's ascender distance above a baseline in millimetres, independent of the text. */
-    readonly ascent: number;
-    /** Selected font's descender distance below a baseline in millimetres, a non-negative value. */
-    readonly descent: number;
-    /** Actual distance between baselines in millimetres. */
-    readonly lineHeight: number;
-    /** Number of lines, including empty and trailing lines; empty text occupies one line. */
-    readonly lineCount: number;
-}
-
-export { }
+/** Imported modeling operations and opaque host-owned contracts. @packageDocumentation */
+
+/** ACME 29-degree included-angle profile. */
+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;
+}
+
+/**
+ * Reads a copied, immutable named anchor from this exact active generation.
+ *
+ * @example Read the top datum
+ * ```ts
+ * const plate = box({ size: [30, 20, 6] });
+ * anchor(plate, "top"); // position [0, 0, 3], direction [0, 0, 1]
+ * ```
+ */
+export declare function anchor(shape: Solid | Section, name: string): Anchor3;
+
+/**
+ * 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: Vector3;
+  /** World-space attachment position. */
+  readonly position: Vector3;
+  /** Roll guide projected into the plane perpendicular to `direction`. */
+  readonly up: Vector3;
+}
+
+/**
+ * Degree-based anchor attachment controls for a scoped solid.
+ */
+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 millimetres. */
+  readonly gap?: number;
+  /** Additional right-handed roll about the attached direction, in degrees. */
+  readonly spinDegrees?: number;
+  /** Optional numeric comparison overrides. */
+  readonly tolerance?: GeometryToleranceOptions;
+}
+
+/** Axis-aligned bounds in two-dimensional model space. */
+export declare interface Bounds2 {
+  /** Inclusive maximum X/Y coordinates. */
+  readonly max: Vector2;
+  /** Inclusive minimum X/Y coordinates. */
+  readonly min: Vector2;
+}
+
+/** Axis-aligned bounds in three-dimensional model space. */
+export declare interface Bounds3 {
+  /** Inclusive maximum X/Y/Z coordinates. */
+  readonly max: Vector3;
+  /** Inclusive minimum X/Y/Z coordinates. */
+  readonly min: Vector3;
+}
+
+/**
+ * Axis-aligned box with uniform or disjoint named edge/group treatments.
+ *
+ * @example Rounded box
+ * ```ts
+ * box({ size: [30, 20, 8], treatment: { kind: "round", radius: 2 } });
+ * ```
+ */
+export declare function box(options: BoxOptions): Solid;
+
+/** Box edges use +Z top, +Y front and +X right; vertical names list front/back first. */
+export declare type BoxEdge =
+  | "top-front"
+  | "top-back"
+  | "top-left"
+  | "top-right"
+  | "bottom-front"
+  | "bottom-back"
+  | "bottom-left"
+  | "bottom-right"
+  | "front-left"
+  | "front-right"
+  | "back-left"
+  | "back-right";
+
+/** Named individual edges or top/bottom rims and all four vertical edges. */
+export declare type BoxEdgeSelection = BoxEdge | "top" | "bottom" | "vertical";
+
+/** Independent treatments for disjoint named edge selections; overlapping selections fail. */
+export declare type BoxEdgeTreatments = Readonly<
+  Partial<Record<BoxEdgeSelection, EdgeTreatment>>
+>;
+
+/**
+ * Dimensions, placement, and uniform or independently selected finishing for an axis-aligned box.
+ */
+export declare interface BoxOptions extends PrimitivePlacement {
+  /** Explicit sampling ceilings for edge treatments, bounded by the host policy. */
+  readonly limits?: Partial<GeometrySamplingLimits>;
+  /**
+   * Centers the box on the XYZ origin when `true`; otherwise its minimum corner is at the origin.
+   * @defaultValue `true`
+   */
+  readonly center?: boolean;
+  /** Positive uniform size or explicit `[X, Y, Z]` extents in millimetres. */
+  readonly size: number | Vector3;
+  /** Uniform treatment or independent disjoint nominal edge/group treatments. */
+  readonly treatment?: EdgeTreatment | BoxEdgeTreatments;
+}
+
+/** Axial side carrying the near-normal pressure flank of a buttress thread. */
+declare type ButtressPressureFlankSide = "negative" | "positive";
+
+/** Asymmetric printable buttress profile with 7/45-degree flanks. */
+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" });
+ * ```
+ */
+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; mutually exclusive with diameter. */
+        readonly radius: number;
+        /** Full diameter is unavailable when radius is supplied. */
+        readonly diameter?: never;
+      }
+    | {
+        /** Positive full diameter in millimetres; mutually exclusive with radius. */
+        readonly diameter: number;
+        /** Radius is unavailable when diameter is supplied. */
+        readonly radius?: never;
+      }
+  );
+
+/**
+ * Circular dimensions with exactly one nominal radius or diameter.
+ */
+export declare type CircleOptions = CircleContourOptions & PrimitivePlacement;
+
+/**
+ * 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;
+}
+
+/**
+ * Separates a solid's disconnected surface shells into same-session solid handles.
+ *
+ * For solids without enclosed cavities, these shells are the disconnected material islands.
+ * Enclosed cavities produce separate inward shells with negative signed volume; these cannot
+ * be finalized alone as manufacturing parts. This does not cut connected geometry.
+ *
+ * @example Move disconnected pieces independently
+ * ```ts
+ * const islands = union([box({ size: 8 }), box({ size: 8 }).translate([12, 0, 0])]);
+ * const pieces = components(islands);
+ * // Component order is unspecified; the index only sets a display height here.
+ * union(pieces.map((piece, index) => piece.translate([0, 0, index * 6])));
+ * ```
+ */
+export declare function components(solid: Solid): readonly Solid[];
+
+/** Separates filled 2D islands into sections, retaining each island's holes; empty gives []. */
+export declare function components(section: Section): readonly Section[];
+
+/** Combines disjoint components without resolving overlap. */
+export declare function compose(solids: readonly Solid[]): Solid;
+
+/** 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. */
+  (): 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 closed two-dimensional boundary whose first point is not repeated at the end.
+ *
+ * Polygon exteriors are counter-clockwise and holes are clockwise. Algorithms
+ * may reject duplicate adjacent points or fewer than three effective vertices.
+ */
+export declare type Contour = readonly Vector2[];
+
+/** 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;
+};
+
+/** Caller-defined periodic axial/radial profile in millimetres. */
+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 Vector2[];
+}
+
+/**
+ * +Z cylinder or frustum. Face sizing compensates polygon faceting.
+ *
+ * @example Cylinder
+ * ```ts
+ * cylinder({ height: 20, radius: 10 });
+ * ```
+ *
+ * @example Cone
+ * ```ts
+ * cylinder({ height: 20, radius: [10, 0] });
+ * ```
+ */
+export declare function cylinder(options: CylinderOptions): Solid;
+
+/**
+ * Dimensions, placement, independent end finishing, and tessellation for a Z-axis cylinder or frustum.
+ */
+export declare type CylinderOptions = CircularPrimitiveOptions &
+  RadialSizingOptions &
+  PrimitivePlacement & {
+    /**
+     * Centers the solid on the Z origin when `true`; otherwise its bottom is at `Z = 0`.
+     * @defaultValue `true`
+     */
+    readonly center?: boolean;
+    /** Independent end treatments; first setback is cap inset and second follows the sloped side. */
+    readonly ends?: EndTreatments;
+    /** Total height along +Z in millimetres. */
+    readonly height: number;
+  } & (
+    | {
+        /** Positive uniform radius or nonnegative `[bottom, top]` radii in millimetres; one must be positive. */
+        readonly radius: number | readonly [bottom: number, top: number];
+        /** Full diameter is unavailable when radius is supplied. */
+        readonly diameter?: never;
+      }
+    | {
+        /** Positive uniform diameter or nonnegative `[bottom, top]` diameters in millimetres; one must be positive. */
+        readonly diameter: number | readonly [bottom: number, top: number];
+        /** Radius is unavailable when diameter is supplied. */
+        readonly radius?: never;
+      }
+  );
+
+/** Typed parameter association for an assertion or warning. */
+export declare interface DiagnosticOptions<P> {
+  /** Existing top-level parameter key. */
+  readonly parameterId?: Extract<keyof P, string> | undefined;
+}
+
+/**
+ * Measures the minimum separation between two nonempty solids in millimetres.
+ *
+ * Uses actual geometry, not bounding-box separation or distance between object origins.
+ * Contact or overlapping material returns zero, including one solid inside another.
+ * The kernel's search range is managed internally; the result is not capped at a caller limit.
+ * Empty, expired or foreign-build handles reject. Results follow native numeric precision.
+ *
+ * @example Measure the gap between two blocks
+ * ```ts
+ * const left = box({ size: 10 });
+ * const right = box({ size: 10 }).translate([13, 0, 0]);
+ * const gap = distance(left, right); // 3 mm
+ * ```
+ */
+export declare function distance(solid: Solid, other: Solid): number;
+
+/**
+ * Uniform finishing vocabulary shared by applicable solid edges and profile corners.
+ */
+export declare type EdgeTreatment =
+  | ChamferedEdgeTreatment
+  | RoundedEdgeTreatment
+  | SmoothEdgeTreatment
+  | ProfiledEdgeTreatment;
+
+/**
+ * Centered elliptical section.
+ *
+ * @example Ellipse by full dimensions
+ * ```ts
+ * ellipse({ size: [30, 20] });
+ * ```
+ */
+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: Vector2;
+        /** Full XY extents are unavailable when radius is supplied. */
+        readonly size?: never;
+      }
+    | {
+        /** Positive full XY extents in millimetres; mutually exclusive with radius. */
+        readonly size: Vector2;
+        /** XY radii are unavailable when size is supplied. */
+        readonly radius?: never;
+      }
+  );
+
+/**
+ * Ellipse dimensions in local XY, with exactly one radii or full-size tuple.
+ */
+export declare type EllipseOptions = EllipseContourOptions & PrimitivePlacement;
+
+/**
+ * Independent inward finishing on primitive or straight convex extrusion ends.
+ * Zero amounts leave the end untreated, including when all ends are disabled.
+ */
+export declare interface EndTreatments {
+  /** Bottom cap and adjoining side; omitted leaves the end untreated. */
+  readonly bottom?: EdgeTreatment;
+  /** Top cap and adjoining side; omitted leaves the end untreated. */
+  readonly top?: EdgeTreatment;
+}
+
+/**
+ * Extrudes explicit corresponding contours along +Z with degree twist and top scaling.
+ * Filled Sections use `section.extrude(options)`.
+ *
+ * @example Extrude
+ * ```ts
+ * import { extrude, matchProfiles } from "@metamesh/modeling";
+ * import { rectangleProfile } from "@metamesh/modeling/geometry";
+ *
+ * const [profile] = matchProfiles([rectangleProfile({ size: [30, 20] })]);
+ * extrude(profile!, { height: 8 });
+ * ```
+ */
+export declare function extrude(
+  shape: CorrespondingProfile,
+  options: ExtrudeOptions,
+): Solid;
+
+/**
+ * Dimensions and sampling shared by native and pure +Z extrusion.
+ */
+export declare interface ExtrudeOptions extends ExtrusionSamplingOptions {
+  /** Positive extrusion height in millimetres. */
+  readonly height: number;
+  /** Center the extrusion on Z; otherwise its bottom is at zero. Defaults to false. */
+  readonly center?: boolean;
+  /** Independent inward end treatments on straight convex single-contour extrusions. */
+  readonly ends?: EndTreatments;
+}
+
+/** Shared sampling controls for a twisted or scaled linear extrusion. */
+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 | Vector2;
+  /** Finite rotation of the top profile about +Z, in degrees; defaults to zero. */
+  readonly twistDegrees?: number;
+}
+
+/** Finalized manufacturing snapshot. Its arrays are independent of all native values. */
+export declare interface FinalizedModel {
+  /** Ordered finalized manufacturing parts with copied transferable arrays. */
+  readonly parts: readonly FinalizedPart[];
+  /** Axis-aligned XYZ bounds in millimetres. */
+  readonly bounds: Bounds3;
+  /** Aggregate counts, unique backing storage, volume, and execution timings. */
+  readonly stats: {
+    /** Aggregate position-buffer vertex count. */
+    readonly vertices: number;
+    /** Aggregate indexed triangle count. */
+    readonly triangles: number;
+    /** Signed enclosed volume of all selected parts in cubic millimetres. */
+    readonly volumeMm3: number;
+    /** Unique transferable backing-buffer bytes, counted once across all parts. */
+    readonly bytes: number;
+    /** Synchronous callback duration in milliseconds. */
+    readonly buildMs: number;
+    /** Manufacturing validation and buffer finalization duration in milliseconds. */
+    readonly finalizationMs: number;
+    /** Total callback and finalization duration in milliseconds. */
+    readonly generationMs: number;
+  };
+}
+
+/** Copied manufacturing part with facts computed from the finalized mesh. */
+export declare interface FinalizedPart extends TriangleMesh {
+  /** Stable canonical lowercase identity; unique within the containing topology or output. */
+  readonly id: string;
+  /** Optional six-digit hex RGB display color. */
+  readonly color?: string;
+  /** Fresh validated facts for these exact finalized buffers. */
+  readonly measurements: TriangleMeshAnalysis;
+}
+
+/** A right-handed orthonormal coordinate frame expressed in world coordinates. */
+export declare interface Frame3 {
+  /** World-space origin of the local frame. */
+  readonly origin: Vector3;
+  /** Unit vector defining the local +X axis. */
+  readonly xAxis: Vector3;
+  /** Unit vector defining the local +Y axis. */
+  readonly yAxis: Vector3;
+  /** Unit vector defining the local +Z axis. */
+  readonly zAxis: Vector3;
+}
+
+/** Imports explicit region topology once. */
+export declare function fromRegion(region: Region): Section;
+
+/**
+ * Defines a typed model without executing it. Use `computed` only for work worth reusing.
+ *
+ * @example A simple model
+ * ```ts
+ * const model = generate<{ height: number }>(({ params, part, assert }) => {
+ *   assert(params.height > 0, "Height must be positive.");
+ *   return part("body", box({ size: [10, 10, params.height] }));
+ * });
+ * ```
+ */
+export declare function generate<P, S = Record<never, never>>(
+  callback: GenerateCallback<P, S>,
+): ModelProgram<P, S>;
+
+/** Pure synchronous callback returning one declared part or an array; caches are optional. */
+export declare type GenerateCallback<P, S = Record<never, never>> = (
+  context: GenerateContext<P, S>,
+) => GeneratedPart | readonly GeneratedPart[];
+
+/** The sole synchronous authoring context, supplied independently of Studio. */
+export declare interface GenerateContext<P, S = Record<never, never>> {
+  /** Frozen ordinary parameter values; synchronous top-level reads are tracked. */
+  readonly params: Readonly<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>;
+  /** Declares a semantic part with identity placement, or explicit placement and appearance. */
+  readonly part: {
+    (id: string, geometry: ComputedValue<PartGeometry>): GeneratedPart;
+    (id: string, options: PartOptions): GeneratedPart;
+  };
+  /** Immediately aborts on false; geometry observations in the condition run first. */
+  readonly assert: {
+    (condition: false, message: string, options?: DiagnosticOptions<P>): never;
+    (condition: boolean, message: string, options?: DiagnosticOptions<P>): void;
+  };
+  /** Records a nonblocking issue; call only in the outer generation callback. */
+  readonly warn: (message: string, options?: DiagnosticOptions<P>) => void;
+}
+
+/** One declared output part. Construct with the context's `part` helper. */
+export declare interface GeneratedPart extends PartOptions {
+  /** Unique canonical lowercase hyphen-separated identity, at most 64 characters. */
+  readonly id: string;
+}
+
+/** Structured user-facing issue associated with the attempted revision. */
+export declare interface GenerationDiagnostic {
+  /** An error aborts generation; a warning allows generation to continue. */
+  readonly severity: "error" | "warning";
+  /** Human-readable corrective guidance. */
+  readonly message: string;
+  /** Optional control identity, validated against the supplied parameters. */
+  readonly parameterId?: string | undefined;
+}
+
+/** A user-correctable assertion failure. Successful computation 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[];
+  /** Captures immutable diagnostics; unexpected author errors retain their original type. */
+  constructor(diagnostics: readonly GenerationDiagnostic[]);
+}
+
+/**
+ * Tessellation policy for sampled geometry measured in millimetres.
+ */
+export declare interface GeometryResolution {
+  /** Optional exact full-circle segment count, of at least three, bounded by the selected circular ceiling. */
+  readonly circularSegments?: number;
+  /** Maximum radial chord error in millimetres; defaults to 0.05. */
+  readonly maxChordError?: number;
+  /** Optional maximum sampled edge length in millimetres. */
+  readonly maxSegmentLength?: number;
+  /** Upper safety bound for a full circle; defaults to the selected maxCircularSegments (512 by default). */
+  readonly maximumSegments?: number;
+  /** Lower full-circle segment count; defaults to 16 or a lower selected circular ceiling. */
+  readonly minimumSegments?: number;
+}
+
+/** Explicit allocation ceilings for pure sampling and host-owned modeling operations. */
+export declare interface GeometrySamplingLimits {
+  /** Maximum points in one sampled path or placement/frame result. */
+  readonly maxPathPoints: number;
+  /** Maximum aggregate points in one sampled profile or Section. */
+  readonly maxProfilePoints: number;
+  /** Maximum points in one profile swept along a path. */
+  readonly maxSweepProfilePoints: number;
+  /** Maximum segments around one complete circle. */
+  readonly maxCircularSegments: number;
+}
+
+/** Optional overrides for MetaMesh's geometry comparison policy. */
+export declare interface GeometryToleranceOptions {
+  /** Absolute distance floor in model units. Must be finite and greater than zero. */
+  readonly absolute?: number;
+  /** Angular comparison threshold in radians. Must be finite and greater than zero. */
+  readonly angular?: number;
+  /** Dimensionless scale multiplier. Must be finite and non-negative. */
+  readonly relative?: number;
+}
+
+/**
+ * XY or XYZ copies, optionally centered or placed in an explicit frame.
+ *
+ * @example Centered XY grid
+ * ```ts
+ * gridPattern(box({ size: 4 }), { count: [3, 2], spacing: [10, 10], center: true });
+ * ```
+ */
+export declare function gridPattern(
+  source: PatternSource,
+  options: GridPatternOptions,
+): readonly Solid[];
+
+/** Repeats a filled Section on a grid; placements must preserve its XY plane. */
+export declare function gridPattern(
+  source: PatternSource<Section>,
+  options: GridPatternOptions,
+): readonly Section[];
+
+/**
+ * XY or XYZ grid with X varying fastest. The first item starts at the local origin.
+ */
+export declare type GridPatternOptions = {
+  /** 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: Vector2;
+      /** Signed millimetres between adjacent copies on X and Y. */
+      readonly spacing: Vector2;
+    }
+  | {
+      /** Positive integer counts on X, Y and Z. */
+      readonly count: Vector3;
+      /** Signed millimetres between adjacent copies on X, Y and Z. */
+      readonly spacing: Vector3;
+    }
+);
+
+/**
+ * Closed rectilinear top above a flat base, with uniform or explicit XY coordinates.
+ * Samples each grid height once; center-error triangulation also samples each cell centre.
+ *
+ * @example Heightfield
+ * ```ts
+ * heightfield({
+ *   size: [30, 20], segments: [24, 16],
+ *   height: ([x, y]) => 3 + Math.cos(x / 5) * Math.cos(y / 5),
+ * });
+ * ```
+ */
+export declare function heightfield(options: HeightfieldOptions): Solid;
+
+/**
+ * A closed rectilinear heightfield above a flat base, with uniform or explicit XY samples in millimetres.
+ *
+ * Uniform sampling requires positive `size: [width, depth]` and positive integer `segments: [x, y]`.
+ * Optional `origin` sets the lower-left XY corner; omitting it centres the footprint on XY.
+ * Alternatively, supply `coordinates: { x, y }` with at least two strictly increasing finite
+ * absolute samples per axis, distinct in Float32. This infers the footprint and interval counts;
+ * `size`, `segments`, and `origin` cannot be combined with explicit coordinates.
+ */
+export declare type HeightfieldOptions = {
+  /** Absolute top Z at the supplied XY point. Every sample must be above baseZ. */
+  readonly height: (point: Vector2) => number;
+  /** Flat bottom Z. Defaults to zero. */
+  readonly baseZ?: number;
+  /**
+   * Top-cell diagonal policy. Defaults to fixed (lower-left to upper-right).
+   * min-edge selects the shorter 3D diagonal; center-error selects the diagonal whose endpoint
+   * average is closest to one extra height sample at the physical cell centre. Ties use fixed.
+   * All policies retain two triangles per cell; neither estimates error elsewhere in the cell.
+   */
+  readonly triangulation?: "fixed" | "min-edge" | "center-error";
+} & (
+  | {
+      /** Positive XY footprint for uniform sampling. */
+      readonly size: Vector2;
+      /** Exact positive integer X/Y interval counts. */
+      readonly segments: readonly [x: number, y: number];
+      /** Lower-left footprint XY. Omitted centers the footprint on XY. */
+      readonly origin?: Vector2;
+      /** Explicit coordinates cannot be combined with uniform sampling. */
+      readonly coordinates?: never;
+    }
+  | {
+      /**
+       * Absolute XY coordinates, each with at least two strictly increasing finite values that
+       * remain distinct in Float32. Uneven spacing permits caller-owned local refinement.
+       */
+      readonly coordinates: {
+        /** Absolute X samples in ascending order. */
+        readonly x: readonly number[];
+        /** Absolute Y samples in ascending order. */
+        readonly y: readonly number[];
+      };
+      /** The footprint is inferred from explicit coordinates. */
+      readonly size?: never;
+      /** Interval counts are inferred from explicit coordinates. */
+      readonly segments?: never;
+      /** Explicit coordinates already include their origin. */
+      readonly origin?: never;
+    }
+);
+
+/** Runtime-neutral options for the dedicated helical ridge mesher. */
+export declare interface HelicalThreadRidgeMeshOptions {
+  /**
+   * Optional bottom/top ridge-end treatments. Standalone ridges honor the requested boundaries;
+   * BOSL2-style non-cut lead-in scaling is available on complete thread solids.
+   */
+  readonly ends?: ThreadEndTreatmentOptions;
+  /** Helix direction. Default: `right`. */
+  readonly handedness?: ThreadHandedness;
+  /** Total threaded axial length in millimetres. */
+  readonly length: number;
+  /** Explicit output and circular allocation ceilings. */
+  readonly limits?: Partial<ModelingLimits>;
+  /** Nominal major diameter before any caller-owned fit compensation. */
+  readonly majorDiameter: number;
+  /** Angular offset of the first start in degrees. Default: `0`. */
+  readonly phaseDegrees?: number;
+  /** Validated periodic profile repeated around the shaft. */
+  readonly profile: ThreadProfile;
+  /** Optional circular-resolution policy. */
+  readonly resolution?: GeometryResolution;
+  /** Number of evenly phased starts. Default: `1`. */
+  readonly starts?: number;
+  /** Optional numerical tolerance overrides. */
+  readonly tolerance?: GeometryToleranceOptions;
+}
+
+/** Conservative allocation facts resolved before constructing a direct thread solid mesh. */
+export declare interface HelicalThreadSolidMeshPreflight {
+  /** Uniform axial intervals required only by a requested physical segment-length limit. */
+  readonly axialIntervals: number;
+  /** Start-aligned full-circle segment count used by the surface mesh. */
+  readonly circularSegments: number;
+  /** Conservative surface-row count across profile breaks, ends, and bevel stations. */
+  readonly estimatedRows: number;
+  /** Conservative triangle count used by the selected output allocation policy. */
+  readonly estimatedTriangles: number;
+}
+
+/**
+ * Convex hull of points or solids.
+ *
+ * @example Hull
+ * ```ts
+ * const left = sphere({ radius: 5 }).translate([-10, 0, 0]);
+ * const right = sphere({ radius: 5 }).translate([10, 0, 0]);
+ * hull({ solids: [left, right] });
+ * ```
+ */
+export declare function hull(options: HullOptions): Solid;
+
+/** Convex filled XY hull of finite points or same-session sections. */
+export declare function hull(options: SectionHullOptions): Section;
+
+/** Hull inputs are either finite points or same-session solids. */
+export declare type HullOptions =
+  | {
+      /** Finite millimetre XYZ points to include in the convex hull. */
+      readonly points: readonly Vector3[];
+      /** Point input excludes solid input. */
+      readonly solids?: never;
+    }
+  | {
+      /** Same-build solids to include in the convex hull. */
+      readonly solids: readonly Solid[];
+      /** Solid input excludes point input. */
+      readonly points?: never;
+    };
+
+/** Owned immutable numeric data. Use copy() to obtain mutable storage for numerical work. */
+export declare interface ImmutableBuffer<T extends NumericArray> {
+  /** Opaque element-storage brand; construct buffers with immutableBuffer(). */
+  readonly [immutableBufferBrand]: T;
+  /** Number of numeric elements, independent of their byte width. */
+  readonly length: number;
+  /** Reads an integer offset; negative offsets count from the end. Invalid offsets return undefined. */
+  at(this: void, index: number): number | undefined;
+  /** Returns a fresh mutable array of the original numeric type; never exposes cached storage. */
+  copy(this: void): T;
+}
+
+/**
+ * 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 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;
+
+/**
+ * Copies mesh buffers into immutable data; geometric validation still occurs when modeling or finalizing.
+ * @example
+ * ```ts
+ * import { generate, immutableMesh } from "@metamesh/modeling";
+ * import { heightfieldMesh } from "@metamesh/modeling/geometry";
+ * const model = generate(({ computed, part }) => {
+ *   const surface = computed("surface", () => immutableMesh(heightfieldMesh({
+ *     size: [10, 10], segments: [8, 8], height: () => 2,
+ *   })));
+ *   return [part("surface", surface)];
+ * });
+ * ```
+ */
+export declare function immutableMesh(
+  mesh: TriangleMesh,
+): ImmutableTriangleMesh;
+
+/** Immutable local XYZ positions and triangle indices, suitable for a computed value or part. */
+export declare interface ImmutableTriangleMesh {
+  /** Packed XYZ coordinates in millimetres. */
+  readonly positions: ImmutableBuffer<Float32Array>;
+  /** Zero-based vertex indices, three per triangle. */
+  readonly indices: ImmutableBuffer<Uint32Array>;
+}
+
+/** Bounded positive-inside implicit field constructor. */
+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. */
+  readonly field: (point: Vector3) => number;
+  /** Axis-aligned XYZ bounds in millimetres. */
+  readonly bounds: Bounds3;
+  /** Positive sampling edge length in millimetres. */
+  readonly edgeLength: number;
+  /** Field isosurface value; defaults to zero. */
+  readonly level?: number;
+  /** Positive native geometric tolerance in millimetres; omitted uses interpolated grid crossings. */
+  readonly tolerance?: number;
+}
+
+/**
+ * Copies lightweight section measurements.
+ *
+ * @example Check filled area
+ * ```ts
+ * const facts = inspectSection(rectangle({ size: [20, 10] }));
+ * facts.area; // 200 mm²
+ * ```
+ */
+export declare function inspectSection(section: Section): SectionInspection;
+
+/**
+ * Reads immutable native facts once per solid; temporary components are owned by the build.
+ *
+ * @example Check dimensions and volume
+ * ```ts
+ * const facts = inspectSolid(box({ size: [30, 20, 6] }));
+ * facts.volume; // 3600 mm³
+ * ```
+ */
+export declare function inspectSolid(solid: Solid): SolidInspection;
+
+/**
+ * Compensated internal threaded cutter.
+ *
+ * @example Internal thread
+ * ```ts
+ * import { cylinder, internalThreadCutter } from "@metamesh/modeling";
+ * import { createThreadProfile } from "@metamesh/modeling/geometry";
+ * const profile = createThreadProfile({ 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]);
+ * ```
+ */
+export declare function internalThreadCutter(
+  options: InternalThreadCutterOptions,
+): Solid;
+
+/** Options for a compensated internal-thread subtraction tool along +Z. */
+export declare interface InternalThreadCutterOptions
+  extends
+    Omit<HelicalThreadRidgeMeshOptions, "majorDiameter">,
+    ThreadBevelOptions {
+  /** Printable fit or caller-calibrated allowances. Default: `normal`. */
+  readonly fit?: PrintableThreadFit | PrintableThreadFitPolicy;
+  /** Nominal major diameter before female compensation and faceting correction. */
+  readonly nominalMajorDiameter: number;
+}
+
+/**
+ * Robust intersection.
+ *
+ * @example Intersect
+ * ```ts
+ * intersect([box({ size: 20 }), sphere({ radius: 12 })]);
+ * ```
+ */
+export declare function intersect(solids: readonly Solid[]): Solid;
+
+/** Native filled section intersection; dimensions cannot be mixed. */
+export declare function intersect(sections: readonly Section[]): Section;
+
+/**
+ * Checks whether a same-session solid or filled section contains no geometry.
+ *
+ * Accepts a 3D Solid or 2D Section handle, not a finalized model or raw triangle mesh.
+ * Useful after a Boolean operation whose inputs may not overlap; no mesh is extracted.
+ *
+ * @example Check a missed intersection
+ * ```ts
+ * const body = box({ size: 10 });
+ * const distant = box({ size: 10 }).translate([30, 0, 0]);
+ * const empty = intersect([body, distant]);
+ * const missed = isEmpty(empty); // true
+ * ```
+ */
+export declare function isEmpty(shape: Solid | Section): boolean;
+
+/**
+ * Repeats one solid along a normalized direction.
+ *
+ * @example Three copies along X
+ * ```ts
+ * linearPattern(box({ size: 4 }), { count: 3, spacing: 10 });
+ * ```
+ */
+export declare function linearPattern(
+  source: PatternSource,
+  options: LinearPatternOptions,
+): readonly Solid[];
+
+/** Repeats a filled Section; every placement must preserve its XY plane. */
+export declare function linearPattern(
+  source: PatternSource<Section>,
+  options: LinearPatternOptions,
+): readonly Section[];
+
+/**
+ * Equal linear intervals determined by exactly two of count, spacing and total length.
+ */
+export declare type LinearPatternOptions = {
+  /** Direction of repetition; magnitude is ignored. Defaults to +X. */
+  readonly direction?: Vector3;
+} & (
+  | {
+      /** 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 primitive Sections at z heights or frames; arbitrary Sections and loops require an explicit correspondence method.
+ *
+ * @example Loft
+ * ```ts
+ * loft([
+ *   { profile: circle({ diameter: 16 }), z: 0 },
+ *   { profile: rectangle({ size: [30, 20], treatment: { kind: "round", radius: 3 } }), z: 30 },
+ * ]);
+ * ```
+ */
+export declare function loft(
+  stations: readonly LoftStation[],
+  options?: LoftOptions,
+): Solid;
+
+/** Lofts explicit corresponding contours, including holes and collapsed logical slots. */
+export declare function loft(
+  stations: readonly CorrespondingProfileStation[],
+  options?: LoftOptions,
+): Solid;
+
+/**
+ * Associates ordered loft contours without inferring component identities or repairing topology.
+ *
+ * - `direct` preserves seams and subdivides edges to a common count without dropping vertices.
+ * - `reindex` applies direct subdivision, then selects the next contour's cyclic phase with the
+ *   least total world-space connection length.
+ * - `fast-distance` preserves supplied seams and minimizes connection length over ordered closed
+ *   vertex associations, repeating vertices for triangular fans.
+ * - `distance` runs the same ordered optimization over every cyclic phase of the next contour.
+ *
+ * Components and holes are paired by their existing order. Use identified profiles when semantic
+ * correspondence must remain authoritative.
+ */
+export declare type LoftCorrespondence =
+  "direct" | "reindex" | "fast-distance" | "distance";
+
+/**
+ * Shared controls for native and pure lofts. Point data and arbitrary Sections require explicit correspondence.
+ */
+export declare interface LoftOptions {
+  /** One method or one per consecutive station gap. Omitted preserves known landmarks, including circle/ellipse-to-rectangle corners, or maps other unlike primitive seams directly. */
+  readonly correspondence?: LoftCorrespondence | readonly LoftCorrespondence[];
+  /** Extra points follow edge length or distribute equally across existing segments. Defaults to perimeter for direct/reindex, or segments when any distance method is selected; distance methods require segments. */
+  readonly distribution?: "perimeter" | "segments";
+  /** Positive integer point-density multiplier, uniformly or per input profile. Original vertices are retained. Defaults to one. */
+  readonly refine?: number | readonly number[];
+  /** Nonnegative count of world-linearly interpolated profiles, uniformly or per gap. Defaults to zero. */
+  readonly slices?: number | readonly number[];
+  /** Physical curve policy for retained primitives, and maximum edge length for point data. Exact primitive curve counts take precedence. */
+  readonly resolution?: GeometryResolution;
+  /** Explicit output and sampling budgets; native operations may only lower host ceilings. */
+  readonly limits?: Partial<ModelingLimits>;
+}
+
+/**
+ * A horizontal XY station height, or an explicit right-handed spatial frame, never both.
+ */
+export declare type LoftPlacement =
+  | {
+      /** Horizontal XY station height in millimetres. */
+      readonly z: number;
+      /** Excluded when a horizontal height is supplied. */
+      readonly frame?: never;
+    }
+  | {
+      /** Right-handed orthonormal station frame in world coordinates. */
+      readonly frame: Frame3;
+      /** Excluded when an explicit spatial frame is supplied. */
+      readonly z?: never;
+    };
+
+/**
+ * A Section or point loop at an explicit height or frame.
+ */
+export declare type LoftStation = LoftPlacement & {
+  /** Same-build filled Section or ordered XY boundary point data. */
+  readonly profile: Section | Contour;
+};
+
+/** Explicit family matching on a shared physical span grid using session or operation resolution. */
+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>;
+}
+
+/** Three-dimensional Minkowski sum. */
+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, S = Record<never, never>> {
+  /** Exact generation protocol discriminator. */
+  readonly kind: "metamesh-model";
+  /** Typed synchronous declaration callback. */
+  readonly generate: GenerateCallback<P, S>;
+}
+
+/** Numeric storage supported by immutable generation buffers. */
+export declare type NumericArray =
+  Float32Array | Float64Array | Uint32Array | Uint8Array | Int32Array;
+
+/** Manufacturing geometry; filled sections are intermediate construction values. */
+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>;
+  /** XYZ translation in millimetres, applied after rotation; defaults to zero. */
+  readonly position?: ComputedValue<Vector3>;
+  /** Fixed global X, Y, Z rotations in degrees; defaults to zero. */
+  readonly rotation?: ComputedValue<Vector3>;
+  /** Optional six-digit hexadecimal semantic part color. */
+  readonly color?: string;
+}
+
+/**
+ * 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: Vector3,
+  index: number,
+) => Vector3;
+
+/**
+ * Physical arc-length copies along a sampled path, with optional tangent orientation.
+ *
+ * @example Copies along a bent path
+ * ```ts
+ * pathPattern(box({ size: 4 }), [[0, 0, 0], [20, 0, 0], [20, 20, 0]], { count: 5 });
+ * ```
+ */
+export declare function pathPattern(
+  source: PatternSource,
+  path: readonly Vector3[],
+  options: PathPatternOptions,
+): readonly Solid[];
+
+/**
+ * Repeats a filled Section along a sampled XY path at Z=0. Fixed orientation preserves XY;
+ * tangent orientation maps +Z to the tangent and rejects when that leaves the plane.
+ */
+export declare function pathPattern(
+  source: PatternSource<Section>,
+  path: readonly Vector3[],
+  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;
+  /** Include the closing edge without duplicating the seam; defaults to false. */
+  readonly closed?: boolean;
+  /** Preserve the source orientation, or align its +Z to the path tangent; defaults to fixed. */
+  readonly orientation?: "fixed" | "tangent";
+}
+
+/**
+ * One same-session shape, or a synchronous factory called once per copy in index order.
+ */
+export declare type PatternSource<T extends Solid | Section = Solid> =
+  T | ((index: number) => T);
+
+/** A world-space cutting plane, retaining the half-space in the normal's direction. */
+export declare interface PlaneOptions {
+  /** Finite nonzero plane normal; magnitude does not affect the plane. */
+  readonly normal: Vector3;
+  /** Signed millimetre distance from the origin along the unit normal. Defaults to zero. */
+  readonly offset?: number;
+}
+
+/**
+ * One bounded two-dimensional polygon.
+ *
+ * `outer` is counter-clockwise and each hole is clockwise. Boundary arrays omit
+ * their duplicated closing point. Holes must lie inside `outer` and must not
+ * intersect each other or the exterior.
+ */
+export declare interface Polygon {
+  /** 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;
+}
+
+/**
+ * Fills one closed millimetre XY outline, explicit outer/hole topology, or compound contours.
+ * Closing edges are implicit. Compound contours use nonzero fill unless selected otherwise.
+ * Explicit topology must be simple and disjoint; compound winding may resolve overlaps.
+ *
+ * @example Extrude a triangular plate
+ * ```ts
+ * polygon([[0, 0], [20, 0], [10, 12]]).extrude({ height: 3 });
+ * ```
+ */
+export declare function polygon(input: Contour | PolygonOptions): Section;
+
+/** Explicit polygon topology or compound contours; all closing edges are implicit. */
+export declare type PolygonOptions =
+  | {
+      /** One simple exterior boundary, normalized to counterclockwise winding. */
+      readonly outer: Contour;
+      /** Disjoint simple holes inside the exterior; normalized to clockwise winding. */
+      readonly holes?: readonly Contour[];
+      /** Explicit topology excludes compound contours. */
+      readonly contours?: never;
+      /** Explicit topology determines fill without a winding rule. */
+      readonly fillRule?: never;
+    }
+  | {
+      /** Compound boundaries; may overlap or contain holes according to the fill rule. */
+      readonly contours: readonly Contour[];
+      /** Winding interpretation; defaults to nonzero. An empty list creates an empty Section. */
+      readonly fillRule?: "nonzero" | "evenodd";
+      /** Compound contours exclude explicit topology. */
+      readonly outer?: never;
+      /** Compound contours determine their own holes. */
+      readonly holes?: never;
+    };
+
+/** Allocation-free internal-thread facts. */
+export declare function preflightInternalThreadCutter(
+  options: InternalThreadCutterOptions,
+): HelicalThreadSolidMeshPreflight;
+
+/** Allocation-free nut/cutter facts. */
+export declare function preflightThreadedNut(
+  options: ThreadedNutOptions,
+): ThreadedNutPreflight;
+
+/** Allocation-free external-thread facts. */
+export declare function preflightThreadedRod(
+  options: ThreadedRodOptions,
+): HelicalThreadSolidMeshPreflight;
+
+/** Placement shared by solid and filled-section factories. */
+export declare interface PrimitivePlacement {
+  /** Applied after local construction; Section placement must preserve the XY plane. */
+  readonly placement?: PrimitivePlacementOptions;
+}
+
+/** Maps an explicit or named shape-local attachment anchor onto a world-space anchor. */
+export declare interface PrimitivePlacementOptions {
+  /** Shape-local source frame or a named primitive anchor such as bottom. */
+  readonly source: Anchor3 | string;
+  /** World-space target frame in millimetres. */
+  readonly target: Anchor3;
+  /** Align outward directions face-to-face or in parallel. Defaults to opposed. */
+  readonly alignment?: "opposed" | "same";
+  /** Finite separation along the target direction in millimetres. Defaults to zero. */
+  readonly gap?: number;
+  /** Finite additional roll around the attached direction in degrees. Defaults to zero. */
+  readonly spinDegrees?: number;
+  /** Explicit numeric comparison overrides for anchor normalization. */
+  readonly tolerance?: GeometryToleranceOptions;
+}
+
+/**
+ * Named baseline fit policies for calibrated FDM-style printed threads.
+ */
+export declare type PrintableThreadFit = "tight" | "normal" | "loose";
+
+/**
+ * Explicit radial and axial allowances for a mating printed thread pair.
+ *
+ * Male and female radial values are applied independently, so their sum is the
+ * assembled radial clearance. Values are millimetres and intentionally do not
+ * encode printer, material, or process calibration.
+ */
+export declare interface PrintableThreadFitPolicy {
+  /** Nominal axial backlash available between opposing flanks. */
+  readonly axialBacklash: number;
+  /** Radial increase applied to an internal thread envelope. */
+  readonly femaleRadialOutset: number;
+  /** Radial reduction applied to an external thread envelope. */
+  readonly maleRadialInset: number;
+}
+
+/** An explicit component/contour/span topology, before shared family sampling. */
+export declare interface Profile {
+  /** Ordered components with explicit contour identities. */
+  readonly components: readonly ProfileComponent2[];
+}
+
+/** One component and its explicitly identified holes. */
+export declare interface ProfileComponent2 {
+  /** Stable canonical lowercase identity; unique within the containing topology or output. */
+  readonly id: string;
+  /** Counterclockwise outer contour. */
+  readonly outer: ProfileContour2;
+  /** Clockwise hole contours belonging to this component. */
+  readonly holes: readonly ProfileContour2[];
+}
+
+/** Ordered, closed spans. Outer winding is CCW and hole winding is CW. */
+export declare interface ProfileContour2 {
+  /** Stable canonical lowercase identity; unique within the containing topology or output. */
+  readonly id: string;
+  /** Ordered identified spans; the last endpoint meets the first start. */
+  readonly spans: readonly ProfileSpan2[];
+}
+
+/** A deliberately sampled, inward-only corner profile with exact polyline geometry. */
+export declare interface ProfiledEdgeTreatment {
+  /** Selects an explicit corner profile; no analytic curve is inferred from its samples. */
+  readonly kind: "profile";
+  /**
+   * Millimetre setbacks on adjoining surfaces, from [positive, 0] to [0, positive].
+   * First coordinates decrease and second coordinates increase. Cylinder/extrusion ends use
+   * cap inset first, side setback second; planar corners use incoming then outgoing edges.
+   */
+  readonly profile: readonly Vector2[];
+}
+
+/** 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: Vector2;
+      /** End point in millimetres. */
+      readonly end: Vector2;
+    }
+  | {
+      /** Selects the geometric curve or span family. */
+      readonly kind: "arc";
+      /** Center point in millimetres. */
+      readonly center: Vector2;
+      /** Circular radius in millimetres. */
+      readonly radius: number;
+      /** Initial counterclockwise angle in degrees. */
+      readonly startDegrees: number;
+      /** Signed counterclockwise angular sweep in degrees. */
+      readonly sweepDegrees: number;
+    }
+  | {
+      /** Selects a cubic Bézier span with the same coordinates as CubicBezierCurve2. */
+      readonly kind: "cubic";
+      /** Start point in millimetres. */
+      readonly start: Vector2;
+      /** First control point in millimetres. */
+      readonly control1: Vector2;
+      /** Second control point in millimetres. */
+      readonly control2: Vector2;
+      /** End point in millimetres. */
+      readonly end: Vector2;
+    }
+);
+
+/**
+ * Repeats one solid about an axis.
+ *
+ * @example Six copies around Z
+ * ```ts
+ * const pin = cylinder({ height: 6, radius: 2 }).translate([12, 0, 0]);
+ * radialPattern(pin, { count: 6, axis: [0, 0, 1], angleDegrees: 60 });
+ * ```
+ */
+export declare function radialPattern(
+  source: PatternSource,
+  options: RadialPatternOptions,
+): readonly Solid[];
+
+/** Repeats a filled Section about an axis; placements must preserve its XY plane. */
+export declare function radialPattern(
+  source: PatternSource<Section>,
+  options: RadialPatternOptions,
+): readonly Section[];
+
+/**
+ * Options for repeating one solid around an axis through a center point.
+ */
+export declare interface RadialPatternOptions {
+  /** Number of solids to return, including the original. */
+  readonly count: number;
+  /** Axis of the right-handed rotation. Its magnitude is ignored. */
+  readonly axis: Vector3;
+  /** Signed rotation from one copy to the next, in degrees. */
+  readonly angleDegrees: number;
+  /** Rotation center in world coordinates. Defaults to the origin. */
+  readonly center?: Vector3;
+}
+
+/**
+ * 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;
+}
+
+/** Copies intersections along the finite directed origin-to-endpoint segment. */
+export declare function rayCast(
+  solid: Solid,
+  origin: Vector3,
+  endpoint: Vector3,
+): readonly SolidRayHit[];
+
+/**
+ * Filled rectangular section with uniform or independently treated corners.
+ *
+ * @example Round the corners
+ * ```ts
+ * rectangle({ size: [30, 20], treatment: { kind: "round", radius: 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 | Vector2;
+  /** 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.
+ */
+export declare interface RectangleOptions
+  extends RectangleContourOptions, PrimitivePlacement {}
+
+/** A two-dimensional region represented by disjoint filled polygons. */
+export declare type Region = readonly Polygon[];
+
+/** Clipper2 join styles accepted by robust region offsets. */
+export declare type RegionOffsetJoin = "miter" | "round" | "square";
+
+/** Options controlling robust Clipper2 region offsets. */
+export declare interface RegionOffsetOptions {
+  /** Number of segments per full circle for round joins. */
+  readonly circularSegments?: number;
+  /** Corner treatment; defaults to `round`. */
+  readonly join?: RegionOffsetJoin;
+  /** Maximum miter extension in offset-distance multiples; at least two. */
+  readonly miterLimit?: number;
+  /** Operation-level physical tessellation policy over the active model-wide policy. */
+  readonly resolution?: GeometryResolution;
+}
+
+/**
+ * Regular polygon with a vertex on +X.
+ *
+ * @example Hexagonal section
+ * ```ts
+ * regularPolygon({ radius: 10, sides: 6, sizing: "face" });
+ * ```
+ */
+export declare function regularPolygon(options: RegularPolygonOptions): Section;
+
+/**
+ * Regular polygon dimensions, radial convention and degree rotation.
+ */
+export declare type RegularPolygonOptions = RadialSizingOptions &
+  PrimitivePlacement & {
+    /** 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 rotationDegrees?: number;
+  };
+
+/**
+ * Revolves explicit corresponding radial/Z contours around +Z, with caps for partial sweeps.
+ * Filled Sections use `section.revolve(options)`.
+ *
+ * @example Revolve
+ * ```ts
+ * import { matchProfiles, revolve } from "@metamesh/modeling";
+ * import { rectangleProfile } from "@metamesh/modeling/geometry";
+ *
+ * // Contour coordinates are [radius, Z].
+ * const [profile] = matchProfiles([rectangleProfile({ size: [4, 16], center: false })]);
+ * revolve(profile!, { revolveDegrees: 270 });
+ * ```
+ */
+export declare function revolve(
+  shape: CorrespondingProfile,
+  options?: RevolveOptions,
+): Solid;
+
+/**
+ * Circumferential sampling and degree sweep shared by pure and filled revolution.
+ */
+export declare interface RevolveOptions extends CircularPrimitiveOptions {
+  /**
+   * Positive angular sweep no greater than 360 degrees; partial revolutions have end caps.
+   * Segment counts describe a complete circle and scale to this angular span. Native filled
+   * revolutions require at least three sweep intervals: adaptive sampling refines to that floor,
+   * while exact counts that imply fewer intervals reject. Pure revolveMesh supports one interval.
+   */
+  readonly revolveDegrees?: number;
+  /** Explicit output and sampling allocation ceilings. */
+  readonly limits?: Partial<ModelingLimits>;
+}
+
+/**
+ * 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 belonging to exactly one model session.
+ * Methods run during synchronous generation and preserve their receiver.
+ * Distances use millimetres; rotations are counterclockwise degrees about the origin.
+ * Construction uses the session resolution unless the operation supplies explicit options.
+ *
+ * @example Extrude an outline with a border
+ * ```ts
+ * const body = rectangle({ size: [20, 12] })
+ *   .subtract([rectangle({ size: [16, 8] })])
+ *   .offset(0.5)
+ *   .extrude({ height: 4 });
+ * ```
+ */
+export declare interface Section {
+  /** Compile-time ownership brand for a same-session section. */
+  readonly [sectionBrand]: "Section";
+  /** Translates XY coordinates in millimetres. */
+  translate(this: Section, offset: Vector2): Section;
+  /** Rotates counterclockwise about the origin by a scalar angle in degrees. */
+  rotate(this: Section, degrees: number): Section;
+  /**
+   * Nonsingular scaling about the origin.
+   */
+  scale(this: Section, factors: number | Vector2): Section;
+  /** Reflection across an origin line/plane. */
+  mirror(this: Section, normal: Vector2): Section;
+  /** Row-major affine transform preserving dimensionality. */
+  transform(this: Section, matrix: Transform2): Section;
+  /** Native section difference; an empty cutter array preserves the source. */
+  subtract(this: Section, cutters: readonly Section[]): Section;
+  /**
+   * Simplifies filled 2D contours using an explicit positive millimetre tolerance.
+   *
+   * Useful for dense imported outlines before extrusion. This changes the outline rather
+   * than selecting a lower rendering quality; fine features may be removed.
+   */
+  simplify(this: Section, tolerance: number): Section;
+  /**
+   * Returns a new same-session handle with copied named anchors; existing names may be replaced.
+   */
+  withAnchors(
+    this: Section,
+    anchors: Readonly<Record<string, Anchor3>>,
+  ): Section;
+  /**
+   * Native millimetre offset preserving holes.
+   */
+  offset(
+    this: Section,
+    distance: number,
+    options?: RegionOffsetOptions,
+  ): Section;
+  /**
+   * 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.
+   */
+  revolve(this: Section, options?: RevolveOptions): Solid;
+  /**
+   * Sweeps this filled section using the selected frame policy and degree twist.
+   */
+  sweep(this: Section, path: readonly Vector3[], options?: SweepOptions): Solid;
+}
+
+declare const sectionBrand: unique symbol;
+
+/** Planar convex hull inputs are finite XY points or same-session filled sections. */
+export declare type SectionHullOptions =
+  | {
+      /** At least three finite millimetre XY points spanning positive area. */
+      readonly points: readonly Vector2[];
+      /** Point input excludes section input. */
+      readonly sections?: never;
+    }
+  | {
+      /** One through 1000 same-session sections to include in the convex hull. */
+      readonly sections: readonly Section[];
+      /** Section input excludes point input. */
+      readonly points?: never;
+    };
+
+/**
+ * Immutable native filled section facts in millimetres and square millimetres.
+ * Repeated inspections of the same native shape share these facts within one revision.
+ */
+export declare interface SectionInspection {
+  /** Whether this filled section has no area or boundary. */
+  readonly isEmpty: boolean;
+  /** Filled section area in square millimetres. */
+  readonly area: number;
+  /** Number of extracted outer and hole contours. */
+  readonly contours: number;
+  /** Inclusive maximum coordinates in millimetres. */
+  readonly max: Vector2;
+  /** Inclusive minimum coordinates in millimetres. */
+  readonly min: Vector2;
+  /** Number of disconnected filled section components. */
+  readonly parts: number;
+  /** Number of native section vertices. */
+  readonly vertices: number;
+}
+
+/** A cubic corner transition with zero curvature at its straight tangent joins. */
+export declare interface SmoothEdgeTreatment {
+  /** Selects continuous-curvature cubic rounding, rather than a circular radius. */
+  readonly kind: "smooth";
+  /** 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 belonging to exactly one model session.
+ * Methods run during synchronous generation, preserve their receiver, and use millimetres and degrees.
+ * A no-op may reuse the receiver; final part placement belongs in `part` options.
+ *
+ * @example Shape a body with a through bore
+ * ```ts
+ * const body = box({ size: [30, 20, 6] })
+ *   .subtract([cylinder({ height: 8, radius: 3 })])
+ *   .rotate([0, 0, 45]);
+ * ```
+ */
+export declare interface Solid {
+  /** Compile-time ownership brand for a same-session solid. */
+  readonly [solidBrand]: "Solid";
+  /**
+   * Translates XYZ coordinates in millimetres.
+   */
+  translate(this: Solid, offset: Vector3): Solid;
+  /**
+   * Rotates about the origin using XYZ Euler angles in degrees.
+   */
+  rotate(this: Solid, degrees: Vector3): Solid;
+  /**
+   * Nonsingular scaling about the origin.
+   */
+  scale(this: Solid, factors: number | Vector3): Solid;
+  /**
+   * Reflection across an origin line/plane.
+   */
+  mirror(this: Solid, normal: Vector3): Solid;
+  /** Row-major affine transform preserving dimensionality. */
+  transform(this: Solid, matrix: Transform3): Solid;
+  /**
+   * Robust difference; an empty cutter array preserves the source.
+   */
+  subtract(this: Solid, cutters: readonly Solid[]): Solid;
+  /**
+   * Simplifies a solid using an explicit positive millimetre tolerance.
+   *
+   * Removes redundant vertices while keeping surfaces within the greater of this tolerance
+   * 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 same-session handle 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.
+   */
+  attach(
+    this: Solid,
+    source: Anchor3 | string,
+    target: Anchor3,
+    options?: AttachOptions,
+  ): Solid;
+  /** Replaces native tolerance on an immutable copy; zero selects the kernel minimum. */
+  setTolerance(this: Solid, tolerance: number): Solid;
+  /** Projects this solid into a filled XY section. */
+  projectSection(this: Solid): Section;
+  /** Takes a filled horizontal slice at Z millimetres. */
+  sliceSection(this: Solid, z: number): Section;
+}
+
+declare const solidBrand: unique symbol;
+
+/**
+ * Imports a bounded closed indexed mesh.
+ *
+ * @example Mesh import
+ * ```ts
+ * import { solidFromMesh } from "@metamesh/modeling";
+ * import { extrudeMesh, rectangleContour } from "@metamesh/modeling/geometry";
+ *
+ * const mesh = extrudeMesh(rectangleContour({ size: [20, 12] }), { height: 6 });
+ * solidFromMesh(mesh);
+ * ```
+ */
+export declare function solidFromMesh(
+  mesh: TriangleMesh | ImmutableTriangleMesh,
+): Solid;
+
+/**
+ * Immutable solid bounds, emptiness, component count, volume, surface area and native tolerance.
+ * Repeated inspections of the same native shape share these facts within one revision.
+ */
+export declare interface SolidInspection {
+  /** Whether this native solid contains no material. */
+  readonly isEmpty: boolean;
+  /** Inclusive maximum coordinates in millimetres. */
+  readonly max: Vector3;
+  /** Inclusive minimum coordinates in millimetres. */
+  readonly min: Vector3;
+  /** Number of connected surface shells; inward cavity shells count separately. */
+  readonly parts: number;
+  /** Enclosed native solid volume in cubic millimetres. */
+  readonly volume: number;
+  /** Total native surface area in square millimetres. */
+  readonly surfaceArea: number;
+  /** Effective native geometric tolerance in millimetres. */
+  readonly tolerance: number;
+}
+
+/** Copied surface intersection from a finite directed segment. Distance is in millimetres. */
+export declare interface SolidRayHit {
+  /** Copied numeric native face identity. */
+  readonly faceId: number;
+  /** Distance from the ray origin in millimetres. */
+  readonly distance: number;
+  /** Intersection position in millimetres. */
+  readonly position: Vector3;
+  /** Outward unit surface normal at the intersection. */
+  readonly normal: Vector3;
+}
+
+/**
+ * Origin-centered sphere.
+ *
+ * @example Sphere
+ * ```ts
+ * sphere({ diameter: 20 });
+ * ```
+ */
+export declare function sphere(options: SphereOptions): Solid;
+
+/**
+ * Exactly one radius or diameter, placement, and tessellation for an origin-centered sphere.
+ */
+export declare type SphereOptions = CircularPrimitiveOptions &
+  PrimitivePlacement &
+  (
+    | {
+        /** Positive radius in millimetres; mutually exclusive with diameter. */
+        readonly radius: number;
+        /** Full diameter is unavailable when radius is supplied. */
+        readonly diameter?: never;
+      }
+    | {
+        /** Positive full diameter in millimetres; mutually exclusive with radius. */
+        readonly diameter: number;
+        /** Radius is unavailable when diameter is supplied. */
+        readonly radius?: never;
+      }
+  );
+
+/**
+ * Splits a solid into [inside the cutter, outside the cutter].
+ *
+ * The first result is the intersection; the second is the subtraction. The cutter itself
+ * is not returned. Either result may be empty or contain multiple disconnected components.
+ *
+ * @example Keep the plug and the surrounding body
+ * ```ts
+ * const body = box({ size: [30, 20, 8] });
+ * const cutter = cylinder({ height: 10, diameter: 8 });
+ * const [plug, remainder] = split(body, cutter);
+ * // Move the plug beside the body to show both results.
+ * union([plug.translate([0, -20, 0]), remainder]);
+ * ```
+ */
+export declare function split(
+  solid: Solid,
+  cutter: Solid,
+): readonly [Solid, Solid];
+
+/**
+ * Splits a solid into [positive-normal side, negative side] at a world-space plane.
+ *
+ * The nonzero normal is normalized; offset is the signed distance from the origin in
+ * millimetres, defaulting to zero. Both cut faces are closed. Select either tuple result
+ * to retain one side; either result may be empty.
+ *
+ * @example Separate two halves at X = 0
+ * ```ts
+ * const body = box({ size: [30, 20, 8] });
+ * const [right, left] = splitByPlane(body, { normal: [1, 0, 0] });
+ * // The gap is only for display; the cut itself removes no material.
+ * union([right.translate([4, 0, 0]), left.translate([-4, 0, 0])]);
+ * ```
+ *
+ * @example Keep only the positive half
+ * ```ts
+ * const [right] = splitByPlane(box({ size: [30, 20, 8] }), { normal: [1, 0, 0] });
+ * right;
+ * ```
+ */
+export declare function splitByPlane(
+  solid: Solid,
+  plane: PlaneOptions,
+): readonly [Solid, Solid];
+
+/** Square profile with equal crest and root widths. */
+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 });
+ * ```
+ */
+export declare function star(options: StarOptions): Section;
+
+/**
+ * Alternating outer and inner vertices, centered on the XY origin.
+ */
+export declare interface StarOptions extends PrimitivePlacement {
+  /** Explicit sampling ceilings, bounded by the host policy. */
+  readonly limits?: Partial<GeometrySamplingLimits>;
+  /** Positive outer vertex radius in millimetres. */
+  readonly outerRadius: number;
+  /** Positive inner vertex radius, smaller than the outer radius. */
+  readonly innerRadius: number;
+  /** Integer outer point count from three through 50000. */
+  readonly points: number;
+  /** Initial counterclockwise rotation in degrees; defaults to zero. */
+  readonly rotationDegrees?: number;
+}
+
+/** Placement of painted SVG geometry after SVG Y-axis inversion. */
+export declare type SvgOrigin = "center" | "document";
+
+/**
+ * Imports bounded filled SVG path data.
+ *
+ * @example Fill an SVG path in millimetres
+ * ```ts
+ * svgPathSection("M0 0H20V12H0Z", { origin: "center", scale: 1 });
+ * ```
+ */
+export declare function svgPathSection(
+  path: string,
+  options?: SvgPathSectionOptions,
+): Section;
+
+/** Bounded filled SVG path sampling. Path scale converts user units to millimetres. */
+export declare interface SvgPathSectionOptions {
+  /** Local allocation ceilings may only lower the configured engine policy. */
+  readonly limits?: Partial<GeometrySamplingLimits>;
+  /** Nonzero or even-odd filled-contour rule; defaults to nonzero. */
+  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. */
+  readonly origin?: SvgOrigin;
+  /** Positive uniform factor converting SVG user units to millimetres; defaults to one. */
+  readonly scale?: number;
+}
+
+/**
+ * Imports bounded painted SVG document geometry.
+ *
+ * @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" },
+ * );
+ * ```
+ */
+export declare function svgSection(
+  svg: string,
+  options?: SvgSectionOptions,
+): Section;
+
+/**
+ * Bounded SVG document sampling. Center origin uses the final painted bounds.
+ */
+export declare interface SvgSectionOptions {
+  /** Local allocation ceilings may only lower the configured engine policy. */
+  readonly limits?: Partial<GeometrySamplingLimits>;
+  /** Exact circular tessellation count overriding physical sampling. */
+  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. */
+  readonly origin?: SvgOrigin;
+}
+
+/**
+ * Sweeps explicit corresponding contours using the selected frame policy.
+ * Filled Sections use `section.sweep(path, options)`.
+ *
+ * @example Sweep
+ * ```ts
+ * import { matchProfiles, sweep } from "@metamesh/modeling";
+ * import { rectangleProfile } from "@metamesh/modeling/geometry";
+ *
+ * const [profile] = matchProfiles([rectangleProfile({ size: [6, 3] })]);
+ * sweep(profile!, [[0, 0, 0], [0, 0, 15], [10, 0, 25]], {
+ *   orientation: { kind: "transport", initialNormal: [0, 1, 0] },
+ * });
+ * ```
+ */
+export declare function sweep(
+  shape: CorrespondingProfile,
+  path: readonly Vector3[],
+  options?: SweepOptions,
+): Solid;
+
+/**
+ * Controls shared by pure mesh construction and filled modeling sweeps.
+ */
+export declare interface SweepOptions {
+  /** Join the path's last station to its first. Open paths retain watertight end caps. */
+  readonly closed?: boolean;
+  /** Explicit output and sampling allocation ceilings. */
+  readonly limits?: Partial<ModelingLimits>;
+  /** Explicit frame policy; default transport minimizes rotations, initially projecting +X then +Y then +Z. */
+  readonly orientation?: SweepOrientation;
+  /** Physical sampling of nonzero twist; inserted stations retain authored station controls. */
+  readonly resolution?: GeometryResolution;
+  /** Total additional profile rotation in degrees, with progression selected by twistBy. */
+  readonly twistDegrees?: number;
+  /** Twist advances by physical path length (default), or normalized authored station position, including a closed seam gap. */
+  readonly twistBy?: "length" | "stations";
+  /** Positive uniform/XY scale, or one XY pair per path station. Defaults to one. */
+  readonly scale?: number | Vector2 | readonly Vector2[];
+  /** Corresponding point-index advance at a rotationally equivalent closed seam. */
+  readonly seamProfileOffset?: number;
+}
+
+/**
+ * Explicit profile-X frame policy; all normals are directed, and selected singular policies reject.
+ */
+export declare type SweepOrientation =
+  | {
+      /** Minimizes frame rotation by parallel transport. */
+      readonly kind: "transport";
+      /** Initial profile +X guide, projected perpendicular to the first tangent. */
+      readonly initialNormal?: Vector3;
+    }
+  | {
+      /** Projects one fixed world-space normal at every path station. */
+      readonly kind: "fixed-normal";
+      /** Directed profile +X guide; must not be parallel to any local tangent. */
+      readonly normal: Vector3;
+    }
+  | {
+      /** Uses an explicitly directed normal callback at each original normalized station. */
+      readonly kind: "guide";
+      /** Finite profile +X guide callback, evaluated once per original path station. */
+      readonly normal: PathNormalGuide;
+    }
+  | {
+      /** Uses sampled curvature normals; zero-curvature stations reject. */
+      readonly kind: "frenet";
+    };
+
+/**
+ * Consumes a previously prepared layout; never shapes or fetches a font.
+ *
+ * @example Use a prepared text layout
+ * ```ts
+ * // Prepare the exact font and layout before entering build.
+ * function labelSection(layout: VectorTextLayout) {
+ *   return textSection(layout);
+ * }
+ * ```
+ */
+export declare function textSection(
+  layout: VectorTextLayout,
+  options?: TextSectionOptions,
+): Section;
+
+/**
+ * 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>;
+  /** Local physical sampling policy; exact interval counts take precedence. */
+  readonly resolution?: GeometryResolution;
+}
+
+/** End bevel controls shared by threaded rods and cutters. */
+declare interface ThreadBevelOptions {
+  /** Apply a 45-degree bevel at Z=0. */
+  readonly bevelBottom?: boolean;
+  /**
+   * Axial bevel extent in millimetres. Active blunt ends default to one sixth of the compensated
+   * male minor radius or female major radius; other ends default to the profile depth.
+   */
+  readonly bevelSize?: number;
+  /** Apply a 45-degree bevel at Z=length. */
+  readonly bevelTop?: boolean;
+}
+
+/**
+ * Compensated threaded nut.
+ *
+ * @example Threaded nut
+ * ```ts
+ * import { threadedNut } from "@metamesh/modeling";
+ * import { createThreadProfile } from "@metamesh/modeling/geometry";
+ *
+ * const profile = createThreadProfile({ kind: "triangular", pitch: 1.75 });
+ * threadedNut({ nominalMajorDiameter: 12, thickness: 8, width: 20, shape: "hex", profile, fit: "normal" });
+ * ```
+ */
+export declare function threadedNut(options: ThreadedNutOptions): Solid;
+
+/** Nut-edge bevel selection. */
+export declare type ThreadedNutBevel =
+  "automatic" | "both" | "inside" | "none" | "outside";
+
+/**
+ * Options for a compensated nut with an internal thread.
+ */
+export declare interface ThreadedNutOptions extends Omit<
+  InternalThreadCutterOptions,
+  "bevelBottom" | "bevelSize" | "bevelTop" | "length"
+> {
+  /** Nut body bevel selection. Default: `automatic`. */
+  readonly bevel?: ThreadedNutBevel;
+  /** Optional physical policy for a round body, independent of the thread's matched facet grid. */
+  readonly bodyResolution?: GeometryResolution;
+  /** 45-degree body chamfer extent. Default: `min(profile.depth, thickness/4)`. */
+  readonly chamferSize?: number;
+  /** Leave the bottom outside edge flat for build-plate adhesion. Default: `false`. */
+  readonly flushBuildPlateBottom?: boolean;
+  /** Nut body shape. */
+  readonly shape: ThreadedNutShape;
+  /** Nut thickness along +Z in millimetres. */
+  readonly thickness: number;
+  /** Across-flats width for hex/square or diameter for round, in millimetres. */
+  readonly width: number;
+}
+
+/** Allocation-free body, cutter, and end-face facts resolved for a threaded nut. */
+export declare interface ThreadedNutPreflight {
+  /** Polygon segment count used by the nut body. */
+  readonly bodySegments: number;
+  /** Shared 45-degree chamfer size applied to the selected body and cutter edges. */
+  readonly chamferSize: number;
+  /** Maximum compensated cutter radius at either requested face. */
+  readonly cutterFaceRadius: number;
+  /** Minimum nut-body inradius across the requested top and bottom faces. */
+  readonly minimumBodyFaceInradius: number;
+  /** Smallest radial wall left between the body and cutter at either requested face. */
+  readonly minimumFaceWall: number;
+  /** Conservative allocation facts for the exact extended internal-thread cutter mesh. */
+  readonly thread: HelicalThreadSolidMeshPreflight;
+  /** Start-aligned circular facet count used by the compensated thread cutter. */
+  readonly threadCircularSegments: number;
+}
+
+/**
+ * Supported printable nut body shapes.
+ */
+export declare type ThreadedNutShape = "hex" | "round" | "square";
+
+/**
+ * Compensated external threaded rod.
+ *
+ * @example Threaded rod
+ * ```ts
+ * import { threadedRod } from "@metamesh/modeling";
+ * import { createThreadProfile } from "@metamesh/modeling/geometry";
+ *
+ * const profile = createThreadProfile({ 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<HelicalThreadRidgeMeshOptions, "majorDiameter">,
+    ThreadBevelOptions {
+  /** Printable fit or caller-calibrated allowances. Default: `normal`. */
+  readonly fit?: PrintableThreadFit | PrintableThreadFitPolicy;
+  /** Nominal major diameter before male compensation. */
+  readonly nominalMajorDiameter: number;
+}
+
+/** End shape of a generated helical ridge. */
+export declare type ThreadEndStyle = "blunt" | "standard" | "tapered";
+
+/** Axial end controls for a generated ridge. */
+export declare interface ThreadEndTreatmentOptions {
+  /**
+   * Ridge shape at the lower working boundary. `blunt` ends at full profile height, `standard`
+   * clips the periodic profile at the face, and `tapered` ramps out from the minor envelope.
+   * @defaultValue `"blunt"`
+   */
+  readonly bottom?: ThreadEndStyle;
+  /**
+   * Non-negative unthreaded envelope length reserved at each non-standard end, in millimetres.
+   * Active blunt bevels may raise this reservation to the effective bevel size.
+   * @defaultValue `0`
+   */
+  readonly endLength?: number;
+  /**
+   * Radial envelope toward which a blunt lead-in collapses.
+   * @defaultValue `"minor"`
+   */
+  readonly leadInEnvelope?: ThreadLeadInEnvelope;
+  /**
+   * Physical circumferential lead-in length in millimetres.
+   * @defaultValue The profile depth.
+   */
+  readonly leadInLength?: number;
+  /**
+   * Cross-section scaling curve used by blunt ends. `cut` switches abruptly to the full profile.
+   * @defaultValue `"cut"`
+   */
+  readonly leadInShape?: ThreadLeadInShape;
+  /**
+   * Ridge shape at the upper working boundary. `blunt` ends at full profile height, `standard`
+   * clips the periodic profile at the face, and `tapered` ramps into the minor envelope.
+   * @defaultValue `"blunt"`
+   */
+  readonly top?: ThreadEndStyle;
+}
+
+/**
+ * Direction in which a conventional helical thread advances around +Z.
+ */
+export declare type ThreadHandedness = "left" | "right";
+
+/** 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 Vector2[];
+  /** Axial width of the flat at the minor envelope. */
+  readonly rootFlatWidth: number;
+}
+
+/** Fields shared by all thread profile specifications. */
+declare interface ThreadProfileBaseSpec {
+  /** Adjacent axial thread spacing in millimetres. */
+  readonly pitch: number;
+  /** Optional numerical tolerance overrides. */
+  readonly tolerance?: GeometryToleranceOptions;
+}
+
+/**
+ * Supported built-in and caller-defined thread profiles.
+ */
+declare type ThreadProfileSpec =
+  | AcmeThreadProfileSpec
+  | ButtressThreadProfileSpec
+  | CustomThreadProfileSpec
+  | SquareThreadProfileSpec
+  | TrapezoidalThreadProfileSpec
+  | TriangularThreadProfileSpec;
+
+/** Helical ridge mesh construction. */
+export declare function threadRidge(options: ThreadRidgeOptions): Solid;
+
+/** Parameters for a helical ridge before solid construction. */
+export declare type ThreadRidgeOptions = HelicalThreadRidgeMeshOptions;
+
+/** Explicit copied topology inspection; not needed for section operations. */
+export declare function toRegion(section: Section): Region;
+
+/**
+ * Torus around +Z.
+ *
+ * @example Torus
+ * ```ts
+ * torus({ majorRadius: 12, minorRadius: 3 });
+ * ```
+ */
+export declare function torus(options: TorusOptions): Solid;
+
+/**
+ * Dimensions and independent ring/profile tessellation for a torus around the Z axis.
+ */
+export declare interface TorusOptions extends PrimitivePlacement {
+  /** Explicit sampling ceilings, bounded by the host policy. */
+  readonly limits?: Partial<GeometrySamplingLimits>;
+  /** Radius from the Z axis to the profile center, in millimetres; greater than `minorRadius`. */
+  readonly majorRadius: number;
+  /** Exact segment count around the Z axis; omitted uses adaptive resolution. */
+  readonly majorSegments?: number;
+  /** Radius of the swept circular profile in millimetres. */
+  readonly minorRadius: number;
+  /** Exact segment count around the swept profile; omitted uses adaptive resolution. */
+  readonly minorSegments?: number;
+  /** Operation-level physical tessellation policy over the active model-wide policy. */
+  readonly resolution?: GeometryResolution;
+}
+
+/** Copies a handle to manufacturing mesh buffers. */
+export declare function toTriangleMesh(solid: Solid): TriangleMesh;
+
+/** Row-major affine XY matrix. Translation occupies m02/m12; final row is [0, 0, 1]. */
+export declare type Transform2 = readonly [
+  m00: number,
+  m01: number,
+  m02: number,
+  m10: number,
+  m11: number,
+  m12: number,
+  m20: number,
+  m21: number,
+  m22: number,
+];
+
+/**
+ * A row-major affine 4x4 matrix applied to column vectors.
+ *
+ * Translation occupies indices 3, 7, and 11. The final row must be
+ * `[0, 0, 0, 1]` within the active geometry tolerance.
+ */
+export declare type Transform3 = readonly [
+  m00: number,
+  m01: number,
+  m02: number,
+  m03: number,
+  m10: number,
+  m11: number,
+  m12: number,
+  m13: number,
+  m20: number,
+  m21: number,
+  m22: number,
+  m23: number,
+  m30: number,
+  m31: number,
+  m32: number,
+  m33: number,
+];
+
+/** Trapezoidal thread profile with a configurable included angle. */
+declare interface TrapezoidalThreadProfileSpec extends ThreadProfileBaseSpec {
+  /** Selects the trapezoidal profile family. */
+  readonly kind: "trapezoidal";
+  /**
+   * Radial depth in millimetres.
+   * @defaultValue `pitch / 2`
+   */
+  readonly depth?: number;
+  /**
+   * Included flank angle in degrees. Use `90` for printable 45-degree slopes.
+   * @defaultValue `30`
+   */
+  readonly threadAngle?: number;
+}
+
+/**
+ * A topology-preserving indexed triangle mesh with XYZ vertex positions.
+ */
+export declare interface TriangleMesh {
+  /** Three unsigned vertex indices per triangle. */
+  readonly indices: Uint32Array;
+  /** Flat XYZ coordinates, three finite values per vertex. */
+  readonly positions: Float32Array;
+}
+
+/**
+ * Measurements and optional edge-connected topology from one validated mesh traversal.
+ */
+export declare interface TriangleMeshAnalysis extends TriangleMeshMeasurements {
+  /** Number of referenced edge-connected components when `includeTopology` is requested. */
+  readonly connectedComponentCount?: number;
+  /** Number of distinct indexed undirected edges when `includeTopology` is requested. */
+  readonly edgeCount?: number;
+}
+
+/**
+ * Geometric measurements derived from a validated, non-empty triangle mesh.
+ */
+export declare interface TriangleMeshMeasurements {
+  /** Axis-aligned bounds. */
+  readonly bounds: Bounds3;
+  /** 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;
+}
+
+/**
+ * ISO/UTS-like 60-degree truncated triangular profile.
+ */
+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.
+ *
+ * @example Tube
+ * ```ts
+ * tube({ height: 20, outerRadius: 10, innerRadius: 6 });
+ * ```
+ */
+export declare function tube(options: TubeOptions): Solid;
+
+/**
+ * Dimensions, placement, and tessellation for a hollow Z-axis tube.
+ */
+export declare interface TubeOptions
+  extends CircularPrimitiveOptions, PrimitivePlacement {
+  /**
+   * Centers the tube on the Z origin when `true`; otherwise its bottom is at `Z = 0`.
+   * @defaultValue `true`
+   */
+  readonly center?: boolean;
+  /** Total height along Z in millimetres. */
+  readonly height: number;
+  /** Positive inner radius in millimetres. */
+  readonly innerRadius: number;
+  /** Outer radius in millimetres; greater than {@link TubeOptions.innerRadius}. */
+  readonly outerRadius: number;
+}
+
+/**
+ * Robust union.
+ *
+ * @example Union
+ * ```ts
+ * const block = box({ size: 20 });
+ * const cap = sphere({ radius: 10 }).translate([0, 0, 10]);
+ * union([block, cap]);
+ * ```
+ */
+export declare function union(solids: readonly Solid[]): Solid;
+
+/** Native filled section union; dimensions cannot be mixed. */
+export declare function union(sections: readonly Section[]): Section;
+
+/** A two-dimensional Cartesian vector or point. */
+export declare type Vector2 = readonly [x: number, y: number];
+
+/** A three-dimensional Cartesian vector or point. */
+export declare type Vector3 = readonly [x: number, y: number, z: number];
+
+/**
+ * Immutable vector layout with no browser, font parser, or kernel ownership.
+ */
+export declare interface VectorTextLayout {
+  /** Nonzero-filled path data in millimetres, positive Y upward; empty for text with no ink. */
+  readonly paths: readonly string[];
+  /** Exact measurements of these paths and their logical text layout. */
+  readonly metrics: VectorTextMetrics;
+}
+
+/** 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: Bounds2 | 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 {};