okgeometry-api 1.26.1 → 1.27.0

package/src/NurbsCurve.ts

@@ -1,655 +1,655 @@
-import { ensureInit } from "./engine.js";
-import { Point } from "./Point.js";
-import { Vec3 } from "./Vec3.js";
-import { Plane } from "./Plane.js";
-import { Mesh } from "./Mesh.js";
-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";
-
-/**
- * Non-Uniform Rational B-Spline (NURBS) curve backed by WASM.
- * Provides exact representation for complex curves including conics.
- *
- * WASM data format: [degree, num_pts, x0,y0,z0, ..., w0,w1,..., k0,k1,...]
- */
-export class NurbsCurve {
-  private _data: Float64Array;
-
-  /**
-   * Create a new NURBS curve.
-   * @param degree - Polynomial degree (1 = linear, 2 = quadratic, 3 = cubic)
-   * @param controlPoints - Control points defining the curve shape
-   * @param weights - Rational weights for each control point (use 1 for non-rational)
-   * @param knots - Knot vector (length = num_points + degree + 1)
-   */
-  constructor(
-    public readonly degree: number,
-    public readonly controlPoints: Point[],
-    public readonly weights: number[],
-    public readonly knots: number[]
-  ) {
-    this._data = NurbsCurve.encode(degree, controlPoints, weights, knots);
-  }
-
-  /**
-   * Evaluate a point on the curve at normalized parameter t.
-   * @param t - Parameter in [0, 1] (0 = start, 1 = end)
-   * @returns Point on curve at parameter t
-   */
-  pointAt(t: number): Point {
-    ensureInit();
-    const r = wasm.evaluate_nurbs_curve_at(this._data, t);
-    return new Point(r[0], r[1], r[2]);
-  }
-
-  /**
-   * Sample the curve into evenly-spaced points.
-   * @param n - Number of points to generate
-   * @returns Array of n points along the curve
-   */
-  sample(n: number): Point[] {
-    ensureInit();
-    const buf = wasm.sample_nurbs_curve(this._data, n);
-    const pts: Point[] = [];
-    for (let i = 0; i < buf.length; i += 3) {
-      pts.push(new Point(buf[i], buf[i + 1], buf[i + 2]));
-    }
-    return pts;
-  }
-
-  /**
-   * Check if this NURBS curve is closed.
-   * @param eps - Tolerance for comparing start and end points
-   * @returns True if the curve closes on itself
-   */
-  isClosed(eps = 1e-10): boolean {
-    return this.pointAt(0).equals(this.pointAt(1), eps);
-  }
-
-  /**
-   * Find intersection points with a plane.
-   * @param plane - Cutting plane
-   * @returns Array of intersection points
-   */
-  intersectPlane(plane: Plane): Point[] {
-    ensureInit();
-    const buf = wasm.nurbs_curve_plane_intersect(
-      this._data,
-      plane.normal.x, plane.normal.y, plane.normal.z,
-      plane.d
-    );
-    if (buf.length === 0) return [];
-    const numPts = buf[0];
-    const pts: Point[] = [];
-    for (let i = 0; i < numPts; i++) {
-      const off = 1 + i * 3;
-      pts.push(new Point(buf[off], buf[off + 1], buf[off + 2]));
-    }
-    return pts;
-  }
-
-  /**
-   * Find intersection points with another NURBS curve.
-   * @param other - Other curve to intersect with
-   * @returns Array of intersection points
-   */
-  intersectCurve(other: NurbsCurve): Point[] {
-    ensureInit();
-    const buf = wasm.nurbs_curve_curve_intersect(this._data, other._data);
-    if (buf.length === 0) return [];
-    const numPts = buf[0];
-    const pts: Point[] = [];
-    for (let i = 0; i < numPts; i++) {
-      const off = 1 + i * 3;
-      pts.push(new Point(buf[off], buf[off + 1], buf[off + 2]));
-    }
-    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;
-  }
-
-  /**
-   * 2D REGION boolean between this curve and another, both CLOSED and
-   * COPLANAR (Rhino CurveBoolean). Closed planar curves bound regions, so
-   * union / subtract / intersect are well defined: the curves are projected
-   * onto a common plane (fitted from this curve, coplanarity verified),
-   * tessellated to polygons, arranged in 2D, classified by nonzero winding,
-   * and the result loops emitted.
-   *
-   * The result is a list of closed POLYLINE (degree-1 NURBS) curves —
-   * Rhino-parity fidelity, so curved input boundaries are approximated to the
-   * tessellation tolerance. Tessellation samples include every distinct
-   * interior knot value, so degree-1 polygon corners and C0 kinks are
-   * preserved EXACTLY, and consecutive collinear points are collapsed so
-   * straight runs come back as single segments. OUTER boundaries are
-   * counter-clockwise (positive signed area in the fitted plane); HOLE
-   * boundaries are clockwise. CCW is measured about a DETERMINISTIC plane
-   * normal: the normal fitted from THIS curve, flipped so its dominant
-   * world-axis component is positive (for curves in the world XY plane the
-   * reference normal is +Z, so outer loops are CCW viewed from +Z). The
-   * emitted orientation is therefore independent of either curve's drawing
-   * direction. Callers reconstruct the region topology by nesting (a CW loop
-   * inside a CCW loop is that region's hole).
-   *
-   * A valid but empty result (e.g. a disjoint intersect) returns `[]`. Throws
-   * on non-coplanar or OPEN input (closure is verified kernel-side: the
-   * curves' endpoints must coincide within a scale-relative tolerance).
-   *
-   * @param other - The other closed coplanar curve
-   * @param op - 0 = union, 1 = subtract (this − other), 2 = intersect
-   * @returns Result region boundary loops (outer CCW, holes CW)
-   */
-  private regionBoolean(other: NurbsCurve, op: number): NurbsCurve[] {
-    ensureInit();
-    const buf = wasm.curve_region_boolean(this._data, other._data, op);
-    // An EMPTY buffer signals an error (non-coplanar / malformed); a valid
-    // empty result is the non-empty [0] packing.
-    if (buf.length === 0) {
-      throw new Error(
-        "NurbsCurve region boolean failed — curves must be closed and coplanar",
-      );
-    }
-    return NurbsCurve.decodeCurveList(buf);
-  }
-
-  /**
-   * Region UNION with another closed coplanar curve. See {@link regionBoolean}.
-   * @param other - The other closed coplanar curve
-   * @returns Boundary loops of (inside-this OR inside-other), outer CCW / holes CW
-   */
-  regionUnion(other: NurbsCurve): NurbsCurve[] {
-    return this.regionBoolean(other, 0);
-  }
-
-  /**
-   * Region SUBTRACT (this − other) of a closed coplanar curve. Order matters.
-   * See {@link regionBoolean}.
-   * @param other - The curve subtracted from this
-   * @returns Boundary loops of (inside-this AND NOT inside-other)
-   */
-  regionSubtract(other: NurbsCurve): NurbsCurve[] {
-    return this.regionBoolean(other, 1);
-  }
-
-  /**
-   * Region INTERSECT with another closed coplanar curve. See
-   * {@link regionBoolean}.
-   * @param other - The other closed coplanar curve
-   * @returns Boundary loops of (inside-this AND inside-other)
-   */
-  regionIntersect(other: NurbsCurve): NurbsCurve[] {
-    return this.regionBoolean(other, 2);
-  }
-
-  /**
-   * Region SPLIT: partition this curve and another closed coplanar curve into
-   * ALL region boundaries (Rhino "region split"). The arrangement partitions
-   * the plane into the pieces inside-this-only, inside-other-only and
-   * inside-both; every bounded region's outer and hole loops come back as
-   * their own closed curves (outer CCW, holes CW). See {@link regionBoolean}
-   * for the fidelity and orientation contract.
-   *
-   * @param other - The other closed coplanar curve
-   * @returns All region boundary loops
-   */
-  regionSplit(other: NurbsCurve): NurbsCurve[] {
-    ensureInit();
-    const buf = wasm.curve_region_split(this._data, other._data);
-    if (buf.length === 0) {
-      throw new Error(
-        "NurbsCurve region split failed — curves must be closed and coplanar",
-      );
-    }
-    return NurbsCurve.decodeCurveList(buf);
-  }
-
-  /** Parse [count, (bufLen, curveData…)·count] into NurbsCurves. */
-  private static decodeCurveList(buf: Float64Array): NurbsCurve[] {
-    if (buf.length < 1) return [];
-    const out: NurbsCurve[] = [];
-    let offset = 1;
-    const count = Number(buf[0]);
-    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;
-  }
-
-  /**
-   * Translate this curve by an offset vector.
-   * @param offset - Translation vector
-   * @returns New translated curve
-   */
-  translate(offset: Vec3): NurbsCurve {
-    return new NurbsCurve(
-      this.degree,
-      this.controlPoints.map(p => p.add(offset)),
-      this.weights,
-      this.knots
-    );
-  }
-
-  /**
-   * Apply a row-major 4x4 AFFINE matrix to this curve. NURBS are invariant
-   * under affine maps of their control points, so rigid transforms, scaling
-   * (uniform or not) and shear are EXACT — weights and knots are unchanged.
-   * @param matrix - Row-major 4x4 matrix (16 entries)
-   * @returns New transformed curve
-   */
-  applyMatrix(matrix: number[] | Float64Array): NurbsCurve {
-    return new NurbsCurve(
-      this.degree,
-      this.controlPoints.map(p => p.applyMatrix(matrix)),
-      this.weights,
-      this.knots
-    );
-  }
-
-  /**
-   * Rotate this curve around an axis.
-   * @param axis - Rotation axis (Vec3 through origin, or Line for arbitrary axis)
-   * @param angle - Rotation angle in radians
-   * @returns New rotated curve
-   */
-  rotate(axis: RotationAxis, angle: number): NurbsCurve {
-    return new NurbsCurve(
-      this.degree,
-      this.controlPoints.map(p => p.rotate(axis, angle)),
-      this.weights,
-      this.knots
-    );
-  }
-
-  /**
-   * Project this curve onto a plane.
-   * @param plane - Target plane
-   * @param direction - Optional projection direction (default: perpendicular to plane)
-   * @returns New projected curve
-   */
-  projectOntoPlane(plane: Plane, direction?: Vec3): NurbsCurve {
-    const proj = (p: Point) => direction ? plane.projectPointAlongDirection(p, direction) : plane.projectPoint(p);
-    return new NurbsCurve(
-      this.degree,
-      this.controlPoints.map(proj),
-      this.weights,
-      this.knots
-    );
-  }
-
-  // NOTE: `offset()` (exact NURBS offset, kernel-refit to tolerance) lives
-  // further down next to `data`. The former sampled-polyline `offset()` was
-  // replaced by it; the sampled multi-result path remains as `offsetAll()`.
-
-  /**
-   * Offset this curve by a distance and return every sampled result polyline.
-   * Note: NURBS offset is approximated by sampling and offsetting as polyline.
-   * @param distance - Offset distance
-   * @param normal - Reference normal for determining offset direction
-   * @param samples - Number of sample points used to approximate the source curve
-   * @param arcSamples - Number of samples per exact arc segment in the returned polylines
-   * @param options - Offset options such as join style
-   * @returns Every valid offset polyline approximation
-   */
-  offsetAll(
-    distance: number,
-    normal?: Vec3,
-    samples = 64,
-    arcSamples = 32,
-    options: CurveOffsetOptions = {},
-  ): Polyline[] {
-    const pts = this.sample(samples);
-    const pl = new Polyline(pts);
-    return pl.offsetAll(distance, normal, arcSamples, options);
-  }
-
-  /**
-   * Thicken this curve into a closed PolyCurve.
-   * Note: this is approximated by sampling the NURBS curve into a polyline first.
-   *
-   * When `bothSides` is false, the sampled source curve forms one side of the
-   * result. When true, the distance is applied on each side of the sampled curve.
-   */
-  thicken(
-    distance: number,
-    bothSides = false,
-    normal?: Vec3,
-    samples = 64,
-    options: CurveOffsetOptions = {},
-  ): PolyCurve {
-    const pts = this.sample(samples);
-    return new Polyline(pts).thicken(distance, bothSides, normal, options);
-  }
-
-  /**
-   * Extrude this curve along a direction vector.
-   * Note: this is approximated by sampling the NURBS curve into a polyline
-   * first. Open curves produce an open sheet; closed curves an uncapped tube
-   * unless `caps` is true (see extrudeAsSolid for a boolean-ready solid).
-   * @param direction - Extrusion direction and magnitude
-   * @param segments - Number of segments along the extrusion (default 1)
-   * @param caps - Whether to cap the ends of a closed profile (default false)
-   * @param samples - Number of curve samples used for tessellation (default 64)
-   * @returns Mesh representing the extruded surface
-   */
-  extrude(direction: Vec3, segments = 1, caps = false, samples = 64): Mesh {
-    const pts = this.sample(samples);
-    return new Polyline(pts).extrude(direction, segments, caps);
-  }
-
-  /**
-   * Extrude this closed NURBS curve into a trusted solid suitable for booleans.
-   * @param direction - Extrusion direction and magnitude
-   * @param segments - Number of curve samples used for tessellation (default 64)
-   * @returns Closed mesh solid ready for boolean operations
-   */
-  extrudeAsSolid(direction: Vec3, segments = 64): Mesh {
-    return Mesh.extrudeCurveAsSolid(this, direction, segments);
-  }
-
-  /**
-   * Build a NURBS curve from raw control points with kernel-managed knots and
-   * uniform weights.
-   *
-   * Open curves use a clamped uniform knot vector (curve interpolates the first
-   * and last control points). Closed curves are periodic (C^{degree-1}
-   * continuous loops); the first control point must NOT be repeated at the end.
-   *
-   * @param degree - Requested degree (clamped by the kernel to the valid range)
-   * @param controlPoints - Control points (min 2 open / 3 closed)
-   * @param closed - Build a periodic closed loop (default false)
-   * @returns New NurbsCurve instance
-   */
-  static fromPoints(degree: number, controlPoints: Point[], closed = false): NurbsCurve {
-    ensureInit();
-    const coords = new Float64Array(controlPoints.length * 3);
-    for (let i = 0; i < controlPoints.length; i++) {
-      coords[i * 3] = controlPoints[i].x;
-      coords[i * 3 + 1] = controlPoints[i].y;
-      coords[i * 3 + 2] = controlPoints[i].z;
-    }
-    const buf = wasm.build_nurbs_curve(degree, coords, closed);
-    if (buf.length < 2) {
-      throw new Error(
-        `NurbsCurve.fromPoints failed (degree ${degree}, ${controlPoints.length} points, closed=${closed})`,
-      );
-    }
-    return NurbsCurve.fromData(buf);
-  }
-
-  /**
-   * Decode a NurbsCurve from WASM flat buffer.
-   * @param data - Buffer in format [degree, num_cp, xyz..., w..., k...]
-   * @returns New NurbsCurve instance
-   */
-  static fromData(data: Float64Array | number[]): NurbsCurve {
-    const d = data instanceof Float64Array ? data : new Float64Array(data);
-    const degree = d[0];
-    const n = d[1];
-    let idx = 2;
-    const pts: Point[] = [];
-    for (let i = 0; i < n; i++) {
-      pts.push(new Point(d[idx], d[idx + 1], d[idx + 2]));
-      idx += 3;
-    }
-    const weights = Array.from(d.slice(idx, idx + n)); idx += n;
-    const numKnots = n + degree + 1;
-    const knots = Array.from(d.slice(idx, idx + numKnots));
-    return new NurbsCurve(degree, pts, weights, knots);
-  }
-
-  /**
-   * Create exact degree-1 NURBS from a Line.
-   * @param line - Source line
-   * @returns Degree-1 NURBS representing the line exactly
-   */
-  static fromLine(line: Line): NurbsCurve {
-    return new NurbsCurve(1, [line.start, line.end], [1, 1], [0, 0, 1, 1]);
-  }
-
-  /**
-   * Create exact degree-2 rational NURBS from an Arc.
-   * Uses WASM circle_arc for exact conic representation.
-   * @param arc - Source arc
-   * @returns Degree-2 rational NURBS representing the arc exactly
-   */
-  static fromArc(arc: Arc): NurbsCurve {
-    ensureInit();
-    const buf = wasm.polycurve_to_nurbs(new Float64Array([
-      1, // 1 segment
-      1, // type = Arc
-      arc.center.x, arc.center.y, arc.center.z,
-      arc.normal.x, arc.normal.y, arc.normal.z,
-      arc.radius, arc.startAngle, arc.endAngle
-    ]));
-    if (buf.length < 2) throw new Error("Failed to convert Arc to NURBS");
-    return NurbsCurve.fromData(buf);
-  }
-
-  /**
-   * Offset this planar curve by `distance` within the plane with the given
-   * `normal`. Positive distance offsets toward `normal × tangent` (the same
-   * convention as Polyline/PolyCurve offsets). The result is refit to
-   * `tolerance` (default 1e-6) against the exact offset locus; rational
-   * curves (exact arcs) offset exactly. Closed curves stay closed.
-   *
-   * Throws for non-planar or kinked curves, or when the offset cannot reach
-   * tolerance (for example offsetting inward past the curvature radius).
-   */
-  offset(
-    distance: number,
-    normal: Vec3 = Vec3.Z,
-    options: { tolerance?: number } = {},
-  ): NurbsCurve {
-    ensureInit();
-    const buf = wasm.nurbs_curve_offset(
-      this.data,
-      distance,
-      normal.x,
-      normal.y,
-      normal.z,
-      options.tolerance ?? 1e-6,
-    );
-    if (buf.length < 2) {
-      throw new Error(
-        `NurbsCurve.offset() failed: ${wasm.geometry_last_error() || "unknown error"}`,
-      );
-    }
-    return NurbsCurve.fromData(buf);
-  }
-
-  /**
-   * Rebuild this curve with the given degree and control point count
-   * (Rhino-style Rebuild): a global least-squares refit with clean
-   * approximation knots and chord-length-ish parameterization over [0, 1].
-   * The result is always NON-RATIONAL; geometrically closed curves stay
-   * seamlessly closed (periodic basis, C^(degree-1) across the seam); open
-   * curves keep their exact end points.
-   *
-   * Returns the rebuilt curve together with the measured deviation from the
-   * original (max and mean over dense validation samples).
-   *
-   * Throws for invalid degree/count combinations (degree 1..11, pointCount
-   * >= degree + 1) or degenerate (zero-length) curves.
-   */
-  rebuild(
-    degree: number,
-    pointCount: number,
-  ): { curve: NurbsCurve; maxDeviation: number; avgDeviation: number } {
-    ensureInit();
-    const buf = wasm.nurbs_curve_rebuild(this.data, degree, pointCount);
-    if (buf.length < 4) {
-      throw new Error(
-        `NurbsCurve.rebuild() failed: ${wasm.geometry_last_error() || "unknown error"}`,
-      );
-    }
-    return {
-      maxDeviation: Number(buf[0]),
-      avgDeviation: Number(buf[1]),
-      curve: NurbsCurve.fromData(buf.subarray(2)),
-    };
-  }
-
-  /**
-   * Get internal WASM data buffer.
-   * For advanced use cases requiring direct WASM interop.
-   */
-  get data(): Float64Array {
-    return this._data;
-  }
-
-  /** Encode to WASM format */
-  private static encode(
-    degree: number,
-    controlPoints: Point[],
-    weights: number[],
-    knots: number[]
-  ): Float64Array {
-    const n = controlPoints.length;
-    const data = new Float64Array(2 + n * 3 + weights.length + knots.length);
-    data[0] = degree;
-    data[1] = n;
-    let idx = 2;
-    for (const p of controlPoints) {
-      data[idx++] = p.x;
-      data[idx++] = p.y;
-      data[idx++] = p.z;
-    }
-    for (const w of weights) data[idx++] = w;
-    for (const k of knots) data[idx++] = k;
-    return data;
-  }
-}
+import { ensureInit } from "./engine.js";
+import { Point } from "./Point.js";
+import { Vec3 } from "./Vec3.js";
+import { Plane } from "./Plane.js";
+import { Mesh } from "./Mesh.js";
+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 { wasm } from "./wasm-active.js";
+
+/**
+ * Non-Uniform Rational B-Spline (NURBS) curve backed by WASM.
+ * Provides exact representation for complex curves including conics.
+ *
+ * WASM data format: [degree, num_pts, x0,y0,z0, ..., w0,w1,..., k0,k1,...]
+ */
+export class NurbsCurve {
+  private _data: Float64Array;
+
+  /**
+   * Create a new NURBS curve.
+   * @param degree - Polynomial degree (1 = linear, 2 = quadratic, 3 = cubic)
+   * @param controlPoints - Control points defining the curve shape
+   * @param weights - Rational weights for each control point (use 1 for non-rational)
+   * @param knots - Knot vector (length = num_points + degree + 1)
+   */
+  constructor(
+    public readonly degree: number,
+    public readonly controlPoints: Point[],
+    public readonly weights: number[],
+    public readonly knots: number[]
+  ) {
+    this._data = NurbsCurve.encode(degree, controlPoints, weights, knots);
+  }
+
+  /**
+   * Evaluate a point on the curve at normalized parameter t.
+   * @param t - Parameter in [0, 1] (0 = start, 1 = end)
+   * @returns Point on curve at parameter t
+   */
+  pointAt(t: number): Point {
+    ensureInit();
+    const r = wasm.evaluate_nurbs_curve_at(this._data, t);
+    return new Point(r[0], r[1], r[2]);
+  }
+
+  /**
+   * Sample the curve into evenly-spaced points.
+   * @param n - Number of points to generate
+   * @returns Array of n points along the curve
+   */
+  sample(n: number): Point[] {
+    ensureInit();
+    const buf = wasm.sample_nurbs_curve(this._data, n);
+    const pts: Point[] = [];
+    for (let i = 0; i < buf.length; i += 3) {
+      pts.push(new Point(buf[i], buf[i + 1], buf[i + 2]));
+    }
+    return pts;
+  }
+
+  /**
+   * Check if this NURBS curve is closed.
+   * @param eps - Tolerance for comparing start and end points
+   * @returns True if the curve closes on itself
+   */
+  isClosed(eps = 1e-10): boolean {
+    return this.pointAt(0).equals(this.pointAt(1), eps);
+  }
+
+  /**
+   * Find intersection points with a plane.
+   * @param plane - Cutting plane
+   * @returns Array of intersection points
+   */
+  intersectPlane(plane: Plane): Point[] {
+    ensureInit();
+    const buf = wasm.nurbs_curve_plane_intersect(
+      this._data,
+      plane.normal.x, plane.normal.y, plane.normal.z,
+      plane.d
+    );
+    if (buf.length === 0) return [];
+    const numPts = buf[0];
+    const pts: Point[] = [];
+    for (let i = 0; i < numPts; i++) {
+      const off = 1 + i * 3;
+      pts.push(new Point(buf[off], buf[off + 1], buf[off + 2]));
+    }
+    return pts;
+  }
+
+  /**
+   * Find intersection points with another NURBS curve.
+   * @param other - Other curve to intersect with
+   * @returns Array of intersection points
+   */
+  intersectCurve(other: NurbsCurve): Point[] {
+    ensureInit();
+    const buf = wasm.nurbs_curve_curve_intersect(this._data, other._data);
+    if (buf.length === 0) return [];
+    const numPts = buf[0];
+    const pts: Point[] = [];
+    for (let i = 0; i < numPts; i++) {
+      const off = 1 + i * 3;
+      pts.push(new Point(buf[off], buf[off + 1], buf[off + 2]));
+    }
+    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;
+  }
+
+  /**
+   * 2D REGION boolean between this curve and another, both CLOSED and
+   * COPLANAR (Rhino CurveBoolean). Closed planar curves bound regions, so
+   * union / subtract / intersect are well defined: the curves are projected
+   * onto a common plane (fitted from this curve, coplanarity verified),
+   * tessellated to polygons, arranged in 2D, classified by nonzero winding,
+   * and the result loops emitted.
+   *
+   * The result is a list of closed POLYLINE (degree-1 NURBS) curves —
+   * Rhino-parity fidelity, so curved input boundaries are approximated to the
+   * tessellation tolerance. Tessellation samples include every distinct
+   * interior knot value, so degree-1 polygon corners and C0 kinks are
+   * preserved EXACTLY, and consecutive collinear points are collapsed so
+   * straight runs come back as single segments. OUTER boundaries are
+   * counter-clockwise (positive signed area in the fitted plane); HOLE
+   * boundaries are clockwise. CCW is measured about a DETERMINISTIC plane
+   * normal: the normal fitted from THIS curve, flipped so its dominant
+   * world-axis component is positive (for curves in the world XY plane the
+   * reference normal is +Z, so outer loops are CCW viewed from +Z). The
+   * emitted orientation is therefore independent of either curve's drawing
+   * direction. Callers reconstruct the region topology by nesting (a CW loop
+   * inside a CCW loop is that region's hole).
+   *
+   * A valid but empty result (e.g. a disjoint intersect) returns `[]`. Throws
+   * on non-coplanar or OPEN input (closure is verified kernel-side: the
+   * curves' endpoints must coincide within a scale-relative tolerance).
+   *
+   * @param other - The other closed coplanar curve
+   * @param op - 0 = union, 1 = subtract (this − other), 2 = intersect
+   * @returns Result region boundary loops (outer CCW, holes CW)
+   */
+  private regionBoolean(other: NurbsCurve, op: number): NurbsCurve[] {
+    ensureInit();
+    const buf = wasm.curve_region_boolean(this._data, other._data, op);
+    // An EMPTY buffer signals an error (non-coplanar / malformed); a valid
+    // empty result is the non-empty [0] packing.
+    if (buf.length === 0) {
+      throw new Error(
+        "NurbsCurve region boolean failed — curves must be closed and coplanar",
+      );
+    }
+    return NurbsCurve.decodeCurveList(buf);
+  }
+
+  /**
+   * Region UNION with another closed coplanar curve. See {@link regionBoolean}.
+   * @param other - The other closed coplanar curve
+   * @returns Boundary loops of (inside-this OR inside-other), outer CCW / holes CW
+   */
+  regionUnion(other: NurbsCurve): NurbsCurve[] {
+    return this.regionBoolean(other, 0);
+  }
+
+  /**
+   * Region SUBTRACT (this − other) of a closed coplanar curve. Order matters.
+   * See {@link regionBoolean}.
+   * @param other - The curve subtracted from this
+   * @returns Boundary loops of (inside-this AND NOT inside-other)
+   */
+  regionSubtract(other: NurbsCurve): NurbsCurve[] {
+    return this.regionBoolean(other, 1);
+  }
+
+  /**
+   * Region INTERSECT with another closed coplanar curve. See
+   * {@link regionBoolean}.
+   * @param other - The other closed coplanar curve
+   * @returns Boundary loops of (inside-this AND inside-other)
+   */
+  regionIntersect(other: NurbsCurve): NurbsCurve[] {
+    return this.regionBoolean(other, 2);
+  }
+
+  /**
+   * Region SPLIT: partition this curve and another closed coplanar curve into
+   * ALL region boundaries (Rhino "region split"). The arrangement partitions
+   * the plane into the pieces inside-this-only, inside-other-only and
+   * inside-both; every bounded region's outer and hole loops come back as
+   * their own closed curves (outer CCW, holes CW). See {@link regionBoolean}
+   * for the fidelity and orientation contract.
+   *
+   * @param other - The other closed coplanar curve
+   * @returns All region boundary loops
+   */
+  regionSplit(other: NurbsCurve): NurbsCurve[] {
+    ensureInit();
+    const buf = wasm.curve_region_split(this._data, other._data);
+    if (buf.length === 0) {
+      throw new Error(
+        "NurbsCurve region split failed — curves must be closed and coplanar",
+      );
+    }
+    return NurbsCurve.decodeCurveList(buf);
+  }
+
+  /** Parse [count, (bufLen, curveData…)·count] into NurbsCurves. */
+  private static decodeCurveList(buf: Float64Array): NurbsCurve[] {
+    if (buf.length < 1) return [];
+    const out: NurbsCurve[] = [];
+    let offset = 1;
+    const count = Number(buf[0]);
+    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;
+  }
+
+  /**
+   * Translate this curve by an offset vector.
+   * @param offset - Translation vector
+   * @returns New translated curve
+   */
+  translate(offset: Vec3): NurbsCurve {
+    return new NurbsCurve(
+      this.degree,
+      this.controlPoints.map(p => p.add(offset)),
+      this.weights,
+      this.knots
+    );
+  }
+
+  /**
+   * Apply a row-major 4x4 AFFINE matrix to this curve. NURBS are invariant
+   * under affine maps of their control points, so rigid transforms, scaling
+   * (uniform or not) and shear are EXACT — weights and knots are unchanged.
+   * @param matrix - Row-major 4x4 matrix (16 entries)
+   * @returns New transformed curve
+   */
+  applyMatrix(matrix: number[] | Float64Array): NurbsCurve {
+    return new NurbsCurve(
+      this.degree,
+      this.controlPoints.map(p => p.applyMatrix(matrix)),
+      this.weights,
+      this.knots
+    );
+  }
+
+  /**
+   * Rotate this curve around an axis.
+   * @param axis - Rotation axis (Vec3 through origin, or Line for arbitrary axis)
+   * @param angle - Rotation angle in radians
+   * @returns New rotated curve
+   */
+  rotate(axis: RotationAxis, angle: number): NurbsCurve {
+    return new NurbsCurve(
+      this.degree,
+      this.controlPoints.map(p => p.rotate(axis, angle)),
+      this.weights,
+      this.knots
+    );
+  }
+
+  /**
+   * Project this curve onto a plane.
+   * @param plane - Target plane
+   * @param direction - Optional projection direction (default: perpendicular to plane)
+   * @returns New projected curve
+   */
+  projectOntoPlane(plane: Plane, direction?: Vec3): NurbsCurve {
+    const proj = (p: Point) => direction ? plane.projectPointAlongDirection(p, direction) : plane.projectPoint(p);
+    return new NurbsCurve(
+      this.degree,
+      this.controlPoints.map(proj),
+      this.weights,
+      this.knots
+    );
+  }
+
+  // NOTE: `offset()` (exact NURBS offset, kernel-refit to tolerance) lives
+  // further down next to `data`. The former sampled-polyline `offset()` was
+  // replaced by it; the sampled multi-result path remains as `offsetAll()`.
+
+  /**
+   * Offset this curve by a distance and return every sampled result polyline.
+   * Note: NURBS offset is approximated by sampling and offsetting as polyline.
+   * @param distance - Offset distance
+   * @param normal - Reference normal for determining offset direction
+   * @param samples - Number of sample points used to approximate the source curve
+   * @param arcSamples - Number of samples per exact arc segment in the returned polylines
+   * @param options - Offset options such as join style
+   * @returns Every valid offset polyline approximation
+   */
+  offsetAll(
+    distance: number,
+    normal?: Vec3,
+    samples = 64,
+    arcSamples = 32,
+    options: CurveOffsetOptions = {},
+  ): Polyline[] {
+    const pts = this.sample(samples);
+    const pl = new Polyline(pts);
+    return pl.offsetAll(distance, normal, arcSamples, options);
+  }
+
+  /**
+   * Thicken this curve into a closed PolyCurve.
+   * Note: this is approximated by sampling the NURBS curve into a polyline first.
+   *
+   * When `bothSides` is false, the sampled source curve forms one side of the
+   * result. When true, the distance is applied on each side of the sampled curve.
+   */
+  thicken(
+    distance: number,
+    bothSides = false,
+    normal?: Vec3,
+    samples = 64,
+    options: CurveOffsetOptions = {},
+  ): PolyCurve {
+    const pts = this.sample(samples);
+    return new Polyline(pts).thicken(distance, bothSides, normal, options);
+  }
+
+  /**
+   * Extrude this curve along a direction vector.
+   * Note: this is approximated by sampling the NURBS curve into a polyline
+   * first. Open curves produce an open sheet; closed curves an uncapped tube
+   * unless `caps` is true (see extrudeAsSolid for a boolean-ready solid).
+   * @param direction - Extrusion direction and magnitude
+   * @param segments - Number of segments along the extrusion (default 1)
+   * @param caps - Whether to cap the ends of a closed profile (default false)
+   * @param samples - Number of curve samples used for tessellation (default 64)
+   * @returns Mesh representing the extruded surface
+   */
+  extrude(direction: Vec3, segments = 1, caps = false, samples = 64): Mesh {
+    const pts = this.sample(samples);
+    return new Polyline(pts).extrude(direction, segments, caps);
+  }
+
+  /**
+   * Extrude this closed NURBS curve into a trusted solid suitable for booleans.
+   * @param direction - Extrusion direction and magnitude
+   * @param segments - Number of curve samples used for tessellation (default 64)
+   * @returns Closed mesh solid ready for boolean operations
+   */
+  extrudeAsSolid(direction: Vec3, segments = 64): Mesh {
+    return Mesh.extrudeCurveAsSolid(this, direction, segments);
+  }
+
+  /**
+   * Build a NURBS curve from raw control points with kernel-managed knots and
+   * uniform weights.
+   *
+   * Open curves use a clamped uniform knot vector (curve interpolates the first
+   * and last control points). Closed curves are periodic (C^{degree-1}
+   * continuous loops); the first control point must NOT be repeated at the end.
+   *
+   * @param degree - Requested degree (clamped by the kernel to the valid range)
+   * @param controlPoints - Control points (min 2 open / 3 closed)
+   * @param closed - Build a periodic closed loop (default false)
+   * @returns New NurbsCurve instance
+   */
+  static fromPoints(degree: number, controlPoints: Point[], closed = false): NurbsCurve {
+    ensureInit();
+    const coords = new Float64Array(controlPoints.length * 3);
+    for (let i = 0; i < controlPoints.length; i++) {
+      coords[i * 3] = controlPoints[i].x;
+      coords[i * 3 + 1] = controlPoints[i].y;
+      coords[i * 3 + 2] = controlPoints[i].z;
+    }
+    const buf = wasm.build_nurbs_curve(degree, coords, closed);
+    if (buf.length < 2) {
+      throw new Error(
+        `NurbsCurve.fromPoints failed (degree ${degree}, ${controlPoints.length} points, closed=${closed})`,
+      );
+    }
+    return NurbsCurve.fromData(buf);
+  }
+
+  /**
+   * Decode a NurbsCurve from WASM flat buffer.
+   * @param data - Buffer in format [degree, num_cp, xyz..., w..., k...]
+   * @returns New NurbsCurve instance
+   */
+  static fromData(data: Float64Array | number[]): NurbsCurve {
+    const d = data instanceof Float64Array ? data : new Float64Array(data);
+    const degree = d[0];
+    const n = d[1];
+    let idx = 2;
+    const pts: Point[] = [];
+    for (let i = 0; i < n; i++) {
+      pts.push(new Point(d[idx], d[idx + 1], d[idx + 2]));
+      idx += 3;
+    }
+    const weights = Array.from(d.slice(idx, idx + n)); idx += n;
+    const numKnots = n + degree + 1;
+    const knots = Array.from(d.slice(idx, idx + numKnots));
+    return new NurbsCurve(degree, pts, weights, knots);
+  }
+
+  /**
+   * Create exact degree-1 NURBS from a Line.
+   * @param line - Source line
+   * @returns Degree-1 NURBS representing the line exactly
+   */
+  static fromLine(line: Line): NurbsCurve {
+    return new NurbsCurve(1, [line.start, line.end], [1, 1], [0, 0, 1, 1]);
+  }
+
+  /**
+   * Create exact degree-2 rational NURBS from an Arc.
+   * Uses WASM circle_arc for exact conic representation.
+   * @param arc - Source arc
+   * @returns Degree-2 rational NURBS representing the arc exactly
+   */
+  static fromArc(arc: Arc): NurbsCurve {
+    ensureInit();
+    const buf = wasm.polycurve_to_nurbs(new Float64Array([
+      1, // 1 segment
+      1, // type = Arc
+      arc.center.x, arc.center.y, arc.center.z,
+      arc.normal.x, arc.normal.y, arc.normal.z,
+      arc.radius, arc.startAngle, arc.endAngle
+    ]));
+    if (buf.length < 2) throw new Error("Failed to convert Arc to NURBS");
+    return NurbsCurve.fromData(buf);
+  }
+
+  /**
+   * Offset this planar curve by `distance` within the plane with the given
+   * `normal`. Positive distance offsets toward `normal × tangent` (the same
+   * convention as Polyline/PolyCurve offsets). The result is refit to
+   * `tolerance` (default 1e-6) against the exact offset locus; rational
+   * curves (exact arcs) offset exactly. Closed curves stay closed.
+   *
+   * Throws for non-planar or kinked curves, or when the offset cannot reach
+   * tolerance (for example offsetting inward past the curvature radius).
+   */
+  offset(
+    distance: number,
+    normal: Vec3 = Vec3.Z,
+    options: { tolerance?: number } = {},
+  ): NurbsCurve {
+    ensureInit();
+    const buf = wasm.nurbs_curve_offset(
+      this.data,
+      distance,
+      normal.x,
+      normal.y,
+      normal.z,
+      options.tolerance ?? 1e-6,
+    );
+    if (buf.length < 2) {
+      throw new Error(
+        `NurbsCurve.offset() failed: ${wasm.geometry_last_error() || "unknown error"}`,
+      );
+    }
+    return NurbsCurve.fromData(buf);
+  }
+
+  /**
+   * Rebuild this curve with the given degree and control point count
+   * (Rhino-style Rebuild): a global least-squares refit with clean
+   * approximation knots and chord-length-ish parameterization over [0, 1].
+   * The result is always NON-RATIONAL; geometrically closed curves stay
+   * seamlessly closed (periodic basis, C^(degree-1) across the seam); open
+   * curves keep their exact end points.
+   *
+   * Returns the rebuilt curve together with the measured deviation from the
+   * original (max and mean over dense validation samples).
+   *
+   * Throws for invalid degree/count combinations (degree 1..11, pointCount
+   * >= degree + 1) or degenerate (zero-length) curves.
+   */
+  rebuild(
+    degree: number,
+    pointCount: number,
+  ): { curve: NurbsCurve; maxDeviation: number; avgDeviation: number } {
+    ensureInit();
+    const buf = wasm.nurbs_curve_rebuild(this.data, degree, pointCount);
+    if (buf.length < 4) {
+      throw new Error(
+        `NurbsCurve.rebuild() failed: ${wasm.geometry_last_error() || "unknown error"}`,
+      );
+    }
+    return {
+      maxDeviation: Number(buf[0]),
+      avgDeviation: Number(buf[1]),
+      curve: NurbsCurve.fromData(buf.subarray(2)),
+    };
+  }
+
+  /**
+   * Get internal WASM data buffer.
+   * For advanced use cases requiring direct WASM interop.
+   */
+  get data(): Float64Array {
+    return this._data;
+  }
+
+  /** Encode to WASM format */
+  private static encode(
+    degree: number,
+    controlPoints: Point[],
+    weights: number[],
+    knots: number[]
+  ): Float64Array {
+    const n = controlPoints.length;
+    const data = new Float64Array(2 + n * 3 + weights.length + knots.length);
+    data[0] = degree;
+    data[1] = n;
+    let idx = 2;
+    for (const p of controlPoints) {
+      data[idx++] = p.x;
+      data[idx++] = p.y;
+      data[idx++] = p.z;
+    }
+    for (const w of weights) data[idx++] = w;
+    for (const k of knots) data[idx++] = k;
+    return data;
+  }
+}