okgeometry-api 1.26.1 → 1.27.0

package/src/Circle.ts

@@ -1,166 +1,166 @@
-import { ensureInit } from "./engine.js";
-import { Point } from "./Point.js";
-import { Vec3 } from "./Vec3.js";
-import { Mesh } from "./Mesh.js";
-import { Polygon } from "./Polygon.js";
-import { Plane } from "./Plane.js";
-import type { RotationAxis } from "./types.js";
-import * as wasm from "./wasm-bindings.js";
-
-/**
- * Immutable circle defined by center, radius, and normal.
- * Supports evaluation, transformation, extrusion, and projection.
- */
-export class Circle {
-  /**
-   * Create a new circle.
-   * @param center - Center point
-   * @param radius - Circle radius
-   * @param normal - Normal vector defining the circle's plane (default Z axis)
-   * @param uAxis - Optional reference direction defining where t=0 starts.
-   *                Critical for sweep operations to maintain consistent profile orientation.
-   */
-  constructor(
-    public readonly center: Point,
-    public readonly radius: number,
-    public readonly normal: Vec3 = Vec3.Z,
-    public readonly uAxis?: Vec3
-  ) {}
-
-  /**
-   * Create a Circle from a Plane, automatically using the plane's xAxis
-   * as the circle's uAxis for consistent orientation in sweep operations.
-   * @param plane - Plane defining circle's position and orientation
-   * @param radius - Circle radius
-   * @returns New Circle at plane origin with plane normal
-   */
-  static fromPlane(plane: Plane, radius: number): Circle {
-    return new Circle(plane.origin, radius, plane.normal, plane.getXAxis());
-  }
-
-  /**
-   * Evaluate a point on the circle at normalized parameter t.
-   * @param t - Parameter in [0, 1] (0 and 1 are the same point for closed circle)
-   * @returns Point on circle at parameter t
-   */
-  pointAt(t: number): Point {
-    ensureInit();
-    const r = wasm.circle_point_at(
-      this.center.x, this.center.y, this.center.z,
-      this.normal.x, this.normal.y, this.normal.z,
-      this.radius, t
-    );
-    return new Point(r[0], r[1], r[2]);
-  }
-
-  /**
-   * Get the circumference of this circle.
-   * @returns 2 * PI * radius
-   */
-  length(): number {
-    ensureInit();
-    return wasm.circle_length(this.radius);
-  }
-
-  /**
-   * Sample the circle into evenly-spaced points across the full closed
-   * parameter range INCLUSIVE of both ends: the last point coincides with
-   * the first (the seam). Consumers building a closed polygon from a circle
-   * must drop the final duplicate (see Mesh.buildPlanarCircle).
-   * @param n - Number of points to generate
-   * @returns Array of n points around the circle, first == last
-   */
-  sample(n: number): Point[] {
-    ensureInit();
-    const buf = wasm.create_circle(
-      this.center.x, this.center.y, this.center.z,
-      this.normal.x, this.normal.y, this.normal.z,
-      this.radius, 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;
-  }
-
-  /**
-   * Translate this circle by an offset vector.
-   * @param offset - Translation vector
-   * @returns New translated circle
-   */
-  translate(offset: Vec3): Circle {
-    return new Circle(this.center.add(offset), this.radius, this.normal, this.uAxis);
-  }
-
-  /**
-   * Rotate this circle around an axis.
-   * @param axis - Rotation axis (Vec3 through origin, or Line for arbitrary axis)
-   * @param angle - Rotation angle in radians
-   * @returns New rotated circle
-   */
-  rotate(axis: RotationAxis, angle: number): Circle {
-    const n = this.normal;
-    // Normal is a direction — always rotate around origin regardless of axis type
-    const dirAxis = 'start' in axis ? new Vec3(axis.end.x - axis.start.x, axis.end.y - axis.start.y, axis.end.z - axis.start.z) : axis;
-    const rn = new Point(n.x, n.y, n.z).rotate(dirAxis, angle);
-    // Also rotate the uAxis if present
-    let rotatedUAxis: Vec3 | undefined;
-    if (this.uAxis) {
-      const ru = new Point(this.uAxis.x, this.uAxis.y, this.uAxis.z).rotate(dirAxis, angle);
-      rotatedUAxis = new Vec3(ru.x, ru.y, ru.z);
-    }
-    return new Circle(this.center.rotate(axis, angle), this.radius, new Vec3(rn.x, rn.y, rn.z), rotatedUAxis);
-  }
-
-  /**
-   * Offset this circle by changing its radius.
-   * @param distance - Distance to offset (positive = larger, negative = smaller)
-   * @returns New circle with adjusted radius
-   */
-  offset(distance: number): Circle {
-    return new Circle(this.center, this.radius + distance, this.normal, this.uAxis);
-  }
-
-  /**
-   * Project onto plane. Returns a Polygon because a tilted circle projects to an ellipse.
-   * @param plane - Target plane
-   * @param direction - Optional projection direction (default: perpendicular to plane)
-   * @param samples - Number of sample points for approximation (default 64)
-   * @returns Polygon approximating the projected circle
-   */
-  projectOntoPlane(plane: Plane, direction?: Vec3, samples = 64): Polygon {
-    const pts = this.sample(samples);
-    const proj = (p: Point) => direction ? plane.projectPointAlongDirection(p, direction) : plane.projectPoint(p);
-    return new Polygon(pts.map(proj));
-  }
-
-  /**
-   * Extrude this circle along a direction vector to create a cylindrical mesh.
-   * @param direction - Extrusion direction and magnitude
-   * @param segments - Number of circumferential segments (default 16)
-   * @param caps - Whether to cap the ends (default true)
-   * @returns Mesh representing the extruded cylinder
-   */
-  extrude(direction: Vec3, segments = 16, caps = true): Mesh {
-    ensureInit();
-    const buf = wasm.extrude_circle(
-      this.center.x, this.center.y, this.center.z,
-      this.normal.x, this.normal.y, this.normal.z,
-      this.radius,
-      direction.x, direction.y, direction.z,
-      segments, caps
-    );
-    return Mesh.fromBuffer(buf);
-  }
-
-  /**
-   * Extrude this closed circle into a trusted solid suitable for booleans.
-   * @param direction - Extrusion direction and magnitude
-   * @param segments - Number of boundary samples used for tessellation (default 32)
-   * @returns Closed mesh solid ready for boolean operations
-   */
-  extrudeAsSolid(direction: Vec3, segments = 32): Mesh {
-    return Mesh.extrudeCurveAsSolid(this, direction, segments);
-  }
-}
+import { ensureInit } from "./engine.js";
+import { Point } from "./Point.js";
+import { Vec3 } from "./Vec3.js";
+import { Mesh } from "./Mesh.js";
+import { Polygon } from "./Polygon.js";
+import { Plane } from "./Plane.js";
+import type { RotationAxis } from "./types.js";
+import { wasm } from "./wasm-active.js";
+
+/**
+ * Immutable circle defined by center, radius, and normal.
+ * Supports evaluation, transformation, extrusion, and projection.
+ */
+export class Circle {
+  /**
+   * Create a new circle.
+   * @param center - Center point
+   * @param radius - Circle radius
+   * @param normal - Normal vector defining the circle's plane (default Z axis)
+   * @param uAxis - Optional reference direction defining where t=0 starts.
+   *                Critical for sweep operations to maintain consistent profile orientation.
+   */
+  constructor(
+    public readonly center: Point,
+    public readonly radius: number,
+    public readonly normal: Vec3 = Vec3.Z,
+    public readonly uAxis?: Vec3
+  ) {}
+
+  /**
+   * Create a Circle from a Plane, automatically using the plane's xAxis
+   * as the circle's uAxis for consistent orientation in sweep operations.
+   * @param plane - Plane defining circle's position and orientation
+   * @param radius - Circle radius
+   * @returns New Circle at plane origin with plane normal
+   */
+  static fromPlane(plane: Plane, radius: number): Circle {
+    return new Circle(plane.origin, radius, plane.normal, plane.getXAxis());
+  }
+
+  /**
+   * Evaluate a point on the circle at normalized parameter t.
+   * @param t - Parameter in [0, 1] (0 and 1 are the same point for closed circle)
+   * @returns Point on circle at parameter t
+   */
+  pointAt(t: number): Point {
+    ensureInit();
+    const r = wasm.circle_point_at(
+      this.center.x, this.center.y, this.center.z,
+      this.normal.x, this.normal.y, this.normal.z,
+      this.radius, t
+    );
+    return new Point(r[0], r[1], r[2]);
+  }
+
+  /**
+   * Get the circumference of this circle.
+   * @returns 2 * PI * radius
+   */
+  length(): number {
+    ensureInit();
+    return wasm.circle_length(this.radius);
+  }
+
+  /**
+   * Sample the circle into evenly-spaced points across the full closed
+   * parameter range INCLUSIVE of both ends: the last point coincides with
+   * the first (the seam). Consumers building a closed polygon from a circle
+   * must drop the final duplicate (see Mesh.buildPlanarCircle).
+   * @param n - Number of points to generate
+   * @returns Array of n points around the circle, first == last
+   */
+  sample(n: number): Point[] {
+    ensureInit();
+    const buf = wasm.create_circle(
+      this.center.x, this.center.y, this.center.z,
+      this.normal.x, this.normal.y, this.normal.z,
+      this.radius, 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;
+  }
+
+  /**
+   * Translate this circle by an offset vector.
+   * @param offset - Translation vector
+   * @returns New translated circle
+   */
+  translate(offset: Vec3): Circle {
+    return new Circle(this.center.add(offset), this.radius, this.normal, this.uAxis);
+  }
+
+  /**
+   * Rotate this circle around an axis.
+   * @param axis - Rotation axis (Vec3 through origin, or Line for arbitrary axis)
+   * @param angle - Rotation angle in radians
+   * @returns New rotated circle
+   */
+  rotate(axis: RotationAxis, angle: number): Circle {
+    const n = this.normal;
+    // Normal is a direction — always rotate around origin regardless of axis type
+    const dirAxis = 'start' in axis ? new Vec3(axis.end.x - axis.start.x, axis.end.y - axis.start.y, axis.end.z - axis.start.z) : axis;
+    const rn = new Point(n.x, n.y, n.z).rotate(dirAxis, angle);
+    // Also rotate the uAxis if present
+    let rotatedUAxis: Vec3 | undefined;
+    if (this.uAxis) {
+      const ru = new Point(this.uAxis.x, this.uAxis.y, this.uAxis.z).rotate(dirAxis, angle);
+      rotatedUAxis = new Vec3(ru.x, ru.y, ru.z);
+    }
+    return new Circle(this.center.rotate(axis, angle), this.radius, new Vec3(rn.x, rn.y, rn.z), rotatedUAxis);
+  }
+
+  /**
+   * Offset this circle by changing its radius.
+   * @param distance - Distance to offset (positive = larger, negative = smaller)
+   * @returns New circle with adjusted radius
+   */
+  offset(distance: number): Circle {
+    return new Circle(this.center, this.radius + distance, this.normal, this.uAxis);
+  }
+
+  /**
+   * Project onto plane. Returns a Polygon because a tilted circle projects to an ellipse.
+   * @param plane - Target plane
+   * @param direction - Optional projection direction (default: perpendicular to plane)
+   * @param samples - Number of sample points for approximation (default 64)
+   * @returns Polygon approximating the projected circle
+   */
+  projectOntoPlane(plane: Plane, direction?: Vec3, samples = 64): Polygon {
+    const pts = this.sample(samples);
+    const proj = (p: Point) => direction ? plane.projectPointAlongDirection(p, direction) : plane.projectPoint(p);
+    return new Polygon(pts.map(proj));
+  }
+
+  /**
+   * Extrude this circle along a direction vector to create a cylindrical mesh.
+   * @param direction - Extrusion direction and magnitude
+   * @param segments - Number of circumferential segments (default 16)
+   * @param caps - Whether to cap the ends (default true)
+   * @returns Mesh representing the extruded cylinder
+   */
+  extrude(direction: Vec3, segments = 16, caps = true): Mesh {
+    ensureInit();
+    const buf = wasm.extrude_circle(
+      this.center.x, this.center.y, this.center.z,
+      this.normal.x, this.normal.y, this.normal.z,
+      this.radius,
+      direction.x, direction.y, direction.z,
+      segments, caps
+    );
+    return Mesh.fromBuffer(buf);
+  }
+
+  /**
+   * Extrude this closed circle into a trusted solid suitable for booleans.
+   * @param direction - Extrusion direction and magnitude
+   * @param segments - Number of boundary samples used for tessellation (default 32)
+   * @returns Closed mesh solid ready for boolean operations
+   */
+  extrudeAsSolid(direction: Vec3, segments = 32): Mesh {
+    return Mesh.extrudeCurveAsSolid(this, direction, segments);
+  }
+}

package/src/Line.ts

@@ -1,171 +1,171 @@
-import { ensureInit } from "./engine.js";
-import { Point } from "./Point.js";
-import { Vec3 } from "./Vec3.js";
-import { Mesh } from "./Mesh.js";
-import { PolyCurve } from "./PolyCurve.js";
-import { Polyline } from "./Polyline.js";
-import type { Plane } from "./Plane.js";
-import type { CurveOffsetOptions, RotationAxis } from "./types.js";
-import * as wasm from "./wasm-bindings.js";
-
-/**
- * Immutable line segment defined by start and end points.
- * Supports evaluation, transformation, and extrusion operations.
- */
-export class Line {
-  constructor(
-    public readonly start: Point,
-    public readonly end: Point
-  ) {}
-
-  /**
-   * Evaluate a point on the line at normalized parameter t.
-   * @param t - Parameter in [0, 1] (0 = start, 1 = end)
-   * @returns Point on line at parameter t
-   */
-  pointAt(t: number): Point {
-    ensureInit();
-    const r = wasm.line_point_at(
-      this.start.x, this.start.y, this.start.z,
-      this.end.x, this.end.y, this.end.z,
-      t
-    );
-    return new Point(r[0], r[1], r[2]);
-  }
-
-  /**
-   * Get the length of this line segment.
-   * @returns Euclidean distance from start to end
-   */
-  length(): number {
-    ensureInit();
-    return wasm.line_length(
-      this.start.x, this.start.y, this.start.z,
-      this.end.x, this.end.y, this.end.z
-    );
-  }
-
-  /**
-   * Get the unit direction vector of this line.
-   * @returns Normalized vector from start to end
-   */
-  tangent(): Vec3 {
-    ensureInit();
-    const r = wasm.line_tangent(
-      this.start.x, this.start.y, this.start.z,
-      this.end.x, this.end.y, this.end.z
-    );
-    return new Vec3(r[0], r[1], r[2]);
-  }
-
-  /**
-   * Sample the line into evenly-spaced points.
-   * @param n - Number of points to generate
-   * @returns Array of n points along the line
-   */
-  sample(n: number): Point[] {
-    ensureInit();
-    const buf = wasm.create_line(
-      this.start.x, this.start.y, this.start.z,
-      this.end.x, this.end.y, this.end.z,
-      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;
-  }
-
-  /**
-   * Translate this line by an offset vector.
-   * @param offset - Translation vector
-   * @returns New translated line
-   */
-  translate(offset: Vec3): Line {
-    return new Line(this.start.add(offset), this.end.add(offset));
-  }
-
-  /**
-   * Apply a row-major 4x4 matrix to both endpoints.
-   * @param matrix - Row-major 4x4 matrix (16 entries)
-   * @returns New transformed line
-   */
-  applyMatrix(matrix: number[] | Float64Array): Line {
-    return new Line(this.start.applyMatrix(matrix), this.end.applyMatrix(matrix));
-  }
-
-  /**
-   * Rotate this line around an axis.
-   * @param axis - Rotation axis (Vec3 through origin, or Line for arbitrary axis)
-   * @param angle - Rotation angle in radians
-   * @returns New rotated line
-   */
-  rotate(axis: RotationAxis, angle: number): Line {
-    return new Line(this.start.rotate(axis, angle), this.end.rotate(axis, angle));
-  }
-
-  /**
-   * Offset this line perpendicular to its direction.
-   * @param distance - Offset distance (positive = along normal cross direction)
-   * @param normal - Reference normal for determining offset direction (default Z axis)
-   * @returns New offset line
-   */
-  offset(distance: number, normal: Vec3 = Vec3.Z): Line {
-    ensureInit();
-    const r = wasm.line_offset(
-      this.start.x, this.start.y, this.start.z,
-      this.end.x, this.end.y, this.end.z,
-      distance,
-      normal.x, normal.y, normal.z,
-    );
-    return new Line(
-      new Point(r[0], r[1], r[2]),
-      new Point(r[3], r[4], r[5]),
-    );
-  }
-
-  /**
-   * Thicken this line into a closed PolyCurve suitable for extrusion.
-   * When `bothSides` is false, the source line forms one side of the result.
-   * When true, the thickness is added on each side of the line.
-   *
-   * If `normal` is omitted, the kernel will infer a stable fallback plane.
-   */
-  thicken(
-    distance: number,
-    bothSides = false,
-    normal?: Vec3,
-    options: CurveOffsetOptions = {},
-  ): PolyCurve {
-    return new Polyline([this.start, this.end]).thicken(distance, bothSides, normal, options);
-  }
-
-  /**
-   * Project this line onto a plane.
-   * @param plane - Target plane
-   * @param direction - Optional projection direction (default: perpendicular to plane)
-   * @returns New projected line
-   */
-  projectOntoPlane(plane: Plane, direction?: Vec3): Line {
-    const proj = (p: Point) => direction ? plane.projectPointAlongDirection(p, direction) : plane.projectPoint(p);
-    return new Line(proj(this.start), proj(this.end));
-  }
-
-  /**
-   * Extrude this line into a mesh surface.
-   * @param direction - Extrusion direction vector
-   * @param segments - Number of segments along extrusion (default 1)
-   * @returns Mesh representing the extruded surface
-   */
-  extrude(direction: Vec3, segments = 1): Mesh {
-    ensureInit();
-    const buf = wasm.extrude_line(
-      this.start.x, this.start.y, this.start.z,
-      this.end.x, this.end.y, this.end.z,
-      direction.x, direction.y, direction.z,
-      segments
-    );
-    return Mesh.fromBuffer(buf);
-  }
-}
+import { ensureInit } from "./engine.js";
+import { Point } from "./Point.js";
+import { Vec3 } from "./Vec3.js";
+import { Mesh } from "./Mesh.js";
+import { PolyCurve } from "./PolyCurve.js";
+import { Polyline } from "./Polyline.js";
+import type { Plane } from "./Plane.js";
+import type { CurveOffsetOptions, RotationAxis } from "./types.js";
+import { wasm } from "./wasm-active.js";
+
+/**
+ * Immutable line segment defined by start and end points.
+ * Supports evaluation, transformation, and extrusion operations.
+ */
+export class Line {
+  constructor(
+    public readonly start: Point,
+    public readonly end: Point
+  ) {}
+
+  /**
+   * Evaluate a point on the line at normalized parameter t.
+   * @param t - Parameter in [0, 1] (0 = start, 1 = end)
+   * @returns Point on line at parameter t
+   */
+  pointAt(t: number): Point {
+    ensureInit();
+    const r = wasm.line_point_at(
+      this.start.x, this.start.y, this.start.z,
+      this.end.x, this.end.y, this.end.z,
+      t
+    );
+    return new Point(r[0], r[1], r[2]);
+  }
+
+  /**
+   * Get the length of this line segment.
+   * @returns Euclidean distance from start to end
+   */
+  length(): number {
+    ensureInit();
+    return wasm.line_length(
+      this.start.x, this.start.y, this.start.z,
+      this.end.x, this.end.y, this.end.z
+    );
+  }
+
+  /**
+   * Get the unit direction vector of this line.
+   * @returns Normalized vector from start to end
+   */
+  tangent(): Vec3 {
+    ensureInit();
+    const r = wasm.line_tangent(
+      this.start.x, this.start.y, this.start.z,
+      this.end.x, this.end.y, this.end.z
+    );
+    return new Vec3(r[0], r[1], r[2]);
+  }
+
+  /**
+   * Sample the line into evenly-spaced points.
+   * @param n - Number of points to generate
+   * @returns Array of n points along the line
+   */
+  sample(n: number): Point[] {
+    ensureInit();
+    const buf = wasm.create_line(
+      this.start.x, this.start.y, this.start.z,
+      this.end.x, this.end.y, this.end.z,
+      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;
+  }
+
+  /**
+   * Translate this line by an offset vector.
+   * @param offset - Translation vector
+   * @returns New translated line
+   */
+  translate(offset: Vec3): Line {
+    return new Line(this.start.add(offset), this.end.add(offset));
+  }
+
+  /**
+   * Apply a row-major 4x4 matrix to both endpoints.
+   * @param matrix - Row-major 4x4 matrix (16 entries)
+   * @returns New transformed line
+   */
+  applyMatrix(matrix: number[] | Float64Array): Line {
+    return new Line(this.start.applyMatrix(matrix), this.end.applyMatrix(matrix));
+  }
+
+  /**
+   * Rotate this line around an axis.
+   * @param axis - Rotation axis (Vec3 through origin, or Line for arbitrary axis)
+   * @param angle - Rotation angle in radians
+   * @returns New rotated line
+   */
+  rotate(axis: RotationAxis, angle: number): Line {
+    return new Line(this.start.rotate(axis, angle), this.end.rotate(axis, angle));
+  }
+
+  /**
+   * Offset this line perpendicular to its direction.
+   * @param distance - Offset distance (positive = along normal cross direction)
+   * @param normal - Reference normal for determining offset direction (default Z axis)
+   * @returns New offset line
+   */
+  offset(distance: number, normal: Vec3 = Vec3.Z): Line {
+    ensureInit();
+    const r = wasm.line_offset(
+      this.start.x, this.start.y, this.start.z,
+      this.end.x, this.end.y, this.end.z,
+      distance,
+      normal.x, normal.y, normal.z,
+    );
+    return new Line(
+      new Point(r[0], r[1], r[2]),
+      new Point(r[3], r[4], r[5]),
+    );
+  }
+
+  /**
+   * Thicken this line into a closed PolyCurve suitable for extrusion.
+   * When `bothSides` is false, the source line forms one side of the result.
+   * When true, the thickness is added on each side of the line.
+   *
+   * If `normal` is omitted, the kernel will infer a stable fallback plane.
+   */
+  thicken(
+    distance: number,
+    bothSides = false,
+    normal?: Vec3,
+    options: CurveOffsetOptions = {},
+  ): PolyCurve {
+    return new Polyline([this.start, this.end]).thicken(distance, bothSides, normal, options);
+  }
+
+  /**
+   * Project this line onto a plane.
+   * @param plane - Target plane
+   * @param direction - Optional projection direction (default: perpendicular to plane)
+   * @returns New projected line
+   */
+  projectOntoPlane(plane: Plane, direction?: Vec3): Line {
+    const proj = (p: Point) => direction ? plane.projectPointAlongDirection(p, direction) : plane.projectPoint(p);
+    return new Line(proj(this.start), proj(this.end));
+  }
+
+  /**
+   * Extrude this line into a mesh surface.
+   * @param direction - Extrusion direction vector
+   * @param segments - Number of segments along extrusion (default 1)
+   * @returns Mesh representing the extruded surface
+   */
+  extrude(direction: Vec3, segments = 1): Mesh {
+    ensureInit();
+    const buf = wasm.extrude_line(
+      this.start.x, this.start.y, this.start.z,
+      this.end.x, this.end.y, this.end.z,
+      direction.x, direction.y, direction.z,
+      segments
+    );
+    return Mesh.fromBuffer(buf);
+  }
+}