okgeometry-api 1.11.1 → 1.15.0

package/src/Mesh.ts

@@ -1277,7 +1277,12 @@ export class Mesh {
 
   /**
    * Build a planar arc from center, start, and end points.
-   * Uses the shortest signed sweep between start and end around `normal`.
+   * Without `sweepHint` the shortest signed sweep between start and end
+   * around `normal` is used. With `sweepHint` (signed radians, typically the
+   * sweep from the previous interactive update or a stored arc parameter),
+   * the sweep candidate closest to the hint is chosen instead — this tracks
+   * the user's winding direction continuously through 180° and up to just
+   * under a full circle.
    */
   static buildPlanarArcCenterStartEnd(
     center: Point,
@@ -1285,6 +1290,7 @@ export class Mesh {
     endPoint: Point,
     normal: Vec3,
     segments = 64,
+    sweepHint?: number,
   ): PlanarArc {
     const n = normal.normalize();
     const minSegments = Math.max(2, Math.floor(segments));
@@ -1311,7 +1317,8 @@ export class Mesh {
     const basis = Mesh.resolveArcBasis(center, radius, n);
     const startAngle = Mesh.angleOnBasis(startVec, basis.uAxis, basis.vAxis);
     const endAngleRaw = Mesh.angleOnBasis(endVec.scale(radius / endLen), basis.uAxis, basis.vAxis);
-    const sweepAngle = Mesh.normalizeSignedAngle(endAngleRaw - startAngle);
+    const shortestSweep = Mesh.normalizeSignedAngle(endAngleRaw - startAngle);
+    const sweepAngle = Mesh.resolveSweepWithHint(shortestSweep, sweepHint);
     if (Math.abs(sweepAngle) < 1e-9) {
       return {
         points: [],
@@ -1440,6 +1447,93 @@ export class Mesh {
     };
   }
 
+  /**
+   * Build a planar arc through three points: `startPoint`, a point the arc
+   * passes through, and `endPoint`. All points are projected to the plane
+   * through `startPoint` orthogonal to `normal`; the circle is the
+   * circumcircle of the projected points and the sweep direction is the one
+   * that passes through `throughPoint` (any sweep up to a full circle).
+   * Returns null when the points are (near) collinear or coincident.
+   */
+  static buildPlanarArcThreePoint(
+    startPoint: Point,
+    throughPoint: Point,
+    endPoint: Point,
+    normal: Vec3,
+    segments = 64,
+  ): PlanarArc | null {
+    const n = normal.normalize();
+    const minSegments = Math.max(2, Math.floor(segments));
+    const a = Mesh.projectPointToPlane(startPoint, startPoint, n);
+    const b = Mesh.projectPointToPlane(throughPoint, startPoint, n);
+    const c = Mesh.projectPointToPlane(endPoint, startPoint, n);
+
+    const ab = b.sub(a);
+    const ac = c.sub(a);
+    const scale = Math.max(ab.length(), ac.length());
+    const cross = ab.cross(ac);
+    const crossLen = cross.length();
+    if (scale < 1e-12 || crossLen < 1e-9 * scale * scale) {
+      return null;
+    }
+
+    // Circumcenter: A + ((|ab|²·ac − |ac|²·ab) × (ab × ac)) / (2·|ab × ac|²)
+    const numerator = ac.scale(ab.dot(ab)).sub(ab.scale(ac.dot(ac)));
+    const center = a.add(numerator.cross(cross).scale(1 / (2 * cross.dot(cross))));
+    const radius = a.sub(center).length();
+    if (radius < 1e-12) {
+      return null;
+    }
+
+    const basis = Mesh.resolveArcBasis(center, radius, n);
+    const twoPi = Math.PI * 2;
+    const startAngle = Mesh.angleOnBasis(a.sub(center), basis.uAxis, basis.vAxis);
+    const throughAngle = Mesh.angleOnBasis(b.sub(center), basis.uAxis, basis.vAxis);
+    const endAngleRaw = Mesh.angleOnBasis(c.sub(center), basis.uAxis, basis.vAxis);
+
+    const ccwSweep = ((endAngleRaw - startAngle) % twoPi + twoPi) % twoPi;
+    const ccwThrough = ((throughAngle - startAngle) % twoPi + twoPi) % twoPi;
+    if (ccwSweep < 1e-9 || twoPi - ccwSweep < 1e-9) {
+      return null;
+    }
+    const sweepAngle = ccwThrough <= ccwSweep ? ccwSweep : ccwSweep - twoPi;
+    const endAngle = startAngle + sweepAngle;
+    const arc = new Arc(center, radius, startAngle, endAngle, n);
+    return {
+      points: arc.sample(minSegments),
+      center,
+      radius,
+      startAngle,
+      endAngle,
+      sweepAngle,
+    };
+  }
+
+  /** Largest supported arc sweep — just under a full circle keeps arcs open. */
+  private static readonly MAX_ARC_SWEEP = Math.PI * 2 - 1e-4;
+
+  /**
+   * Pick the sweep equivalent (shortest, +2π, or −2π) closest to `hint`,
+   * clamped to just under a full circle. Without a hint the shortest sweep
+   * is kept.
+   */
+  private static resolveSweepWithHint(shortestSweep: number, hint?: number): number {
+    if (hint === undefined || !Number.isFinite(hint)) {
+      return shortestSweep;
+    }
+    const twoPi = Math.PI * 2;
+    let best = shortestSweep;
+    let bestDistance = Math.abs(shortestSweep - hint);
+    for (const candidate of [shortestSweep + twoPi, shortestSweep - twoPi]) {
+      const distance = Math.abs(candidate - hint);
+      if (distance < bestDistance) {
+        best = candidate;
+        bestDistance = distance;
+      }
+    }
+    return Math.max(-Mesh.MAX_ARC_SWEEP, Math.min(Mesh.MAX_ARC_SWEEP, best));
+  }
+
   private static resolveArcBasis(
     center: Point,
     radius: number,
@@ -2901,6 +2995,179 @@ export class Mesh {
     return { inside, outside };
   }
 
+  /**
+   * Compute all transversal crossing points of a polyline with this mesh.
+   * Works on OPEN meshes (sheets) — unlike `clipPolyline`, the mesh is NOT
+   * required to be a closed volume.
+   *
+   * Hits are deduplicated (shared-edge / shared-vertex crossings merge into
+   * one, keeping the smallest triangle index) and sorted by
+   * (segmentIndex, segmentT). Coplanar sliding overlaps yield no hits.
+   * Segment `i` runs from point `i` to point `(i + 1) % n`; open polylines
+   * have n − 1 segments, closed ones n (the wrap segment).
+   *
+   * @param polyline - Polyline (closedness inferred) or raw point list
+   * @param closed - Treat the points as a closed loop (defaults to the
+   *   polyline's own closedness; required when passing a raw point list)
+   * @returns Crossings with the 3D point, segment index/parameter, and
+   *   triangle index
+   */
+  intersectPolyline(
+    polyline: Polyline | Point[],
+    closed?: boolean,
+  ): { point: Point; segmentIndex: number; segmentT: number; triangleIndex: number }[] {
+    ensureInit();
+    const { flat, isClosed } = Mesh.flattenPolylineArg(polyline, closed, "Mesh.intersectPolyline");
+    const buf = wasm.mesh_polyline_intersection_points(
+      this._vertexCount,
+      this._buffer,
+      flat,
+      isClosed,
+    );
+    if (buf.length === 0) {
+      throw new Error(
+        "Mesh.intersectPolyline failed — the mesh and polyline must be non-degenerate.",
+      );
+    }
+    const count = buf[0];
+    const hits: { point: Point; segmentIndex: number; segmentT: number; triangleIndex: number }[] = [];
+    for (let i = 0; i < count; i++) {
+      const off = 1 + i * 6;
+      hits.push({
+        point: new Point(buf[off], buf[off + 1], buf[off + 2]),
+        segmentIndex: buf[off + 3],
+        segmentT: buf[off + 4],
+        triangleIndex: buf[off + 5],
+      });
+    }
+    return hits;
+  }
+
+  /**
+   * Split a polyline into pieces at every crossing with this mesh (open
+   * sheets allowed). Hit points become the shared endpoints of adjacent
+   * pieces; a closed loop is opened at the first crossing (N crossings → N
+   * pieces), an open polyline yields N + 1 pieces. With no crossings the
+   * original polyline comes back as one piece. Pieces are NOT classified —
+   * use `clipPolyline` (closed volume, containment) or
+   * `clipPolylineBySheet` (oriented sheet, signed side) for classification.
+   *
+   * @param polyline - Polyline (closedness inferred) or raw point list
+   * @param closed - Treat the points as a closed loop (defaults to the
+   *   polyline's own closedness; required when passing a raw point list)
+   * @returns Polyline pieces in order along the input
+   */
+  splitPolyline(polyline: Polyline | Point[], closed?: boolean): Polyline[] {
+    ensureInit();
+    const { flat, isClosed } = Mesh.flattenPolylineArg(polyline, closed, "Mesh.splitPolyline");
+    const buf = wasm.mesh_split_polyline(this._vertexCount, this._buffer, flat, isClosed);
+    if (buf.length === 0) {
+      throw new Error(
+        "Mesh.splitPolyline failed — the mesh and polyline must be non-degenerate.",
+      );
+    }
+    return parsePolylineBuf(buf).map(pts => new Polyline(pts));
+  }
+
+  /**
+   * Clip a polyline by this mesh treated as an OPEN oriented sheet: the
+   * polyline is split at every crossing and each piece is classified by the
+   * SIGNED SIDE of the sheet — `inside` = in FRONT of the sheet normal,
+   * `outside` = behind it (the mesh's stored winding defines the normals).
+   *
+   * This is side classification, NOT containment — unlike `clipPolyline`,
+   * which requires a CLOSED volume: the sheet may be open, and pieces far
+   * from it still classify deterministically by the nearest facet's normal.
+   * Pieces lying ON the sheet default to `inside`. Adjacent same-side pieces
+   * (e.g. from a touch, not a crossing) merge back into one run; closed
+   * loops merge the run spanning the seam.
+   *
+   * @param polyline - Polyline (closedness inferred) or raw point list
+   * @param closed - Treat the points as a closed loop (defaults to the
+   *   polyline's own closedness; required when passing a raw point list)
+   */
+  clipPolylineBySheet(
+    polyline: Polyline | Point[],
+    closed?: boolean,
+  ): { inside: Polyline[]; outside: Polyline[] } {
+    ensureInit();
+    const { flat, isClosed } = Mesh.flattenPolylineArg(
+      polyline,
+      closed,
+      "Mesh.clipPolylineBySheet",
+    );
+    const buf = wasm.mesh_clip_polyline_by_sheet(this._vertexCount, this._buffer, flat, isClosed);
+    if (buf.length === 0) {
+      throw new Error(
+        "Mesh.clipPolylineBySheet failed — the sheet and polyline must be non-degenerate.",
+      );
+    }
+    // Two concatenated polyline groups: inside first, then outside — same
+    // packing as clipPolyline.
+    let idx = 0;
+    const readGroup = (): Polyline[] => {
+      const group: Polyline[] = [];
+      const count = buf[idx++];
+      for (let i = 0; i < count; i++) {
+        const n = buf[idx++];
+        const points: Point[] = [];
+        for (let k = 0; k < n; k++) {
+          points.push(new Point(buf[idx], buf[idx + 1], buf[idx + 2]));
+          idx += 3;
+        }
+        if (points.length >= 2) group.push(new Polyline(points));
+      }
+      return group;
+    };
+    const inside = readGroup();
+    const outside = readGroup();
+    return { inside, outside };
+  }
+
+  /**
+   * Flatten a Polyline-or-points argument into WASM coords + closed flag.
+   *
+   * Closed inputs following the duplicated-seam convention (terminal point
+   * repeating the first) have the duplicate STRIPPED before crossing the
+   * boundary — the kernel's closed-polyline encoding is seam-free (the wrap
+   * segment is implicit), and a duplicated seam would add a zero-length wrap
+   * segment / doubled seam vertex to split pieces.
+   */
+  private static flattenPolylineArg(
+    polyline: Polyline | Point[],
+    closed: boolean | undefined,
+    context: string,
+  ): { flat: Float64Array; isClosed: boolean } {
+    let pts = Array.isArray(polyline) ? polyline : polyline.points;
+    if (pts.length < 2) {
+      throw new Error(`${context} needs at least 2 polyline points`);
+    }
+    const isClosed = closed ?? (!Array.isArray(polyline) && polyline.isClosed());
+    if (isClosed && pts.length > 2) {
+      // Scale-relative epsilon for the duplicate-seam test.
+      let maxAbs = 0;
+      for (const p of pts) {
+        maxAbs = Math.max(maxAbs, Math.abs(p.x), Math.abs(p.y), Math.abs(p.z));
+      }
+      const eps = (1 + maxAbs) * 1e-12;
+      const first = pts[0];
+      const last = pts[pts.length - 1];
+      const dx = first.x - last.x;
+      const dy = first.y - last.y;
+      const dz = first.z - last.z;
+      if (Math.sqrt(dx * dx + dy * dy + dz * dz) <= eps) {
+        pts = pts.slice(0, -1);
+      }
+    }
+    const flat = new Float64Array(pts.length * 3);
+    for (let i = 0; i < pts.length; i++) {
+      flat[i * 3] = pts[i].x;
+      flat[i * 3 + 1] = pts[i].y;
+      flat[i * 3 + 2] = pts[i].z;
+    }
+    return { flat, isClosed };
+  }
+
   /**
    * Apply a 4x4 transformation matrix.
    * @param matrix - Row-major flat array of 16 numbers
@@ -3116,6 +3383,37 @@ export class Mesh {
     return new Point(r[0], r[1], r[2]);
   }
 
+  /**
+   * Boundary loops of the coplanar edge-connected face group containing
+   * faceIndex. Each loop is a closed polygon (winding preserved, collinear
+   * subdivision points collapsed); the closing edge back to the first point
+   * is implicit.
+   */
+  getFaceBoundaryLoops(faceIndex: number): Point[][] {
+    ensureInit();
+    if (!Number.isFinite(faceIndex) || faceIndex < 0) return [];
+    const r = wasm.mesh_get_face_boundary_loops(
+      this._vertexCount,
+      this._buffer,
+      Math.floor(faceIndex),
+    );
+    if (!r || r.length < 1) return [];
+    const loopCount = Math.floor(r[0]);
+    const loops: Point[][] = [];
+    let offset = 1;
+    for (let l = 0; l < loopCount && offset < r.length; l++) {
+      const pointCount = Math.floor(r[offset]);
+      offset += 1;
+      const loop: Point[] = [];
+      for (let i = 0; i < pointCount && offset + 2 < r.length; i++) {
+        loop.push(new Point(r[offset], r[offset + 1], r[offset + 2]));
+        offset += 3;
+      }
+      if (loop.length >= 3) loops.push(loop);
+    }
+    return loops;
+  }
+
   /**
    * Unique edge count for this triangulated mesh.
    */

package/src/NurbsCurve.ts

@@ -7,6 +7,8 @@ import { Polyline } from "./Polyline.js";
 import { PolyCurve } from "./PolyCurve.js";
 import type { Line } from "./Line.js";
 import type { Arc } from "./Arc.js";
+import type { NurbsSurface } from "./NurbsSurface.js";
+import type { Brep } from "./Brep.js";
 import type { CurveOffsetOptions, RotationAxis } from "./types.js";
 import * as wasm from "./wasm-bindings.js";
 
@@ -110,6 +112,133 @@ export class NurbsCurve {
     return pts;
   }
 
+  /**
+   * Find all intersections with another NURBS curve, with exact parameters.
+   *
+   * Parameters are normalized to [0, 1] (the same parameterization as
+   * `pointAt`), so `this.pointAt(paramA)` and `other.pointAt(paramB)` both
+   * reproduce `point` up to the convergence tolerance. Results are sorted by
+   * `paramA`. Coincident (overlapping) curve runs yield NO points — identical
+   * curves return an empty array.
+   *
+   * @param other - Other curve to intersect with
+   * @returns Intersections with the 3D point and the parameter on each curve
+   */
+  intersectCurveParams(other: NurbsCurve): { point: Point; paramA: number; paramB: number }[] {
+    ensureInit();
+    const buf = wasm.nurbs_curve_curve_intersect_params(this._data, other._data);
+    if (buf.length === 0) return [];
+    const count = buf[0];
+    const hits: { point: Point; paramA: number; paramB: number }[] = [];
+    for (let i = 0; i < count; i++) {
+      const off = 1 + i * 5;
+      hits.push({
+        point: new Point(buf[off], buf[off + 1], buf[off + 2]),
+        paramA: buf[off + 3],
+        paramB: buf[off + 4],
+      });
+    }
+    return hits;
+  }
+
+  /**
+   * Find all isolated intersections with a NURBS surface, with exact
+   * parameters.
+   *
+   * All parameters are normalized to [0, 1]: `this.pointAt(curveParam)` and
+   * `surface.evaluate(u, v)` both reproduce `point` up to the convergence
+   * tolerance. Results are sorted by `curveParam`. Curve segments lying ON
+   * the surface (coincident runs) yield no points — a line inside a planar
+   * surface returns an empty array.
+   *
+   * @param surface - Surface to intersect with
+   * @returns Intersections with the 3D point, curve parameter, and surface (u, v)
+   */
+  intersectSurfaceExact(
+    surface: NurbsSurface,
+  ): { point: Point; curveParam: number; u: number; v: number }[] {
+    ensureInit();
+    const buf = wasm.nurbs_curve_surface_intersect_exact(this._data, surface.data);
+    if (buf.length === 0) return [];
+    const count = buf[0];
+    const hits: { point: Point; curveParam: number; u: number; v: number }[] = [];
+    for (let i = 0; i < count; i++) {
+      const off = 1 + i * 6;
+      hits.push({
+        point: new Point(buf[off], buf[off + 1], buf[off + 2]),
+        curveParam: buf[off + 3],
+        u: buf[off + 4],
+        v: buf[off + 5],
+      });
+    }
+    return hits;
+  }
+
+  /**
+   * Find intersection points with a NURBS surface.
+   * Point-only convenience wrapper around `intersectSurfaceExact`.
+   * @param surface - Surface to intersect with
+   * @returns Array of intersection points, sorted along the curve
+   */
+  intersectSurface(surface: NurbsSurface): Point[] {
+    return this.intersectSurfaceExact(surface).map(hit => hit.point);
+  }
+
+  /**
+   * Boolean-intersection clip of this curve against a CLOSED solid Brep —
+   * delegate for {@link Brep.clipCurve}: the curve is split EXACTLY (knot
+   * insertion) at every boundary crossing and each piece is classified by
+   * containment, so every returned piece lies exactly on this curve. Throws
+   * when the Brep is not a closed solid.
+   *
+   * @param brep - Closed solid BREP to clip against
+   * @returns Exact sub-curves inside and outside the solid
+   */
+  clipByBrep(brep: Brep): { inside: NurbsCurve[]; outside: NurbsCurve[] } {
+    return brep.clipCurve(this);
+  }
+
+  /**
+   * Split this curve at multiple normalized parameters t in [0, 1].
+   *
+   * Splitting is exact (knot insertion), so every returned piece lies exactly
+   * on this curve. Parameters are sorted, deduplicated, and clamped
+   * internally. Closed curves are opened at the FIRST parameter (N interior
+   * parameters yield N pieces, the seam-spanning piece rejoined); open curves
+   * yield N + 1 pieces. With no valid parameters the (clamped) curve comes
+   * back as the single piece.
+   *
+   * @param params - Normalized split parameters in [0, 1]
+   * @param closed - Explicit topology override. `true` forces closed
+   *   (seam-rejoin) semantics; `false` forces open semantics — an open curve
+   *   whose endpoints merely coincide (a C-shape drawn back onto its start)
+   *   keeps its N + 1 pieces. Omit to infer closedness geometrically from the
+   *   endpoint distance (the historical behavior).
+   * @returns Curve pieces in parameter order
+   */
+  splitAtParams(params: number[], closed?: boolean): NurbsCurve[] {
+    ensureInit();
+    const closedHint = closed === undefined ? -1 : closed ? 1 : 0;
+    const buf = wasm.nurbs_curve_split_at_params(
+      this._data,
+      new Float64Array(params),
+      closedHint
+    );
+    if (buf.length === 0) {
+      throw new Error("NurbsCurve.splitAtParams failed — malformed curve data");
+    }
+    // Packing: [curveCount, (bufLen, curveData…)·curveCount]
+    const count = buf[0];
+    const pieces: NurbsCurve[] = [];
+    let idx = 1;
+    for (let i = 0; i < count; i++) {
+      const len = buf[idx++];
+      pieces.push(NurbsCurve.fromData(buf.subarray(idx, idx + len)));
+      idx += len;
+    }
+    return pieces;
+  }
+
   /**
    * Translate this curve by an offset vector.
    * @param offset - Translation vector

package/src/NurbsSurface.ts

@@ -147,6 +147,47 @@ export class NurbsSurface implements Surface {
     return parsePolylineBuf(buf).map(pts => new Polyline(pts));
   }
 
+  /**
+   * EXACT intersection curves with another NURBS surface.
+   *
+   * Unlike {@link intersectSurface} (tessellation-based, returns polylines at
+   * a fixed sampling resolution), this runs the parametric boolean's
+   * surface–surface intersection pipeline — seeded tri-tri detection,
+   * chaining, and Newton/tangent-plane relaxation of every point onto the
+   * true intersection — and fits each chain to an interpolating NURBS curve,
+   * densified until the fitted curve stays within `tolerance` of the exact
+   * intersection.
+   *
+   * Closed intersection loops (e.g. cylinder × plane) come back as ONE closed
+   * curve. Coincident (overlapping) surfaces return an empty array — their
+   * overlap is a 2D region, not a curve set.
+   *
+   * @param other - Other surface to intersect with
+   * @param tolerance - Absolute geometric tolerance of the fitted curves
+   *   (model units; floored relative to the combined model scale)
+   * @returns Exact fitted NURBS intersection curves
+   */
+  intersectSurfaceCurves(other: NurbsSurface, tolerance = 1e-6): NurbsCurve[] {
+    ensureInit();
+    const buf = wasm.nurbs_surface_surface_intersect_curves(this._data, other._data, tolerance);
+    return NurbsSurface.parseCurveList(buf);
+  }
+
+  /** Parse [count, (bufLen, curveData…)·count] into NurbsCurves. */
+  private static parseCurveList(buf: Float64Array): NurbsCurve[] {
+    if (buf.length < 1) return [];
+    const out: NurbsCurve[] = [];
+    const count = Number(buf[0]);
+    let offset = 1;
+    for (let k = 0; k < count && offset < buf.length; k++) {
+      const len = Number(buf[offset]);
+      offset += 1;
+      out.push(NurbsCurve.fromData(buf.subarray(offset, offset + len)));
+      offset += len;
+    }
+    return out;
+  }
+
   /**
    * Convert any supported curve type to a NurbsCurve.
    * @param c - Curve to convert
@@ -176,11 +217,19 @@ export class NurbsSurface implements Surface {
     // Step 0: Convert all curves to NurbsCurve
     const nurbsCurves = curves.map(c => NurbsSurface.toNurbs(c));
 
-    // Step 1: Make curves compatible (unified knot vectors, same CP count)
+    // Step 1: Make curves compatible (same degree, unified knot vectors,
+    // same CP count). Mixed degrees are fine — the kernel degree-elevates
+    // lower-degree curves to the max degree exactly (a 2-point line lofts
+    // with a cubic).
     let loftCurves = nurbsCurves;
     if (nurbsCurves.length >= 2) {
-      const cpCounts = nurbsCurves.map(c => c.controlPoints.length);
-      const allSame = cpCounts.every(n => n === cpCounts[0]);
+      const ref = nurbsCurves[0];
+      const matchesRef = (c: NurbsCurve) =>
+        c.degree === ref.degree &&
+        c.controlPoints.length === ref.controlPoints.length &&
+        c.knots.length === ref.knots.length &&
+        c.knots.every((k, i) => Math.abs(k - (ref.knots[i] as number)) < 1e-12);
+      const allSame = nurbsCurves.every(matchesRef);
       if (!allSame) {
         const compatParts: number[] = [nurbsCurves.length];
         for (const c of nurbsCurves) {
@@ -190,19 +239,20 @@ export class NurbsSurface implements Surface {
           for (const k of c.knots) { compatParts.push(k); }
         }
         const compatBuf = wasm.make_nurbs_curves_compatible(new Float64Array(compatParts));
-        if (compatBuf.length > 0) {
-          const count = Number(compatBuf[0] ?? 0);
-          const decoded: NurbsCurve[] = [];
-          let off = 1;
-          for (let i = 0; i < count; i++) {
-            const deg = Number(compatBuf[off] ?? 0);
-            const n = Number(compatBuf[off + 1] ?? 0);
-            const curveLen = 2 + n * 3 + n + (n + deg + 1);
-            decoded.push(NurbsCurve.fromData(compatBuf.slice(off, off + curveLen)));
-            off += curveLen;
-          }
-          loftCurves = decoded;
+        if (compatBuf.length === 0) {
+          throw new Error("NurbsSurface loft: profile curves could not be made compatible");
+        }
+        const count = Number(compatBuf[0] ?? 0);
+        const decoded: NurbsCurve[] = [];
+        let off = 1;
+        for (let i = 0; i < count; i++) {
+          const deg = Number(compatBuf[off] ?? 0);
+          const n = Number(compatBuf[off + 1] ?? 0);
+          const curveLen = 2 + n * 3 + n + (n + deg + 1);
+          decoded.push(NurbsCurve.fromData(compatBuf.slice(off, off + curveLen)));
+          off += curveLen;
         }
+        loftCurves = decoded;
       }
     }