opengeometry 2.0.6 → 2.0.8

package/README.md

@@ -7,7 +7,7 @@
 <h1 align="center">OpenGeometry</h1>
 
 <p align="center">
-  <strong>CAD kernel for the web — built with Rust, WebAssembly, and Three.js.</strong>
+  <strong>Browser-native CAD kernel built with Rust, WebAssembly, and Three.js.</strong>
 </p>
 
 <p align="center">
@@ -30,11 +30,11 @@
 
 ## What is OpenGeometry?
 
-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.
+OpenGeometry is an **open-source, browser-native CAD kernel**. The geometry engine is written in **Rust**, compiled to **WebAssembly**, and paired with a **Three.js-friendly TypeScript layer** so you can build real CAD tools that run in the browser.
 
-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.
+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 deterministic, 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.
+It is the geometry engine layer, not a full CAD application. OpenPlans is a downstream application/toolkit built on top of OpenGeometry for AEC workflows. In this repository, OpenGeometry is the primary SDK and engine.
 
 ## When to use OpenGeometry
 
@@ -45,15 +45,38 @@ Use OpenGeometry when you need:
 - 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
+- a deterministic geometry engine behind AI-assisted CAD or design workflows
+
+## Why it works well for AI-powered CAD apps
+
+OpenGeometry is a good fit for **AI-assisted CAD apps** because the kernel layer stays explicit and deterministic. An AI copilot or agent can suggest modeling steps, generate profiles, or orchestrate edits, while OpenGeometry executes the actual geometry operations, booleans, projections, and exports in a predictable browser runtime.
+
+Good examples include:
+
+- AI copilots that translate user intent into concrete modeling operations
+- prompt-to-geometry or agent-driven editing flows inside browser CAD tools
+- AI-assisted design interfaces that still need reliable extrusion, boolean, projection, and export workflows
+
+## Good fit / Not the right fit
+
+**Good fit**
+
+- browser CAD, AEC/BIM, and geometry-heavy web applications
+- Three.js-based modeling tools that need a real kernel behind them
+- AI-assisted CAD frontends that need deterministic geometry execution in the browser
+
+**Not the default fit**
+
+- desktop-native CAD products instead of an embeddable web SDK
+- non-browser runtimes with no WebAssembly or browser delivery story
+- pure visualization-only apps where raw Three.js is enough and kernel-backed modeling is unnecessary
 
 ## 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)
+- [AGENTS.md](./AGENTS.md) - single source of truth for all coding agents (architecture, commands, gotchas, behavioral rules)
+- [README.md](./README.md) - product overview, positioning, and quick start
 - [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)
@@ -66,7 +89,7 @@ If you are using ChatGPT, Claude, Gemini, Copilot, or other coding agents on thi
 | **Primitives** | Lines, arcs, curves, polylines, rectangles |
 | **Shapes** | Polygons, solids, cuboids, cylinders, spheres, wedges, sweeps, openings |
 | **Operations** | Triangulation, extrusion, sweep, offset, boolean operations |
-| **Exports** | STL, STEP, IFC, PDF projection |
+| **Exports** | STL, STEP, IFC, PDF projection (PDF is currently native/Node-only — browser PDF is on the roadmap) |
 | **Integration** | Three.js scene management, WebAssembly-powered performance |
 
 ## Demos
@@ -85,6 +108,8 @@ Install from npm:
 npm install opengeometry
 ```
 
+A practical browser deployment looks like this: install `opengeometry` from npm, serve `opengeometry_bg.wasm` from your app, then initialize the runtime once with `OpenGeometry.create({ wasmURL })` before creating `Vector3` values or kernel-backed wrappers.
+
 ```ts
 import { Cuboid, OpenGeometry, Vector3 } from "opengeometry";
 
@@ -184,11 +209,12 @@ 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.
+- All AI coding agent instructions live in a single file: [AGENTS.md](./AGENTS.md).
+  `CLAUDE.md` and `.github/copilot-instructions.md` are thin redirects to it.
+- Stable architecture and domain notes are tracked in [`knowledge/`](./knowledge/).
+- User-facing docs live in [`docs/`](./docs/) (Mintlify source).
+- Agents should not create planning, handoff, or runbook files during a task. The
+  conversation, the diff, and the commit message are the handoff.
 
 ---
 

package/index.js

@@ -201,9 +201,6 @@ function extrudeBrepFace$1(local_brep_serialized, height) {
     wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
   }
 }
-function isLikeNone(x) {
-  return x === undefined || x === null;
-}
 function getArrayJsValueFromWasm0(ptr, len) {
   ptr = ptr >>> 0;
   const mem = getDataViewMemory0();
@@ -214,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
@@ -1666,6 +1666,99 @@ class OGCylinder {
     return Vector3.__wrap(ret);
   }
 }
+const OGEntityRegistryFinalization = typeof FinalizationRegistry === 'undefined' ? {
+  register: () => {},
+  unregister: () => {}
+} : new FinalizationRegistry(ptr => wasm.__wbg_ogentityregistry_free(ptr >>> 0, 1));
+/**
+ * Flat entity registry with a batched multi-view projection API.
+ * Replaces the scene-centric OGSceneManager pattern for export use cases.
+ */
+class OGEntityRegistry {
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    OGEntityRegistryFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_ogentityregistry_free(ptr, 0);
+  }
+  constructor() {
+    const ret = wasm.ogentityregistry_new();
+    this.__wbg_ptr = ret >>> 0;
+    OGEntityRegistryFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+  /**
+   * Register (or replace) an entity. `kind` must be an OGEntityKind string.
+   * @param {string} id
+   * @param {string} kind
+   * @param {string} brep_json
+   */
+  registerEntity(id, kind, brep_json) {
+    const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ptr1 = passStringToWasm0(kind, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    const ptr2 = passStringToWasm0(brep_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len2 = WASM_VECTOR_LEN;
+    const ret = wasm.ogentityregistry_registerEntity(this.__wbg_ptr, ptr0, len0, ptr1, len1, ptr2, len2);
+    if (ret[1]) {
+      throw takeFromExternrefTable0(ret[0]);
+    }
+  }
+  /**
+   * Remove a previously registered entity.
+   * @param {string} id
+   * @returns {boolean}
+   */
+  unregisterEntity(id) {
+    const ptr0 = passStringToWasm0(id, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.ogentityregistry_unregisterEntity(this.__wbg_ptr, ptr0, len0);
+    return ret !== 0;
+  }
+  /**
+   * Remove all registered entities.
+   */
+  clearEntities() {
+    wasm.ogentityregistry_clearEntities(this.__wbg_ptr);
+  }
+  /**
+   * Batched multi-view projection.
+   *
+   * Input:  JSON array of `{ id, camera, hlr?, section_plane? }` (ViewRequest).
+   * Output: JSON map of `{ viewportId: Scene2D }`.
+   *
+   * All viewports are projected in a single WASM call, amortising
+   * serialisation overhead and keeping BRep data in WASM memory.
+   * @param {string} views_json
+   * @returns {string}
+   */
+  projectCurrentToViews(views_json) {
+    let deferred3_0;
+    let deferred3_1;
+    try {
+      const ptr0 = passStringToWasm0(views_json, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+      const len0 = WASM_VECTOR_LEN;
+      const ret = wasm.ogentityregistry_projectCurrentToViews(this.__wbg_ptr, ptr0, len0);
+      var ptr2 = ret[0];
+      var len2 = ret[1];
+      if (ret[3]) {
+        ptr2 = 0;
+        len2 = 0;
+        throw takeFromExternrefTable0(ret[2]);
+      }
+      deferred3_0 = ptr2;
+      deferred3_1 = len2;
+      return getStringFromWasm0(ptr2, len2);
+    } finally {
+      wasm.__wbindgen_free(deferred3_0, deferred3_1, 1);
+    }
+  }
+}
 const OGFreeformEditorFinalization = typeof FinalizationRegistry === 'undefined' ? {
   register: () => {},
   unregister: () => {}
@@ -4996,7 +5089,7 @@ class OGSweep {
    * @returns {Vector3}
    */
   get_anchor() {
-    const ret = wasm.ogarc_get_anchor(this.__wbg_ptr);
+    const ret = wasm.ogsweep_get_anchor(this.__wbg_ptr);
     return Vector3.__wrap(ret);
   }
   /**
@@ -5277,7 +5370,7 @@ class OGWedge {
    * @returns {Vector3}
    */
   get_anchor() {
-    const ret = wasm.ogwedge_get_anchor(this.__wbg_ptr);
+    const ret = wasm.ogsweep_get_anchor(this.__wbg_ptr);
     return Vector3.__wrap(ret);
   }
 }
@@ -5692,6 +5785,7 @@ var OGKernel = /*#__PURE__*/Object.freeze({
     OGCuboid: OGCuboid,
     OGCurve: OGCurve,
     OGCylinder: OGCylinder,
+    OGEntityRegistry: OGEntityRegistry,
     OGFreeformEditor: OGFreeformEditor,
     OGFreeformGeometry: OGFreeformGeometry,
     OGIfcExportResult: OGIfcExportResult,
@@ -6250,7 +6344,6 @@ function createFreeformGeometry(source, options) {
     return geometry;
 }
 
-/* eslint-enable no-unused-vars */
 /**
  * Simple Line defined by Two Points
  */
@@ -6473,7 +6566,6 @@ class Line extends THREE.Line {
     }
 }
 
-/* eslint-enable no-unused-vars */
 /**
  * Polyline wrapper backed by the kernel OGPolyline primitive.
  */
@@ -6913,7 +7005,6 @@ class Arc extends THREE.Line {
     }
 }
 
-/* eslint-enable no-unused-vars */
 /**
  * Rectangle wrapper backed by the kernel OGRectangle primitive.
  */
@@ -7151,7 +7242,6 @@ class Rectangle extends THREE.Line {
     }
 }
 
-/* eslint-enable no-unused-vars */
 /**
  * Curve wrapper backed by the kernel OGCurve primitive.
  */
@@ -7427,15 +7517,14 @@ function serializeBrepLike$1(value) {
 }
 
 var _BooleanResult_outlineMesh;
-/* eslint-enable no-unused-vars */
 const BOOLEAN_CREASE_ANGLE = Math.PI / 5;
 const BOOLEAN_OUTLINE_THRESHOLD_DEGREES = 26;
 /**
  * Renderable result mesh returned by the kernel boolean helpers.
  */
 class BooleanResult extends THREE.Mesh {
-    constructor(kernelResult, options) {
-        var _a, _b, _c;
+    constructor(kernelResult, options, sourceMaterial = null) {
+        var _a, _b;
         super();
         this.report = null;
         this.brepSerialized = "";
@@ -7448,15 +7537,15 @@ class BooleanResult extends THREE.Mesh {
         this.ogid = getUUID();
         this._fatOutlines = (_a = options === null || options === void 0 ? void 0 : options.fatOutlines) !== null && _a !== void 0 ? _a : false;
         this._outlineWidth = sanitizeOutlineWidth(options === null || options === void 0 ? void 0 : options.outlineWidth);
-        this.applyKernelResult(kernelResult, (_b = options === null || options === void 0 ? void 0 : options.color) !== null && _b !== void 0 ? _b : 0x2563eb);
-        if ((_c = options === null || options === void 0 ? void 0 : options.outline) !== null && _c !== void 0 ? _c : false) {
+        this.applyKernelResult(kernelResult, options, sourceMaterial);
+        if ((_b = options === null || options === void 0 ? void 0 : options.outline) !== null && _b !== void 0 ? _b : false) {
             this.outline = true;
         }
     }
     /**
      * Rebuilds the mesh, cached BRep payload, and outline geometry from the kernel output.
      */
-    applyKernelResult(kernelResult, color = 0x2563eb) {
+    applyKernelResult(kernelResult, options, sourceMaterial = null) {
         this.disposeGeometry();
         this.brepSerialized = kernelResult.brepSerialized;
         this.brepData = JSON.parse(kernelResult.brepSerialized);
@@ -7467,15 +7556,7 @@ class BooleanResult extends THREE.Mesh {
         const geometry = toCreasedNormals(baseGeometry, BOOLEAN_CREASE_ANGLE);
         geometry.computeBoundingBox();
         this.outlinePositions = getRenderableOutlinePositions(geometry, kernelResult.outlineGeometrySerialized);
-        const material = new THREE.MeshStandardMaterial({
-            color,
-            transparent: true,
-            opacity: 0.82,
-            side: THREE.FrontSide,
-            polygonOffset: true,
-            polygonOffsetFactor: 1,
-            polygonOffsetUnits: 1,
-        });
+        const material = buildResultMaterial(sourceMaterial, options);
         this.geometry = geometry;
         this.material = material;
         if (this._outlineEnabled) {
@@ -7603,7 +7684,7 @@ function executeBooleanSubtractionMany(lhs, cutters, options) {
     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);
+    return createBooleanResult(kernelResult, options, resolveOperandMaterial(lhs));
 }
 /**
  * Normalizes mixed wrapper/raw operands, invokes the wasm boolean export, and
@@ -7617,7 +7698,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);
-    return createBooleanResult(kernelResult, options);
+    return createBooleanResult(kernelResult, options, resolveOperandMaterial(lhs));
 }
 /**
  * Accepts wrapper objects, raw BRep data, or serialized JSON and normalizes
@@ -7673,14 +7754,69 @@ function serializeKernelOptions(options) {
         merge_coplanar_faces: options.mergeCoplanarFaces,
     });
 }
-function createBooleanResult(kernelResult, options) {
+function createBooleanResult(kernelResult, options, sourceMaterial = null) {
     var _a;
-    const result = new BooleanResult(kernelResult, options);
+    const result = new BooleanResult(kernelResult, options, sourceMaterial);
     if ((_a = options === null || options === void 0 ? void 0 : options.outline) !== null && _a !== void 0 ? _a : true) {
         result.outline = true;
     }
     return result;
 }
+/**
+ * Returns a clonable `THREE.Material` from the operand when it is a Three mesh
+ * subclass (Solid, Polygon, Cuboid, Opening, BooleanResult, etc.). Returns
+ * `null` for serialized JSON, parsed BRep objects, or anything else without a
+ * reachable material so the boolean result can fall back to the legacy default.
+ */
+function resolveOperandMaterial(operand) {
+    var _a;
+    if (typeof operand !== "object" || operand === null) {
+        return null;
+    }
+    if (!(operand instanceof THREE.Mesh)) {
+        return null;
+    }
+    const material = operand.material;
+    if (Array.isArray(material)) {
+        return (_a = material[0]) !== null && _a !== void 0 ? _a : null;
+    }
+    return material instanceof THREE.Material ? material : null;
+}
+/**
+ * Builds the boolean result mesh's material by cloning the host (LHS) material
+ * when available so the result inherits the host's color, transparency, and
+ * side mode. Caller-provided overrides on `BooleanRenderOptions` win, and the
+ * polygon-offset settings that prevent z-fighting with the result outline are
+ * always reapplied after cloning.
+ */
+function buildResultMaterial(sourceMaterial, options) {
+    const material = sourceMaterial
+        ? sourceMaterial.clone()
+        : new THREE.MeshStandardMaterial({
+            color: 0x2563eb,
+            transparent: true,
+            opacity: 0.82,
+            side: THREE.FrontSide,
+        });
+    if ((options === null || options === void 0 ? void 0 : options.color) !== undefined && "color" in material) {
+        material.color.set(options.color);
+    }
+    if ((options === null || options === void 0 ? void 0 : options.opacity) !== undefined) {
+        material.opacity = options.opacity;
+        material.transparent = options.opacity < 1 || material.transparent;
+    }
+    if ((options === null || options === void 0 ? void 0 : options.transparent) !== undefined) {
+        material.transparent = options.transparent;
+    }
+    if ((options === null || options === void 0 ? void 0 : options.side) !== undefined) {
+        material.side = options.side;
+    }
+    material.polygonOffset = true;
+    material.polygonOffsetFactor = 1;
+    material.polygonOffsetUnits = 1;
+    material.needsUpdate = true;
+    return material;
+}
 /**
  * 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.
@@ -7858,10 +7994,9 @@ class Solid extends THREE.Mesh {
         var _a;
         const bufferData = this.solid.getGeometryBuffer();
         this.writePositionsToGeometry(this.geometry, bufferData);
+        let material;
         if (this.material instanceof THREE.MeshStandardMaterial) {
-            this.material.color.set(this.options.color);
-            this.material.transparent = true;
-            this.material.opacity = 0.6;
+            material = this.material;
         }
         else {
             if (Array.isArray(this.material)) {
@@ -7870,12 +8005,21 @@ class Solid extends THREE.Mesh {
             else {
                 this.material.dispose();
             }
-            this.material = new THREE.MeshStandardMaterial({
+            material = new THREE.MeshStandardMaterial({
                 color: this.options.color,
-                transparent: true,
-                opacity: 0.6,
+                transparent: false,
+                opacity: 1,
+                depthWrite: true,
+                side: THREE.FrontSide,
             });
-        }
+            this.material = material;
+        }
+        material.color.set(this.options.color);
+        material.transparent = false;
+        material.opacity = 1;
+        material.depthWrite = true;
+        material.side = THREE.FrontSide;
+        material.needsUpdate = true;
         if (bufferData.length > 0) {
             this.geometry.computeVertexNormals();
             this.geometry.computeBoundingBox();
@@ -8486,8 +8630,8 @@ class Cylinder extends THREE.Mesh {
         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;
+            // this.material.transparent = true;
+            // this.material.opacity = 0.6;
         }
         else {
             if (Array.isArray(this.material)) {
@@ -8498,8 +8642,8 @@ class Cylinder extends THREE.Mesh {
             }
             this.material = new THREE.MeshStandardMaterial({
                 color: this.options.color,
-                transparent: true,
-                opacity: 0.6,
+                // transparent: true,
+                // opacity: 0.6,
             });
         }
         this.geometry.computeVertexNormals();
@@ -8697,8 +8841,8 @@ class Cuboid extends THREE.Mesh {
         this.writePositionsToGeometry(this.geometry, geometryData);
         if (this.material instanceof THREE.MeshStandardMaterial) {
             this.material.color.set(this.options.color);
-            this.material.transparent = true;
-            this.material.opacity = 0.6;
+            // this.material.transparent = true;
+            // this.material.opacity = 0.6;
         }
         else {
             if (Array.isArray(this.material)) {
@@ -8709,8 +8853,8 @@ class Cuboid extends THREE.Mesh {
             }
             this.material = new THREE.MeshStandardMaterial({
                 color: this.options.color,
-                transparent: true,
-                opacity: 0.6,
+                // transparent: true,
+                // opacity: 0.6,
             });
         }
         this.geometry.computeVertexNormals();
@@ -9151,7 +9295,6 @@ class Opening extends THREE.Mesh {
 _Opening_outlineMesh = new WeakMap();
 
 var _Sphere_outlineMesh;
-/* eslint-enable no-unused-vars */
 /**
  * Sphere wrapper backed by the kernel sphere primitive.
  */
@@ -9310,8 +9453,8 @@ class Sphere extends THREE.Mesh {
         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;
+            // this.material.transparent = true;
+            // this.material.opacity = 0.6;
         }
         else {
             if (Array.isArray(this.material)) {
@@ -9322,8 +9465,8 @@ class Sphere extends THREE.Mesh {
             }
             this.material = new THREE.MeshStandardMaterial({
                 color: this.options.color,
-                transparent: true,
-                opacity: 0.6,
+                // transparent: true,
+                // opacity: 0.6,
             });
         }
         this.geometry.computeVertexNormals();
@@ -9578,8 +9721,8 @@ class Wedge extends THREE.Mesh {
         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;
+            // this.material.transparent = true;
+            // this.material.opacity = 0.6;
         }
         else {
             if (Array.isArray(this.material)) {
@@ -9590,8 +9733,8 @@ class Wedge extends THREE.Mesh {
             }
             this.material = new THREE.MeshStandardMaterial({
                 color: this.options.color,
-                transparent: true,
-                opacity: 0.6,
+                // transparent: true,
+                // opacity: 0.6,
             });
         }
         this.geometry.computeVertexNormals();
@@ -9696,7 +9839,6 @@ class Wedge extends THREE.Mesh {
 _Wedge_outlineMesh = new WeakMap();
 
 var _Sweep_outlineMesh;
-/* eslint-enable no-unused-vars */
 /**
  * Sweep wrapper backed by the kernel sweep primitive.
  */
@@ -9877,8 +10019,8 @@ class Sweep extends THREE.Mesh {
         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;
+            // this.material.transparent = true;
+            // this.material.opacity = 0.6;
         }
         else {
             if (Array.isArray(this.material)) {
@@ -9889,8 +10031,8 @@ class Sweep extends THREE.Mesh {
             }
             this.material = new THREE.MeshStandardMaterial({
                 color: this.options.color,
-                transparent: true,
-                opacity: 0.6,
+                // transparent: true,
+                // opacity: 0.6,
             });
         }
         this.geometry.computeVertexNormals();