@metamesh/modeling 0.6.0 → 0.7.0

package/dist/api/text.d.ts

@@ -1,10 +1,22 @@
 /** Limits apply before parsing or shaping untrusted font data. */
 export declare const MAX_VECTOR_FONT_BYTES: number;
 
-/** Parses bounded font bytes using optional fontkit and WOFF2 peers; no font fetching occurs here. */
+/**
+ * Parses bounded font bytes using optional fontkit and WOFF2 peers; no font fetching occurs here.
+ *
+ * @example Prepare a label before building geometry
+ * ```ts
+ * async function prepareLabel(fontBytes: Uint8Array) {
+ *   const font = await prepareVectorFont(fontBytes);
+ *   return font.layout("MetaMesh", { fontSize: 8 });
+ * }
+ * ```
+ */
 export declare function prepareVectorFont(bytes: Uint8Array, options?: VectorFontOptions): Promise<VectorFont>;
 
-/** A prepared font owns its parsed bytes; keep handles local to their Worker or invocation. */
+/**
+ * A prepared font owns its parsed bytes; keep handles local to their Worker or invocation.
+ */
 export declare interface VectorFont {
     /** Shape and position up to 512 UTF-16 units and 16 lines; supports empty or whitespace text. */
     readonly layout: (text: string, options: VectorTextLayoutOptions) => VectorTextLayout;
@@ -28,7 +40,9 @@ export declare interface VectorTextBounds {
     readonly max: readonly [number, number];
 }
 
-/** Immutable vector layout with no browser, font parser, or kernel ownership. */
+/**
+ * Immutable vector layout with no browser, font parser, or kernel ownership.
+ */
 export declare interface VectorTextLayout {
     /** Nonzero-filled path data in millimetres, positive Y upward; empty for text with no ink. */
     readonly paths: readonly string[];
@@ -36,7 +50,9 @@ export declare interface VectorTextLayout {
     readonly metrics: VectorTextMetrics;
 }
 
-/** Horizontal multiline text, bounded to 512 UTF-16 units and 16 lines without wrapping. */
+/**
+ * Horizontal multiline text, bounded to 512 UTF-16 units and 16 lines without wrapping.
+ */
 export declare interface VectorTextLayoutOptions extends VectorTextOptions {
     /** Place each line's advance at the origin; defaults to left. Ink overhang is preserved. */
     readonly align?: "left" | "center" | "right";

package/dist/engine/index.js

@@ -61,7 +61,18 @@ function engineFromModule(module, engineLimits) {
         },
     });
 }
-/** Initializes one host kernel and returns a lifecycle-safe engine. No generator initializes WASM. */
+/**
+ * Initializes one host kernel and returns a lifecycle-safe engine. No generator initializes WASM.
+ *
+ * @example Build a box in a host application
+ * ```ts
+ * import { box } from "@metamesh/modeling";
+ * import { createModelEngine } from "@metamesh/modeling/engine";
+ *
+ * const engine = await createModelEngine();
+ * const snapshot = engine.build(() => box({ size: [30, 20, 8] }));
+ * ```
+ */
 export async function createModelEngine(options = {}) {
     const limits = resolveModelingLimits(options.limits);
     const module = await createManifoldModule({

package/dist/geometry/curves/sampling.js

@@ -224,7 +224,8 @@ function sampleCurve(curve, options, createWriter) {
             return curveFailure("INVALID_ARGUMENT", "Unsupported curve kind.");
     }
 }
-/** Samples a spatial curve, preserving endpoints and directed unit tangents.
+/**
+ * Samples a spatial curve, preserving endpoints and directed unit tangents.
  * @remarks Exact counts use uniform curve parameters, not equal physical distances. Adaptive cubics
  * bound the full control hull. Full-circle arcs repeat their endpoint; closed polylines do not.
  * @example

package/dist/geometry/heightfield.js

@@ -45,6 +45,14 @@ export function preflightHeightfield(options, limits = {}) {
  * Builds a closed indexed solid from a regularly sampled top, matched boundary walls, and flat base.
  * Heights are evaluated once per grid point after allocation preflight. Physical XY sizes and all
  * output coordinates must fit Float32 storage. Shared wall vertices prevent cracks at the base.
+ *
+ * @example Sample a closed wavy mesh
+ * ```ts
+ * heightfieldMesh({
+ *   size: [30, 20], segments: [24, 16],
+ *   height: ([x, y]) => 3 + Math.cos(x / 5) * Math.cos(y / 5),
+ * });
+ * ```
  */
 export function heightfieldMesh(options, limits = {}) {
     const facts = preflightHeightfield(options, limits);

package/dist/geometry/loft.js

@@ -14,6 +14,13 @@ export { triangulateLoop2 } from "./loft-triangulation.js";
  * Both ends use ear-clipped caps, supporting concave profiles without center fans.
  * Intermediate slices interpolate placed world vertices, never frame axes.
  * Transformed coordinates must fit finite Float32 mesh storage.
+ *
+ * @example Loft with explicit point correspondence
+ * ```ts
+ * const bottom = rectangleLoop({ size: [20, 12] });
+ * const top = rectangleLoop({ size: [30, 20], treatment: { kind: "round", radius: 3 } });
+ * loftMesh([{ profile: bottom, z: 0 }, { profile: top, z: 30 }], { correspondence: "reindex" });
+ * ```
  */
 export function loftMesh(stations, options) {
     return buildLoftMesh(stations, options);
@@ -40,7 +47,15 @@ export function buildLoftMesh(stations, options, allocationGuard) {
     }));
     return simpleLoftMesh(prepareLoftGeometry(profiles, options, limits, false), limits, allocationGuard);
 }
-/** Linearly extrudes one simple profile along +Z with robust ear-clipped caps. */
+/**
+ * Linearly extrudes one simple profile along +Z with robust ear-clipped caps.
+ *
+ * @example Extrude point data without an engine
+ * ```ts
+ * const outline = rectangleLoop({ size: [30, 20], treatment: { kind: "round", radius: 3 } });
+ * extrudeMesh(outline, { height: 8 });
+ * ```
+ */
 export function extrudeMesh(profile, options) {
     const { height } = options;
     const { center, scales, twistDegrees } = resolveExtrusionControls(height, options, "extrudeMesh");

package/dist/geometry/math/vector3.js

@@ -1,16 +1,46 @@
-/** Adds two finite XYZ vectors component-wise. @example `add3([1, 2, 3], [4, 5, 6])` */
+/**
+ * Adds two finite XYZ vectors component-wise.
+ * @example
+ * ```ts
+ * add3([1, 2, 3], [4, 5, 6]); // [5, 7, 9]
+ * ```
+ */
 export const add3 = (a, b) => [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
-/** Subtracts `b` from `a`. @example `subtract3([4, 5, 6], [1, 2, 3])` */
+/**
+ * Subtracts `b` from `a`.
+ * @example
+ * ```ts
+ * subtract3([4, 5, 6], [1, 2, 3]); // [3, 3, 3]
+ * ```
+ */
 export const subtract3 = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
-/** Multiplies a vector by a dimensionless scalar. @example `scale3([1, 2, 3], 2)` */
+/**
+ * Multiplies a vector by a dimensionless scalar.
+ * @example
+ * ```ts
+ * scale3([1, 2, 3], 2); // [2, 4, 6]
+ * ```
+ */
 export const scale3 = (vector, scale) => [
     vector[0] * scale,
     vector[1] * scale,
     vector[2] * scale,
 ];
-/** Returns the scalar dot product. @example `dot3([1, 0, 0], [0, 1, 0])` */
+/**
+ * Returns the scalar dot product.
+ * @example
+ * ```ts
+ * dot3([1, 0, 0], [0, 1, 0]); // 0
+ * ```
+ */
 export const dot3 = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
-/** Returns the right-handed cross product. @example `cross3([1, 0, 0], [0, 1, 0])` */
+/**
+ * Returns the right-handed cross product.
+ * @example
+ * ```ts
+ * cross3([1, 0, 0], [0, 1, 0]); // [0, 0, 1]
+ * ```
+ */
 export const cross3 = (a, b) => [
     a[1] * b[2] - a[2] * b[1],
     a[2] * b[0] - a[0] * b[2],

package/dist/geometry/mechanical/thread-profiles.js

@@ -234,6 +234,11 @@ const standardProfile = (kind, pitch, depth, root, crest, leftRun, rightRun) =>
  * The open path spans one pitch. Radial zero is the major envelope; negative
  * values point toward the shaft. Custom paths must be finite, axially
  * non-decreasing, periodic at their endpoints, and reach radial zero.
+ *
+ * @example Printable triangular thread profile
+ * ```ts
+ * createThreadProfile({ kind: "triangular", pitch: 1.75 });
+ * ```
  */
 export function createThreadProfile(spec) {
     const operation = "createThreadProfile";

package/dist/geometry/mesh-edge-table.js

@@ -0,0 +1,126 @@
+const MAXIMUM_UINT32 = 0xffff_ffff;
+const MAXIMUM_SLOT_CAPACITY = 0x1_0000_0000;
+const FORWARD = 1;
+const BACKWARD = 2;
+const PAIRED = 3;
+const INVALID = 4;
+function doubledCapacity(capacity) {
+    const doubled = capacity * 2;
+    if (doubled > MAXIMUM_SLOT_CAPACITY)
+        throw new RangeError("Mesh edge table exceeds Uint32 slot capacity.");
+    return doubled;
+}
+/**
+ * @internal Indexed edge closure and first-face records; coordinates are never welded.
+ * Dense record IDs remain stable when the hash slots grow. Inputs are validated Uint32
+ * vertex indices with distinct endpoints, and triangle IDs fit Uint32 storage.
+ */
+export class IndexedMeshEdgeTable {
+    slotCapacity;
+    mask;
+    slots;
+    recordCapacity;
+    recordCount = 0;
+    lower;
+    upper;
+    states;
+    firstTriangle;
+    constructor(indexCount, includeTopology) {
+        if (!Number.isSafeInteger(indexCount) || indexCount < 0 || indexCount > MAXIMUM_UINT32)
+            throw new RangeError("Mesh edge table requires an index count within Uint32 capacity.");
+        let capacity = 16;
+        // Multiplication avoids the signed-int32 wrap of bitwise capacity doubling.
+        while (capacity < indexCount)
+            capacity = doubledCapacity(capacity);
+        this.slotCapacity = capacity;
+        this.mask = capacity - 1;
+        this.slots = new Uint32Array(capacity);
+        this.recordCapacity = capacity / 2;
+        this.lower = new Uint32Array(this.recordCapacity);
+        this.upper = new Uint32Array(this.recordCapacity);
+        this.states = new Uint8Array(this.recordCapacity);
+        this.firstTriangle = includeTopology ? new Uint32Array(this.recordCapacity) : null;
+    }
+    /** Returns -1 for a new edge, otherwise its first triangle (or zero without topology). */
+    touch(a, b, triangle) {
+        const lower = Math.min(a, b);
+        const upper = Math.max(a, b);
+        const state = a < b ? FORWARD : BACKWARD;
+        let slot = (this.hash(lower, upper) & this.mask) >>> 0;
+        while (this.slots[slot] !== 0) {
+            const record = this.slots[slot] - 1;
+            // Hashes wrap to int32; only the complete two Uint32 keys establish identity.
+            if (this.lower[record] === lower && this.upper[record] === upper) {
+                const previous = this.states[record];
+                this.states[record] =
+                    (previous === FORWARD && state === BACKWARD) ||
+                        (previous === BACKWARD && state === FORWARD)
+                        ? PAIRED
+                        : INVALID;
+                return this.firstTriangle?.[record] ?? 0;
+            }
+            slot = ((slot + 1) & this.mask) >>> 0;
+        }
+        // Repeat touches cannot increase occupancy; check growth only for an absent key.
+        if (this.recordCount + 1 > this.slotCapacity * 0.7) {
+            this.growSlots();
+            return this.touch(a, b, triangle);
+        }
+        if (this.recordCount >= MAXIMUM_UINT32)
+            throw new RangeError("Mesh edge table exceeds Uint32 record capacity.");
+        if (this.recordCount === this.recordCapacity)
+            this.growRecords();
+        const record = this.recordCount;
+        this.slots[slot] = record + 1;
+        this.lower[record] = lower;
+        this.upper[record] = upper;
+        this.states[record] = state;
+        if (this.firstTriangle !== null)
+            this.firstTriangle[record] = triangle;
+        this.recordCount += 1;
+        return -1;
+    }
+    /** Checks exactly two oppositely wound uses after every triangle has been validated. */
+    isClosed() {
+        for (let record = 0; record < this.recordCount; record += 1)
+            if (this.states[record] !== PAIRED)
+                return false;
+        return true;
+    }
+    hash(lower, upper) {
+        const mixed = Math.imul(lower, 0x9e3779b1) ^ Math.imul(upper, 0x85ebca6b);
+        return (mixed ^ (mixed >>> 16)) >>> 0;
+    }
+    growSlots() {
+        const capacity = doubledCapacity(this.slotCapacity);
+        const mask = capacity - 1;
+        const slots = new Uint32Array(capacity);
+        // Paired and invalid records must remain: forgetting either could admit four-face edges.
+        for (let record = 0; record < this.recordCount; record += 1) {
+            let slot = (this.hash(this.lower[record], this.upper[record]) & mask) >>> 0;
+            while (slots[slot] !== 0)
+                slot = ((slot + 1) & mask) >>> 0;
+            slots[slot] = record + 1;
+        }
+        this.slotCapacity = capacity;
+        this.mask = mask;
+        this.slots = slots;
+    }
+    growRecords() {
+        const capacity = doubledCapacity(this.recordCapacity);
+        const lower = new Uint32Array(capacity);
+        const upper = new Uint32Array(capacity);
+        const states = new Uint8Array(capacity);
+        const firstTriangle = this.firstTriangle === null ? null : new Uint32Array(capacity);
+        lower.set(this.lower);
+        upper.set(this.upper);
+        states.set(this.states);
+        if (firstTriangle !== null)
+            firstTriangle.set(this.firstTriangle);
+        this.recordCapacity = capacity;
+        this.lower = lower;
+        this.upper = upper;
+        this.states = states;
+        this.firstTriangle = firstTriangle;
+    }
+}

package/dist/geometry/mesh.js

@@ -1,4 +1,5 @@
 import { GeometryError } from "./errors.js";
+import { IndexedMeshEdgeTable } from "./mesh-edge-table.js";
 import { writeMeshVertex } from "./numeric.js";
 import { resolveGeometryTolerance } from "./tolerance.js";
 import { transformDeterminant3, validateTransform3 } from "./transform3.js";
@@ -33,7 +34,7 @@ function inspectTriangleMesh(mesh, options = {}, mode = "validate", topology = f
     const extent = vertexCount === 0 ? 0 : Math.max(max[0] - min[0], max[1] - min[1], max[2] - min[2]);
     const minimumDoubleArea = resolveGeometryTolerance(extent, options.tolerance).area;
     const edges = options.requireClosed || topology
-        ? new Map()
+        ? new IndexedMeshEdgeTable(mesh.indices.length, topology)
         : null;
     const triangleCount = mesh.indices.length / 3;
     const parents = topology ? new Int32Array(triangleCount) : null;
@@ -64,23 +65,11 @@ function inspectTriangleMesh(mesh, options = {}, mode = "validate", topology = f
     };
     let edgeCount = 0;
     const addEdge = (a, b, triangle) => {
-        const lower = Math.min(a, b), upper = Math.max(a, b);
-        let neighbors = edges.get(lower);
-        if (neighbors === undefined) {
-            neighbors = new Map();
-            edges.set(lower, neighbors);
-        }
-        let edge = neighbors.get(upper);
-        if (edge === undefined) {
-            edge = { count: 0, balance: 0, ...(topology ? { firstTriangle: triangle } : {}) };
-            neighbors.set(upper, edge);
+        const firstTriangle = edges.touch(a, b, triangle);
+        if (firstTriangle === -1)
             edgeCount += 1;
-        }
-        else if (topology) {
-            connect(edge.firstTriangle, triangle);
-        }
-        edge.count += 1;
-        edge.balance += a < b ? 1 : -1;
+        else if (topology)
+            connect(firstTriangle, triangle);
     };
     // Keep the two hot-loop accumulators independent and local: no mutable numeric objects escape.
     let surfaceArea = 0, areaCorrection = 0, signedVolume = 0, volumeCorrection = 0;
@@ -129,14 +118,8 @@ function inspectTriangleMesh(mesh, options = {}, mode = "validate", topology = f
             addEdge(c, a, offset / 3);
         }
     }
-    if (options.requireClosed && edges !== null) {
-        for (const neighbors of edges.values())
-            for (const edge of neighbors.values()) {
-                if (edge.count !== 2 || edge.balance !== 0) {
-                    throw new GeometryError("INVALID_MESH", "Closed meshes require exactly two oppositely wound faces at every edge.");
-                }
-            }
-    }
+    if (options.requireClosed && edges !== null && !edges.isClosed())
+        throw new GeometryError("INVALID_MESH", "Closed meshes require exactly two oppositely wound faces at every edge.");
     if (referenced !== null) {
         for (let vertex = 0; vertex < vertexCount; vertex += 1) {
             if (referenced[vertex] === 0) {

package/dist/geometry/paths/path.js

@@ -26,5 +26,7 @@ export const cumulativePathLengths = (path, limits = {}) => {
     }
     return cumulative;
 };
-/** Returns total sampled 3D path length, or zero for an empty path. */
+/**
+ * Returns total sampled 3D path length, or zero for an empty path.
+ */
 export const pathLength = (path, limits = {}) => cumulativePathLengths(path, limits).at(-1) ?? 0;

package/dist/geometry/paths/resampling.js

@@ -99,7 +99,8 @@ function resamplePolyline(path, dimensions, options, createWriter) {
     }
     return writer.finish();
 }
-/** Resamples a spatial polyline at equal arc lengths with directed outgoing tangents.
+/**
+ * Resamples a spatial polyline at equal arc lengths with directed outgoing tangents.
  * @remarks Open paths retain both endpoints; closed paths include the closing edge and omit the
  * repeated seam. Repeated adjacent inputs and explicit closing duplicates are removed. Physical
  * maxSegmentLength bounds arc-length intervals; exact counts override that policy. Output edges

package/dist/geometry/profiles/matched.js

@@ -68,6 +68,14 @@ const contours = (component) => [
  * Cubics share a checked uniform parameter grid, including grids selected by exact paired requests.
  * Input order and winding are preserved. Collapsed spans retain repeated logical slots, which
  * the engine maps to shared physical vertices while omitting degenerate faces.
+ *
+ * @example Match named rectangle landmarks
+ * ```ts
+ * matchProfiles([
+ *   rectangleProfile({ size: [20, 12] }),
+ *   rectangleProfile({ size: [30, 20], treatment: { kind: "round", radius: 3 } }),
+ * ]);
+ * ```
  */
 export function matchProfiles(profiles, options = {}) {
     if (!isArray(profiles) || profiles.length === 0 || profiles.length > 1000)

package/dist/geometry/profiles/profiles.js

@@ -3,7 +3,14 @@ import { resolveCircularPrimitiveSegments } from "../primitive-resolution.js";
 import { assertPrimitiveOptions } from "../primitive-resolvers.js";
 import { requireFiniteProfileValues, requireProfileVertexCount } from "./validation.js";
 export { rectangleLoop } from "./rectangle.js";
-/** Creates an immutable centered CCW circle with +X seam and vertex or face radial sizing. */
+/**
+ * Creates an immutable centered CCW circle with +X seam and vertex or face radial sizing.
+ *
+ * @example Explicit circular point data
+ * ```ts
+ * circleLoop({ diameter: 20, segments: 32 });
+ * ```
+ */
 export const circleLoop = (options) => {
     const operation = "circleLoop";
     assertPrimitiveOptions(options, operation);
@@ -32,7 +39,14 @@ export const circleLoop = (options) => {
         return Object.freeze([sampledRadius * Math.cos(angle), sampledRadius * Math.sin(angle)]);
     }));
 };
-/** Creates a centered CCW point loop with vertex or face radial sizing and an implicit seam. */
+/**
+ * Creates a centered CCW point loop with vertex or face radial sizing and an implicit seam.
+ *
+ * @example Hexagon sized to its faces
+ * ```ts
+ * regularPolygonLoop({ radius: 10, sides: 6, sizing: "face" });
+ * ```
+ */
 export const regularPolygonLoop = (options) => {
     const operation = "regularPolygonLoop";
     const { radius, sides, rotationDegrees = 0, sizing = "vertex" } = options;
@@ -53,7 +67,14 @@ export const regularPolygonLoop = (options) => {
         return [sampledRadius * Math.cos(angle), sampledRadius * Math.sin(angle)];
     });
 };
-/** Creates a centered CCW alternating-radius star within the selected profile sampling ceiling. */
+/**
+ * Creates a centered CCW alternating-radius star within the selected profile sampling ceiling.
+ *
+ * @example Five-point outline
+ * ```ts
+ * starLoop(12, 5, 6);
+ * ```
+ */
 export const starLoop = (outerRadius, points, innerRadius = outerRadius / 2, limits = {}) => {
     const operation = "starLoop";
     requireFiniteProfileValues([outerRadius, innerRadius], operation);

package/dist/geometry/profiles/rectangle.js

@@ -78,7 +78,14 @@ export function rectangleCornerSegments(corner, limits) {
         limits: selected,
     }) / 4);
 }
-/** Creates an immutable CCW rectangle loop. Round radius zero is square; tangent saturated endpoints occur once. */
+/**
+ * Creates an immutable CCW rectangle loop. Round radius zero is square; tangent saturated endpoints occur once.
+ *
+ * @example Rounded rectangle outline
+ * ```ts
+ * rectangleLoop({ size: [30, 20], treatment: { kind: "round", radius: 3 } });
+ * ```
+ */
 export function rectangleLoop(options) {
     const { width, height, corners, limits } = resolveRectangle(options, "rectangleLoop");
     const counts = corners.map((corner) => {
@@ -138,7 +145,14 @@ export function rectangleLoop(options) {
         clean.pop();
     return Object.freeze(clean.map(([px, py]) => Object.freeze(options.center === false ? [px + x, py + y] : [px, py])));
 }
-/** Creates an identified rectangle whose edge/corner spans survive zero and saturated round radii. Outer winding is CCW. */
+/**
+ * Creates an identified rectangle whose edge/corner spans survive zero and saturated round radii. Outer winding is CCW.
+ *
+ * @example Retain rectangle landmarks
+ * ```ts
+ * rectangleProfile({ size: [30, 20], treatment: { kind: "round", radius: 3 } });
+ * ```
+ */
 export function rectangleProfile(options) {
     const { width, height, corners, setbacks, limits } = resolveRectangle(options, "rectangleProfile");
     const id = options.id ?? "body";

package/dist/geometry/profiles/shapes.js

@@ -2,7 +2,14 @@ import { GeometryError } from "../errors.js";
 import { resolveCircularPrimitiveSegments } from "../primitive-resolution.js";
 import { assertPrimitiveOptions } from "../primitive-resolvers.js";
 import { requireFiniteProfileValues, requireProfileVertexCount } from "./validation.js";
-/** Creates an immutable centered CCW ellipse with +X seam within the selected sampling ceiling. */
+/**
+ * Creates an immutable centered CCW ellipse with +X seam within the selected sampling ceiling.
+ *
+ * @example Ellipse by full dimensions
+ * ```ts
+ * ellipseLoop({ size: [30, 20] });
+ * ```
+ */
 export function ellipseLoop(options) {
     assertPrimitiveOptions(options, "ellipseLoop");
     if ((options.radius === undefined) === (options.size === undefined)) {

package/dist/geometry/revolve/revolve-mesh.js

@@ -20,6 +20,12 @@ const AXIS_EPSILON = 1e-10;
  * @param profile - Closed CCW `[radius, z]` profile without a duplicated seam point.
  * @param options - Optional physical or exact circumferential sampling controls. Defaults to `{}`.
  * @returns A closed indexed triangle mesh revolved counter-clockwise around +Z.
+ *
+ * @example Partial revolution with end caps
+ * ```ts
+ * // Each point is [radius, Z]; the profile seam is implicit.
+ * revolveMesh([[0, 0], [12, 0], [8, 20], [0, 20]], { revolveDegrees: 270 });
+ * ```
  */
 export const revolveMesh = (profile, options = {}) => {
     if (typeof options !== "object" || options === null || Array.isArray(options))

package/dist/geometry/sweeps/sweep-mesh.js

@@ -2,7 +2,17 @@ import { GeometryError } from "../errors.js";
 import { validateSweepOptions } from "./orientation.js";
 import { buildClosedSweepMesh } from "./sweep-closed.js";
 import { buildOpenSweepMesh } from "./sweep-open.js";
-/** Sweeps one explicitly ordered point loop, with caps or a geometrically matching closed seam. */
+/**
+ * Sweeps one explicitly ordered point loop, with caps or a geometrically matching closed seam.
+ *
+ * @example Sweep point data along a bent path
+ * ```ts
+ * const profile = rectangleLoop({ size: [6, 3] });
+ * sweepMesh(profile, [[0, 0, 0], [0, 0, 15], [10, 0, 25]], {
+ *   orientation: { kind: "transport", initialNormal: [0, 1, 0] },
+ * });
+ * ```
+ */
 export function sweepMesh(profile, path, options = {}) {
     return buildSweepMesh(profile, path, options);
 }

package/dist/model/operations.js

@@ -14,7 +14,9 @@ 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. */
+/**
+ * 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);

package/dist/text/index.js

@@ -19,7 +19,17 @@ function serializeVectorText({ paths, metrics }) {
         fail("Text outlines exceed 256 KiB. Use fewer characters or a simpler font.");
     return svg;
 }
-/** Parses bounded font bytes using optional fontkit and WOFF2 peers; no font fetching occurs here. */
+/**
+ * Parses bounded font bytes using optional fontkit and WOFF2 peers; no font fetching occurs here.
+ *
+ * @example Prepare a label before building geometry
+ * ```ts
+ * async function prepareLabel(fontBytes: Uint8Array) {
+ *   const font = await prepareVectorFont(fontBytes);
+ *   return font.layout("MetaMesh", { fontSize: 8 });
+ * }
+ * ```
+ */
 export async function prepareVectorFont(bytes, options = {}) {
     if (bytes.byteLength === 0 || bytes.byteLength > MAX_VECTOR_FONT_BYTES)
         fail("Font files must be non-empty and at most 16 MiB.");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@metamesh/modeling",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Scoped solid modeling and pure geometry foundations for Node and browsers.",
   "license": "Apache-2.0",
   "repository": {