@metamesh/modeling 0.9.0 → 0.11.0

package/dist/api/index.d.ts

@@ -11,8 +11,16 @@ declare interface AcmeThreadProfileSpec extends ThreadProfileBaseSpec {
     readonly depth?: number;
 }
 
-/** Reads one immutable named anchor from a shape in the active build. */
-export declare const anchor: ModelingContext["anchor"];
+/**
+ * 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.
@@ -29,9 +37,6 @@ export declare interface Anchor3 {
     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.
  */
@@ -46,8 +51,15 @@ export declare interface AttachOptions {
     readonly tolerance?: GeometryToleranceOptions;
 }
 
-/** Host-bound box operation. Valid only during a synchronous build. */
-export declare const box: ModelingContext["box"];
+/**
+ * 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";
@@ -75,9 +87,6 @@ export declare interface BoxOptions extends PrimitivePlacement {
     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";
 
@@ -108,8 +117,15 @@ export declare interface ChamferedEdgeTreatment {
     readonly distance: number | readonly [first: number, second: number];
 }
 
-/** Host-bound circle operation. Valid only during a synchronous build. */
-export declare const circle: ModelingContext["circle"];
+/**
+ * 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.
@@ -148,11 +164,41 @@ export declare interface CircularPrimitiveOptions {
     readonly resolution?: GeometryResolution;
 }
 
-/** Host-bound components operation. Valid only during a synchronous build. */
-export declare const components: ModelingContext["components"];
+/**
+ * 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;
 
-/** Host-bound compose operation. Valid only during a synchronous build. */
-export declare const compose: ModelingContext["compose"];
+/** 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 {
@@ -197,8 +243,20 @@ declare interface CustomThreadProfileSpec extends ThreadProfileBaseSpec {
     readonly points: readonly Vec2[];
 }
 
-/** Host-bound cylinder operation. Valid only during a synchronous build. */
-export declare const cylinder: ModelingContext["cylinder"];
+/**
+ * +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.
@@ -225,16 +283,43 @@ export declare type CylinderOptions = CircularPrimitiveOptions & RadialSizingOpt
     readonly radius?: never;
 });
 
-/** Measures the minimum separation between two nonempty solids in millimetres. */
-export declare const distance: ModelingContext["distance"];
+/** 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;
 
-/** Host-bound ellipse operation. Valid only during a synchronous build. */
-export declare const ellipse: ModelingContext["ellipse"];
+/**
+ * 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.
@@ -266,8 +351,20 @@ export declare interface EndTreatments {
     readonly top?: EdgeTreatment;
 }
 
-/** Host-bound extrude operation. Valid only during a synchronous build. */
-export declare const extrude: ModelingContext["extrude"];
+/**
+ * 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.
@@ -342,8 +439,73 @@ export declare interface Frame3 {
     readonly zAxis: Vec3;
 }
 
-/** Host-bound fromRegion operation. Valid only during a synchronous build. */
-export declare const fromRegion: ModelingContext["fromRegion"];
+/** 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; capture changing locals through explicit bindings. */
+    readonly computed: {
+        <T>(id: string, callback: () => T): Computed<T>;
+        <B extends Readonly<Record<string, unknown>>, T>(id: string, bindings: B, callback: (bindings: B) => T): 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.
@@ -383,8 +545,15 @@ export declare interface GeometryToleranceOptions {
     readonly relative?: number;
 }
 
-/** Host-bound gridPattern operation. Valid only during a synchronous build. */
-export declare const gridPattern: ModelingContext["gridPattern"];
+/**
+ * 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.
@@ -406,8 +575,19 @@ export declare type GridPatternOptions = {
     readonly spacing: Vec3;
 });
 
-/** Constructs a closed rectilinear heightfield during the active synchronous build. */
-export declare const heightfield: ModelingContext["heightfield"];
+/**
+ * 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.
@@ -497,10 +677,22 @@ export declare interface HelicalThreadSolidMeshPreflight {
     readonly estimatedTriangles: number;
 }
 
-/** Host-bound hull operation. Valid only during a synchronous build. */
-export declare const hull: ModelingContext["hull"];
+/**
+ * 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-build solids. */
+/** 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[];
@@ -513,8 +705,60 @@ export declare type HullOptions = {
     readonly points?: never;
 };
 
-/** Host-bound implicit operation. Valid only during a synchronous build. */
-export declare const implicit: ModelingContext["implicit"];
+/** 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 {
@@ -530,14 +774,42 @@ export declare interface ImplicitOptions {
     readonly tolerance?: number;
 }
 
-/** Host-bound inspectSection operation. Valid only during a synchronous build. */
-export declare const inspectSection: ModelingContext["inspectSection"];
+/**
+ * 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;
 
-/** Host-bound inspectSolid operation. Valid only during a synchronous build. */
-export declare const inspectSolid: ModelingContext["inspectSolid"];
+/**
+ * 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;
 
-/** Host-bound internalThreadCutter operation. Valid only during a synchronous build. */
-export declare const internalThreadCutter: ModelingContext["internalThreadCutter"];
+/**
+ * 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 {
@@ -547,14 +819,44 @@ export declare interface InternalThreadCutterOptions extends Omit<HelicalThreadR
     readonly nominalMajorDiameter: number;
 }
 
-/** Host-bound intersect operation. Valid only during a synchronous build. */
-export declare const intersect: ModelingContext["intersect"];
+/**
+ * Robust intersection.
+ *
+ * @example Intersect
+ * ```ts
+ * intersect([box({ size: 20 }), sphere({ radius: 12 })]);
+ * ```
+ */
+export declare function intersect(solids: readonly Solid[]): Solid;
 
-/** Tests a solid or filled section in the active build, including expected empty Boolean results. */
-export declare const isEmpty: ModelingContext["isEmpty"];
+/** 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;
 
-/** Host-bound linearPattern operation. Valid only during a synchronous build. */
-export declare const linearPattern: ModelingContext["linearPattern"];
+/**
+ * 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.
@@ -585,10 +887,35 @@ export declare type LinearPatternOptions = {
     readonly count?: never;
 });
 
-/** Host-bound loft operation. Valid only during a synchronous build. */
-export declare const loft: ModelingContext["loft"];
+/**
+ * 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;
 
-/** Deterministic ordered edge subdivision or bounded geometric vertex association. */
+/**
+ * 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";
 
 /**
@@ -640,8 +967,8 @@ export declare type LoftStation = LoftPlacement & {
  */
 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 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 {
@@ -661,615 +988,8 @@ export declare interface MeshBounds {
     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;
-    /**
-     * 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([translate(plug, [0, -20, 0]), remainder]);
-     * ```
-     */
-    split(this: void, 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([translate(right, [4, 0, 0]), translate(left, [-4, 0, 0])]);
-     * ```
-     *
-     * @example Keep only the positive half
-     * ```ts
-     * const [right] = splitByPlane(box({ size: [30, 20, 8] }), { normal: [1, 0, 0] });
-     * right;
-     * ```
-     */
-    splitByPlane(this: void, solid: Solid, plane: PlaneOptions): readonly [Solid, Solid];
-    /** 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;
-    /** Convex filled XY hull of finite points or same-build sections. */
-    hull(this: void, options: SectionHullOptions): Section;
-    /** 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;
-    /**
-     * 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³
-     * ```
-     */
-    inspectSolid(this: void, solid: Solid): SolidInspection;
-    /**
-     * Checks whether a same-build 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 = translate(box({ size: 10 }), [30, 0, 0]);
-     * const empty = intersect([body, distant]);
-     * const missed = isEmpty(empty); // true
-     * ```
-     */
-    isEmpty(this: void, shape: Solid | Section): boolean;
-    /**
-     * 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 = translate(box({ size: 10 }), [13, 0, 0]);
-     * const gap = distance(left, right); // 3 mm
-     * ```
-     */
-    distance(this: void, solid: Solid, other: Solid): number;
-    /** Copies intersections along the finite directed origin-to-endpoint segment. */
-    rayCast(this: void, solid: Solid, origin: Vec3, endpoint: Vec3): readonly SolidRayHit[];
-    /**
-     * Separates a solid's disconnected surface shells into same-build 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 }), translate(box({ size: 8 }), [12, 0, 0])]);
-     * const pieces = components(islands);
-     * // Component order is unspecified; the index only sets a display height here.
-     * union(pieces.map((piece, index) => translate(piece, [0, 0, index * 6])));
-     * ```
-     */
-    components(this: void, solid: Solid): readonly Solid[];
-    /** Separates filled 2D islands into sections, retaining each island's holes; empty gives []. */
-    components(this: void, section: Section): readonly Section[];
-    /**
-     * 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: void, solid: Solid, tolerance: number): Solid;
-    /**
-     * 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.
-     *
-     * @example Clean a dense outline before extrusion
-     * ```ts
-     * const outline = circle({ diameter: 20, segments: 256 });
-     * const cleaned = simplify(outline, 0.05); // 0.05 mm cleanup tolerance
-     * const body = extrude(cleaned, { height: 3 });
-     * ```
-     */
-    simplify(this: void, section: Section, tolerance: number): Section;
-    /** 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 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),
-     * });
-     * ```
-     */
-    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;
+/** 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 {
@@ -1283,14 +1003,31 @@ export declare interface ModelingLimits extends GeometrySamplingLimits {
     readonly maxBytes: number;
 }
 
-/** A native filled shape or sampled profile with explicit contour identities. */
-export declare type ModelingShape = Section | CorrespondingProfile;
+/** 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>;
+}
 
-/** Named manufacturing output containing exactly one solid or direct mesh. */
-export declare type ModelPart = SolidPart | MeshPart;
+/** Numeric storage supported by immutable generation buffers. */
+export declare type NumericArray = Float32Array | Float64Array | Uint32Array | Uint8Array | Int32Array;
 
-/** Host-bound offset operation. Valid only during a synchronous build. */
-export declare const offset: ModelingContext["offset"];
+/** 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.
@@ -1301,8 +1038,15 @@ export declare const offset: ModelingContext["offset"];
  */
 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"];
+/**
+ * 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 {
@@ -1315,7 +1059,7 @@ export declare interface PathPatternOptions {
 }
 
 /**
- * One same-build shape, or a synchronous factory called once per copy in index order.
+ * One same-session shape, or a synchronous factory called once per copy in index order.
  */
 export declare type PatternSource = Solid | ((index: number) => Solid);
 
@@ -1341,14 +1085,14 @@ export declare interface Polygon2 {
     readonly outer: Loop2;
 }
 
-/** Host-bound preflightInternalThreadCutter operation. Valid only during a synchronous build. */
-export declare const preflightInternalThreadCutter: ModelingContext["preflightInternalThreadCutter"];
+/** Allocation-free internal-thread facts. */
+export declare function preflightInternalThreadCutter(options: InternalThreadCutterOptions): HelicalThreadSolidMeshPreflight;
 
-/** Host-bound preflightThreadedNut operation. Valid only during a synchronous build. */
-export declare const preflightThreadedNut: ModelingContext["preflightThreadedNut"];
+/** Allocation-free nut/cutter facts. */
+export declare function preflightThreadedNut(options: ThreadedNutOptions): ThreadedNutPreflight;
 
-/** Host-bound preflightThreadedRod operation. Valid only during a synchronous build. */
-export declare const preflightThreadedRod: ModelingContext["preflightThreadedRod"];
+/** Allocation-free external-thread facts. */
+export declare function preflightThreadedRod(options: ThreadedRodOptions): HelicalThreadSolidMeshPreflight;
 
 /** Placement shared by solid and filled-section factories. */
 export declare interface PrimitivePlacement {
@@ -1468,11 +1212,16 @@ export declare type ProfileSpan2 = {
     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"];
+/**
+ * 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.
@@ -1503,11 +1252,18 @@ export declare interface RadialSizingOptions {
     readonly sizing?: RadialSizing;
 }
 
-/** Copies intersections along a finite directed ray segment during the active build. */
-export declare const rayCast: ModelingContext["rayCast"];
+/** Copies intersections along the finite directed origin-to-endpoint segment. */
+export declare function rayCast(solid: Solid, origin: Vec3, endpoint: Vec3): readonly SolidRayHit[];
 
-/** Host-bound rectangle operation. Valid only during a synchronous build. */
-export declare const rectangle: ModelingContext["rectangle"];
+/**
+ * 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 | {
@@ -1561,8 +1317,15 @@ export declare interface RegionOffsetOptions {
     readonly resolution?: GeometryResolution;
 }
 
-/** Host-bound regularPolygon operation. Valid only during a synchronous build. */
-export declare const regularPolygon: ModelingContext["regularPolygon"];
+/**
+ * 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.
@@ -1576,8 +1339,21 @@ export declare type RegularPolygonOptions = RadialSizingOptions & PrimitivePlace
     readonly rotationDegrees?: number;
 };
 
-/** Host-bound revolve operation. Valid only during a synchronous build. */
-export declare const revolve: ModelingContext["revolve"];
+/**
+ * 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.
@@ -1594,9 +1370,6 @@ export declare interface RevolveOptions extends CircularPrimitiveOptions {
     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.
  */
@@ -1607,19 +1380,72 @@ export declare interface RoundedEdgeTreatment extends CircularPrimitiveOptions {
     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. */
+/**
+ * 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-build 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;
 
-/** Host-bound sectionFromContours operation. Valid only during a synchronous build. */
-export declare const sectionFromContours: ModelingContext["sectionFromContours"];
+/**
+ * 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.
@@ -1629,14 +1455,14 @@ export declare interface SectionFromContoursOptions {
     readonly fillRule?: "nonzero" | "evenodd";
 }
 
-/** Planar convex hull inputs are finite XY points or same-build filled sections. */
+/** 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-build sections to include in the convex hull. */
+    /** One through 1000 same-session sections to include in the convex hull. */
     readonly sections: readonly Section[];
     /** Section input excludes point input. */
     readonly points?: never;
@@ -1644,7 +1470,7 @@ export declare type SectionHullOptions = {
 
 /**
  * Immutable native filled section facts in millimetres and square millimetres.
- * Repeated inspections of the same native shape share these facts within one build.
+ * 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. */
@@ -1663,15 +1489,6 @@ export declare interface SectionInspection {
     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. */
@@ -1686,20 +1503,85 @@ export declare interface SmoothEdgeTreatment {
     readonly limits?: Partial<GeometrySamplingLimits>;
 }
 
-/** Immutable solid handle belonging to exactly one synchronous engine build. */
+/**
+ * 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-build 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;
 
-/** Host-bound solidFromMesh operation. Valid only during a synchronous build. */
-export declare const solidFromMesh: ModelingContext["solidFromMesh"];
+/**
+ * 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 build.
+ * Repeated inspections of the same native shape share these facts within one revision.
  */
 export declare interface SolidInspection {
     /** Whether this native solid contains no material. */
@@ -1718,18 +1600,6 @@ export declare interface SolidInspection {
     readonly tolerance: 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. */
@@ -1742,8 +1612,15 @@ export declare interface SolidRayHit {
     readonly normal: Vec3;
 }
 
-/** Host-bound sphere operation. Valid only during a synchronous build. */
-export declare const sphere: ModelingContext["sphere"];
+/**
+ * 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.
@@ -1760,11 +1637,45 @@ export declare type SphereOptions = CircularPrimitiveOptions & PrimitivePlacemen
     readonly radius?: never;
 });
 
-/** Returns intersection and difference with a same-build cutter, including empty results. */
-export declare const split: ModelingContext["split"];
+/**
+ * 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 the normal-side and opposite-side halves of a world-space plane. */
-export declare const splitByPlane: ModelingContext["splitByPlane"];
+/**
+ * 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 {
@@ -1777,8 +1688,15 @@ declare interface SquareThreadProfileSpec extends ThreadProfileBaseSpec {
     readonly depth?: number;
 }
 
-/** Host-bound star operation. Valid only during a synchronous build. */
-export declare const star: ModelingContext["star"];
+/**
+ * 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.
@@ -1796,14 +1714,18 @@ export declare interface StarOptions extends PrimitivePlacement {
     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"];
+/**
+ * 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 {
@@ -1819,8 +1741,18 @@ export declare interface SvgPathSectionOptions {
     readonly scale?: number;
 }
 
-/** Host-bound svgSection operation. Valid only during a synchronous build. */
-export declare const svgSection: ModelingContext["svgSection"];
+/**
+ * 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.
@@ -1836,8 +1768,22 @@ export declare interface SvgSectionOptions {
     readonly origin?: SvgOrigin;
 }
 
-/** Host-bound sweep operation. Valid only during a synchronous build. */
-export declare const sweep: ModelingContext["sweep"];
+/**
+ * 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.
@@ -1884,8 +1830,18 @@ export declare type SweepOrientation = {
     readonly kind: "frenet";
 };
 
-/** Host-bound textSection operation. Valid only during a synchronous build. */
-export declare const textSection: ModelingContext["textSection"];
+/**
+ * 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.
@@ -1910,8 +1866,19 @@ declare interface ThreadBevelOptions {
     readonly bevelTop?: boolean;
 }
 
-/** Host-bound threadedNut operation. Valid only during a synchronous build. */
-export declare const threadedNut: ModelingContext["threadedNut"];
+/**
+ * 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";
@@ -1959,8 +1926,19 @@ export declare interface ThreadedNutPreflight {
  */
 export declare type ThreadedNutShape = "hex" | "round" | "square";
 
-/** Host-bound threadedRod operation. Valid only during a synchronous build. */
-export declare const threadedRod: ModelingContext["threadedRod"];
+/**
+ * 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.
@@ -2054,17 +2032,24 @@ declare interface ThreadProfileBaseSpec {
  */
 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"];
+/** Helical ridge mesh construction. */
+export declare function threadRidge(options: ThreadRidgeOptions): Solid;
 
 /** 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"];
+/** Explicit copied topology inspection; not needed for section operations. */
+export declare function toRegion(section: Section): Region2;
 
-/** Host-bound torus operation. Valid only during a synchronous build. */
-export declare const torus: ModelingContext["torus"];
+/**
+ * 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.
@@ -2084,11 +2069,8 @@ export declare interface TorusOptions extends PrimitivePlacement {
     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"];
+/** 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 [
@@ -2128,9 +2110,6 @@ 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. */
@@ -2201,8 +2180,15 @@ declare interface TriangularThreadProfileSpec extends ThreadProfileBaseSpec {
     readonly rootFlatRatio?: number;
 }
 
-/** Host-bound tube operation. Valid only during a synchronous build. */
-export declare const tube: ModelingContext["tube"];
+/**
+ * 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.
@@ -2221,8 +2207,20 @@ export declare interface TubeOptions extends CircularPrimitiveOptions, Primitive
     readonly outerRadius: number;
 }
 
-/** Host-bound union operation. Valid only during a synchronous build. */
-export declare const union: ModelingContext["union"];
+/**
+ * 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];
@@ -2266,7 +2264,4 @@ export declare interface VectorTextMetrics {
     readonly lineCount: number;
 }
 
-/** Returns a new same-build shape handle with explicit copied named anchors. */
-export declare const withAnchors: ModelingContext["withAnchors"];
-
 export { }