fluidcad 0.0.37 → 0.0.39

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,

package/lib/dist/math/bspline-interpolation.js

@@ -1,16 +1,18 @@
 /**
- * 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.
  */
 /** Largest knot span index whose half-open interval contains t. */
-function findSpan(poleCount, degree, t, flatKnots) {
+export function findSpan(poleCount, degree, t, flatKnots) {
     const n = poleCount - 1;
     if (t >= flatKnots[n + 1]) {
         return n;
@@ -30,7 +32,7 @@ function findSpan(poleCount, degree, t, flatKnots) {
     return mid;
 }
 /** Nonzero basis function values N[span-degree .. span] at t (Cox–de Boor). */
-function basisFunctions(span, t, degree, flatKnots) {
+export function basisFunctions(span, t, degree, flatKnots) {
     const values = [1];
     const left = [];
     const right = [];
@@ -47,49 +49,73 @@ function basisFunctions(span, t, degree, flatKnots) {
     }
     return values;
 }
-/** Gaussian elimination with partial pivoting; solves A·x = b for both RHS columns. */
-function solveDense(matrix, rhsX, rhsY) {
+/**
+ * Gaussian elimination restricted to the matrix band; solves A·x = b for
+ * every RHS column at once. Mutates its inputs.
+ *
+ * B-spline collocation matrices are banded (bandwidth ≤ degree) and totally
+ * positive, so elimination without pivoting is stable (de Boor) — and the
+ * band restriction turns the O(n³) dense solve into O(n·b²), which is what
+ * makes dense-sample curve approximation affordable.
+ */
+function solveBanded(matrix, rhsColumns) {
     const n = matrix.length;
-    for (let col = 0; col < n; col++) {
-        let pivot = col;
-        for (let row = col + 1; row < n; row++) {
-            if (Math.abs(matrix[row][col]) > Math.abs(matrix[pivot][col])) {
-                pivot = row;
+    let lowerBandwidth = 0;
+    let upperBandwidth = 0;
+    for (let row = 0; row < n; row++) {
+        for (let col = 0; col < n; col++) {
+            if (matrix[row][col] !== 0) {
+                lowerBandwidth = Math.max(lowerBandwidth, row - col);
+                upperBandwidth = Math.max(upperBandwidth, col - row);
             }
         }
-        if (Math.abs(matrix[pivot][col]) < 1e-14) {
+    }
+    for (let col = 0; col < n; col++) {
+        if (Math.abs(matrix[col][col]) < 1e-14) {
             throw new Error("B-spline interpolation: singular system (degenerate or duplicate points)");
         }
-        if (pivot !== col) {
-            [matrix[pivot], matrix[col]] = [matrix[col], matrix[pivot]];
-            [rhsX[pivot], rhsX[col]] = [rhsX[col], rhsX[pivot]];
-            [rhsY[pivot], rhsY[col]] = [rhsY[col], rhsY[pivot]];
-        }
-        for (let row = col + 1; row < n; row++) {
+        const lastRow = Math.min(n - 1, col + lowerBandwidth);
+        const lastCol = Math.min(n - 1, col + upperBandwidth);
+        for (let row = col + 1; row <= lastRow; row++) {
             const factor = matrix[row][col] / matrix[col][col];
             if (factor === 0) {
                 continue;
             }
-            for (let k = col; k < n; k++) {
+            for (let k = col; k <= lastCol; k++) {
                 matrix[row][k] -= factor * matrix[col][k];
             }
-            rhsX[row] -= factor * rhsX[col];
-            rhsY[row] -= factor * rhsY[col];
+            for (const rhs of rhsColumns) {
+                rhs[row] -= factor * rhs[col];
+            }
         }
     }
-    const x = new Array(n);
-    const y = new Array(n);
+    const solutions = rhsColumns.map(() => new Array(n));
     for (let row = n - 1; row >= 0; row--) {
-        let sumX = rhsX[row];
-        let sumY = rhsY[row];
-        for (let k = row + 1; k < n; k++) {
-            sumX -= matrix[row][k] * x[k];
-            sumY -= matrix[row][k] * y[k];
+        const lastCol = Math.min(n - 1, row + upperBandwidth);
+        for (let d = 0; d < rhsColumns.length; d++) {
+            let sum = rhsColumns[d][row];
+            for (let k = row + 1; k <= lastCol; k++) {
+                sum -= matrix[row][k] * solutions[d][k];
+            }
+            solutions[d][row] = sum / matrix[row][row];
+        }
+    }
+    return solutions;
+}
+/** Converts a flat knot vector to OCC's distinct-knots + multiplicities. */
+function toDistinctKnots(flatKnots) {
+    const knots = [];
+    const multiplicities = [];
+    for (const knot of flatKnots) {
+        if (knots.length > 0 && knot === knots[knots.length - 1]) {
+            multiplicities[multiplicities.length - 1]++;
+        }
+        else {
+            knots.push(knot);
+            multiplicities.push(1);
         }
-        x[row] = sumX / matrix[row][row];
-        y[row] = sumY / matrix[row][row];
     }
-    return { x, y };
+    return { knots, multiplicities };
 }
 /** Drops consecutive points closer than a millionth of the total chord. */
 function dedupe(points) {
@@ -118,6 +144,127 @@ function dedupe(points) {
     }
     return result;
 }
+/**
+ * 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 function interpolateWithDerivatives(points, params, startDerivative, endDerivative) {
+    const pointCount = points.length;
+    if (pointCount < 2) {
+        throw new Error("B-spline interpolation needs at least two points");
+    }
+    if (params.length !== pointCount) {
+        throw new Error("B-spline interpolation: params must match points in length");
+    }
+    for (let i = 1; i < pointCount; i++) {
+        if (!(params[i] > params[i - 1])) {
+            throw new Error("B-spline interpolation: params must be strictly increasing");
+        }
+    }
+    const dimension = points[0].length;
+    for (const derivative of [startDerivative, endDerivative]) {
+        if (derivative && derivative.length !== dimension) {
+            throw new Error("B-spline interpolation: derivative dimension must match points");
+        }
+    }
+    const constraintCount = (startDerivative ? 1 : 0) + (endDerivative ? 1 : 0);
+    const poleCount = pointCount + constraintCount;
+    const degree = Math.min(3, poleCount - 1);
+    // Knots by averaging (NURBS book eq. 9.8) over a parameter list padded with
+    // one extra copy of the first/last parameter per derivative constraint —
+    // this reduces to eq. 9.8 unconstrained and to eq. 9.11 with both ends
+    // constrained, and keeps the collocation matrix nonsingular in between.
+    const padded = [params[0]];
+    if (startDerivative) {
+        padded.push(params[0]);
+    }
+    for (let i = 1; i < pointCount - 1; i++) {
+        padded.push(params[i]);
+    }
+    if (endDerivative) {
+        padded.push(params[pointCount - 1]);
+    }
+    padded.push(params[pointCount - 1]);
+    const flatKnots = [];
+    for (let i = 0; i <= degree; i++) {
+        flatKnots.push(params[0]);
+    }
+    for (let j = 1; j <= poleCount - 1 - degree; j++) {
+        let sum = 0;
+        for (let i = j; i <= j + degree - 1; i++) {
+            sum += padded[i];
+        }
+        flatKnots.push(sum / degree);
+    }
+    for (let i = 0; i <= degree; i++) {
+        flatKnots.push(params[pointCount - 1]);
+    }
+    // Pinned poles: clamped endpoints, plus the derivative neighbours.
+    const poles = new Array(poleCount).fill(null);
+    poles[0] = [...points[0]];
+    poles[poleCount - 1] = [...points[pointCount - 1]];
+    if (startDerivative) {
+        const span = (flatKnots[degree + 1] - params[0]) / degree;
+        poles[1] = points[0].map((v, d) => v + startDerivative[d] * span);
+    }
+    if (endDerivative) {
+        const span = (params[pointCount - 1] - flatKnots[poleCount - 1]) / degree;
+        poles[poleCount - 2] = points[pointCount - 1].map((v, d) => v - endDerivative[d] * span);
+    }
+    const unknownIndices = [];
+    for (let i = 0; i < poleCount; i++) {
+        if (poles[i] === null) {
+            unknownIndices.push(i);
+        }
+    }
+    if (unknownIndices.length > 0) {
+        const columnOfPole = new Map();
+        unknownIndices.forEach((poleIndex, column) => columnOfPole.set(poleIndex, column));
+        // One collocation row per interior point; pinned poles move to the RHS.
+        const matrix = [];
+        const rhsColumns = Array.from({ length: dimension }, () => []);
+        for (let k = 1; k <= pointCount - 2; k++) {
+            const row = new Array(unknownIndices.length).fill(0);
+            const rhs = [...points[k]];
+            const span = findSpan(poleCount, degree, params[k], flatKnots);
+            const values = basisFunctions(span, params[k], degree, flatKnots);
+            for (let j = 0; j <= degree; j++) {
+                const poleIndex = span - degree + j;
+                const pinned = poles[poleIndex];
+                if (pinned) {
+                    for (let d = 0; d < dimension; d++) {
+                        rhs[d] -= values[j] * pinned[d];
+                    }
+                }
+                else {
+                    row[columnOfPole.get(poleIndex)] = values[j];
+                }
+            }
+            matrix.push(row);
+            for (let d = 0; d < dimension; d++) {
+                rhsColumns[d].push(rhs[d]);
+            }
+        }
+        const solved = solveBanded(matrix, rhsColumns);
+        unknownIndices.forEach((poleIndex, column) => {
+            poles[poleIndex] = solved.map(solution => solution[column]);
+        });
+    }
+    const { knots, multiplicities } = toDistinctKnots(flatKnots);
+    return {
+        poles: poles,
+        knots,
+        multiplicities,
+        degree,
+    };
+}
 /**
  * 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,
@@ -129,7 +276,6 @@ export function interpolateBSpline2d(rawPoints) {
         throw new Error("B-spline interpolation needs at least two distinct points");
     }
     const n = points.length - 1;
-    const degree = Math.min(3, n);
     // Chord-length parameters, normalized to [0, 1].
     const params = new Array(points.length);
     params[0] = 0;
@@ -141,54 +287,11 @@ export function interpolateBSpline2d(rawPoints) {
         params[i] /= total;
     }
     params[n] = 1;
-    // Knots by averaging (NURBS book eq. 9.8): clamped ends, one internal knot
-    // per unconstrained pole.
-    const flatKnots = [];
-    for (let i = 0; i <= degree; i++) {
-        flatKnots.push(0);
-    }
-    for (let j = 1; j <= n - degree; j++) {
-        let sum = 0;
-        for (let i = j; i <= j + degree - 1; i++) {
-            sum += params[i];
-        }
-        flatKnots.push(sum / degree);
-    }
-    for (let i = 0; i <= degree; i++) {
-        flatKnots.push(1);
-    }
-    // Interpolation system: one basis row per parameter.
-    const matrix = [];
-    const rhsX = [];
-    const rhsY = [];
-    for (let k = 0; k <= n; k++) {
-        const row = new Array(n + 1).fill(0);
-        const span = findSpan(n + 1, degree, params[k], flatKnots);
-        const values = basisFunctions(span, params[k], degree, flatKnots);
-        for (let j = 0; j <= degree; j++) {
-            row[span - degree + j] = values[j];
-        }
-        matrix.push(row);
-        rhsX.push(points[k].x);
-        rhsY.push(points[k].y);
-    }
-    const solved = solveDense(matrix, rhsX, rhsY);
-    // Convert the flat knot vector to OCC's distinct-knots + multiplicities.
-    const knots = [];
-    const multiplicities = [];
-    for (const knot of flatKnots) {
-        if (knots.length > 0 && knot === knots[knots.length - 1]) {
-            multiplicities[multiplicities.length - 1]++;
-        }
-        else {
-            knots.push(knot);
-            multiplicities.push(1);
-        }
-    }
+    const data = interpolateWithDerivatives(points.map(p => [p.x, p.y]), params);
     return {
-        poles: solved.x.map((x, i) => ({ x, y: solved.y[i] })),
-        knots,
-        multiplicities,
-        degree,
+        poles: data.poles.map(p => ({ x: p[0], y: p[1] })),
+        knots: data.knots,
+        multiplicities: data.multiplicities,
+        degree: data.degree,
     };
 }