fluidcad 0.0.38 → 0.0.39

package/lib/dist/features/loft.d.ts

@@ -1,21 +1,58 @@
 import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
-import { ILoft } from "../core/interfaces.js";
+import { LoftEndCondition } from "../oc/loft-ops.js";
+import { ILoft, LoftConditionType } from "../core/interfaces.js";
+import { type NumberParam } from "../core/param.js";
 import { ExtrudeBase } from "./extrude-base.js";
 export declare class Loft extends ExtrudeBase implements ILoft {
     private _profiles;
+    private _guides;
+    private _startCondition?;
+    private _endCondition?;
     constructor(...profiles: SceneObject[]);
     get profiles(): SceneObject[];
+    /**
+     * Adds side guide curves the loft surface must follow. FluidCAD supports
+     * one or two guides (the underlying OCC algorithm has no notion of more);
+     * each guide must pass through every profile.
+     */
+    guides(...guides: SceneObject[]): this;
+    /**
+     * Constrains how the surface leaves the first profile: 'normal' takes off
+     * perpendicular to the profile plane, 'tangent' takes off inside the
+     * profile plane (outward), 'none' clears the constraint. The magnitude
+     * scales the takeoff strength (default 1).
+     */
+    startCondition(type: LoftConditionType, magnitude?: NumberParam): this;
+    /**
+     * Constrains how the surface arrives at the last profile — see
+     * {@link startCondition}.
+     */
+    endCondition(type: LoftConditionType, magnitude?: NumberParam): this;
+    private static resolveCondition;
+    private hasConditions;
     validate(): void;
     build(context: BuildSceneObjectContext): void;
+    /**
+     * The options for `LoftOps.makeLoft`, with guide objects resolved to wires.
+     * A single guide argument may carry several separate curves (e.g. a sketch
+     * with a curve and its mirror) — each connected chain counts as one guide.
+     * Returns undefined for a plain loft, keeping the legacy multi-wire path
+     * untouched.
+     */
+    private resolveLoftOptions;
     private buildThinLoft;
     private getProfilePlane;
     private getWiresFromSceneObject;
     getDependencies(): SceneObject[];
     createCopy(remap: Map<SceneObject, SceneObject>): SceneObject;
     compareTo(other: Loft): boolean;
+    private static conditionsEqual;
     getType(): string;
     serialize(): {
         profiles: any[];
+        guides: any[];
+        startCondition: LoftEndCondition;
+        endCondition: LoftEndCondition;
         operationMode: "new" | "remove";
         thin: [number, number] | [number];
     };

package/lib/dist/features/loft.js

@@ -3,12 +3,16 @@ import { LoftOps } from "../oc/loft-ops.js";
 import { FaceMaker2 } from "../oc/face-maker2.js";
 import { FaceOps } from "../oc/face-ops.js";
 import { BooleanOps } from "../oc/boolean-ops.js";
-import { fuseWithSceneObjects, cutWithSceneObjects } from "../helpers/scene-helpers.js";
+import { resolveParam } from "../core/param.js";
+import { fuseWithSceneObjects, cutWithSceneObjects, wiresFromSceneObjectEdges } from "../helpers/scene-helpers.js";
 import { ExtrudeBase } from "./extrude-base.js";
 import { ThinFaceMaker } from "../oc/thin-face-maker.js";
 import { requireShapes } from "../common/operand-check.js";
 export class Loft extends ExtrudeBase {
     _profiles = [];
+    _guides = [];
+    _startCondition;
+    _endCondition;
     constructor(...profiles) {
         super();
         this._profiles = profiles;
@@ -16,19 +20,78 @@ export class Loft extends ExtrudeBase {
     get profiles() {
         return this._profiles;
     }
+    /**
+     * Adds side guide curves the loft surface must follow. FluidCAD supports
+     * one or two guides (the underlying OCC algorithm has no notion of more);
+     * each guide must pass through every profile.
+     */
+    guides(...guides) {
+        if (guides.length === 0) {
+            throw new Error("loft.guides: provide at least one guide curve.");
+        }
+        this._guides = guides;
+        return this;
+    }
+    /**
+     * Constrains how the surface leaves the first profile: 'normal' takes off
+     * perpendicular to the profile plane, 'tangent' takes off inside the
+     * profile plane (outward), 'none' clears the constraint. The magnitude
+     * scales the takeoff strength (default 1).
+     */
+    startCondition(type, magnitude) {
+        this._startCondition = Loft.resolveCondition("startCondition", type, magnitude);
+        return this;
+    }
+    /**
+     * Constrains how the surface arrives at the last profile — see
+     * {@link startCondition}.
+     */
+    endCondition(type, magnitude) {
+        this._endCondition = Loft.resolveCondition("endCondition", type, magnitude);
+        return this;
+    }
+    static resolveCondition(method, type, magnitude) {
+        if (type === "none") {
+            if (magnitude !== undefined) {
+                throw new Error(`loft.${method}: magnitude has no effect with 'none'.`);
+            }
+            return undefined;
+        }
+        if (type !== "normal" && type !== "tangent") {
+            throw new Error(`loft.${method}: expected 'none', 'normal' or 'tangent', got '${type}'.`);
+        }
+        const value = magnitude === undefined ? 1 : resolveParam(magnitude);
+        if (value === 0) {
+            throw new Error(`loft.${method}: magnitude must be non-zero.`);
+        }
+        return { kind: type, magnitude: value };
+    }
+    hasConditions() {
+        return this._startCondition !== undefined || this._endCondition !== undefined;
+    }
     validate() {
         for (let i = 0; i < this._profiles.length; i++) {
             requireShapes(this._profiles[i], `profile ${i + 1}`, "loft");
         }
+        for (let i = 0; i < this._guides.length; i++) {
+            requireShapes(this._guides[i], `guide ${i + 1}`, "loft");
+        }
+        if (this._guides.length > 2) {
+            throw new Error("Loft supports at most two guide curves.");
+        }
+        if (this._guides.length > 0 && this.isThin()) {
+            throw new Error("Loft guides cannot be combined with thin mode.");
+        }
     }
     build(context) {
         if (this.profiles.length < 2) {
             throw new Error("Loft requires at least two profiles.");
         }
         const p = context.getProfiler();
+        const options = p.record('Resolve loft options', () => this.resolveLoftOptions());
         let newShapes;
         if (this.isThin()) {
-            newShapes = p.record('Build thin loft', () => this.buildThinLoft());
+            newShapes = p.record('Build thin loft', () => this.buildThinLoft(options));
         }
         else {
             const allWires = [];
@@ -37,15 +100,21 @@ export class Loft extends ExtrudeBase {
                 if (wires.length === 0) {
                     throw new Error("Could not extract wire from profile.");
                 }
+                if (options && wires.length !== 1) {
+                    throw new Error("Loft with guides or start/end conditions requires exactly one region per profile.");
+                }
                 for (const wire of wires) {
                     allWires.push(wire);
                 }
             }
-            newShapes = p.record('Make loft', () => LoftOps.makeLoft(allWires));
+            newShapes = p.record('Make loft', () => LoftOps.makeLoft(allWires, options));
         }
         for (const profile of this.profiles) {
             profile.removeShapes(this);
         }
+        for (const guide of this._guides) {
+            guide.removeShapes(this);
+        }
         // Classify faces into start/end/side using profile planes
         const firstPlane = this.getProfilePlane(this.profiles[0]);
         const lastPlane = this.getProfilePlane(this.profiles[this.profiles.length - 1]);
@@ -102,7 +171,31 @@ export class Loft extends ExtrudeBase {
         this.classifyExtrudeEdges();
         this.setFinalShapes(this.getShapes());
     }
-    buildThinLoft() {
+    /**
+     * The options for `LoftOps.makeLoft`, with guide objects resolved to wires.
+     * A single guide argument may carry several separate curves (e.g. a sketch
+     * with a curve and its mirror) — each connected chain counts as one guide.
+     * Returns undefined for a plain loft, keeping the legacy multi-wire path
+     * untouched.
+     */
+    resolveLoftOptions() {
+        if (this._guides.length === 0 && !this.hasConditions()) {
+            return undefined;
+        }
+        let guides;
+        if (this._guides.length > 0) {
+            guides = this._guides.flatMap((guide, i) => wiresFromSceneObjectEdges(guide, `loft guide ${i + 1}`));
+            if (guides.length > 2) {
+                throw new Error(`Loft supports at most two guide curves, got ${guides.length}.`);
+            }
+        }
+        return {
+            startCondition: this._startCondition,
+            endCondition: this._endCondition,
+            guides,
+        };
+    }
+    buildThinLoft(options) {
         const outerWires = [];
         const innerWires = [];
         for (const profile of this.profiles) {
@@ -120,9 +213,15 @@ export class Loft extends ExtrudeBase {
                 }
             }
         }
-        const outerSolids = LoftOps.makeLoft(outerWires);
+        // With conditions, both walls come from the in-house skin — assemble the
+        // thin solid directly (walls + ring caps). Booleans between two
+        // nearly-parallel B-spline shells take OCC seconds.
+        if (options && innerWires.length > 0 && innerWires.length === outerWires.length) {
+            return LoftOps.makeThinLoft(outerWires, innerWires, options);
+        }
+        const outerSolids = LoftOps.makeLoft(outerWires, options);
         if (innerWires.length > 0 && innerWires.length === outerWires.length) {
-            const innerSolids = LoftOps.makeLoft(innerWires);
+            const innerSolids = LoftOps.makeLoft(innerWires, options);
             const outerFuse = BooleanOps.fuse(outerSolids);
             const innerFuse = BooleanOps.fuse(innerSolids);
             const cutResult = BooleanOps.cutShapes(outerFuse.result[0], innerFuse.result[0]);
@@ -187,11 +286,16 @@ export class Loft extends ExtrudeBase {
         return [];
     }
     getDependencies() {
-        return [...this._profiles];
+        return [...this._profiles, ...this._guides];
     }
     createCopy(remap) {
         const profiles = this._profiles.map(p => remap.get(p) || p);
-        return new Loft(...profiles).syncWith(this);
+        const copy = new Loft(...profiles);
+        copy.syncWith(this);
+        copy._guides = this._guides.map(g => remap.get(g) || g);
+        copy._startCondition = this._startCondition ? { ...this._startCondition } : undefined;
+        copy._endCondition = this._endCondition ? { ...this._endCondition } : undefined;
+        return copy;
     }
     compareTo(other) {
         if (!(other instanceof Loft)) {
@@ -208,14 +312,35 @@ export class Loft extends ExtrudeBase {
                 return false;
             }
         }
+        if (this._guides.length !== other._guides.length) {
+            return false;
+        }
+        for (let i = 0; i < this._guides.length; i++) {
+            if (!this._guides[i].compareTo(other._guides[i])) {
+                return false;
+            }
+        }
+        if (!Loft.conditionsEqual(this._startCondition, other._startCondition)
+            || !Loft.conditionsEqual(this._endCondition, other._endCondition)) {
+            return false;
+        }
         return true;
     }
+    static conditionsEqual(a, b) {
+        if (a === undefined || b === undefined) {
+            return a === b;
+        }
+        return a.kind === b.kind && a.magnitude === b.magnitude;
+    }
     getType() {
         return "loft";
     }
     serialize() {
         return {
             profiles: this.profiles.map(f => f.serialize()),
+            guides: this._guides.length > 0 ? this._guides.map(g => g.serialize()) : undefined,
+            startCondition: this._startCondition,
+            endCondition: this._endCondition,
             operationMode: this._operationMode !== 'add' ? this._operationMode : undefined,
             thin: this._thin,
         };

package/lib/dist/features/rib.js

@@ -57,8 +57,18 @@ export class Rib extends ExtrudeBase {
         let direction;
         let distance;
         if (this._parallel) {
+            // The in-plane extrude direction is plane.normal × spineDir — a cross
+            // product, hence a pseudovector. Under a mirror clone (repeat("mirror",
+            // …)) both operands are already reflected, and for a reflection
+            // M(a) × M(b) = −M(a × b): the recomputed perpendicular points to the
+            // opposite side, sending the mirrored rib the wrong way. Flip it back
+            // when this instance's clone transform is a reflection. Proper
+            // transforms (linear/circular/rotate repeats, det > 0) need no fix, and
+            // normal-mode direction (±plane.normal) is linear so it is never
+            // affected.
+            const mirrorSign = context.getTransform()?.isMirroring() ? -1 : 1;
             const perpDir = RibOps.computeSpinePerpendicularDirection(spineWire, plane);
-            direction = perpDir.multiply(dirSign);
+            direction = perpDir.multiply(dirSign * mirrorSign);
             distance = p.record('Compute extrude distance', () => RibOps.computeExtrudeDistanceAlongDirection(direction, plane.origin, scopeShapes));
         }
         else {

package/lib/dist/features/shell.d.ts

@@ -23,6 +23,6 @@ export declare class Shell extends SceneObject implements IShell {
     getType(): string;
     serialize(): {
         thickness: number;
-        joinType: "intersection" | "tangent";
+        joinType: "tangent" | "intersection";
     };
 }

package/lib/dist/features/shell.js

@@ -63,8 +63,17 @@ export class Shell extends SceneObject {
                 originalObj.removeShape(shape, this);
             }
             catch {
+                // OCCT's MakeThickSolid could not offset the inner wall. Keep the
+                // original (un-shelled) solid in the scene so downstream features
+                // still have geometry to work with, but surface the failure instead
+                // of silently serving an unchanged part.
                 newShapes.push(shape);
                 console.warn("Shell: Failed to create thick solid.");
+                this.setError("shell: could not hollow the solid — wall offset failed.\n" +
+                    "Hint: the wall may be thicker than a nearby feature or radius of " +
+                    "curvature, or a cut/groove may open onto a removed face. Try a " +
+                    "thinner wall, fewer/simpler open faces, or shelling before cutting " +
+                    "small features.");
             }
         }
         for (const sel of this.faceSelections) {

package/lib/dist/features/sweep.d.ts

@@ -1,11 +1,19 @@
 import { BuildSceneObjectContext, SceneObject } from "../common/scene-object.js";
 import { Extrudable } from "../helpers/types.js";
 import { ExtrudeBase } from "./extrude-base.js";
-import { ISweep } from "../core/interfaces.js";
+import { ISweep, SweepSide } from "../core/interfaces.js";
+import { type NumberParam } from "../core/param.js";
 export declare class Sweep extends ExtrudeBase implements ISweep {
     private _path;
+    private _extendStart?;
+    private _extendEnd?;
     constructor(path: SceneObject, extrudable?: Extrudable);
     get path(): SceneObject;
+    /**
+     * Extends the swept solid beyond the path at the given end by `amount`,
+     * continuing straight along the path's tangent there. Chain twice for both ends.
+     */
+    extend(side: SweepSide, amount: NumberParam): this;
     validate(): void;
     build(context: BuildSceneObjectContext): void;
     /** Plain sweep: classify by inner-wire detection on the start face. */
@@ -41,5 +49,7 @@ export declare class Sweep extends ExtrudeBase implements ISweep {
         extrudable: any;
         operationMode: "new" | "remove";
         thin: [number, number] | [number];
+        extendStart: number;
+        extendEnd: number;
     };
 }

package/lib/dist/features/sweep.js

@@ -1,13 +1,16 @@
 import { Explorer } from "../oc/explorer.js";
 import { SweepOps } from "../oc/sweep-ops.js";
-import { WireOps } from "../oc/wire-ops.js";
+import { WireExtendOps } from "../oc/wire-extend-ops.js";
 import { FaceMaker2 } from "../oc/face-maker2.js";
 import { ExtrudeBase } from "./extrude-base.js";
-import { cutWithSceneObjects } from "../helpers/scene-helpers.js";
+import { resolveParam } from "../core/param.js";
+import { cutWithSceneObjects, wireFromSceneObjectEdges } from "../helpers/scene-helpers.js";
 import { ThinFaceMaker } from "../oc/thin-face-maker.js";
 import { requireShapes } from "../common/operand-check.js";
 export class Sweep extends ExtrudeBase {
     _path;
+    _extendStart;
+    _extendEnd;
     constructor(path, extrudable) {
         super(extrudable);
         this._path = path;
@@ -15,6 +18,23 @@ export class Sweep extends ExtrudeBase {
     get path() {
         return this._path;
     }
+    /**
+     * Extends the swept solid beyond the path at the given end by `amount`,
+     * continuing straight along the path's tangent there. Chain twice for both ends.
+     */
+    extend(side, amount) {
+        const value = resolveParam(amount);
+        if (side === "start") {
+            this._extendStart = value;
+        }
+        else if (side === "end") {
+            this._extendEnd = value;
+        }
+        else {
+            throw new Error(`sweep.extend: side must be 'start' or 'end', got '${side}'.`);
+        }
+        return this;
+    }
     validate() {
         requireShapes(this._path, "path", "sweep");
     }
@@ -152,10 +172,14 @@ export class Sweep extends ExtrudeBase {
         this.finalizeAndFuse(solids, classified, context, { skipSimplify: true });
     }
     getSpineWire(pathObj) {
-        const shapes = pathObj.getShapes({ excludeMeta: false });
-        const edges = shapes.flatMap(s => s.getSubShapes('edge'));
-        console.log(`Sweep: Extracted ${edges.length} edges from path object for spine wire.`);
-        return WireOps.makeWireFromEdges(edges);
+        let wire = wireFromSceneObjectEdges(pathObj, "sweep path");
+        if (this._extendStart !== undefined) {
+            wire = WireExtendOps.extendWire(wire, "start", this._extendStart);
+        }
+        if (this._extendEnd !== undefined) {
+            wire = WireExtendOps.extendWire(wire, "end", this._extendEnd);
+        }
+        return wire;
     }
     getDependencies() {
         const deps = [];
@@ -172,7 +196,11 @@ export class Sweep extends ExtrudeBase {
             ? (remap.get(this.extrudable) || this.extrudable)
             : undefined;
         const path = remap.get(this._path) || this._path;
-        return new Sweep(path, extrudable).syncWith(this);
+        const copy = new Sweep(path, extrudable);
+        copy.syncWith(this);
+        copy._extendStart = this._extendStart;
+        copy._extendEnd = this._extendEnd;
+        return copy;
     }
     compareTo(other) {
         if (!(other instanceof Sweep)) {
@@ -187,6 +215,12 @@ export class Sweep extends ExtrudeBase {
         if (!this.extrudable.compareTo(other.extrudable)) {
             return false;
         }
+        if (this._extendStart !== other._extendStart) {
+            return false;
+        }
+        if (this._extendEnd !== other._extendEnd) {
+            return false;
+        }
         return true;
     }
     getType() {
@@ -198,6 +232,8 @@ export class Sweep extends ExtrudeBase {
             extrudable: this.extrudable.serialize(),
             operationMode: this._operationMode !== 'add' ? this._operationMode : undefined,
             thin: this._thin,
+            extendStart: this._extendStart,
+            extendEnd: this._extendEnd,
             ...this.serializePickFields(),
         };
     }

package/lib/dist/helpers/clone-transform.js

@@ -1,3 +1,6 @@
+import { GeometrySceneObject } from "../features/2d/geometry.js";
+import { Sketch } from "../features/2d/sketch.js";
+import { FrozenGeometry } from "../features/frozen-geometry.js";
 export function cloneWithTransform(objects, transform, container) {
     const visited = new Set();
     const ordered = [];
@@ -27,17 +30,71 @@ export function cloneWithTransform(objects, transform, container) {
     for (const obj of objects) {
         collectDeps(obj);
     }
+    // Sketch geometry whose owning sketch is part of the clone set rebuilds
+    // normally (on the cloned, transformed plane). But a repeated feature can
+    // also reference a bare curve that lives in a sketch *outside* the clone set
+    // (e.g. a sweep path `otherSketch.regions.foo`). That curve has no sketch
+    // ancestor among the clones, so it can't rebuild — `this.sketch` would be
+    // null. Freeze such geometry's built edges instead (see FrozenGeometry).
+    const clonedSketches = new Set();
+    for (const obj of ordered) {
+        if (obj instanceof Sketch) {
+            clonedSketches.add(obj);
+        }
+    }
+    const owningSketchInCloneSet = (geom) => {
+        let parent = geom.getParent();
+        while (parent && !(parent instanceof Sketch)) {
+            parent = parent.getParent();
+        }
+        return parent ? clonedSketches.has(parent) : false;
+    };
+    const isOrphanGeometry = (obj) => obj instanceof GeometrySceneObject && !owningSketchInCloneSet(obj);
+    // A boundary orphan is one a kept (non-orphan) clone — or a repeat root —
+    // actually references. Those get frozen; orphan geometry reachable only as
+    // the source curves of another orphan (e.g. the lines behind a fillet) is
+    // dropped, since the frozen edges already incorporate it.
+    const roots = new Set(objects);
+    const frozenSources = new Set();
+    for (const obj of ordered) {
+        if (isOrphanGeometry(obj)) {
+            if (roots.has(obj)) {
+                frozenSources.add(obj);
+            }
+            continue;
+        }
+        for (const dep of obj.getDependencies()) {
+            if (isOrphanGeometry(dep)) {
+                frozenSources.add(dep);
+            }
+        }
+    }
     const remap = new Map();
     const allCloned = [];
-    for (const obj of ordered) {
-        const copy = obj.createCopy(remap);
-        remap.set(obj, copy);
+    const registerClone = (source, copy) => {
+        remap.set(source, copy);
         copy.setTransform(transform);
-        copy.setCloneSource(obj);
-        if (obj.isReusable()) {
+        copy.setCloneSource(source);
+        if (source.isReusable()) {
             copy.reusable();
         }
         allCloned.push(copy);
+    };
+    // Freeze boundary orphans first so referring clones remap onto them. They
+    // hold baked edges and need no sketch parent, so they live under the
+    // container directly.
+    for (const source of frozenSources) {
+        const frozen = new FrozenGeometry(source);
+        registerClone(source, frozen);
+        container.addChildObject(frozen);
+    }
+    for (const obj of ordered) {
+        if (isOrphanGeometry(obj)) {
+            // Frozen above, or dropped as the source of a frozen curve.
+            continue;
+        }
+        const copy = obj.createCopy(remap);
+        registerClone(obj, copy);
         const parent = obj.getParent();
         if (parent && remap.has(parent)) {
             remap.get(parent).addChildObject(copy);

package/lib/dist/helpers/scene-helpers.d.ts

@@ -3,6 +3,18 @@ import { Shape } from "../common/shapes.js";
 import { Plane } from "../math/plane.js";
 import { ShapeHistory } from "../common/shape-history-tracker.js";
 import { Profiler } from "../common/profiler.js";
+import { Wire } from "../common/wire.js";
+/**
+ * Collects every edge of the object's shapes into one connected wire.
+ * Used by path-style inputs that need a single curve (sweep paths).
+ */
+export declare function wireFromSceneObjectEdges(obj: SceneObject, label: string): Wire;
+/**
+ * Groups the object's edges into connected chains — one wire per chain.
+ * Used by inputs that may carry several separate curves (e.g. a loft guide
+ * sketch holding a curve and its mirror).
+ */
+export declare function wiresFromSceneObjectEdges(obj: SceneObject, label: string): Wire[];
 export declare function fuseWithSceneObjects(sceneObjects: SceneObject[], extrusions: Shape<any>[], opts?: {
     glue?: 'full' | 'shift';
     recordHistoryFor?: SceneObject;

package/lib/dist/helpers/scene-helpers.js

@@ -7,6 +7,32 @@ import { Face } from "../common/face.js";
 import { Edge } from "../common/edge.js";
 import { getOC } from "../oc/init.js";
 import { ColorTransfer } from "../oc/color-transfer.js";
+import { WireOps } from "../oc/wire-ops.js";
+/**
+ * Collects every edge of the object's shapes into one connected wire.
+ * Used by path-style inputs that need a single curve (sweep paths).
+ */
+export function wireFromSceneObjectEdges(obj, label) {
+    const shapes = obj.getShapes({ excludeMeta: false });
+    const edges = shapes.flatMap(s => s.getSubShapes('edge'));
+    if (edges.length === 0) {
+        throw new Error(`${label} has no edges to build a curve from.`);
+    }
+    return WireOps.makeWireFromEdges(edges);
+}
+/**
+ * Groups the object's edges into connected chains — one wire per chain.
+ * Used by inputs that may carry several separate curves (e.g. a loft guide
+ * sketch holding a curve and its mirror).
+ */
+export function wiresFromSceneObjectEdges(obj, label) {
+    const shapes = obj.getShapes({ excludeMeta: false });
+    const edges = shapes.flatMap(s => s.getSubShapes('edge'));
+    if (edges.length === 0) {
+        throw new Error(`${label} has no edges to build a curve from.`);
+    }
+    return WireOps.connectEdgesToWires(edges);
+}
 export function fuseWithSceneObjects(sceneObjects, extrusions, opts) {
     const p = opts?.profiler;
     const modified = [];

package/lib/dist/math/bspline-interpolation.d.ts

@@ -1,13 +1,15 @@
 /**
- * Global B-spline interpolation of planar points (The NURBS Book, §9.2.1):
- * chord-length parameters, knots by averaging, and a banded linear system
- * solved densely. The resulting curve passes through every input point and
- * is C2 (for the cubic case).
+ * Global B-spline interpolation (The NURBS Book, §9.2.1–9.2.2): chord-length
+ * or caller-supplied parameters, knots by averaging, and a banded linear
+ * system solved densely. The resulting curve passes through every input
+ * point and is C2 (for the cubic case). Optional end-derivative constraints
+ * (§9.2.2) pin the takeoff/arrival tangent vectors exactly — used by the
+ * loft end conditions to control how a skinned surface leaves its profiles.
  *
  * Exists because fluidcad-ocjs currently miscompiles the `Geom2dAPI` fitting
  * classes (both their constructors and `Init` produce corrupted curves);
- * `Geom2d_BSplineCurve`'s array constructor is unaffected, so we compute the
- * poles/knots ourselves and hand them over.
+ * the `Geom_BSplineCurve`/`Geom2d_BSplineCurve` array constructors are
+ * unaffected, so we compute the poles/knots ourselves and hand them over.
  */
 export interface XY {
     x: number;
@@ -21,6 +23,31 @@ export interface BSpline2dData {
     multiplicities: number[];
     degree: number;
 }
+/** Dimension-agnostic interpolation result; each pole is one point (length = dimension). */
+export interface BSplineCurveData {
+    poles: number[][];
+    /** Distinct knot values (OCC convention). */
+    knots: number[];
+    /** Multiplicity per distinct knot. */
+    multiplicities: number[];
+    degree: number;
+}
+/** Largest knot span index whose half-open interval contains t. */
+export declare function findSpan(poleCount: number, degree: number, t: number, flatKnots: number[]): number;
+/** Nonzero basis function values N[span-degree .. span] at t (Cox–de Boor). */
+export declare function basisFunctions(span: number, t: number, degree: number, flatKnots: number[]): number[];
+/**
+ * Interpolates points (of any dimension) with a B-spline of degree up to 3,
+ * passing exactly through every point at the given parameters. Optional end
+ * derivatives constrain the curve's takeoff / arrival vectors (with respect
+ * to the same parameterization as `params`), adding one pole per constraint
+ * (The NURBS Book §9.2.2).
+ *
+ * With an end derivative D at a clamped end, the neighbouring pole is pinned
+ * directly (P1 = P0 + D·Δu/p and its mirror), so the constraint is exact and
+ * the linear system only solves for the remaining interior poles.
+ */
+export declare function interpolateWithDerivatives(points: ReadonlyArray<ReadonlyArray<number>>, params: ReadonlyArray<number>, startDerivative?: ReadonlyArray<number>, endDerivative?: ReadonlyArray<number>): BSplineCurveData;
 /**
  * Interpolates the given planar points with a B-spline of degree up to 3
  * (lower for 2 or 3 points). The curve passes exactly through every point,