okgeometry-api 1.1.5 → 1.1.7

package/dist/wasm-base64.js.map

@@ -1 +1 @@
-{"version":3,"file":"wasm-base64.js","sourceRoot":"","sources":["../src/wasm-base64.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,MAAM,CAAC,MAAM,QAAQ,GAAG,kl+tDAAkl+tD,CAAC"}
+{"version":3,"file":"wasm-base64.js","sourceRoot":"","sources":["../src/wasm-base64.ts"],"names":[],"mappings":"AAAA,+BAA+B;AAC/B,MAAM,CAAC,MAAM,QAAQ,GAAG,86lvDAA86lvD,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "okgeometry-api",
-  "version": "1.1.5",
+  "version": "1.1.7",
   "description": "Geometry engine API for AEC applications — NURBS, meshes, booleans, intersections. Powered by Rust/WASM.",
   "type": "module",
   "main": "dist/index.js",
@@ -16,10 +16,12 @@
     "src/",
     "wasm/"
   ],
-  "scripts": {
-    "inline-wasm": "tsx scripts/inline-wasm.ts",
-    "build": "npm run inline-wasm && tsc",
-    "bench:boolean-manifold-baseline": "npm run build && tsx scripts/bench-boolean-manifold-baseline.ts",
+  "scripts": {
+    "build:wasm": "node -e \"require('fs').rmSync('wasm',{recursive:true,force:true})\" && cd .. && wasm-pack build --target web --out-dir okgeometry-api/wasm",
+    "inline-wasm": "tsx scripts/inline-wasm.ts",
+    "build": "npm run build:wasm && npm run inline-wasm && tsc",
+    "check:primitive-parity": "npm run build:wasm && tsx scripts/check-primitive-parity.ts",
+    "bench:boolean-manifold-baseline": "npm run build && tsx scripts/bench-boolean-manifold-baseline.ts",
     "bench:boolean-replacement-heavy": "npm run build && tsx scripts/bench-boolean-replacement-heavy.ts",
     "bench:boolean-deterministic": "npm run build && tsx scripts/bench-boolean-deterministic.ts",
     "bench:boolean-ab": "npm run build && tsx scripts/bench-boolean-ab.ts",

package/src/Arc.ts

@@ -1,117 +1,117 @@
-import { ensureInit } from "./engine.js";
-import { Point } from "./Point.js";
-import { Vec3 } from "./Vec3.js";
-import { Polyline } from "./Polyline.js";
-import type { Plane } from "./Plane.js";
-import type { RotationAxis } from "./types.js";
-import * as wasm from "../wasm/okgeometrycore_bg.js";
-
-/**
- * Immutable circular arc defined by center, radius, and angular span.
- * Angles are in radians, measured counter-clockwise from the positive X axis
- * in the plane defined by the normal.
- */
-export class Arc {
-  /**
-   * Create a new arc.
-   * @param center - Center point
-   * @param radius - Arc radius
-   * @param startAngle - Start angle in radians
-   * @param endAngle - End angle in radians
-   * @param normal - Normal vector defining the arc's plane (default Z axis)
-   */
-  constructor(
-    public readonly center: Point,
-    public readonly radius: number,
-    public readonly startAngle: number,
-    public readonly endAngle: number,
-    public readonly normal: Vec3 = Vec3.Z
-  ) {}
-
-  /**
-   * Evaluate a point on the arc at normalized parameter t.
-   * @param t - Parameter in [0, 1] (0 = start angle, 1 = end angle)
-   * @returns Point on arc at parameter t
-   */
-  pointAt(t: number): Point {
-    ensureInit();
-    const r = wasm.arc_point_at(
-      this.center.x, this.center.y, this.center.z,
-      this.normal.x, this.normal.y, this.normal.z,
-      this.radius, this.startAngle, this.endAngle, t
-    );
-    return new Point(r[0], r[1], r[2]);
-  }
-
-  /**
-   * Get the arc length.
-   * @returns Arc length = radius * angular span
-   */
-  length(): number {
-    ensureInit();
-    return wasm.arc_length(this.radius, this.startAngle, this.endAngle);
-  }
-
-  /**
-   * Translate this arc by an offset vector.
-   * @param offset - Translation vector
-   * @returns New translated arc
-   */
-  translate(offset: Vec3): Arc {
-    return new Arc(this.center.add(offset), this.radius, this.startAngle, this.endAngle, this.normal);
-  }
-
-  /**
-   * Rotate this arc around an axis.
-   * @param axis - Rotation axis (Vec3 through origin, or Line for arbitrary axis)
-   * @param angle - Rotation angle in radians
-   * @returns New rotated arc
-   */
-  rotate(axis: RotationAxis, angle: number): Arc {
-    const n = this.normal;
-    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);
-    return new Arc(this.center.rotate(axis, angle), this.radius, this.startAngle, this.endAngle, new Vec3(rn.x, rn.y, rn.z));
-  }
-
-  /**
-   * Offset this arc by changing its radius.
-   * @param distance - Distance to offset (positive = larger, negative = smaller)
-   * @returns New arc with adjusted radius
-   */
-  offset(distance: number): Arc {
-    return new Arc(this.center, this.radius + distance, this.startAngle, this.endAngle, this.normal);
-  }
-
-  /**
-   * Project onto plane. Returns a Polyline because a tilted arc projects to an elliptical arc.
-   * @param plane - Target plane
-   * @param direction - Optional projection direction (default: perpendicular to plane)
-   * @param samples - Number of sample points for approximation (default 64)
-   * @returns Polyline approximating the projected arc
-   */
-  projectOntoPlane(plane: Plane, direction?: Vec3, samples = 64): Polyline {
-    const pts = this.sample(samples);
-    const proj = (p: Point) => direction ? plane.projectPointAlongDirection(p, direction) : plane.projectPoint(p);
-    return new Polyline(pts.map(proj));
-  }
-
-  /**
-   * Sample the arc into evenly-spaced points.
-   * @param n - Number of points to generate
-   * @returns Array of n points along the arc
-   */
-  sample(n: number): Point[] {
-    ensureInit();
-    const buf = wasm.create_arc(
-      this.center.x, this.center.y, this.center.z,
-      this.normal.x, this.normal.y, this.normal.z,
-      this.radius, this.startAngle, this.endAngle, 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;
-  }
-}
+import { ensureInit } from "./engine.js";
+import { Point } from "./Point.js";
+import { Vec3 } from "./Vec3.js";
+import { Polyline } from "./Polyline.js";
+import type { Plane } from "./Plane.js";
+import type { RotationAxis } from "./types.js";
+import * as wasm from "../wasm/okgeometrycore.js";
+
+/**
+ * Immutable circular arc defined by center, radius, and angular span.
+ * Angles are in radians, measured counter-clockwise from the positive X axis
+ * in the plane defined by the normal.
+ */
+export class Arc {
+  /**
+   * Create a new arc.
+   * @param center - Center point
+   * @param radius - Arc radius
+   * @param startAngle - Start angle in radians
+   * @param endAngle - End angle in radians
+   * @param normal - Normal vector defining the arc's plane (default Z axis)
+   */
+  constructor(
+    public readonly center: Point,
+    public readonly radius: number,
+    public readonly startAngle: number,
+    public readonly endAngle: number,
+    public readonly normal: Vec3 = Vec3.Z
+  ) {}
+
+  /**
+   * Evaluate a point on the arc at normalized parameter t.
+   * @param t - Parameter in [0, 1] (0 = start angle, 1 = end angle)
+   * @returns Point on arc at parameter t
+   */
+  pointAt(t: number): Point {
+    ensureInit();
+    const r = wasm.arc_point_at(
+      this.center.x, this.center.y, this.center.z,
+      this.normal.x, this.normal.y, this.normal.z,
+      this.radius, this.startAngle, this.endAngle, t
+    );
+    return new Point(r[0], r[1], r[2]);
+  }
+
+  /**
+   * Get the arc length.
+   * @returns Arc length = radius * angular span
+   */
+  length(): number {
+    ensureInit();
+    return wasm.arc_length(this.radius, this.startAngle, this.endAngle);
+  }
+
+  /**
+   * Translate this arc by an offset vector.
+   * @param offset - Translation vector
+   * @returns New translated arc
+   */
+  translate(offset: Vec3): Arc {
+    return new Arc(this.center.add(offset), this.radius, this.startAngle, this.endAngle, this.normal);
+  }
+
+  /**
+   * Rotate this arc around an axis.
+   * @param axis - Rotation axis (Vec3 through origin, or Line for arbitrary axis)
+   * @param angle - Rotation angle in radians
+   * @returns New rotated arc
+   */
+  rotate(axis: RotationAxis, angle: number): Arc {
+    const n = this.normal;
+    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);
+    return new Arc(this.center.rotate(axis, angle), this.radius, this.startAngle, this.endAngle, new Vec3(rn.x, rn.y, rn.z));
+  }
+
+  /**
+   * Offset this arc by changing its radius.
+   * @param distance - Distance to offset (positive = larger, negative = smaller)
+   * @returns New arc with adjusted radius
+   */
+  offset(distance: number): Arc {
+    return new Arc(this.center, this.radius + distance, this.startAngle, this.endAngle, this.normal);
+  }
+
+  /**
+   * Project onto plane. Returns a Polyline because a tilted arc projects to an elliptical arc.
+   * @param plane - Target plane
+   * @param direction - Optional projection direction (default: perpendicular to plane)
+   * @param samples - Number of sample points for approximation (default 64)
+   * @returns Polyline approximating the projected arc
+   */
+  projectOntoPlane(plane: Plane, direction?: Vec3, samples = 64): Polyline {
+    const pts = this.sample(samples);
+    const proj = (p: Point) => direction ? plane.projectPointAlongDirection(p, direction) : plane.projectPoint(p);
+    return new Polyline(pts.map(proj));
+  }
+
+  /**
+   * Sample the arc into evenly-spaced points.
+   * @param n - Number of points to generate
+   * @returns Array of n points along the arc
+   */
+  sample(n: number): Point[] {
+    ensureInit();
+    const buf = wasm.create_arc(
+      this.center.x, this.center.y, this.center.z,
+      this.normal.x, this.normal.y, this.normal.z,
+      this.radius, this.startAngle, this.endAngle, 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;
+  }
+}

package/src/Circle.ts

@@ -1,153 +1,153 @@
-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/okgeometrycore_bg.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.
-   * @param n - Number of points to generate
-   * @returns Array of n points around the circle
-   */
-  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);
-  }
-}
+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/okgeometrycore.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.
+   * @param n - Number of points to generate
+   * @returns Array of n points around the circle
+   */
+  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);
+  }
+}