opengeometry 2.0.11 → 2.0.13

package/index.js

@@ -209,42 +209,16 @@ function getStringFromWasm0(ptr, len) {
   ptr = ptr >>> 0;
   return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
 }
-function takeFromExternrefTable0(idx) {
-  const value = wasm.__wbindgen_export_2.get(idx);
-  wasm.__externref_table_dealloc(idx);
-  return value;
-}
-/**
- * @param {string} local_brep_serialized
- * @param {number} height
- * @returns {string}
- */
-function extrudeBrepFace$1(local_brep_serialized, height) {
-  let deferred3_0;
-  let deferred3_1;
-  try {
-    const ptr0 = passStringToWasm0(local_brep_serialized, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ret = wasm.extrudeBrepFace(ptr0, len0, height);
-    var ptr2 = ret[0];
-    var len2 = ret[1];
-    if (ret[3]) {
-      ptr2 = 0;
-      len2 = 0;
-      throw takeFromExternrefTable0(ret[2]);
-    }
-    deferred3_0 = ptr2;
-    deferred3_1 = len2;
-    return getStringFromWasm0(ptr2, len2);
-  } finally {
-    wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
-  }
-}
 function _assertClass(instance, klass) {
   if (!(instance instanceof klass)) {
     throw new Error(`expected instance of ${klass.name}`);
   }
 }
+function takeFromExternrefTable0(idx) {
+  const value = wasm.__wbindgen_export_2.get(idx);
+  wasm.__externref_table_dealloc(idx);
+  return value;
+}
 let cachedFloat64ArrayMemory0 = null;
 function getFloat64ArrayMemory0() {
   if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
@@ -265,6 +239,12 @@ function passArrayJsValueToWasm0(array, malloc) {
   WASM_VECTOR_LEN = array.length;
   return ptr;
 }
+function passArrayF64ToWasm0(arg, malloc) {
+  const ptr = malloc(arg.length * 8, 8) >>> 0;
+  getFloat64ArrayMemory0().set(arg, ptr / 8);
+  WASM_VECTOR_LEN = arg.length;
+  return ptr;
+}
 function getArrayJsValueFromWasm0(ptr, len) {
   ptr = ptr >>> 0;
   const mem = getDataViewMemory0();
@@ -278,12 +258,91 @@ function getArrayJsValueFromWasm0(ptr, len) {
 function isLikeNone(x) {
   return x === undefined || x === null;
 }
-function passArrayF64ToWasm0(arg, malloc) {
-  const ptr = malloc(arg.length * 8, 8) >>> 0;
-  getFloat64ArrayMemory0().set(arg, ptr / 8);
-  WASM_VECTOR_LEN = arg.length;
-  return ptr;
+/**
+ * Wasm entry point: analyze a flat `[x0,y0,z0,…]` loop, returning the report as
+ * JSON (the corrected points are not returned here; use the kernel API).
+ * @param {Float64Array} flat_points
+ * @returns {string}
+ */
+function analyzeProfile(flat_points) {
+  let deferred3_0;
+  let deferred3_1;
+  try {
+    const ptr0 = passArrayF64ToWasm0(flat_points, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.analyzeProfile(ptr0, len0);
+    var ptr2 = ret[0];
+    var len2 = ret[1];
+    if (ret[3]) {
+      ptr2 = 0;
+      len2 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred3_0 = ptr2;
+    deferred3_1 = len2;
+    return getStringFromWasm0(ptr2, len2);
+  } finally {
+    wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+  }
+}
+
+/**
+ * Wasm entry point: check a serialized B-rep's geometric validity, returning
+ * the [`ValidityReport`] as JSON.
+ * @param {string} brep_json
+ * @returns {string}
+ */
+function checkBrepValidity(brep_json) {
+  let deferred3_0;
+  let deferred3_1;
+  try {
+    const ptr0 = passStringToWasm0(brep_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.checkBrepValidity(ptr0, len0);
+    var ptr2 = ret[0];
+    var len2 = ret[1];
+    if (ret[3]) {
+      ptr2 = 0;
+      len2 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred3_0 = ptr2;
+    deferred3_1 = len2;
+    return getStringFromWasm0(ptr2, len2);
+  } finally {
+    wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+  }
+}
+
+/**
+ * Wasm entry point: heal a serialized B-rep, returning JSON
+ * `{ "brep": <healed brep>, "report": <heal report> }`.
+ * @param {string} brep_json
+ * @param {number} tolerance
+ * @returns {string}
+ */
+function healBrep(brep_json, tolerance) {
+  let deferred3_0;
+  let deferred3_1;
+  try {
+    const ptr0 = passStringToWasm0(brep_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.healBrep(ptr0, len0, tolerance);
+    var ptr2 = ret[0];
+    var len2 = ret[1];
+    if (ret[3]) {
+      ptr2 = 0;
+      len2 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred3_0 = ptr2;
+    deferred3_1 = len2;
+    return getStringFromWasm0(ptr2, len2);
+  } finally {
+    wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+  }
 }
+
 /**
  * Wasm entry point: offset a centreline by `width` into stroked regions via the
  * deterministic analytic offset. `centreline_flat` is `[x0,y0,z0, …]`. Returns
@@ -322,6 +381,103 @@ function offsetPolylineGroupRegions$1(polylines_json) {
   return OGOffsetRegionsResult.__wrap(ret[0]);
 }
 
+/**
+ * Wasm entry point: inset a CLOSED ring inward with one distance per edge
+ * (edge i = ring[i] → ring[i+1]). `ring_flat` is `[x0,y0,z0, …]`;
+ * `holes_json` is `[{ring:[x,y,z,…], distances:[…]}, …]` (`"[]"` = none) —
+ * excluded interior rings, each grown outward by its own per-edge distances.
+ * Returns CW-outer / CCW-hole regions, canonicalised; possibly several when a
+ * deep inset (or a hole) splits the ring, and empty (does NOT throw) when the
+ * inset collapses or the outer ring is degenerate. THROWS on malformed
+ * arguments: a distance count that does not match an edge count, a negative /
+ * non-finite distance, a degenerate hole, or unparsable `holes_json`. Corners
+ * where distances differ are circumscribed clearance arcs (conservative), so
+ * no output point is ever closer to an edge than that edge's distance —
+ * there is no miter-limit knob because there are no miters.
+ * @param {Float64Array} ring_flat
+ * @param {Float64Array} distances
+ * @param {string} holes_json
+ * @returns {OGOffsetRegionsResult}
+ */
+function offsetRingVariable$1(ring_flat, distances, holes_json) {
+  const ptr0 = passArrayF64ToWasm0(ring_flat, wasm.__wbindgen_malloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ptr1 = passArrayF64ToWasm0(distances, wasm.__wbindgen_malloc);
+  const len1 = WASM_VECTOR_LEN;
+  const ptr2 = passStringToWasm0(holes_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len2 = WASM_VECTOR_LEN;
+  const ret = wasm.offsetRingVariable(ptr0, len0, ptr1, len1, ptr2, len2);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return OGOffsetRegionsResult.__wrap(ret[0]);
+}
+
+/**
+ * @param {string} local_brep_serialized
+ * @param {number} height
+ * @returns {string}
+ */
+function extrudeBrepFace$1(local_brep_serialized, height) {
+  let deferred3_0;
+  let deferred3_1;
+  try {
+    const ptr0 = passStringToWasm0(local_brep_serialized, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.extrudeBrepFace(ptr0, len0, height);
+    var ptr2 = ret[0];
+    var len2 = ret[1];
+    if (ret[3]) {
+      ptr2 = 0;
+      len2 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred3_0 = ptr2;
+    deferred3_1 = len2;
+    return getStringFromWasm0(ptr2, len2);
+  } finally {
+    wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+  }
+}
+
+/**
+ * Wasm entry point for general extrude. `direction` is `[x,y,z]`; `extent_kind`
+ * is `"one_sided" | "symmetric" | "two_sided"`; `d_plus`/`d_minus` are the
+ * extent distances (`d_minus` ignored unless two-sided, `d_plus` is the
+ * distance for one-sided/symmetric).
+ * @param {string} local_brep_serialized
+ * @param {Float64Array} direction
+ * @param {string} extent_kind
+ * @param {number} d_plus
+ * @param {number} d_minus
+ * @returns {string}
+ */
+function extrudeBrepFaceDirectional(local_brep_serialized, direction, extent_kind, d_plus, d_minus) {
+  let deferred5_0;
+  let deferred5_1;
+  try {
+    const ptr0 = passStringToWasm0(local_brep_serialized, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passArrayF64ToWasm0(direction, wasm.__wbindgen_malloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passStringToWasm0(extent_kind, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.extrudeBrepFaceDirectional(ptr0, len0, ptr1, len1, ptr2, len2, d_plus, d_minus);
+    var ptr4 = ret[0];
+    var len4 = ret[1];
+    if (ret[3]) {
+      ptr4 = 0;
+      len4 = 0;
+      throw takeFromExternrefTable0(ret[2]);
+    }
+    deferred5_0 = ptr4;
+    deferred5_1 = len4;
+    return getStringFromWasm0(ptr4, len4);
+  } finally {
+    wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
+  }
+}
+
 /**
  * Wasm entry point for union.
  * @param {string} lhs_brep_serialized
@@ -1639,25 +1795,288 @@ class OGCylinder {
   set_scale(scale) {
     _assertClass(scale, Vector3);
     var ptr0 = scale.__destroy_into_raw();
-    const ret = wasm.ogcylinder_set_scale(this.__wbg_ptr, ptr0);
+    const ret = wasm.ogcylinder_set_scale(this.__wbg_ptr, ptr0);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  generate_brep() {
+    const ret = wasm.ogcylinder_generate_brep(this.__wbg_ptr);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  clean_geometry() {
+    wasm.ogcylinder_clean_geometry(this.__wbg_ptr);
+  }
+  generate_geometry() {
+    const ret = wasm.ogcylinder_generate_geometry(this.__wbg_ptr);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  /**
+   * @returns {string}
+   */
+  get_brep_serialized() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.ogcylinder_get_brep_serialized(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @returns {string}
+   */
+  get_local_brep_serialized() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.ogcylinder_get_local_brep_serialized(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @returns {string}
+   */
+  get_geometry_serialized() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.ogcylinder_get_geometry_serialized(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @returns {string}
+   */
+  get_local_geometry_serialized() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.ogcylinder_get_local_geometry_serialized(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @returns {Float64Array}
+   */
+  get_geometry_buffer() {
+    const ret = wasm.ogcylinder_get_geometry_buffer(this.__wbg_ptr);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+  }
+  /**
+   * @returns {Float64Array}
+   */
+  get_local_geometry_buffer() {
+    const ret = wasm.ogcylinder_get_local_geometry_buffer(this.__wbg_ptr);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+  }
+  /**
+   * @returns {string}
+   */
+  get_outline_geometry_serialized() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.ogcylinder_get_outline_geometry_serialized(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @returns {string}
+   */
+  get_local_outline_geometry_serialized() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.ogcylinder_get_local_outline_geometry_serialized(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @returns {Float64Array}
+   */
+  get_outline_geometry_buffer() {
+    const ret = wasm.ogcylinder_get_outline_geometry_buffer(this.__wbg_ptr);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+  }
+  /**
+   * @returns {Float64Array}
+   */
+  get_local_outline_geometry_buffer() {
+    const ret = wasm.ogcylinder_get_local_outline_geometry_buffer(this.__wbg_ptr);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+  }
+  /**
+   * @returns {Vector3}
+   */
+  get_anchor() {
+    const ret = wasm.ogcylinder_get_anchor(this.__wbg_ptr);
+    return Vector3.__wrap(ret);
+  }
+}
+const OGEllipticalArcFinalization = typeof FinalizationRegistry === 'undefined' ? {
+  register: () => {},
+  unregister: () => {}
+} : new FinalizationRegistry(ptr => wasm.__wbg_ogellipticalarc_free(ptr >>> 0, 1));
+class OGEllipticalArc {
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    OGEllipticalArcFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_ogellipticalarc_free(ptr, 0);
+  }
+  /**
+   * @param {string} id
+   */
+  set id(id) {
+    const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    wasm.ogellipticalarc_set_id(this.__wbg_ptr, ptr0, len0);
+  }
+  /**
+   * @returns {string}
+   */
+  get id() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.ogellipticalarc_id(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * @param {string} id
+   */
+  constructor(id) {
+    const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.ogellipticalarc_new(ptr0, len0);
+    this.__wbg_ptr = ret >>> 0;
+    OGEllipticalArcFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+  /**
+   * @param {Vector3} center
+   * @param {number} radius_x
+   * @param {number} radius_z
+   * @param {number} start_angle
+   * @param {number} end_angle
+   * @param {number} segments
+   */
+  set_config(center, radius_x, radius_z, start_angle, end_angle, segments) {
+    _assertClass(center, Vector3);
+    var ptr0 = center.__destroy_into_raw();
+    const ret = wasm.ogellipticalarc_set_config(this.__wbg_ptr, ptr0, radius_x, radius_z, start_angle, end_angle, segments);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  /**
+   * @param {Vector3} center
+   */
+  set_center(center) {
+    _assertClass(center, Vector3);
+    var ptr0 = center.__destroy_into_raw();
+    wasm.ogellipticalarc_set_center(this.__wbg_ptr, ptr0);
+  }
+  /**
+   * @param {Vector3} position
+   * @param {Vector3} rotation
+   * @param {Vector3} scale
+   */
+  set_transform(position, rotation, scale) {
+    _assertClass(position, Vector3);
+    var ptr0 = position.__destroy_into_raw();
+    _assertClass(rotation, Vector3);
+    var ptr1 = rotation.__destroy_into_raw();
+    _assertClass(scale, Vector3);
+    var ptr2 = scale.__destroy_into_raw();
+    const ret = wasm.ogellipticalarc_set_transform(this.__wbg_ptr, ptr0, ptr1, ptr2);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  /**
+   * @param {Vector3} translation
+   */
+  set_translation(translation) {
+    _assertClass(translation, Vector3);
+    var ptr0 = translation.__destroy_into_raw();
+    wasm.ogellipticalarc_set_translation(this.__wbg_ptr, ptr0);
+  }
+  /**
+   * @param {Vector3} rotation
+   */
+  set_rotation(rotation) {
+    _assertClass(rotation, Vector3);
+    var ptr0 = rotation.__destroy_into_raw();
+    wasm.ogellipticalarc_set_rotation(this.__wbg_ptr, ptr0);
+  }
+  /**
+   * @param {Vector3} scale
+   */
+  set_scale(scale) {
+    _assertClass(scale, Vector3);
+    var ptr0 = scale.__destroy_into_raw();
+    const ret = wasm.ogellipticalarc_set_scale(this.__wbg_ptr, ptr0);
     if (ret[1]) {
       throw takeFromExternrefTable0(ret[0]);
     }
   }
-  generate_brep() {
-    const ret = wasm.ogcylinder_generate_brep(this.__wbg_ptr);
+  generate_geometry() {
+    const ret = wasm.ogellipticalarc_generate_geometry(this.__wbg_ptr);
     if (ret[1]) {
       throw takeFromExternrefTable0(ret[0]);
     }
   }
-  clean_geometry() {
-    wasm.ogcylinder_clean_geometry(this.__wbg_ptr);
+  dispose_points() {
+    wasm.ogellipticalarc_dispose_points(this.__wbg_ptr);
   }
-  generate_geometry() {
-    const ret = wasm.ogcylinder_generate_geometry(this.__wbg_ptr);
-    if (ret[1]) {
-      throw takeFromExternrefTable0(ret[0]);
-    }
+  destroy() {
+    wasm.ogellipticalarc_destroy(this.__wbg_ptr);
   }
   /**
    * @returns {string}
@@ -1666,7 +2085,7 @@ class OGCylinder {
     let deferred1_0;
     let deferred1_1;
     try {
-      const ret = wasm.ogcylinder_get_brep_serialized(this.__wbg_ptr);
+      const ret = wasm.ogellipticalarc_get_brep_serialized(this.__wbg_ptr);
       deferred1_0 = ret[0];
       deferred1_1 = ret[1];
       return getStringFromWasm0(ret[0], ret[1]);
@@ -1681,7 +2100,7 @@ class OGCylinder {
     let deferred1_0;
     let deferred1_1;
     try {
-      const ret = wasm.ogcylinder_get_local_brep_serialized(this.__wbg_ptr);
+      const ret = wasm.ogellipticalarc_get_local_brep_serialized(this.__wbg_ptr);
       deferred1_0 = ret[0];
       deferred1_1 = ret[1];
       return getStringFromWasm0(ret[0], ret[1]);
@@ -1696,7 +2115,7 @@ class OGCylinder {
     let deferred1_0;
     let deferred1_1;
     try {
-      const ret = wasm.ogcylinder_get_geometry_serialized(this.__wbg_ptr);
+      const ret = wasm.ogellipticalarc_get_geometry_serialized(this.__wbg_ptr);
       deferred1_0 = ret[0];
       deferred1_1 = ret[1];
       return getStringFromWasm0(ret[0], ret[1]);
@@ -1711,7 +2130,7 @@ class OGCylinder {
     let deferred1_0;
     let deferred1_1;
     try {
-      const ret = wasm.ogcylinder_get_local_geometry_serialized(this.__wbg_ptr);
+      const ret = wasm.ogellipticalarc_get_local_geometry_serialized(this.__wbg_ptr);
       deferred1_0 = ret[0];
       deferred1_1 = ret[1];
       return getStringFromWasm0(ret[0], ret[1]);
@@ -1723,7 +2142,7 @@ class OGCylinder {
    * @returns {Float64Array}
    */
   get_geometry_buffer() {
-    const ret = wasm.ogcylinder_get_geometry_buffer(this.__wbg_ptr);
+    const ret = wasm.ogellipticalarc_get_geometry_buffer(this.__wbg_ptr);
     var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
     wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
     return v1;
@@ -1732,55 +2151,7 @@ class OGCylinder {
    * @returns {Float64Array}
    */
   get_local_geometry_buffer() {
-    const ret = wasm.ogcylinder_get_local_geometry_buffer(this.__wbg_ptr);
-    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v1;
-  }
-  /**
-   * @returns {string}
-   */
-  get_outline_geometry_serialized() {
-    let deferred1_0;
-    let deferred1_1;
-    try {
-      const ret = wasm.ogcylinder_get_outline_geometry_serialized(this.__wbg_ptr);
-      deferred1_0 = ret[0];
-      deferred1_1 = ret[1];
-      return getStringFromWasm0(ret[0], ret[1]);
-    } finally {
-      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
-    }
-  }
-  /**
-   * @returns {string}
-   */
-  get_local_outline_geometry_serialized() {
-    let deferred1_0;
-    let deferred1_1;
-    try {
-      const ret = wasm.ogcylinder_get_local_outline_geometry_serialized(this.__wbg_ptr);
-      deferred1_0 = ret[0];
-      deferred1_1 = ret[1];
-      return getStringFromWasm0(ret[0], ret[1]);
-    } finally {
-      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
-    }
-  }
-  /**
-   * @returns {Float64Array}
-   */
-  get_outline_geometry_buffer() {
-    const ret = wasm.ogcylinder_get_outline_geometry_buffer(this.__wbg_ptr);
-    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
-    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
-    return v1;
-  }
-  /**
-   * @returns {Float64Array}
-   */
-  get_local_outline_geometry_buffer() {
-    const ret = wasm.ogcylinder_get_local_outline_geometry_buffer(this.__wbg_ptr);
+    const ret = wasm.ogellipticalarc_get_local_geometry_buffer(this.__wbg_ptr);
     var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
     wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
     return v1;
@@ -1789,7 +2160,7 @@ class OGCylinder {
    * @returns {Vector3}
    */
   get_anchor() {
-    const ret = wasm.ogcylinder_get_anchor(this.__wbg_ptr);
+    const ret = wasm.ogellipticalarc_get_anchor(this.__wbg_ptr);
     return Vector3.__wrap(ret);
   }
 }
@@ -3550,7 +3921,7 @@ class OGPolyline {
    * @returns {Vector3}
    */
   get_anchor() {
-    const ret = wasm.ogpolyline_get_anchor(this.__wbg_ptr);
+    const ret = wasm.ogline_get_anchor(this.__wbg_ptr);
     return Vector3.__wrap(ret);
   }
   /**
@@ -4878,7 +5249,7 @@ class OGSphere {
    * @returns {Vector3}
    */
   get_anchor() {
-    const ret = wasm.ogsphere_get_anchor(this.__wbg_ptr);
+    const ret = wasm.ogline_get_anchor(this.__wbg_ptr);
     return Vector3.__wrap(ret);
   }
 }
@@ -5260,7 +5631,7 @@ class OGSweep {
    * @returns {Vector3}
    */
   get_anchor() {
-    const ret = wasm.ogsweep_get_anchor(this.__wbg_ptr);
+    const ret = wasm.ogellipticalarc_get_anchor(this.__wbg_ptr);
     return Vector3.__wrap(ret);
   }
   /**
@@ -5541,7 +5912,7 @@ class OGWedge {
    * @returns {Vector3}
    */
   get_anchor() {
-    const ret = wasm.ogarc_get_anchor(this.__wbg_ptr);
+    const ret = wasm.ogwedge_get_anchor(this.__wbg_ptr);
     return Vector3.__wrap(ret);
   }
 }
@@ -5834,6 +6205,100 @@ class Vector3 {
     wasm.vector3_apply_matrix4(this.__wbg_ptr, ptr0);
   }
 }
+const WorkPlaneFinalization = typeof FinalizationRegistry === 'undefined' ? {
+  register: () => {},
+  unregister: () => {}
+} : new FinalizationRegistry(ptr => wasm.__wbg_workplane_free(ptr >>> 0, 1));
+class WorkPlane {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(WorkPlane.prototype);
+    obj.__wbg_ptr = ptr;
+    WorkPlaneFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    WorkPlaneFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_workplane_free(ptr, 0);
+  }
+  /**
+   * Builds a work plane from an origin and normal, choosing a stable in-plane
+   * `u` axis automatically (`v = normal × u`).
+   * @param {Vector3} origin
+   * @param {Vector3} normal
+   * @returns {WorkPlane}
+   */
+  static fromOriginNormal(origin, normal) {
+    _assertClass(origin, Vector3);
+    var ptr0 = origin.__destroy_into_raw();
+    _assertClass(normal, Vector3);
+    var ptr1 = normal.__destroy_into_raw();
+    const ret = wasm.workplane_fromOriginNormal(ptr0, ptr1);
+    return WorkPlane.__wrap(ret);
+  }
+  /**
+   * Builds a work plane from an origin, normal, and a preferred `u` axis. The
+   * `u` axis is projected onto the plane and orthonormalized; `v = normal × u`.
+   * @param {Vector3} origin
+   * @param {Vector3} normal
+   * @param {Vector3} u_hint
+   */
+  constructor(origin, normal, u_hint) {
+    _assertClass(origin, Vector3);
+    var ptr0 = origin.__destroy_into_raw();
+    _assertClass(normal, Vector3);
+    var ptr1 = normal.__destroy_into_raw();
+    _assertClass(u_hint, Vector3);
+    var ptr2 = u_hint.__destroy_into_raw();
+    const ret = wasm.workplane_new(ptr0, ptr1, ptr2);
+    this.__wbg_ptr = ret >>> 0;
+    WorkPlaneFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+  /**
+   * Lifts a single 2D in-plane coordinate to 3D world space.
+   * @param {number} u
+   * @param {number} v
+   * @returns {Vector3}
+   */
+  liftPoint(u, v) {
+    const ret = wasm.workplane_liftPoint(this.__wbg_ptr, u, v);
+    return Vector3.__wrap(ret);
+  }
+  /**
+   * Lifts a flat `[u0,v0,u1,v1,…]` buffer to a flat `[x0,y0,z0,…]` world buffer.
+   * @param {Float64Array} uv
+   * @returns {Float64Array}
+   */
+  liftPoints(uv) {
+    const ptr0 = passArrayF64ToWasm0(uv, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.workplane_liftPoints(this.__wbg_ptr, ptr0, len0);
+    var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v2;
+  }
+  /**
+   * @returns {Vector3}
+   */
+  get origin() {
+    const ret = wasm.workplane_origin(this.__wbg_ptr);
+    return Vector3.__wrap(ret);
+  }
+  /**
+   * @returns {Vector3}
+   */
+  get normal() {
+    const ret = wasm.workplane_normal(this.__wbg_ptr);
+    return Vector3.__wrap(ret);
+  }
+}
 async function __wbg_load(module, imports) {
   if (typeof Response === 'function' && module instanceof Response) {
     if (typeof WebAssembly.instantiateStreaming === 'function') {
@@ -5963,6 +6428,7 @@ var OGKernel = /*#__PURE__*/Object.freeze({
     OGCuboid: OGCuboid,
     OGCurve: OGCurve,
     OGCylinder: OGCylinder,
+    OGEllipticalArc: OGEllipticalArc,
     OGEntityRegistry: OGEntityRegistry,
     OGFreeformEditor: OGFreeformEditor,
     OGFreeformGeometry: OGFreeformGeometry,
@@ -5979,16 +6445,22 @@ var OGKernel = /*#__PURE__*/Object.freeze({
     OGSweep: OGSweep,
     OGWedge: OGWedge,
     Vector3: Vector3,
+    WorkPlane: WorkPlane,
+    analyzeProfile: analyzeProfile,
     batchUnion: batchUnion,
     booleanIntersection: booleanIntersection$1,
     booleanSubtraction: booleanSubtraction$1,
     booleanSubtractionMany: booleanSubtractionMany,
     booleanUnion: booleanUnion$1,
+    checkBrepValidity: checkBrepValidity,
     default: __wbg_init,
     extrudeBrepFace: extrudeBrepFace$1,
+    extrudeBrepFaceDirectional: extrudeBrepFaceDirectional,
+    healBrep: healBrep,
     initSync: initSync,
     offsetPolylineGroupRegions: offsetPolylineGroupRegions$1,
-    offsetPolylineRegions: offsetPolylineRegions$1
+    offsetPolylineRegions: offsetPolylineRegions$1,
+    offsetRingVariable: offsetRingVariable$1
 });
 
 function spotLabelElement() {
@@ -7368,7 +7840,173 @@ class Rectangle extends THREE.Line {
         }
     }
     generateGeometry() {
-        const bufferData = Array.from(this.polyLineRectangle.get_geometry_buffer());
+        const bufferData = Array.from(this.polyLineRectangle.get_geometry_buffer());
+        this.writePositionsToGeometry(this.geometry, bufferData);
+        this.geometry.computeBoundingBox();
+        this.geometry.computeBoundingSphere();
+        if (this.material instanceof THREE.LineBasicMaterial) {
+            this.material.color.set(this.options.color);
+        }
+        else {
+            if (Array.isArray(this.material)) {
+                this.material.forEach((material) => material.dispose());
+            }
+            else {
+                this.material.dispose();
+            }
+            this.material = new THREE.LineBasicMaterial({ color: this.options.color });
+        }
+        this.updateRenderStyle(bufferData);
+    }
+    getBrep() {
+        const brepData = this.polyLineRectangle.get_brep_serialized();
+        if (!brepData) {
+            throw new Error("Brep data is not available for Rectangle");
+        }
+        return JSON.parse(brepData);
+    }
+    getOffset(distance, acuteThresholdDegrees = 35.0, bevel = true) {
+        var _a;
+        const kernel = this.polyLineRectangle;
+        if (typeof kernel.get_offset_serialized !== "function") {
+            throw new Error("Offset API is not available in OGRectangle. Rebuild opengeometry wasm bindings.");
+        }
+        const serialized = kernel.get_offset_serialized(distance, acuteThresholdDegrees, bevel);
+        const parsed = JSON.parse(serialized);
+        return {
+            points: parsed.points.map((point) => new Vector3(point.x, point.y, point.z)),
+            beveledVertexIndices: (_a = parsed.beveled_vertex_indices) !== null && _a !== void 0 ? _a : [],
+            isClosed: Boolean(parsed.is_closed),
+        };
+    }
+    discardGeometry() {
+        this.geometry.dispose();
+    }
+    writePositionsToGeometry(geometry, positions) {
+        const existing = geometry.getAttribute("position");
+        if (!(existing instanceof THREE.BufferAttribute) ||
+            existing.itemSize !== 3 ||
+            existing.count !== positions.length / 3) {
+            geometry.setAttribute("position", new THREE.Float32BufferAttribute(positions, 3));
+            return;
+        }
+        const array = existing.array;
+        array.set(positions);
+        existing.needsUpdate = true;
+    }
+}
+
+/**
+ * Curve wrapper backed by the kernel OGCurve primitive.
+ */
+class Curve extends THREE.Line {
+    set color(color) {
+        this.options.color = color;
+        if (this.material instanceof THREE.LineBasicMaterial) {
+            this.material.color.set(color);
+        }
+    }
+    constructor(options) {
+        var _a, _b, _c, _d;
+        super();
+        this.options = {
+            controlPoints: [],
+            color: 0x00aa55,
+            translation: new Vector3(0, 0, 0),
+            rotation: new Vector3(0, 0, 0),
+            scale: new Vector3(1, 1, 1),
+        };
+        this.ogid = (_a = options === null || options === void 0 ? void 0 : options.ogid) !== null && _a !== void 0 ? _a : getUUID();
+        this.curve = new OGCurve(this.ogid);
+        this.options = Object.assign(Object.assign({}, this.options), options);
+        this.options.ogid = this.ogid;
+        this.setConfig({
+            controlPoints: this.options.controlPoints.map((point) => point.clone()),
+            color: this.options.color,
+        });
+        this.setPlacement({
+            translation: (_b = this.options.translation) === null || _b === void 0 ? void 0 : _b.clone(),
+            rotation: (_c = this.options.rotation) === null || _c === void 0 ? void 0 : _c.clone(),
+            scale: (_d = this.options.scale) === null || _d === void 0 ? void 0 : _d.clone(),
+        });
+    }
+    setConfig(options) {
+        const nextOptions = Object.assign(Object.assign({}, this.options), options);
+        const geometryChanged = "controlPoints" in options;
+        const colorChanged = "color" in options;
+        this.options = nextOptions;
+        if (geometryChanged) {
+            this.curve.set_config(nextOptions.controlPoints.map((point) => point.clone()));
+            this.generateGeometry();
+            return;
+        }
+        if (colorChanged && this.material instanceof THREE.LineBasicMaterial) {
+            this.material.color.set(this.options.color);
+        }
+    }
+    getConfig() {
+        return this.options;
+    }
+    getAnchor() {
+        const anchor = this.curve.get_anchor();
+        return new Vector3(anchor.x, anchor.y, anchor.z);
+    }
+    setAnchor(anchor) {
+        this.curve.set_anchor(anchor.clone());
+        this.generateGeometry();
+    }
+    resetAnchor() {
+        this.curve.reset_anchor();
+        this.generateGeometry();
+    }
+    setPlacement(placement) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
+        this.options.translation = (_b = (_a = placement.translation) === null || _a === void 0 ? void 0 : _a.clone()) !== null && _b !== void 0 ? _b : this.options.translation;
+        this.options.rotation = (_d = (_c = placement.rotation) === null || _c === void 0 ? void 0 : _c.clone()) !== null && _d !== void 0 ? _d : this.options.rotation;
+        this.options.scale = (_f = (_e = placement.scale) === null || _e === void 0 ? void 0 : _e.clone()) !== null && _f !== void 0 ? _f : this.options.scale;
+        this.curve.set_transform((_h = (_g = this.options.translation) === null || _g === void 0 ? void 0 : _g.clone()) !== null && _h !== void 0 ? _h : new Vector3(0, 0, 0), (_k = (_j = this.options.rotation) === null || _j === void 0 ? void 0 : _j.clone()) !== null && _k !== void 0 ? _k : new Vector3(0, 0, 0), (_m = (_l = this.options.scale) === null || _l === void 0 ? void 0 : _l.clone()) !== null && _m !== void 0 ? _m : new Vector3(1, 1, 1));
+        this.generateGeometry();
+    }
+    setTransform(translation, rotation, scale) {
+        this.setPlacement({
+            translation,
+            rotation,
+            scale,
+        });
+    }
+    setTranslation(translation) {
+        this.setPlacement({ translation });
+    }
+    setRotation(rotation) {
+        this.setPlacement({ rotation });
+    }
+    setScale(scale) {
+        this.setPlacement({ scale });
+    }
+    getPlacement() {
+        return clonePlacement({
+            translation: this.options.translation,
+            rotation: this.options.rotation,
+            scale: this.options.scale,
+        });
+    }
+    getEditCapabilities() {
+        return createParametricEditCapabilities("curve", "curve");
+    }
+    canConvertToFreeform() {
+        return true;
+    }
+    toFreeform(id = this.ogid) {
+        if (!this.canConvertToFreeform()) {
+            throw new Error("This entity cannot be converted to freeform.");
+        }
+        return createFreeformGeometry(this.curve.get_local_brep_serialized(), {
+            id,
+            placement: this.getPlacement(),
+        });
+    }
+    generateGeometry() {
+        const bufferData = Array.from(this.curve.get_geometry_buffer());
         this.writePositionsToGeometry(this.geometry, bufferData);
         this.geometry.computeBoundingBox();
         this.geometry.computeBoundingSphere();
@@ -7384,20 +8022,12 @@ class Rectangle extends THREE.Line {
             }
             this.material = new THREE.LineBasicMaterial({ color: this.options.color });
         }
-        this.updateRenderStyle(bufferData);
-    }
-    getBrep() {
-        const brepData = this.polyLineRectangle.get_brep_serialized();
-        if (!brepData) {
-            throw new Error("Brep data is not available for Rectangle");
-        }
-        return JSON.parse(brepData);
     }
     getOffset(distance, acuteThresholdDegrees = 35.0, bevel = true) {
         var _a;
-        const kernel = this.polyLineRectangle;
+        const kernel = this.curve;
         if (typeof kernel.get_offset_serialized !== "function") {
-            throw new Error("Offset API is not available in OGRectangle. Rebuild opengeometry wasm bindings.");
+            throw new Error("Offset API is not available in OGCurve. Rebuild opengeometry wasm bindings.");
         }
         const serialized = kernel.get_offset_serialized(distance, acuteThresholdDegrees, bevel);
         const parsed = JSON.parse(serialized);
@@ -7407,9 +8037,6 @@ class Rectangle extends THREE.Line {
             isClosed: Boolean(parsed.is_closed),
         };
     }
-    discardGeometry() {
-        this.geometry.dispose();
-    }
     writePositionsToGeometry(geometry, positions) {
         const existing = geometry.getAttribute("position");
         if (!(existing instanceof THREE.BufferAttribute) ||
@@ -7425,32 +8052,50 @@ class Rectangle extends THREE.Line {
 }
 
 /**
- * Curve wrapper backed by the kernel OGCurve primitive.
+ * EllipticalArc wrapper backed by the kernel OGEllipticalArc primitive.
  */
-class Curve extends THREE.Line {
+class EllipticalArc extends THREE.Line {
     set color(color) {
         this.options.color = color;
         if (this.material instanceof THREE.LineBasicMaterial) {
             this.material.color.set(color);
         }
+        if (this.fatLine && this.fatLine.material instanceof LineMaterial) {
+            this.fatLine.material.color.set(color);
+        }
     }
     constructor(options) {
         var _a, _b, _c, _d;
         super();
         this.options = {
-            controlPoints: [],
-            color: 0x00aa55,
+            center: new Vector3(0, 0, 0),
+            radiusX: 1.0,
+            radiusZ: 0.5,
+            startAngle: 0,
+            endAngle: Math.PI * 2,
+            segments: 32,
+            color: 0x00ff00,
+            fatLines: false,
+            width: 20,
             translation: new Vector3(0, 0, 0),
             rotation: new Vector3(0, 0, 0),
             scale: new Vector3(1, 1, 1),
         };
+        this.fatLine = null;
         this.ogid = (_a = options === null || options === void 0 ? void 0 : options.ogid) !== null && _a !== void 0 ? _a : getUUID();
-        this.curve = new OGCurve(this.ogid);
+        this.ellipticalArc = new OGEllipticalArc(this.ogid);
         this.options = Object.assign(Object.assign({}, this.options), options);
         this.options.ogid = this.ogid;
         this.setConfig({
-            controlPoints: this.options.controlPoints.map((point) => point.clone()),
+            center: this.options.center.clone(),
+            radiusX: this.options.radiusX,
+            radiusZ: this.options.radiusZ,
+            startAngle: this.options.startAngle,
+            endAngle: this.options.endAngle,
+            segments: this.options.segments,
             color: this.options.color,
+            fatLines: this.options.fatLines,
+            width: this.options.width,
         });
         this.setPlacement({
             translation: (_b = this.options.translation) === null || _b === void 0 ? void 0 : _b.clone(),
@@ -7458,49 +8103,47 @@ class Curve extends THREE.Line {
             scale: (_d = this.options.scale) === null || _d === void 0 ? void 0 : _d.clone(),
         });
     }
+    validateOptions() {
+        if (!this.options) {
+            throw new Error("Options are not defined for EllipticalArc");
+        }
+    }
     setConfig(options) {
+        this.validateOptions();
         const nextOptions = Object.assign(Object.assign({}, this.options), options);
-        const geometryChanged = "controlPoints" in options;
-        const colorChanged = "color" in options;
+        const geometryChanged = "center" in options ||
+            "radiusX" in options ||
+            "radiusZ" in options ||
+            "segments" in options ||
+            "startAngle" in options ||
+            "endAngle" in options;
+        const renderChanged = "color" in options ||
+            "fatLines" in options ||
+            "width" in options;
         this.options = nextOptions;
         if (geometryChanged) {
-            this.curve.set_config(nextOptions.controlPoints.map((point) => point.clone()));
+            this.ellipticalArc.set_config(nextOptions.center.clone(), nextOptions.radiusX, nextOptions.radiusZ, nextOptions.startAngle, nextOptions.endAngle, nextOptions.segments);
             this.generateGeometry();
             return;
         }
-        if (colorChanged && this.material instanceof THREE.LineBasicMaterial) {
-            this.material.color.set(this.options.color);
+        if (renderChanged) {
+            this.updateRenderStyle();
         }
     }
-    getConfig() {
-        return this.options;
-    }
     getAnchor() {
-        const anchor = this.curve.get_anchor();
+        const anchor = this.ellipticalArc.get_anchor();
         return new Vector3(anchor.x, anchor.y, anchor.z);
     }
-    setAnchor(anchor) {
-        this.curve.set_anchor(anchor.clone());
-        this.generateGeometry();
-    }
-    resetAnchor() {
-        this.curve.reset_anchor();
-        this.generateGeometry();
-    }
     setPlacement(placement) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m;
         this.options.translation = (_b = (_a = placement.translation) === null || _a === void 0 ? void 0 : _a.clone()) !== null && _b !== void 0 ? _b : this.options.translation;
         this.options.rotation = (_d = (_c = placement.rotation) === null || _c === void 0 ? void 0 : _c.clone()) !== null && _d !== void 0 ? _d : this.options.rotation;
         this.options.scale = (_f = (_e = placement.scale) === null || _e === void 0 ? void 0 : _e.clone()) !== null && _f !== void 0 ? _f : this.options.scale;
-        this.curve.set_transform((_h = (_g = this.options.translation) === null || _g === void 0 ? void 0 : _g.clone()) !== null && _h !== void 0 ? _h : new Vector3(0, 0, 0), (_k = (_j = this.options.rotation) === null || _j === void 0 ? void 0 : _j.clone()) !== null && _k !== void 0 ? _k : new Vector3(0, 0, 0), (_m = (_l = this.options.scale) === null || _l === void 0 ? void 0 : _l.clone()) !== null && _m !== void 0 ? _m : new Vector3(1, 1, 1));
+        this.ellipticalArc.set_transform((_h = (_g = this.options.translation) === null || _g === void 0 ? void 0 : _g.clone()) !== null && _h !== void 0 ? _h : new Vector3(0, 0, 0), (_k = (_j = this.options.rotation) === null || _j === void 0 ? void 0 : _j.clone()) !== null && _k !== void 0 ? _k : new Vector3(0, 0, 0), (_m = (_l = this.options.scale) === null || _l === void 0 ? void 0 : _l.clone()) !== null && _m !== void 0 ? _m : new Vector3(1, 1, 1));
         this.generateGeometry();
     }
     setTransform(translation, rotation, scale) {
-        this.setPlacement({
-            translation,
-            rotation,
-            scale,
-        });
+        this.setPlacement({ translation, rotation, scale });
     }
     setTranslation(translation) {
         this.setPlacement({ translation });
@@ -7511,6 +8154,9 @@ class Curve extends THREE.Line {
     setScale(scale) {
         this.setPlacement({ scale });
     }
+    getConfig() {
+        return this.options;
+    }
     getPlacement() {
         return clonePlacement({
             translation: this.options.translation,
@@ -7519,7 +8165,7 @@ class Curve extends THREE.Line {
         });
     }
     getEditCapabilities() {
-        return createParametricEditCapabilities("curve", "curve");
+        return createParametricEditCapabilities("elliptical_arc", "curve");
     }
     canConvertToFreeform() {
         return true;
@@ -7528,13 +8174,50 @@ class Curve extends THREE.Line {
         if (!this.canConvertToFreeform()) {
             throw new Error("This entity cannot be converted to freeform.");
         }
-        return createFreeformGeometry(this.curve.get_local_brep_serialized(), {
+        return createFreeformGeometry(this.ellipticalArc.get_local_brep_serialized(), {
             id,
             placement: this.getPlacement(),
         });
     }
+    getCurrentPositions() {
+        const attribute = this.geometry.getAttribute("position");
+        if (!attribute || attribute.itemSize !== 3) {
+            return [];
+        }
+        const positions = [];
+        for (let index = 0; index < attribute.count; index += 1) {
+            positions.push(attribute.getX(index), attribute.getY(index), attribute.getZ(index));
+        }
+        return positions;
+    }
+    updateRenderStyle(bufferData) {
+        var _a;
+        const positions = bufferData !== null && bufferData !== void 0 ? bufferData : this.getCurrentPositions();
+        if (this.options.fatLines) {
+            if (!this.fatLine) {
+                this.fatLine = new Line2(new LineGeometry(), new LineMaterial({
+                    color: this.options.color,
+                    linewidth: this.options.width,
+                    resolution: new THREE.Vector2(window.innerWidth, window.innerHeight),
+                }));
+                this.add(this.fatLine);
+            }
+            this.fatLine.geometry.setPositions(positions);
+            this.fatLine.material.color.set(this.options.color);
+            this.fatLine.material.linewidth = (_a = this.options.width) !== null && _a !== void 0 ? _a : 5;
+            this.fatLine.material.resolution.set(window.innerWidth, window.innerHeight);
+            this.fatLine.visible = true;
+        }
+        else if (this.fatLine) {
+            this.fatLine.visible = false;
+        }
+        if (this.material instanceof THREE.LineBasicMaterial) {
+            this.material.color.set(this.options.color);
+            this.material.visible = !this.options.fatLines;
+        }
+    }
     generateGeometry() {
-        const bufferData = Array.from(this.curve.get_geometry_buffer());
+        const bufferData = Array.from(this.ellipticalArc.get_geometry_buffer());
         this.writePositionsToGeometry(this.geometry, bufferData);
         this.geometry.computeBoundingBox();
         this.geometry.computeBoundingSphere();
@@ -7550,20 +8233,17 @@ class Curve extends THREE.Line {
             }
             this.material = new THREE.LineBasicMaterial({ color: this.options.color });
         }
+        this.updateRenderStyle(bufferData);
     }
-    getOffset(distance, acuteThresholdDegrees = 35.0, bevel = true) {
-        var _a;
-        const kernel = this.curve;
-        if (typeof kernel.get_offset_serialized !== "function") {
-            throw new Error("Offset API is not available in OGCurve. Rebuild opengeometry wasm bindings.");
+    getBrep() {
+        const brepData = this.ellipticalArc.get_brep_serialized();
+        if (!brepData) {
+            throw new Error("Brep data is not available for EllipticalArc");
         }
-        const serialized = kernel.get_offset_serialized(distance, acuteThresholdDegrees, bevel);
-        const parsed = JSON.parse(serialized);
-        return {
-            points: parsed.points.map((point) => new Vector3(point.x, point.y, point.z)),
-            beveledVertexIndices: (_a = parsed.beveled_vertex_indices) !== null && _a !== void 0 ? _a : [],
-            isClosed: Boolean(parsed.is_closed),
-        };
+        return JSON.parse(brepData);
+    }
+    discardGeometry() {
+        this.geometry.dispose();
     }
     writePositionsToGeometry(geometry, positions) {
         const existing = geometry.getAttribute("position");
@@ -10807,6 +11487,139 @@ function createOffsetExample(scene) {
     };
 }
 
+/**
+ * Offset a centreline by ±half-width into one or more filled REGIONS, via the
+ * deterministic analytic offset — miters / flat bevels at `miterLimit`, concave
+ * trims, and nonzero-winding resolution of reflex / closed loops. NO boolean union
+ * (so it is deterministic, unlike the 3D-mesh CSG path). A simple centreline returns
+ * one region; a self-crossing closed centreline (e.g. a figure-8) returns one per
+ * simple sub-loop. Returns an EMPTY array for a genuinely unbuildable input (does
+ * not throw, so it never looks like a kernel crash). Rings are CW-outer / CCW-holes.
+ *
+ * @param centrelineFlat centreline points as `[x,y,z, …]`.
+ * @param width full stroke width (offset ±width/2 on each side).
+ * @param miterLimit SVG stroke-miterlimit; corners sharper than this bevel. Default 4.
+ */
+function offsetPolylineRegions(centrelineFlat, width, closed, miterLimit = 4) {
+    const buildExport = offsetPolylineRegions$1;
+    if (typeof buildExport !== "function") {
+        throw new Error("offsetPolylineRegions is not available in the loaded wasm package. Rebuild opengeometry wasm bindings.");
+    }
+    const flat = centrelineFlat instanceof Float64Array ? centrelineFlat : new Float64Array(centrelineFlat);
+    const result = buildExport(flat, width, closed, miterLimit);
+    return JSON.parse(result.regionsSerialized);
+}
+/**
+ * Inset a CLOSED ring inward with one distance per edge (edge i =
+ * `ring[i] → ring[i+1]`; an explicit closing duplicate point is accepted and
+ * stripped, the distance count stays one per unique edge). Built for setback
+ * envelopes: the result is the CLEARANCE-EXACT buildable region — the ring's
+ * interior minus every point within `distances[i]` of edge i's SEGMENT, so
+ * distant lot lines are honoured across notches and corners where distances
+ * differ become circumscribed clearance arcs (conservative). There is no
+ * `miterLimit` parameter, deliberately: miters and bevels only approximate the
+ * clearance arc, and a bevel would claim points inside the required distance.
+ *
+ * `holes` are excluded interior rings, each grown outward by its own per-edge
+ * distances — the region keeps clear of a hole's edges exactly as it keeps
+ * clear of the lot lines, so a hole can split the region or swallow it.
+ *
+ * Returns CW-outer / CCW-hole regions (canonical start vertex), possibly
+ * SEVERAL when a deep inset (or a hole) splits a waisted ring into disjoint
+ * lobes, and an EMPTY array when the inset collapses or the outer ring is
+ * degenerate (< 3 unique points, zero area, self-intersecting). THROWS on
+ * malformed arguments: a distance count that does not match an edge count, a
+ * negative / non-finite distance, or a degenerate hole — those are caller
+ * bugs, not geometry.
+ *
+ * @param ring closed ring points as `[x,y,z, …]` (Y is carried through).
+ * @param distances inward inset distance per edge, metres, each >= 0
+ *                  (0 = the edge stays in place, e.g. lot-line construction).
+ * @param holes excluded interior rings with their own per-edge distances.
+ */
+function offsetRingVariable(ring, distances, holes = []) {
+    const buildExport = offsetRingVariable$1;
+    if (typeof buildExport !== "function") {
+        throw new Error("offsetRingVariable is not available in the loaded wasm package. It requires opengeometry >= 2.0.12 — rebuild or upgrade the opengeometry wasm bindings.");
+    }
+    const flatRing = ring instanceof Float64Array ? ring : new Float64Array(ring);
+    const flatDistances = distances instanceof Float64Array ? distances : new Float64Array(distances);
+    const holesJson = JSON.stringify(holes.map((hole) => ({ ring: Array.from(hole.ring), distances: Array.from(hole.distances) })));
+    const result = buildExport(flatRing, flatDistances, holesJson);
+    return JSON.parse(result.regionsSerialized);
+}
+/**
+ * Merge a GROUP of separate polylines (a crossing T / X / L overlap) into one clean
+ * region by nonzero-winding union of their mitered bands — the overlapping strokes
+ * merge into a single region with mitered/bevelled corners, no internal edges.
+ * Returns CW-outer / CCW-hole regions (one or more); empty if nothing is buildable.
+ * No CSG. Used to render/extrude an overlapping crossing as one joined mass.
+ */
+function offsetPolylineGroupRegions(polylines) {
+    const buildExport = offsetPolylineGroupRegions$1;
+    if (typeof buildExport !== "function") {
+        throw new Error("offsetPolylineGroupRegions is not available in the loaded wasm package. Rebuild opengeometry wasm bindings.");
+    }
+    const result = buildExport(JSON.stringify(polylines));
+    return JSON.parse(result.regionsSerialized);
+}
+
+/** Close a kernel ring for Polyline rendering (repeat the first point). */
+function closedRingPoints(ring) {
+    const points = ring.map((point) => new Vector3(point.x, point.y, point.z));
+    if (points.length > 0) {
+        const first = ring[0];
+        points.push(new Vector3(first.x, first.y, first.z));
+    }
+    return points;
+}
+/**
+ * Variable (per-edge) ring inset: a rectangular "parcel" inset by front 6 /
+ * side 1.5 / rear 3 setbacks, and a waisted (dumbbell) parcel whose uniform
+ * 3 m inset SPLITS into two disjoint buildable envelopes — the case a uniform
+ * offset cannot express.
+ */
+function createOffsetRingVariableExample(scene) {
+    const scale = 0.2; // metres → scene units, keeps both parcels in frame
+    const parcel = [0, 0, 0, 20, 0, 0, 20, 0, 30, 0, 0, 30].map((v) => v * scale);
+    const parcelSetbacks = [6, 1.5, 3, 1.5].map((v) => v * scale);
+    const dumbbell = [
+        0, 0, 0, 20, 0, 0, 20, 0, 14, 12, 0, 14, 12, 0, 26, 20, 0, 26, 20, 0, 40, 0, 0, 40, 0, 0, 26,
+        8, 0, 26, 8, 0, 14, 0, 0, 14,
+    ].map((v, index) => (index % 3 === 0 ? v * scale + 6 : v * scale)); // shifted +x
+    const dumbbellSetbacks = new Array(12).fill(3 * scale);
+    const parcelOutline = new Polyline({
+        points: closedRingPoints(Array.from({ length: parcel.length / 3 }, (_, i) => ({
+            x: parcel[i * 3],
+            y: parcel[i * 3 + 1],
+            z: parcel[i * 3 + 2],
+        }))),
+        color: 0x1f2937,
+    });
+    scene.add(parcelOutline);
+    const dumbbellOutline = new Polyline({
+        points: closedRingPoints(Array.from({ length: dumbbell.length / 3 }, (_, i) => ({
+            x: dumbbell[i * 3],
+            y: dumbbell[i * 3 + 1],
+            z: dumbbell[i * 3 + 2],
+        }))),
+        color: 0x1f2937,
+    });
+    scene.add(dumbbellOutline);
+    const envelopes = [];
+    for (const region of offsetRingVariable(parcel, parcelSetbacks)) {
+        const envelope = new Polyline({ points: closedRingPoints(region.outer), color: 0x16a34a });
+        envelopes.push(envelope);
+        scene.add(envelope);
+    }
+    for (const region of offsetRingVariable(dumbbell, dumbbellSetbacks)) {
+        const envelope = new Polyline({ points: closedRingPoints(region.outer), color: 0xdc2626 });
+        envelopes.push(envelope);
+        scene.add(envelope);
+    }
+    return { parcelOutline, dumbbellOutline, envelopes };
+}
+
 const EPSILON = 1.0e-9;
 function areClose(a, b) {
     const dx = a.x - b.x;
@@ -11255,44 +12068,6 @@ function createEditorModesExample(scene) {
     };
 }
 
-/**
- * Offset a centreline by ±half-width into one or more filled REGIONS, via the
- * deterministic analytic offset — miters / flat bevels at `miterLimit`, concave
- * trims, and nonzero-winding resolution of reflex / closed loops. NO boolean union
- * (so it is deterministic, unlike the 3D-mesh CSG path). A simple centreline returns
- * one region; a self-crossing closed centreline (e.g. a figure-8) returns one per
- * simple sub-loop. Returns an EMPTY array for a genuinely unbuildable input (does
- * not throw, so it never looks like a kernel crash). Rings are CW-outer / CCW-holes.
- *
- * @param centrelineFlat centreline points as `[x,y,z, …]`.
- * @param width full stroke width (offset ±width/2 on each side).
- * @param miterLimit SVG stroke-miterlimit; corners sharper than this bevel. Default 4.
- */
-function offsetPolylineRegions(centrelineFlat, width, closed, miterLimit = 4) {
-    const buildExport = offsetPolylineRegions$1;
-    if (typeof buildExport !== "function") {
-        throw new Error("offsetPolylineRegions is not available in the loaded wasm package. Rebuild opengeometry wasm bindings.");
-    }
-    const flat = centrelineFlat instanceof Float64Array ? centrelineFlat : new Float64Array(centrelineFlat);
-    const result = buildExport(flat, width, closed, miterLimit);
-    return JSON.parse(result.regionsSerialized);
-}
-/**
- * Merge a GROUP of separate polylines (a crossing T / X / L overlap) into one clean
- * region by nonzero-winding union of their mitered bands — the overlapping strokes
- * merge into a single region with mitered/bevelled corners, no internal edges.
- * Returns CW-outer / CCW-hole regions (one or more); empty if nothing is buildable.
- * No CSG. Used to render/extrude an overlapping crossing as one joined mass.
- */
-function offsetPolylineGroupRegions(polylines) {
-    const buildExport = offsetPolylineGroupRegions$1;
-    if (typeof buildExport !== "function") {
-        throw new Error("offsetPolylineGroupRegions is not available in the loaded wasm package. Rebuild opengeometry wasm bindings.");
-    }
-    const result = buildExport(JSON.stringify(polylines));
-    return JSON.parse(result.regionsSerialized);
-}
-
 /**
  * Shared runtime entrypoint used to initialize the OpenGeometry wasm module.
  */
@@ -11357,5 +12132,5 @@ class OpenGeometry {
 OpenGeometry.version = OPEN_GEOMETRY_THREE_VERSION;
 OpenGeometry.instance = null;
 
-export { Arc, BooleanError, BooleanResult, CoincidentFacesError, Cuboid, Curve, CutterExceedsHostError, Cylinder, FreeformEditor, FreeformGeometry, Line, NonManifoldOutputError, OGSceneManager, OpenGeometry, Opening, OverlappingCuttersError, Polygon, Polyline, Rectangle, Solid, Sphere, SpotLabel, Sweep, Vector3, Wedge, booleanIntersection, booleanSubtraction, booleanUnion, clonePlacement, createBooleanExample, createEditorModesExample, createFreeformEditor, createFreeformGeometry, createOffsetExample, createParametricEditCapabilities, createPrimitivesExample, createShapesExample, createSweepExample, createWallFromOffsetsExample, describeWallSubtractError, executeBooleanSubtractionMany, extrudeBrepFace, offsetPolylineGroupRegions, offsetPolylineRegions, parseBooleanError, toObjectTransformation$1 as toObjectTransformation };
+export { Arc, BooleanError, BooleanResult, CoincidentFacesError, Cuboid, Curve, CutterExceedsHostError, Cylinder, EllipticalArc, FreeformEditor, FreeformGeometry, Line, NonManifoldOutputError, OGSceneManager, OpenGeometry, Opening, OverlappingCuttersError, Polygon, Polyline, Rectangle, Solid, Sphere, SpotLabel, Sweep, Vector3, Wedge, booleanIntersection, booleanSubtraction, booleanUnion, clonePlacement, createBooleanExample, createEditorModesExample, createFreeformEditor, createFreeformGeometry, createOffsetExample, createOffsetRingVariableExample, createParametricEditCapabilities, createPrimitivesExample, createShapesExample, createSweepExample, createWallFromOffsetsExample, describeWallSubtractError, executeBooleanSubtractionMany, extrudeBrepFace, offsetPolylineGroupRegions, offsetPolylineRegions, offsetRingVariable, parseBooleanError, toObjectTransformation$1 as toObjectTransformation };
 //# sourceMappingURL=index.js.map