opengeometry 2.0.14 → 2.0.15

package/index.js

@@ -137,37 +137,16 @@ function passStringToWasm0(arg, malloc, realloc) {
   WASM_VECTOR_LEN = offset;
   return ptr;
 }
+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;
 }
-/**
- * @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);
-  }
-}
 let cachedFloat64ArrayMemory0 = null;
 function getFloat64ArrayMemory0() {
   if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
@@ -175,35 +154,69 @@ function getFloat64ArrayMemory0() {
   }
   return cachedFloat64ArrayMemory0;
 }
-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;
 }
+function isLikeNone(x) {
+  return x === undefined || x === null;
+}
 /**
- * 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
+ * @param {string} a_json
+ * @param {string} b_json
+ * @param {string} operation
+ * @returns {OGOffsetRegionsResult}
+ */
+function booleanRegions2D$1(a_json, b_json, operation) {
+  const ptr0 = passStringToWasm0(a_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len0 = WASM_VECTOR_LEN;
+  const ptr1 = passStringToWasm0(b_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len1 = WASM_VECTOR_LEN;
+  const ptr2 = passStringToWasm0(operation, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+  const len2 = WASM_VECTOR_LEN;
+  const ret = wasm.booleanRegions2D(ptr0, len0, ptr1, len1, ptr2, len2);
+  if (ret[2]) {
+    throw takeFromExternrefTable0(ret[1]);
+  }
+  return OGOffsetRegionsResult.__wrap(ret[0]);
+}
+
+/**
+ * Exact line/arc region Boolean. The JSON rings contain analytic edges rather
+ * than vertices, and the result keeps arcs as arcs. As with booleanRegions2D,
+ * outer rings are CW in XZ and holes are CCW.
+ * @param {string} a_json
+ * @param {string} b_json
+ * @param {string} operation
  * @returns {string}
  */
-function extrudeBrepFaceDirectional(local_brep_serialized, direction, extent_kind, d_plus, d_minus) {
+function booleanCurvedRegions2D$1(a_json, b_json, operation) {
   let deferred5_0;
   let deferred5_1;
   try {
-    const ptr0 = passStringToWasm0(local_brep_serialized, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const ptr0 = passStringToWasm0(a_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len0 = WASM_VECTOR_LEN;
-    const ptr1 = passArrayF64ToWasm0(direction, wasm.__wbindgen_malloc);
+    const ptr1 = passStringToWasm0(b_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
     const len1 = WASM_VECTOR_LEN;
-    const ptr2 = passStringToWasm0(extent_kind, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const ptr2 = passStringToWasm0(operation, 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);
+    const ret = wasm.booleanCurvedRegions2D(ptr0, len0, ptr1, len1, ptr2, len2);
     var ptr4 = ret[0];
     var len4 = ret[1];
     if (ret[3]) {
@@ -218,60 +231,10 @@ function extrudeBrepFaceDirectional(local_brep_serialized, direction, extent_kin
     wasm.__wbindgen_free(deferred5_0, deferred5_1, 1);
   }
 }
-
-/**
- * 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);
-  }
-}
-function _assertClass(instance, klass) {
-  if (!(instance instanceof klass)) {
-    throw new Error(`expected instance of ${klass.name}`);
-  }
-}
-function isLikeNone(x) {
-  return x === undefined || x === null;
-}
-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;
+function passArrayF64ToWasm0(arg, malloc) {
+  const ptr = malloc(arg.length * 8, 8) >>> 0;
+  getFloat64ArrayMemory0().set(arg, ptr / 8);
+  WASM_VECTOR_LEN = arg.length;
   return ptr;
 }
 /**
@@ -298,7 +261,7 @@ function offsetPolylineRegions$1(centreline_flat, width, closed, miter_limit) {
  * 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.
+ * CW-outer / CCW-hole regions (one or more); empty when no region remains.
  * @param {string} polylines_json
  * @returns {OGOffsetRegionsResult}
  */
@@ -344,6 +307,109 @@ function offsetRingVariable$1(ring_flat, distances, holes_json) {
   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: 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);
+  }
+}
+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;
+}
+
 /**
  * @param {string} serialized
  * @returns {string}
@@ -409,16 +475,6 @@ 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;
-}
 typeof FinalizationRegistry === 'undefined' ? {
   } : new FinalizationRegistry(ptr => wasm.__wbg_matrix3_free(ptr >>> 0, 1));
 const Matrix4Finalization = typeof FinalizationRegistry === 'undefined' ? {
@@ -856,6 +912,22 @@ class OGAnalyticBrep {
     }
     return OGAnalyticBrep.__wrap(ret[0]);
   }
+  /**
+   * @param {string} cutters_json
+   * @param {string} id
+   * @returns {OGAnalyticBrep}
+   */
+  subtract_planar_cutters(cutters_json, id) {
+    const ptr0 = passStringToWasm0(cutters_json, 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_subtract_planar_cutters(this.__wbg_ptr, ptr0, len0, ptr1, len1);
+    if (ret[2]) {
+      throw takeFromExternrefTable0(ret[1]);
+    }
+    return OGAnalyticBrep.__wrap(ret[0]);
+  }
   /**
    * @param {number} thickness
    * @param {string} id
@@ -5007,7 +5079,7 @@ class OGSphere {
    * @returns {Vector3}
    */
   get_anchor() {
-    const ret = wasm.ogsphere_get_anchor(this.__wbg_ptr);
+    const ret = wasm.ogcurve_get_anchor(this.__wbg_ptr);
     return Vector3.__wrap(ret);
   }
 }
@@ -5389,7 +5461,7 @@ class OGSweep {
    * @returns {Vector3}
    */
   get_anchor() {
-    const ret = wasm.ogcurve_get_anchor(this.__wbg_ptr);
+    const ret = wasm.ogsweep_get_anchor(this.__wbg_ptr);
     return Vector3.__wrap(ret);
   }
   /**
@@ -5670,7 +5742,7 @@ class OGWedge {
    * @returns {Vector3}
    */
   get_anchor() {
-    const ret = wasm.ogellipticalarc_get_anchor(this.__wbg_ptr);
+    const ret = wasm.ogwedge_get_anchor(this.__wbg_ptr);
     return Vector3.__wrap(ret);
   }
 }
@@ -6046,7 +6118,7 @@ class WorkPlane {
    * @returns {Vector3}
    */
   get origin() {
-    const ret = wasm.ogline_get_anchor(this.__wbg_ptr);
+    const ret = wasm.workplane_origin(this.__wbg_ptr);
     return Vector3.__wrap(ret);
   }
   /**
@@ -6833,16 +6905,58 @@ class AnalyticSolid extends THREE.Group {
         return this.boolean(other, "intersection", options);
     }
     subtract(cutters, options = {}) {
+        var _a, _b, _c, _d;
         if (!Array.isArray(cutters) || cutters.length === 0 || cutters.some((cutter) => !(cutter instanceof AnalyticSolid))) {
             throw new Error("Analytic subtraction requires a nonempty AnalyticSolid array");
         }
-        let result = this.boolean(cutters[0], "subtraction", options);
-        for (const cutter of cutters.slice(1)) {
-            const next = result.boolean(cutter, "subtraction", options);
-            result.dispose();
-            result = next;
+        if (cutters.length > 1) {
+            const host = this.worldKernel();
+            const cutterKernels = [];
+            let result;
+            try {
+                for (const cutter of cutters)
+                    cutterKernels.push(cutter.worldKernel());
+                const payload = `[${cutterKernels.map((cutter) => cutter.get_brep_serialized()).join(",")}]`;
+                result = host.subtract_planar_cutters(payload, getUUID());
+                const report = result.get_boolean_report_serialized();
+                const solid = AnalyticSolid.fromBrep(result.get_brep_serialized(), {
+                    deflection: (_a = options.deflection) !== null && _a !== void 0 ? _a : this.lastDeflection,
+                    color: (_b = options.color) !== null && _b !== void 0 ? _b : this.surface.material.color,
+                });
+                solid.booleanReport = report ? JSON.parse(report) : undefined;
+                solid.name = this.name;
+                solid.userData = Object.assign({}, this.userData);
+                solid.outline = this.outline;
+                return solid;
+            }
+            catch (error) {
+                const parsed = parseAnalyticGeometryError(error);
+                // The native mixed-cutter path already chose a safe cutter order and
+                // checked spatial overlap. A serial fallback may drop an earlier
+                // cylindrical void or accept an invalid arched profile.
+                if (parsed.code !== "coverage_gap"
+                    || ((_d = (_c = parsed.families) === null || _c === void 0 ? void 0 : _c[0]) === null || _d === void 0 ? void 0 : _d.includes("mixed cutter batch")))
+                    throw parsed;
+            }
+            finally {
+                result === null || result === void 0 ? void 0 : result.free();
+                cutterKernels.forEach((cutter) => cutter.free());
+                host.free();
+            }
+        }
+        let result;
+        try {
+            for (const cutter of cutters) {
+                const next = (result !== null && result !== void 0 ? result : this).boolean(cutter, "subtraction", options);
+                result === null || result === void 0 ? void 0 : result.dispose();
+                result = next;
+            }
+            return result;
+        }
+        catch (error) {
+            result === null || result === void 0 ? void 0 : result.dispose();
+            throw error;
         }
-        return result;
     }
     shell(thickness, options = {}) {
         var _a, _b;
@@ -7196,13 +7310,17 @@ class AnalyticSolid extends THREE.Group {
     }
 }
 function createPrimitiveKernel(options, ogid) {
-    var _a, _b, _c;
+    var _a, _b, _c, _d, _e;
     const frame = (_a = options.frame) !== null && _a !== void 0 ? _a : (options.kind === "planarPolyhedron" || options.kind === "polygonLoft"
         ? { origin: [0, 0, 0], x: [1, 0, 0], y: [0, 1, 0], z: [0, 0, 1] }
         : { origin: [0, 0, 0], x: [1, 0, 0], y: [0, 0, -1], z: [0, 1, 0] });
     const profileExtent = options.kind === "linearExtrusion"
         ? [options.outer, ...options.holes].reduce((extent, loop) => (loop.reduce((loopExtent, point) => Math.max(loopExtent, Math.abs(point[0]), Math.abs(point[1])), extent)), 0)
-        : 0;
+        : options.kind === "arcEdgedExtrusion"
+            ? [options.outer, ...((_b = options.holes) !== null && _b !== void 0 ? _b : [])].reduce((extent, ring) => ring.reduce((loopExtent, edge) => edge.kind === "line"
+                ? Math.max(loopExtent, ...edge.from.map(Math.abs), ...edge.to.map(Math.abs))
+                : Math.max(loopExtent, Math.abs(edge.center[0]) + edge.radius, Math.abs(edge.center[1]) + edge.radius), extent), 0)
+            : 0;
     const loftExtent = options.kind === "polygonLoft"
         ? [...options.lower, ...options.upper].reduce((extent, point) => Math.max(extent, ...point.map(Math.abs)), 0)
         : 0;
@@ -7217,17 +7335,17 @@ function createPrimitiveKernel(options, ogid) {
                 ? Math.max(2 * options.outerRadius, options.height)
                 : options.kind === "chamferedCuboid"
                     ? Math.max(options.width, options.depth, options.height)
-                    : options.kind === "linearExtrusion"
+                    : options.kind === "linearExtrusion" || options.kind === "arcEdgedExtrusion"
                         ? Math.max(options.height, profileExtent)
                         : options.kind === "polygonLoft"
                             ? loftExtent
-                            : options.kind === "straightWallWithArchedOpening"
+                            : options.kind === "boxWithArchedOpening"
                                 ? Math.max(options.width, options.depth, options.height)
                                 : options.kind === "planarPolyhedron"
                                     ? polyhedronExtent
                                     : options.kind === "frustum"
                                         ? Math.max(2 * options.lowerRadius, 2 * options.upperRadius, options.height)
-                                        : options.kind === "circularWall" || options.kind === "circularWallWithOpenings" || options.kind === "circularWallWithArchedOpening"
+                                        : options.kind === "annularSectorExtrusion" || options.kind === "annularSectorExtrusionWithOpenings" || options.kind === "annularSectorExtrusionWithArchedOpening"
                                             ? Math.max(2 * options.radius + options.thickness, options.height)
                                             : options.kind === "cuboid"
                                                 ? Math.max(options.width, options.depth, options.height)
@@ -7236,7 +7354,7 @@ function createPrimitiveKernel(options, ogid) {
                                                     : Math.max(2 * options.radius, options.height);
     const coordinateFloor = Math.max(...frame.origin.map(Math.abs)) * 64 * Number.EPSILON;
     const geometric = Math.max(1e-9, size * 1e-8, coordinateFloor);
-    const accuracy = (_b = options.accuracy) !== null && _b !== void 0 ? _b : {
+    const accuracy = (_c = options.accuracy) !== null && _c !== void 0 ? _c : {
         geometric, intersection: geometric / 4, tessellation: 0.001, exchange: 0.00001,
     };
     const dimensions = options.kind === "torus"
@@ -7251,38 +7369,46 @@ function createPrimitiveKernel(options, ogid) {
                         ? { radius: options.radius, height: options.height, fillet_radius: options.filletRadius }
                         : options.kind === "linearExtrusion"
                             ? { outer: options.outer, holes: options.holes, height: options.height }
-                            : options.kind === "polygonLoft"
-                                ? {
-                                    lower: options.lower,
-                                    upper: options.upper,
-                                    alignment: options.alignment === undefined || options.alignment === "auto"
-                                        ? { kind: "auto" }
-                                        : {
-                                            kind: "indexed",
-                                            upper_start: options.alignment.upperStartIndex,
-                                            reverse_upper: (_c = options.alignment.reverseUpper) !== null && _c !== void 0 ? _c : false,
-                                        },
-                                }
-                                : options.kind === "straightWallWithArchedOpening"
-                                    ? { width: options.width, depth: options.depth, height: options.height, opening: options.opening }
-                                    : options.kind === "planarPolyhedron"
-                                        ? { vertices: options.vertices, faces: options.faces }
-                                        : options.kind === "frustum"
-                                            ? { lower_radius: options.lowerRadius, upper_radius: options.upperRadius, height: options.height }
-                                            : options.kind === "circularWall" || options.kind === "circularWallWithOpenings" || options.kind === "circularWallWithArchedOpening"
-                                                ? Object.assign({ radius: options.radius, thickness: options.thickness, height: options.height, start_angle: options.startAngle, sweep_angle: options.sweepAngle }, (options.kind === "circularWallWithOpenings" ? { openings: options.openings.map((opening) => ({ id: opening.id, angle: opening.angle, width: opening.width, bottom: opening.bottom, height: opening.height })) } : options.kind === "circularWallWithArchedOpening" ? { opening: { id: options.opening.id, angle: options.opening.angle, width: options.opening.width, bottom: options.opening.bottom, height: options.opening.height } } : {})) : options.kind === "cylinderSector"
-                                                ? { radius: options.radius, height: options.height, start_angle: options.startAngle, sweep_angle: options.sweepAngle }
-                                                : options.kind === "cuboid"
-                                                    ? { size: [options.width, options.depth, options.height] }
-                                                    : options.kind === "sphere"
-                                                        ? { radius: options.radius }
-                                                        : { radius: options.radius, height: options.height };
-    return OGAnalyticBrep.from_primitive(JSON.stringify(Object.assign({ kind: options.kind === "circularWall"
-            ? "circular_wall"
-            : options.kind === "circularWallWithOpenings"
-                ? "circular_wall_with_openings"
-                : options.kind === "circularWallWithArchedOpening"
-                    ? "circular_wall_with_arched_opening"
+                            : options.kind === "arcEdgedExtrusion"
+                                ? { outer: options.outer.map((edge) => edge.kind === "line" ? edge : {
+                                        kind: "arc", center: edge.center, radius: edge.radius,
+                                        start_angle: edge.startAngle, sweep_angle: edge.sweepAngle,
+                                    }), holes: ((_d = options.holes) !== null && _d !== void 0 ? _d : []).map((ring) => ring.map((edge) => edge.kind === "line" ? edge : {
+                                        kind: "arc", center: edge.center, radius: edge.radius,
+                                        start_angle: edge.startAngle, sweep_angle: edge.sweepAngle,
+                                    })), height: options.height }
+                                : options.kind === "polygonLoft"
+                                    ? {
+                                        lower: options.lower,
+                                        upper: options.upper,
+                                        alignment: options.alignment === undefined || options.alignment === "auto"
+                                            ? { kind: "auto" }
+                                            : {
+                                                kind: "indexed",
+                                                upper_start: options.alignment.upperStartIndex,
+                                                reverse_upper: (_e = options.alignment.reverseUpper) !== null && _e !== void 0 ? _e : false,
+                                            },
+                                    }
+                                    : options.kind === "boxWithArchedOpening"
+                                        ? { width: options.width, depth: options.depth, height: options.height, opening: options.opening }
+                                        : options.kind === "planarPolyhedron"
+                                            ? { vertices: options.vertices, faces: options.faces }
+                                            : options.kind === "frustum"
+                                                ? { lower_radius: options.lowerRadius, upper_radius: options.upperRadius, height: options.height }
+                                                : options.kind === "annularSectorExtrusion" || options.kind === "annularSectorExtrusionWithOpenings" || options.kind === "annularSectorExtrusionWithArchedOpening"
+                                                    ? Object.assign({ radius: options.radius, thickness: options.thickness, height: options.height, start_angle: options.startAngle, sweep_angle: options.sweepAngle }, (options.kind === "annularSectorExtrusionWithOpenings" ? { openings: options.openings.map((opening) => ({ id: opening.id, angle: opening.angle, width: opening.width, bottom: opening.bottom, height: opening.height })) } : options.kind === "annularSectorExtrusionWithArchedOpening" ? { opening: { id: options.opening.id, angle: options.opening.angle, width: options.opening.width, bottom: options.opening.bottom, height: options.opening.height } } : {})) : options.kind === "cylinderSector"
+                                                    ? { radius: options.radius, height: options.height, start_angle: options.startAngle, sweep_angle: options.sweepAngle }
+                                                    : options.kind === "cuboid"
+                                                        ? { size: [options.width, options.depth, options.height] }
+                                                        : options.kind === "sphere"
+                                                            ? { radius: options.radius }
+                                                            : { radius: options.radius, height: options.height };
+    return OGAnalyticBrep.from_primitive(JSON.stringify(Object.assign({ kind: options.kind === "annularSectorExtrusion"
+            ? "annular_sector_extrusion"
+            : options.kind === "annularSectorExtrusionWithOpenings"
+                ? "annular_sector_extrusion_with_openings"
+                : options.kind === "annularSectorExtrusionWithArchedOpening"
+                    ? "annular_sector_extrusion_with_arched_opening"
                     : options.kind === "coaxialCircleLoft"
                         ? "coaxial_circle_loft"
                         : options.kind === "revolvedRectangle"
@@ -7293,15 +7419,17 @@ function createPrimitiveKernel(options, ogid) {
                                     ? "filleted_cylinder"
                                     : options.kind === "linearExtrusion"
                                         ? "linear_extrusion"
-                                        : options.kind === "polygonLoft"
-                                            ? "polygon_loft"
-                                            : options.kind === "straightWallWithArchedOpening"
-                                                ? "straight_wall_with_arched_opening"
-                                                : options.kind === "planarPolyhedron"
-                                                    ? "planar_polyhedron"
-                                                    : options.kind === "cylinderSector"
-                                                        ? "cylinder_sector"
-                                                        : options.kind, id: ogid, frame, accuracy }, dimensions)));
+                                        : options.kind === "arcEdgedExtrusion"
+                                            ? "arc_edged_extrusion"
+                                            : options.kind === "polygonLoft"
+                                                ? "polygon_loft"
+                                                : options.kind === "boxWithArchedOpening"
+                                                    ? "box_with_arched_opening"
+                                                    : options.kind === "planarPolyhedron"
+                                                        ? "planar_polyhedron"
+                                                        : options.kind === "cylinderSector"
+                                                            ? "cylinder_sector"
+                                                            : options.kind, id: ogid, frame, accuracy }, dimensions)));
 }
 
 function finiteMatrix(matrix) {
@@ -10858,7 +10986,7 @@ function createOffsetExample(scene) {
  * 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
+ * simple sub-loop. Returns an EMPTY array for a collapsed 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, …]`.
@@ -10877,17 +11005,17 @@ function offsetPolylineRegions(centrelineFlat, width, closed, miterLimit = 4) {
 /**
  * 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
+ * stripped, the distance count stays one per unique edge). The result is a
+ * clearance-exact inset region: the ring's interior minus every point within
+ * `distances[i]` of edge i's segment. Distant boundary segments remain
+ * effective across notches; different distances produce circumscribed
+ * clearance arcs. 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.
+ * clear of the outer boundary, 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
@@ -10899,7 +11027,7 @@ function offsetPolylineRegions(centrelineFlat, width, closed, miterLimit = 4) {
  *
  * @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).
+ *                  (0 keeps that boundary edge in place).
  * @param holes excluded interior rings with their own per-edge distances.
  */
 function offsetRingVariable(ring, distances, holes = []) {
@@ -10917,7 +11045,7 @@ function offsetRingVariable(ring, distances, holes = []) {
  * 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.
+ * Returns CW-outer / CCW-hole regions (one or more); empty if no region remains.
  * No CSG. Used to render/extrude an overlapping crossing as one joined mass.
  */
 function offsetPolylineGroupRegions(polylines) {
@@ -10992,7 +11120,7 @@ function areClose(a, b) {
     const dz = a.z - b.z;
     return (dx * dx + dy * dy + dz * dz) <= EPSILON * EPSILON;
 }
-function buildWallOutline(left, right) {
+function buildRibbonOutline(left, right) {
     if (left.length === 0 || right.length === 0) {
         return [];
     }
@@ -11007,7 +11135,7 @@ function buildWallOutline(left, right) {
 function midpoint(a, b) {
     return new Vector3((a.x + b.x) * 0.5, (a.y + b.y) * 0.5, (a.z + b.z) * 0.5);
 }
-function buildThroughSlot(centerlinePoints, wallThickness, height, width) {
+function buildThroughSlot(centerlinePoints, ribbonThickness, height, width) {
     const a = centerlinePoints[2];
     const b = centerlinePoints[3];
     const mid = midpoint(a, b);
@@ -11015,7 +11143,7 @@ function buildThroughSlot(centerlinePoints, wallThickness, height, width) {
     const tangent = [(b.x - a.x) / length, (b.z - a.z) / length];
     const normal = [-tangent[1], tangent[0]];
     const halfWidth = width * 0.5;
-    const halfDepth = wallThickness * 0.5 + 0.1;
+    const halfDepth = ribbonThickness * 0.5 + 0.1;
     const point = (along, across) => [
         mid.x + tangent[0] * along + normal[0] * across,
         -(mid.z + tangent[1] * along + normal[1] * across),
@@ -11039,13 +11167,13 @@ function buildThroughSlot(centerlinePoints, wallThickness, height, width) {
  * other thrown value). Used by the example HTML to surface kernel failures
  * in a status panel without losing the structured payload.
  */
-function describeWallSubtractError(error) {
+function describeRibbonSubtractError(error) {
     if (error instanceof Error) {
         return error.message;
     }
     return String(error);
 }
-function createWallFromOffsetsExample(scene, options = {}) {
+function createRibbonFromOffsetsExample(scene, options = {}) {
     var _a, _b, _c;
     const centerline = new Polyline({
         points: [
@@ -11058,11 +11186,11 @@ function createWallFromOffsetsExample(scene, options = {}) {
         ],
         color: 0x1f2937,
     });
-    const wallThickness = 0.45;
-    const half = wallThickness * 0.5;
+    const ribbonThickness = 0.45;
+    const half = ribbonThickness * 0.5;
     const acuteThreshold = 35.0;
     const bevel = true;
-    const wallHeight = (_a = options.height) !== null && _a !== void 0 ? _a : 2.6;
+    const ribbonHeight = (_a = options.height) !== null && _a !== void 0 ? _a : 2.6;
     const leftOffset = centerline.getOffset(half, acuteThreshold, bevel);
     const rightOffset = centerline.getOffset(-0.225, acuteThreshold, bevel);
     const leftOffsetPolyline = new Polyline({
@@ -11073,27 +11201,27 @@ function createWallFromOffsetsExample(scene, options = {}) {
         points: rightOffset.points,
         color: 0xf97316,
     });
-    const wallOutline = buildWallOutline(leftOffset.points, rightOffset.points);
-    if (wallOutline.length < 3) {
-        throw new Error("Failed to create wall polygon from offsets.");
+    const ribbonOutline = buildRibbonOutline(leftOffset.points, rightOffset.points);
+    if (ribbonOutline.length < 3) {
+        throw new Error("Failed to create ribbon polygon from offsets.");
     }
-    const wallPolygon = new Polygon({
-        vertices: wallOutline,
+    const ribbonPolygon = new Polygon({
+        vertices: ribbonOutline,
         color: 0x3b82f6,
     });
-    wallPolygon.position.y = 0.01;
+    ribbonPolygon.position.y = 0.01;
     scene.add(centerline);
     scene.add(leftOffsetPolyline);
     scene.add(rightOffsetPolyline);
-    scene.add(wallPolygon);
+    scene.add(ribbonPolygon);
     let cutResult = null;
     let cutError = null;
     if ((_b = options.cutThroughSlot) !== null && _b !== void 0 ? _b : false) {
-        const wallSolid = new AnalyticSolid({
+        const ribbonSolid = new AnalyticSolid({
             kind: "linearExtrusion",
-            outer: wallOutline.map((point) => [point.x, -point.z]),
+            outer: ribbonOutline.map((point) => [point.x, -point.z]),
             holes: [],
-            height: wallHeight,
+            height: ribbonHeight,
             color: 0x3b82f6,
             deflection: 0.01,
         });
@@ -11104,24 +11232,24 @@ function createWallFromOffsetsExample(scene, options = {}) {
             new Vector3(0.6, 0.0, 0.2),
             new Vector3(0.1, 0.0, 1.0),
             new Vector3(2.6, 0.0, 2.0),
-        ], wallThickness, wallHeight, (_c = options.slotWidth) !== null && _c !== void 0 ? _c : 0.6);
+        ], ribbonThickness, ribbonHeight, (_c = options.slotWidth) !== null && _c !== void 0 ? _c : 0.6);
         const cutters = [cutter];
         try {
-            const cutWall = wallSolid.subtract(cutters, { color: 0x3b82f6 });
-            scene.add(cutWall);
-            cutResult = { wall: cutWall, cutters };
+            const cutRibbon = ribbonSolid.subtract(cutters, { color: 0x3b82f6 });
+            scene.add(cutRibbon);
+            cutResult = { ribbon: cutRibbon, cutters };
         }
         catch (error) {
             cutError = error;
-            scene.add(wallSolid);
-            cutResult = { wall: wallSolid, cutters };
+            scene.add(ribbonSolid);
+            cutResult = { ribbon: ribbonSolid, cutters };
         }
     }
     return {
         centerline,
         leftOffsetPolyline,
         rightOffsetPolyline,
-        wallPolygon,
+        ribbonPolygon,
         leftOffset,
         rightOffset,
         cutResult,
@@ -11319,7 +11447,7 @@ function createPolygonPreset(operation, options) {
 function createExtrudedPreset(operation, options) {
     var _a, _b, _c;
     const extrudedOffset = (_a = options.extrudedOffset) !== null && _a !== void 0 ? _a : new Vector3(0.0, 0.0, 0.0);
-    const wall = new AnalyticSolid({
+    const host = new AnalyticSolid({
         kind: "linearExtrusion",
         outer: [[-2.2, -0.18], [2.2, -0.18], [2.2, 0.18], [-2.2, 0.18]],
         holes: [],
@@ -11327,7 +11455,7 @@ function createExtrudedPreset(operation, options) {
         color: 0x60a5fa,
         deflection: 0.01,
     });
-    const opening = new AnalyticSolid({
+    const cutter = new AnalyticSolid({
         kind: "linearExtrusion",
         outer: [[-0.7, -0.34], [0.9, -0.34], [0.9, 0.34], [-0.7, 0.34]],
         holes: [],
@@ -11335,16 +11463,16 @@ function createExtrudedPreset(operation, options) {
         color: 0xf97316,
         deflection: 0.01,
     });
-    opening.position.set(extrudedOffset.x, 0, extrudedOffset.z);
-    wall.outline = (_b = options.outline) !== null && _b !== void 0 ? _b : true;
-    opening.outline = (_c = options.outline) !== null && _c !== void 0 ? _c : true;
+    cutter.position.set(extrudedOffset.x, 0, extrudedOffset.z);
+    host.outline = (_b = options.outline) !== null && _b !== void 0 ? _b : true;
+    cutter.outline = (_c = options.outline) !== null && _c !== void 0 ? _c : true;
     return {
         title: `${capitalize(operation)} Extruded Solid`,
         description: "Two coextensive authoritative line-profile extrusions use the in-house planar arrangement.",
-        lhsOperand: wall,
-        rhsOperand: opening,
-        lhsVisual: wall,
-        rhsVisual: opening,
+        lhsOperand: host,
+        rhsOperand: cutter,
+        lhsVisual: host,
+        rhsVisual: cutter,
     };
 }
 /**
@@ -11458,6 +11586,33 @@ function createEditorModesExample(scene) {
     };
 }
 
+function booleanRegions2D(a, b, operation) {
+    const kernelExport = booleanRegions2D$1;
+    if (typeof kernelExport !== "function") {
+        throw new Error("booleanRegions2D is unavailable in the loaded WASM package");
+    }
+    const point = (value) => [
+        value.x,
+        value.y,
+        value.z,
+    ];
+    const encode = (regions) => JSON.stringify(regions.map((region) => ({
+        outer: region.outer.map(point),
+        holes: region.holes.map((hole) => hole.map(point)),
+    })));
+    const result = kernelExport(encode(a), encode(b), operation);
+    return JSON.parse(result.regionsSerialized);
+}
+/** Analytic line/arc region Boolean; output arcs retain their exact circles. */
+function booleanCurvedRegions2D(a, b, operation) {
+    const kernelExport = booleanCurvedRegions2D$1;
+    if (typeof kernelExport !== "function") {
+        throw new Error("booleanCurvedRegions2D is unavailable in the loaded WASM package");
+    }
+    const result = kernelExport(JSON.stringify(a), JSON.stringify(b), operation);
+    return JSON.parse(result);
+}
+
 /**
  * Shared runtime entrypoint used to initialize the OpenGeometry wasm module.
  */
@@ -11522,5 +11677,5 @@ class OpenGeometry {
 OpenGeometry.version = OPEN_GEOMETRY_THREE_VERSION;
 OpenGeometry.instance = null;
 
-export { AnalyticCurve, AnalyticGeometryError, AnalyticLodController, AnalyticPattern, AnalyticSolid, AnalyticTessellationWorker, Arc, Cuboid, Curve, Cylinder, EllipticalArc, FreeformEditor, FreeformGeometry, Line, OGAnalyticBrep, OGAnalyticTessellation, OGSceneManager, OpenGeometry, Opening, Polygon, Polyline, Rectangle, Solid, Sphere, SpotLabel, Sweep, Vector3, Wedge, WorkPlane, analyticIfcText, analyzeProfile, booleanIntersection, booleanSubtraction, booleanUnion, circularPattern, clonePlacement, createBooleanExample, createEditorModesExample, createFreeformEditor, createFreeformGeometry, createOffsetExample, createOffsetRingVariableExample, createParametricEditCapabilities, createPrimitivesExample, createShapesExample, createSweepExample, createWallFromOffsetsExample, deflectionBucket, describeWallSubtractError, executeBooleanSubtractionMany, extrudeBrepFace, extrudeBrepFaceDirectional, linearPattern, loftPolygonSections, offsetPolylineGroupRegions, offsetPolylineRegions, offsetRingVariable, parseAnalyticGeometryError, rectangularPattern, tessellateFacetedBrep, tessellate_brep, toObjectTransformation$1 as toObjectTransformation, uniformScale, validateAnalyticBrep, worldUnitsPerPixel };
+export { AnalyticCurve, AnalyticGeometryError, AnalyticLodController, AnalyticPattern, AnalyticSolid, AnalyticTessellationWorker, Arc, Cuboid, Curve, Cylinder, EllipticalArc, FreeformEditor, FreeformGeometry, Line, OGAnalyticBrep, OGAnalyticTessellation, OGSceneManager, OpenGeometry, Opening, Polygon, Polyline, Rectangle, Solid, Sphere, SpotLabel, Sweep, Vector3, Wedge, WorkPlane, analyticIfcText, analyzeProfile, booleanCurvedRegions2D, booleanIntersection, booleanRegions2D, booleanSubtraction, booleanUnion, circularPattern, clonePlacement, createBooleanExample, createEditorModesExample, createFreeformEditor, createFreeformGeometry, createOffsetExample, createOffsetRingVariableExample, createParametricEditCapabilities, createPrimitivesExample, createRibbonFromOffsetsExample, createShapesExample, createSweepExample, deflectionBucket, describeRibbonSubtractError, executeBooleanSubtractionMany, extrudeBrepFace, extrudeBrepFaceDirectional, linearPattern, loftPolygonSections, offsetPolylineGroupRegions, offsetPolylineRegions, offsetRingVariable, parseAnalyticGeometryError, rectangularPattern, tessellateFacetedBrep, tessellate_brep, toObjectTransformation$1 as toObjectTransformation, uniformScale, validateAnalyticBrep, worldUnitsPerPixel };
 //# sourceMappingURL=index.js.map