opengeometry 2.0.3 → 2.0.4

package/README.md

@@ -19,7 +19,7 @@
 </p>
 
 <p align="center">
-  <a href="https://opengeometry.io">Website</a> · <a href="https://docs.opengeometry.io">Documentation</a> · <a href="https://demos.opengeometry.io">Live Demos</a> · <a href="https://opengeometry.io/blog">Blog</a> · <a href="https://www.npmjs.com/package/opengeometry">npm</a>
+  <a href="https://opengeometry.io">Website</a> · <a href="https://docs.opengeometry.io">Documentation</a> · <a href="https://demo.opengeometry.io">Live Demos</a> · <a href="https://opengeometry.io/blog">Blog</a> · <a href="https://www.npmjs.com/package/opengeometry">npm</a>
 </p>
 
 ---
@@ -32,14 +32,39 @@
 
 OpenGeometry is an **open-source CAD kernel** purpose-built for the browser. The geometry engine is written in **Rust**, compiled to **WebAssembly**, and ships with a **Three.js integration layer** — so you can build real CAD tools that run entirely on the web.
 
-Whether you're building a parametric modeler, a BIM viewer, a 3D configurator, or any geometry-heavy web app, OpenGeometry gives you the primitives and operations you need without leaving JavaScript.
+OpenGeometry is best suited for **browser-based CAD, AEC/BIM, configurators, and geometry-heavy web tools**. Whether you're building a parametric modeler, a wall/opening workflow, a BIM viewer, or a custom Three.js modeling tool, OpenGeometry gives you kernel-backed primitives and operations without leaving JavaScript.
+
+OpenPlans is an application/toolkit built on top of OpenGeometry for AEC workflows. In this repository, OpenGeometry is the engine.
+
+## When to use OpenGeometry
+
+Use OpenGeometry when you need:
+
+- browser-based parametric modeling with Rust + WebAssembly performance
+- wall/opening subtraction and other solid boolean workflows
+- polygon extrusion into solids for CAD or AEC modeling
+- IFC, STEP, STL, and PDF-style export/projection in web apps
+- a Three.js-friendly CAD kernel instead of ad hoc mesh math
+
+## AI and Coding Agent Entrypoints
+
+If you are using ChatGPT, Claude, Gemini, Copilot, or other coding agents on this repository, start here:
+
+- [llms.txt](./llms.txt)
+- [llms-full.txt](./llms-full.txt)
+- [llm.txt](./llm.txt)
+- [AGENTS.md](./AGENTS.md)
+- [Quickstart](https://docs.opengeometry.io/quickstart)
+- [Three.js integration](https://docs.opengeometry.io/integration/threejs)
+- [Boolean operations](https://docs.opengeometry.io/api/operations/boolean-operations)
+- [Extrude](https://docs.opengeometry.io/api/operations/extrude)
 
 ### What you can do today
 
 | Category | Capabilities |
 | --- | --- |
 | **Primitives** | Lines, arcs, curves, polylines, rectangles |
-| **Shapes** | Polygons, cylinders, cuboids, spheres, wedges |
+| **Shapes** | Polygons, solids, cuboids, cylinders, spheres, wedges, sweeps, openings |
 | **Operations** | Triangulation, extrusion, sweep, offset, boolean operations |
 | **Exports** | STL, STEP, IFC, PDF projection |
 | **Integration** | Three.js scene management, WebAssembly-powered performance |
@@ -48,7 +73,7 @@ Whether you're building a parametric modeler, a BIM viewer, a 3D configurator, o
 
 See OpenGeometry in action — interactive, browser-based demos showcasing the kernel's capabilities:
 
-**[demos.opengeometry.io](https://demos.opengeometry.io)**
+**[demo.opengeometry.io](https://demo.opengeometry.io)**
 
 Demos include primitives rendering, shape generation, sweep operations, boolean operations, file exports, and more. All running client-side via WebAssembly.
 
@@ -70,6 +95,7 @@ await OpenGeometry.create({
   ).href,
 });
 
+// Initialize once before constructing Vector3 or any wrapper.
 const cuboid = new Cuboid({
   center: new Vector3(0, 0, 0),
   width: 2,
@@ -140,7 +166,7 @@ npm test
 - Contributors interested in the **Rust → WASM geometry pipeline**
 - Anyone exploring **open-source CAD kernel internals**
 
-If you just want a quick look, start with the [hosted demos](https://demos.opengeometry.io) or the [quickstart repo](https://github.com/OpenGeometry-io/quickstart-js).
+If you just want a quick look, start with the [hosted demos](https://demo.opengeometry.io) or the [quickstart repo](https://github.com/OpenGeometry-io/quickstart-js).
 
 ## Community
 
@@ -159,6 +185,8 @@ OpenGeometry is open source under the [MPL-2.0 license](./LICENSE.md). Contribut
 ## AI Agent Docs Policy
 
 - Repository-level AI agent instructions are in [AGENTS.md](./AGENTS.md).
+- LLM-friendly repo entrypoints are [llms.txt](./llms.txt), [llms-full.txt](./llms-full.txt), and
+  [llm.txt](./llm.txt).
 - All AI-generated documentation must live under [`AI-DOCs/`](./AI-DOCs/).
 - AI-generated docs should not be added under app/code folders unless explicitly requested.
 

package/index.d.ts

@@ -1,6 +1,5 @@
 /**
- * OpenGeometry Three.js adapter entrypoint.
- * @module @opengeometry/kernel-three
+ * Public OpenGeometry JavaScript entrypoint.
  */
 import { OGSceneManager, Vector3 } from "./opengeometry/pkg/opengeometry.js";
 import { SpotLabel } from "./src/markup/spotMarker.js";
@@ -47,30 +46,36 @@ export declare class OpenGeometry {
     set enableDebug(value: boolean);
     constructor();
     /**
-     * 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",
      * });
      * ```
      */
     static create(options: OpenGeometryOptions): Promise<OpenGeometry>;
     private setup;
 }
-export { OGSceneManager, Vector3, SpotLabel, };
+/**
+ * Scene manager that stores serialized BRep snapshots in wasm for projection,
+ * export, and other scene-level workflows.
+ */
+export { OGSceneManager };
+/**
+ * Shared wasm-backed vector type used throughout the public API.
+ *
+ * Initialize `OpenGeometry.create(...)` before constructing `Vector3`.
+ */
+export { Vector3 };
+export { SpotLabel };
 /**
  * Primitive wrappers (line/polyline/arc/rectangle/curve).
  */

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,6 +201,16 @@ function passArrayJsValueToWasm0(array, malloc) {
   WASM_VECTOR_LEN = array.length;
   return ptr;
 }
+function getArrayJsValueFromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  const mem = getDataViewMemory0();
+  const result = [];
+  for (let i = ptr; i < ptr + 4 * len; i += 4) {
+    result.push(wasm.__wbindgen_export_2.get(mem.getUint32(i, true)));
+  }
+  wasm.__externref_drop_slice(ptr, len);
+  return result;
+}
 function isLikeNone(x) {
   return x === undefined || x === null;
 }
@@ -242,40 +278,24 @@ function booleanSubtraction$1(lhs_brep_serialized, rhs_brep_serialized, options_
 }
 
 /**
- * @param {string} local_brep_serialized
- * @param {number} height
- * @returns {string}
+ * 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 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();
-  const result = [];
-  for (let i = ptr; i < ptr + 4 * len; i += 4) {
-    result.push(wasm.__wbindgen_export_2.get(mem.getUint32(i, true)));
+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]);
   }
-  wasm.__externref_drop_slice(ptr, len);
-  return result;
+  return OGBooleanResult.__wrap(ret[0]);
 }
 const Matrix3Finalization = typeof FinalizationRegistry === 'undefined' ? {
   register: () => {},
@@ -5688,6 +5708,7 @@ var OGKernel = /*#__PURE__*/Object.freeze({
     Vector3: Vector3,
     booleanIntersection: booleanIntersection$1,
     booleanSubtraction: booleanSubtraction$1,
+    booleanSubtractionMany: booleanSubtractionMany,
     booleanUnion: booleanUnion$1,
     default: __wbg_init,
     extrudeBrepFace: extrudeBrepFace$1,
@@ -7546,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);
@@ -7558,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.`);
@@ -7575,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
@@ -7600,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.
@@ -7622,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.
@@ -7642,8 +7701,11 @@ 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 _Solid_outlineMesh;
@@ -7693,6 +7755,8 @@ class Solid extends THREE.Mesh {
     }
     /**
      * 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) }));
@@ -7779,10 +7843,13 @@ class Solid extends THREE.Mesh {
         return JSON.parse(brepSerialized);
     }
     /**
-     * Subtracts another boolean operand from this solid.
+     * 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(operand, options) {
-        return subtractShapeOperand(this, operand, options);
+    subtract(operands, options) {
+        return subtractShapeOperand(this, operands, options);
     }
     /**
      * Rebuilds the visible mesh and outline from the current freeform geometry.
@@ -8141,6 +8208,9 @@ class Polygon extends THREE.Mesh {
     }
     /**
      * 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();
@@ -8169,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;
@@ -8464,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;
@@ -8675,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;
@@ -9000,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;
@@ -9283,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;
@@ -9551,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;
@@ -9850,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;
@@ -10591,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",
      * });
      * ```
      */
@@ -10634,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, 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 };
+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