@metamesh/modeling 0.10.0 → 0.11.0

package/dist/model/operations.js

@@ -1,161 +1,522 @@
+import { GeometryError } from "../geometry/errors.js";
 import { currentModelContext } from "./execution-binding.js";
-function operation(name) {
-    const invoke = (...args) => {
-        const context = currentModelContext(name);
-        const method = context[name];
-        return Reflect.apply(method, undefined, args);
-    };
-    return invoke;
-}
-/** Matches an explicit profile family using the current build's physical resolution. */
-export const matchProfiles = 
-/* @__PURE__ */ operation("matchProfiles");
-/** Copies intersections along a finite directed ray segment during the active build. */
-export const rayCast = /* @__PURE__ */ operation("rayCast");
-/**
- * Returns bound local operations, optionally with derived resolution, without changing imported operations.
- */
-export function modelingFunctions(resolution) {
-    const context = currentModelContext("modelingFunctions");
-    return resolution === undefined ? context : context.withResolution(resolution);
-}
-/** Host-bound box operation. Valid only during a synchronous build. */
-export const box = /* @__PURE__ */ operation("box");
-/** Constructs a closed rectilinear heightfield during the active synchronous build. */
-export const heightfield = /* @__PURE__ */ operation("heightfield");
-/** Returns an immutable copy with the explicit native millimetre tolerance. */
-export const setTolerance = 
-/* @__PURE__ */ operation("setTolerance");
-/** Host-bound cylinder operation. Valid only during a synchronous build. */
-export const cylinder = /* @__PURE__ */ operation("cylinder");
-/** Host-bound tube operation. Valid only during a synchronous build. */
-export const tube = /* @__PURE__ */ operation("tube");
-/** Host-bound sphere operation. Valid only during a synchronous build. */
-export const sphere = /* @__PURE__ */ operation("sphere");
-/** Host-bound torus operation. Valid only during a synchronous build. */
-export const torus = /* @__PURE__ */ operation("torus");
-/** Host-bound union operation. Valid only during a synchronous build. */
-export const union = /* @__PURE__ */ operation("union");
-/** Host-bound subtract operation. Valid only during a synchronous build. */
-export const subtract = /* @__PURE__ */ operation("subtract");
-/** Host-bound intersect operation. Valid only during a synchronous build. */
-export const intersect = /* @__PURE__ */ operation("intersect");
-/** Returns intersection and difference with a same-build cutter, including empty results. */
-export const split = /* @__PURE__ */ operation("split");
-/** Splits a solid into the normal-side and opposite-side halves of a world-space plane. */
-export const splitByPlane = 
-/* @__PURE__ */ operation("splitByPlane");
-/** Host-bound compose operation. Valid only during a synchronous build. */
-export const compose = /* @__PURE__ */ operation("compose");
-/** Host-bound hull operation. Valid only during a synchronous build. */
-export const hull = /* @__PURE__ */ operation("hull");
-/** Host-bound minkowskiSum operation. Valid only during a synchronous build. */
-export const minkowskiSum = 
-/* @__PURE__ */ operation("minkowskiSum");
-/** Host-bound solidFromMesh operation. Valid only during a synchronous build. */
-export const solidFromMesh = 
-/* @__PURE__ */ operation("solidFromMesh");
-/** Host-bound toTriangleMesh operation. Valid only during a synchronous build. */
-export const toTriangleMesh = 
-/* @__PURE__ */ operation("toTriangleMesh");
-/** Host-bound translate operation. Valid only during a synchronous build. */
-export const translate = /* @__PURE__ */ operation("translate");
-/** Host-bound rotate operation. Valid only during a synchronous build. */
-export const rotate = /* @__PURE__ */ operation("rotate");
-/** Host-bound scale operation. Valid only during a synchronous build. */
-export const scale = /* @__PURE__ */ operation("scale");
-/** Host-bound mirror operation. Valid only during a synchronous build. */
-export const mirror = /* @__PURE__ */ operation("mirror");
-/** Host-bound transform operation. Valid only during a synchronous build. */
-export const transform = /* @__PURE__ */ operation("transform");
-/** Host-bound fromRegion operation. Valid only during a synchronous build. */
-export const fromRegion = /* @__PURE__ */ operation("fromRegion");
-/** Host-bound toRegion operation. Valid only during a synchronous build. */
-export const toRegion = /* @__PURE__ */ operation("toRegion");
-/** Host-bound rectangle operation. Valid only during a synchronous build. */
-export const rectangle = /* @__PURE__ */ operation("rectangle");
-/** Host-bound circle operation. Valid only during a synchronous build. */
-export const circle = /* @__PURE__ */ operation("circle");
-/** Host-bound regularPolygon operation. Valid only during a synchronous build. */
-export const regularPolygon = 
-/* @__PURE__ */ operation("regularPolygon");
-/** Host-bound star operation. Valid only during a synchronous build. */
-export const star = /* @__PURE__ */ operation("star");
-/** Host-bound extrude operation. Valid only during a synchronous build. */
-export const extrude = /* @__PURE__ */ operation("extrude");
-/** Host-bound revolve operation. Valid only during a synchronous build. */
-export const revolve = /* @__PURE__ */ operation("revolve");
-/** Host-bound projectSection operation. Valid only during a synchronous build. */
-export const projectSection = 
-/* @__PURE__ */ operation("projectSection");
-/** Host-bound sliceSection operation. Valid only during a synchronous build. */
-export const sliceSection = 
-/* @__PURE__ */ operation("sliceSection");
-/** Host-bound loft operation. Valid only during a synchronous build. */
-export const loft = /* @__PURE__ */ operation("loft");
-/** Host-bound sweep operation. Valid only during a synchronous build. */
-export const sweep = /* @__PURE__ */ operation("sweep");
-/** Host-bound inspectSection operation. Valid only during a synchronous build. */
-export const inspectSection = 
-/* @__PURE__ */ operation("inspectSection");
-/** Host-bound inspectSolid operation. Valid only during a synchronous build. */
-export const inspectSolid = 
-/* @__PURE__ */ operation("inspectSolid");
-/** Tests a solid or filled section in the active build, including expected empty Boolean results. */
-export const isEmpty = /* @__PURE__ */ operation("isEmpty");
-/** Measures the minimum separation between two nonempty solids in millimetres. */
-export const distance = /* @__PURE__ */ operation("distance");
-/** Host-bound components operation. Valid only during a synchronous build. */
-export const components = /* @__PURE__ */ operation("components");
-/** Host-bound simplify operation. Valid only during a synchronous build. */
-export const simplify = /* @__PURE__ */ operation("simplify");
-/** Host-bound implicit operation. Valid only during a synchronous build. */
-export const implicit = /* @__PURE__ */ operation("implicit");
-/** Host-bound linearPattern operation. Valid only during a synchronous build. */
-export const linearPattern = 
-/* @__PURE__ */ operation("linearPattern");
-/** Host-bound radialPattern operation. Valid only during a synchronous build. */
-export const radialPattern = 
-/* @__PURE__ */ operation("radialPattern");
-/** Host-bound gridPattern operation. Valid only during a synchronous build. */
-export const gridPattern = /* @__PURE__ */ operation("gridPattern");
-/** Host-bound pathPattern operation. Valid only during a synchronous build. */
-export const pathPattern = /* @__PURE__ */ operation("pathPattern");
-/** Host-bound threadRidge operation. Valid only during a synchronous build. */
-export const threadRidge = /* @__PURE__ */ operation("threadRidge");
-/** Host-bound threadedRod operation. Valid only during a synchronous build. */
-export const threadedRod = /* @__PURE__ */ operation("threadedRod");
-/** Host-bound internalThreadCutter operation. Valid only during a synchronous build. */
-export const internalThreadCutter = 
-/* @__PURE__ */ operation("internalThreadCutter");
-/** Host-bound threadedNut operation. Valid only during a synchronous build. */
-export const threadedNut = /* @__PURE__ */ operation("threadedNut");
-/** Host-bound preflightThreadedRod operation. Valid only during a synchronous build. */
-export const preflightThreadedRod = 
-/* @__PURE__ */ operation("preflightThreadedRod");
-/** Host-bound preflightThreadedNut operation. Valid only during a synchronous build. */
-export const preflightThreadedNut = 
-/* @__PURE__ */ operation("preflightThreadedNut");
-/** Host-bound textSection operation. Valid only during a synchronous build. */
-export const textSection = /* @__PURE__ */ operation("textSection");
-/** Host-bound svgSection operation. Valid only during a synchronous build. */
-export const svgSection = /* @__PURE__ */ operation("svgSection");
-/** Host-bound svgPathSection operation. Valid only during a synchronous build. */
-export const svgPathSection = 
-/* @__PURE__ */ operation("svgPathSection");
-/** Host-bound attach operation. Valid only during a synchronous build. */
-export const attach = /* @__PURE__ */ operation("attach");
-/** Reads one immutable named anchor from a shape in the active build. */
-export const anchor = /* @__PURE__ */ operation("anchor");
-/** Returns a new same-build shape handle with explicit copied named anchors. */
-export const withAnchors = /* @__PURE__ */ operation("withAnchors");
-/** Host-bound sectionFromContours operation. Valid only during a synchronous build. */
-export const sectionFromContours = 
-/* @__PURE__ */ operation("sectionFromContours");
-/** Host-bound ellipse operation. Valid only during a synchronous build. */
-export const ellipse = /* @__PURE__ */ operation("ellipse");
-/** Host-bound offset operation. Valid only during a synchronous build. */
-export const offset = /* @__PURE__ */ operation("offset");
-/** Host-bound preflightInternalThreadCutter operation. Valid only during a synchronous build. */
-export const preflightInternalThreadCutter = 
-/* @__PURE__ */ operation("preflightInternalThreadCutter");
+function invoke(name, args) {
+    const context = currentModelContext(name);
+    return Reflect.apply(context[name], undefined, args);
+}
+function requireProfile(shape, operation) {
+    if (typeof shape !== "object" || shape === null || !("components" in shape)) {
+        throw new GeometryError("INVALID_ARGUMENT", `${operation}() requires a CorrespondingProfile. Use section.${operation}() for a Section.`, { operation });
+    }
+}
+/**
+ * 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 function box(options) {
+    return invoke("box", [options]);
+}
+/**
+ * +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 function cylinder(options) {
+    return invoke("cylinder", [options]);
+}
+/**
+ * Hollow +Z tube.
+ *
+ * @example Tube
+ * ```ts
+ * tube({ height: 20, outerRadius: 10, innerRadius: 6 });
+ * ```
+ */
+export function tube(options) {
+    return invoke("tube", [options]);
+}
+/**
+ * Origin-centered sphere.
+ *
+ * @example Sphere
+ * ```ts
+ * sphere({ diameter: 20 });
+ * ```
+ */
+export function sphere(options) {
+    return invoke("sphere", [options]);
+}
+/**
+ * Torus around +Z.
+ *
+ * @example Torus
+ * ```ts
+ * torus({ majorRadius: 12, minorRadius: 3 });
+ * ```
+ */
+export function torus(options) {
+    return invoke("torus", [options]);
+}
+export function union(solids) {
+    return invoke("union", [solids]);
+}
+export function intersect(solids) {
+    return invoke("intersect", [solids]);
+}
+/**
+ * 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 function split(solid, cutter) {
+    return invoke("split", [solid, cutter]);
+}
+/**
+ * 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 function splitByPlane(solid, plane) {
+    return invoke("splitByPlane", [solid, plane]);
+}
+/** Combines disjoint components without resolving overlap. */
+export function compose(solids) {
+    return invoke("compose", [solids]);
+}
+export function hull(options) {
+    return invoke("hull", [options]);
+}
+/** Three-dimensional Minkowski sum. */
+export function minkowskiSum(a, b) {
+    return invoke("minkowskiSum", [a, b]);
+}
+/**
+ * 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 function solidFromMesh(mesh) {
+    return invoke("solidFromMesh", [mesh]);
+}
+/** Copies a handle to manufacturing mesh buffers. */
+export function toTriangleMesh(solid) {
+    return invoke("toTriangleMesh", [solid]);
+}
+/**
+ * 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 function anchor(shape, name) {
+    return invoke("anchor", [shape, name]);
+}
+/**
+ * Creates a native filled section without an intermediate Region2 conversion.
+ */
+export function sectionFromContours(contours, options) {
+    return invoke("sectionFromContours", [contours, options]);
+}
+/** Imports explicit region topology once. */
+export function fromRegion(region) {
+    return invoke("fromRegion", [region]);
+}
+/** Explicit copied topology inspection; not needed for section operations. */
+export function toRegion(section) {
+    return invoke("toRegion", [section]);
+}
+/**
+ * Filled rectangular section with uniform or independently treated corners.
+ *
+ * @example Round the corners
+ * ```ts
+ * rectangle({ size: [30, 20], treatment: { kind: "round", radius: 3 } });
+ * ```
+ */
+export function rectangle(options) {
+    return invoke("rectangle", [options]);
+}
+/**
+ * Centered circular section.
+ *
+ * @example Size to polygon faces
+ * ```ts
+ * circle({ diameter: 12, sizing: "face" });
+ * ```
+ */
+export function circle(options) {
+    return invoke("circle", [options]);
+}
+/**
+ * Centered elliptical section.
+ *
+ * @example Ellipse by full dimensions
+ * ```ts
+ * ellipse({ size: [30, 20] });
+ * ```
+ */
+export function ellipse(options) {
+    return invoke("ellipse", [options]);
+}
+/**
+ * Regular polygon with a vertex on +X.
+ *
+ * @example Hexagonal section
+ * ```ts
+ * regularPolygon({ radius: 10, sides: 6, sizing: "face" });
+ * ```
+ */
+export function regularPolygon(options) {
+    return invoke("regularPolygon", [options]);
+}
+/**
+ * Alternating outer/inner star vertices.
+ *
+ * @example Five-point section
+ * ```ts
+ * star({ outerRadius: 12, innerRadius: 6, points: 5 });
+ * ```
+ */
+export function star(options) {
+    return invoke("star", [options]);
+}
+/**
+ * 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 function extrude(shape, options) {
+    requireProfile(shape, "extrude");
+    return invoke("extrude", [shape, options]);
+}
+/**
+ * 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 function revolve(shape, options) {
+    requireProfile(shape, "revolve");
+    return invoke("revolve", [shape, options]);
+}
+export function loft(stations, options) {
+    return invoke("loft", [stations, options]);
+}
+/** Explicit family matching on a shared physical span grid using session or operation resolution. */
+export function matchProfiles(profiles, options) {
+    return invoke("matchProfiles", [profiles, options]);
+}
+/**
+ * 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 function sweep(shape, path, options) {
+    requireProfile(shape, "sweep");
+    return invoke("sweep", [shape, path, options]);
+}
+/**
+ * Copies lightweight section measurements.
+ *
+ * @example Check filled area
+ * ```ts
+ * const facts = inspectSection(rectangle({ size: [20, 10] }));
+ * facts.area; // 200 mm²
+ * ```
+ */
+export function inspectSection(section) {
+    return invoke("inspectSection", [section]);
+}
+/**
+ * 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 function inspectSolid(solid) {
+    return invoke("inspectSolid", [solid]);
+}
+/**
+ * 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 function isEmpty(shape) {
+    return invoke("isEmpty", [shape]);
+}
+/**
+ * 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 function distance(solid, other) {
+    return invoke("distance", [solid, other]);
+}
+/** Copies intersections along the finite directed origin-to-endpoint segment. */
+export function rayCast(solid, origin, endpoint) {
+    return invoke("rayCast", [solid, origin, endpoint]);
+}
+export function components(solid) {
+    return invoke("components", [solid]);
+}
+/** Bounded positive-inside implicit field constructor. */
+export function implicit(options) {
+    return invoke("implicit", [options]);
+}
+/**
+ * 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 function heightfield(options) {
+    return invoke("heightfield", [options]);
+}
+/**
+ * Repeats one solid along a normalized direction.
+ *
+ * @example Three copies along X
+ * ```ts
+ * linearPattern(box({ size: 4 }), { count: 3, spacing: 10 });
+ * ```
+ */
+export function linearPattern(source, options) {
+    return invoke("linearPattern", [source, options]);
+}
+/**
+ * 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 function radialPattern(source, options) {
+    return invoke("radialPattern", [source, options]);
+}
+/**
+ * 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 function gridPattern(source, options) {
+    return invoke("gridPattern", [source, options]);
+}
+/**
+ * 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 function pathPattern(source, path, options) {
+    return invoke("pathPattern", [source, path, options]);
+}
+/** Helical ridge mesh construction. */
+export function threadRidge(options) {
+    return invoke("threadRidge", [options]);
+}
+/**
+ * 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 function threadedRod(options) {
+    return invoke("threadedRod", [options]);
+}
+/**
+ * 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 function internalThreadCutter(options) {
+    return invoke("internalThreadCutter", [options]);
+}
+/**
+ * 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 function threadedNut(options) {
+    return invoke("threadedNut", [options]);
+}
+/** Allocation-free external-thread facts. */
+export function preflightThreadedRod(options) {
+    return invoke("preflightThreadedRod", [options]);
+}
+/** Allocation-free internal-thread facts. */
+export function preflightInternalThreadCutter(options) {
+    return invoke("preflightInternalThreadCutter", [options]);
+}
+/** Allocation-free nut/cutter facts. */
+export function preflightThreadedNut(options) {
+    return invoke("preflightThreadedNut", [options]);
+}
+/**
+ * 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 function textSection(layout, options) {
+    return invoke("textSection", [layout, options]);
+}
+/**
+ * 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 function svgSection(svg, options) {
+    return invoke("svgSection", [svg, options]);
+}
+/**
+ * Imports bounded filled SVG path data.
+ *
+ * @example Fill an SVG path in millimetres
+ * ```ts
+ * svgPathSection("M0 0H20V12H0Z", { origin: "center", scale: 1 });
+ * ```
+ */
+export function svgPathSection(path, options) {
+    return invoke("svgPathSection", [path, options]);
+}