opengeometry 2.0.2 → 2.0.4

package/index.js

@@ -159,6 +159,32 @@ function getArrayF64FromWasm0(ptr, len) {
   ptr = ptr >>> 0;
   return getFloat64ArrayMemory0().subarray(ptr / 8, ptr / 8 + len);
 }
+/**
+ * @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 cachedDataViewMemory0 = null;
 function getDataViewMemory0() {
   if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer) {
@@ -175,9 +201,6 @@ function passArrayJsValueToWasm0(array, malloc) {
   WASM_VECTOR_LEN = array.length;
   return ptr;
 }
-function isLikeNone(x) {
-  return x === undefined || x === null;
-}
 function getArrayJsValueFromWasm0(ptr, len) {
   ptr = ptr >>> 0;
   const mem = getDataViewMemory0();
@@ -188,6 +211,9 @@ function getArrayJsValueFromWasm0(ptr, len) {
   wasm.__externref_drop_slice(ptr, len);
   return result;
 }
+function isLikeNone(x) {
+  return x === undefined || x === null;
+}
 /**
  * Wasm entry point for union.
  * @param {string} lhs_brep_serialized
@@ -250,6 +276,27 @@ function booleanSubtraction$1(lhs_brep_serialized, rhs_brep_serialized, options_
   }
   return OGBooleanResult.__wrap(ret[0]);
 }
+
+/**
+ * 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}
+ */
+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]);
+  }
+  return OGBooleanResult.__wrap(ret[0]);
+}
 const Matrix3Finalization = typeof FinalizationRegistry === 'undefined' ? {
   register: () => {},
   unregister: () => {}
@@ -2229,6 +2276,24 @@ class OGFreeformGeometry {
       wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
   }
+  /**
+   * @returns {Float64Array}
+   */
+  getGeometryBuffer() {
+    const ret = wasm.ogfreeformgeometry_getGeometryBuffer(this.__wbg_ptr);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+  }
+  /**
+   * @returns {Float64Array}
+   */
+  getLocalGeometryBuffer() {
+    const ret = wasm.ogfreeformgeometry_getLocalGeometryBuffer(this.__wbg_ptr);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+  }
   /**
    * @returns {string}
    */
@@ -2244,6 +2309,24 @@ class OGFreeformGeometry {
       wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
     }
   }
+  /**
+   * @returns {Float64Array}
+   */
+  getOutlineGeometryBuffer() {
+    const ret = wasm.ogfreeformgeometry_getOutlineGeometryBuffer(this.__wbg_ptr);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+  }
+  /**
+   * @returns {Float64Array}
+   */
+  getLocalOutlineGeometryBuffer() {
+    const ret = wasm.ogfreeformgeometry_getLocalOutlineGeometryBuffer(this.__wbg_ptr);
+    var v1 = getArrayF64FromWasm0(ret[0], ret[1]).slice();
+    wasm.__wbindgen_free(ret[0], ret[1] * 8, 8);
+    return v1;
+  }
   /**
    * @returns {string}
    */
@@ -2577,7 +2660,7 @@ class OGLine {
    * @returns {Vector3}
    */
   get_anchor() {
-    const ret = wasm.ogline_get_anchor(this.__wbg_ptr);
+    const ret = wasm.ogcurve_get_anchor(this.__wbg_ptr);
     return Vector3.__wrap(ret);
   }
   /**
@@ -3203,7 +3286,7 @@ class OGPolyline {
    * @returns {Vector3}
    */
   get_anchor() {
-    const ret = wasm.ogline_get_anchor(this.__wbg_ptr);
+    const ret = wasm.ogcurve_get_anchor(this.__wbg_ptr);
     return Vector3.__wrap(ret);
   }
   /**
@@ -5194,7 +5277,7 @@ class OGWedge {
    * @returns {Vector3}
    */
   get_anchor() {
-    const ret = wasm.ogline_get_anchor(this.__wbg_ptr);
+    const ret = wasm.ogwedge_get_anchor(this.__wbg_ptr);
     return Vector3.__wrap(ret);
   }
 }
@@ -5625,8 +5708,10 @@ var OGKernel = /*#__PURE__*/Object.freeze({
     Vector3: Vector3,
     booleanIntersection: booleanIntersection$1,
     booleanSubtraction: booleanSubtraction$1,
+    booleanSubtractionMany: booleanSubtractionMany,
     booleanUnion: booleanUnion$1,
     default: __wbg_init,
+    extrudeBrepFace: extrudeBrepFace$1,
     initSync: initSync
 });
 
@@ -5648,7 +5733,10 @@ class SpotLabel extends CSS2DObject {
     }
 }
 
-const OPEN_GEOMETRY_THREE_VERSION = '0.0.6';
+/**
+ * Version string exposed by the Three.js adapter at runtime.
+ */
+const OPEN_GEOMETRY_THREE_VERSION = "2.0.3";
 
 /**
  * Convert array of 16 byte values to UUID string format of the form:
@@ -5708,10 +5796,13 @@ function getUUID() {
     return uuid;
 }
 
-function cloneVector$1(vector, fallback) {
+function cloneVector$2(vector, fallback) {
     var _a;
     return (_a = vector === null || vector === void 0 ? void 0 : vector.clone()) !== null && _a !== void 0 ? _a : new Vector3(...fallback);
 }
+/**
+ * Returns the canonical capability payload exposed by parametric wrappers.
+ */
 function createParametricEditCapabilities(entityType, editFamily) {
     return {
         editingMode: "parametric",
@@ -5722,27 +5813,34 @@ function createParametricEditCapabilities(entityType, editFamily) {
         canConvertToFreeform: true,
     };
 }
+/**
+ * Normalizes optional placement fields into concrete vectors.
+ */
 function clonePlacement(placement) {
     return {
-        translation: cloneVector$1(placement.translation, [0, 0, 0]),
-        rotation: cloneVector$1(placement.rotation, [0, 0, 0]),
-        scale: cloneVector$1(placement.scale, [1, 1, 1]),
+        translation: cloneVector$2(placement.translation, [0, 0, 0]),
+        rotation: cloneVector$2(placement.rotation, [0, 0, 0]),
+        scale: cloneVector$2(placement.scale, [1, 1, 1]),
     };
 }
+/**
+ * Converts a parametric placement payload into the freeform/object transform
+ * structure expected by BRep-backed helpers.
+ */
 function toObjectTransformation$1(placement) {
     if ("anchor" in placement) {
         return {
-            anchor: cloneVector$1(placement.anchor, [0, 0, 0]),
-            translation: cloneVector$1(placement.translation, [0, 0, 0]),
-            rotation: cloneVector$1(placement.rotation, [0, 0, 0]),
-            scale: cloneVector$1(placement.scale, [1, 1, 1]),
+            anchor: cloneVector$2(placement.anchor, [0, 0, 0]),
+            translation: cloneVector$2(placement.translation, [0, 0, 0]),
+            rotation: cloneVector$2(placement.rotation, [0, 0, 0]),
+            scale: cloneVector$2(placement.scale, [1, 1, 1]),
         };
     }
     return {
         anchor: new Vector3(0, 0, 0),
-        translation: cloneVector$1(placement.translation, [0, 0, 0]),
-        rotation: cloneVector$1(placement.rotation, [0, 0, 0]),
-        scale: cloneVector$1(placement.scale, [1, 1, 1]),
+        translation: cloneVector$2(placement.translation, [0, 0, 0]),
+        rotation: cloneVector$2(placement.rotation, [0, 0, 0]),
+        scale: cloneVector$2(placement.scale, [1, 1, 1]),
     };
 }
 
@@ -5834,69 +5932,132 @@ function serializeOptions(options) {
             ? toPlainVector3$1(options.constraintPlaneNormal)
             : undefined }));
 }
+/**
+ * High-level editor facade over the kernel freeform editing API.
+ */
 class FreeformEditor {
     constructor(geometry, editor = new OGFreeformEditor()) {
         this.geometry = geometry;
         this.editor = editor;
     }
+    /**
+     * Returns the freeform geometry currently managed by this editor.
+     */
     getFreeformGeometry() {
         return this.geometry;
     }
+    /**
+     * Returns renderable topology buffers for faces, edges, and vertices.
+     */
     getTopologyRenderData() {
         return normalizeTopologyRenderData(parseJson$1(this.editor.getTopologyRenderData(this.geometry.getKernelGeometry())));
     }
+    /**
+     * Returns semantic and topological information for a face id.
+     */
     getFaceInfo(faceId) {
         return normalizeFaceInfo(parseJson$1(this.editor.getFaceInfo(this.geometry.getKernelGeometry(), faceId)));
     }
+    /**
+     * Returns semantic and topological information for an edge id.
+     */
     getEdgeInfo(edgeId) {
         return normalizeEdgeInfo(parseJson$1(this.editor.getEdgeInfo(this.geometry.getKernelGeometry(), edgeId)));
     }
+    /**
+     * Returns semantic and topological information for a vertex id.
+     */
     getVertexInfo(vertexId) {
         return normalizeVertexInfo(parseJson$1(this.editor.getVertexInfo(this.geometry.getKernelGeometry(), vertexId)));
     }
+    /**
+     * Returns global edit capabilities for the current freeform model.
+     */
     getEditCapabilities() {
         return normalizeFreeformCapabilities(parseJson$1(this.editor.getEditCapabilities(this.geometry.getKernelGeometry())));
     }
+    /**
+     * Returns edit capabilities scoped to a single face.
+     */
     getFaceEditCapabilities(faceId) {
         return normalizeFeatureCapabilities(parseJson$1(this.editor.getFaceEditCapabilities(this.geometry.getKernelGeometry(), faceId)));
     }
+    /**
+     * Returns edit capabilities scoped to a single edge.
+     */
     getEdgeEditCapabilities(edgeId) {
         return normalizeFeatureCapabilities(parseJson$1(this.editor.getEdgeEditCapabilities(this.geometry.getKernelGeometry(), edgeId)));
     }
+    /**
+     * Returns edit capabilities scoped to a single vertex.
+     */
     getVertexEditCapabilities(vertexId) {
         return normalizeFeatureCapabilities(parseJson$1(this.editor.getVertexEditCapabilities(this.geometry.getKernelGeometry(), vertexId)));
     }
+    /**
+     * Offset a face along its editable normal direction.
+     */
     pushPullFace(faceId, distance, options) {
         return parseEditResult(this.editor.pushPullFace(this.geometry.getKernelGeometry(), faceId, distance, serializeOptions(options)));
     }
+    /**
+     * Creates new side faces by extruding a face region.
+     */
     extrudeFace(faceId, distance, options) {
         return parseEditResult(this.editor.extrudeFace(this.geometry.getKernelGeometry(), faceId, distance, serializeOptions(options)));
     }
+    /**
+     * Splits a face by connecting two points sampled on its boundary edges.
+     */
     cutFace(faceId, startEdgeId, startT, endEdgeId, endT, options) {
         return parseEditResult(this.editor.cutFace(this.geometry.getKernelGeometry(), faceId, startEdgeId, startT, endEdgeId, endT, serializeOptions(options)));
     }
+    /**
+     * Moves a face by a translation vector, subject to kernel constraints.
+     */
     moveFace(faceId, translation, options) {
         return parseEditResult(this.editor.moveFace(this.geometry.getKernelGeometry(), faceId, translation, serializeOptions(options)));
     }
+    /**
+     * Moves an edge by a translation vector, subject to kernel constraints.
+     */
     moveEdge(edgeId, translation, options) {
         return parseEditResult(this.editor.moveEdge(this.geometry.getKernelGeometry(), edgeId, translation, serializeOptions(options)));
     }
+    /**
+     * Moves a vertex by a translation vector, subject to kernel constraints.
+     */
     moveVertex(vertexId, translation, options) {
         return parseEditResult(this.editor.moveVertex(this.geometry.getKernelGeometry(), vertexId, translation, serializeOptions(options)));
     }
+    /**
+     * Inserts a vertex at parametric position `t` along an edge.
+     */
     insertVertexOnEdge(edgeId, t, options) {
         return parseEditResult(this.editor.insertVertexOnEdge(this.geometry.getKernelGeometry(), edgeId, t, serializeOptions(options)));
     }
+    /**
+     * Splits an edge at parametric position `t`.
+     */
     splitEdge(edgeId, t, options) {
         return parseEditResult(this.editor.splitEdge(this.geometry.getKernelGeometry(), edgeId, t, serializeOptions(options)));
     }
+    /**
+     * Creates a loop cut that propagates from the selected edge when possible.
+     */
     loopCut(edgeId, t, options) {
         return parseEditResult(this.editor.loopCut(this.geometry.getKernelGeometry(), edgeId, t, serializeOptions(options)));
     }
+    /**
+     * Removes a vertex when the current topology allows the edit.
+     */
     removeVertex(vertexId, options) {
         return parseEditResult(this.editor.removeVertex(this.geometry.getKernelGeometry(), vertexId, serializeOptions(options)));
     }
 }
+/**
+ * Convenience factory for creating a freeform editor around a geometry wrapper.
+ */
 function createFreeformEditor(geometry) {
     return new FreeformEditor(geometry);
 }
@@ -5914,7 +6075,7 @@ function toPlainVector3(value) {
         z: value.z,
     };
 }
-function cloneVector(vector, fallback) {
+function cloneVector$1(vector, fallback) {
     var _a;
     return (_a = vector === null || vector === void 0 ? void 0 : vector.clone()) !== null && _a !== void 0 ? _a : new Vector3(...fallback);
 }
@@ -5928,10 +6089,10 @@ function normalizePlacement(placement) {
 }
 function toObjectTransformation(placement) {
     return {
-        anchor: cloneVector(placement.anchor, [0, 0, 0]),
-        translation: cloneVector(placement.translation, [0, 0, 0]),
-        rotation: cloneVector(placement.rotation, [0, 0, 0]),
-        scale: cloneVector(placement.scale, [1, 1, 1]),
+        anchor: cloneVector$1(placement.anchor, [0, 0, 0]),
+        translation: cloneVector$1(placement.translation, [0, 0, 0]),
+        rotation: cloneVector$1(placement.rotation, [0, 0, 0]),
+        scale: cloneVector$1(placement.scale, [1, 1, 1]),
     };
 }
 function toPlainObjectTransformation(transform) {
@@ -5942,7 +6103,7 @@ function toPlainObjectTransformation(transform) {
         scale: toPlainVector3(transform.scale),
     };
 }
-function serializeBrepLike$1(value) {
+function serializeBrepLike$2(value) {
     return typeof value === "string" ? value : JSON.stringify(value);
 }
 function normalizeFreeformSerialized(source) {
@@ -5953,56 +6114,119 @@ function normalizeFreeformSerialized(source) {
         return source.getLocalBrepSerialized();
     }
     if (typeof source.getLocalBrepData === "function") {
-        return serializeBrepLike$1(source.getLocalBrepData());
+        return serializeBrepLike$2(source.getLocalBrepData());
     }
     if (typeof source.getBrepSerialized === "function") {
         return source.getBrepSerialized();
     }
     if (typeof source.getBrepData === "function") {
-        return serializeBrepLike$1(source.getBrepData());
+        return serializeBrepLike$2(source.getBrepData());
     }
     if (typeof source.getBrep === "function") {
-        return serializeBrepLike$1(source.getBrep());
+        return serializeBrepLike$2(source.getBrep());
     }
     return JSON.stringify(source);
 }
+/**
+ * Thin client-side wrapper around the kernel `OGFreeformGeometry` object.
+ */
 class FreeformGeometry {
     constructor(geometry) {
         this.geometry = geometry;
     }
+    /**
+     * Returns the stable kernel-side id for this freeform geometry object.
+     */
     getId() {
         return this.geometry.id;
     }
+    /**
+     * Returns the world-space serialized BRep payload.
+     */
     getBrepSerialized() {
         return this.geometry.getBrepSerialized();
     }
+    /**
+     * Returns the local-space serialized BRep payload.
+     */
     getLocalBrepSerialized() {
         return this.geometry.getLocalBrepSerialized();
     }
+    /**
+     * Returns the serialized triangle position buffer emitted by the kernel.
+     */
     getGeometrySerialized() {
         return this.geometry.getGeometrySerialized();
     }
+    /**
+     * Returns world-space triangle positions as a plain number array.
+     */
+    getGeometryBuffer() {
+        return Array.from(this.geometry.getGeometryBuffer());
+    }
+    /**
+     * Returns local-space triangle positions as a plain number array.
+     */
+    getLocalGeometryBuffer() {
+        return Array.from(this.geometry.getLocalGeometryBuffer());
+    }
+    /**
+     * Returns the serialized outline buffer emitted by the kernel.
+     */
     getOutlineGeometrySerialized() {
         return this.geometry.getOutlineGeometrySerialized();
     }
+    /**
+     * Returns world-space outline segment positions as a plain number array.
+     */
+    getOutlineGeometryBuffer() {
+        return Array.from(this.geometry.getOutlineGeometryBuffer());
+    }
+    /**
+     * Returns local-space outline segment positions as a plain number array.
+     */
+    getLocalOutlineGeometryBuffer() {
+        return Array.from(this.geometry.getLocalOutlineGeometryBuffer());
+    }
+    /**
+     * Returns the current normalized placement for this freeform geometry.
+     */
     getPlacement() {
         return normalizePlacement(parseJson(this.geometry.getPlacementSerialized()));
     }
+    /**
+     * Replaces the full placement transform in one call.
+     */
     setPlacement(transform) {
         this.geometry.setPlacementSerialized(JSON.stringify(toPlainObjectTransformation(transform)));
     }
+    /**
+     * Sets translation, rotation, and scale without changing the current anchor.
+     */
     setTransform(translation, rotation, scale) {
         this.geometry.setTransform(translation, rotation, scale);
     }
+    /**
+     * Updates only the translation component of the placement.
+     */
     setTranslation(translation) {
         this.geometry.setTranslation(translation);
     }
+    /**
+     * Updates only the rotation component of the placement.
+     */
     setRotation(rotation) {
         this.geometry.setRotation(rotation);
     }
+    /**
+     * Updates only the scale component of the placement.
+     */
     setScale(scale) {
         this.geometry.setScale(scale);
     }
+    /**
+     * Updates the explicit modeling anchor used by downstream transforms.
+     */
     setAnchor(anchor) {
         this.geometry.setAnchor(anchor);
     }
@@ -6011,6 +6235,10 @@ class FreeformGeometry {
         return this.geometry;
     }
 }
+/**
+ * Creates a `FreeformGeometry` wrapper from serialized BRep JSON, a parsed
+ * BRep object, or another wrapper exposing BRep accessors.
+ */
 function createFreeformGeometry(source, options) {
     var _a;
     const id = (_a = options === null || options === void 0 ? void 0 : options.id) !== null && _a !== void 0 ? _a : `freeform-${Date.now()}`;
@@ -6246,6 +6474,9 @@ class Line extends THREE.Line {
 }
 
 /* eslint-enable no-unused-vars */
+/**
+ * Polyline wrapper backed by the kernel OGPolyline primitive.
+ */
 class Polyline extends THREE.Line {
     set color(color) {
         this.options.color = color;
@@ -6473,6 +6704,9 @@ class Polyline extends THREE.Line {
     }
 }
 
+/**
+ * Arc wrapper backed by the kernel OGArc primitive.
+ */
 class Arc extends THREE.Line {
     set color(color) {
         this.options.color = color;
@@ -6680,6 +6914,9 @@ class Arc extends THREE.Line {
 }
 
 /* eslint-enable no-unused-vars */
+/**
+ * Rectangle wrapper backed by the kernel OGRectangle primitive.
+ */
 class Rectangle extends THREE.Line {
     // set width(width: number) {
     //   this.options.width = width;
@@ -6915,6 +7152,9 @@ class Rectangle extends THREE.Line {
 }
 
 /* eslint-enable no-unused-vars */
+/**
+ * Curve wrapper backed by the kernel OGCurve primitive.
+ */
 class Curve extends THREE.Line {
     set color(color) {
         this.options.color = color;
@@ -7075,12 +7315,18 @@ function getOutlineResolution() {
     }
     return new THREE.Vector2(window.innerWidth, window.innerHeight);
 }
+/**
+ * Clamps outline width inputs to the supported positive finite range.
+ */
 function sanitizeOutlineWidth(width) {
     if (!Number.isFinite(width) || typeof width !== "number" || width <= 0) {
         return DEFAULT_OUTLINE_WIDTH;
     }
     return width;
 }
+/**
+ * Creates either a thin or fat outline mesh from line segment positions.
+ */
 function createShapeOutlineMesh({ positions, color = DEFAULT_OUTLINE_COLOR, fatOutlines = false, outlineWidth = DEFAULT_OUTLINE_WIDTH, }) {
     if (fatOutlines) {
         const fatGeometry = new LineSegmentsGeometry();
@@ -7099,6 +7345,9 @@ function createShapeOutlineMesh({ positions, color = DEFAULT_OUTLINE_COLOR, fatO
     const outlineMaterial = new THREE.LineBasicMaterial({ color });
     return new THREE.LineSegments(outlineGeometry, outlineMaterial);
 }
+/**
+ * Disposes the geometry and material owned by an outline mesh.
+ */
 function disposeShapeOutlineMesh(mesh) {
     if (!mesh) {
         return;
@@ -7110,6 +7359,9 @@ function disposeShapeOutlineMesh(mesh) {
     }
     mesh.material.dispose();
 }
+/**
+ * Updates the color of an existing outline mesh in place.
+ */
 function setShapeOutlineColor(mesh, color) {
     if (!mesh) {
         return;
@@ -7122,6 +7374,9 @@ function setShapeOutlineColor(mesh, color) {
         mesh.material.color.set(color);
     }
 }
+/**
+ * Reads the current outline color, falling back when no outline exists.
+ */
 function getShapeOutlineColor(mesh, fallback = DEFAULT_OUTLINE_COLOR) {
     if (!mesh) {
         return fallback;
@@ -7135,6 +7390,42 @@ function getShapeOutlineColor(mesh, fallback = DEFAULT_OUTLINE_COLOR) {
     return fallback;
 }
 
+/**
+ * Extrudes the first face or wire in a local BRep payload into a closed solid BRep.
+ */
+function extrudeBrepFace(source, height) {
+    const extrudeExport = extrudeBrepFace$1;
+    if (typeof extrudeExport !== "function") {
+        throw new Error("extrudeBrepFace is not available in the loaded wasm package. Rebuild opengeometry wasm bindings.");
+    }
+    const kernelFunction = extrudeExport;
+    return kernelFunction(resolveLocalBrepSerialized(source), height);
+}
+function resolveLocalBrepSerialized(source) {
+    if (typeof source === "string") {
+        return source;
+    }
+    if (typeof source.getLocalBrepSerialized === "function") {
+        return source.getLocalBrepSerialized();
+    }
+    if (typeof source.getLocalBrepData === "function") {
+        return serializeBrepLike$1(source.getLocalBrepData());
+    }
+    if (typeof source.getBrepSerialized === "function") {
+        return source.getBrepSerialized();
+    }
+    if (typeof source.getBrepData === "function") {
+        return serializeBrepLike$1(source.getBrepData());
+    }
+    if (typeof source.getBrep === "function") {
+        return serializeBrepLike$1(source.getBrep());
+    }
+    return JSON.stringify(source);
+}
+function serializeBrepLike$1(value) {
+    return typeof value === "string" ? value : JSON.stringify(value);
+}
+
 var _BooleanResult_outlineMesh;
 /* eslint-enable no-unused-vars */
 const BOOLEAN_CREASE_ANGLE = Math.PI / 5;
@@ -7276,6 +7567,9 @@ class BooleanResult extends THREE.Mesh {
 _BooleanResult_outlineMesh = new WeakMap();
 /**
  * Computes a kernel-backed boolean union and returns a renderable result mesh.
+ *
+ * Accepts wrapper objects directly, including `Solid`, `Cuboid`, `Opening`,
+ * and other shapes that expose BRep accessors.
  */
 function booleanUnion(lhs, rhs, options) {
     return executeBoolean("booleanUnion", lhs, rhs, options);
@@ -7288,16 +7582,34 @@ function booleanIntersection(lhs, rhs, options) {
 }
 /**
  * Computes a kernel-backed boolean subtraction and returns a renderable result mesh.
+ *
+ * Use this when you want a standalone helper rather than a shape-level
+ * convenience method like `opening.subtractFrom(host)`.
  */
 function booleanSubtraction(lhs, rhs, options) {
     return executeBoolean("booleanSubtraction", lhs, rhs, options);
 }
+/**
+ * Computes a kernel-backed repeated subtraction using a left-to-right cutter array.
+ *
+ * This is used by the shape-level `.subtract([...])` helpers so the heavy
+ * boolean orchestration stays in the Rust/WASM layer instead of JavaScript.
+ */
+function executeBooleanSubtractionMany(lhs, cutters, options) {
+    const booleanExport = booleanSubtractionMany;
+    if (typeof booleanExport !== "function") {
+        throw new Error("booleanSubtractionMany is not available in the loaded wasm package. Rebuild opengeometry wasm bindings.");
+    }
+    const kernelFunction = booleanExport;
+    const kernelOptions = serializeKernelOptions(options === null || options === void 0 ? void 0 : options.kernel);
+    const kernelResult = kernelFunction(resolveOperandSerialized(lhs), JSON.stringify(cutters.map(resolveOperandPayload)), kernelOptions);
+    return createBooleanResult(kernelResult, options);
+}
 /**
  * Normalizes mixed wrapper/raw operands, invokes the wasm boolean export, and
  * returns the renderable result wrapper.
  */
 function executeBoolean(exportName, lhs, rhs, options) {
-    var _a;
     const booleanExport = OGKernel[exportName];
     if (typeof booleanExport !== "function") {
         throw new Error(`${exportName} is not available in the loaded wasm package. Rebuild opengeometry wasm bindings.`);
@@ -7305,11 +7617,7 @@ function executeBoolean(exportName, lhs, rhs, options) {
     const kernelFunction = booleanExport;
     const kernelOptions = serializeKernelOptions(options === null || options === void 0 ? void 0 : options.kernel);
     const kernelResult = kernelFunction(resolveOperandSerialized(lhs), resolveOperandSerialized(rhs), kernelOptions);
-    const result = new BooleanResult(kernelResult, options);
-    if ((_a = options === null || options === void 0 ? void 0 : options.outline) !== null && _a !== void 0 ? _a : true) {
-        result.outline = true;
-    }
-    return result;
+    return createBooleanResult(kernelResult, options);
 }
 /**
  * Accepts wrapper objects, raw BRep data, or serialized JSON and normalizes
@@ -7330,6 +7638,19 @@ function resolveOperandSerialized(operand) {
     }
     return serializeBrepLike(operand);
 }
+/**
+ * Parses a boolean operand into a raw BRep payload so array-backed boolean
+ * calls can serialize a JSON array of BReps instead of a JSON array of strings.
+ */
+function resolveOperandPayload(operand) {
+    const serialized = resolveOperandSerialized(operand);
+    try {
+        return JSON.parse(serialized);
+    }
+    catch (_a) {
+        throw new Error("Boolean operands must resolve to valid serialized BRep JSON before array subtraction.");
+    }
+}
 /**
  * Accepts either a parsed BRep object or an already serialized JSON payload
  * and always returns the canonical serialized form expected by the wasm API.
@@ -7352,6 +7673,14 @@ function serializeKernelOptions(options) {
         merge_coplanar_faces: options.mergeCoplanarFaces,
     });
 }
+function createBooleanResult(kernelResult, options) {
+    var _a;
+    const result = new BooleanResult(kernelResult, options);
+    if ((_a = options === null || options === void 0 ? void 0 : options.outline) !== null && _a !== void 0 ? _a : true) {
+        result.outline = true;
+    }
+    return result;
+}
 /**
  * Builds a display-quality outline buffer from the rendered mesh and falls back
  * to the kernel-provided edges when the client-side extraction is empty.
@@ -7372,50 +7701,322 @@ function getRenderableOutlinePositions(geometry, fallbackSerialized) {
 /**
  * Executes a kernel-backed subtraction for a shape wrapper against another boolean operand.
  */
-function subtractShapeOperand(host, operand, options) {
-    return booleanSubtraction(host, operand, options);
+function subtractShapeOperand(host, operands, options) {
+    if (!Array.isArray(operands)) {
+        throw new Error("shape.subtract(...) now requires an operand array. Pass shape.subtract([operand], options) even for a single cutter.");
+    }
+    return executeBooleanSubtractionMany(host, operands, options);
 }
 
-var _Polygon_outlineMesh;
-class Polygon extends THREE.Mesh {
+var _Solid_outlineMesh;
+/**
+ * Generic renderable BRep-backed solid used for extrusion outputs and other
+ * kernel results that are not dedicated parametric shapes.
+ */
+class Solid extends THREE.Mesh {
     set color(color) {
         this.options.color = color;
-        if (this.material instanceof THREE.MeshBasicMaterial) {
+        if (this.material instanceof THREE.MeshStandardMaterial) {
             this.material.color.set(color);
         }
     }
     get color() {
         return this.options.color;
     }
-    // TODO: Make Options Optional
-    // constructor(vertices?: Vector3[]) // If no vertices are provided, it will be an empty polygon
     constructor(options) {
-        var _a, _b, _c, _d, _e;
+        var _a, _b;
         super();
         this.options = {
-            vertices: [],
-            holes: [],
+            brep: "{}",
             color: 0x00ff00,
             fatOutlines: false,
             outlineWidth: 1,
+            anchor: new Vector3(0, 0, 0),
             translation: new Vector3(0, 0, 0),
             rotation: new Vector3(0, 0, 0),
             scale: new Vector3(1, 1, 1),
         };
-        _Polygon_outlineMesh.set(this, null);
+        _Solid_outlineMesh.set(this, null);
         this._outlineEnabled = false;
         this._fatOutlines = false;
         this._outlineWidth = 1;
         this._outlineColor = 0x000000;
-        this.transformationMatrix = new THREE.Matrix4();
-        // private _placement: THREE.Vector3 = new THREE.Vector3(0, 0, 0);
-        // private _yaw: number = 0;
-        // Store local center offset to align outlines
-        // TODO: Can this be moved to Engine? It can increase performance | Needs to be used in other shapes too
-        this._geometryCenterOffset = new THREE.Vector3();
-        this.ogid = (_a = options === null || options === void 0 ? void 0 : options.ogid) !== null && _a !== void 0 ? _a : getUUID();
-        this.polygon = new OGPolygon(this.ogid);
-        this.options = Object.assign(Object.assign({}, this.options), options);
+        this.ogid = (_a = options.ogid) !== null && _a !== void 0 ? _a : getUUID();
+        this.options = Object.assign(Object.assign(Object.assign({}, this.options), options), { ogid: this.ogid, anchor: cloneVector(options.anchor, [0, 0, 0]), translation: cloneVector(options.translation, [0, 0, 0]), rotation: cloneVector(options.rotation, [0, 0, 0]), scale: cloneVector(options.scale, [1, 1, 1]) });
+        this._fatOutlines = (_b = this.options.fatOutlines) !== null && _b !== void 0 ? _b : false;
+        this._outlineWidth = sanitizeOutlineWidth(this.options.outlineWidth);
+        this.options.fatOutlines = this._fatOutlines;
+        this.options.outlineWidth = this._outlineWidth;
+        this.solid = createFreeformGeometry(this.options.brep, {
+            id: this.ogid,
+            placement: this.getPlacementTransform(),
+        });
+        this.generateGeometry();
+    }
+    /**
+     * Extrudes a face-like BRep source and wraps the result as a renderable solid.
+     *
+     * Prefer `polygon.extrude(height)` when the source is already a `Polygon`.
+     */
+    static extrude(source, height, options) {
+        return new Solid(Object.assign(Object.assign({}, options), { brep: extrudeBrepFace(source, height) }));
+    }
+    /**
+     * Returns the current placement values as cloned vectors.
+     */
+    getPlacement() {
+        return clonePlacement(this.getPlacementTransform());
+    }
+    /**
+     * Applies translation, rotation, and scale updates to the wrapped BRep.
+     */
+    setPlacement(placement) {
+        var _a, _b, _c;
+        this.options.translation = cloneVector((_a = placement.translation) !== null && _a !== void 0 ? _a : this.options.translation, [0, 0, 0]);
+        this.options.rotation = cloneVector((_b = placement.rotation) !== null && _b !== void 0 ? _b : this.options.rotation, [0, 0, 0]);
+        this.options.scale = cloneVector((_c = placement.scale) !== null && _c !== void 0 ? _c : this.options.scale, [1, 1, 1]);
+        this.solid.setPlacement(this.getPlacementTransform());
+        this.generateGeometry();
+    }
+    setTransform(translation, rotation, scale) {
+        this.setPlacement({
+            translation,
+            rotation,
+            scale,
+        });
+    }
+    setTranslation(translation) {
+        this.setPlacement({ translation });
+    }
+    setRotation(rotation) {
+        this.setPlacement({ rotation });
+    }
+    setScale(scale) {
+        this.setPlacement({ scale });
+    }
+    getAnchor() {
+        return this.getPlacementTransform().anchor.clone();
+    }
+    setAnchor(anchor) {
+        this.options.anchor = anchor.clone();
+        this.solid.setPlacement(this.getPlacementTransform());
+        this.generateGeometry();
+    }
+    /**
+     * Solid is always convertible back to the freeform editing wrapper.
+     */
+    canConvertToFreeform() {
+        return true;
+    }
+    /**
+     * Returns a freeform wrapper for direct editing of this solid's BRep.
+     */
+    toFreeform(id = this.ogid) {
+        if (!this.canConvertToFreeform()) {
+            throw new Error("This entity cannot be converted to freeform.");
+        }
+        return createFreeformGeometry(this.getLocalBrepSerialized(), {
+            id,
+            placement: this.getPlacementTransform(),
+        });
+    }
+    /**
+     * Returns the world-space serialized BRep payload for this solid.
+     */
+    getBrepSerialized() {
+        return this.solid.getBrepSerialized();
+    }
+    /**
+     * Returns the local-space serialized BRep payload for this solid.
+     */
+    getLocalBrepSerialized() {
+        return this.solid.getLocalBrepSerialized();
+    }
+    /**
+     * Returns the parsed world-space BRep object for this solid.
+     */
+    getBrepData() {
+        const brepSerialized = this.getBrepSerialized();
+        if (!brepSerialized) {
+            throw new Error("Brep data is not available for this solid.");
+        }
+        return JSON.parse(brepSerialized);
+    }
+    /**
+     * Subtracts one or more boolean operands from this solid.
+     *
+     * This is the main shape-level boolean workflow after operations like
+     * `polygon.extrude(height)` or `Solid.extrude(...)`.
+     */
+    subtract(operands, options) {
+        return subtractShapeOperand(this, operands, options);
+    }
+    /**
+     * Rebuilds the visible mesh and outline from the current freeform geometry.
+     */
+    generateGeometry() {
+        var _a;
+        const bufferData = this.solid.getGeometryBuffer();
+        this.writePositionsToGeometry(this.geometry, bufferData);
+        if (this.material instanceof THREE.MeshStandardMaterial) {
+            this.material.color.set(this.options.color);
+            this.material.transparent = true;
+            this.material.opacity = 0.6;
+        }
+        else {
+            if (Array.isArray(this.material)) {
+                this.material.forEach((material) => material.dispose());
+            }
+            else {
+                this.material.dispose();
+            }
+            this.material = new THREE.MeshStandardMaterial({
+                color: this.options.color,
+                transparent: true,
+                opacity: 0.6,
+            });
+        }
+        if (bufferData.length > 0) {
+            this.geometry.computeVertexNormals();
+            this.geometry.computeBoundingBox();
+            this.geometry.computeBoundingSphere();
+        }
+        else {
+            this.geometry.deleteAttribute("normal");
+            this.geometry.boundingBox = null;
+            this.geometry.boundingSphere = null;
+        }
+        if (!this._outlineEnabled) {
+            return;
+        }
+        const outlineData = this.solid.getOutlineGeometryBuffer();
+        if (!__classPrivateFieldGet(this, _Solid_outlineMesh, "f")) {
+            this.outline = true;
+            return;
+        }
+        if (__classPrivateFieldGet(this, _Solid_outlineMesh, "f") instanceof THREE.LineSegments) {
+            this.writePositionsToGeometry(__classPrivateFieldGet(this, _Solid_outlineMesh, "f").geometry, outlineData);
+            __classPrivateFieldGet(this, _Solid_outlineMesh, "f").geometry.computeBoundingBox();
+            __classPrivateFieldGet(this, _Solid_outlineMesh, "f").geometry.computeBoundingSphere();
+            return;
+        }
+        const fatGeometry = __classPrivateFieldGet(this, _Solid_outlineMesh, "f").geometry;
+        fatGeometry.setPositions(outlineData);
+        const fatOutline = __classPrivateFieldGet(this, _Solid_outlineMesh, "f");
+        (_a = fatOutline.computeLineDistances) === null || _a === void 0 ? void 0 : _a.call(fatOutline);
+    }
+    set outlineColor(color) {
+        this._outlineColor = color;
+        setShapeOutlineColor(__classPrivateFieldGet(this, _Solid_outlineMesh, "f"), color);
+    }
+    get outlineColor() {
+        return getShapeOutlineColor(__classPrivateFieldGet(this, _Solid_outlineMesh, "f"), this._outlineColor);
+    }
+    set outline(enable) {
+        this._outlineEnabled = enable;
+        this.clearOutlineMesh();
+        if (enable) {
+            __classPrivateFieldSet(this, _Solid_outlineMesh, createShapeOutlineMesh({
+                positions: this.solid.getOutlineGeometryBuffer(),
+                color: this._outlineColor,
+                fatOutlines: this._fatOutlines,
+                outlineWidth: this._outlineWidth,
+            }), "f");
+            this.add(__classPrivateFieldGet(this, _Solid_outlineMesh, "f"));
+        }
+    }
+    get outline() {
+        return this._outlineEnabled;
+    }
+    set fatOutlines(value) {
+        this._fatOutlines = value;
+        this.options.fatOutlines = value;
+        if (this._outlineEnabled) {
+            this.outline = true;
+        }
+    }
+    get fatOutlines() {
+        return this._fatOutlines;
+    }
+    set outlineWidth(value) {
+        this._outlineWidth = sanitizeOutlineWidth(value);
+        this.options.outlineWidth = this._outlineWidth;
+        if (this._outlineEnabled) {
+            this.outline = true;
+        }
+    }
+    get outlineWidth() {
+        return this._outlineWidth;
+    }
+    clearOutlineMesh() {
+        if (!__classPrivateFieldGet(this, _Solid_outlineMesh, "f")) {
+            return;
+        }
+        this.remove(__classPrivateFieldGet(this, _Solid_outlineMesh, "f"));
+        disposeShapeOutlineMesh(__classPrivateFieldGet(this, _Solid_outlineMesh, "f"));
+        __classPrivateFieldSet(this, _Solid_outlineMesh, null, "f");
+    }
+    getPlacementTransform() {
+        return toObjectTransformation$1({
+            anchor: cloneVector(this.options.anchor, [0, 0, 0]),
+            translation: cloneVector(this.options.translation, [0, 0, 0]),
+            rotation: cloneVector(this.options.rotation, [0, 0, 0]),
+            scale: cloneVector(this.options.scale, [1, 1, 1]),
+        });
+    }
+    writePositionsToGeometry(geometry, positions) {
+        const attribute = geometry.getAttribute("position");
+        if (!(attribute instanceof THREE.BufferAttribute) ||
+            attribute.itemSize !== 3 ||
+            attribute.count !== positions.length / 3) {
+            geometry.setAttribute("position", new THREE.Float32BufferAttribute(positions, 3));
+            return;
+        }
+        attribute.array.set(positions);
+        attribute.needsUpdate = true;
+    }
+}
+_Solid_outlineMesh = new WeakMap();
+function cloneVector(vector, fallback) {
+    var _a;
+    return (_a = vector === null || vector === void 0 ? void 0 : vector.clone()) !== null && _a !== void 0 ? _a : new Vector3(...fallback);
+}
+
+var _Polygon_outlineMesh;
+/**
+ * Planar polygon mesh with support for holes, booleans, and extrusion to `Solid`.
+ */
+class Polygon extends THREE.Mesh {
+    set color(color) {
+        this.options.color = color;
+        if (this.material instanceof THREE.MeshBasicMaterial) {
+            this.material.color.set(color);
+        }
+    }
+    get color() {
+        return this.options.color;
+    }
+    constructor(options) {
+        var _a, _b, _c, _d, _e;
+        super();
+        this.options = {
+            vertices: [],
+            holes: [],
+            color: 0x00ff00,
+            fatOutlines: false,
+            outlineWidth: 1,
+            translation: new Vector3(0, 0, 0),
+            rotation: new Vector3(0, 0, 0),
+            scale: new Vector3(1, 1, 1),
+        };
+        _Polygon_outlineMesh.set(this, null);
+        this._outlineEnabled = false;
+        this._fatOutlines = false;
+        this._outlineWidth = 1;
+        this._outlineColor = 0x000000;
+        this.ogid = (_a = options === null || options === void 0 ? void 0 : options.ogid) !== null && _a !== void 0 ? _a : getUUID();
+        this.polygon = new OGPolygon(this.ogid);
+        this.options = Object.assign(Object.assign({}, this.options), options);
         this.options.ogid = this.ogid;
         this.setConfig({
             vertices: this.options.vertices.map((vertex) => vertex.clone()),
@@ -7429,19 +8030,6 @@ class Polygon extends THREE.Mesh {
             rotation: (_d = this.options.rotation) === null || _d === void 0 ? void 0 : _d.clone(),
             scale: (_e = this.options.scale) === null || _e === void 0 ? void 0 : _e.clone(),
         });
-        // TODO: THIS MIGHT HELP WITH SHARING THE POSITION with KERNEL when something is changed
-        // const originalSet = this.position.set.bind(this.position);
-        // this.position.set = (x: number, y: number, z: number) => {
-        //   console.log(`Position set to (${x}, ${y}, ${z})`);
-        //   // your custom logic here (e.g., notify OpenGeometry)
-        //   return originalSet(x, y, z);
-        // };
-        // // Optional: Override copy if you're using .copy() too
-        // const originalCopy = this.position.copy.bind(this.position);
-        // this.position.copy = (v: THREE.Vector3) => {
-        //   console.log(`Position copied from ${v.x}, ${v.y}, ${v.z}`);
-        //   return originalCopy(v);
-        // };
     }
     validateOptions() {
         if (!this.options) {
@@ -7523,12 +8111,21 @@ class Polygon extends THREE.Mesh {
             scale: this.options.scale,
         });
     }
+    /**
+     * Returns the editing capability payload advertised by parametric wrappers.
+     */
     getEditCapabilities() {
         return createParametricEditCapabilities("polygon", "profile");
     }
+    /**
+     * Polygon always supports conversion into the freeform editing wrapper.
+     */
     canConvertToFreeform() {
         return true;
     }
+    /**
+     * Returns a freeform wrapper for direct BRep editing of this polygon.
+     */
     toFreeform(id = this.ogid) {
         if (!this.canConvertToFreeform()) {
             throw new Error("This entity cannot be converted to freeform.");
@@ -7538,62 +8135,8 @@ class Polygon extends THREE.Mesh {
             placement: this.getPlacement(),
         });
     }
-    // /**
-    //  * Sets the placement of the polygon in 3D space.
-    //  * @param x X-coordinate
-    //  * @param y Y-coordinate
-    //  * @param z Z-coordinate
-    //  */
-    // placement(x: number, y: number, z: number) {
-    //   this._placement.set(x, y, z);
-    //   // Do the recalculation of position based on the placement
-    //   const clonedObject = this.clone();
-    //   clonedObject.rotation.set(0, 0, 0);
-    //   clonedObject.geometry.computeBoundingBox();
-    //   if (!clonedObject.geometry.boundingBox) return;
-    //   const center = new THREE.Vector3();
-    //   clonedObject.geometry.boundingBox.getCenter(center);
-    //   const min = clonedObject.geometry.boundingBox.min;
-    //   this.position.set(
-    //     center.x + this._placement.x - min.x,
-    //     // this._placement.y,
-    //     0.01, // Set Y to a small value to avoid z-fighting
-    //     center.z + this._placement.z - min.z
-    //   );
-    // }
-    // positionToPlacement() {
-    //   const clonedObject = this.clone();
-    //   clonedObject.rotation.set(0, 0, 0);
-    //   clonedObject.geometry.computeBoundingBox();
-    //   if (!clonedObject.geometry.boundingBox) return;
-    //   const min = clonedObject.geometry.boundingBox.min;
-    //   this._placement.set(
-    //     this.position.x + min.x,
-    //     this.position.y + min.y,
-    //     this.position.z + min.z
-    //   );
-    //   // console.log("Placement set to:", this._placement.x, this._placement.y, this._placement.z);
-    // }
-    // /**
-    //  * Rotates the polygon around the Y-axis.
-    //  * @param angle Rotation angle in Degrees
-    //  */
-    // set yaw(angle: number) {
-    //   this._yaw = angle;
-    //   this.rotation.set(0, 0, 0);
-    //   this.rotation.y = THREE.MathUtils.degToRad(this._yaw);
-    // }
-    // get yaw() {
-    //   return this._yaw;
-    // }
     cleanGeometry() {
-        this.geometry.dispose();
-        if (Array.isArray(this.material)) {
-            this.material.forEach(mat => mat.dispose());
-        }
-        else {
-            this.material.dispose();
-        }
+        this.disposeResources();
     }
     generateGeometry() {
         var _a;
@@ -7643,24 +8186,6 @@ class Polygon extends THREE.Mesh {
         fatGeometry.setPositions(outlineData);
         const fatOutline = __classPrivateFieldGet(this, _Polygon_outlineMesh, "f");
         (_a = fatOutline.computeLineDistances) === null || _a === void 0 ? void 0 : _a.call(fatOutline);
-        // this.geometry.computeBoundingBox();
-        // const originalCenter = new THREE.Vector3();
-        // this.geometry.boundingBox?.getCenter(originalCenter);
-        // console.log("Original Center:", originalCenter.x, originalCenter.y, originalCenter.z);
-        // this.geometry.center();
-        // this.geometry.computeBoundingBox();
-        // const newCenter = new THREE.Vector3();
-        // this.geometry.boundingBox?.getCenter(newCenter);
-        // console.log("New Center after centering:", newCenter.x, newCenter.y, newCenter.z);
-        // if (!this.geometry.boundingBox) return;
-        // const min = this.geometry.boundingBox.min;
-        // // console.log("Position before centering:", this.position.x, this.position.y, this.position.z);
-        // console.log("Bounding Box Min:", min.x, min.y, min.z);
-        // this.position.set(-min.x, 0, -min.z);
-        // if (this._placement) {
-        //   this.placement(this._placement.x, this._placement.y, this._placement.z);
-        // }
-        // console.log("New Position after centering:", this.position.x, this.position.y, this.position.z);
     }
     addVertices(vertices) {
         if (!this.polygon)
@@ -7669,59 +8194,6 @@ class Polygon extends THREE.Mesh {
             vertices: vertices.map((vertex) => vertex.clone()),
         });
     }
-    saveTransformationToBREP() {
-        if (!this.polygon)
-            return;
-    }
-    // /**
-    //  * Rotates the object around the Y-axis.
-    //  * @param angle Rotation angle in Degrees
-    //  * @returns 
-    //  * @summary If rotation methods from threejs is used, it will rotate around the first vertex which might not be desired.
-    //  */
-    // rotateOnYAxis(angle: number) {
-    //   if (!this.polygon) return;
-    // }
-    // resetVertices() {
-    //   if (!this.polygon) return;
-    //   this.layerVertices = [];
-    //   this.geometry.dispose();
-    //   this.polygon?.clear_vertices();
-    //   this.isTriangulated = false;
-    // }
-    // addVertex(threeVertex: Vector3) {
-    //   if (this.isTriangulated) {
-    //     this.layerVertices = [];
-    //     this.geometry.dispose();
-    //     this.polygon?.clear_vertices();
-    //     this.isTriangulated = false;
-    //     for (const vertex of this.layerBackVertices) {
-    //       this.layerVertices.push(vertex.clone());
-    //     }
-    //   };
-    //   const backupVertex = new Vector3(
-    //     parseFloat(threeVertex.x.toFixed(2)),
-    //     0,
-    //     parseFloat(threeVertex.z.toFixed(2))
-    //   );
-    //   this.layerBackVertices.push(backupVertex);
-    //   const vertex = new Vector3(
-    //     parseFloat(threeVertex.x.toFixed(2)),
-    //     // when doing the parse operation getting -0 instead of 0
-    //     0,
-    //     parseFloat(threeVertex.z.toFixed(2))
-    //   );
-    //   this.layerVertices.push(vertex);
-    //   if (this.layerVertices.length > 3) {
-    //     this.polygon?.add_vertices(this.layerVertices);
-    //     const bufFlush = this.polygon?.triangulate();
-    //     if (!bufFlush) {
-    //       return;
-    //     }
-    //     this.addFlushBufferToScene(bufFlush);
-    //     this.isTriangulated = true;
-    //   }
-    // }
     addHole(holeVertices) {
         var _a, _b;
         if (!this.polygon)
@@ -7734,29 +8206,32 @@ class Polygon extends THREE.Mesh {
             holes: ((_b = this.options.holes) !== null && _b !== void 0 ? _b : []).map((hole) => hole.map((vertex) => vertex.clone())),
         });
     }
-    // extrude(height: number) {
-    //   if (!this.polygon) return;
-    //   const extruded_buff = this.polygon.extrude_by_height(height);
-    //   console.log(extruded_buff);
-    //   this.generateExtrudedGeometry(extruded_buff);
-    // }
-    // generateExtrudedGeometry(extruded_buff: string) {
-    //   // THIS WORKS
-    //   const flushBuffer = JSON.parse(extruded_buff);
-    //   console.log(flushBuffer);
-    //   const geometry = new THREE.BufferGeometry();
-    //   geometry.setAttribute("position", new THREE.BufferAttribute(new Float32Array(flushBuffer), 3));
-    //   geometry.computeVertexNormals();
-    //   this.geometry = geometry;
-    //   const material = new THREE.MeshStandardMaterial({
-    //     color: 0x00ff00, 
-    //     side: THREE.FrontSide, 
-    //     transparent: true, 
-    //     opacity: 0.5, 
-    //     // wireframe: true
-    //   });
-    //   this.material = material;
-    // }
+    /**
+     * Builds a kernel-backed `Solid` by extruding this polygon face by `height`.
+     *
+     * This is the recommended public path when a browser CAD or AEC workflow
+     * starts from a planar profile and needs a boolean-ready solid.
+     */
+    extrude(height) {
+        const config = this.getConfig();
+        const placement = this.getPlacement();
+        const solid = new Solid({
+            brep: extrudeBrepFace(this.polygon.get_local_brep_serialized(), height),
+            color: config.color,
+            fatOutlines: config.fatOutlines,
+            outlineWidth: config.outlineWidth,
+            anchor: this.getAnchor(),
+            translation: placement.translation.clone(),
+            rotation: placement.rotation.clone(),
+            scale: placement.scale.clone(),
+        });
+        solid.outline = this.outline;
+        solid.outlineColor = this.outlineColor;
+        return solid;
+    }
+    /**
+     * Returns the serialized BRep payload for this polygon.
+     */
     getBrepData() {
         if (!this.polygon)
             return null;
@@ -7764,10 +8239,10 @@ class Polygon extends THREE.Mesh {
         return brepData;
     }
     /**
-     * Subtracts another boolean operand from this polygon.
+     * Subtracts one or more boolean operands from this polygon.
      */
-    subtract(operand, options) {
-        return subtractShapeOperand(this, operand, options);
+    subtract(operands, options) {
+        return subtractShapeOperand(this, operands, options);
     }
     set outlineColor(color) {
         this._outlineColor = color;
@@ -7776,7 +8251,6 @@ class Polygon extends THREE.Mesh {
     get outlineColor() {
         return getShapeOutlineColor(__classPrivateFieldGet(this, _Polygon_outlineMesh, "f"), this._outlineColor);
     }
-    // TODO: Do we need a separate method for Hole Outlines?
     set outline(enable) {
         this._outlineEnabled = enable;
         this.clearOutlineMesh();
@@ -7788,8 +8262,6 @@ class Polygon extends THREE.Mesh {
                 fatOutlines: this._fatOutlines,
                 outlineWidth: this._outlineWidth,
             }), "f");
-            // this.#outlineMesh.geometry.center();
-            // this.#outlineMesh.applyMatrix4(this.transformationMatrix);
             this.add(__classPrivateFieldGet(this, _Polygon_outlineMesh, "f"));
         }
     }
@@ -7816,20 +8288,8 @@ class Polygon extends THREE.Mesh {
     get outlineWidth() {
         return this._outlineWidth;
     }
-    // bTree() {
-    //   if (!this.polygon) return;
-    //   const bTree = this.polygon.binary_tree();
-    //   const parsedData = JSON.parse(bTree);
-    //   console.log(parsedData);
-    // }
     disposeGeometryMaterial() {
-        if (this.geometry) {
-            this.geometry.dispose();
-        }
-        if (this.material instanceof THREE.Material) {
-            this.material.dispose();
-        }
-        this.clearOutlineMesh();
+        this.disposeResources();
     }
     clearOutlineMesh() {
         if (!__classPrivateFieldGet(this, _Polygon_outlineMesh, "f")) {
@@ -7840,20 +8300,7 @@ class Polygon extends THREE.Mesh {
         __classPrivateFieldSet(this, _Polygon_outlineMesh, null, "f");
     }
     dispose() {
-        // // console.log("Disposing OG - Polygon");
-        // this.geometry.dispose();
-        // if (this.material instanceof THREE.Material) {
-        //   this.material.dispose();
-        // }
-        // if (this.#outlineMesh) {
-        //   this.#outlineMesh.geometry.dispose();
-        //   if (this.#outlineMesh.material instanceof THREE.Material) {
-        //     this.#outlineMesh.material.dispose();
-        //   }
-        // }
-        // this.polygon = null;
-        // this.layerVertices = [];
-        // this.layerBackVertices = [];
+        this.disposeResources();
     }
     writePositionsToGeometry(geometry, positions) {
         const existing = geometry.getAttribute("position");
@@ -7867,10 +8314,25 @@ class Polygon extends THREE.Mesh {
         array.set(positions);
         existing.needsUpdate = true;
     }
+    disposeResources() {
+        if (this.geometry) {
+            this.geometry.dispose();
+        }
+        if (Array.isArray(this.material)) {
+            this.material.forEach((material) => material.dispose());
+        }
+        else if (this.material instanceof THREE.Material) {
+            this.material.dispose();
+        }
+        this.clearOutlineMesh();
+    }
 }
 _Polygon_outlineMesh = new WeakMap();
 
 var _Cylinder_outlineMesh;
+/**
+ * Cylinder wrapper backed by the kernel cylindrical primitive.
+ */
 class Cylinder extends THREE.Mesh {
     set radius(value) {
         this.setConfig({ radius: value });
@@ -8072,10 +8534,10 @@ class Cylinder extends THREE.Mesh {
         return JSON.parse(brepData);
     }
     /**
-     * Subtracts another boolean operand, such as an Opening, from this cylinder.
+     * Subtracts one or more boolean operands, such as Opening volumes, from this cylinder.
      */
-    subtract(operand, options) {
-        return subtractShapeOperand(this, operand, options);
+    subtract(operands, options) {
+        return subtractShapeOperand(this, operands, options);
     }
     set outline(enable) {
         this._outlineEnabled = enable;
@@ -8141,6 +8603,9 @@ class Cylinder extends THREE.Mesh {
 _Cylinder_outlineMesh = new WeakMap();
 
 var _Cuboid_outlineMesh;
+/**
+ * Box-shaped solid wrapper backed by the kernel cuboid primitive.
+ */
 class Cuboid extends THREE.Mesh {
     set width(value) {
         this.setConfig({ width: value });
@@ -8280,10 +8745,10 @@ class Cuboid extends THREE.Mesh {
         return JSON.parse(brepData);
     }
     /**
-     * Subtracts another boolean operand, such as an Opening, from this cuboid.
+     * Subtracts one or more boolean operands, such as Opening volumes, from this cuboid.
      */
-    subtract(operand, options) {
-        return subtractShapeOperand(this, operand, options);
+    subtract(operands, options) {
+        return subtractShapeOperand(this, operands, options);
     }
     set outline(enable) {
         this._outlineEnabled = enable;
@@ -8395,6 +8860,9 @@ class Cuboid extends THREE.Mesh {
 _Cuboid_outlineMesh = new WeakMap();
 
 var _Opening_outlineMesh;
+/**
+ * Opening wrapper used as a subtractive solid in architectural workflows.
+ */
 class Opening extends THREE.Mesh {
     set width(value) {
         this.setConfig({ width: value });
@@ -8602,16 +9070,19 @@ class Opening extends THREE.Mesh {
         return JSON.parse(brepData);
     }
     /**
-     * Subtracts another boolean operand from this opening volume.
+     * Subtracts one or more boolean operands from this opening volume.
      */
-    subtract(operand, options) {
-        return subtractShapeOperand(this, operand, options);
+    subtract(operands, options) {
+        return subtractShapeOperand(this, operands, options);
     }
     /**
      * Uses this opening volume to cut a host shape.
+     *
+     * Prefer this helper for wall, slab, and other host-cutting workflows in
+     * browser-based AEC/BIM tools.
      */
     subtractFrom(host, options) {
-        return subtractShapeOperand(host, this, options);
+        return booleanSubtraction(host, this, options);
     }
     set outline(enable) {
         this._outlineEnabled = enable;
@@ -8681,6 +9152,9 @@ _Opening_outlineMesh = new WeakMap();
 
 var _Sphere_outlineMesh;
 /* eslint-enable no-unused-vars */
+/**
+ * Sphere wrapper backed by the kernel sphere primitive.
+ */
 class Sphere extends THREE.Mesh {
     set radius(value) {
         this.setConfig({ radius: value });
@@ -8882,10 +9356,10 @@ class Sphere extends THREE.Mesh {
         return JSON.parse(brepData);
     }
     /**
-     * Subtracts another boolean operand, such as an Opening, from this sphere.
+     * Subtracts one or more boolean operands, such as Opening volumes, from this sphere.
      */
-    subtract(operand, options) {
-        return subtractShapeOperand(this, operand, options);
+    subtract(operands, options) {
+        return subtractShapeOperand(this, operands, options);
     }
     set outline(enable) {
         this._outlineEnabled = enable;
@@ -8954,6 +9428,9 @@ class Sphere extends THREE.Mesh {
 _Sphere_outlineMesh = new WeakMap();
 
 var _Wedge_outlineMesh;
+/**
+ * Wedge wrapper backed by the kernel wedge primitive.
+ */
 class Wedge extends THREE.Mesh {
     set color(color) {
         this.options.color = color;
@@ -9147,10 +9624,10 @@ class Wedge extends THREE.Mesh {
         return JSON.parse(brepData);
     }
     /**
-     * Subtracts another boolean operand, such as an Opening, from this wedge.
+     * Subtracts one or more boolean operands, such as Opening volumes, from this wedge.
      */
-    subtract(operand, options) {
-        return subtractShapeOperand(this, operand, options);
+    subtract(operands, options) {
+        return subtractShapeOperand(this, operands, options);
     }
     set outline(enable) {
         this._outlineEnabled = enable;
@@ -9220,6 +9697,9 @@ _Wedge_outlineMesh = new WeakMap();
 
 var _Sweep_outlineMesh;
 /* eslint-enable no-unused-vars */
+/**
+ * Sweep wrapper backed by the kernel sweep primitive.
+ */
 class Sweep extends THREE.Mesh {
     set color(color) {
         this.options.color = color;
@@ -9443,10 +9923,10 @@ class Sweep extends THREE.Mesh {
         return JSON.parse(brepData);
     }
     /**
-     * Subtracts another boolean operand, such as an Opening, from this sweep.
+     * Subtracts one or more boolean operands, such as Opening volumes, from this sweep.
      */
-    subtract(operand, options) {
-        return subtractShapeOperand(this, operand, options);
+    subtract(operands, options) {
+        return subtractShapeOperand(this, operands, options);
     }
     set outline(enable) {
         this._outlineEnabled = enable;
@@ -9867,11 +10347,7 @@ function createWallFromOffsetsExample(scene) {
  * Builds a complete operand/result scene group for a boolean example page.
  */
 function createBooleanExample(operation, options) {
-    const preset = options.mode === "solid"
-        ? createSolidPreset(operation, options)
-        : options.mode === "polygon"
-            ? createPolygonPreset(operation, options)
-            : createExtrudedPreset(operation, options);
+    const preset = createPreset(operation, options);
     const execute = getBooleanExecutor(operation);
     const result = execute(preset.lhsOperand, preset.rhsOperand, options);
     const group = new THREE.Group();
@@ -9887,6 +10363,16 @@ function createBooleanExample(operation, options) {
         description: preset.description,
     };
 }
+function createPreset(operation, options) {
+    switch (options.mode) {
+        case "solid":
+            return createSolidPreset(operation, options);
+        case "polygon":
+            return createPolygonPreset(operation, options);
+        case "extruded":
+            return createExtrudedPreset(operation, options);
+    }
+}
 /**
  * Builds the solid-operand preset used by the example pages.
  */
@@ -9972,63 +10458,47 @@ function createPolygonPreset(operation, options) {
     };
 }
 /**
- * Builds the straight-sweep solid preset used to demonstrate extruded booleans.
+ * Builds an extrusion-first preset that exercises polygon.extrude(height) and
+ * reuses the standard solid boolean pipeline.
  */
 function createExtrudedPreset(operation, options) {
     var _a, _b, _c, _d, _e, _f;
     const outlineWidth = (_a = options.outlineWidth) !== null && _a !== void 0 ? _a : 3;
     const extrudedOffset = (_b = options.extrudedOffset) !== null && _b !== void 0 ? _b : new Vector3(0.0, 0.0, 0.0);
-    const path = [
-        new Vector3(0.0, 0.0, 0.0),
-        new Vector3(0.0, 1.6, 0.0),
-    ];
-    const lhsProfile = [
-        new Vector3(-2, 0.0, -0.65),
-        new Vector3(2.1, 0.0, -0.65),
-        new Vector3(1.75, 0.0, 0.7),
-        new Vector3(-1.55, 0.0, 0.7),
-    ];
-    const rhsProfile = operation === "subtraction"
-        ? [
-            new Vector3(-0.42, 0.0, -0.24),
-            new Vector3(0.42, 0.0, -0.24),
-            new Vector3(0.42, 0.0, 0.24),
-            new Vector3(-0.42, 0.0, 0.24),
-        ]
-        : [
-            new Vector3(-0.8, 0.0, -0.42),
-            new Vector3(0.72, 0.0, -0.42),
-            new Vector3(0.72, 0.0, 0.42),
-            new Vector3(-0.8, 0.0, 0.42),
-        ];
-    const lhs = new Sweep({
-        path,
-        profile: lhsProfile,
+    const wallProfile = new Polygon({
+        vertices: [
+            new Vector3(-2.2, 0.0, -0.18),
+            new Vector3(2.2, 0.0, -0.18),
+            new Vector3(2.2, 0.0, 0.18),
+            new Vector3(-2.2, 0.0, 0.18),
+        ],
         color: 0x60a5fa,
-        capStart: true,
-        capEnd: true,
         fatOutlines: (_c = options.fatOutlines) !== null && _c !== void 0 ? _c : true,
         outlineWidth,
     });
-    const rhs = new Sweep({
-        path: path.map((point) => point.clone()),
-        profile: rhsProfile,
+    const openingProfile = new Polygon({
+        vertices: [
+            new Vector3(-0.7, 0.0, -0.34),
+            new Vector3(0.9, 0.0, -0.34),
+            new Vector3(0.9, 0.0, 0.34),
+            new Vector3(-0.7, 0.0, 0.34),
+        ],
         color: 0xf97316,
-        capStart: true,
-        capEnd: true,
-        translation: extrudedOffset.clone(),
         fatOutlines: (_d = options.fatOutlines) !== null && _d !== void 0 ? _d : true,
         outlineWidth,
     });
-    lhs.outline = (_e = options.outline) !== null && _e !== void 0 ? _e : true;
-    rhs.outline = (_f = options.outline) !== null && _f !== void 0 ? _f : true;
+    const wall = wallProfile.extrude(2.8);
+    const opening = openingProfile.extrude(operation === "intersection" ? 1.45 : 1.35);
+    opening.setTranslation(new Vector3(extrudedOffset.x, 0.85, extrudedOffset.z));
+    wall.outline = (_e = options.outline) !== null && _e !== void 0 ? _e : true;
+    opening.outline = (_f = options.outline) !== null && _f !== void 0 ? _f : true;
     return {
-        title: `${capitalize(operation)} Extruded Solids`,
-        description: "Two capped straight sweeps demonstrate boolean operations on extruded solid profiles.",
-        lhsOperand: lhs,
-        rhsOperand: rhs,
-        lhsVisual: lhs,
-        rhsVisual: rhs,
+        title: `${capitalize(operation)} Extruded Solid`,
+        description: "Two polygon.extrude(height) solids overlap to demonstrate renderable BRep booleans.",
+        lhsOperand: wall,
+        rhsOperand: opening,
+        lhsVisual: wall,
+        rhsVisual: opening,
     };
 }
 /**
@@ -10168,6 +10638,9 @@ function createEditorModesExample(scene) {
     };
 }
 
+/**
+ * Shared runtime entrypoint used to initialize the OpenGeometry wasm module.
+ */
 class OpenGeometry {
     get enableDebug() {
         return this._enableDebug;
@@ -10191,23 +10664,18 @@ class OpenGeometry {
         this._enableDebug = false;
     }
     /**
-     * Asynchronously creates and initializes an instance of OpenGeometry.
+     * Asynchronously initializes the OpenGeometry wasm runtime and returns a
+     * cached singleton instance on subsequent calls.
      *
-     * This factory method sets up the OpenGeometry engine by linking it with the
-     * rendering context and the WebAssembly module. It ensures all required
-     * options are provided and prepares the instance for 3D geometry operations.
+     * Call this before constructing `Vector3` or any kernel-backed wrapper.
      *
      * @param options - Configuration object for initializing OpenGeometry.
      * @returns A promise that resolves to a fully initialized OpenGeometry instance.
-     * @throws If any of the required options (`container`, `scene`, or `camera`) are missing.
      *
      * @example
      * ```ts
-     * const openGeometry = await OpenGeometry.create({
-     *   container: document.getElementById('myContainer')!,
-     *   scene: threeScene,
-     *   camera: threeCamera,
-     *   wasmURL: '/assets/opengeometry.wasm'
+     * await OpenGeometry.create({
+     *   wasmURL: "/opengeometry_bg.wasm",
      * });
      * ```
      */
@@ -10234,5 +10702,5 @@ class OpenGeometry {
 OpenGeometry.version = OPEN_GEOMETRY_THREE_VERSION;
 OpenGeometry.instance = null;
 
-export { Arc, BooleanResult, Cuboid, Curve, Cylinder, FreeformEditor, FreeformGeometry, Line, OGSceneManager, OpenGeometry, Opening, Polygon, Polyline, Rectangle, Sphere, SpotLabel, Sweep, Vector3, Wedge, booleanIntersection, booleanSubtraction, booleanUnion, clonePlacement, createBooleanExample, createEditorModesExample, createFreeformEditor, createFreeformGeometry, createOffsetExample, createParametricEditCapabilities, createPrimitivesExample, createShapesExample, createSweepExample, createWallFromOffsetsExample, toObjectTransformation$1 as toObjectTransformation };
+export { Arc, BooleanResult, Cuboid, Curve, Cylinder, FreeformEditor, FreeformGeometry, Line, OGSceneManager, OpenGeometry, Opening, Polygon, Polyline, Rectangle, Solid, Sphere, SpotLabel, Sweep, Vector3, Wedge, booleanIntersection, booleanSubtraction, booleanUnion, clonePlacement, createBooleanExample, createEditorModesExample, createFreeformEditor, createFreeformGeometry, createOffsetExample, createParametricEditCapabilities, createPrimitivesExample, createShapesExample, createSweepExample, createWallFromOffsetsExample, executeBooleanSubtractionMany, extrudeBrepFace, toObjectTransformation$1 as toObjectTransformation };
 //# sourceMappingURL=index.js.map