opengeometry 2.0.11 → 2.0.14

package/opengeometry/pkg/opengeometry.js

@@ -29,69 +29,13 @@ function handleError(f, args) {
     }
 }
 
-function debugString(val) {
-    // primitive types
-    const type = typeof val;
-    if (type == 'number' || type == 'boolean' || val == null) {
-        return  `${val}`;
-    }
-    if (type == 'string') {
-        return `"${val}"`;
-    }
-    if (type == 'symbol') {
-        const description = val.description;
-        if (description == null) {
-            return 'Symbol';
-        } else {
-            return `Symbol(${description})`;
-        }
-    }
-    if (type == 'function') {
-        const name = val.name;
-        if (typeof name == 'string' && name.length > 0) {
-            return `Function(${name})`;
-        } else {
-            return 'Function';
-        }
-    }
-    // objects
-    if (Array.isArray(val)) {
-        const length = val.length;
-        let debug = '[';
-        if (length > 0) {
-            debug += debugString(val[0]);
-        }
-        for(let i = 1; i < length; i++) {
-            debug += ', ' + debugString(val[i]);
-        }
-        debug += ']';
-        return debug;
-    }
-    // Test for built-in
-    const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
-    let className;
-    if (builtInMatches && builtInMatches.length > 1) {
-        className = builtInMatches[1];
-    } else {
-        // Failed to match the standard '[object ClassName]'
-        return toString.call(val);
-    }
-    if (className == 'Object') {
-        // we're a user defined class or Object
-        // JSON.stringify avoids problems with cycles, and is generally much
-        // easier than looping through ownProperties of `val`.
-        try {
-            return 'Object(' + JSON.stringify(val) + ')';
-        } catch (_) {
-            return 'Object';
-        }
-    }
-    // errors
-    if (val instanceof Error) {
-        return `${val.name}: ${val.message}\n${val.stack}`;
-    }
-    // TODO we could test for more things here, like `Set`s and `Map`s.
-    return className;
+const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } );
+
+if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); };
+
+function getStringFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
 }
 
 let WASM_VECTOR_LEN = 0;
@@ -150,24 +94,6 @@ function passStringToWasm0(arg, malloc, realloc) {
     return ptr;
 }
 
-let cachedDataViewMemory0 = null;
-
-function getDataViewMemory0() {
-    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
-        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
-    }
-    return cachedDataViewMemory0;
-}
-
-const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } );
-
-if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); };
-
-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);
@@ -199,12 +125,6 @@ export function extrudeBrepFace(local_brep_serialized, height) {
     }
 }
 
-function _assertClass(instance, klass) {
-    if (!(instance instanceof klass)) {
-        throw new Error(`expected instance of ${klass.name}`);
-    }
-}
-
 let cachedFloat64ArrayMemory0 = null;
 
 function getFloat64ArrayMemory0() {
@@ -214,40 +134,107 @@ function getFloat64ArrayMemory0() {
     return cachedFloat64ArrayMemory0;
 }
 
-function getArrayF64FromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
+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 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);
+    }
 }
 
-function passArrayJsValueToWasm0(array, malloc) {
-    const ptr = malloc(array.length * 4, 4) >>> 0;
-    for (let i = 0; i < array.length; i++) {
-        const add = addToExternrefTable0(array[i]);
-        getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
+/**
+ * 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_VECTOR_LEN = array.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)));
+function _assertClass(instance, klass) {
+    if (!(instance instanceof klass)) {
+        throw new Error(`expected instance of ${klass.name}`);
     }
-    wasm.__externref_drop_slice(ptr, len);
-    return result;
 }
 
 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;
+function getArrayF64FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
+}
+
+let cachedDataViewMemory0 = null;
+
+function getDataViewMemory0() {
+    if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || (cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer)) {
+        cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+    }
+    return cachedDataViewMemory0;
+}
+
+function passArrayJsValueToWasm0(array, malloc) {
+    const ptr = malloc(array.length * 4, 4) >>> 0;
+    for (let i = 0; i < array.length; i++) {
+        const add = addToExternrefTable0(array[i]);
+        getDataViewMemory0().setUint32(ptr + 4 * i, add, true);
+    }
+    WASM_VECTOR_LEN = array.length;
     return ptr;
 }
 /**
@@ -289,106 +276,171 @@ export function offsetPolylineGroupRegions(polylines_json) {
 }
 
 /**
- * Wasm entry point for union.
- * @param {string} lhs_brep_serialized
- * @param {string} rhs_brep_serialized
- * @param {string | null} [options_json]
- * @returns {OGBooleanResult}
+ * 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 booleanUnion(lhs_brep_serialized, rhs_brep_serialized, options_json) {
-    const ptr0 = passStringToWasm0(lhs_brep_serialized, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+export function offsetRingVariable(ring_flat, distances, holes_json) {
+    const ptr0 = passArrayF64ToWasm0(ring_flat, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passStringToWasm0(rhs_brep_serialized, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const ptr1 = passArrayF64ToWasm0(distances, wasm.__wbindgen_malloc);
     const len1 = WASM_VECTOR_LEN;
-    var ptr2 = isLikeNone(options_json) ? 0 : passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    var len2 = WASM_VECTOR_LEN;
-    const ret = wasm.booleanUnion(ptr0, len0, ptr1, len1, ptr2, len2);
+    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 OGBooleanResult.__wrap(ret[0]);
+    return OGOffsetRegionsResult.__wrap(ret[0]);
 }
 
 /**
- * Wasm entry point for intersection.
- * @param {string} lhs_brep_serialized
- * @param {string} rhs_brep_serialized
- * @param {string | null} [options_json]
- * @returns {OGBooleanResult}
+ * @param {string} serialized
+ * @returns {string}
  */
-export function booleanIntersection(lhs_brep_serialized, rhs_brep_serialized, options_json) {
-    const ptr0 = passStringToWasm0(lhs_brep_serialized, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passStringToWasm0(rhs_brep_serialized, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len1 = WASM_VECTOR_LEN;
-    var ptr2 = isLikeNone(options_json) ? 0 : passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    var len2 = WASM_VECTOR_LEN;
-    const ret = wasm.booleanIntersection(ptr0, len0, ptr1, len1, ptr2, len2);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
+export function validateAnalyticBrep(serialized) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+        const ptr0 = passStringToWasm0(serialized, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.validateAnalyticBrep(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);
     }
-    return OGBooleanResult.__wrap(ret[0]);
 }
 
 /**
- * Wasm entry point for subtraction.
- * @param {string} lhs_brep_serialized
- * @param {string} rhs_brep_serialized
+ * @param {string} serialized
+ * @param {number} deflection
  * @param {string | null} [options_json]
- * @returns {OGBooleanResult}
+ * @returns {OGAnalyticTessellation}
  */
-export function booleanSubtraction(lhs_brep_serialized, rhs_brep_serialized, options_json) {
-    const ptr0 = passStringToWasm0(lhs_brep_serialized, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+export function tessellate_brep(serialized, deflection, options_json) {
+    const ptr0 = passStringToWasm0(serialized, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passStringToWasm0(rhs_brep_serialized, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len1 = WASM_VECTOR_LEN;
-    var ptr2 = isLikeNone(options_json) ? 0 : passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    var len2 = WASM_VECTOR_LEN;
-    const ret = wasm.booleanSubtraction(ptr0, len0, ptr1, len1, ptr2, len2);
+    var ptr1 = isLikeNone(options_json) ? 0 : passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    var len1 = WASM_VECTOR_LEN;
+    const ret = wasm.tessellate_brep(ptr0, len0, deflection, ptr1, len1);
     if (ret[2]) {
         throw takeFromExternrefTable0(ret[1]);
     }
-    return OGBooleanResult.__wrap(ret[0]);
+    return OGAnalyticTessellation.__wrap(ret[0]);
+}
+
+let cachedFloat32ArrayMemory0 = null;
+
+function getFloat32ArrayMemory0() {
+    if (cachedFloat32ArrayMemory0 === null || cachedFloat32ArrayMemory0.byteLength === 0) {
+        cachedFloat32ArrayMemory0 = new Float32Array(wasm.memory.buffer);
+    }
+    return cachedFloat32ArrayMemory0;
+}
+
+function getArrayF32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getFloat32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
+let cachedUint32ArrayMemory0 = null;
+
+function getUint32ArrayMemory0() {
+    if (cachedUint32ArrayMemory0 === null || cachedUint32ArrayMemory0.byteLength === 0) {
+        cachedUint32ArrayMemory0 = new Uint32Array(wasm.memory.buffer);
+    }
+    return cachedUint32ArrayMemory0;
 }
 
+function getArrayU32FromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    return getUint32ArrayMemory0().subarray(ptr / 4, ptr / 4 + len);
+}
+
+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;
+}
 /**
- * Wasm entry point for array-backed repeated subtraction.
- * @param {string} lhs_brep_serialized
- * @param {string} cutters_brep_serialized
- * @param {string | null} [options_json]
- * @returns {OGBooleanResult}
+ * Wasm entry point: check a serialized B-rep's geometric validity, returning
+ * the [`ValidityReport`] as JSON.
+ * @param {string} brep_json
+ * @returns {string}
  */
-export function booleanSubtractionMany(lhs_brep_serialized, cutters_brep_serialized, options_json) {
-    const ptr0 = passStringToWasm0(lhs_brep_serialized, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passStringToWasm0(cutters_brep_serialized, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    const len1 = WASM_VECTOR_LEN;
-    var ptr2 = isLikeNone(options_json) ? 0 : passStringToWasm0(options_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-    var len2 = WASM_VECTOR_LEN;
-    const ret = wasm.booleanSubtractionMany(ptr0, len0, ptr1, len1, ptr2, len2);
-    if (ret[2]) {
-        throw takeFromExternrefTable0(ret[1]);
+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);
     }
-    return OGBooleanResult.__wrap(ret[0]);
 }
 
 /**
- * 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}
+ * 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 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]);
+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);
     }
-    return OGBooleanResult.__wrap(ret[0]);
 }
 
 const Matrix3Finalization = (typeof FinalizationRegistry === 'undefined')
@@ -713,39 +765,449 @@ export class Matrix4 {
     }
 }
 
-const OGArcFinalization = (typeof FinalizationRegistry === 'undefined')
+const OGAnalyticBrepFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_ogarc_free(ptr >>> 0, 1));
+    : new FinalizationRegistry(ptr => wasm.__wbg_oganalyticbrep_free(ptr >>> 0, 1));
 
-export class OGArc {
+export class OGAnalyticBrep {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(OGAnalyticBrep.prototype);
+        obj.__wbg_ptr = ptr;
+        OGAnalyticBrepFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
 
     __destroy_into_raw() {
         const ptr = this.__wbg_ptr;
         this.__wbg_ptr = 0;
-        OGArcFinalization.unregister(this);
+        OGAnalyticBrepFinalization.unregister(this);
         return ptr;
     }
 
     free() {
         const ptr = this.__destroy_into_raw();
-        wasm.__wbg_ogarc_free(ptr, 0);
+        wasm.__wbg_oganalyticbrep_free(ptr, 0);
     }
     /**
-     * @param {string} id
+     * @param {string} serialized
      */
-    set id(id) {
-        const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    constructor(serialized) {
+        const ptr0 = passStringToWasm0(serialized, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len0 = WASM_VECTOR_LEN;
-        wasm.ogarc_set_id(this.__wbg_ptr, ptr0, len0);
+        const ret = wasm.oganalyticbrep_new(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0] >>> 0;
+        OGAnalyticBrepFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {string} config_json
+     * @returns {OGAnalyticBrep}
+     */
+    static from_primitive(config_json) {
+        const ptr0 = passStringToWasm0(config_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.oganalyticbrep_from_primitive(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return OGAnalyticBrep.__wrap(ret[0]);
     }
     /**
      * @returns {string}
      */
-    get id() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.ogarc_id(this.__wbg_ptr);
+    get_brep_serialized() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.oganalyticbrep_get_brep_serialized(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * @param {string} length_unit
+     * @returns {string}
+     */
+    export_step(length_unit) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passStringToWasm0(length_unit, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.oganalyticbrep_export_step(this.__wbg_ptr, 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);
+        }
+    }
+    /**
+     * @param {string} frame_json
+     * @param {number} scale
+     * @returns {OGAnalyticBrep}
+     */
+    placed(frame_json, scale) {
+        const ptr0 = passStringToWasm0(frame_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.oganalyticbrep_placed(this.__wbg_ptr, ptr0, len0, scale);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return OGAnalyticBrep.__wrap(ret[0]);
+    }
+    /**
+     * @returns {string}
+     */
+    prepare_ifc_exchange() {
+        let deferred2_0;
+        let deferred2_1;
+        try {
+            const ret = wasm.oganalyticbrep_prepare_ifc_exchange(this.__wbg_ptr);
+            var ptr1 = ret[0];
+            var len1 = ret[1];
+            if (ret[3]) {
+                ptr1 = 0; len1 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred2_0 = ptr1;
+            deferred2_1 = len1;
+            return getStringFromWasm0(ptr1, len1);
+        } finally {
+            wasm.__wbindgen_free(deferred2_0, deferred2_1, 1);
+        }
+    }
+    /**
+     * @param {number} face_id
+     * @param {Float64Array} point
+     * @returns {Float64Array}
+     */
+    face_normal_at(face_id, point) {
+        const ptr0 = passArrayF64ToWasm0(point, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.oganalyticbrep_face_normal_at(this.__wbg_ptr, face_id, ptr0, len0);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v2 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v2;
+    }
+    /**
+     * @param {Float64Array} point
+     * @returns {string}
+     */
+    classify_point(point) {
+        let deferred3_0;
+        let deferred3_1;
+        try {
+            const ptr0 = passArrayF64ToWasm0(point, wasm.__wbindgen_malloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ret = wasm.oganalyticbrep_classify_point(this.__wbg_ptr, 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);
+        }
+    }
+    /**
+     * @param {string} camera_json
+     * @param {string} hlr_json
+     * @param {number} deflection
+     * @returns {string}
+     */
+    project_to_2d_lines(camera_json, hlr_json, deflection) {
+        let deferred4_0;
+        let deferred4_1;
+        try {
+            const ptr0 = passStringToWasm0(camera_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(hlr_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+            const len1 = WASM_VECTOR_LEN;
+            const ret = wasm.oganalyticbrep_project_to_2d_lines(this.__wbg_ptr, ptr0, len0, ptr1, len1, deflection);
+            var ptr3 = ret[0];
+            var len3 = ret[1];
+            if (ret[3]) {
+                ptr3 = 0; len3 = 0;
+                throw takeFromExternrefTable0(ret[2]);
+            }
+            deferred4_0 = ptr3;
+            deferred4_1 = len3;
+            return getStringFromWasm0(ptr3, len3);
+        } finally {
+            wasm.__wbindgen_free(deferred4_0, deferred4_1, 1);
+        }
+    }
+    /**
+     * @param {OGAnalyticBrep} other
+     * @param {string} operation
+     * @param {string} id
+     * @returns {OGAnalyticBrep}
+     */
+    boolean_brep(other, operation, id) {
+        _assertClass(other, OGAnalyticBrep);
+        const ptr0 = passStringToWasm0(operation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ptr1 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len1 = WASM_VECTOR_LEN;
+        const ret = wasm.oganalyticbrep_boolean_brep(this.__wbg_ptr, other.__wbg_ptr, ptr0, len0, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return OGAnalyticBrep.__wrap(ret[0]);
+    }
+    /**
+     * @param {number} thickness
+     * @param {string} id
+     * @returns {OGAnalyticBrep}
+     */
+    shell(thickness, id) {
+        const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.oganalyticbrep_shell(this.__wbg_ptr, thickness, ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return OGAnalyticBrep.__wrap(ret[0]);
+    }
+    /**
+     * @returns {string | undefined}
+     */
+    get_boolean_report_serialized() {
+        const ret = wasm.oganalyticbrep_get_boolean_report_serialized(this.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        let v1;
+        if (ret[0] !== 0) {
+            v1 = getStringFromWasm0(ret[0], ret[1]).slice();
+            wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
+        }
+        return v1;
+    }
+    /**
+     * @param {number} deflection
+     * @returns {OGAnalyticTessellation}
+     */
+    tessellate(deflection) {
+        const ret = wasm.oganalyticbrep_tessellate(this.__wbg_ptr, deflection);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return OGAnalyticTessellation.__wrap(ret[0]);
+    }
+    /**
+     * @returns {number}
+     */
+    get_face_count() {
+        const ret = wasm.oganalyticbrep_get_face_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get_edge_count() {
+        const ret = wasm.oganalyticbrep_get_edge_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {string}
+     */
+    get_id() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.oganalyticbrep_get_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);
+        }
+    }
+    /**
+     * @returns {Float64Array}
+     */
+    get_bounds() {
+        const ret = wasm.oganalyticbrep_get_bounds(this.__wbg_ptr);
+        if (ret[3]) {
+            throw takeFromExternrefTable0(ret[2]);
+        }
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * @returns {number}
+     */
+    get_vertex_count() {
+        const ret = wasm.oganalyticbrep_get_vertex_count(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {bigint}
+     */
+    get_revision() {
+        const ret = wasm.oganalyticbrep_get_revision(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+}
+
+const OGAnalyticTessellationFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_oganalytictessellation_free(ptr >>> 0, 1));
+
+export class OGAnalyticTessellation {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(OGAnalyticTessellation.prototype);
+        obj.__wbg_ptr = ptr;
+        OGAnalyticTessellationFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        OGAnalyticTessellationFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_oganalytictessellation_free(ptr, 0);
+    }
+    /**
+     * @returns {Float64Array}
+     */
+    positions() {
+        const ret = wasm.oganalytictessellation_positions(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * @returns {Float32Array}
+     */
+    normals() {
+        const ret = wasm.oganalytictessellation_normals(this.__wbg_ptr);
+        var v1 = getArrayF32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @returns {Uint32Array}
+     */
+    indices() {
+        const ret = wasm.oganalytictessellation_indices(this.__wbg_ptr);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @returns {Uint32Array}
+     */
+    triangle_face_ids() {
+        const ret = wasm.oganalytictessellation_triangle_face_ids(this.__wbg_ptr);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @returns {Float64Array}
+     */
+    outline_positions() {
+        const ret = wasm.oganalytictessellation_outline_positions(this.__wbg_ptr);
+        var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
+    }
+    /**
+     * @returns {Uint32Array}
+     */
+    outline_edge_ids() {
+        const ret = wasm.oganalytictessellation_outline_edge_ids(this.__wbg_ptr);
+        var v1 = getArrayU32FromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
+    /**
+     * @returns {bigint}
+     */
+    revision() {
+        const ret = wasm.oganalytictessellation_revision(this.__wbg_ptr);
+        return BigInt.asUintN(64, ret);
+    }
+    /**
+     * @returns {number}
+     */
+    achieved_deflection() {
+        const ret = wasm.oganalytictessellation_achieved_deflection(this.__wbg_ptr);
+        return ret;
+    }
+}
+
+const OGArcFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_ogarc_free(ptr >>> 0, 1));
+
+export class OGArc {
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        OGArcFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_ogarc_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.ogarc_set_id(this.__wbg_ptr, ptr0, len0);
+    }
+    /**
+     * @returns {string}
+     */
+    get id() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.ogarc_id(this.__wbg_ptr);
             deferred1_0 = ret[0];
             deferred1_1 = ret[1];
             return getStringFromWasm0(ret[0], ret[1]);
@@ -918,104 +1380,15 @@ export class OGArc {
     get_local_geometry_buffer() {
         const ret = wasm.ogarc_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.ogarc_get_anchor(this.__wbg_ptr);
-        return Vector3.__wrap(ret);
-    }
-}
-
-const OGBooleanResultFinalization = (typeof FinalizationRegistry === 'undefined')
-    ? { register: () => {}, unregister: () => {} }
-    : new FinalizationRegistry(ptr => wasm.__wbg_ogbooleanresult_free(ptr >>> 0, 1));
-/**
- * Result payload returned across the wasm boundary.
- */
-export class OGBooleanResult {
-
-    static __wrap(ptr) {
-        ptr = ptr >>> 0;
-        const obj = Object.create(OGBooleanResult.prototype);
-        obj.__wbg_ptr = ptr;
-        OGBooleanResultFinalization.register(obj, obj.__wbg_ptr, obj);
-        return obj;
-    }
-
-    __destroy_into_raw() {
-        const ptr = this.__wbg_ptr;
-        this.__wbg_ptr = 0;
-        OGBooleanResultFinalization.unregister(this);
-        return ptr;
-    }
-
-    free() {
-        const ptr = this.__destroy_into_raw();
-        wasm.__wbg_ogbooleanresult_free(ptr, 0);
-    }
-    /**
-     * @returns {string}
-     */
-    get brepSerialized() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.ogbooleanresult_brepSerialized(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 geometrySerialized() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.ogbooleanresult_geometrySerialized(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 outlineGeometrySerialized() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.ogbooleanresult_outlineGeometrySerialized(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);
-        }
+        wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+        return v1;
     }
     /**
-     * @returns {string}
+     * @returns {Vector3}
      */
-    get reportJson() {
-        let deferred1_0;
-        let deferred1_1;
-        try {
-            const ret = wasm.ogbooleanresult_reportJson(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);
-        }
+    get_anchor() {
+        const ret = wasm.ogarc_get_anchor(this.__wbg_ptr);
+        return Vector3.__wrap(ret);
     }
 }
 
@@ -1782,6 +2155,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));
@@ -3544,7 +4135,7 @@ export 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);
     }
     /**
@@ -5266,7 +5857,7 @@ export class OGSweep {
      * @returns {Vector3}
      */
     get_anchor() {
-        const ret = wasm.ogsweep_get_anchor(this.__wbg_ptr);
+        const ret = wasm.ogcurve_get_anchor(this.__wbg_ptr);
         return Vector3.__wrap(ret);
     }
     /**
@@ -5550,7 +6141,7 @@ export class OGWedge {
      * @returns {Vector3}
      */
     get_anchor() {
-        const ret = wasm.ogarc_get_anchor(this.__wbg_ptr);
+        const ret = wasm.ogellipticalarc_get_anchor(this.__wbg_ptr);
         return Vector3.__wrap(ret);
     }
 }
@@ -5849,6 +6440,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.ogline_get_anchor(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') {
@@ -5894,13 +6583,6 @@ function __wbg_get_imports() {
         const ret = Vector3.__unwrap(arg0);
         return ret;
     };
-    imports.wbg.__wbindgen_debug_string = function(arg0, arg1) {
-        const ret = debugString(arg1);
-        const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
-        getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
-        getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
-    };
     imports.wbg.__wbindgen_init_externref_table = function() {
         const table = wasm.__wbindgen_export_2;
         const offset = table.grow(4);
@@ -5930,7 +6612,9 @@ function __wbg_finalize_init(instance, module) {
     wasm = instance.exports;
     __wbg_init.__wbindgen_wasm_module = module;
     cachedDataViewMemory0 = null;
+    cachedFloat32ArrayMemory0 = null;
     cachedFloat64ArrayMemory0 = null;
+    cachedUint32ArrayMemory0 = null;
     cachedUint8ArrayMemory0 = null;