okgeometry-api 1.1.6 → 1.1.7

package/src/Polyline.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 { Line } from "./Line.js";
-import { PolyCurve } from "./PolyCurve.js";
-import type { Plane } from "./Plane.js";
-import type { RotationAxis } from "./types.js";
-import { pointsToCoords, coordsToPoints } from "./BufferCodec.js";
-import * as wasm from "../wasm/okgeometrycore_bg.js";
-
-/**
- * Open or closed polyline defined by a sequence of points.
- * Supports length, evaluation, transformation, and extrusion operations.
- */
-export class Polyline {
-  public readonly points: Point[];
-
-  constructor(points: Point[]) {
-    this.points = points;
-  }
-
-  /**
-   * Get the total length of this polyline.
-   * @returns Sum of segment lengths
-   */
-  length(): number {
-    ensureInit();
-    return wasm.polyline_length(this.toCoords());
-  }
-
-  /**
-   * Evaluate a point on the polyline at normalized parameter t.
-   * @param t - Parameter in [0, 1] (0 = first point, 1 = last point)
-   * @returns Point on polyline at parameter t
-   */
-  pointAt(t: number): Point {
-    ensureInit();
-    const r = wasm.polyline_point_at(this.toCoords(), t);
-    return new Point(r[0], r[1], r[2]);
-  }
-
-  /**
-   * Check if this polyline is closed.
-   * @param eps - Tolerance for comparing first and last points
-   * @returns True if first and last points coincide
-   */
-  isClosed(eps = 1e-10): boolean {
-    if (this.points.length < 2) return false;
-    return this.points[0].equals(this.points[this.points.length - 1], eps);
-  }
-
-  /**
-   * Extrude this polyline along a direction vector.
-   * @param direction - Extrusion direction and magnitude
-   * @param segments - Number of segments along extrusion (default 1)
-   * @param caps - Whether to cap the ends (default false)
-   * @returns Mesh representing the extruded surface
-   */
-  extrude(direction: Vec3, segments = 1, caps = false): Mesh {
-    ensureInit();
-    const buf = wasm.extrude_polyline(
-      this.toCoords(),
-      direction.x, direction.y, direction.z,
-      segments, caps
-    );
-    return Mesh.fromBuffer(buf);
-  }
-
-  /**
-   * Translate this polyline by an offset vector.
-   * @param offset - Translation vector
-   * @returns New translated polyline
-   */
-  translate(offset: Vec3): Polyline {
-    return new Polyline(this.points.map(p => p.add(offset)));
-  }
-
-  /**
-   * Rotate this polyline around an axis.
-   * @param axis - Rotation axis (Vec3 through origin, or Line for arbitrary axis)
-   * @param angle - Rotation angle in radians
-   * @returns New rotated polyline
-   */
-  rotate(axis: RotationAxis, angle: number): Polyline {
-    return new Polyline(this.points.map(p => p.rotate(axis, angle)));
-  }
-
-  /**
-   * Offset this polyline perpendicular to its segments.
-   * @param distance - Offset distance
-   * @param normal - Reference normal for determining offset direction
-   * @returns New offset polyline
-   */
-  offset(distance: number, normal?: Vec3): Polyline {
-    ensureInit();
-    const nx = normal?.x ?? 0, ny = normal?.y ?? 0, nz = normal?.z ?? 0;
-    const result = wasm.offset_polyline_curve(this.toCoords(), distance, nx, ny, nz);
-    return new Polyline(coordsToPoints(result));
-  }
-
-  /**
-   * Project this polyline onto a plane.
-   * @param plane - Target plane
-   * @param direction - Optional projection direction (default: perpendicular to plane)
-   * @returns New projected polyline
-   */
-  projectOntoPlane(plane: Plane, direction?: Vec3): Polyline {
-    const proj = (p: Point) => direction ? plane.projectPointAlongDirection(p, direction) : plane.projectPoint(p);
-    return new Polyline(this.points.map(proj));
-  }
-
-  /**
-   * Fillet corners of this polyline with arcs of the given radius.
-   * @param radius - Fillet radius
-   * @param normal - Reference normal for arc orientation (auto-detected if not provided)
-   * @returns PolyCurve with Line and Arc segments
-   */
-  fillet(radius: number, normal?: Vec3): PolyCurve {
-    ensureInit();
-    if (this.points.length < 3) {
-      throw new Error("Polyline.fillet() requires at least 3 points");
-    }
-
-    const nx = normal?.x ?? 0, ny = normal?.y ?? 0, nz = normal?.z ?? 0;
-    const buf = wasm.fillet_polycurve(this.toCoords(), radius, nx, ny, nz);
-    if (buf.length < 1) {
-      throw new Error("Polyline.fillet() failed - WASM returned empty result");
-    }
-
-    return PolyCurve.fromSegmentData(buf);
-  }
-
-  /**
-   * Convert this polyline to a PolyCurve (line segments only).
-   * @returns PolyCurve with Line segments connecting consecutive points
-   */
-  toPolyCurve(): PolyCurve {
-    const segs: Line[] = [];
-    for (let i = 0; i < this.points.length - 1; i++) {
-      segs.push(new Line(this.points[i], this.points[i + 1]));
-    }
-    return new PolyCurve(segs);
-  }
-
-  /**
-   * Convert points to flat coordinate array for WASM.
-   * @returns Float64Array [x1,y1,z1, x2,y2,z2, ...]
-   */
-  private toCoords(): Float64Array {
-    return pointsToCoords(this.points);
-  }
-}
+import { ensureInit } from "./engine.js";
+import { Point } from "./Point.js";
+import { Vec3 } from "./Vec3.js";
+import { Mesh } from "./Mesh.js";
+import { Line } from "./Line.js";
+import { PolyCurve } from "./PolyCurve.js";
+import type { Plane } from "./Plane.js";
+import type { RotationAxis } from "./types.js";
+import { pointsToCoords, coordsToPoints } from "./BufferCodec.js";
+import * as wasm from "../wasm/okgeometrycore.js";
+
+/**
+ * Open or closed polyline defined by a sequence of points.
+ * Supports length, evaluation, transformation, and extrusion operations.
+ */
+export class Polyline {
+  public readonly points: Point[];
+
+  constructor(points: Point[]) {
+    this.points = points;
+  }
+
+  /**
+   * Get the total length of this polyline.
+   * @returns Sum of segment lengths
+   */
+  length(): number {
+    ensureInit();
+    return wasm.polyline_length(this.toCoords());
+  }
+
+  /**
+   * Evaluate a point on the polyline at normalized parameter t.
+   * @param t - Parameter in [0, 1] (0 = first point, 1 = last point)
+   * @returns Point on polyline at parameter t
+   */
+  pointAt(t: number): Point {
+    ensureInit();
+    const r = wasm.polyline_point_at(this.toCoords(), t);
+    return new Point(r[0], r[1], r[2]);
+  }
+
+  /**
+   * Check if this polyline is closed.
+   * @param eps - Tolerance for comparing first and last points
+   * @returns True if first and last points coincide
+   */
+  isClosed(eps = 1e-10): boolean {
+    if (this.points.length < 2) return false;
+    return this.points[0].equals(this.points[this.points.length - 1], eps);
+  }
+
+  /**
+   * Extrude this polyline along a direction vector.
+   * @param direction - Extrusion direction and magnitude
+   * @param segments - Number of segments along extrusion (default 1)
+   * @param caps - Whether to cap the ends (default false)
+   * @returns Mesh representing the extruded surface
+   */
+  extrude(direction: Vec3, segments = 1, caps = false): Mesh {
+    ensureInit();
+    const buf = wasm.extrude_polyline(
+      this.toCoords(),
+      direction.x, direction.y, direction.z,
+      segments, caps
+    );
+    return Mesh.fromBuffer(buf);
+  }
+
+  /**
+   * Translate this polyline by an offset vector.
+   * @param offset - Translation vector
+   * @returns New translated polyline
+   */
+  translate(offset: Vec3): Polyline {
+    return new Polyline(this.points.map(p => p.add(offset)));
+  }
+
+  /**
+   * Rotate this polyline around an axis.
+   * @param axis - Rotation axis (Vec3 through origin, or Line for arbitrary axis)
+   * @param angle - Rotation angle in radians
+   * @returns New rotated polyline
+   */
+  rotate(axis: RotationAxis, angle: number): Polyline {
+    return new Polyline(this.points.map(p => p.rotate(axis, angle)));
+  }
+
+  /**
+   * Offset this polyline perpendicular to its segments.
+   * @param distance - Offset distance
+   * @param normal - Reference normal for determining offset direction
+   * @returns New offset polyline
+   */
+  offset(distance: number, normal?: Vec3): Polyline {
+    ensureInit();
+    const nx = normal?.x ?? 0, ny = normal?.y ?? 0, nz = normal?.z ?? 0;
+    const result = wasm.offset_polyline_curve(this.toCoords(), distance, nx, ny, nz);
+    return new Polyline(coordsToPoints(result));
+  }
+
+  /**
+   * Project this polyline onto a plane.
+   * @param plane - Target plane
+   * @param direction - Optional projection direction (default: perpendicular to plane)
+   * @returns New projected polyline
+   */
+  projectOntoPlane(plane: Plane, direction?: Vec3): Polyline {
+    const proj = (p: Point) => direction ? plane.projectPointAlongDirection(p, direction) : plane.projectPoint(p);
+    return new Polyline(this.points.map(proj));
+  }
+
+  /**
+   * Fillet corners of this polyline with arcs of the given radius.
+   * @param radius - Fillet radius
+   * @param normal - Reference normal for arc orientation (auto-detected if not provided)
+   * @returns PolyCurve with Line and Arc segments
+   */
+  fillet(radius: number, normal?: Vec3): PolyCurve {
+    ensureInit();
+    if (this.points.length < 3) {
+      throw new Error("Polyline.fillet() requires at least 3 points");
+    }
+
+    const nx = normal?.x ?? 0, ny = normal?.y ?? 0, nz = normal?.z ?? 0;
+    const buf = wasm.fillet_polycurve(this.toCoords(), radius, nx, ny, nz);
+    if (buf.length < 1) {
+      throw new Error("Polyline.fillet() failed - WASM returned empty result");
+    }
+
+    return PolyCurve.fromSegmentData(buf);
+  }
+
+  /**
+   * Convert this polyline to a PolyCurve (line segments only).
+   * @returns PolyCurve with Line segments connecting consecutive points
+   */
+  toPolyCurve(): PolyCurve {
+    const segs: Line[] = [];
+    for (let i = 0; i < this.points.length - 1; i++) {
+      segs.push(new Line(this.points[i], this.points[i + 1]));
+    }
+    return new PolyCurve(segs);
+  }
+
+  /**
+   * Convert points to flat coordinate array for WASM.
+   * @returns Float64Array [x1,y1,z1, x2,y2,z2, ...]
+   */
+  private toCoords(): Float64Array {
+    return pointsToCoords(this.points);
+  }
+}

package/src/Ray.ts

@@ -1,90 +1,90 @@
-import { ensureInit } from "./engine.js";
-import { Point } from "./Point.js";
-import { Vec3 } from "./Vec3.js";
-import * as wasm from "../wasm/okgeometrycore_bg.js";
-
-/**
- * 3D ray defined by origin and direction.
- * Parametric form: point(t) = origin + t * direction
- */
-export class Ray {
-  constructor(
-    public readonly origin: Point,
-    public readonly direction: Vec3
-  ) {}
-
-  /**
-   * Create a ray from origin and direction, normalizing the direction.
-   * Returns null if direction is zero-length.
-   */
-  static fromOriginDirection(origin: Point, direction: Vec3): Ray | null {
-    const normalized = direction.normalize();
-    if (normalized.length() < 1e-10) return null;
-    return new Ray(origin, normalized);
-  }
-
-  /**
-   * Get point along the ray at parameter t.
-   * Returns origin + t * direction
-   */
-  pointAt(t: number): Point {
-    ensureInit();
-    const r = wasm.ray_point_at(
-      this.origin.x, this.origin.y, this.origin.z,
-      this.direction.x, this.direction.y, this.direction.z,
-      t
-    );
-    return new Point(r[0], r[1], r[2]);
-  }
-
-  /**
-   * Find the parameter t for the closest point on the ray to a given point.
-   * The closest point is at: origin + t * direction
-   * Note: t can be negative if the closest point is "behind" the ray origin,
-   * but closestPoint() clamps t >= 0.
-   */
-  closestPointParameter(point: Point): number {
-    ensureInit();
-    return wasm.ray_closest_point_parameter(
-      this.origin.x, this.origin.y, this.origin.z,
-      this.direction.x, this.direction.y, this.direction.z,
-      point.x, point.y, point.z
-    );
-  }
-
-  /**
-   * Find the closest point on the ray to a given point.
-   * The result is clamped to the ray (t >= 0), so if the closest
-   * point would be "behind" the origin, returns the origin.
-   */
-  closestPoint(point: Point): Point {
-    ensureInit();
-    const r = wasm.ray_closest_point(
-      this.origin.x, this.origin.y, this.origin.z,
-      this.direction.x, this.direction.y, this.direction.z,
-      point.x, point.y, point.z
-    );
-    return new Point(r[0], r[1], r[2]);
-  }
-
-  /**
-   * Compute the distance from this ray to a point.
-   * This is the perpendicular distance from the ray to the point,
-   * clamped so that the closest point is on the ray (t >= 0).
-   */
-  distanceToPoint(point: Point): number {
-    ensureInit();
-    return wasm.ray_distance_to_point(
-      this.origin.x, this.origin.y, this.origin.z,
-      this.direction.x, this.direction.y, this.direction.z,
-      point.x, point.y, point.z
-    );
-  }
-
-  /**
-   * Translate the ray by an offset vector.
-   */
-  translate(offset: Vec3): Ray {
-    return new Ray(this.origin.add(offset), this.direction);
-  }
-}
+import { ensureInit } from "./engine.js";
+import { Point } from "./Point.js";
+import { Vec3 } from "./Vec3.js";
+import * as wasm from "../wasm/okgeometrycore.js";
+
+/**
+ * 3D ray defined by origin and direction.
+ * Parametric form: point(t) = origin + t * direction
+ */
+export class Ray {
+  constructor(
+    public readonly origin: Point,
+    public readonly direction: Vec3
+  ) {}
+
+  /**
+   * Create a ray from origin and direction, normalizing the direction.
+   * Returns null if direction is zero-length.
+   */
+  static fromOriginDirection(origin: Point, direction: Vec3): Ray | null {
+    const normalized = direction.normalize();
+    if (normalized.length() < 1e-10) return null;
+    return new Ray(origin, normalized);
+  }
+
+  /**
+   * Get point along the ray at parameter t.
+   * Returns origin + t * direction
+   */
+  pointAt(t: number): Point {
+    ensureInit();
+    const r = wasm.ray_point_at(
+      this.origin.x, this.origin.y, this.origin.z,
+      this.direction.x, this.direction.y, this.direction.z,
+      t
+    );
+    return new Point(r[0], r[1], r[2]);
+  }
+
+  /**
+   * Find the parameter t for the closest point on the ray to a given point.
+   * The closest point is at: origin + t * direction
+   * Note: t can be negative if the closest point is "behind" the ray origin,
+   * but closestPoint() clamps t >= 0.
+   */
+  closestPointParameter(point: Point): number {
+    ensureInit();
+    return wasm.ray_closest_point_parameter(
+      this.origin.x, this.origin.y, this.origin.z,
+      this.direction.x, this.direction.y, this.direction.z,
+      point.x, point.y, point.z
+    );
+  }
+
+  /**
+   * Find the closest point on the ray to a given point.
+   * The result is clamped to the ray (t >= 0), so if the closest
+   * point would be "behind" the origin, returns the origin.
+   */
+  closestPoint(point: Point): Point {
+    ensureInit();
+    const r = wasm.ray_closest_point(
+      this.origin.x, this.origin.y, this.origin.z,
+      this.direction.x, this.direction.y, this.direction.z,
+      point.x, point.y, point.z
+    );
+    return new Point(r[0], r[1], r[2]);
+  }
+
+  /**
+   * Compute the distance from this ray to a point.
+   * This is the perpendicular distance from the ray to the point,
+   * clamped so that the closest point is on the ray (t >= 0).
+   */
+  distanceToPoint(point: Point): number {
+    ensureInit();
+    return wasm.ray_distance_to_point(
+      this.origin.x, this.origin.y, this.origin.z,
+      this.direction.x, this.direction.y, this.direction.z,
+      point.x, point.y, point.z
+    );
+  }
+
+  /**
+   * Translate the ray by an offset vector.
+   */
+  translate(offset: Vec3): Ray {
+    return new Ray(this.origin.add(offset), this.direction);
+  }
+}

package/src/engine.ts

@@ -1,25 +1,23 @@
 import { WASM_B64 } from "./wasm-base64.js";
 import coreWasmInit from "../wasm/okgeometrycore.js";
-import * as bg from "../wasm/okgeometrycore_bg.js";
 
 let initialized = false;
-
-const engineGlobal = globalThis as typeof globalThis & {
-  __okgeometry_boolean_should_cancel?: () => boolean;
-};
 
-if (typeof engineGlobal.__okgeometry_boolean_should_cancel !== "function") {
-  engineGlobal.__okgeometry_boolean_should_cancel = () => false;
-}
-
+const engineGlobal = globalThis as typeof globalThis & {
+  __okgeometry_boolean_should_cancel?: () => boolean;
+};
+
+if (typeof engineGlobal.__okgeometry_boolean_should_cancel !== "function") {
+  engineGlobal.__okgeometry_boolean_should_cancel = () => false;
+}
+
 export async function init(): Promise<void> {
   if (initialized) return;
   const raw = atob(WASM_B64);
   const bytes = new Uint8Array(raw.length);
   for (let i = 0; i < raw.length; i++) bytes[i] = raw.charCodeAt(i);
 
-  const exports = await coreWasmInit({ module_or_path: bytes });
-  (bg as any).__wbg_set_wasm(exports);
+  await coreWasmInit({ module_or_path: bytes });
 
   initialized = true;
 }

package/src/index.ts

@@ -39,7 +39,13 @@ export type {
   MeshBooleanDebugProbeId,
   MeshBooleanDebugOptions,
   MeshBooleanDebugProbe,
+  MeshBooleanDebugProbeSummary,
   MeshBooleanDebugReport,
+  MeshBooleanReproOperand,
+  MeshBooleanReproResult,
+  MeshBooleanReproError,
+  MeshBooleanReproPayload,
+  MeshBooleanReproOptions,
   MeshDebugBounds,
   MeshDebugRayHit,
   MeshDebugSummary,