fluidcad 0.0.37 → 0.0.39

package/lib/dist/oc/loft/section-curve.js

@@ -0,0 +1,264 @@
+import { getOC } from "../init.js";
+import { CurveData } from "./curve-data.js";
+/**
+ * Turns a profile wire into a single clamped B-spline curve, parameterized
+ * over [0, 1] with spans proportional to edge arc length. Corners survive as
+ * interior knots of multiplicity `degree` (C0), so any planar profile — a
+ * polygon, a slot, a circle — becomes exactly one curve. That single-curve
+ * form is what makes profiles with different edge counts loftable against
+ * each other: compatibility reduces to sharing one degree and one knot
+ * vector instead of matching edges pairwise.
+ */
+export class SectionCurve {
+    // Rational→polynomial section conversion tolerance (mm). Loose enough to
+    // keep pole counts small — pole count drives the cost of every downstream
+    // stage (knot union, skinning, surface, meshing). Caps always sew exactly
+    // (they share the section's poles), so this only bounds the deviation of
+    // the loft wall from the true profile curve.
+    static APPROX_TOLERANCE = 1e-4;
+    static LENGTH_SAMPLES = 32;
+    /**
+     * With `forcePolynomial`, rational pieces (arcs, circles) are approximated
+     * as polynomial B-splines before concatenation — piece-by-piece, so profile
+     * corners stay sharp. Used when sections with different weight structures
+     * must share one surface (see `SectionCompatibility`).
+     */
+    static fromWire(wire, forcePolynomial = false) {
+        const oc = getOC();
+        const pieces = [];
+        const explorer = new oc.BRepTools_WireExplorer(wire);
+        while (explorer.More()) {
+            const edge = explorer.Current();
+            if (!oc.BRep_Tool.Degenerated(edge)) {
+                let piece = SectionCurve.edgeToBSpline(edge);
+                if (forcePolynomial && piece.IsRational()) {
+                    const polynomial = SectionCurve.toPolynomial(piece, SectionCurve.APPROX_TOLERANCE);
+                    piece.delete();
+                    piece = polynomial;
+                }
+                pieces.push(piece);
+            }
+            explorer.Next();
+        }
+        explorer.delete();
+        if (pieces.length === 0) {
+            throw new Error("Loft profile wire has no usable edges.");
+        }
+        const section = SectionCurve.concatenate(pieces, wire.Closed());
+        for (const piece of pieces) {
+            piece.delete();
+        }
+        return section;
+    }
+    /**
+     * Concatenates ordered, connected pieces into one clamped B-spline over
+     * [0, 1]: junctions become interior knots of multiplicity `degree` and the
+     * shared endpoint poles collapse into one. If any piece is rational, every
+     * piece contributes weights. A NURBS is unchanged under a global weight
+     * scale, and the only cross-piece constraint is agreement at the shared
+     * junction pole — so each piece is chain-scaled to match its predecessor's
+     * trailing weight (the first piece is anchored at weight 1).
+     *
+     * Pieces span parameter ranges proportional to their arc length, unless
+     * `spans` prescribes the fractions explicitly (rail-contact alignment
+     * re-proportions sections so matching features share parameters).
+     */
+    static concatenate(pieces, closed, spans) {
+        const degree = Math.max(...pieces.map(piece => piece.Degree()));
+        for (const piece of pieces) {
+            if (piece.Degree() < degree) {
+                piece.IncreaseDegree(degree);
+            }
+        }
+        const datas = pieces.map(piece => CurveData.read(piece));
+        const rational = datas.some(data => data.weights !== null);
+        if (rational) {
+            let junctionWeight = 1;
+            for (const data of datas) {
+                const pieceWeights = data.weights ?? new Array(data.poles.length).fill(1);
+                const factor = junctionWeight / pieceWeights[0];
+                data.weights = pieceWeights.map(w => w * factor);
+                junctionWeight = data.weights[data.weights.length - 1];
+            }
+        }
+        // Piece spans proportional to arc length, over a total range of [0, 1].
+        const lengths = spans ?? pieces.map(piece => SectionCurve.approximateLength(piece));
+        const totalLength = lengths.reduce((sum, length) => sum + length, 0);
+        if (totalLength <= 0) {
+            throw new Error("Loft profile wire is degenerate (zero total length).");
+        }
+        const breaks = [0];
+        for (let i = 0; i < lengths.length; i++) {
+            breaks.push(breaks[i] + lengths[i] / totalLength);
+        }
+        breaks[breaks.length - 1] = 1;
+        const knots = [0];
+        const multiplicities = [degree + 1];
+        const poles = [];
+        const weights = rational ? [] : null;
+        for (let i = 0; i < datas.length; i++) {
+            const data = datas[i];
+            const [start, end] = [breaks[i], breaks[i + 1]];
+            const [a, b] = [data.knots[0], data.knots[data.knots.length - 1]];
+            for (let k = 1; k < data.knots.length - 1; k++) {
+                knots.push(start + ((data.knots[k] - a) / (b - a)) * (end - start));
+                multiplicities.push(Math.min(data.multiplicities[k], degree));
+            }
+            if (i < datas.length - 1) {
+                knots.push(end);
+                multiplicities.push(degree);
+            }
+            else {
+                knots.push(1);
+                multiplicities.push(degree + 1);
+            }
+            // The junction pole is shared: seat it at the midpoint of the two
+            // coincident clamped end poles so wire-tolerance gaps split evenly.
+            const firstPoleIndex = i === 0 ? 0 : 1;
+            if (i > 0) {
+                const previous = poles[poles.length - 1];
+                const incoming = data.poles[0];
+                poles[poles.length - 1] = previous.map((v, d) => (v + incoming[d]) / 2);
+            }
+            for (let j = firstPoleIndex; j < data.poles.length; j++) {
+                poles.push(data.poles[j]);
+                if (weights) {
+                    weights.push(data.weights ? data.weights[j] : 1);
+                }
+            }
+        }
+        if (closed && poles.length > 1) {
+            poles[poles.length - 1] = [...poles[0]];
+        }
+        return CurveData.build({ poles, weights, knots, multiplicities, degree });
+    }
+    /**
+     * Approximates any B-spline with a polynomial (non-rational) one within
+     * `tolerance`, as a chain of cubic Hermite segments (position + tangent
+     * matched at the ends of every segment, so the result stays G1). Segments
+     * split at the curve's own knots — rational conversions are typically only
+     * C1 there, and keeping the reduced-continuity points on segment
+     * boundaries preserves O(h⁴) convergence — then subdivide until every
+     * segment fits. Pole count stays proportional to the geometry's curvature
+     * (a circle needs a few dozen poles), never to a sample budget.
+     */
+    static toPolynomial(curve, tolerance) {
+        const oc = getOC();
+        const point = new oc.gp_Pnt();
+        const vector = new oc.gp_Vec();
+        const spans = [];
+        for (let i = 1; i < curve.NbKnots(); i++) {
+            spans.push([curve.Knot(i), curve.Knot(i + 1)]);
+        }
+        try {
+            for (let subdivisions = 1; subdivisions <= 64; subdivisions *= 2) {
+                const breakpoints = [spans[0][0]];
+                for (const [a, b] of spans) {
+                    for (let m = 1; m <= subdivisions; m++) {
+                        breakpoints.push(a + ((b - a) * m) / subdivisions);
+                    }
+                }
+                const samples = breakpoints.map(t => {
+                    curve.D1(t, point, vector);
+                    return {
+                        position: [point.X(), point.Y(), point.Z()],
+                        tangent: [vector.X(), vector.Y(), vector.Z()],
+                    };
+                });
+                // One cubic Bézier per segment in Hermite form.
+                const segments = [];
+                for (let s = 0; s + 1 < breakpoints.length; s++) {
+                    const h = (breakpoints[s + 1] - breakpoints[s]) / 3;
+                    const from = samples[s];
+                    const to = samples[s + 1];
+                    segments.push([
+                        from.position,
+                        from.position.map((v, d) => v + from.tangent[d] * h),
+                        to.position.map((v, d) => v - to.tangent[d] * h),
+                        to.position,
+                    ]);
+                }
+                if (SectionCurve.maxHermiteDeviation(curve, breakpoints, segments) <= tolerance) {
+                    return SectionCurve.assembleCubicSegments(breakpoints, segments);
+                }
+            }
+            throw new Error("Loft could not approximate a rational profile curve within tolerance.");
+        }
+        finally {
+            point.delete();
+            vector.delete();
+        }
+    }
+    /** Largest distance between the Hermite segments and the curve, sampled inside each segment. */
+    static maxHermiteDeviation(curve, breakpoints, segments) {
+        const oc = getOC();
+        const point = new oc.gp_Pnt();
+        let maxDeviation = 0;
+        for (let s = 0; s < segments.length; s++) {
+            const [p0, p1, p2, p3] = segments[s];
+            for (const local of [0.25, 0.5, 0.75]) {
+                const t = breakpoints[s] + (breakpoints[s + 1] - breakpoints[s]) * local;
+                curve.D0(t, point);
+                const u = 1 - local;
+                const b0 = u * u * u;
+                const b1 = 3 * u * u * local;
+                const b2 = 3 * u * local * local;
+                const b3 = local * local * local;
+                const dx = b0 * p0[0] + b1 * p1[0] + b2 * p2[0] + b3 * p3[0] - point.X();
+                const dy = b0 * p0[1] + b1 * p1[1] + b2 * p2[1] + b3 * p3[1] - point.Y();
+                const dz = b0 * p0[2] + b1 * p1[2] + b2 * p2[2] + b3 * p3[2] - point.Z();
+                maxDeviation = Math.max(maxDeviation, Math.hypot(dx, dy, dz));
+            }
+        }
+        point.delete();
+        return maxDeviation;
+    }
+    /** Joins cubic Bézier segments into one B-spline over the original parameter range. */
+    static assembleCubicSegments(breakpoints, segments) {
+        const degree = 3;
+        const knots = [...breakpoints];
+        const multiplicities = breakpoints.map((_, i) => i === 0 || i === breakpoints.length - 1 ? degree + 1 : degree);
+        const poles = [segments[0][0]];
+        for (const segment of segments) {
+            poles.push(segment[1], segment[2], segment[3]);
+        }
+        return CurveData.build({ poles, weights: null, knots, multiplicities, degree });
+    }
+    /** Curve arc length approximated by chord sampling — used only to proportion knot spans. */
+    static approximateLength(curve) {
+        const oc = getOC();
+        const first = curve.FirstParameter();
+        const last = curve.LastParameter();
+        const point = new oc.gp_Pnt();
+        let length = 0;
+        let px = 0;
+        let py = 0;
+        let pz = 0;
+        for (let i = 0; i <= SectionCurve.LENGTH_SAMPLES; i++) {
+            const t = first + ((last - first) * i) / SectionCurve.LENGTH_SAMPLES;
+            curve.D0(t, point);
+            if (i > 0) {
+                length += Math.hypot(point.X() - px, point.Y() - py, point.Z() - pz);
+            }
+            px = point.X();
+            py = point.Y();
+            pz = point.Z();
+        }
+        point.delete();
+        return length;
+    }
+    static edgeToBSpline(edge) {
+        const oc = getOC();
+        const curveInfo = oc.BRep_Tool.Curve(edge, 0, 1);
+        const trimmed = new oc.Geom_TrimmedCurve(curveInfo.returnValue, curveInfo.First, curveInfo.Last, true, true);
+        const bspline = oc.GeomConvert.CurveToBSplineCurve(trimmed);
+        trimmed.delete();
+        if (bspline.IsPeriodic()) {
+            bspline.SetNotPeriodic();
+        }
+        if (edge.Orientation() === oc.TopAbs_Orientation.TopAbs_REVERSED) {
+            bspline.Reverse();
+        }
+        return bspline;
+    }
+}

package/lib/dist/oc/loft/skinning.d.ts

@@ -0,0 +1,104 @@
+import type { TopoDS_Shape, TopoDS_Wire } from "ocjs-fluidcad";
+import { BSplineCurveData } from "../../math/bspline-interpolation.js";
+import { Solid } from "../../common/solid.js";
+import { CompatibleSections, CompatibleSection } from "./section-compatibility.js";
+/** How a loft leaves (or arrives at) an end profile. */
+export type LoftConditionKind = "normal" | "tangent";
+export interface LoftEndCondition {
+    kind: LoftConditionKind;
+    /** Scales the takeoff tangent; 1 ≈ one loft length of influence. Negative flips the direction. */
+    magnitude: number;
+}
+/** The u-direction surface basis every skinned section shares. */
+export interface LoftSurfaceBasis {
+    degree: number;
+    knots: number[];
+    multiplicities: number[];
+    /** Shared weight vector, or null when polynomial. */
+    weights: number[] | null;
+    /** Interior u-knots with a real profile corner — face-split points. */
+    creases?: number[];
+}
+export interface SkinnedGrid {
+    /** Surface poles, indexed [uIndex][vIndex] — u runs around the sections, v along the loft. */
+    grid: number[][][];
+    /** The v-direction basis produced by the column interpolation. */
+    vBasis: BSplineCurveData;
+    /** The loft parameter assigned to each input section. */
+    params: number[];
+    /** Average flow-line length — the scale reference for condition magnitudes. */
+    averageLength: number;
+}
+/**
+ * The shared loft-skinning pipeline: interpolates matching pole columns of
+ * compatible sections along the loft (optionally with end-derivative
+ * constraints) and assembles the resulting `Geom_BSplineSurface` plus exact
+ * boundary caps into a sewn solid. Used by `ConstrainedLoft` (conditions)
+ * and `GuidedLoft` (virtual sections along rails).
+ */
+export declare class Skinning {
+    private static readonly SEWING_TOLERANCE;
+    /**
+     * Interpolates each pole column along the loft. Every column shares the
+     * same parameters and constraint pattern, so every column yields the same
+     * v-basis.
+     */
+    static skinSections(compatible: CompatibleSections, startCondition?: LoftEndCondition, endCondition?: LoftEndCondition): SkinnedGrid;
+    /**
+     * Interpolates pole columns across a stack of sections (sections[k] is the
+     * full pole set of section k) at the given parameters, with optional
+     * per-column end derivatives.
+     */
+    static interpolateColumns(sections: number[][][], params: number[], startField?: number[][] | null, endField?: number[][] | null): {
+        grid: number[][][];
+        vBasis: BSplineCurveData;
+    };
+    /**
+     * Loft parameters v_k in [0, 1] by chord length averaged over the pole
+     * columns (the standard skinning parameterization), plus the average
+     * flow-line length used to scale condition magnitudes.
+     */
+    static loftParameters(sections: CompatibleSection[]): {
+        params: number[];
+        averageLength: number;
+    };
+    /**
+     * The takeoff derivative per pole column at an end section. `normal` uses
+     * the section's plane normal (constant across the section — the surface
+     * leaves perpendicular everywhere); `tangent` uses the in-plane outward
+     * direction per column (winding tangent × section normal).
+     *
+     * At the last section the surface *arrives* rather than departs: a normal
+     * arrival still travels along the loft (no flip), but an outward-bulging
+     * tangent arrival must descend back from the bulge — the in-plane
+     * derivative flips inward so a positive magnitude bulges both ends outward.
+     */
+    static derivativeField(section: CompatibleSection, condition: LoftEndCondition, averageLength: number, isEnd: boolean): number[][];
+    /**
+     * Builds the side surface from the pole grid, caps it with the exact
+     * boundary sections (the first and last v-columns of the grid), and sews
+     * everything into one correctly-oriented solid.
+     */
+    static buildLoftSolid(uBasis: LoftSurfaceBasis, grid: number[][][], vBasis: BSplineCurveData): Solid;
+    /**
+     * The wall faces of a skinned grid, split at profile corners: a corner
+     * buried inside one face has no edge to render, select or fillet, and its
+     * mesh normals smear. Each u-range between creases (the seam is always a
+     * boundary) becomes its own face; smooth profiles keep the single closed
+     * face.
+     */
+    static sideFaces(uBasis: LoftSurfaceBasis, grid: number[][][], vBasis: BSplineCurveData): TopoDS_Shape[];
+    /** Sews faces into a watertight shell and wraps it into a solid. */
+    static sewSolid(faces: TopoDS_Shape[]): Solid;
+    /**
+     * The section's exact boundary as a wire, segmented at the same crease
+     * points as the wall faces so sewing pairs edges exactly.
+     */
+    static capWire(uBasis: LoftSurfaceBasis, poles: number[][]): TopoDS_Wire;
+    /** Planar cap built from the section's exact boundary curve. */
+    private static capFace;
+    /** Consecutive u-ranges between profile corners; one full range when the profile is smooth. */
+    private static uRanges;
+    /** Wraps the sewn shell into a correctly-oriented solid. */
+    private static solidFromShell;
+}

package/lib/dist/oc/loft/skinning.js

@@ -0,0 +1,299 @@
+import { getOC } from "../init.js";
+import { Explorer } from "../explorer.js";
+import { ShapeProps } from "../props.js";
+import { NCollections } from "../ncollection.js";
+import { Vector3d } from "../../math/vector3d.js";
+import { interpolateWithDerivatives } from "../../math/bspline-interpolation.js";
+import { Solid } from "../../common/solid.js";
+import { CurveData } from "./curve-data.js";
+/**
+ * The shared loft-skinning pipeline: interpolates matching pole columns of
+ * compatible sections along the loft (optionally with end-derivative
+ * constraints) and assembles the resulting `Geom_BSplineSurface` plus exact
+ * boundary caps into a sewn solid. Used by `ConstrainedLoft` (conditions)
+ * and `GuidedLoft` (virtual sections along rails).
+ */
+export class Skinning {
+    static SEWING_TOLERANCE = 1e-6;
+    /**
+     * Interpolates each pole column along the loft. Every column shares the
+     * same parameters and constraint pattern, so every column yields the same
+     * v-basis.
+     */
+    static skinSections(compatible, startCondition, endCondition) {
+        const { sections } = compatible;
+        const { params, averageLength } = Skinning.loftParameters(sections);
+        const startField = startCondition
+            ? Skinning.derivativeField(sections[0], startCondition, averageLength, false)
+            : null;
+        const endField = endCondition
+            ? Skinning.derivativeField(sections[sections.length - 1], endCondition, averageLength, true)
+            : null;
+        const columns = sections.map(section => section.poles);
+        const { grid, vBasis } = Skinning.interpolateColumns(columns, params, startField, endField);
+        return { grid, vBasis, params, averageLength };
+    }
+    /**
+     * Interpolates pole columns across a stack of sections (sections[k] is the
+     * full pole set of section k) at the given parameters, with optional
+     * per-column end derivatives.
+     */
+    static interpolateColumns(sections, params, startField = null, endField = null) {
+        const poleCount = sections[0].length;
+        const grid = [];
+        let vBasis = null;
+        for (let i = 0; i < poleCount; i++) {
+            const column = sections.map(section => section[i]);
+            const interpolated = interpolateWithDerivatives(column, params, startField ? startField[i] : undefined, endField ? endField[i] : undefined);
+            grid.push(interpolated.poles);
+            vBasis = interpolated;
+        }
+        return { grid, vBasis: vBasis };
+    }
+    /**
+     * Loft parameters v_k in [0, 1] by chord length averaged over the pole
+     * columns (the standard skinning parameterization), plus the average
+     * flow-line length used to scale condition magnitudes.
+     */
+    static loftParameters(sections) {
+        const sectionCount = sections.length;
+        const poleCount = sections[0].poles.length;
+        const sums = new Array(sectionCount).fill(0);
+        let usableColumns = 0;
+        let totalLength = 0;
+        for (let i = 0; i < poleCount; i++) {
+            const cumulative = new Array(sectionCount).fill(0);
+            for (let k = 1; k < sectionCount; k++) {
+                const a = sections[k - 1].poles[i];
+                const b = sections[k].poles[i];
+                cumulative[k] = cumulative[k - 1] + Math.hypot(b[0] - a[0], b[1] - a[1], b[2] - a[2]);
+            }
+            const total = cumulative[sectionCount - 1];
+            if (total > 1e-12) {
+                usableColumns++;
+                totalLength += total;
+                for (let k = 1; k < sectionCount; k++) {
+                    sums[k] += cumulative[k] / total;
+                }
+            }
+        }
+        if (usableColumns === 0) {
+            throw new Error("Loft profiles are coincident — nothing to loft between.");
+        }
+        const params = sums.map(sum => sum / usableColumns);
+        params[0] = 0;
+        params[sectionCount - 1] = 1;
+        for (let k = 1; k < sectionCount; k++) {
+            if (params[k] <= params[k - 1]) {
+                throw new Error("Loft has coincident consecutive profiles.");
+            }
+        }
+        return { params, averageLength: totalLength / usableColumns };
+    }
+    /**
+     * The takeoff derivative per pole column at an end section. `normal` uses
+     * the section's plane normal (constant across the section — the surface
+     * leaves perpendicular everywhere); `tangent` uses the in-plane outward
+     * direction per column (winding tangent × section normal).
+     *
+     * At the last section the surface *arrives* rather than departs: a normal
+     * arrival still travels along the loft (no flip), but an outward-bulging
+     * tangent arrival must descend back from the bulge — the in-plane
+     * derivative flips inward so a positive magnitude bulges both ends outward.
+     */
+    static derivativeField(section, condition, averageLength, isEnd) {
+        const poleCount = section.poles.length;
+        let scale = condition.magnitude * averageLength;
+        if (condition.kind === "normal") {
+            const direction = section.normal.multiply(scale);
+            const vector = [direction.x, direction.y, direction.z];
+            return new Array(poleCount).fill(vector);
+        }
+        if (isEnd) {
+            scale = -scale;
+        }
+        // Closed sections repeat the first pole at the end; wrap around it so
+        // the seam column gets the same direction from both sides.
+        const field = [];
+        for (let i = 0; i < poleCount; i++) {
+            const previous = section.poles[i === 0 ? poleCount - 2 : i - 1];
+            const next = section.poles[i === poleCount - 1 ? 1 : i + 1];
+            const tangent = new Vector3d(next[0] - previous[0], next[1] - previous[1], next[2] - previous[2]);
+            let outward = tangent.cross(section.normal);
+            if (outward.length() < 1e-12) {
+                throw new Error("Loft tangent condition: profile winding is degenerate at a pole.");
+            }
+            outward = outward.normalize().multiply(scale);
+            field.push([outward.x, outward.y, outward.z]);
+        }
+        return field;
+    }
+    /**
+     * Builds the side surface from the pole grid, caps it with the exact
+     * boundary sections (the first and last v-columns of the grid), and sews
+     * everything into one correctly-oriented solid.
+     */
+    static buildLoftSolid(uBasis, grid, vBasis) {
+        const faces = Skinning.sideFaces(uBasis, grid, vBasis);
+        faces.push(Skinning.capFace(uBasis, grid.map(row => row[0])));
+        faces.push(Skinning.capFace(uBasis, grid.map(row => row[row.length - 1])));
+        return Skinning.sewSolid(faces);
+    }
+    /**
+     * The wall faces of a skinned grid, split at profile corners: a corner
+     * buried inside one face has no edge to render, select or fillet, and its
+     * mesh normals smear. Each u-range between creases (the seam is always a
+     * boundary) becomes its own face; smooth profiles keep the single closed
+     * face.
+     */
+    static sideFaces(uBasis, grid, vBasis) {
+        const oc = getOC();
+        const [poles, disposePoles] = NCollections.toArray2Pnt(grid);
+        const [uKnots, disposeUKnots] = NCollections.toArray1Double(uBasis.knots);
+        const [uMults, disposeUMults] = NCollections.toArray1Int(uBasis.multiplicities);
+        const [vKnots, disposeVKnots] = NCollections.toArray1Double(vBasis.knots);
+        const [vMults, disposeVMults] = NCollections.toArray1Int(vBasis.multiplicities);
+        let surface;
+        try {
+            if (uBasis.weights) {
+                const weightGrid = grid.map((row, uIndex) => row.map(() => uBasis.weights[uIndex]));
+                const [weights, disposeWeights] = NCollections.toArray2Double(weightGrid);
+                try {
+                    surface = new oc.Geom_BSplineSurface(poles, weights, uKnots, vKnots, uMults, vMults, uBasis.degree, vBasis.degree, false, false);
+                }
+                finally {
+                    disposeWeights();
+                }
+            }
+            else {
+                surface = new oc.Geom_BSplineSurface(poles, uKnots, vKnots, uMults, vMults, uBasis.degree, vBasis.degree, false, false);
+            }
+        }
+        finally {
+            disposePoles();
+            disposeUKnots();
+            disposeUMults();
+            disposeVKnots();
+            disposeVMults();
+        }
+        const ranges = Skinning.uRanges(uBasis);
+        const faces = [];
+        for (const [from, to] of ranges) {
+            let piece = surface;
+            if (ranges.length > 1) {
+                piece = oc.GeomConvert.SplitBSplineSurface(surface, from, to, true, 1e-9, true);
+            }
+            const faceMaker = new oc.BRepBuilderAPI_MakeFace(piece, Skinning.SEWING_TOLERANCE);
+            const isDone = faceMaker.IsDone();
+            if (isDone) {
+                faces.push(faceMaker.Face());
+            }
+            faceMaker.delete();
+            if (piece !== surface) {
+                piece.delete();
+            }
+            if (!isDone) {
+                surface.delete();
+                throw new Error("Loft failed to build its side surface.");
+            }
+        }
+        surface.delete();
+        return faces;
+    }
+    /** Sews faces into a watertight shell and wraps it into a solid. */
+    static sewSolid(faces) {
+        const oc = getOC();
+        const sewing = new oc.BRepBuilderAPI_Sewing(Skinning.SEWING_TOLERANCE, true, true, true, false);
+        for (const face of faces) {
+            sewing.Add(face);
+        }
+        const progress = new oc.Message_ProgressRange();
+        sewing.Perform(progress);
+        progress.delete();
+        if (sewing.NbFreeEdges() > 0) {
+            sewing.delete();
+            throw new Error("Loft surface and caps did not close into a watertight shell.");
+        }
+        const sewn = sewing.SewedShape();
+        sewing.delete();
+        return Skinning.solidFromShell(sewn);
+    }
+    /**
+     * The section's exact boundary as a wire, segmented at the same crease
+     * points as the wall faces so sewing pairs edges exactly.
+     */
+    static capWire(uBasis, poles) {
+        const oc = getOC();
+        const boundary = CurveData.build({
+            poles,
+            weights: uBasis.weights,
+            knots: uBasis.knots,
+            multiplicities: uBasis.multiplicities,
+            degree: uBasis.degree,
+        });
+        const ranges = Skinning.uRanges(uBasis);
+        const wireMaker = new oc.BRepBuilderAPI_MakeWire();
+        for (const [from, to] of ranges) {
+            let segment = boundary;
+            if (ranges.length > 1) {
+                segment = oc.GeomConvert.SplitBSplineCurve(boundary, from, to, 1e-9, true);
+            }
+            const edgeMaker = new oc.BRepBuilderAPI_MakeEdge(segment);
+            wireMaker.Add(edgeMaker.Edge());
+            edgeMaker.delete();
+            if (segment !== boundary) {
+                segment.delete();
+            }
+        }
+        boundary.delete();
+        const wire = wireMaker.Wire();
+        wireMaker.delete();
+        return wire;
+    }
+    /** Planar cap built from the section's exact boundary curve. */
+    static capFace(uBasis, poles) {
+        const oc = getOC();
+        const faceMaker = new oc.BRepBuilderAPI_MakeFace(Skinning.capWire(uBasis, poles), true);
+        if (!faceMaker.IsDone()) {
+            faceMaker.delete();
+            throw new Error("Loft could not cap a profile — guided and conditioned lofts require planar profiles.");
+        }
+        const face = faceMaker.Face();
+        faceMaker.delete();
+        return face;
+    }
+    /** Consecutive u-ranges between profile corners; one full range when the profile is smooth. */
+    static uRanges(uBasis) {
+        const bounds = [
+            uBasis.knots[0],
+            ...(uBasis.creases ?? []),
+            uBasis.knots[uBasis.knots.length - 1],
+        ];
+        const ranges = [];
+        for (let i = 0; i + 1 < bounds.length; i++) {
+            ranges.push([bounds[i], bounds[i + 1]]);
+        }
+        return ranges;
+    }
+    /** Wraps the sewn shell into a correctly-oriented solid. */
+    static solidFromShell(sewn) {
+        const oc = getOC();
+        let shellShape = sewn;
+        if (sewn.ShapeType() !== oc.TopAbs_ShapeEnum.TopAbs_SHELL) {
+            const shells = Explorer.findShapes(sewn, oc.TopAbs_ShapeEnum.TopAbs_SHELL);
+            if (shells.length !== 1) {
+                throw new Error("Loft sewing did not produce a single shell.");
+            }
+            shellShape = shells[0];
+        }
+        const builder = new oc.BRep_Builder();
+        let solid = new oc.TopoDS_Solid();
+        builder.MakeSolid(solid);
+        builder.Add(solid, oc.TopoDS.Shell(shellShape));
+        builder.delete();
+        if (ShapeProps.getProperties(solid).volumeMm3 < 0) {
+            solid = oc.TopoDS.Solid(solid.Reversed());
+        }
+        return Solid.fromTopoDSSolid(solid);
+    }
+}