opengeometry 2.0.10 → 2.0.13

package/opengeometry/pkg/opengeometry.js

@@ -204,9 +204,242 @@ function passArrayJsValueToWasm0(array, malloc) {
     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();
+    const result = [];
+    for (let i = ptr; i < ptr + 4 * len; i += 4) {
+        result.push(wasm.__wbindgen_export_2.get(mem.getUint32(i, true)));
+    }
+    wasm.__externref_drop_slice(ptr, len);
+    return result;
+}
+
 function isLikeNone(x) {
     return x === undefined || x === null;
 }
+/**
+ * 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}
+ */
+export 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}
+ */
+export 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}
+ */
+export 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
+ * CW-outer / CCW-hole regions, canonicalised; empty (does NOT throw) when degenerate.
+ * @param {Float64Array} centreline_flat
+ * @param {number} width
+ * @param {boolean} closed
+ * @param {number} miter_limit
+ * @returns {OGOffsetRegionsResult}
+ */
+export function offsetPolylineRegions(centreline_flat, width, closed, miter_limit) {
+    const ptr0 = passArrayF64ToWasm0(centreline_flat, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.offsetPolylineRegions(ptr0, len0, width, closed, miter_limit);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    return OGOffsetRegionsResult.__wrap(ret[0]);
+}
+
+/**
+ * Wasm entry point: merge a GROUP of separate polylines (a crossing T / X / L
+ * overlap) into one clean stroked region by nonzero-winding union of their mitered
+ * bands. `polylines_json` is `[{centreline:[x,y,z,…], width, closed}, …]`. Returns
+ * CW-outer / CCW-hole regions (one or more); empty when nothing is buildable.
+ * @param {string} polylines_json
+ * @returns {OGOffsetRegionsResult}
+ */
+export function offsetPolylineGroupRegions(polylines_json) {
+    const ptr0 = passStringToWasm0(polylines_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.offsetPolylineGroupRegions(ptr0, len0);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
+    }
+    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}
+ */
+export function offsetRingVariable(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}
+ */
+export function extrudeBrepFace(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}
+ */
+export 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
@@ -292,40 +525,22 @@ export function booleanSubtractionMany(lhs_brep_serialized, cutters_brep_seriali
 }
 
 /**
- * @param {string} local_brep_serialized
- * @param {number} height
- * @returns {string}
+ * Wasm entry point for array-backed batched union. Accepts a JSON array of
+ * serialized BReps and folds them with `batch_union` in one boundary crossing.
+ * @param {string} operands_brep_serialized
+ * @param {string | null} [options_json]
+ * @returns {OGBooleanResult}
  */
-export function extrudeBrepFace(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 getArrayJsValueFromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    const mem = getDataViewMemory0();
-    const result = [];
-    for (let i = ptr; i < ptr + 4 * len; i += 4) {
-        result.push(wasm.__wbindgen_export_2.get(mem.getUint32(i, true)));
+export function batchUnion(operands_brep_serialized, options_json) {
+    const ptr0 = passStringToWasm0(operands_brep_serialized, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    var ptr1 = isLikeNone(options_json) ? 0 : passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    const ret = wasm.batchUnion(ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+        throw takeFromExternrefTable0(ret[1]);
     }
-    wasm.__externref_drop_slice(ptr, len);
-    return result;
+    return OGBooleanResult.__wrap(ret[0]);
 }
 
 const Matrix3Finalization = (typeof FinalizationRegistry === 'undefined')
@@ -1719,6 +1934,224 @@ export class OGCylinder {
     }
 }
 
+const OGEllipticalArcFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_ogellipticalarc_free(ptr >>> 0, 1));
+
+export 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_geometry() {
+        const ret = wasm.ogellipticalarc_generate_geometry(this.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
+    dispose_points() {
+        wasm.ogellipticalarc_dispose_points(this.__wbg_ptr);
+    }
+    destroy() {
+        wasm.ogellipticalarc_destroy(this.__wbg_ptr);
+    }
+    /**
+     * @returns {string}
+     */
+    get_brep_serialized() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.ogellipticalarc_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.ogellipticalarc_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.ogellipticalarc_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.ogellipticalarc_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.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;
+    }
+    /**
+     * @returns {Float64Array}
+     */
+    get_local_geometry_buffer() {
+        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;
+    }
+    /**
+     * @returns {Vector3}
+     */
+    get_anchor() {
+        const ret = wasm.ogellipticalarc_get_anchor(this.__wbg_ptr);
+        return Vector3.__wrap(ret);
+    }
+}
+
 const OGEntityRegistryFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_ogentityregistry_free(ptr >>> 0, 1));
@@ -2801,7 +3234,7 @@ export class OGLine {
      * @returns {Vector3}
      */
     get_anchor() {
-        const ret = wasm.ogcurve_get_anchor(this.__wbg_ptr);
+        const ret = wasm.ogline_get_anchor(this.__wbg_ptr);
         return Vector3.__wrap(ret);
     }
     /**
@@ -2856,6 +3289,53 @@ export class OGLine {
     }
 }
 
+const OGOffsetRegionsResultFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_ogoffsetregionsresult_free(ptr >>> 0, 1));
+/**
+ * Result payload for a polyline offset: a list of regions (each an outer ring +
+ * inner-void holes). Normally one region; a self-crossing closed centreline (e.g.
+ * a figure-8) yields one per simple sub-loop. The deterministic analytic offset —
+ * no extrude/solid. Used to build the plan polygons + extruded base solids in JS.
+ */
+export class OGOffsetRegionsResult {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(OGOffsetRegionsResult.prototype);
+        obj.__wbg_ptr = ptr;
+        OGOffsetRegionsResultFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        OGOffsetRegionsResultFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_ogoffsetregionsresult_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    get regionsSerialized() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.ogoffsetregionsresult_regionsSerialized(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);
+        }
+    }
+}
+
 const OGPolygonFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_ogpolygon_free(ptr >>> 0, 1));
@@ -3434,7 +3914,7 @@ export class OGPolyline {
      * @returns {Vector3}
      */
     get_anchor() {
-        const ret = wasm.ogcurve_get_anchor(this.__wbg_ptr);
+        const ret = wasm.ogline_get_anchor(this.__wbg_ptr);
         return Vector3.__wrap(ret);
     }
     /**
@@ -4763,7 +5243,7 @@ export 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);
     }
 }
@@ -5156,7 +5636,7 @@ export 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);
     }
     /**
@@ -5739,6 +6219,104 @@ export class Vector3 {
     }
 }
 
+const WorkPlaneFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_workplane_free(ptr >>> 0, 1));
+
+export 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') {