@metamesh/modeling 0.0.0-stage → 0.7.0

package/dist/api/index.d.ts

@@ -0,0 +1,2087 @@
+/** 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 one immutable named anchor from a shape in the active build. */
+export declare const anchor: ModelingContext["anchor"];
+
+/**
+ * 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;
+}
+
+/** Host-bound attach operation. Valid only during a synchronous build. */
+export declare const attach: ModelingContext["attach"];
+
+/**
+ * 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;
+}
+
+/** Host-bound box operation. Valid only during a synchronous build. */
+export declare const box: ModelingContext["box"];
+
+/** 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;
+}
+
+/** A bare solid receives the semantic part ID `model`. Explicit parts preserve their IDs. */
+export declare type BuildOutput = Solid | readonly ModelPart[];
+
+/** 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];
+}
+
+/** Host-bound circle operation. Valid only during a synchronous build. */
+export declare const circle: ModelingContext["circle"];
+
+/**
+ * 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;
+}
+
+/** Host-bound components operation. Valid only during a synchronous build. */
+export declare const components: ModelingContext["components"];
+
+/** Host-bound compose operation. Valid only during a synchronous build. */
+export declare const compose: ModelingContext["compose"];
+
+/** 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[];
+}
+
+/** Host-bound cylinder operation. Valid only during a synchronous build. */
+export declare const cylinder: ModelingContext["cylinder"];
+
+/**
+ * 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;
+});
+
+/**
+ * Uniform finishing vocabulary shared by applicable solid edges and profile corners.
+ */
+export declare type EdgeTreatment = ChamferedEdgeTreatment | RoundedEdgeTreatment | SmoothEdgeTreatment | ProfiledEdgeTreatment;
+
+/** Host-bound ellipse operation. Valid only during a synchronous build. */
+export declare const ellipse: ModelingContext["ellipse"];
+
+/**
+ * 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;
+}
+
+/** Host-bound extrude operation. Valid only during a synchronous build. */
+export declare const extrude: ModelingContext["extrude"];
+
+/**
+ * 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;
+}
+
+/** Host-bound fromRegion operation. Valid only during a synchronous build. */
+export declare const fromRegion: ModelingContext["fromRegion"];
+
+/**
+ * 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;
+}
+
+/** Host-bound gridPattern operation. Valid only during a synchronous build. */
+export declare const gridPattern: ModelingContext["gridPattern"];
+
+/**
+ * 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;
+});
+
+/** Constructs a closed regularly sampled heightfield during the active synchronous build. */
+export declare const heightfield: ModelingContext["heightfield"];
+
+/** A regularly sampled, closed heightfield above a flat base, in millimetres. */
+export declare interface HeightfieldOptions {
+    /** Positive XY footprint. */
+    readonly size: Vec2;
+    /** Exact positive integer X/Y interval counts. */
+    readonly segments: readonly [x: number, y: number];
+    /** Absolute top Z at the supplied XY point. Every sample must be above baseZ. */
+    readonly height: (point: Vec2) => number;
+    /** Flat bottom Z. Defaults to zero. */
+    readonly baseZ?: number;
+    /** Lower-left footprint XY. Omitted centers the footprint on XY. */
+    readonly origin?: Vec2;
+}
+
+/** 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;
+}
+
+/** Host-bound hull operation. Valid only during a synchronous build. */
+export declare const hull: ModelingContext["hull"];
+
+/** Hull inputs are either finite points or same-build 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;
+};
+
+/** Host-bound implicit operation. Valid only during a synchronous build. */
+export declare const implicit: ModelingContext["implicit"];
+
+/** 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;
+    /** Explicit nonnegative native geometric tolerance in millimetres. */
+    readonly tolerance?: number;
+}
+
+/** Host-bound inspectSection operation. Valid only during a synchronous build. */
+export declare const inspectSection: ModelingContext["inspectSection"];
+
+/** Host-bound inspectSolid operation. Valid only during a synchronous build. */
+export declare const inspectSolid: ModelingContext["inspectSolid"];
+
+/** Host-bound internalThreadCutter operation. Valid only during a synchronous build. */
+export declare const internalThreadCutter: ModelingContext["internalThreadCutter"];
+
+/** 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;
+}
+
+/** Host-bound intersect operation. Valid only during a synchronous build. */
+export declare const intersect: ModelingContext["intersect"];
+
+/** Host-bound linearPattern operation. Valid only during a synchronous build. */
+export declare const linearPattern: ModelingContext["linearPattern"];
+
+/**
+ * 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;
+});
+
+/** Host-bound loft operation. Valid only during a synchronous build. */
+export declare const loft: ModelingContext["loft"];
+
+/** Deterministic ordered edge subdivision or bounded geometric vertex association. */
+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[];
+
+/** Matches an explicit profile family using the current build's physical resolution. */
+export declare const matchProfiles: ModelingContext["matchProfiles"];
+
+/** 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;
+}
+
+/** Named direct mesh part. Input is copied, validated, and bounded by the host. */
+export declare interface MeshPart {
+    /** Stable canonical lowercase identity; unique within the containing topology or output. */
+    readonly id: string;
+    /** Optional six-digit hex RGB display color. */
+    readonly color?: string;
+    /** Direct manufacturing mesh; mutually exclusive with a solid handle. */
+    readonly mesh: TriangleMesh;
+    /** Same-build solid handle; mutually exclusive with a direct mesh. */
+    readonly solid?: never;
+}
+
+/** Host-bound minkowskiSum operation. Valid only during a synchronous build. */
+export declare const minkowskiSum: ModelingContext["minkowskiSum"];
+
+/** Host-bound mirror operation. Valid only during a synchronous build. */
+export declare const mirror: ModelingContext["mirror"];
+
+/** The sole modeling facade used by compiled and authored generators.
+ * Methods are bound to the host execution and can be destructured safely. Angles are degrees;
+ * lengths are millimetres. Handles cannot outlive this build or cross into a different build.
+ */
+export declare interface ModelingContext {
+    /** Derives a context with explicit physical sampling defaults in the same execution. */
+    withResolution(this: void, resolution: GeometryResolution): ModelingContext;
+    /**
+     * 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 } });
+     * ```
+     */
+    box(this: void, options: BoxOptions): Solid;
+    /**
+     * +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] });
+     * ```
+     */
+    cylinder(this: void, options: CylinderOptions): Solid;
+    /**
+     * Hollow +Z tube.
+     *
+     * @example Tube
+     * ```ts
+     * tube({ height: 20, outerRadius: 10, innerRadius: 6 });
+     * ```
+     */
+    tube(this: void, options: TubeOptions): Solid;
+    /**
+     * Origin-centered sphere.
+     *
+     * @example Sphere
+     * ```ts
+     * sphere({ diameter: 20 });
+     * ```
+     */
+    sphere(this: void, options: SphereOptions): Solid;
+    /**
+     * Torus around +Z.
+     *
+     * @example Torus
+     * ```ts
+     * torus({ majorRadius: 12, minorRadius: 3 });
+     * ```
+     */
+    torus(this: void, options: TorusOptions): Solid;
+    /**
+     * Robust union.
+     *
+     * @example Union
+     * ```ts
+     * const block = box({ size: 20 });
+     * const cap = translate(sphere({ radius: 10 }), [0, 0, 10]);
+     * union([block, cap]);
+     * ```
+     */
+    union(this: void, solids: readonly Solid[]): Solid;
+    /** Native filled section union; dimensions cannot be mixed. */
+    union(this: void, sections: readonly Section[]): Section;
+    /**
+     * Robust difference; an empty cutter array preserves the source.
+     *
+     * @example Subtract
+     * ```ts
+     * const plate = box({ size: [30, 20, 6] });
+     * // Extend the cutter beyond both faces.
+     * const bore = cylinder({ height: 8, radius: 3, sizing: "face" });
+     * subtract(plate, [bore]);
+     * ```
+     */
+    subtract(this: void, solid: Solid, cutters: readonly Solid[]): Solid;
+    /** Native section difference; an empty cutter array preserves the source. */
+    subtract(this: void, section: Section, cutters: readonly Section[]): Section;
+    /**
+     * Robust intersection.
+     *
+     * @example Intersect
+     * ```ts
+     * intersect([box({ size: 20 }), sphere({ radius: 12 })]);
+     * ```
+     */
+    intersect(this: void, solids: readonly Solid[]): Solid;
+    /** Native filled section intersection; dimensions cannot be mixed. */
+    intersect(this: void, sections: readonly Section[]): Section;
+    /** Combines disjoint components without resolving overlap. */
+    compose(this: void, solids: readonly Solid[]): Solid;
+    /**
+     * Convex hull of points or solids.
+     *
+     * @example Hull
+     * ```ts
+     * const left = translate(sphere({ radius: 5 }), [-10, 0, 0]);
+     * const right = translate(sphere({ radius: 5 }), [10, 0, 0]);
+     * hull({ solids: [left, right] });
+     * ```
+     */
+    hull(this: void, options: HullOptions): Solid;
+    /** Three-dimensional Minkowski sum. */
+    minkowskiSum(this: void, a: Solid, b: Solid): Solid;
+    /**
+     * 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);
+     * ```
+     */
+    solidFromMesh(this: void, mesh: TriangleMesh): Solid;
+    /** Copies a handle to manufacturing mesh buffers. */
+    toTriangleMesh(this: void, solid: Solid): TriangleMesh;
+    /** Translation preserving dimensionality. */
+    translate(this: void, section: Section, offset: Vec2): Section;
+    /**
+     * Translation preserving dimensionality.
+     *
+     * @example Translate
+     * ```ts
+     * translate(box({ size: [12, 8, 4] }), [15, 0, 0]);
+     * ```
+     */
+    translate(this: void, solid: Solid, offset: Vec3): Solid;
+    /** Degree rotation; scalar XY rotation or XYZ solid Euler angles. */
+    rotate(this: void, section: Section, degrees: number): Section;
+    /**
+     * Degree rotation; scalar XY rotation or XYZ solid Euler angles.
+     *
+     * @example Rotate
+     * ```ts
+     * rotate(box({ size: [20, 10, 6] }), [0, 0, 30]);
+     * ```
+     */
+    rotate(this: void, solid: Solid, degrees: Vec3): Solid;
+    /**
+     * Nonsingular scaling about the origin.
+     */
+    scale(this: void, section: Section, factors: number | Vec2): Section;
+    /**
+     * Nonsingular scaling about the origin.
+     *
+     * @example Scale
+     * ```ts
+     * scale(sphere({ radius: 8 }), [2, 1, 1]);
+     * ```
+     */
+    scale(this: void, solid: Solid, factors: number | Vec3): Solid;
+    /** Reflection across an origin line/plane. */
+    mirror(this: void, section: Section, normal: Vec2): Section;
+    /**
+     * Reflection across an origin line/plane.
+     *
+     * @example Mirror
+     * ```ts
+     * const block = translate(box({ size: [12, 8, 4] }), [10, 0, 0]);
+     * mirror(block, [1, 0, 0]);
+     * ```
+     */
+    mirror(this: void, solid: Solid, normal: Vec3): Solid;
+    /** Row-major affine transform preserving dimensionality. */
+    transform(this: void, section: Section, matrix: Transform2): Section;
+    /** Row-major affine transform preserving dimensionality. */
+    transform(this: void, solid: Solid, matrix: Transform3): Solid;
+    /**
+     * Reads a copied, immutable named anchor from this exact active build.
+     *
+     * @example Read the top datum
+     * ```ts
+     * const plate = box({ size: [30, 20, 6] });
+     * anchor(plate, "top"); // position [0, 0, 3], direction [0, 0, 1]
+     * ```
+     */
+    anchor(this: void, shape: Solid | Section, name: string): Anchor3;
+    /**
+     * Returns a new same-build handle with copied named anchors; existing names may be replaced.
+     */
+    withAnchors<T extends Solid | Section>(this: void, shape: T, anchors: Readonly<Record<string, Anchor3>>): T;
+    /**
+     * Places an explicit or named source anchor against an explicit target anchor.
+     *
+     * @example Anchor attachment
+     * ```ts
+     * const plate = box({ size: [30, 20, 6] });
+     * const pin = cylinder({ height: 12, radius: 3 });
+     * attach(pin, "bottom", anchor(plate, "top"), { gap: 1 });
+     * ```
+     */
+    attach(this: void, solid: Solid, source: Anchor3 | string, target: Anchor3, options?: AttachOptions): Solid;
+    /**
+     * Creates a native filled section without an intermediate Region2 conversion.
+     */
+    sectionFromContours(this: void, contours: readonly Loop2[], options?: SectionFromContoursOptions): Section;
+    /** Imports explicit region topology once. */
+    fromRegion(this: void, region: Region2): Section;
+    /** Explicit copied topology inspection; not needed for section operations. */
+    toRegion(this: void, section: Section): Region2;
+    /**
+     * Filled rectangular section with uniform or independently treated corners.
+     *
+     * @example Round the corners
+     * ```ts
+     * rectangle({ size: [30, 20], treatment: { kind: "round", radius: 3 } });
+     * ```
+     */
+    rectangle(this: void, options: RectangleOptions): Section;
+    /**
+     * Centered circular section.
+     *
+     * @example Size to polygon faces
+     * ```ts
+     * circle({ diameter: 12, sizing: "face" });
+     * ```
+     */
+    circle(this: void, options: CircleOptions): Section;
+    /**
+     * Centered elliptical section.
+     *
+     * @example Ellipse by full dimensions
+     * ```ts
+     * ellipse({ size: [30, 20] });
+     * ```
+     */
+    ellipse(this: void, options: EllipseOptions): Section;
+    /**
+     * Regular polygon with a vertex on +X.
+     *
+     * @example Hexagonal section
+     * ```ts
+     * regularPolygon({ radius: 10, sides: 6, sizing: "face" });
+     * ```
+     */
+    regularPolygon(this: void, options: RegularPolygonOptions): Section;
+    /**
+     * Alternating outer/inner star vertices.
+     *
+     * @example Five-point section
+     * ```ts
+     * star({ outerRadius: 12, innerRadius: 6, points: 5 });
+     * ```
+     */
+    star(this: void, options: StarOptions): Section;
+    /**
+     * Native millimetre offset preserving holes.
+     *
+     * @example Add a 2 mm margin
+     * ```ts
+     * const outline = rectangle({ size: [20, 12] });
+     * offset(outline, 2, { join: "round" });
+     * ```
+     */
+    offset(this: void, section: Section, distance: number, options?: RegionOffsetOptions): Section;
+    /**
+     * Extrudes along +Z with degree twist and top scaling.
+     *
+     * @example Extrude
+     * ```ts
+     * const outline = rectangle({ size: [30, 20], treatment: { kind: "round", radius: 3 } });
+     * extrude(outline, { height: 8 });
+     * ```
+     */
+    extrude(this: void, shape: ModelingShape, options: ExtrudeOptions): Solid;
+    /**
+     * Revolves a filled radial/Z shape around +Z, with caps for partial sweeps.
+     *
+     * @example Revolve
+     * ```ts
+     * // Contour coordinates are [radius, Z].
+     * const profile = sectionFromContours([[[8, 0], [12, 0], [12, 16], [8, 16]]]);
+     * revolve(profile, { revolveDegrees: 270 });
+     * ```
+     */
+    revolve(this: void, shape: ModelingShape, options?: RevolveOptions): Solid;
+    /** Filled XY projection. */
+    projectSection(this: void, solid: Solid): Section;
+    /** Horizontal filled slice. */
+    sliceSection(this: void, solid: Solid, z: number): Section;
+    /**
+     * 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 },
+     * ]);
+     * ```
+     */
+    loft(this: void, stations: readonly LoftStation[], options?: LoftOptions): Solid;
+    /** Lofts explicit corresponding contours, including holes and collapsed logical slots. */
+    loft(this: void, stations: readonly CorrespondingProfileStation[], options?: LoftOptions): Solid;
+    /** Explicit family matching on a shared physical span grid using context resolution. */
+    matchProfiles(this: void, profiles: readonly Profile[], options?: MatchProfilesOptions): readonly CorrespondingProfile[];
+    /**
+     * Sweeps filled or explicitly corresponding contours using the selected frame policy.
+     *
+     * @example Sweep
+     * ```ts
+     * const profile = rectangle({ size: [6, 3], treatment: { kind: "round", radius: 1 } });
+     * sweep(profile, [[0, 0, 0], [0, 0, 15], [10, 0, 25]], {
+     *   orientation: { kind: "transport", initialNormal: [0, 1, 0] },
+     * });
+     * ```
+     */
+    sweep(this: void, shape: ModelingShape, path: readonly Vec3[], options?: SweepOptions): Solid;
+    /**
+     * Copies lightweight section measurements.
+     *
+     * @example Check filled area
+     * ```ts
+     * const facts = inspectSection(rectangle({ size: [20, 10] }));
+     * facts.area; // 200 mm²
+     * ```
+     */
+    inspectSection(this: void, section: Section): SectionInspection;
+    /**
+     * Copies solid bounds and volume; 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³
+     * ```
+     */
+    inspectSolid(this: void, solid: Solid): SolidInspection;
+    /** Copies intersections along the finite directed origin-to-endpoint segment. */
+    rayCast(this: void, solid: Solid, origin: Vec3, endpoint: Vec3): readonly SolidRayHit[];
+    /** Returns same-build disconnected solid handles. */
+    components(this: void, solid: Solid): readonly Solid[];
+    /** Removes features within the explicit millimetre tolerance. */
+    simplify(this: void, solid: Solid, tolerance: number): Solid;
+    /** Bounded positive-inside implicit field constructor. */
+    implicit(this: void, options: ImplicitOptions): Solid;
+    /** Replaces native tolerance on an immutable copy; zero selects the kernel minimum. */
+    setTolerance(this: void, solid: Solid, tolerance: number): Solid;
+    /**
+     * Closed regular-grid top above a flat base; every height is sampled once.
+     *
+     * @example Heightfield
+     * ```ts
+     * heightfield({
+     *   size: [30, 20], segments: [24, 16],
+     *   height: ([x, y]) => 3 + Math.cos(x / 5) * Math.cos(y / 5),
+     * });
+     * ```
+     */
+    heightfield(this: void, options: HeightfieldOptions): Solid;
+    /**
+     * Repeats one solid along a normalized direction.
+     *
+     * @example Three copies along X
+     * ```ts
+     * linearPattern(box({ size: 4 }), { count: 3, spacing: 10 });
+     * ```
+     */
+    linearPattern(this: void, source: PatternSource, options: LinearPatternOptions): readonly Solid[];
+    /**
+     * Repeats one solid about an axis.
+     *
+     * @example Six copies around Z
+     * ```ts
+     * const pin = translate(cylinder({ height: 6, radius: 2 }), [12, 0, 0]);
+     * radialPattern(pin, { count: 6, axis: [0, 0, 1], angleDegrees: 60 });
+     * ```
+     */
+    radialPattern(this: void, source: PatternSource, options: RadialPatternOptions): readonly Solid[];
+    /**
+     * 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 });
+     * ```
+     */
+    gridPattern(this: void, source: PatternSource, options: GridPatternOptions): readonly Solid[];
+    /**
+     * 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 });
+     * ```
+     */
+    pathPattern(this: void, source: PatternSource, path: readonly Vec3[], options: PathPatternOptions): readonly Solid[];
+    /** Helical ridge mesh construction. */
+    threadRidge(this: void, options: ThreadRidgeOptions): Solid;
+    /**
+     * 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" });
+     * ```
+     */
+    threadedRod(this: void, options: ThreadedRodOptions): Solid;
+    /**
+     * Compensated internal threaded cutter.
+     *
+     * @example Internal thread
+     * ```ts
+     * import { cylinder, internalThreadCutter, subtract } 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 });
+     * subtract(body, [cutter]);
+     * ```
+     */
+    internalThreadCutter(this: void, options: InternalThreadCutterOptions): Solid;
+    /**
+     * 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" });
+     * ```
+     */
+    threadedNut(this: void, options: ThreadedNutOptions): Solid;
+    /** Allocation-free external-thread facts. */
+    preflightThreadedRod(this: void, options: ThreadedRodOptions): HelicalThreadSolidMeshPreflight;
+    /** Allocation-free internal-thread facts. */
+    preflightInternalThreadCutter(this: void, options: InternalThreadCutterOptions): HelicalThreadSolidMeshPreflight;
+    /** Allocation-free nut/cutter facts. */
+    preflightThreadedNut(this: void, options: ThreadedNutOptions): ThreadedNutPreflight;
+    /**
+     * 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);
+     * }
+     * ```
+     */
+    textSection(this: void, layout: VectorTextLayout, options?: TextSectionOptions): Section;
+    /**
+     * 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" },
+     * );
+     * ```
+     */
+    svgSection(this: void, svg: string, options?: SvgSectionOptions): Section;
+    /**
+     * Imports bounded filled SVG path data.
+     *
+     * @example Fill an SVG path in millimetres
+     * ```ts
+     * svgPathSection("M0 0H20V12H0Z", { origin: "center", scale: 1 });
+     * ```
+     */
+    svgPathSection(this: void, path: string, options?: SvgPathSectionOptions): Section;
+}
+
+/**
+ * Returns bound local operations, optionally with derived resolution, without changing imported operations.
+ */
+export declare function modelingFunctions(resolution?: GeometryResolution): ModelingContext;
+
+/** 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;
+}
+
+/** A native filled shape or sampled profile with explicit contour identities. */
+export declare type ModelingShape = Section | CorrespondingProfile;
+
+/** Named manufacturing output containing exactly one solid or direct mesh. */
+export declare type ModelPart = SolidPart | MeshPart;
+
+/** Host-bound offset operation. Valid only during a synchronous build. */
+export declare const offset: ModelingContext["offset"];
+
+/**
+ * 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;
+
+/** Host-bound pathPattern operation. Valid only during a synchronous build. */
+export declare const pathPattern: ModelingContext["pathPattern"];
+
+/** 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-build shape, or a synchronous factory called once per copy in index order.
+ */
+export declare type PatternSource = Solid | ((index: number) => Solid);
+
+/**
+ * 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;
+}
+
+/** Host-bound preflightInternalThreadCutter operation. Valid only during a synchronous build. */
+export declare const preflightInternalThreadCutter: ModelingContext["preflightInternalThreadCutter"];
+
+/** Host-bound preflightThreadedNut operation. Valid only during a synchronous build. */
+export declare const preflightThreadedNut: ModelingContext["preflightThreadedNut"];
+
+/** Host-bound preflightThreadedRod operation. Valid only during a synchronous build. */
+export declare const preflightThreadedRod: ModelingContext["preflightThreadedRod"];
+
+/** 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;
+});
+
+/** Host-bound projectSection operation. Valid only during a synchronous build. */
+export declare const projectSection: ModelingContext["projectSection"];
+
+/** Host-bound radialPattern operation. Valid only during a synchronous build. */
+export declare const radialPattern: ModelingContext["radialPattern"];
+
+/**
+ * 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 a finite directed ray segment during the active build. */
+export declare const rayCast: ModelingContext["rayCast"];
+
+/** Host-bound rectangle operation. Valid only during a synchronous build. */
+export declare const rectangle: ModelingContext["rectangle"];
+
+/** 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;
+}
+
+/** Host-bound regularPolygon operation. Valid only during a synchronous build. */
+export declare const regularPolygon: ModelingContext["regularPolygon"];
+
+/**
+ * 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;
+};
+
+/** Host-bound revolve operation. Valid only during a synchronous build. */
+export declare const revolve: ModelingContext["revolve"];
+
+/**
+ * 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>;
+}
+
+/** Host-bound rotate operation. Valid only during a synchronous build. */
+export declare const rotate: ModelingContext["rotate"];
+
+/**
+ * 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;
+}
+
+/** Host-bound scale operation. Valid only during a synchronous build. */
+export declare const scale: ModelingContext["scale"];
+
+/** Immutable native filled XY section belonging to exactly one synchronous engine build. */
+export declare interface Section {
+    /** Compile-time ownership brand for a same-build section. */
+    readonly [sectionBrand]: "Section";
+}
+
+declare const sectionBrand: unique symbol;
+
+/** Host-bound sectionFromContours operation. Valid only during a synchronous build. */
+export declare const sectionFromContours: ModelingContext["sectionFromContours"];
+
+/**
+ * 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";
+}
+
+/**
+ * Copied native filled section facts in millimetres and square millimetres.
+ */
+export declare interface SectionInspection {
+    /** 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;
+}
+
+/** Returns an immutable copy with the explicit native millimetre tolerance. */
+export declare const setTolerance: ModelingContext["setTolerance"];
+
+/** Host-bound simplify operation. Valid only during a synchronous build. */
+export declare const simplify: ModelingContext["simplify"];
+
+/** Host-bound sliceSection operation. Valid only during a synchronous build. */
+export declare const sliceSection: ModelingContext["sliceSection"];
+
+/** 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 solid handle belonging to exactly one synchronous engine build. */
+export declare interface Solid {
+    /** Compile-time ownership brand for a same-build solid. */
+    readonly [solidBrand]: "Solid";
+}
+
+declare const solidBrand: unique symbol;
+
+/** Host-bound solidFromMesh operation. Valid only during a synchronous build. */
+export declare const solidFromMesh: ModelingContext["solidFromMesh"];
+
+/**
+ * Copied solid bounds, connected component count, and cubic millimetre volume.
+ */
+export declare interface SolidInspection {
+    /** Inclusive maximum coordinates in millimetres. */
+    readonly max: Vec3;
+    /** Inclusive minimum coordinates in millimetres. */
+    readonly min: Vec3;
+    /** Number of connected native solid components. */
+    readonly parts: number;
+    /** Enclosed native solid volume in cubic millimetres. */
+    readonly volume: number;
+}
+
+/** Named same-build solid manufacturing part. */
+export declare interface SolidPart {
+    /** Stable canonical lowercase identity; unique within the containing topology or output. */
+    readonly id: string;
+    /** Optional six-digit hex RGB display color. */
+    readonly color?: string;
+    /** Same-build solid handle; mutually exclusive with a direct mesh. */
+    readonly solid: Solid;
+    /** Direct manufacturing mesh; mutually exclusive with a solid handle. */
+    readonly mesh?: never;
+}
+
+/** 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;
+}
+
+/** Host-bound sphere operation. Valid only during a synchronous build. */
+export declare const sphere: ModelingContext["sphere"];
+
+/**
+ * Exactly one radius or diameter, placement, and tessellation for an origin-centered sphere.
+ */
+export declare type SphereOptions = CircularPrimitiveOptions & PrimitivePlacement & ({
+    /** Positive radius in millimetres; mutually exclusive with diameter. */
+    readonly radius: number;
+    /** Full diameter is unavailable when radius is supplied. */
+    readonly diameter?: never;
+} | {
+    /** Positive full diameter in millimetres; mutually exclusive with radius. */
+    readonly diameter: number;
+    /** Radius is unavailable when diameter is supplied. */
+    readonly radius?: never;
+});
+
+/** Square profile with equal crest and root widths. */
+declare interface SquareThreadProfileSpec extends ThreadProfileBaseSpec {
+    /** Selects the square profile family. */
+    readonly kind: "square";
+    /**
+     * Radial depth in millimetres.
+     * @defaultValue `pitch / 2`
+     */
+    readonly depth?: number;
+}
+
+/** Host-bound star operation. Valid only during a synchronous build. */
+export declare const star: ModelingContext["star"];
+
+/**
+ * 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;
+}
+
+/** Host-bound subtract operation. Valid only during a synchronous build. */
+export declare const subtract: ModelingContext["subtract"];
+
+/** Placement of painted SVG geometry after SVG Y-axis inversion. */
+export declare type SvgOrigin = "center" | "document";
+
+/** Host-bound svgPathSection operation. Valid only during a synchronous build. */
+export declare const svgPathSection: ModelingContext["svgPathSection"];
+
+/** 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;
+}
+
+/** Host-bound svgSection operation. Valid only during a synchronous build. */
+export declare const svgSection: ModelingContext["svgSection"];
+
+/**
+ * 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;
+}
+
+/** Host-bound sweep operation. Valid only during a synchronous build. */
+export declare const sweep: ModelingContext["sweep"];
+
+/**
+ * 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";
+};
+
+/** Host-bound textSection operation. Valid only during a synchronous build. */
+export declare const textSection: ModelingContext["textSection"];
+
+/**
+ * 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;
+}
+
+/** Host-bound threadedNut operation. Valid only during a synchronous build. */
+export declare const threadedNut: ModelingContext["threadedNut"];
+
+/** 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";
+
+/** Host-bound threadedRod operation. Valid only during a synchronous build. */
+export declare const threadedRod: ModelingContext["threadedRod"];
+
+/**
+ * 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;
+
+/** Host-bound threadRidge operation. Valid only during a synchronous build. */
+export declare const threadRidge: ModelingContext["threadRidge"];
+
+/** Parameters for a helical ridge before solid construction. */
+export declare type ThreadRidgeOptions = HelicalThreadRidgeMeshOptions;
+
+/** Host-bound toRegion operation. Valid only during a synchronous build. */
+export declare const toRegion: ModelingContext["toRegion"];
+
+/** Host-bound torus operation. Valid only during a synchronous build. */
+export declare const torus: ModelingContext["torus"];
+
+/**
+ * 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;
+}
+
+/** Host-bound toTriangleMesh operation. Valid only during a synchronous build. */
+export declare const toTriangleMesh: ModelingContext["toTriangleMesh"];
+
+/** Host-bound transform operation. Valid only during a synchronous build. */
+export declare const transform: ModelingContext["transform"];
+
+/** 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
+];
+
+/** Host-bound translate operation. Valid only during a synchronous build. */
+export declare const translate: ModelingContext["translate"];
+
+/** 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;
+}
+
+/** Host-bound tube operation. Valid only during a synchronous build. */
+export declare const tube: ModelingContext["tube"];
+
+/**
+ * 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;
+}
+
+/** Host-bound union operation. Valid only during a synchronous build. */
+export declare const union: ModelingContext["union"];
+
+/** 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 pen displacement: final line advance and negative baseline displacement, in mm. */
+    readonly advance: readonly [number, number];
+    /** Maximum line advance in millimetres, including spaces; distinct from visible ink width. */
+    readonly logicalWidth: number;
+    /** Selected font's ascender distance above a baseline in millimetres, independent of the text. */
+    readonly ascent: number;
+    /** Selected font's descender distance below a baseline in millimetres, a non-negative value. */
+    readonly descent: number;
+    /** Actual distance between baselines in millimetres. */
+    readonly lineHeight: number;
+    /** Number of lines, including empty and trailing lines; empty text occupies one line. */
+    readonly lineCount: number;
+}
+
+/** Returns a new same-build shape handle with explicit copied named anchors. */
+export declare const withAnchors: ModelingContext["withAnchors"];
+
+export { }