opengeometry 2.0.1 → 2.0.3

package/index.js

@@ -3,9 +3,9 @@ import * as THREE from 'three';
 import { Line2 } from 'three/examples/jsm/lines/Line2.js';
 import { LineMaterial } from 'three/examples/jsm/lines/LineMaterial.js';
 import { LineGeometry } from 'three/examples/jsm/lines/LineGeometry.js';
-import { toCreasedNormals } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
 import { LineSegments2 } from 'three/examples/jsm/lines/LineSegments2.js';
 import { LineSegmentsGeometry } from 'three/examples/jsm/lines/LineSegmentsGeometry.js';
+import { toCreasedNormals } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
 
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
@@ -138,16 +138,16 @@ function passStringToWasm0(arg, malloc, realloc) {
   WASM_VECTOR_LEN = offset;
   return ptr;
 }
-function takeFromExternrefTable0(idx) {
-  const value = wasm.__wbindgen_export_2.get(idx);
-  wasm.__externref_table_dealloc(idx);
-  return value;
-}
 function _assertClass(instance, klass) {
   if (!(instance instanceof klass)) {
     throw new Error(`expected instance of ${klass.name}`);
   }
 }
+function takeFromExternrefTable0(idx) {
+  const value = wasm.__wbindgen_export_2.get(idx);
+  wasm.__externref_table_dealloc(idx);
+  return value;
+}
 let cachedFloat64ArrayMemory0 = null;
 function getFloat64ArrayMemory0() {
   if (cachedFloat64ArrayMemory0 === null || cachedFloat64ArrayMemory0.byteLength === 0) {
@@ -178,34 +178,6 @@ function passArrayJsValueToWasm0(array, malloc) {
 function isLikeNone(x) {
   return x === undefined || x === null;
 }
-/**
- * @param {string} local_brep_serialized
- * @param {number} face_id
- * @param {number} distance
- * @returns {string}
- */
-function extrudeBrepFace(local_brep_serialized, face_id, distance) {
-  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, face_id, distance);
-    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 union.
  * @param {string} lhs_brep_serialized
@@ -268,6 +240,33 @@ function booleanSubtraction$1(lhs_brep_serialized, rhs_brep_serialized, options_
   }
   return OGBooleanResult.__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);
+  }
+}
 function getArrayJsValueFromWasm0(ptr, len) {
   ptr = ptr >>> 0;
   const mem = getDataViewMemory0();
@@ -2257,6 +2256,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}
    */
@@ -2272,6 +2289,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}
    */
@@ -5655,7 +5690,7 @@ var OGKernel = /*#__PURE__*/Object.freeze({
     booleanSubtraction: booleanSubtraction$1,
     booleanUnion: booleanUnion$1,
     default: __wbg_init,
-    extrudeBrepFace: extrudeBrepFace,
+    extrudeBrepFace: extrudeBrepFace$1,
     initSync: initSync
 });
 
@@ -5677,7 +5712,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:
@@ -5741,6 +5779,9 @@ 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",
@@ -5751,13 +5792,20 @@ function createParametricEditCapabilities(entityType, editFamily) {
         canConvertToFreeform: true,
     };
 }
-function clonePlacement$1(placement) {
+/**
+ * Normalizes optional placement fields into concrete vectors.
+ */
+function clonePlacement(placement) {
     return {
         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 {
@@ -5775,7 +5823,7 @@ function toObjectTransformation$1(placement) {
     };
 }
 
-function parseJson$2(payload) {
+function parseJson$1(payload) {
     return JSON.parse(payload);
 }
 function toVector3$1(value) {
@@ -5850,7 +5898,7 @@ function normalizeFreeformCapabilities(raw) {
     };
 }
 function parseEditResult(payload) {
-    const result = parseJson$2(payload);
+    const result = parseJson$1(payload);
     return Object.assign(Object.assign({}, result), { placement: normalizePlacement$1(result.placement) });
 }
 function serializeOptions(options) {
@@ -5863,74 +5911,137 @@ 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$2(this.editor.getTopologyRenderData(this.geometry.getKernelGeometry())));
+        return normalizeTopologyRenderData(parseJson$1(this.editor.getTopologyRenderData(this.geometry.getKernelGeometry())));
     }
+    /**
+     * Returns semantic and topological information for a face id.
+     */
     getFaceInfo(faceId) {
-        return normalizeFaceInfo(parseJson$2(this.editor.getFaceInfo(this.geometry.getKernelGeometry(), 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$2(this.editor.getEdgeInfo(this.geometry.getKernelGeometry(), 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$2(this.editor.getVertexInfo(this.geometry.getKernelGeometry(), 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$2(this.editor.getEditCapabilities(this.geometry.getKernelGeometry())));
+        return normalizeFreeformCapabilities(parseJson$1(this.editor.getEditCapabilities(this.geometry.getKernelGeometry())));
     }
+    /**
+     * Returns edit capabilities scoped to a single face.
+     */
     getFaceEditCapabilities(faceId) {
-        return normalizeFeatureCapabilities(parseJson$2(this.editor.getFaceEditCapabilities(this.geometry.getKernelGeometry(), 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$2(this.editor.getEdgeEditCapabilities(this.geometry.getKernelGeometry(), 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$2(this.editor.getVertexEditCapabilities(this.geometry.getKernelGeometry(), 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);
 }
 
-function parseJson$1(payload) {
+function parseJson(payload) {
     return JSON.parse(payload);
 }
 function toVector3(value) {
@@ -5971,7 +6082,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) {
@@ -5982,56 +6093,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$1(this.geometry.getPlacementSerialized()));
+        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);
     }
@@ -6040,6 +6214,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()}`;
@@ -6158,7 +6336,7 @@ class Line extends THREE.Line {
         this.setPlacement({ scale });
     }
     getPlacement() {
-        return clonePlacement$1({
+        return clonePlacement({
             translation: this.options.translation,
             rotation: this.options.rotation,
             scale: this.options.scale,
@@ -6275,6 +6453,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;
@@ -6378,7 +6559,7 @@ class Polyline extends THREE.Line {
         this.setPlacement({ scale });
     }
     getPlacement() {
-        return clonePlacement$1({
+        return clonePlacement({
             translation: this.options.translation,
             rotation: this.options.rotation,
             scale: this.options.scale,
@@ -6502,6 +6683,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;
@@ -6607,7 +6791,7 @@ class Arc extends THREE.Line {
         return this.options;
     }
     getPlacement() {
-        return clonePlacement$1({
+        return clonePlacement({
             translation: this.options.translation,
             rotation: this.options.rotation,
             scale: this.options.scale,
@@ -6709,6 +6893,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;
@@ -6828,7 +7015,7 @@ class Rectangle extends THREE.Line {
         return this.options;
     }
     getPlacement() {
-        return clonePlacement$1({
+        return clonePlacement({
             translation: this.options.translation,
             rotation: this.options.rotation,
             scale: this.options.scale,
@@ -6944,6 +7131,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;
@@ -7029,7 +7219,7 @@ class Curve extends THREE.Line {
         this.setPlacement({ scale });
     }
     getPlacement() {
-        return clonePlacement$1({
+        return clonePlacement({
             translation: this.options.translation,
             rotation: this.options.rotation,
             scale: this.options.scale,
@@ -7104,12 +7294,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();
@@ -7128,6 +7324,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;
@@ -7139,6 +7338,9 @@ function disposeShapeOutlineMesh(mesh) {
     }
     mesh.material.dispose();
 }
+/**
+ * Updates the color of an existing outline mesh in place.
+ */
 function setShapeOutlineColor(mesh, color) {
     if (!mesh) {
         return;
@@ -7151,6 +7353,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;
@@ -7164,6 +7369,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;
@@ -7398,158 +7639,162 @@ function getRenderableOutlinePositions(geometry, fallbackSerialized) {
     return JSON.parse(fallbackSerialized);
 }
 
-var _ExtrudedShape_outlineMesh;
-function parseJson(payload) {
-    return JSON.parse(payload);
-}
-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);
-}
-function clonePlacement(placement) {
-    return {
-        anchor: cloneVector(placement === null || placement === void 0 ? void 0 : placement.anchor, [0, 0, 0]),
-        translation: cloneVector(placement === null || placement === void 0 ? void 0 : placement.translation, [0, 0, 0]),
-        rotation: cloneVector(placement === null || placement === void 0 ? void 0 : placement.rotation, [0, 0, 0]),
-        scale: cloneVector(placement === null || placement === void 0 ? void 0 : placement.scale, [1, 1, 1]),
-    };
+/**
+ * Executes a kernel-backed subtraction for a shape wrapper against another boolean operand.
+ */
+function subtractShapeOperand(host, operand, options) {
+    return booleanSubtraction(host, operand, options);
 }
-class ExtrudedShape extends THREE.Mesh {
-    constructor(localBrepSerialized, options) {
-        var _a, _b, _c, _d, _e;
-        super();
-        _ExtrudedShape_outlineMesh.set(this, null);
-        this._outlineEnabled = false;
-        this._fatOutlines = false;
-        this._outlineWidth = 1;
-        this._outlineColor = 0x000000;
-        this._color = 0x2563eb;
-        this.ogid = (_a = options === null || options === void 0 ? void 0 : options.ogid) !== null && _a !== void 0 ? _a : getUUID();
-        this._color = (_b = options === null || options === void 0 ? void 0 : options.color) !== null && _b !== void 0 ? _b : this._color;
-        this._fatOutlines = (_c = options === null || options === void 0 ? void 0 : options.fatOutlines) !== null && _c !== void 0 ? _c : false;
-        this._outlineWidth = sanitizeOutlineWidth(options === null || options === void 0 ? void 0 : options.outlineWidth);
-        this._outlineColor = (_d = options === null || options === void 0 ? void 0 : options.outlineColor) !== null && _d !== void 0 ? _d : this._outlineColor;
-        this.freeform = createFreeformGeometry(localBrepSerialized, {
-            id: this.ogid,
-            placement: clonePlacement(options === null || options === void 0 ? void 0 : options.placement),
-        });
-        this.generateGeometry();
-        if ((_e = options === null || options === void 0 ? void 0 : options.outline) !== null && _e !== void 0 ? _e : false) {
-            this.outline = true;
-        }
-    }
+
+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._color = color;
+        this.options.color = color;
         if (this.material instanceof THREE.MeshStandardMaterial) {
             this.material.color.set(color);
         }
     }
     get color() {
-        return this._color;
+        return this.options.color;
     }
-    getBrepSerialized() {
-        return this.freeform.getBrepSerialized();
+    constructor(options) {
+        var _a, _b;
+        super();
+        this.options = {
+            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),
+        };
+        _Solid_outlineMesh.set(this, null);
+        this._outlineEnabled = false;
+        this._fatOutlines = false;
+        this._outlineWidth = 1;
+        this._outlineColor = 0x000000;
+        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.
+     */
+    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 this.freeform.getPlacement();
+        return clonePlacement(this.getPlacementTransform());
     }
+    /**
+     * Applies translation, rotation, and scale updates to the wrapped BRep.
+     */
     setPlacement(placement) {
-        var _a, _b, _c, _d, _e, _f, _g, _h;
-        const current = this.freeform.getPlacement();
-        this.freeform.setPlacement({
-            anchor: (_b = (_a = placement.anchor) === null || _a === void 0 ? void 0 : _a.clone()) !== null && _b !== void 0 ? _b : current.anchor.clone(),
-            translation: (_d = (_c = placement.translation) === null || _c === void 0 ? void 0 : _c.clone()) !== null && _d !== void 0 ? _d : current.translation.clone(),
-            rotation: (_f = (_e = placement.rotation) === null || _e === void 0 ? void 0 : _e.clone()) !== null && _f !== void 0 ? _f : current.rotation.clone(),
-            scale: (_h = (_g = placement.scale) === null || _g === void 0 ? void 0 : _g.clone()) !== null && _h !== void 0 ? _h : current.scale.clone(),
-        });
+        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.freeform.setTransform(translation.clone(), rotation.clone(), scale.clone());
-        this.generateGeometry();
+        this.setPlacement({
+            translation,
+            rotation,
+            scale,
+        });
     }
     setTranslation(translation) {
-        this.freeform.setTranslation(translation.clone());
-        this.generateGeometry();
+        this.setPlacement({ translation });
     }
     setRotation(rotation) {
-        this.freeform.setRotation(rotation.clone());
-        this.generateGeometry();
+        this.setPlacement({ rotation });
     }
     setScale(scale) {
-        this.freeform.setScale(scale.clone());
-        this.generateGeometry();
-    }
-    union(operand, options) {
-        return booleanUnion(this, operand, options);
-    }
-    intersection(operand, options) {
-        return booleanIntersection(this, operand, options);
+        this.setPlacement({ scale });
     }
-    subtract(operand, options) {
-        return booleanSubtraction(this, operand, options);
+    getAnchor() {
+        return this.getPlacementTransform().anchor.clone();
     }
-    set outlineColor(color) {
-        this._outlineColor = color;
-        setShapeOutlineColor(__classPrivateFieldGet(this, _ExtrudedShape_outlineMesh, "f"), color);
+    setAnchor(anchor) {
+        this.options.anchor = anchor.clone();
+        this.solid.setPlacement(this.getPlacementTransform());
+        this.generateGeometry();
     }
-    get outlineColor() {
-        return getShapeOutlineColor(__classPrivateFieldGet(this, _ExtrudedShape_outlineMesh, "f"), this._outlineColor);
+    /**
+     * Solid is always convertible back to the freeform editing wrapper.
+     */
+    canConvertToFreeform() {
+        return true;
     }
-    set outline(enable) {
-        this._outlineEnabled = enable;
-        this.clearOutlineMesh();
-        if (!enable) {
-            return;
+    /**
+     * 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.");
         }
-        const outlinePositions = parseJson(this.freeform.getOutlineGeometrySerialized());
-        __classPrivateFieldSet(this, _ExtrudedShape_outlineMesh, createShapeOutlineMesh({
-            positions: outlinePositions,
-            color: this._outlineColor,
-            fatOutlines: this._fatOutlines,
-            outlineWidth: this._outlineWidth,
-        }), "f");
-        this.add(__classPrivateFieldGet(this, _ExtrudedShape_outlineMesh, "f"));
-    }
-    get outline() {
-        return this._outlineEnabled;
+        return createFreeformGeometry(this.getLocalBrepSerialized(), {
+            id,
+            placement: this.getPlacementTransform(),
+        });
     }
-    set fatOutlines(value) {
-        this._fatOutlines = value;
-        if (this._outlineEnabled) {
-            this.outline = true;
-        }
+    /**
+     * Returns the world-space serialized BRep payload for this solid.
+     */
+    getBrepSerialized() {
+        return this.solid.getBrepSerialized();
     }
-    get fatOutlines() {
-        return this._fatOutlines;
+    /**
+     * Returns the local-space serialized BRep payload for this solid.
+     */
+    getLocalBrepSerialized() {
+        return this.solid.getLocalBrepSerialized();
     }
-    set outlineWidth(value) {
-        this._outlineWidth = sanitizeOutlineWidth(value);
-        if (this._outlineEnabled) {
-            this.outline = true;
+    /**
+     * 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);
     }
-    get outlineWidth() {
-        return this._outlineWidth;
-    }
-    dispose() {
-        this.clearOutlineMesh();
-        this.geometry.dispose();
-        if (Array.isArray(this.material)) {
-            this.material.forEach((material) => material.dispose());
-            return;
-        }
-        this.material.dispose();
+    /**
+     * Subtracts another boolean operand from this solid.
+     */
+    subtract(operand, options) {
+        return subtractShapeOperand(this, operand, options);
     }
+    /**
+     * Rebuilds the visible mesh and outline from the current freeform geometry.
+     */
     generateGeometry() {
         var _a;
-        const positions = parseJson(this.freeform.getGeometrySerialized());
-        this.writePositionsToGeometry(this.geometry, positions);
+        const bufferData = this.solid.getGeometryBuffer();
+        this.writePositionsToGeometry(this.geometry, bufferData);
         if (this.material instanceof THREE.MeshStandardMaterial) {
-            this.material.color.set(this._color);
+            this.material.color.set(this.options.color);
             this.material.transparent = true;
-            this.material.opacity = 0.82;
-            this.material.side = THREE.FrontSide;
+            this.material.opacity = 0.6;
         }
         else {
             if (Array.isArray(this.material)) {
@@ -7559,16 +7804,12 @@ class ExtrudedShape extends THREE.Mesh {
                 this.material.dispose();
             }
             this.material = new THREE.MeshStandardMaterial({
-                color: this._color,
+                color: this.options.color,
                 transparent: true,
-                opacity: 0.82,
-                side: THREE.FrontSide,
-                polygonOffset: true,
-                polygonOffsetFactor: 1,
-                polygonOffsetUnits: 1,
+                opacity: 0.6,
             });
         }
-        if (positions.length > 0) {
+        if (bufferData.length > 0) {
             this.geometry.computeVertexNormals();
             this.geometry.computeBoundingBox();
             this.geometry.computeBoundingSphere();
@@ -7581,53 +7822,103 @@ class ExtrudedShape extends THREE.Mesh {
         if (!this._outlineEnabled) {
             return;
         }
-        const outlinePositions = parseJson(this.freeform.getOutlineGeometrySerialized());
-        if (!__classPrivateFieldGet(this, _ExtrudedShape_outlineMesh, "f")) {
+        const outlineData = this.solid.getOutlineGeometryBuffer();
+        if (!__classPrivateFieldGet(this, _Solid_outlineMesh, "f")) {
             this.outline = true;
             return;
         }
-        if (__classPrivateFieldGet(this, _ExtrudedShape_outlineMesh, "f") instanceof THREE.LineSegments) {
-            this.writePositionsToGeometry(__classPrivateFieldGet(this, _ExtrudedShape_outlineMesh, "f").geometry, outlinePositions);
-            __classPrivateFieldGet(this, _ExtrudedShape_outlineMesh, "f").geometry.computeBoundingBox();
-            __classPrivateFieldGet(this, _ExtrudedShape_outlineMesh, "f").geometry.computeBoundingSphere();
+        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, _ExtrudedShape_outlineMesh, "f").geometry;
-        fatGeometry.setPositions(outlinePositions);
-        const fatOutline = __classPrivateFieldGet(this, _ExtrudedShape_outlineMesh, "f");
+        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, _ExtrudedShape_outlineMesh, "f")) {
+        if (!__classPrivateFieldGet(this, _Solid_outlineMesh, "f")) {
             return;
         }
-        this.remove(__classPrivateFieldGet(this, _ExtrudedShape_outlineMesh, "f"));
-        disposeShapeOutlineMesh(__classPrivateFieldGet(this, _ExtrudedShape_outlineMesh, "f"));
-        __classPrivateFieldSet(this, _ExtrudedShape_outlineMesh, null, "f");
+        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 existing = geometry.getAttribute("position");
-        if (!(existing instanceof THREE.BufferAttribute) ||
-            existing.itemSize !== 3 ||
-            existing.count !== positions.length / 3) {
+        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;
         }
-        const array = existing.array;
-        array.set(positions);
-        existing.needsUpdate = true;
+        attribute.array.set(positions);
+        attribute.needsUpdate = true;
     }
 }
-_ExtrudedShape_outlineMesh = new WeakMap();
-
-/**
- * Executes a kernel-backed subtraction for a shape wrapper against another boolean operand.
- */
-function subtractShapeOperand(host, operand, options) {
-    return booleanSubtraction(host, operand, options);
+_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;
@@ -7638,8 +7929,6 @@ class Polygon extends THREE.Mesh {
     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;
         super();
@@ -7658,12 +7947,6 @@ class Polygon extends THREE.Mesh {
         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);
@@ -7680,19 +7963,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) {
@@ -7768,18 +8038,27 @@ class Polygon extends THREE.Mesh {
         this.setPlacement({ scale });
     }
     getPlacement() {
-        return clonePlacement$1({
+        return clonePlacement({
             translation: this.options.translation,
             rotation: this.options.rotation,
             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.");
@@ -7789,62 +8068,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;
@@ -7894,24 +8119,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)
@@ -7920,59 +8127,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)
@@ -7985,28 +8139,29 @@ class Polygon extends THREE.Mesh {
             holes: ((_b = this.options.holes) !== null && _b !== void 0 ? _b : []).map((hole) => hole.map((vertex) => vertex.clone())),
         });
     }
-    extrude(height = 1, faceId = 0) {
-        const extrudeFaceExport = extrudeBrepFace;
-        if (typeof extrudeFaceExport !== "function") {
-            throw new Error("extrudeBrepFace is not available in the loaded wasm package. Rebuild opengeometry wasm bindings.");
-        }
-        const localBrepSerialized = this.polygon.get_local_brep_serialized();
-        const extrudedLocalBrep = extrudeFaceExport(localBrepSerialized, faceId, height);
+    /**
+     * Builds a kernel-backed `Solid` by extruding this polygon face by `height`.
+     */
+    extrude(height) {
+        const config = this.getConfig();
         const placement = this.getPlacement();
-        return new ExtrudedShape(extrudedLocalBrep, {
-            color: this.color,
-            outline: this.outline,
-            fatOutlines: this.fatOutlines,
-            outlineWidth: this.outlineWidth,
-            outlineColor: this.outlineColor,
-            placement: {
-                anchor: this.getAnchor(),
-                translation: placement.translation,
-                rotation: placement.rotation,
-                scale: placement.scale,
-            },
+        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;
@@ -8026,7 +8181,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();
@@ -8038,8 +8192,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"));
         }
     }
@@ -8066,20 +8218,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")) {
@@ -8090,20 +8230,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");
@@ -8117,10 +8244,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 });
@@ -8238,7 +8380,7 @@ class Cylinder extends THREE.Mesh {
         this.setPlacement({ scale });
     }
     getPlacement() {
-        return clonePlacement$1({
+        return clonePlacement({
             translation: this.options.translation,
             rotation: this.options.rotation,
             scale: this.options.scale,
@@ -8391,6 +8533,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 });
@@ -8443,7 +8588,7 @@ class Cuboid extends THREE.Mesh {
         return this.options;
     }
     getPlacement() {
-        return clonePlacement$1({
+        return clonePlacement({
             translation: this.options.translation,
             rotation: this.options.rotation,
             scale: this.options.scale,
@@ -8645,6 +8790,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 });
@@ -8766,7 +8914,7 @@ class Opening extends THREE.Mesh {
         this.setPlacement({ scale });
     }
     getPlacement() {
-        return clonePlacement$1({
+        return clonePlacement({
             translation: this.options.translation,
             rotation: this.options.rotation,
             scale: this.options.scale,
@@ -8931,6 +9079,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 });
@@ -9050,7 +9201,7 @@ class Sphere extends THREE.Mesh {
         this.setPlacement({ scale });
     }
     getPlacement() {
-        return clonePlacement$1({
+        return clonePlacement({
             translation: this.options.translation,
             rotation: this.options.rotation,
             scale: this.options.scale,
@@ -9204,6 +9355,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;
@@ -9315,7 +9469,7 @@ class Wedge extends THREE.Mesh {
         this.setPlacement({ scale });
     }
     getPlacement() {
-        return clonePlacement$1({
+        return clonePlacement({
             translation: this.options.translation,
             rotation: this.options.rotation,
             scale: this.options.scale,
@@ -9470,6 +9624,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;
@@ -9611,7 +9768,7 @@ class Sweep extends THREE.Mesh {
         this.setPlacement({ scale });
     }
     getPlacement() {
-        return clonePlacement$1({
+        return clonePlacement({
             translation: this.options.translation,
             rotation: this.options.rotation,
             scale: this.options.scale,
@@ -10117,9 +10274,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)
-        : createPolygonPreset(operation, options);
+    const preset = createPreset(operation, options);
     const execute = getBooleanExecutor(operation);
     const result = execute(preset.lhsOperand, preset.rhsOperand, options);
     const group = new THREE.Group();
@@ -10135,6 +10290,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.
  */
@@ -10219,6 +10384,50 @@ function createPolygonPreset(operation, options) {
         rhsVisual: rhs,
     };
 }
+/**
+ * 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 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,
+        fatOutlines: (_c = options.fatOutlines) !== null && _c !== void 0 ? _c : true,
+        outlineWidth,
+    });
+    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,
+        fatOutlines: (_d = options.fatOutlines) !== null && _d !== void 0 ? _d : true,
+        outlineWidth,
+    });
+    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 Solid`,
+        description: "Two polygon.extrude(height) solids overlap to demonstrate renderable BRep booleans.",
+        lhsOperand: wall,
+        rhsOperand: opening,
+        lhsVisual: wall,
+        rhsVisual: opening,
+    };
+}
 /**
  * Selects the exported boolean helper that matches the current example mode.
  */
@@ -10356,6 +10565,9 @@ function createEditorModesExample(scene) {
     };
 }
 
+/**
+ * Shared runtime entrypoint used to initialize the OpenGeometry wasm module.
+ */
 class OpenGeometry {
     get enableDebug() {
         return this._enableDebug;
@@ -10422,5 +10634,5 @@ class OpenGeometry {
 OpenGeometry.version = OPEN_GEOMETRY_THREE_VERSION;
 OpenGeometry.instance = null;
 
-export { Arc, BooleanResult, Cuboid, Curve, Cylinder, ExtrudedShape, FreeformEditor, FreeformGeometry, Line, OGSceneManager, OpenGeometry, Opening, Polygon, Polyline, Rectangle, Sphere, SpotLabel, Sweep, Vector3, Wedge, booleanIntersection, booleanSubtraction, booleanUnion, clonePlacement$1 as 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, extrudeBrepFace, toObjectTransformation$1 as toObjectTransformation };
 //# sourceMappingURL=index.js.map