opengeometry 2.0.7 → 2.0.9

package/index.js

@@ -77,20 +77,69 @@ function handleError(f, args) {
     wasm.__wbindgen_exn_store(idx);
   }
 }
-const cachedTextDecoder = typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', {
-  ignoreBOM: true,
-  fatal: true
-}) : {
-  decode: () => {
-    throw Error('TextDecoder not available');
+function debugString(val) {
+  // primitive types
+  const type = typeof val;
+  if (type == 'number' || type == 'boolean' || val == null) {
+    return `${val}`;
+  }
+  if (type == 'string') {
+    return `"${val}"`;
+  }
+  if (type == 'symbol') {
+    const description = val.description;
+    if (description == null) {
+      return 'Symbol';
+    } else {
+      return `Symbol(${description})`;
+    }
   }
-};
-if (typeof TextDecoder !== 'undefined') {
-  cachedTextDecoder.decode();
-}
-function getStringFromWasm0(ptr, len) {
-  ptr = ptr >>> 0;
-  return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+  if (type == 'function') {
+    const name = val.name;
+    if (typeof name == 'string' && name.length > 0) {
+      return `Function(${name})`;
+    } else {
+      return 'Function';
+    }
+  }
+  // objects
+  if (Array.isArray(val)) {
+    const length = val.length;
+    let debug = '[';
+    if (length > 0) {
+      debug += debugString(val[0]);
+    }
+    for (let i = 1; i < length; i++) {
+      debug += ', ' + debugString(val[i]);
+    }
+    debug += ']';
+    return debug;
+  }
+  // Test for built-in
+  const builtInMatches = /\[object ([^\]]+)\]/.exec(toString.call(val));
+  let className;
+  if (builtInMatches && builtInMatches.length > 1) {
+    className = builtInMatches[1];
+  } else {
+    // Failed to match the standard '[object ClassName]'
+    return toString.call(val);
+  }
+  if (className == 'Object') {
+    // we're a user defined class or Object
+    // JSON.stringify avoids problems with cycles, and is generally much
+    // easier than looping through ownProperties of `val`.
+    try {
+      return 'Object(' + JSON.stringify(val) + ')';
+    } catch (_) {
+      return 'Object';
+    }
+  }
+  // errors
+  if (val instanceof Error) {
+    return `${val.name}: ${val.message}\n${val.stack}`;
+  }
+  // TODO we could test for more things here, like `Set`s and `Map`s.
+  return className;
 }
 let WASM_VECTOR_LEN = 0;
 const cachedTextEncoder = typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : {
@@ -138,6 +187,28 @@ function passStringToWasm0(arg, malloc, realloc) {
   WASM_VECTOR_LEN = offset;
   return ptr;
 }
+let cachedDataViewMemory0 = null;
+function getDataViewMemory0() {
+  if (cachedDataViewMemory0 === null || cachedDataViewMemory0.buffer.detached === true || cachedDataViewMemory0.buffer.detached === undefined && cachedDataViewMemory0.buffer !== wasm.memory.buffer) {
+    cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
+  }
+  return cachedDataViewMemory0;
+}
+const cachedTextDecoder = typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', {
+  ignoreBOM: true,
+  fatal: true
+}) : {
+  decode: () => {
+    throw Error('TextDecoder not available');
+  }
+};
+if (typeof TextDecoder !== 'undefined') {
+  cachedTextDecoder.decode();
+}
+function getStringFromWasm0(ptr, len) {
+  ptr = ptr >>> 0;
+  return cachedTextDecoder.decode(getUint8ArrayMemory0().subarray(ptr, ptr + len));
+}
 function _assertClass(instance, klass) {
   if (!(instance instanceof klass)) {
     throw new Error(`expected instance of ${klass.name}`);
@@ -159,39 +230,6 @@ 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) {
-    cachedDataViewMemory0 = new DataView(wasm.memory.buffer);
-  }
-  return cachedDataViewMemory0;
-}
 function passArrayJsValueToWasm0(array, malloc) {
   const ptr = malloc(array.length * 4, 4) >>> 0;
   for (let i = 0; i < array.length; i++) {
@@ -287,6 +325,33 @@ function booleanSubtractionMany(lhs_brep_serialized, cutters_brep_serialized, op
   }
   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();
@@ -1666,6 +1731,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 +5154,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);
   }
   /**
@@ -5613,6 +5771,13 @@ function __wbg_get_imports() {
     const ret = Vector3.__unwrap(arg0);
     return ret;
   };
+  imports.wbg.__wbindgen_debug_string = function (arg0, arg1) {
+    const ret = debugString(arg1);
+    const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+    const len1 = WASM_VECTOR_LEN;
+    getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+    getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+  };
   imports.wbg.__wbindgen_init_externref_table = function () {
     const table = wasm.__wbindgen_export_2;
     const offset = table.grow(4);
@@ -5692,6 +5857,7 @@ var OGKernel = /*#__PURE__*/Object.freeze({
     OGCuboid: OGCuboid,
     OGCurve: OGCurve,
     OGCylinder: OGCylinder,
+    OGEntityRegistry: OGEntityRegistry,
     OGFreeformEditor: OGFreeformEditor,
     OGFreeformGeometry: OGFreeformGeometry,
     OGIfcExportResult: OGIfcExportResult,
@@ -6250,7 +6416,6 @@ function createFreeformGeometry(source, options) {
     return geometry;
 }
 
-/* eslint-enable no-unused-vars */
 /**
  * Simple Line defined by Two Points
  */
@@ -6473,7 +6638,6 @@ class Line extends THREE.Line {
     }
 }
 
-/* eslint-enable no-unused-vars */
 /**
  * Polyline wrapper backed by the kernel OGPolyline primitive.
  */
@@ -6913,7 +7077,6 @@ class Arc extends THREE.Line {
     }
 }
 
-/* eslint-enable no-unused-vars */
 /**
  * Rectangle wrapper backed by the kernel OGRectangle primitive.
  */
@@ -7151,7 +7314,6 @@ class Rectangle extends THREE.Line {
     }
 }
 
-/* eslint-enable no-unused-vars */
 /**
  * Curve wrapper backed by the kernel OGCurve primitive.
  */
@@ -7426,16 +7588,169 @@ function serializeBrepLike$1(value) {
     return typeof value === "string" ? value : JSON.stringify(value);
 }
 
+/**
+ * Typed error hierarchy for boolean operations.
+ *
+ * The Rust kernel emits a structured `BooleanError` as JSON across the WASM
+ * boundary (see `main/opengeometry/src/booleans/error.rs`). This module parses
+ * that JSON and re-throws it as a typed `BooleanError` (or a more specific
+ * subclass) so app code can `instanceof`-discriminate without parsing message
+ * strings.
+ *
+ * Cutter indices are **0-based** to match `Vec` / array indexing on both
+ * sides of the boundary.
+ */
+/**
+ * Base class for every typed boolean error. Carries the structured payload the
+ * kernel emitted across WASM. Specialized subclasses (`OverlappingCuttersError`,
+ * `CutterExceedsHostError`, `NonManifoldOutputError`, `CoincidentFacesError`)
+ * narrow the payload for the variants that carry extra fields.
+ */
+class BooleanError extends Error {
+    constructor(payload) {
+        super(payload.message);
+        this.name = "BooleanError";
+        this.reason = payload.kind.code;
+        this.phase = payload.phase;
+        this.cutterIndex = payload.cutter_index;
+        this.details = payload.details;
+        this.edgeSamples = payload.edge_samples
+            ? payload.edge_samples.map(([a, b]) => [
+                new THREE.Vector3(a.x, a.y, a.z),
+                new THREE.Vector3(b.x, b.y, b.z),
+            ])
+            : null;
+    }
+}
+/**
+ * Two cutters overlap each other. `otherIndex` is the 0-based index of the
+ * cutter that conflicts with the one at `cutterIndex`.
+ */
+class OverlappingCuttersError extends BooleanError {
+    constructor(payload) {
+        var _a;
+        super(payload);
+        this.name = "OverlappingCuttersError";
+        this.otherIndex = (_a = payload.kind.other_index) !== null && _a !== void 0 ? _a : -1;
+    }
+}
+/**
+ * A cutter extends past the host's hull along the named axis.
+ */
+class CutterExceedsHostError extends BooleanError {
+    constructor(payload) {
+        var _a, _b;
+        super(payload);
+        this.name = "CutterExceedsHostError";
+        const axis = ((_a = payload.kind.axis) !== null && _a !== void 0 ? _a : "x").toLowerCase();
+        this.axis = (axis === "y" || axis === "z" ? axis : "x");
+        this.overshoot = (_b = payload.kind.overshoot) !== null && _b !== void 0 ? _b : 0;
+    }
+}
+/**
+ * Output mesh has open or over-shared edges after a boolean. `edgeSamples`
+ * carries up to ~8 sample non-manifold edges to aid app-side debugging.
+ */
+class NonManifoldOutputError extends BooleanError {
+    constructor(payload) {
+        super(payload);
+        this.name = "NonManifoldOutputError";
+    }
+}
+/**
+ * Cutter and host share a coplanar face. Distinct from
+ * `DegenerateTriangleError` (zero-area input) — see `06a-snap-tolerance.md`.
+ */
+class CoincidentFacesError extends BooleanError {
+    constructor(payload) {
+        super(payload);
+        this.name = "CoincidentFacesError";
+    }
+}
+/**
+ * Parses a WASM-thrown error and returns the appropriate typed `BooleanError`
+ * subclass. If the error's message is not valid `BooleanError` JSON, returns a
+ * fallback `BooleanError` with `reason: "kernel_failure"` carrying the original
+ * string, so callers always get a typed error and never have to `try/catch`
+ * twice.
+ */
+function parseBooleanError(raw) {
+    var _a, _b, _c, _d, _e;
+    const message = extractMessage(raw);
+    let payload = null;
+    try {
+        const parsed = JSON.parse(message);
+        if (parsed && typeof parsed === "object" && parsed.kind && typeof parsed.kind === "object") {
+            payload = {
+                kind: parsed.kind,
+                phase: ((_a = parsed.phase) !== null && _a !== void 0 ? _a : "input_validation"),
+                cutter_index: (_b = parsed.cutter_index) !== null && _b !== void 0 ? _b : null,
+                message: (_c = parsed.message) !== null && _c !== void 0 ? _c : message,
+                details: (_d = parsed.details) !== null && _d !== void 0 ? _d : null,
+                edge_samples: (_e = parsed.edge_samples) !== null && _e !== void 0 ? _e : null,
+            };
+        }
+    }
+    catch (_f) {
+        payload = null;
+    }
+    if (!payload) {
+        payload = {
+            kind: { code: "kernel_failure" },
+            phase: "input_validation",
+            cutter_index: null,
+            message,
+            details: null,
+            edge_samples: null,
+        };
+    }
+    switch (payload.kind.code) {
+        case "overlapping_cutters":
+            return new OverlappingCuttersError(payload);
+        case "cutter_exceeds_host":
+            return new CutterExceedsHostError(payload);
+        case "non_manifold_edges":
+        case "open_shell":
+            return new NonManifoldOutputError(payload);
+        case "coincident_faces":
+            return new CoincidentFacesError(payload);
+        default:
+            return new BooleanError(payload);
+    }
+}
+function extractMessage(raw) {
+    if (raw === null || raw === undefined) {
+        return "";
+    }
+    if (typeof raw === "string") {
+        return raw;
+    }
+    if (raw instanceof Error) {
+        return raw.message;
+    }
+    if (typeof raw === "object" && "message" in raw) {
+        const message = raw.message;
+        if (typeof message === "string") {
+            return message;
+        }
+    }
+    try {
+        return String(raw);
+    }
+    catch (_a) {
+        return "Unknown boolean error";
+    }
+}
+
 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, host = null) {
+        var _a, _b;
         super();
         this.report = null;
         this.brepSerialized = "";
@@ -7448,15 +7763,47 @@ 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) {
+        const metadata = resolveOperandMetadata(host);
+        if (metadata.name) {
+            this.name = metadata.name;
+        }
+        if (metadata.userData) {
+            this.userData = Object.assign({}, metadata.userData);
+        }
+        this.applyKernelResult(kernelResult, options, metadata.material);
+        if ((_b = options === null || options === void 0 ? void 0 : options.outline) !== null && _b !== void 0 ? _b : false) {
             this.outline = true;
         }
     }
+    /**
+     * Updates the result mesh's color in place without re-running the boolean
+     * pipeline. Accepts any value Three.js accepts (`number`, hex string, css
+     * color name, or `THREE.Color`). No-op for materials without a `color` field.
+     */
+    set color(value) {
+        const apply = (material) => {
+            if ("color" in material) {
+                material.color.set(value);
+            }
+            material.needsUpdate = true;
+        };
+        if (Array.isArray(this.material)) {
+            this.material.forEach(apply);
+            return;
+        }
+        apply(this.material);
+    }
+    get color() {
+        const material = Array.isArray(this.material) ? this.material[0] : this.material;
+        if (!material || !("color" in material)) {
+            return null;
+        }
+        return material.color;
+    }
     /**
      * 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 +7814,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) {
@@ -7602,12 +7941,21 @@ 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);
+    let kernelResult;
+    try {
+        kernelResult = kernelFunction(resolveOperandSerialized(lhs), JSON.stringify(cutters.map(resolveOperandPayload)), kernelOptions);
+    }
+    catch (error) {
+        throw parseBooleanError(error);
+    }
+    return createBooleanResult(kernelResult, options, lhs);
 }
 /**
  * Normalizes mixed wrapper/raw operands, invokes the wasm boolean export, and
  * returns the renderable result wrapper.
+ *
+ * @throws {BooleanError} (or a subclass) when the kernel rejects the operation.
+ *   See `boolean-errors.ts` for the typed hierarchy.
  */
 function executeBoolean(exportName, lhs, rhs, options) {
     const booleanExport = OGKernel[exportName];
@@ -7616,8 +7964,14 @@ 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);
+    let kernelResult;
+    try {
+        kernelResult = kernelFunction(resolveOperandSerialized(lhs), resolveOperandSerialized(rhs), kernelOptions);
+    }
+    catch (error) {
+        throw parseBooleanError(error);
+    }
+    return createBooleanResult(kernelResult, options, lhs);
 }
 /**
  * Accepts wrapper objects, raw BRep data, or serialized JSON and normalizes
@@ -7673,14 +8027,76 @@ function serializeKernelOptions(options) {
         merge_coplanar_faces: options.mergeCoplanarFaces,
     });
 }
-function createBooleanResult(kernelResult, options) {
+function createBooleanResult(kernelResult, options, host = null) {
     var _a;
-    const result = new BooleanResult(kernelResult, options);
+    const result = new BooleanResult(kernelResult, options, host);
     if ((_a = options === null || options === void 0 ? void 0 : options.outline) !== null && _a !== void 0 ? _a : true) {
         result.outline = true;
     }
     return result;
 }
+/**
+ * Returns the material, name, and userData carried on the operand when it is
+ * a Three mesh subclass (Solid, Polygon, Cuboid, Opening, BooleanResult,
+ * etc.) so the result mesh can drop into a scene graph as-is. Falls back to
+ * empty metadata for serialized JSON, parsed BRep objects, or anything else
+ * without a reachable host mesh.
+ */
+function resolveOperandMetadata(operand) {
+    var _a, _b, _c;
+    const empty = { material: null, name: "", userData: null };
+    if (operand === null || typeof operand !== "object" || !(operand instanceof THREE.Mesh)) {
+        return empty;
+    }
+    const rawMaterial = operand.material;
+    let material = null;
+    if (Array.isArray(rawMaterial)) {
+        material = (_a = rawMaterial[0]) !== null && _a !== void 0 ? _a : null;
+    }
+    else if (rawMaterial instanceof THREE.Material) {
+        material = rawMaterial;
+    }
+    return {
+        material,
+        name: (_b = operand.name) !== null && _b !== void 0 ? _b : "",
+        userData: (_c = operand.userData) !== null && _c !== void 0 ? _c : 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: false,
+            opacity: 1,
+            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.
@@ -9159,7 +9575,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.
  */
@@ -9704,7 +10119,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.
  */
@@ -10302,7 +10716,61 @@ function buildWallOutline(left, right) {
     }
     return outline;
 }
-function createWallFromOffsetsExample(scene) {
+function midpoint(a, b) {
+    return new Vector3((a.x + b.x) * 0.5, (a.y + b.y) * 0.5, (a.z + b.z) * 0.5);
+}
+function buildDoorCutters(centerlinePoints, count, overshootMeters, wallThickness, doorHeight) {
+    const cutters = [];
+    const wallDepth = wallThickness + 2 * overshootMeters;
+    const doorWidth = 0.6;
+    const segments = centerlinePoints.length - 1;
+    const stride = Math.max(1, Math.floor(segments / count));
+    for (let doorIdx = 0; doorIdx < count; doorIdx++) {
+        const segmentIdx = Math.min(segments - 1, doorIdx * stride);
+        const a = centerlinePoints[segmentIdx];
+        const b = centerlinePoints[segmentIdx + 1];
+        const mid = midpoint(a, b);
+        cutters.push(new Cuboid({
+            width: doorWidth,
+            height: doorHeight,
+            depth: wallDepth,
+            center: new Vector3(0, 0, 0),
+            translation: new Vector3(mid.x, doorHeight * 0.5 + 0.001, mid.z),
+            color: 0xef4444,
+        }));
+    }
+    return cutters;
+}
+/**
+ * Renders a human-readable description for a typed `BooleanError` (or any
+ * other thrown value). Used by the example HTML to surface kernel failures
+ * in a status panel without losing the structured payload.
+ */
+function describeWallSubtractError(error) {
+    var _a, _b, _c, _d, _e;
+    if (error instanceof OverlappingCuttersError) {
+        return `OverlappingCuttersError @ cutter #${error.cutterIndex} (other #${error.otherIndex}): ${(_a = error.details) !== null && _a !== void 0 ? _a : error.message}`;
+    }
+    if (error instanceof CutterExceedsHostError) {
+        return `CutterExceedsHostError: cutter overshoots ${error.axis} by ${error.overshoot.toExponential(3)}`;
+    }
+    if (error instanceof CoincidentFacesError) {
+        return `CoincidentFacesError: ${(_b = error.details) !== null && _b !== void 0 ? _b : error.message}`;
+    }
+    if (error instanceof NonManifoldOutputError) {
+        const samples = (_d = (_c = error.edgeSamples) === null || _c === void 0 ? void 0 : _c.length) !== null && _d !== void 0 ? _d : 0;
+        return `NonManifoldOutputError: ${samples} non-manifold edges sampled — ${(_e = error.details) !== null && _e !== void 0 ? _e : error.message}`;
+    }
+    if (error instanceof BooleanError) {
+        return `BooleanError (${error.reason}, phase ${error.phase}): ${error.message}`;
+    }
+    if (error instanceof Error) {
+        return `Untyped error: ${error.message}`;
+    }
+    return `Untyped error: ${String(error)}`;
+}
+function createWallFromOffsetsExample(scene, options = {}) {
+    var _a, _b, _c, _d;
     const centerline = new Polyline({
         points: [
             new Vector3(-2.6, 0.0, -1.9),
@@ -10318,6 +10786,7 @@ function createWallFromOffsetsExample(scene) {
     const half = wallThickness * 0.5;
     const acuteThreshold = 35.0;
     const bevel = true;
+    const wallHeight = (_a = options.height) !== null && _a !== void 0 ? _a : 2.6;
     const leftOffset = centerline.getOffset(half, acuteThreshold, bevel);
     const rightOffset = centerline.getOffset(-0.225, acuteThreshold, bevel);
     const leftOffsetPolyline = new Polyline({
@@ -10341,6 +10810,34 @@ function createWallFromOffsetsExample(scene) {
     scene.add(leftOffsetPolyline);
     scene.add(rightOffsetPolyline);
     scene.add(wallPolygon);
+    let cutResult = null;
+    let cutError = null;
+    if (((_b = options.doorCount) !== null && _b !== void 0 ? _b : 0) > 0) {
+        const overshootMeters = ((_c = options.overshootMm) !== null && _c !== void 0 ? _c : 1) * 0.001;
+        const wallSolid = wallPolygon.extrude(wallHeight);
+        const cutters = buildDoorCutters([
+            new Vector3(-2.6, 0.0, -1.9),
+            new Vector3(-1.2, 0.0, -1),
+            new Vector3(-0.2, 0.0, 0.1),
+            new Vector3(0.6, 0.0, 0.2),
+            new Vector3(0.1, 0.0, 1.0),
+            new Vector3(2.6, 0.0, 2.0),
+        ], (_d = options.doorCount) !== null && _d !== void 0 ? _d : 0, overshootMeters, wallThickness, 2.1);
+        try {
+            const cutWall = wallSolid.subtract(cutters, {
+                color: 0x3b82f6,
+                transparent: false,
+                opacity: 1,
+            });
+            scene.add(cutWall);
+            cutResult = { wall: cutWall, cutters };
+        }
+        catch (error) {
+            cutError = error;
+            scene.add(wallSolid);
+            cutResult = { wall: wallSolid, cutters };
+        }
+    }
     return {
         centerline,
         leftOffsetPolyline,
@@ -10348,6 +10845,8 @@ function createWallFromOffsetsExample(scene) {
         wallPolygon,
         leftOffset,
         rightOffset,
+        cutResult,
+        cutError,
     };
 }
 
@@ -10710,5 +11209,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, executeBooleanSubtractionMany, extrudeBrepFace, toObjectTransformation$1 as toObjectTransformation };
+export { Arc, BooleanError, BooleanResult, CoincidentFacesError, Cuboid, Curve, CutterExceedsHostError, Cylinder, FreeformEditor, FreeformGeometry, Line, NonManifoldOutputError, OGSceneManager, OpenGeometry, Opening, OverlappingCuttersError, Polygon, Polyline, Rectangle, Solid, Sphere, SpotLabel, Sweep, Vector3, Wedge, booleanIntersection, booleanSubtraction, booleanUnion, clonePlacement, createBooleanExample, createEditorModesExample, createFreeformEditor, createFreeformGeometry, createOffsetExample, createParametricEditCapabilities, createPrimitivesExample, createShapesExample, createSweepExample, createWallFromOffsetsExample, describeWallSubtractError, executeBooleanSubtractionMany, extrudeBrepFace, parseBooleanError, toObjectTransformation$1 as toObjectTransformation };
 //# sourceMappingURL=index.js.map