@jgphilpott/polytree 0.0.7 → 0.0.9

package/polytree.bundle.browser.js

@@ -0,0 +1,3998 @@
+// Generated by CoffeeScript 2.7.0
+import { Vector2, Vector3, Box3, Line3, Sphere, Matrix3, Triangle, Ray, Raycaster, Mesh, DoubleSide, BufferGeometry, BufferAttribute, Plane as ThreePlane } from "three";
+// Generated by CoffeeScript 2.7.0
+// =============================================================================
+// MATHEMATICAL CONSTANTS
+// Constants used for floating-point precision, geometry, and mathematical operations.
+// =============================================================================
+// Floating-point tolerance for general geometric operations.
+var ASYNC_OPERATION_TIMEOUT, DEBUG_COLOR_BACK, DEBUG_COLOR_COPLANAR, DEBUG_COLOR_FRONT, DEBUG_COLOR_SPANNING, DEBUG_GEOMETRY_VALIDATION, DEBUG_INTERSECTION_VERIFICATION, DEBUG_PERFORMANCE_TIMING, DEBUG_VERBOSE_LOGGING, DEFAULT_BUFFER_SIZE, DEFAULT_COORDINATE_PRECISION, DEFAULT_MATERIAL_INDEX, GARBAGE_COLLECTION_THRESHOLD, GEOMETRIC_EPSILON, GEOMETRY_CACHE_SIZE, INTERSECTION_CACHE_SIZE, MAX_REFINEMENT_ITERATIONS, MAX_WORKER_THREADS, MEMORY_USAGE_WARNING_LIMIT, POINT_COINCIDENCE_THRESHOLD, POLYGON_BACK, POLYGON_COPLANAR, POLYGON_FRONT, POLYGON_SPANNING, POLYTREE_MAX_DEPTH, POLYTREE_MAX_POLYGONS_PER_NODE, POLYTREE_MIN_NODE_SIZE, RAY_INTERSECTION_EPSILON, TRIANGLE_2D_EPSILON, WINDING_NUMBER_FULL_ROTATION, defaultRayDirection, meshOperationNormalVector, meshOperationVertexVector, polygonID, rayTriangleEdge1, rayTriangleEdge2, rayTriangleHVector, rayTriangleQVector, rayTriangleSVector, temporaryBoundingBox, temporaryMatrix3, temporaryMatrixWithNormalCalc, temporaryRay, temporaryRaycaster, temporaryTriangleVertex, temporaryTriangleVertexSecondary, temporaryVector3Primary, temporaryVector3Quaternary, temporaryVector3Secondary, temporaryVector3Tertiary, windingNumberEpsilonOffsets, windingNumberEpsilonOffsetsCount, windingNumberMatrix3, windingNumberTestPoint, windingNumberVector1, windingNumberVector2, windingNumberVector3;
+GEOMETRIC_EPSILON = 1e-8;
+// Ultra-high precision tolerance for ray-triangle intersection calculations.
+RAY_INTERSECTION_EPSILON = 1e-12;
+// 2D geometry tolerance for triangle overlap calculations.
+TRIANGLE_2D_EPSILON = 1e-14;
+// Full rotation constant (4π) used in winding number calculations.
+WINDING_NUMBER_FULL_ROTATION = 4 * Math.PI;
+// =============================================================================
+// POLYGON CLASSIFICATION CONSTANTS
+// Used for determining spatial relationships between polygons and planes.
+// =============================================================================
+// Polygon lies exactly on the splitting plane.
+POLYGON_COPLANAR = 0;
+// Polygon lies entirely in front of the splitting plane.
+POLYGON_FRONT = 1;
+// Polygon lies entirely behind the splitting plane
+POLYGON_BACK = 2;
+// Polygon crosses the splitting plane (requires splitting).
+POLYGON_SPANNING = 3;
+// =============================================================================
+// GENERAL PURPOSE TEMPORARY OBJECTS
+// Reusable objects to avoid memory allocation during calculations.
+// =============================================================================
+// Primary temporary vector for general 3D calculations.
+temporaryVector3Primary = new Vector3();
+// Secondary temporary vector for 3D calculations when two vectors needed.
+temporaryVector3Secondary = new Vector3();
+// Tertiary temporary vector for calculations requiring three vectors.
+temporaryVector3Tertiary = new Vector3();
+// Quaternary temporary vector for triangle-specific calculations.
+temporaryVector3Quaternary = new Vector3();
+// Temporary bounding box for spatial calculations.
+temporaryBoundingBox = new Box3();
+// Temporary raycaster for intersection calculations.
+temporaryRaycaster = new Raycaster();
+// Temporary ray object for geometric queries.
+temporaryRay = new Ray();
+// Default ray direction pointing along positive Z-axis.
+defaultRayDirection = new Vector3(0, 0, 1);
+// =============================================================================
+// WINDING NUMBER ALGORITHM VARIABLES
+// Used for point-in-polygon testing using the winding number method.
+// =============================================================================
+// First vertex vector relative to test point.
+windingNumberVector1 = new Vector3();
+// Second vertex vector relative to test point.
+windingNumberVector2 = new Vector3();
+// Third vertex vector relative to test point.
+windingNumberVector3 = new Vector3();
+// Test point position vector.
+windingNumberTestPoint = new Vector3();
+// Epsilon offset vectors for handling edge cases in winding number calculation.
+windingNumberEpsilonOffsets = [new Vector3(GEOMETRIC_EPSILON, 0, 0), new Vector3(0, GEOMETRIC_EPSILON, 0), new Vector3(0, 0, GEOMETRIC_EPSILON), new Vector3(-GEOMETRIC_EPSILON, 0, 0), new Vector3(0, -GEOMETRIC_EPSILON, 0), new Vector3(0, 0, -GEOMETRIC_EPSILON)];
+// Count of epsilon offset vectors for iteration.
+windingNumberEpsilonOffsetsCount = windingNumberEpsilonOffsets.length;
+// 3x3 matrix for winding number determinant calculations.
+windingNumberMatrix3 = new Matrix3();
+// =============================================================================
+// RAY-TRIANGLE INTERSECTION VARIABLES
+// Used in Möller–Trumbore ray-triangle intersection algorithm.
+// =============================================================================
+// Triangle edge vector from vertex A to vertex B.
+rayTriangleEdge1 = new Vector3();
+// Triangle edge vector from vertex A to vertex C.
+rayTriangleEdge2 = new Vector3();
+// Cross product of ray direction and second edge.
+rayTriangleHVector = new Vector3();
+// Vector from ray origin to triangle vertex A.
+rayTriangleSVector = new Vector3();
+// Cross product for final intersection calculation.
+rayTriangleQVector = new Vector3();
+// =============================================================================
+// MATRIX AND TRANSFORMATION VARIABLES
+// Used for coordinate transformations and matrix operations.
+// =============================================================================
+// Temporary vertex position for geometric calculations.
+temporaryTriangleVertex = new Vector3();
+// Second temporary vertex for calculations requiring multiple vertices.
+temporaryTriangleVertexSecondary = new Vector3();
+// Temporary 3x3 matrix for normal transformations and general calculations.
+temporaryMatrix3 = new Matrix3();
+// Extended temporary matrix with normal matrix calculation method.
+temporaryMatrixWithNormalCalc = new Matrix3();
+// Method to calculate normal matrix from 4x4 transformation matrix.
+temporaryMatrixWithNormalCalc.getNormalMatrix = function(matrix) {
+  return this.setFromMatrix4(matrix).invert().transpose();
+};
+// Temporary vector for mesh normal calculations and geometry operations.
+meshOperationNormalVector = new Vector3();
+// Temporary vertex vector for mesh transformation and vertex operations.
+meshOperationVertexVector = new Vector3();
+// =============================================================================
+// CSG AND POLYTREE OPERATION VARIABLES
+// Variables for Constructive Solid Geometry and spatial partitioning.
+// =============================================================================
+// Maximum subdivision depth for polytree structures.
+POLYTREE_MAX_DEPTH = 1000;
+// Maximum polygons per polytree node before subdivision.
+POLYTREE_MAX_POLYGONS_PER_NODE = 100000;
+// Minimum polytree node size to prevent excessive subdivision.
+POLYTREE_MIN_NODE_SIZE = 1e-6;
+// Default material index for CSG operations.
+DEFAULT_MATERIAL_INDEX = 0;
+// Maximum iterations for iterative refinement algorithms.
+MAX_REFINEMENT_ITERATIONS = 10000;
+// =============================================================================
+// PERFORMANCE AND OPTIMIZATION VARIABLES
+// Settings for balancing accuracy vs performance.
+// =============================================================================
+// Default precision for point coordinate rounding.
+DEFAULT_COORDINATE_PRECISION = 15;
+// Threshold for considering two points as identical.
+POINT_COINCIDENCE_THRESHOLD = 1e-15;
+// Buffer size for batch processing operations.
+DEFAULT_BUFFER_SIZE = 16384;
+// Maximum number of worker threads for parallel processing.
+MAX_WORKER_THREADS = 2e308;
+// Timeout for async operations (in milliseconds).
+ASYNC_OPERATION_TIMEOUT = 2e308;
+// Memory management thresholds.
+GARBAGE_COLLECTION_THRESHOLD = 100000;
+MEMORY_USAGE_WARNING_LIMIT = 0.95;
+// Cache size limits.
+GEOMETRY_CACHE_SIZE = 2e308;
+INTERSECTION_CACHE_SIZE = 2e308;
+// =============================================================================
+// POLYGON ID MANAGEMENT
+// Global counter for assigning unique IDs to polygon instances.
+// =============================================================================
+// Global polygon ID counter for unique polygon identification.
+polygonID = 0;
+// =============================================================================
+// DEBUGGING AND DEVELOPMENT VARIABLES
+// Variables useful for debugging and development.
+// =============================================================================
+// Enable detailed logging for debugging.
+DEBUG_VERBOSE_LOGGING = false;
+// Enable performance timing measurements.
+DEBUG_PERFORMANCE_TIMING = false;
+// Enable geometry validation checks.
+DEBUG_GEOMETRY_VALIDATION = false;
+// Enable intersection result verification.
+DEBUG_INTERSECTION_VERIFICATION = false;
+// Color codes for debug visualization.
+DEBUG_COLOR_FRONT = 0x00ff00;
+DEBUG_COLOR_BACK = 0xff0000;
+DEBUG_COLOR_COPLANAR = 0x0000ff;
+DEBUG_COLOR_SPANNING = 0xffff00;
+// =============================================================================
+// EXPORTS FOR TESTING
+// Export all variables so they can be tested.
+// =============================================================================
+// Only export when in a testing environment (when module.exports exists).
+if (typeof module !== 'undefined' && module.exports) {
+  // Mathematical Constants
+          // Polygon Classification Constants
+          // General Purpose Temporary Objects
+                  // Winding Number Algorithm Variables
+                // Ray-Triangle Intersection Variables
+            // Matrix and Transformation Variables
+              // CSG and Polytree Operation Variables
+            // Performance and Optimization Variables
+                    // Polygon ID Management
+    // Debugging and Development Variables
+                }
+// Generated by CoffeeScript 2.7.0
+// === BUFFER UTILITIES ===
+// Simple LRU cache for intersection results to improve performance.
+var calculateWindingNumberFromBuffer, checkMemoryUsage, clearGeometryCache, clearIntersectionCache, createIntersectionCacheKey, createVector2Buffer, createVector3Buffer, disposePolytreeResources, extractCoordinatesFromArray, geometryCache, geometryCacheKeys, handleIntersectingPolytrees, intersectionCache, intersectionCacheKeys, operationCounter, prepareTriangleBufferFromPolygons, roundPointCoordinates, sortRaycastIntersectionsByDistance, splitPolygonByPlane, splitPolygonVertexArray, testPolygonInsideUsingWindingNumber, testRayTriangleIntersection;
+intersectionCache = new Map();
+intersectionCacheKeys = [];
+// Geometry calculation cache for expensive operations.
+geometryCache = new Map();
+geometryCacheKeys = [];
+// Operation counter for garbage collection threshold tracking.
+operationCounter = 0;
+// Clear intersection cache when it exceeds size limit.
+clearIntersectionCache = function() {
+  var i, key, keysToRemove, len, results;
+  if (INTERSECTION_CACHE_SIZE !== 2e308 && intersectionCache.size > INTERSECTION_CACHE_SIZE) {
+    // Remove oldest entries (simple FIFO approach).
+    keysToRemove = intersectionCacheKeys.splice(0, Math.floor(INTERSECTION_CACHE_SIZE / 2));
+    results = [];
+    for (i = 0, len = keysToRemove.length; i < len; i++) {
+      key = keysToRemove[i];
+      results.push(intersectionCache.delete(key));
+    }
+    return results;
+  }
+};
+// Clear geometry cache when it exceeds size limit.
+clearGeometryCache = function() {
+  var i, key, keysToRemove, len, results;
+  if (GEOMETRY_CACHE_SIZE !== 2e308 && geometryCache.size > GEOMETRY_CACHE_SIZE) {
+    // Remove oldest entries (simple FIFO approach).
+    keysToRemove = geometryCacheKeys.splice(0, Math.floor(GEOMETRY_CACHE_SIZE / 2));
+    results = [];
+    for (i = 0, len = keysToRemove.length; i < len; i++) {
+      key = keysToRemove[i];
+      results.push(geometryCache.delete(key));
+    }
+    return results;
+  }
+};
+// Create cache key from two polygons.
+createIntersectionCacheKey = function(polygonA, polygonB) {
+  return `${polygonA.id}_${polygonB.id}`;
+};
+// Memory management utilities.
+checkMemoryUsage = function() {
+  var heapTotalMB, heapUsedMB, memoryUsage, usageRatio;
+  if (typeof process !== 'undefined' && process.memoryUsage) {
+    memoryUsage = process.memoryUsage();
+    heapUsedMB = memoryUsage.heapUsed / 1024 / 1024;
+    heapTotalMB = memoryUsage.heapTotal / 1024 / 1024;
+    usageRatio = memoryUsage.heapUsed / memoryUsage.heapTotal;
+    if (DEBUG_VERBOSE_LOGGING) {
+      console.log(`Memory usage: ${heapUsedMB.toFixed(2)}MB / ${heapTotalMB.toFixed(2)}MB (${(usageRatio * 100).toFixed(1)}%)`);
+    }
+    if (usageRatio > MEMORY_USAGE_WARNING_LIMIT) {
+      console.warn(`Memory usage is high: ${(usageRatio * 100).toFixed(1)}%`);
+      if (typeof (typeof global !== "undefined" && global !== null ? global.gc : void 0) === 'function') {
+        console.log("Triggering garbage collection...");
+        global.gc();
+      }
+    }
+    return usageRatio;
+  }
+  return 0;
+};
+// Create a 2D vector buffer with write functionality.
+// This helper provides efficient storage and writing of 2D vector data.
+// @param vectorCount - The number of vectors this buffer can hold (defaults to DEFAULT_BUFFER_SIZE).
+// @return Buffer object with write method and Float32Array storage.
+createVector2Buffer = function(vectorCount = DEFAULT_BUFFER_SIZE) {
+  return {
+    top: 0,
+    array: new Float32Array(vectorCount * 2),
+    write: function(vector) {
+      this.array[this.top++] = vector.x;
+      return this.array[this.top++] = vector.y;
+    }
+  };
+};
+// Create a 3D vector buffer with write functionality.
+// This helper provides efficient storage and writing of 3D vector data.
+// @param vectorCount - The number of vectors this buffer can hold (defaults to DEFAULT_BUFFER_SIZE).
+// @return Buffer object with write method and Float32Array storage.
+createVector3Buffer = function(vectorCount = DEFAULT_BUFFER_SIZE) {
+  return {
+    top: 0,
+    array: new Float32Array(vectorCount * 3),
+    write: function(vector) {
+      this.array[this.top++] = vector.x;
+      this.array[this.top++] = vector.y;
+      return this.array[this.top++] = vector.z;
+    }
+  };
+};
+// === POINT AND GEOMETRIC UTILITIES ===
+// Sort raycast intersections by distance in ascending order.
+// Used for ordering ray intersection results from closest to farthest.
+// @param intersectionA - First intersection object with distance property.
+// @param intersectionB - Second intersection object with distance property.
+// @return Comparison result for sorting (-1, 0, or 1).
+sortRaycastIntersectionsByDistance = function(intersectionA, intersectionB) {
+  return intersectionA.distance - intersectionB.distance;
+};
+// Round point coordinates to specified decimal precision.
+// This helps eliminate floating point precision errors in geometric calculations.
+// @param point - Vector3 point to round.
+// @param decimalPlaces - Number of decimal places to round to (defaults to DEFAULT_COORDINATE_PRECISION).
+// @return The same point object with rounded coordinates.
+roundPointCoordinates = function(point, decimalPlaces = DEFAULT_COORDINATE_PRECISION) {
+  point.x = +point.x.toFixed(decimalPlaces);
+  point.y = +point.y.toFixed(decimalPlaces);
+  point.z = +point.z.toFixed(decimalPlaces);
+  return point;
+};
+// Extract XYZ coordinates from a flat array at the specified index.
+// Helper for working with triangle buffer data in winding number calculations.
+// @param coordinatesArray - Float32Array containing XYZ coordinates.
+// @param startIndex - Starting index in the array.
+// @return Object with x, y, z properties.
+extractCoordinatesFromArray = function(coordinatesArray, startIndex) {
+  return {
+    x: coordinatesArray[startIndex],
+    y: coordinatesArray[startIndex + 1],
+    z: coordinatesArray[startIndex + 2]
+  };
+};
+// === POLYGON OPERATIONS ===
+// Split a polygon by a plane into front and back fragments.
+// This is a core CSG operation that classifies polygon parts relative to a plane.
+// The algorithm handles coplanar, front, back, and spanning polygon cases.
+// @param polygon - The polygon to split.
+// @param plane - The cutting plane with normal and distance properties.
+// @param result - Array to store results (optional).
+// @return Array of polygon fragments with classification types.
+splitPolygonByPlane = function(polygon, plane, result = []) {
+  var backPolygonFragments, backVertices, currentVertex, currentVertexType, distanceToPlane, fragmentIndex, frontPolygonFragments, frontVertices, i, interpolatedVertex, intersectionParameter, j, k, l, nextVertex, nextVertexIndex, nextVertexType, polygonType, ref, ref1, ref2, ref3, returnPolygon, vertexIndex, vertexType, vertexTypes;
+  returnPolygon = {
+    polygon: polygon,
+    type: "undecided"
+  };
+  polygonType = 0;
+  vertexTypes = [];
+// Classify each vertex relative to the plane.
+  for (vertexIndex = i = 0, ref = polygon.vertices.length; (0 <= ref ? i < ref : i > ref); vertexIndex = 0 <= ref ? ++i : --i) {
+    distanceToPlane = plane.normal.dot(polygon.vertices[vertexIndex].pos) - plane.distanceFromOrigin;
+    vertexType = distanceToPlane < -GEOMETRIC_EPSILON ? POLYGON_BACK : distanceToPlane > GEOMETRIC_EPSILON ? POLYGON_FRONT : POLYGON_COPLANAR;
+    polygonType |= vertexType;
+    vertexTypes.push(vertexType);
+  }
+  // Handle polygon classification based on vertex types.
+  switch (polygonType) {
+    case POLYGON_COPLANAR:
+      returnPolygon.type = plane.normal.dot(polygon.plane.normal) > 0 ? "coplanar-front" : "coplanar-back";
+      if (DEBUG_VERBOSE_LOGGING) {
+        console.log("Polygon classified as COPLANAR, debug color:", DEBUG_COLOR_COPLANAR.toString(16));
+      }
+      result.push(returnPolygon);
+      break;
+    case POLYGON_FRONT:
+      returnPolygon.type = "front";
+      result.push(returnPolygon);
+      if (DEBUG_VERBOSE_LOGGING) {
+        console.log("Polygon classified as FRONT, debug color:", DEBUG_COLOR_FRONT.toString(16));
+      }
+      break;
+    case POLYGON_BACK:
+      returnPolygon.type = "back";
+      result.push(returnPolygon);
+      if (DEBUG_VERBOSE_LOGGING) {
+        console.log("Polygon classified as BACK, debug color:", DEBUG_COLOR_BACK.toString(16));
+      }
+      break;
+    case POLYGON_SPANNING:
+      if (DEBUG_VERBOSE_LOGGING) {
+        console.log("Polygon classified as SPANNING, debug color:", DEBUG_COLOR_SPANNING.toString(16));
+      }
+      frontVertices = [];
+      backVertices = [];
+// Process each edge to build front and back vertex lists.
+      for (vertexIndex = j = 0, ref1 = polygon.vertices.length; (0 <= ref1 ? j < ref1 : j > ref1); vertexIndex = 0 <= ref1 ? ++j : --j) {
+        nextVertexIndex = (vertexIndex + 1) % polygon.vertices.length;
+        currentVertexType = vertexTypes[vertexIndex];
+        nextVertexType = vertexTypes[nextVertexIndex];
+        currentVertex = polygon.vertices[vertexIndex];
+        nextVertex = polygon.vertices[nextVertexIndex];
+        // Add vertex to front list if not behind plane.
+        if (currentVertexType !== POLYGON_BACK) {
+          frontVertices.push(currentVertex);
+        }
+        // Add vertex to back list if not in front of plane.
+        if (currentVertexType !== POLYGON_FRONT) {
+          backVertices.push(currentVertexType !== POLYGON_BACK ? currentVertex.clone() : currentVertex);
+        }
+        // Handle edge intersections with the plane.
+        if ((currentVertexType | nextVertexType) === POLYGON_SPANNING) {
+          intersectionParameter = (plane.distanceFromOrigin - plane.normal.dot(currentVertex.pos)) / plane.normal.dot(temporaryTriangleVertex.copy(nextVertex.pos).sub(currentVertex.pos));
+          interpolatedVertex = currentVertex.interpolate(nextVertex, intersectionParameter);
+          frontVertices.push(interpolatedVertex);
+          backVertices.push(interpolatedVertex.clone());
+        }
+      }
+      // Create front polygon fragments if we have enough vertices.
+      if (frontVertices.length >= 3) {
+        if (frontVertices.length > 3) {
+          frontPolygonFragments = splitPolygonVertexArray(frontVertices);
+          for (fragmentIndex = k = 0, ref2 = frontPolygonFragments.length; (0 <= ref2 ? k < ref2 : k > ref2); fragmentIndex = 0 <= ref2 ? ++k : --k) {
+            result.push({
+              polygon: new Polygon(frontPolygonFragments[fragmentIndex], polygon.shared),
+              type: "front"
+            });
+          }
+        } else {
+          result.push({
+            polygon: new Polygon(frontVertices, polygon.shared),
+            type: "front"
+          });
+        }
+      }
+      // Create back polygon fragments if we have enough vertices.
+      if (backVertices.length >= 3) {
+        if (backVertices.length > 3) {
+          backPolygonFragments = splitPolygonVertexArray(backVertices);
+          for (fragmentIndex = l = 0, ref3 = backPolygonFragments.length; (0 <= ref3 ? l < ref3 : l > ref3); fragmentIndex = 0 <= ref3 ? ++l : --l) {
+            result.push({
+              polygon: new Polygon(backPolygonFragments[fragmentIndex], polygon.shared),
+              type: "back"
+            });
+          }
+        } else {
+          result.push({
+            polygon: new Polygon(backVertices, polygon.shared),
+            type: "back"
+          });
+        }
+      }
+  }
+  // If no fragments were created, return the original polygon.
+  if (result.length === 0) {
+    result.push(returnPolygon);
+  }
+  return result;
+};
+// Split a polygon vertex array into triangulated fragments.
+// This handles polygons with more than 3 vertices by creating triangle fans.
+// @param vertexArray - Array of vertices to triangulate.
+// @return Array of vertex arrays, each representing a triangle.
+splitPolygonVertexArray = function(vertexArray) {
+  var i, ref, triangleFragments, triangleIndex, triangleVertices;
+  triangleFragments = [];
+  // Handle polygons with more than 4 vertices using fan triangulation.
+  if (vertexArray.length > 4) {
+    console.warn("[splitPolygonVertexArray] vertexArray.length > 4", vertexArray.length);
+    for (triangleIndex = i = 3, ref = vertexArray.length; (3 <= ref ? i <= ref : i >= ref); triangleIndex = 3 <= ref ? ++i : --i) {
+      triangleVertices = [];
+      triangleVertices.push(vertexArray[0].clone());
+      triangleVertices.push(vertexArray[triangleIndex - 2].clone());
+      triangleVertices.push(vertexArray[triangleIndex - 1].clone());
+      triangleFragments.push(triangleVertices);
+    }
+  } else {
+    // For quadrilaterals, choose the best diagonal based on distance.
+    if (vertexArray[0].pos.distanceTo(vertexArray[2].pos) <= vertexArray[1].pos.distanceTo(vertexArray[3].pos)) {
+      triangleFragments.push([vertexArray[0].clone(), vertexArray[1].clone(), vertexArray[2].clone()], [vertexArray[0].clone(), vertexArray[2].clone(), vertexArray[3].clone()]);
+    } else {
+      triangleFragments.push([vertexArray[0].clone(), vertexArray[1].clone(), vertexArray[3].clone()], [vertexArray[1].clone(), vertexArray[2].clone(), vertexArray[3].clone()]);
+    }
+  }
+  return triangleFragments;
+};
+// === WINDING NUMBER CALCULATIONS ===
+// Calculate the winding number for a point relative to triangle mesh data.
+// The winding number determines how many times the mesh winds around the test point.
+// This is used for robust inside/outside testing of complex 3D geometry.
+// @param triangleDataArray - Float32Array containing triangle vertex coordinates.
+// @param testPoint - Point to test for winding number.
+// @return Integer winding number (0 = outside, non-zero = inside).
+calculateWindingNumberFromBuffer = function(triangleDataArray, testPoint) {
+  var i, ref, solidAngle, triangleStartIndex, vectorLengthA, vectorLengthB, vectorLengthC, windingNumber;
+  windingNumber = 0;
+// Process each triangle in the buffer (9 floats per triangle: 3 vertices × 3 coordinates).
+  for (triangleStartIndex = i = 0, ref = triangleDataArray.length; i < ref; triangleStartIndex = i += 9) {
+    windingNumberVector1.subVectors(extractCoordinatesFromArray(triangleDataArray, triangleStartIndex), testPoint);
+    windingNumberVector2.subVectors(extractCoordinatesFromArray(triangleDataArray, triangleStartIndex + 3), testPoint);
+    windingNumberVector3.subVectors(extractCoordinatesFromArray(triangleDataArray, triangleStartIndex + 6), testPoint);
+    vectorLengthA = windingNumberVector1.length();
+    vectorLengthB = windingNumberVector2.length();
+    vectorLengthC = windingNumberVector3.length();
+    // Skip degenerate triangles that are too small to contribute meaningfully.
+    if (vectorLengthA < POINT_COINCIDENCE_THRESHOLD || vectorLengthB < POINT_COINCIDENCE_THRESHOLD || vectorLengthC < POINT_COINCIDENCE_THRESHOLD) {
+      continue;
+    }
+    // Calculate the solid angle using the determinant formula.
+    windingNumberMatrix3.set(windingNumberVector1.x, windingNumberVector1.y, windingNumberVector1.z, windingNumberVector2.x, windingNumberVector2.y, windingNumberVector2.z, windingNumberVector3.x, windingNumberVector3.y, windingNumberVector3.z);
+    solidAngle = 2 * Math.atan2(windingNumberMatrix3.determinant(), vectorLengthA * vectorLengthB * vectorLengthC + windingNumberVector1.dot(windingNumberVector2) * vectorLengthC + windingNumberVector2.dot(windingNumberVector3) * vectorLengthA + windingNumberVector3.dot(windingNumberVector1) * vectorLengthB);
+    windingNumber += solidAngle;
+  }
+  // Round to nearest integer to get the final winding number.
+  windingNumber = Math.round(windingNumber / WINDING_NUMBER_FULL_ROTATION);
+  return windingNumber;
+};
+// Test if a polygon is inside a mesh using winding number algorithm.
+// This provides robust inside/outside testing that handles complex cases.
+// For coplanar polygons, epsilon offsets are tested to resolve ambiguity.
+// @param triangleDataArray - Float32Array containing mesh triangle data.
+// @param testPoint - Point to test for inside/outside status.
+// @param isCoplanar - Whether the polygon is coplanar with mesh surfaces.
+// @return Boolean indicating if the polygon is inside the mesh.
+testPolygonInsideUsingWindingNumber = function(triangleDataArray, testPoint, isCoplanar) {
+  var i, isInside, maxOffsetTests, offsetIndex, ref, windingNumber;
+  isInside = false;
+  windingNumberTestPoint.copy(testPoint);
+  windingNumber = calculateWindingNumberFromBuffer(triangleDataArray, windingNumberTestPoint);
+  // For non-coplanar cases, winding number directly indicates inside/outside.
+  if (windingNumber === 0) {
+    if (isCoplanar) {
+      // For coplanar cases, test multiple epsilon-offset points.
+      // Limit iterations to prevent infinite loops in degenerate cases.
+      maxOffsetTests = Math.min(windingNumberEpsilonOffsetsCount, MAX_REFINEMENT_ITERATIONS);
+      for (offsetIndex = i = 0, ref = maxOffsetTests; (0 <= ref ? i < ref : i > ref); offsetIndex = 0 <= ref ? ++i : --i) {
+        windingNumberTestPoint.copy(testPoint).add(windingNumberEpsilonOffsets[offsetIndex]);
+        windingNumber = calculateWindingNumberFromBuffer(triangleDataArray, windingNumberTestPoint);
+        if (windingNumber !== 0) {
+          isInside = true;
+          break;
+        }
+      }
+    }
+  } else {
+    isInside = true;
+  }
+  return isInside;
+};
+// Prepare a triangle buffer from polygon array for winding number calculations.
+// This converts polygon data into a flat Float32Array for efficient processing.
+// @param polygonArray - Array of polygons to convert.
+// @return Float32Array containing triangle vertex coordinates.
+prepareTriangleBufferFromPolygons = function(polygonArray) {
+  var bufferIndex, coordinateArray, i, polygonIndex, ref, triangle, triangleCount;
+  triangleCount = polygonArray.length;
+  coordinateArray = new Float32Array(triangleCount * 3 * 3); // 3 vertices × 3 coordinates per triangle
+  bufferIndex = 0;
+  for (polygonIndex = i = 0, ref = triangleCount; (0 <= ref ? i < ref : i > ref); polygonIndex = 0 <= ref ? ++i : --i) {
+    triangle = polygonArray[polygonIndex].triangle;
+    // Store first vertex coordinates.
+    coordinateArray[bufferIndex++] = triangle.a.x;
+    coordinateArray[bufferIndex++] = triangle.a.y;
+    coordinateArray[bufferIndex++] = triangle.a.z;
+    // Store second vertex coordinates.
+    coordinateArray[bufferIndex++] = triangle.b.x;
+    coordinateArray[bufferIndex++] = triangle.b.y;
+    coordinateArray[bufferIndex++] = triangle.b.z;
+    // Store third vertex coordinates.
+    coordinateArray[bufferIndex++] = triangle.c.x;
+    coordinateArray[bufferIndex++] = triangle.c.y;
+    coordinateArray[bufferIndex++] = triangle.c.z;
+  }
+  return coordinateArray;
+};
+// === RAY-TRIANGLE INTERSECTION ===
+// Test ray-triangle intersection using the Möller–Trumbore algorithm.
+// This is a fast, efficient algorithm for ray-triangle intersection testing.
+// Returns the intersection point if found, or null if no intersection exists.
+// @param ray - Ray object with origin and direction properties.
+// @param triangle - Triangle object with a, b, c vertex properties.
+// @param targetVector - Optional Vector3 to store the intersection point.
+// @return Vector3 intersection point or null if no intersection.
+testRayTriangleIntersection = function(ray, triangle, targetVector = new Vector3()) {
+  var determinant, firstBarycentricCoordinate, intersectionDistance, inverseDeterminant, result, secondBarycentricCoordinate;
+  if (DEBUG_VERBOSE_LOGGING) {
+    console.log("Testing ray-triangle intersection with ray origin:", ray.origin, "direction:", ray.direction);
+  }
+  // Calculate triangle edge vectors.
+  rayTriangleEdge1.subVectors(triangle.b, triangle.a);
+  rayTriangleEdge2.subVectors(triangle.c, triangle.a);
+  // Calculate determinant to check if ray is parallel to triangle.
+  rayTriangleHVector.crossVectors(ray.direction, rayTriangleEdge2);
+  determinant = rayTriangleEdge1.dot(rayTriangleHVector);
+  // If determinant is near zero, ray is parallel to triangle plane.
+  if (determinant > -RAY_INTERSECTION_EPSILON && determinant < RAY_INTERSECTION_EPSILON) {
+    return null;
+  }
+  inverseDeterminant = 1 / determinant;
+  rayTriangleSVector.subVectors(ray.origin, triangle.a);
+  firstBarycentricCoordinate = inverseDeterminant * rayTriangleSVector.dot(rayTriangleHVector);
+  // Check if intersection point is outside triangle (first barycentric test).
+  if (firstBarycentricCoordinate < 0 || firstBarycentricCoordinate > 1) {
+    return null;
+  }
+  rayTriangleQVector.crossVectors(rayTriangleSVector, rayTriangleEdge1);
+  secondBarycentricCoordinate = inverseDeterminant * ray.direction.dot(rayTriangleQVector);
+  // Check if intersection point is outside triangle (second barycentric test).
+  if (secondBarycentricCoordinate < 0 || firstBarycentricCoordinate + secondBarycentricCoordinate > 1) {
+    return null;
+  }
+  // Calculate intersection distance along ray.
+  intersectionDistance = inverseDeterminant * rayTriangleEdge2.dot(rayTriangleQVector);
+  // Check if intersection is in front of ray origin.
+  if (intersectionDistance > RAY_INTERSECTION_EPSILON) {
+    result = targetVector.copy(ray.direction).multiplyScalar(intersectionDistance).add(ray.origin);
+    if (DEBUG_INTERSECTION_VERIFICATION) {
+      console.log("Ray-triangle intersection verified:", {
+        distance: intersectionDistance,
+        point: result,
+        triangle: {
+          a: triangle.a,
+          b: triangle.b,
+          c: triangle.c
+        }
+      });
+    }
+    return result;
+  }
+  return null;
+};
+// === POLYTREE MANAGEMENT ===
+// Handle intersection processing between two polytrees.
+// This coordinates the CSG intersection algorithm by preparing triangle buffers
+// and calling intersection handling methods on the polytree instances.
+// @param polytreeA - First polytree for intersection processing.
+// @param polytreeB - Second polytree for intersection processing.
+// @param processBothDirections - Whether to process intersections in both directions.
+handleIntersectingPolytrees = function(polytreeA, polytreeB, processBothDirections = true) {
+  var endTime, polytreeABuffer, polytreeBBuffer, startTime;
+  startTime = DEBUG_PERFORMANCE_TIMING ? performance.now() : 0;
+  operationCounter++; // Increment operation counter and check for GC threshold.
+  if (operationCounter >= GARBAGE_COLLECTION_THRESHOLD) {
+    operationCounter = 0;
+    clearIntersectionCache();
+    clearGeometryCache();
+    checkMemoryUsage();
+  }
+  polytreeABuffer = void 0;
+  polytreeBBuffer = void 0;
+  // Prepare triangle buffers if winding number algorithm is enabled.
+  if (Polytree.useWindingNumber === true) {
+    if (processBothDirections) {
+      polytreeABuffer = prepareTriangleBufferFromPolygons(polytreeA.getPolygons());
+    }
+    polytreeBBuffer = prepareTriangleBufferFromPolygons(polytreeB.getPolygons());
+  }
+  // Process intersections from A's perspective.
+  polytreeA.handleIntersectingPolygons(polytreeB, polytreeBBuffer);
+  // Process intersections from B's perspective if requested.
+  if (processBothDirections) {
+    polytreeB.handleIntersectingPolygons(polytreeA, polytreeABuffer);
+  }
+  // Clean up buffers to free memory.
+  if (polytreeABuffer !== void 0) {
+    polytreeABuffer = void 0;
+  }
+  if (polytreeBBuffer !== void 0) {
+    polytreeBBuffer = void 0;
+  }
+  if (DEBUG_PERFORMANCE_TIMING) {
+    endTime = performance.now();
+    polytreeBBuffer = void 0;
+    return console.log(`handleIntersectingPolytrees took ${endTime - startTime} milliseconds`);
+  }
+};
+// Dispose of polytree resources to prevent memory leaks.
+// This utility safely calls the delete method on polytree instances
+// if the disposal feature is enabled in the Polytree configuration.
+// @param polytreeInstances - Variable number of polytree instances to dispose.
+disposePolytreeResources = function(...polytreeInstances) {
+  if (Polytree.disposePolytree) {
+    return polytreeInstances.forEach(function(polytreeInstance) {
+      return polytreeInstance.delete();
+    });
+  }
+};
+// Generated by CoffeeScript 2.7.0
+// Main operation handler for processing CSG operations on Polytree objects.
+// This function handles both synchronous and asynchronous CSG operations (unite, subtract, intersect)
+// and manages the conversion between meshes and polytrees as needed.
+// @param operationObject - Object containing the operation definition with properties:
+//   - op: Operation type ('unite', 'subtract', 'intersect')
+//   - objA: First operand (mesh, polytree, or nested operation)
+//   - objB: Second operand (mesh, polytree, or nested operation)
+//   - material: Optional material for final mesh output
+// @param returnPolytrees - Whether to return polytree objects instead of meshes.
+// @param buildTargetPolytree - Whether to build the target polytree structure.
+// @param options - Configuration options including objCounter for unique IDs.
+// @param firstRun - Whether this is the top-level operation call.
+// @param async - Whether to execute asynchronously using promises.
+// @return Result mesh, polytree, or operation tree depending on parameters.
+var handleObjectForOperation, operationHandler;
+operationHandler = function(operationObject, returnPolytrees = false, buildTargetPolytree = true, options = {
+    objCounter: 0
+  }, firstRun = true, async = true) {
+  var allPolygons, defaultMaterial, finalMesh, firstOperand, materialForMesh, ref, resultPolytree, secondOperand;
+  if (async) {
+    return new Promise(function(resolve, reject) {
+      var asyncError, firstOperand, materialForMesh, operandPromise, operandPromises, originalMaterialA, originalMaterialB, ref, ref1, resultPolytree, secondOperand;
+      try {
+        // Initialize variables for the two operands and result.
+        firstOperand = void 0;
+        secondOperand = void 0;
+        resultPolytree = void 0;
+        materialForMesh = void 0;
+        // Capture original material for default use before processing operands.
+        originalMaterialA = (ref = operationObject.objA) != null ? ref.material : void 0;
+        originalMaterialB = (ref1 = operationObject.objB) != null ? ref1.material : void 0;
+        if (operationObject.material) {
+          materialForMesh = operationObject.material;
+        }
+        // Process operands in parallel for async operations.
+        operandPromises = [];
+        if (operationObject.objA) {
+          operandPromise = handleObjectForOperation(operationObject.objA, returnPolytrees, buildTargetPolytree, options, 0, async);
+          operandPromises.push(operandPromise);
+        }
+        if (operationObject.objB) {
+          operandPromise = handleObjectForOperation(operationObject.objB, returnPolytrees, buildTargetPolytree, options, 1, async);
+          operandPromises.push(operandPromise);
+        }
+        return Promise.allSettled(operandPromises).then(function(promiseResults) {
+          var operationPromise;
+          // Extract operands from promise results.
+          promiseResults.forEach(function(promiseResult) {
+            if (promiseResult.status === "fulfilled") {
+              if (promiseResult.value.objIndex === 0) {
+                return firstOperand = promiseResult.value;
+              } else if (promiseResult.value.objIndex === 1) {
+                return secondOperand = promiseResult.value;
+              }
+            }
+          });
+          // Handle polytree return mode by updating operation object references.
+          if (returnPolytrees === true) {
+            // Extract polytrees from wrapper objects when in polytree return mode.
+            if (firstOperand) {
+              operationObject.objA = firstOperand.original;
+              firstOperand = firstOperand.result;
+            }
+            if (secondOperand) {
+              operationObject.objB = secondOperand.original;
+              secondOperand = secondOperand.result;
+            }
+          }
+          // Execute the appropriate CSG operation based on operation type.
+          operationPromise = void 0;
+          switch (operationObject.op) {
+            case 'unite':
+              if (firstOperand && secondOperand) {
+                operationPromise = Polytree.async.unite(firstOperand, secondOperand, buildTargetPolytree);
+              } else {
+                // Handle missing operands gracefully.
+                operationPromise = Promise.resolve(firstOperand || secondOperand || new Polytree());
+              }
+              break;
+            case 'subtract':
+              if (firstOperand && secondOperand) {
+                operationPromise = Polytree.async.subtract(firstOperand, secondOperand, buildTargetPolytree);
+              } else {
+                // For subtract, return first operand or empty polytree.
+                operationPromise = Promise.resolve(firstOperand || new Polytree());
+              }
+              break;
+            case 'intersect':
+              if (firstOperand && secondOperand) {
+                operationPromise = Polytree.async.intersect(firstOperand, secondOperand, buildTargetPolytree);
+              } else {
+                // For intersect, missing operand means no result.
+                operationPromise = Promise.resolve(new Polytree());
+              }
+              break;
+            default:
+              // Handle invalid operation types gracefully.
+              operationPromise = Promise.resolve(new Polytree());
+          }
+          // Handle the operation result and determine final output format.
+          return operationPromise.then(function(resultPolytree) {
+            var allPolygons, defaultMaterial, finalMesh;
+            // Ensure result polytree has proper bounding box for subsequent operations.
+            if (resultPolytree && !resultPolytree.box && resultPolytree.bounds) {
+              resultPolytree.buildTree();
+            }
+            // Convert to mesh for first run operations unless returning polytrees.
+            if (firstRun && !returnPolytrees) {
+              // Skip mesh conversion if result polytree has no valid polygons.
+              allPolygons = resultPolytree.getPolygons();
+              if (!resultPolytree || allPolygons.length === 0) {
+                resolve(void 0);
+                return;
+              }
+              if (materialForMesh) {
+                finalMesh = Polytree.toMesh(resultPolytree, materialForMesh);
+              } else {
+                // Use default material from original operands if no material specified.
+                defaultMaterial = void 0;
+                if (originalMaterialA) {
+                  defaultMaterial = Array.isArray(originalMaterialA) ? originalMaterialA[0] : originalMaterialA;
+                  defaultMaterial = defaultMaterial.clone();
+                } else if (originalMaterialB) {
+                  defaultMaterial = Array.isArray(originalMaterialB) ? originalMaterialB[0] : originalMaterialB;
+                  defaultMaterial = defaultMaterial.clone();
+                } else {
+                  // No material available - resolve with undefined.
+                  resolve(void 0);
+                  return;
+                }
+                finalMesh = Polytree.toMesh(resultPolytree, defaultMaterial);
+              }
+              disposePolytreeResources(resultPolytree);
+              resolve(finalMesh);
+            } else if (firstRun && returnPolytrees) {
+              if (materialForMesh) {
+                finalMesh = Polytree.toMesh(resultPolytree, materialForMesh);
+                disposePolytreeResources(resultPolytree);
+                resolve({
+                  result: finalMesh,
+                  operationTree: operationObject
+                });
+              } else {
+                resolve({
+                  result: resultPolytree,
+                  operationTree: operationObject
+                });
+              }
+            } else {
+              resolve(resultPolytree);
+            }
+            // Clean up intermediate polytrees unless returning them.
+            if (!returnPolytrees) {
+              if (firstOperand || secondOperand) {
+                return disposePolytreeResources(firstOperand, secondOperand);
+              }
+            }
+          }).catch(function(operationError) {
+            return reject(operationError);
+          });
+        });
+      } catch (error) {
+        asyncError = error;
+        return reject(asyncError);
+      }
+    });
+  } else {
+    // Synchronous operation handling.
+    firstOperand = void 0;
+    secondOperand = void 0;
+    resultPolytree = void 0;
+    materialForMesh = void 0;
+    if (operationObject.material) {
+      materialForMesh = operationObject.material;
+    }
+    // Process first operand.
+    if (operationObject.objA) {
+      firstOperand = handleObjectForOperation(operationObject.objA, returnPolytrees, buildTargetPolytree, options, void 0, async);
+      if (returnPolytrees === true) {
+        operationObject.objA = firstOperand.original;
+        firstOperand = firstOperand.result;
+      }
+    }
+    // Process second operand.
+    if (operationObject.objB) {
+      secondOperand = handleObjectForOperation(operationObject.objB, returnPolytrees, buildTargetPolytree, options, void 0, async);
+      if (returnPolytrees === true) {
+        operationObject.objB = secondOperand.original;
+        secondOperand = secondOperand.result;
+      }
+    }
+    // Execute the appropriate CSG operation.
+    switch (operationObject.op) {
+      case 'unite':
+        if (firstOperand && secondOperand) {
+          resultPolytree = Polytree.unite(firstOperand, secondOperand, false);
+        } else {
+          // Handle missing operands - return the available operand or empty polytree.
+          resultPolytree = firstOperand || secondOperand || new Polytree();
+        }
+        break;
+      case 'subtract':
+        if (firstOperand && secondOperand) {
+          resultPolytree = Polytree.subtract(firstOperand, secondOperand, false);
+        } else {
+          // For subtract, if missing second operand, return first; if missing first, return empty.
+          resultPolytree = firstOperand || new Polytree();
+        }
+        break;
+      case 'intersect':
+        if (firstOperand && secondOperand) {
+          resultPolytree = Polytree.intersect(firstOperand, secondOperand, false);
+        } else {
+          // For intersect, missing either operand means no intersection - return empty polytree.
+          resultPolytree = new Polytree();
+        }
+        break;
+      default:
+        // Handle invalid operation types gracefully - return empty polytree.
+        resultPolytree = new Polytree();
+    }
+    // Ensure result polytree has proper bounding box for subsequent operations.
+    if (resultPolytree && !resultPolytree.box && resultPolytree.bounds) {
+      resultPolytree.buildTree();
+    }
+    // Clean up intermediate polytrees unless returning them.
+    if (!returnPolytrees) {
+      if (firstOperand || secondOperand) {
+        disposePolytreeResources(firstOperand, secondOperand);
+      }
+    }
+    // Handle final output format for synchronous operations.
+    if (firstRun && !returnPolytrees) {
+      // Skip mesh conversion if result polytree has no valid polygons.
+      allPolygons = resultPolytree.getPolygons();
+      if (!resultPolytree || allPolygons.length === 0) {
+        return void 0;
+      }
+      // Convert polytree result to mesh for top-level operations.
+      if (materialForMesh) {
+        finalMesh = Polytree.toMesh(resultPolytree, materialForMesh);
+      } else {
+        // Use default material from first operand if no material specified.
+        defaultMaterial = void 0;
+        if ((ref = operationObject.objA) != null ? ref.material : void 0) {
+          defaultMaterial = Array.isArray(operationObject.objA.material) ? operationObject.objA.material[0] : operationObject.objA.material;
+          defaultMaterial = defaultMaterial.clone();
+        } else {
+          return void 0; // No material available - return undefined instead of creating empty mesh.
+        }
+        finalMesh = Polytree.toMesh(resultPolytree, defaultMaterial);
+      }
+      disposePolytreeResources(resultPolytree);
+      return finalMesh;
+    }
+    if (firstRun && returnPolytrees) {
+      return {
+        result: resultPolytree,
+        operationTree: operationObject
+      };
+    }
+    return resultPolytree;
+  }
+};
+// Handle individual object processing for CSG operations.
+// Converts meshes to polytrees and handles nested operations recursively.
+// @param inputObject - Object to process (mesh, polytree, or nested operation).
+// @param returnPolytrees - Whether to return polytree objects instead of meshes.
+// @param buildTargetPolytree - Whether to build the target polytree structure.
+// @param options - Configuration options including objCounter for unique IDs.
+// @param objectIndex - Index identifier for tracking operand position (0 or 1).
+// @param async - Whether to execute asynchronously using promises.
+// @return Processed polytree object or promise resolving to one.
+handleObjectForOperation = function(inputObject, returnPolytrees, buildTargetPolytree, options, objectIndex, async = true) {
+  var processedObject;
+  if (async) {
+    return new Promise(function(resolve, reject) {
+      var processedObject, processingError;
+      try {
+        processedObject = void 0;
+        // Convert Three.js mesh to polytree.
+        if (inputObject.isMesh) {
+          processedObject = Polytree.fromMesh(inputObject, options.objCounter++);
+          if (returnPolytrees) {
+            processedObject = {
+              result: processedObject,
+              original: processedObject.clone()
+            };
+          }
+          processedObject.objIndex = objectIndex;
+          return resolve(processedObject);
+        // Handle existing polytree objects.
+        } else if (inputObject.isPolytree) {
+          processedObject = inputObject;
+          if (returnPolytrees) {
+            processedObject = {
+              result: inputObject,
+              original: inputObject.clone()
+            };
+          }
+          processedObject.objIndex = objectIndex;
+          return resolve(processedObject);
+        // Handle nested operations recursively.
+        } else if (inputObject.op) {
+          return Polytree.operation(inputObject, returnPolytrees, buildTargetPolytree, options, false, async).then(function(nestedResult) {
+            if (returnPolytrees) {
+              nestedResult = {
+                result: nestedResult,
+                original: inputObject
+              };
+            }
+            nestedResult.objIndex = objectIndex;
+            return resolve(nestedResult);
+          });
+        }
+      } catch (error) {
+        processingError = error;
+        return reject(processingError);
+      }
+    });
+  } else {
+    // Synchronous object processing.
+    processedObject = void 0;
+    // Convert Three.js mesh to polytree.
+    if (inputObject.isMesh) {
+      processedObject = Polytree.fromMesh(inputObject, options.objCounter++);
+      if (returnPolytrees) {
+        processedObject = {
+          result: processedObject,
+          original: processedObject.clone()
+        };
+      }
+    // Handle existing polytree objects.
+    } else if (inputObject.isPolytree) {
+      processedObject = inputObject;
+      if (returnPolytrees) {
+        processedObject = {
+          result: inputObject,
+          original: inputObject.clone()
+        };
+      }
+    // Handle nested operations recursively.
+    } else if (inputObject.op) {
+      processedObject = Polytree.operation(inputObject, returnPolytrees, buildTargetPolytree, options, false, async);
+      if (returnPolytrees) {
+        processedObject = {
+          result: processedObject,
+          original: inputObject
+        };
+      }
+    }
+    return processedObject;
+  }
+};
+// Generated by CoffeeScript 2.7.0
+var Polytree;
+Polytree = (function() {
+  class Polytree {
+    // Main constructor for creating Polytree nodes.
+    // Initializes core properties and sets up polygon array management.
+      // @param box - Optional bounding box for this tree node (used internally for polytree subdivision).
+    // @param parent - Optional parent Polytree node (used internally, null for root).
+    constructor(box = null, parent = null) {
+      // Core geometric data.
+      this.box = box; // Bounding box for spatial partitioning.
+      this.polygons = []; // Primary polygon storage for this node.
+      this.replacedPolygons = []; // Temporary storage for replaced polygons during operations.
+      
+      // Tree structure properties.
+      this.parent = parent; // Reference to parent node (null for root).
+      this.subTrees = []; // Child Polytree nodes for polytree subdivision.
+      this.level = 0; // Depth level in polytree hierarchy.
+      
+      // Mesh and Matrix transformation data.
+      this.originalMatrixWorld; // Original world transformation matrix.
+      this.mesh; // Reference to Three.js mesh object.
+      
+      // Polygon array management for root node.
+      this.polygonArrays = void 0; // Collection of all polygon arrays (root node only).
+      this.addPolygonsArrayToRoot(this.polygons);
+    }
+    // === SMALL HELPERS AND GETTERS/SETTERS ===
+    isEmpty() { // Check if this tree node contains any polygons.
+      return this.polygons.length === 0;
+    }
+    getMesh() { // Get the Three.js mesh associated with this Polytree (traverses to root).
+      var current, ref, visited;
+      visited = new Set();
+      current = this;
+      while (current && !visited.has(current)) {
+        visited.add(current);
+        if (!current.parent) {
+          return (ref = current.mesh) != null ? ref : null;
+        }
+        current = current.parent;
+      }
+      return null; // Circular reference or no mesh found.
+    }
+    newPolytree(box, parent) { // Create a new Polytree node with given parameters.
+      return new this.constructor(box, parent);
+    }
+    setPolygonIndex(index) { // Set polygon material index for all polygons in this tree.
+      if (index === void 0) {
+        return;
+      }
+      if (this.polygonArrays) {
+        return this.polygonArrays.forEach(function(polygonsArray) {
+          if (polygonsArray != null ? polygonsArray.length : void 0) {
+            return polygonsArray.forEach(function(polygon) {
+              return polygon.shared = index;
+            });
+          }
+        });
+      }
+    }
+    // === OBJECT CREATION AND COPYING ===
+    clone() { // Creates a deep copy of this Polytree.
+      return (new this.constructor()).copy(this);
+    }
+    copy(source) { // Copy data from another Polytree instance.
+      var i, k, ref, ref1, subTree;
+      if (!source) {
+        return this;
+      }
+      this.deletePolygonsArrayFromRoot(this.polygons);
+      this.polygons = source.polygons ? source.polygons.map(function(polygon) {
+        return polygon.clone();
+      }) : [];
+      this.addPolygonsArrayToRoot(this.polygons);
+      this.replacedPolygons = source.replacedPolygons ? source.replacedPolygons.map(function(polygon) {
+        return polygon.clone();
+      }) : [];
+      if (source.mesh) {
+        this.mesh = source.mesh;
+      }
+      if (source.originalMatrixWorld) {
+        this.originalMatrixWorld = source.originalMatrixWorld.clone();
+      }
+      this.box = source.box ? source.box.clone() : null;
+      this.level = (ref = source.level) != null ? ref : 0;
+      if (source.subTrees) {
+        for (i = k = 0, ref1 = source.subTrees.length; (0 <= ref1 ? k < ref1 : k > ref1); i = 0 <= ref1 ? ++k : --k) {
+          subTree = new this.constructor(void 0, this).copy(source.subTrees[i]);
+          this.subTrees.push(subTree);
+        }
+      }
+      return this;
+    }
+    // === CSG OPERATIONS (INSTANCE METHODS) ===
+      // Perform union operation (combines both meshes).
+    unite(mesh1, mesh2, targetMaterial = null) {
+      return Polytree.unite(mesh1, mesh2, targetMaterial);
+    }
+    // Perform subtraction operation (mesh1 minus mesh2).
+    subtract(mesh1, mesh2, targetMaterial = null) {
+      return Polytree.subtract(mesh1, mesh2, targetMaterial);
+    }
+    // Perform intersection operation (keep only overlapping volume).
+    intersect(mesh1, mesh2, targetMaterial = null) {
+      return Polytree.intersect(mesh1, mesh2, targetMaterial);
+    }
+    // === POLYGON ARRAY MANAGEMENT ===
+      // Add polygon array to root node's collection (internal helper).
+    addPolygonsArrayToRoot(array) {
+      if (this.parent) {
+        return this.parent.addPolygonsArrayToRoot(array);
+      } else {
+        if (this.polygonArrays === void 0) {
+          this.polygonArrays = [];
+        }
+        return this.polygonArrays.push(array);
+      }
+    }
+    // Remove polygon array from root node's collection (internal helper).
+    deletePolygonsArrayFromRoot(array) {
+      var index;
+      if (this.parent) {
+        return this.parent.deletePolygonsArrayFromRoot(array);
+      } else {
+        index = this.polygonArrays.indexOf(array);
+        if (index > -1) {
+          return this.polygonArrays.splice(index, 1);
+        }
+      }
+    }
+    // === CORE POLYGON OPERATIONS ===
+      // Add a polygon to this tree node with spatial bounds calculation.
+    addPolygon(polygon, trianglesSet) {
+      var triangle;
+      if (!this.bounds) {
+        this.bounds = new Box3();
+      }
+      triangle = polygon.triangle;
+      if (trianglesSet && !isUniqueTriangle(triangle, trianglesSet)) {
+        return this;
+      }
+      // Expand bounds to include all triangle vertices.
+      this.bounds.expandByPoint(triangle.a);
+      this.bounds.expandByPoint(triangle.b);
+      this.bounds.expandByPoint(triangle.c);
+      this.polygons.push(polygon);
+      return this;
+    }
+    calcBox() { // Calculate and set bounding box from polygon bounds.
+      var offset;
+      if (!this.bounds) {
+        this.bounds = new Box3();
+      }
+      this.box = this.bounds.clone();
+      offset = POLYTREE_MIN_NODE_SIZE; // Use configurable minimum node size to guarantee that all polygons are included in queries.
+      this.box.min.x -= offset;
+      this.box.min.y -= offset;
+      this.box.min.z -= offset;
+      this.box.max.x += offset;
+      this.box.max.y += offset;
+      this.box.max.z += offset;
+      return this;
+    }
+    // === TREE CONSTRUCTION AND SPATIAL PARTITIONING ===
+      // Split this node into 8 octree children based on spatial subdivision.
+    // This creates a polytree by recursively subdividing space until polygon density is acceptable.
+    split(level) {
+      var box, found, halfSize, i, k, l, len, m, maxDepthLimit, n, nodeSize, o, polygon, polygonLimit, ref, ref1, subTrees, vectorPosition, x, y, z;
+      subTrees = [];
+      if (!this.box) {
+        return this;
+      }
+      halfSize = temporaryVector3Secondary.copy(this.box.max).sub(this.box.min).multiplyScalar(0.5);
+// Create 8 child boxes in a 2x2x2 grid.
+      for (x = k = 0; k <= 1; x = ++k) {
+        for (y = l = 0; l <= 1; y = ++l) {
+          for (z = m = 0; m <= 1; z = ++m) {
+            box = new Box3();
+            vectorPosition = temporaryVector3Primary.set(x, y, z);
+            box.min.copy(this.box.min).add(vectorPosition.multiply(halfSize));
+            box.max.copy(box.min).add(halfSize);
+            box.expandByScalar(GEOMETRIC_EPSILON);
+            subTrees.push(this.newPolytree(box, this));
+          }
+        }
+      }
+      // Redistribute polygons to appropriate child nodes based on midpoint.
+      polygon = void 0;
+      while (polygon = this.polygons.pop()) {
+        found = false;
+        for (i = n = 0, ref = subTrees.length; (0 <= ref ? n < ref : n > ref); i = 0 <= ref ? ++n : --n) {
+          if (subTrees[i].box.containsPoint(polygon.getMidpoint())) {
+            subTrees[i].polygons.push(polygon);
+            found = true;
+          }
+        }
+        if (!found) {
+          throw new Error(`Unable to find subtree for triangle at level ${level}.`);
+        }
+      }
+// Recursively split child nodes if they exceed polygon threshold.
+      for (i = o = 0, ref1 = subTrees.length; (0 <= ref1 ? o < ref1 : o > ref1); i = 0 <= ref1 ? ++o : --o) {
+        subTrees[i].level = level + 1;
+        len = subTrees[i].polygons.length;
+        // Calculate node size to check minimum size constraint.
+        nodeSize = subTrees[i].box.getSize(temporaryVector3Tertiary).length();
+        // Continue subdivision if polygon count exceeds threshold, max depth not reached, and node size is above minimum.
+        // Use the more restrictive of the two depth limits and polygon limits for maximum performance control.
+        maxDepthLimit = Math.min(Polytree.maxLevel, POLYTREE_MAX_DEPTH);
+        polygonLimit = Math.min(Polytree.polygonsPerTree, POLYTREE_MAX_POLYGONS_PER_NODE);
+        if (len > polygonLimit && level < maxDepthLimit && nodeSize > POLYTREE_MIN_NODE_SIZE) {
+          subTrees[i].split(level + 1);
+        }
+        this.subTrees.push(subTrees[i]);
+      }
+      return this;
+    }
+    buildTree() { // Build complete polytree structure from polygon data.
+      this.calcBox();
+      this.split(0);
+      this.processTree();
+      return this;
+    }
+    // Process tree nodes to update bounding boxes after polygon distribution.
+    processTree() {
+      var i, k, l, ref, ref1, results;
+      if (!this.isEmpty()) {
+        temporaryBoundingBox.copy(this.box);
+        for (i = k = 0, ref = this.polygons.length; (0 <= ref ? k < ref : k > ref); i = 0 <= ref ? ++k : --k) {
+          this.box.expandByPoint(this.polygons[i].triangle.a);
+          this.box.expandByPoint(this.polygons[i].triangle.b);
+          this.box.expandByPoint(this.polygons[i].triangle.c);
+        }
+        this.expandParentBox();
+      }
+      results = [];
+      for (i = l = 0, ref1 = this.subTrees.length; (0 <= ref1 ? l < ref1 : l > ref1); i = 0 <= ref1 ? ++l : --l) {
+        results.push(this.subTrees[i].processTree());
+      }
+      return results;
+    }
+    // Recursively expand parent bounding boxes up the tree hierarchy.
+    expandParentBox(visited = new Set()) {
+      if (this.parent && !visited.has(this.parent)) {
+        visited.add(this.parent);
+        this.parent.box.expandByPoint(this.box.min);
+        this.parent.box.expandByPoint(this.box.max);
+        return this.parent.expandParentBox(visited);
+      }
+    }
+    // === POLYGON QUERIES AND INTERSECTION TESTING ===
+      // Invert all polygons by flipping their face normals.
+    invert() {
+      return this.polygonArrays.forEach(function(polygonsArray) {
+        if (polygonsArray.length) {
+          return polygonsArray.forEach(function(polygon) {
+            return polygon.flip();
+          });
+        }
+      });
+    }
+    // Get all valid polygons from all polygon arrays in this tree.
+    getPolygons(polygons = []) {
+      this.polygonArrays.forEach(function(polygonsArray) {
+        var i, k, ref, results;
+        if (polygonsArray.length) {
+          results = [];
+          for (i = k = 0, ref = polygonsArray.length; (0 <= ref ? k < ref : k > ref); i = 0 <= ref ? ++k : --k) {
+            if (polygonsArray[i].valid) {
+              if (polygons.indexOf(polygonsArray[i]) === -1) {
+                results.push(polygons.push(polygonsArray[i]));
+              } else {
+                results.push(void 0);
+              }
+            } else {
+              results.push(void 0);
+            }
+          }
+          return results;
+        }
+      });
+      return polygons;
+    }
+    // Extract triangles from all valid polygons in the tree.
+    // This provides triangle data format as complement to getPolygons().
+    getTriangles(triangles = []) {
+      var polygons;
+      polygons = this.getPolygons();
+      polygons.forEach(function(polygon) {
+        return triangles.push(polygon.triangle);
+      });
+      return triangles;
+    }
+    // Collect polygons that intersect with a ray for raycasting operations.
+    getRayPolygons(ray, polygons = []) {
+      var i, k, l, ref, ref1;
+      if (this.polygons.length > 0) {
+        for (i = k = 0, ref = this.polygons.length; (0 <= ref ? k < ref : k > ref); i = 0 <= ref ? ++k : --k) {
+          if (this.polygons[i].valid && this.polygons[i].originalValid) {
+            if (polygons.indexOf(this.polygons[i]) === -1) {
+              polygons.push(this.polygons[i]);
+            }
+          }
+        }
+      }
+      if (this.replacedPolygons.length > 0) {
+        polygons.push(...this.replacedPolygons);
+      }
+      for (i = l = 0, ref1 = this.subTrees.length; (0 <= ref1 ? l < ref1 : l > ref1); i = 0 <= ref1 ? ++l : --l) {
+        if (ray.intersectsBox(this.subTrees[i].box)) {
+          this.subTrees[i].getRayPolygons(ray, polygons);
+        }
+      }
+      return polygons;
+    }
+    // Extract triangles from polygons that intersect with a ray.
+    // This provides triangle data format as complement to getRayPolygons().
+    getRayTriangles(ray, triangles = []) {
+      var polygons;
+      polygons = this.getRayPolygons(ray);
+      polygons.forEach(function(polygon) {
+        return triangles.push(polygon.triangle);
+      });
+      return triangles;
+    }
+    // Perform ray intersection testing against all polygons in the tree.
+    // Returns array of intersection results sorted by distance.
+    rayIntersect(ray, matrixWorld, intersects = []) {
+      var distance, i, k, newDistance, polygons, ref, result;
+      if (ray.direction.length() === 0) {
+        return [];
+      }
+      distance = 1e100;
+      polygons = this.getRayPolygons(ray);
+      for (i = k = 0, ref = polygons.length; (0 <= ref ? k < ref : k > ref); i = 0 <= ref ? ++k : --k) {
+        result = void 0;
+        if (Polytree.rayIntersectTriangleType === "regular") {
+          result = ray.intersectTriangle(polygons[i].triangle.a, polygons[i].triangle.b, polygons[i].triangle.c, false, temporaryVector3Primary);
+          if (result) {
+            temporaryVector3Primary.applyMatrix4(matrixWorld);
+            distance = temporaryVector3Primary.distanceTo(ray.origin);
+            if (distance < 0 || distance > 2e308) {
+              console.warn("[rayIntersect] Failed ray distance check.", ray);
+            } else {
+              intersects.push({
+                distance: distance,
+                polygon: polygons[i],
+                position: temporaryVector3Primary.clone()
+              });
+            }
+          }
+        } else {
+          result = testRayTriangleIntersection(ray, polygons[i].triangle, temporaryVector3Primary);
+          if (result) {
+            newDistance = result.clone().sub(ray.origin).length();
+            if (distance > newDistance) {
+              distance = newDistance;
+            }
+            if (distance < 1e100) {
+              intersects.push({
+                distance: distance,
+                polygon: polygons[i],
+                position: result.clone().add(ray.origin)
+              });
+            }
+          }
+        }
+      }
+      intersects.length && intersects.sort(sortRaycastIntersectionsByDistance);
+      return intersects;
+    }
+    // Get all polygons marked as intersecting from polygon arrays.
+    getIntersectingPolygons(polygons = []) {
+      this.polygonArrays.forEach(function(polygonsArray) {
+        var i, k, ref, results;
+        if (polygonsArray.length) {
+          results = [];
+          for (i = k = 0, ref = polygonsArray.length; (0 <= ref ? k < ref : k > ref); i = 0 <= ref ? ++k : --k) {
+            if (polygonsArray[i].valid && polygonsArray[i].intersects) {
+              results.push(polygons.push(polygonsArray[i]));
+            } else {
+              results.push(void 0);
+            }
+          }
+          return results;
+        }
+      });
+      return polygons;
+    }
+    // Find all polygons that intersect with a target polygon using spatial partitioning.
+    getPolygonsIntersectingPolygon(targetPolygon, polygons = []) {
+      var allPolygons, i, k, l, m, polygon, ref, ref1, ref2;
+      if (this.box.intersectsTriangle(targetPolygon.triangle)) {
+        if (this.polygons.length > 0) {
+          allPolygons = this.polygons.slice();
+          if (this.replacedPolygons.length > 0) {
+            for (i = k = 0, ref = this.replacedPolygons.length; (0 <= ref ? k < ref : k > ref); i = 0 <= ref ? ++k : --k) {
+              allPolygons.push(this.replacedPolygons[i]);
+            }
+          }
+          for (i = l = 0, ref1 = allPolygons.length; (0 <= ref1 ? l < ref1 : l > ref1); i = 0 <= ref1 ? ++l : --l) {
+            polygon = allPolygons[i];
+            if (!(polygon.originalValid && polygon.valid && polygon.intersects)) {
+              continue;
+            }
+            if (triangleIntersectsTriangle(targetPolygon.triangle, polygon.triangle)) {
+              polygons.push(polygon);
+            }
+          }
+        }
+      }
+      for (i = m = 0, ref2 = this.subTrees.length; (0 <= ref2 ? m < ref2 : m > ref2); i = 0 <= ref2 ? ++m : --m) {
+        this.subTrees[i].getPolygonsIntersectingPolygon(targetPolygon, polygons);
+      }
+      return polygons;
+    }
+    // === POLYGON MODIFICATION AND STATE MANAGEMENT ===
+      // Replace a polygon with one or more new polygons during CSG operations.
+    replacePolygon(polygon, newPolygons) {
+      var i, k, polygonIndex, ref, results;
+      if (!Array.isArray(newPolygons)) {
+        newPolygons = [newPolygons];
+      }
+      if (this.polygons.length > 0) {
+        polygonIndex = this.polygons.indexOf(polygon);
+        if (polygonIndex > -1) {
+          if (polygon.originalValid === true) {
+            this.replacedPolygons.push(polygon);
+          } else {
+            polygon.setInvalid();
+          }
+          this.polygons.splice(polygonIndex, 1, ...newPolygons);
+        }
+      }
+      results = [];
+      for (i = k = 0, ref = this.subTrees.length; (0 <= ref ? k < ref : k > ref); i = 0 <= ref ? ++k : --k) {
+        results.push(this.subTrees[i].replacePolygon(polygon, newPolygons));
+      }
+      return results;
+    }
+    // === COMPLEX CSG OPERATIONS AND STATE MANAGEMENT ===
+      // Delete polygons based on complex state rules for CSG operations.
+    // This implements the polygon classification logic for boolean operations.
+    deletePolygonsByStateRules(rulesArr, firstRun = true) {
+      return this.polygonArrays.forEach(function(polygonsArray) {
+        var polygonArr;
+        if (polygonsArray.length) {
+          polygonArr = polygonsArray.filter(function(polygon) {
+            return (polygon.valid === true) && (polygon.intersects === true);
+          });
+          return polygonArr.forEach(function(polygon) {
+            var found, i, j, k, l, mainStatesObj, polygonIndex, ref, ref1, state, states, statesObj;
+            found = false;
+            for (j = k = 0, ref = rulesArr.length; (0 <= ref ? k < ref : k > ref); j = 0 <= ref ? ++k : --k) {
+              if (rulesArr[j].array) {
+                states = rulesArr[j].rule;
+                if ((states.includes(polygon.state)) && (((polygon.previousState !== "undecided") && (states.includes(polygon.previousState))) || (polygon.previousState === "undecided"))) {
+                  found = true;
+                  statesObj = {};
+                  mainStatesObj = {};
+                  states.forEach(function(state) {
+                    return statesObj[state] = false;
+                  });
+                  states.forEach(function(state) {
+                    return mainStatesObj[state] = false;
+                  });
+                  statesObj[polygon.state] = true;
+                  for (i = l = 0, ref1 = polygon.previousStates.length; (0 <= ref1 ? l < ref1 : l > ref1); i = 0 <= ref1 ? ++l : --l) {
+                    if (!states.includes(polygon.previousStates[i])) {
+                      found = false;
+                      break;
+                    } else {
+                      statesObj[polygon.previousStates[i]] = true;
+                    }
+                  }
+                  if (found) {
+                    for (state in statesObj) {
+                      if (statesObj[state] === false) {
+                        found = false;
+                        break;
+                      }
+                    }
+                    if (found) {
+                      break;
+                    }
+                  }
+                }
+              } else {
+                if (polygon.checkAllStates(rulesArr[j].rule)) {
+                  found = true;
+                  break;
+                }
+              }
+            }
+            if (found) {
+              polygonIndex = polygonsArray.indexOf(polygon);
+              if (polygonIndex > -1) {
+                polygon.setInvalid();
+                polygonsArray.splice(polygonIndex, 1);
+              }
+              if (firstRun) {
+                return polygon.delete();
+              }
+            }
+          });
+        }
+      });
+    }
+    // Delete polygons based on their intersection status (simpler filtering).
+    deletePolygonsByIntersection(intersects, firstRun = true) {
+      if (intersects === void 0) {
+        return;
+      }
+      return this.polygonArrays.forEach(function(polygonsArray) {
+        var polygonArr;
+        if (polygonsArray.length) {
+          polygonArr = polygonsArray.slice();
+          return polygonArr.forEach(function(polygon) {
+            var polygonIndex;
+            if (polygon.valid) {
+              if (polygon.intersects === intersects) {
+                polygonIndex = polygonsArray.indexOf(polygon);
+                if (polygonIndex > -1) {
+                  polygon.setInvalid();
+                  polygonsArray.splice(polygonIndex, 1);
+                }
+                if (firstRun) {
+                  return polygon.delete();
+                }
+              }
+            }
+          });
+        }
+      });
+    }
+    // Check if a polygon intersects with this tree's bounding box.
+    isPolygonIntersecting(polygon) {
+      if (!this.box.intersectsTriangle(polygon.triangle)) {
+        return false;
+      }
+      return true;
+    }
+    // Mark polygons as intersecting with target polytree.
+    markIntesectingPolygons(targetPolytree) {
+      return this.polygonArrays.forEach(function(polygonsArray) {
+        if (polygonsArray.length) {
+          return polygonsArray.forEach(function(polygon) {
+            return polygon.intersects = targetPolytree.isPolygonIntersecting(polygon);
+          });
+        }
+      });
+    }
+    // Reset polygon states for CSG operation preparation.
+    resetPolygons(resetOriginal = true) {
+      return this.polygonArrays.forEach(function(polygonsArray) {
+        if (polygonsArray.length) {
+          return polygonsArray.forEach(function(polygon) {
+            return polygon.reset(resetOriginal);
+          });
+        }
+      });
+    }
+    // Complex CSG intersection handling - splits and classifies polygons.
+    // This is the core method for polygon classification in boolean operations.
+    handleIntersectingPolygons(targetPolytree, targetPolytreeBuffer) {
+      var currentPolygon, i, inside, intersects, j, k, l, m, n, o, point, polygon, polygonStack, ref, ref1, ref2, ref3, ref4, results, splitResults, target, targetPolygons;
+      if (this.polygons.length > 0) {
+        polygonStack = this.polygons.filter(function(polygon) {
+          return (polygon.valid === true) && (polygon.intersects === true) && (polygon.state === "undecided");
+        });
+        currentPolygon = polygonStack.pop();
+        while (currentPolygon) {
+          if (currentPolygon.state !== "undecided") {
+            continue;
+          }
+          if (!currentPolygon.valid) {
+            continue;
+          }
+          targetPolygons = targetPolytree.getPolygonsIntersectingPolygon(currentPolygon);
+          if (targetPolygons.length > 0) {
+            for (j = k = 0, ref = targetPolygons.length; (0 <= ref ? k < ref : k > ref); j = 0 <= ref ? ++k : --k) {
+              target = targetPolygons[j];
+              splitResults = splitPolygonByPlane(currentPolygon, target.plane);
+              if (splitResults.length > 1) {
+                for (i = l = 0, ref1 = splitResults.length; (0 <= ref1 ? l < ref1 : l > ref1); i = 0 <= ref1 ? ++l : --l) {
+                  polygon = splitResults[i].polygon;
+                  polygon.intersects = currentPolygon.intersects;
+                  polygon.newPolygon = true;
+                  polygonStack.push(polygon);
+                }
+                this.replacePolygon(currentPolygon, splitResults.map(function(result) {
+                  return result.polygon;
+                }));
+                break;
+              } else {
+                if (currentPolygon.id !== splitResults[0].polygon.id) {
+                  splitResults[0].polygon.intersects = currentPolygon.intersects;
+                  splitResults[0].polygon.newPolygon = true;
+                  polygonStack.push(splitResults[0].polygon);
+                  this.replacePolygon(currentPolygon, splitResults[0].polygon);
+                  break;
+                } else {
+                  if ((splitResults[0].type === "coplanar-front") || (splitResults[0].type === "coplanar-back")) {
+                    currentPolygon.setState(splitResults[0].type);
+                    currentPolygon.coplanar = true;
+                  }
+                }
+              }
+            }
+          }
+          currentPolygon = polygonStack.pop();
+        }
+        polygonStack = this.polygons.filter(function(polygon) {
+          return (polygon.valid === true) && (polygon.intersects === true);
+        });
+        currentPolygon = polygonStack.pop();
+        inside = false;
+        while (currentPolygon) {
+          if (!currentPolygon.valid) {
+            continue;
+          }
+          inside = false;
+          if (targetPolytree.box.containsPoint(currentPolygon.getMidpoint())) {
+            if (Polytree.useWindingNumber === true) {
+              inside = testPolygonInsideUsingWindingNumber(targetPolytreeBuffer, currentPolygon.getMidpoint(), currentPolygon.coplanar);
+            } else {
+              point = roundPointCoordinates(temporaryVector3Secondary.copy(currentPolygon.getMidpoint()));
+              if (Polytree.usePolytreeRay !== true && targetPolytree.mesh) {
+                defaultRayDirection.copy(currentPolygon.plane.normal);
+                temporaryRaycaster.set(point, defaultRayDirection);
+                intersects = temporaryRaycaster.intersectObject(targetPolytree.mesh);
+                if (intersects.length) {
+                  if (defaultRayDirection.dot(intersects[0].face.normal) > 0) {
+                    inside = true;
+                  }
+                }
+                if (!(inside || !currentPolygon.coplanar)) {
+                  for (j = m = 0, ref2 = windingNumberEpsilonOffsetsCount; (0 <= ref2 ? m < ref2 : m > ref2); j = 0 <= ref2 ? ++m : --m) {
+                    temporaryRaycaster.ray.origin.copy(point).add(windingNumberEpsilonOffsets[j]);
+                    intersects = temporaryRaycaster.intersectObject(targetPolytree.mesh);
+                    if (intersects.length) {
+                      if (defaultRayDirection.dot(intersects[0].face.normal) > 0) {
+                        inside = true;
+                        break;
+                      }
+                    }
+                  }
+                }
+              } else {
+                temporaryRay.origin.copy(point);
+                defaultRayDirection.copy(currentPolygon.plane.normal);
+                temporaryRay.direction.copy(currentPolygon.plane.normal);
+                intersects = targetPolytree.rayIntersect(temporaryRay, targetPolytree.originalMatrixWorld);
+                if (intersects.length) {
+                  if (defaultRayDirection.dot(intersects[0].polygon.plane.normal) > 0) {
+                    inside = true;
+                  }
+                }
+                if (!(inside || !currentPolygon.coplanar)) {
+                  for (j = n = 0, ref3 = windingNumberEpsilonOffsetsCount; (0 <= ref3 ? n < ref3 : n > ref3); j = 0 <= ref3 ? ++n : --n) {
+                    temporaryRay.origin.copy(point).add(windingNumberEpsilonOffsets[j]);
+                    defaultRayDirection.copy(currentPolygon.plane.normal);
+                    temporaryRay.direction.copy(currentPolygon.plane.normal);
+                    intersects = targetPolytree.rayIntersect(temporaryRay, targetPolytree.originalMatrixWorld);
+                    if (intersects.length) {
+                      if (defaultRayDirection.dot(intersects[0].polygon.plane.normal) > 0) {
+                        inside = true;
+                        break;
+                      }
+                    }
+                  }
+                }
+              }
+            }
+          }
+          if (inside === true) {
+            currentPolygon.setState("inside");
+          } else {
+            currentPolygon.setState("outside");
+          }
+          currentPolygon = polygonStack.pop();
+        }
+      }
+      results = [];
+      for (i = o = 0, ref4 = this.subTrees.length; (0 <= ref4 ? o < ref4 : o > ref4); i = 0 <= ref4 ? ++o : --o) {
+        results.push(this.subTrees[i].handleIntersectingPolygons(targetPolytree, targetPolytreeBuffer));
+      }
+      return results;
+    }
+    // Apply transformation matrix to all polygons in this tree.
+    applyMatrix(matrix, normalMatrix, firstRun = true) {
+      var i, k, l, ref, ref1;
+      if (matrix.isMesh) {
+        matrix.updateMatrix();
+        matrix = matrix.matrix;
+      }
+      if (this.box) {
+        this.box.makeEmpty();
+      }
+      normalMatrix = normalMatrix || temporaryMatrixWithNormalCalc.getNormalMatrix(matrix);
+      if (this.polygons.length > 0) {
+        for (i = k = 0, ref = this.polygons.length; (0 <= ref ? k < ref : k > ref); i = 0 <= ref ? ++k : --k) {
+          if (this.polygons[i].valid) {
+            this.polygons[i].applyMatrix(matrix, normalMatrix);
+          }
+        }
+      }
+      for (i = l = 0, ref1 = this.subTrees.length; (0 <= ref1 ? l < ref1 : l > ref1); i = 0 <= ref1 ? ++l : --l) {
+        this.subTrees[i].applyMatrix(matrix, normalMatrix, false);
+      }
+      if (firstRun) {
+        return this.processTree();
+      }
+    }
+    // === ADVANCED COLLISION DETECTION ===
+      // Test intersection between a sphere and a triangle.
+    // Returns intersection data or false if no intersection.
+    // @param sphere - Sphere object with center and radius properties.
+    // @param triangle - Triangle object with a, b, c vertex properties.
+    // @return Object with normal, point, depth properties or false if no intersection.
+    triangleSphereIntersect(sphere, triangle) {
+      var distanceSquared, i, intersectionDepth, k, planePoint, radiusSquared, ref, temporaryLine, temporaryVector1, temporaryVector2, triangleEdges, trianglePlane;
+      // Create temporary objects for calculations.
+      temporaryVector1 = new Vector3();
+      temporaryVector2 = new Vector3();
+      temporaryLine = new Line3();
+      trianglePlane = new ThreePlane();
+      triangle.getPlane(trianglePlane);
+      if (!sphere.intersectsPlane(trianglePlane)) {
+        return false;
+      }
+      intersectionDepth = Math.abs(trianglePlane.distanceToSphere(sphere));
+      radiusSquared = sphere.radius * sphere.radius - intersectionDepth * intersectionDepth;
+      planePoint = trianglePlane.projectPoint(sphere.center, temporaryVector1);
+      if (triangle.containsPoint(sphere.center)) {
+        return {
+          depth: Math.abs(trianglePlane.distanceToSphere(sphere)),
+          normal: trianglePlane.normal.clone(),
+          point: planePoint.clone()
+        };
+      }
+      triangleEdges = [[triangle.a, triangle.b], [triangle.b, triangle.c], [triangle.c, triangle.a]];
+      for (i = k = 0, ref = triangleEdges.length; (0 <= ref ? k < ref : k > ref); i = 0 <= ref ? ++k : --k) {
+        temporaryLine.set(triangleEdges[i][0], triangleEdges[i][1]);
+        temporaryLine.closestPointToPoint(planePoint, true, temporaryVector2);
+        distanceSquared = temporaryVector2.distanceToSquared(sphere.center);
+        if (distanceSquared < radiusSquared) {
+          return {
+            depth: sphere.radius - Math.sqrt(distanceSquared),
+            normal: sphere.center.clone().sub(temporaryVector2).normalize(),
+            point: temporaryVector2.clone()
+          };
+        }
+      }
+      return false;
+    }
+    // Collect triangles that intersect with a sphere using spatial partitioning.
+    // This method recursively traverses the polytree to find relevant triangles.
+    // @param sphere - Sphere object to test intersection against.
+    // @param triangles - Array to collect intersecting triangles.
+    getSphereTriangles(sphere, triangles) {
+      var currentPolygon, currentSubTree, k, polygonIndex, ref, results, subTreeIndex;
+      results = [];
+      for (subTreeIndex = k = 0, ref = this.subTrees.length; (0 <= ref ? k < ref : k > ref); subTreeIndex = 0 <= ref ? ++k : --k) {
+        currentSubTree = this.subTrees[subTreeIndex];
+        if (!sphere.intersectsBox(currentSubTree.box)) {
+          continue;
+        }
+        if (currentSubTree.polygons.length > 0) {
+          results.push((function() {
+            var l, ref1, results1;
+            results1 = [];
+            for (polygonIndex = l = 0, ref1 = currentSubTree.polygons.length; (0 <= ref1 ? l < ref1 : l > ref1); polygonIndex = 0 <= ref1 ? ++l : --l) {
+              currentPolygon = currentSubTree.polygons[polygonIndex];
+              if (!currentPolygon.valid) {
+                continue;
+              }
+              if (triangles.indexOf(currentPolygon.triangle) === -1) {
+                results1.push(triangles.push(currentPolygon.triangle));
+              } else {
+                results1.push(void 0);
+              }
+            }
+            return results1;
+          })());
+        } else {
+          results.push(currentSubTree.getSphereTriangles(sphere, triangles));
+        }
+      }
+      return results;
+    }
+    // Perform high-level sphere intersection testing against the entire polytree.
+    // Returns collision data with adjusted position and penetration depth.
+    // @param sphere - Sphere object to test collision against.
+    // @return Object with normal and depth properties or false if no collision.
+    sphereIntersect(sphere) {
+      var adjustedSphere, collisionDetected, collisionVector, currentTriangle, intersectingTriangles, intersectionResult, k, penetrationDepth, ref, triangleIndex;
+      collisionDetected = false;
+      intersectionResult = void 0;
+      intersectingTriangles = [];
+      adjustedSphere = new Sphere();
+      adjustedSphere.copy(sphere);
+      this.getSphereTriangles(sphere, intersectingTriangles);
+      for (triangleIndex = k = 0, ref = intersectingTriangles.length; (0 <= ref ? k < ref : k > ref); triangleIndex = 0 <= ref ? ++k : --k) {
+        currentTriangle = intersectingTriangles[triangleIndex];
+        if (intersectionResult = this.triangleSphereIntersect(adjustedSphere, currentTriangle)) {
+          collisionDetected = true;
+          adjustedSphere.center.add(intersectionResult.normal.multiplyScalar(intersectionResult.depth));
+        }
+      }
+      if (collisionDetected) {
+        collisionVector = adjustedSphere.center.clone().sub(sphere.center);
+        penetrationDepth = collisionVector.length();
+        return {
+          normal: collisionVector.normalize(),
+          depth: penetrationDepth
+        };
+      }
+      return false;
+    }
+    // Build polytree from Three.js scene graph (Group or Object3D).
+    // This method traverses the scene graph and converts all meshes to polytree data.
+    // @param group - Three.js Group or Object3D to traverse.
+    fromGraphNode(sceneGraphNode) {
+      var targetPolytreeInstance;
+      sceneGraphNode.updateWorldMatrix(true, true);
+      targetPolytreeInstance = this;
+      sceneGraphNode.traverse(function(sceneObject) {
+        if (sceneObject.isMesh === true) {
+          return Polytree.fromMesh(sceneObject, void 0, targetPolytreeInstance, false);
+        }
+      });
+      return this.buildTree();
+    }
+    // === CLEANUP AND DISPOSAL METHODS ===
+      // Clean up replaced polygons from CSG operations.
+    deleteReplacedPolygons() {
+      var i, k, ref, results;
+      if (this.replacedPolygons.length > 0) {
+        this.replacedPolygons.forEach(function(polygon) {
+          return polygon.delete();
+        });
+        this.replacedPolygons.length = 0;
+      }
+      results = [];
+      for (i = k = 0, ref = this.subTrees.length; (0 <= ref ? k < ref : k > ref); i = 0 <= ref ? ++k : --k) {
+        results.push(this.subTrees[i].deleteReplacedPolygons());
+      }
+      return results;
+    }
+    // Mark all polygons as original (not generated by CSG operations).
+    markPolygonsAsOriginal() {
+      return this.polygonArrays.forEach(function(polygonsArray) {
+        if (polygonsArray.length) {
+          return polygonsArray.forEach(function(polygon) {
+            return polygon.originalValid = true;
+          });
+        }
+      });
+    }
+    // Get polygon clones via callback for CSG operations.
+    getPolygonCloneCallback(cbFunc, trianglesSet) {
+      return this.polygonArrays.forEach(function(polygonsArray) {
+        var i, k, ref, results;
+        if (polygonsArray.length) {
+          results = [];
+          for (i = k = 0, ref = polygonsArray.length; (0 <= ref ? k < ref : k > ref); i = 0 <= ref ? ++k : --k) {
+            if (polygonsArray[i].valid) {
+              results.push(cbFunc(polygonsArray[i].clone(), trianglesSet));
+            } else {
+              results.push(void 0);
+            }
+          }
+          return results;
+        }
+      });
+    }
+    // Delete this tree and all its data (primary cleanup method).
+    delete(deletePolygons = true) {
+      var i, k, ref;
+      if (this.polygons.length > 0 && deletePolygons) {
+        this.polygons.forEach(function(polygon) {
+          return polygon.delete();
+        });
+        this.polygons.length = 0;
+      }
+      if (this.replacedPolygons.length > 0 && deletePolygons) {
+        this.replacedPolygons.forEach(function(polygon) {
+          return polygon.delete();
+        });
+        this.replacedPolygons.length = 0;
+      }
+      if (this.polygonArrays) {
+        this.polygonArrays.length = 0;
+      }
+      if (this.subTrees.length) {
+        for (i = k = 0, ref = this.subTrees.length; (0 <= ref ? k < ref : k > ref); i = 0 <= ref ? ++k : --k) {
+          this.subTrees[i].delete(deletePolygons);
+        }
+        this.subTrees.length = 0;
+      }
+      this.mesh = void 0;
+      this.originalMatrixWorld = void 0;
+      this.box = void 0;
+      this.parent = void 0;
+      return this.level = void 0;
+    }
+    // Dispose of this tree (alias for delete).
+    dispose(deletePolygons = true) {
+      return this.delete(deletePolygons);
+    }
+  };
+  // ----- Prototype Properties -----
+  Polytree.prototype.isPolytree = true;
+  // ----- Static Properties -----
+  Polytree.usePolytreeRay = true;
+  Polytree.disposePolytree = true;
+  Polytree.useWindingNumber = false;
+  Polytree.maxLevel = POLYTREE_MAX_DEPTH;
+  Polytree.polygonsPerTree = POLYTREE_MAX_POLYGONS_PER_NODE;
+  Polytree.rayIntersectTriangleType = "MollerTrumbore";
+  // ----- Static Methods -----
+  Polytree.operation = operationHandler;
+  Polytree.rayIntersectsTriangle = testRayTriangleIntersection;
+  return Polytree;
+}).call(this);
+// Generated by CoffeeScript 2.7.0
+// Convert a Polytree instance to a THREE.js BufferGeometry.
+// This method extracts polygon data from the polytree and creates a proper
+// THREE.js geometry with positions, normals, UVs, colors, and material groups.
+// @param polytree - The Polytree instance to convert.
+// @return THREE.js BufferGeometry ready for rendering.
+Polytree.toGeometry = function(polytree) {
+  var colors, defaultGroup, geometry, groupBase, groups, i, index, k, l, len, len1, m, n, normals, polygon, polygons, positions, ref, ref1, totalTriangles, uvs, vertices, verticesLen;
+  groups = [];
+  defaultGroup = [];
+  uvs = void 0;
+  colors = void 0;
+  totalTriangles = 0;
+  polygons = polytree.getPolygons();
+// Calculate the total number of triangles that will be generated.
+  for (k = 0, len = polygons.length; k < len; k++) {
+    polygon = polygons[k];
+    totalTriangles += Math.max(0, polygon.vertices.length - 2);
+  }
+  positions = createVector3Buffer(totalTriangles * 3);
+  normals = createVector3Buffer(totalTriangles * 3);
+  for (l = 0, len1 = polygons.length; l < len1; l++) {
+    polygon = polygons[l];
+    vertices = polygon.vertices;
+    verticesLen = vertices.length;
+    // Initialize material group array if polygon has a shared material index.
+    if (polygon.shared !== void 0) {
+      if (!groups[polygon.shared]) {
+        groups[polygon.shared] = [];
+      }
+    }
+    // Initialize UV and color buffers if vertices contain this data.
+    if (verticesLen > 0) {
+      if (vertices[0].uv !== void 0) {
+        uvs || (uvs = createVector2Buffer(totalTriangles * 3));
+      }
+      if (vertices[0].color !== void 0) {
+        colors || (colors = createVector3Buffer(totalTriangles * 3));
+      }
+    }
+// Triangulate polygon by creating triangles from vertex fan.
+// Each triangle uses vertices[0] as the common vertex.
+    for (i = m = 3, ref = verticesLen; (3 <= ref ? m <= ref : m >= ref); i = 3 <= ref ? ++m : --m) {
+      // Add triangle indices to appropriate group (material-based or default).
+      (polygon.shared === void 0 ? defaultGroup : groups[polygon.shared]).push(positions.top / 3, (positions.top / 3) + 1, (positions.top / 3) + 2);
+      // Write vertex positions for the triangle.
+      positions.write(vertices[0].pos);
+      positions.write(vertices[i - 2].pos);
+      positions.write(vertices[i - 1].pos);
+      // Write vertex normals for the triangle.
+      normals.write(vertices[0].normal);
+      normals.write(vertices[i - 2].normal);
+      normals.write(vertices[i - 1].normal);
+      // Write UV coordinates if available.
+      if (uvs != null) {
+        uvs.write(vertices[0].uv);
+        uvs.write(vertices[i - 2].uv);
+        uvs.write(vertices[i - 1].uv);
+      }
+      // Write vertex colors if available.
+      if (colors != null) {
+        colors.write(vertices[0].color);
+        colors.write(vertices[i - 2].color);
+        colors.write(vertices[i - 1].color);
+      }
+    }
+  }
+  geometry = new BufferGeometry(); // Create THREE.js BufferGeometry and set attributes.
+  geometry.setAttribute('position', new BufferAttribute(positions.array, 3));
+  geometry.setAttribute('normal', new BufferAttribute(normals.array, 3));
+  uvs && geometry.setAttribute('uv', new BufferAttribute(uvs.array, 2));
+  colors && geometry.setAttribute('color', new BufferAttribute(colors.array, 3));
+  // Set up material groups and indices for multi-material support.
+  if (groups.length > 0) {
+    index = [];
+    groupBase = 0;
+// Process each material group.
+    for (i = n = 0, ref1 = groups.length; (0 <= ref1 ? n < ref1 : n > ref1); i = 0 <= ref1 ? ++n : --n) {
+      groups[i] = groups[i] || [];
+      geometry.addGroup(groupBase, groups[i].length, i);
+      groupBase += groups[i].length;
+      index = index.concat(groups[i]);
+    }
+    // Add default group if it has triangles.
+    if (defaultGroup.length) {
+      geometry.addGroup(groupBase, defaultGroup.length, groups.length);
+      index = index.concat(defaultGroup);
+    }
+    geometry.setIndex(index);
+  }
+  return geometry;
+};
+// Convert a Polytree instance to a complete THREE.js Mesh.
+// This is a convenience method that combines geometry creation with material assignment.
+// @param polytree - The Polytree instance to convert.
+// @param toMaterial - The THREE.js material to apply to the mesh.
+// @return THREE.js Mesh ready for scene addition.
+Polytree.toMesh = function(polytree, toMaterial) {
+  var geometry;
+  geometry = Polytree.toGeometry(polytree);
+  return new Mesh(geometry, toMaterial);
+};
+// Convert a THREE.js Mesh to a Polytree instance.
+// This method extracts geometry data from a THREE.js mesh and creates polygon objects
+// for use in CSG operations. Handles material groups, transformations, and validation.
+// @param obj - The THREE.js Mesh object to convert.
+// @param objectIndex - Material index to assign to all polygons (optional).
+// @param polytree - Existing Polytree to add polygons to (optional, creates new if not provided).
+// @param buildTargetPolytree - Whether to build the spatial tree structure (default: true).
+// @return Polytree instance containing the mesh data as polygons.
+Polytree.fromMesh = function(obj, objectIndex, polytree = new Polytree(), buildTargetPolytree = true) {
+  var color, colorattr, geometry, group, groups, i, index, j, k, l, len, m, n, normal, normalattr, polygon, polys, pos, posattr, positionIndex, ref, ref1, uvCoords, uvIndex, uvattr, vertexIndex, vertices;
+  if (obj.isPolytree) {
+    // Return early if object is already a Polytree.
+    return obj;
+  }
+  // Store original matrix world for ray intersection calculations.
+  if (Polytree.rayIntersectTriangleType === "regular") {
+    polytree.originalMatrixWorld = obj.matrixWorld.clone();
+  }
+  // Update transformation matrices and extract geometry attributes.
+  obj.updateWorldMatrix(true, true);
+  geometry = obj.geometry;
+  temporaryMatrixWithNormalCalc.getNormalMatrix(obj.matrix);
+  groups = geometry.groups;
+  uvattr = geometry.attributes.uv;
+  colorattr = geometry.attributes.color;
+  posattr = geometry.attributes.position;
+  normalattr = geometry.attributes.normal;
+  // Generate index array (explicit or implicit).
+  index = geometry.index ? geometry.index.array : Array((posattr.array.length / posattr.itemSize) | 0).fill().map(function(_, i) {
+    return i;
+  });
+  polys = []; // Process each triangle in the geometry.
+  for (i = k = 0, ref = index.length; k < ref; i = k += 3) {
+    vertices = [];
+// Create vertices for each triangle corner.
+    for (j = l = 0; l < 3; j = ++l) {
+      vertexIndex = index[i + j];
+      positionIndex = vertexIndex * 3;
+      uvIndex = vertexIndex * 2;
+      // Extract and transform vertex position.
+      pos = new Vector3(posattr.array[positionIndex], posattr.array[positionIndex + 1], posattr.array[positionIndex + 2]);
+      normal = new Vector3(normalattr.array[positionIndex], normalattr.array[positionIndex + 1], normalattr.array[positionIndex + 2]);
+      pos.applyMatrix4(obj.matrix);
+      normal.applyMatrix3(temporaryMatrixWithNormalCalc);
+      // Extract UV coordinates if available.
+      uvCoords = uvattr ? {
+        x: uvattr.array[uvIndex],
+        y: uvattr.array[uvIndex + 1]
+      } : void 0;
+      // Extract vertex color if available.
+      color = colorattr ? {
+        x: colorattr.array[uvIndex],
+        y: colorattr.array[uvIndex + 1],
+        z: colorattr.array[uvIndex + 2]
+      } : void 0;
+      vertices.push(new Vertex(pos, normal, uvCoords, color));
+    }
+    // Determine material index from geometry groups or use provided objectIndex.
+    if ((objectIndex === void 0) && groups && groups.length > 0) {
+      polygon = void 0;
+// Find which material group this triangle belongs to.
+      for (m = 0, len = groups.length; m < len; m++) {
+        group = groups[m];
+        if ((index[i] >= group.start) && (index[i] < (group.start + group.count))) {
+          polygon = new Polygon(vertices, group.materialIndex);
+          polygon.originalValid = true;
+        }
+      }
+      if (polygon) {
+        polys.push(polygon);
+      }
+    } else {
+      // Use provided objectIndex for all polygons.
+      polygon = new Polygon(vertices, objectIndex);
+      polygon.originalValid = true;
+      polys.push(polygon);
+    }
+  }
+// Add valid triangles to the polytree and clean up invalid ones.
+  for (i = n = 0, ref1 = polys.length; (0 <= ref1 ? n < ref1 : n > ref1); i = 0 <= ref1 ? ++n : --n) {
+    if (isValidTriangle(polys[i].triangle)) {
+      polytree.addPolygon(polys[i]);
+    } else {
+      polys[i].delete();
+    }
+  }
+  // Build spatial tree structure if requested.
+  buildTargetPolytree && polytree.buildTree();
+  // Store reference to original mesh for non-ray operations.
+  if (Polytree.usePolytreeRay !== true) {
+    polytree.mesh = obj;
+  }
+  return polytree;
+};
+// Generated by CoffeeScript 2.7.0
+// ============================================================================
+// Unite CSG Operation for Polytree
+// ============================================================================
+// This module implements the union (unite) boolean operation for Constructive
+// Solid Geometry (CSG). The unite operation combines two 3D objects by merging
+// all their surfaces while removing internal/overlapping geometry.
+// Algorithm Overview:
+// The unite operation preserves polygons from both objects that contribute to
+// the external surface of the combined result. It removes:
+// - Polygons from A that are inside B or coplanar-back with B
+// - Polygons from B that are inside A or coplanar-back/front with A
+// The operation supports both mesh-to-mesh and polytree-to-polytree inputs
+// for backward compatibility and provides optimized processing paths.
+// === POLYGON CLASSIFICATION RULES FOR UNITE OPERATION ===
+// Define which polygons to remove during unite operation.
+// Rules specify polygon states that should be deleted from each object.
+var uniteRules;
+uniteRules = {
+  // Rules for object A: Remove polygons that are inside B or coplanar-back with B.
+  a: [
+    {
+      array: true,
+      rule: ["inside",
+    "coplanar-back"]
+    },
+    {
+      array: false,
+      rule: "inside"
+    }
+  ],
+  // Rules for object B: Remove polygons inside A or coplanar with A.
+  b: [
+    {
+      array: true,
+      rule: ["inside",
+    "coplanar-back"]
+    },
+    {
+      array: true,
+      rule: ["inside",
+    "coplanar-front"]
+    },
+    {
+      array: false,
+      rule: "inside"
+    }
+  ]
+};
+// === PUBLIC CSG OPERATIONS ===
+// Perform unite (union) operation between two 3D objects.
+// This is the main entry point that handles both mesh and polytree inputs.
+// @param mesh1 - First 3D object (Three.js Mesh or Polytree instance).
+// @param mesh2 - Second 3D object (Three.js Mesh or Polytree instance).
+// @param async - Whether to perform operation asynchronously (default: true).
+// @return Three.js Mesh with united geometry, Polytree instance, or Promise.
+Polytree.unite = function(mesh1, mesh2, async = true) {
+  var polytreeA, polytreeB, resultMesh, resultPolytree, targetMaterial;
+  // Handle async request - delegate to async module.
+  if (async) {
+    // Convert meshes to polytrees if needed for async processing.
+    if (mesh1.isPolytree && mesh2.isPolytree) {
+      return Polytree.async.unite(mesh1, mesh2, true);
+    } else {
+      // Convert meshes to polytrees and return Promise that resolves to mesh.
+      polytreeA = Polytree.fromMesh(mesh1);
+      polytreeB = Polytree.fromMesh(mesh2);
+      // Get material from first mesh for final result.
+      targetMaterial = Array.isArray(mesh1.material) ? mesh1.material[0] : mesh1.material;
+      targetMaterial = targetMaterial.clone();
+      return Polytree.async.unite(polytreeA, polytreeB, false).then(function(resultPolytree) {
+        var resultMesh;
+        resultMesh = Polytree.toMesh(resultPolytree, targetMaterial);
+        disposePolytreeResources(polytreeA, polytreeB, resultPolytree);
+        return resultMesh;
+      });
+    }
+  }
+  // Handle both mesh and polytree inputs for backward compatibility.
+  if (mesh1.isPolytree && mesh2.isPolytree) {
+    // Direct polytree-to-polytree operation - most efficient path.
+    polytreeA = mesh1;
+    polytreeB = mesh2;
+    return this.uniteCore(polytreeA, polytreeB, true);
+  } else {
+    // Mesh-to-mesh operation (default behavior) - converts to polytrees internally.
+    polytreeA = Polytree.fromMesh(mesh1);
+    polytreeB = Polytree.fromMesh(mesh2);
+    // Always use material from first mesh (cloned for safety).
+    targetMaterial = Array.isArray(mesh1.material) ? mesh1.material[0] : mesh1.material;
+    targetMaterial = targetMaterial.clone();
+    // Perform unite operation and convert result back to mesh.
+    resultPolytree = this.uniteCore(polytreeA, polytreeB, false);
+    resultMesh = Polytree.toMesh(resultPolytree, targetMaterial);
+    disposePolytreeResources(polytreeA, polytreeB, resultPolytree);
+    return resultMesh;
+  }
+};
+// === CORE CSG IMPLEMENTATION ===
+// Core unite operation implementation working with polytree objects.
+// This method performs the actual CSG boolean logic for union operations.
+// @param polytreeA - First polytree object to unite.
+// @param polytreeB - Second polytree object to unite.
+// @param buildTargetPolytree - Whether to build spatial tree structure in result.
+// @return Polytree containing the united geometry.
+Polytree.uniteCore = function(polytreeA, polytreeB, buildTargetPolytree = true) {
+  var currentMeshSideA, currentMeshSideB, polytree, trianglesSet;
+  // Initialize result polytree and triangle tracking set.
+  polytree = new Polytree();
+  trianglesSet = new Set();
+  // Only process intersection if bounding boxes overlap.
+  if (polytreeA.box.intersectsBox(polytreeB.box)) {
+    // Store original material sides for restoration later.
+    currentMeshSideA = void 0;
+    currentMeshSideB = void 0;
+    // Temporarily set materials to DoubleSide for accurate intersection detection.
+    if (polytreeA.mesh) {
+      currentMeshSideA = polytreeA.mesh.material.side;
+      polytreeA.mesh.material.side = DoubleSide;
+    }
+    if (polytreeB.mesh) {
+      currentMeshSideB = polytreeB.mesh.material.side;
+      polytreeB.mesh.material.side = DoubleSide;
+    }
+    // === CSG PROCESSING PIPELINE ===
+    // Step 1: Reset polygon states for fresh classification.
+    polytreeA.resetPolygons(false);
+    polytreeB.resetPolygons(false);
+    // Step 2: Mark polygons that intersect between the two objects.
+    // Note: Method name has typo but is consistently used throughout codebase.
+    polytreeA.markIntesectingPolygons(polytreeB);
+    polytreeB.markIntesectingPolygons(polytreeA);
+    // Step 3: Handle intersecting polygons by splitting and classifying them.
+    handleIntersectingPolytrees(polytreeA, polytreeB);
+    // Step 4: Clean up replaced polygons from splitting operations.
+    polytreeA.deleteReplacedPolygons();
+    polytreeB.deleteReplacedPolygons();
+    // Step 5: Apply unite-specific rules to remove unwanted polygons.
+    polytreeA.deletePolygonsByStateRules(uniteRules.a);
+    polytreeB.deletePolygonsByStateRules(uniteRules.b);
+    // Step 6: Copy remaining polygons to result polytree.
+    polytreeA.getPolygonCloneCallback(polytree.addPolygon.bind(polytree), trianglesSet);
+    polytreeB.getPolygonCloneCallback(polytree.addPolygon.bind(polytree), trianglesSet);
+    // Restore original material sides.
+    if (polytreeA.mesh && polytreeA.mesh.material.side !== currentMeshSideA) {
+      polytreeA.mesh.material.side = currentMeshSideA;
+    }
+    if (polytreeB.mesh && polytreeB.mesh.material.side !== currentMeshSideB) {
+      polytreeB.mesh.material.side = currentMeshSideB;
+    }
+  } else {
+    // No intersection detected - simply combine all polygons from both objects.
+    polytreeA.getPolygonCloneCallback(polytree.addPolygon.bind(polytree), trianglesSet);
+    polytreeB.getPolygonCloneCallback(polytree.addPolygon.bind(polytree), trianglesSet);
+  }
+  // === FINALIZATION ===
+  // Clean up temporary triangle tracking.
+  trianglesSet.clear();
+  trianglesSet = void 0;
+  // Mark polygons as original (not generated by CSG operations).
+  polytree.markPolygonsAsOriginal();
+  // Build spatial tree structure if requested for optimization.
+  buildTargetPolytree && polytree.buildTree();
+  return polytree;
+};
+// Generated by CoffeeScript 2.7.0
+// ============================================================================
+// Subtract CSG Operation for Polytree
+// ============================================================================
+// This module implements the subtraction (difference) boolean operation for
+// Constructive Solid Geometry (CSG). The subtract operation removes the volume
+// of the second object from the first object, creating a carved-out result.
+// Algorithm Overview:
+// The subtract operation preserves polygons that define the external surface
+// of object A minus the volume of object B. It processes:
+// - Polygons from A that are outside B or coplanar-front with B
+// - Polygons from B that are inside A, inverted to form internal surfaces
+// The operation supports both mesh-to-mesh and polytree-to-polytree inputs
+// for backward compatibility and provides optimized processing paths.
+// === POLYGON CLASSIFICATION RULES FOR SUBTRACT OPERATION ===
+// Define which polygons to remove during subtract operation.
+// Rules specify polygon states that should be deleted from each object.
+var subtractRules;
+subtractRules = {
+  // Rules for object A: Remove polygons that are inside B.
+  a: [
+    {
+      array: true,
+      rule: ["inside",
+    "coplanar-back"]
+    },
+    {
+      array: true,
+      rule: ["inside",
+    "coplanar-front"]
+    },
+    {
+      array: false,
+      rule: "inside"
+    }
+  ],
+  // Rules for object B: Remove polygons that are outside A.
+  b: [
+    {
+      array: true,
+      rule: ["outside",
+    "coplanar-back"]
+    },
+    {
+      array: true,
+      rule: ["outside",
+    "coplanar-front"]
+    },
+    {
+      array: true,
+      rule: ["inside",
+    "coplanar-front"]
+    },
+    {
+      array: false,
+      rule: "outside"
+    }
+  ]
+};
+// === PUBLIC CSG OPERATIONS ===
+// Perform subtract (difference) operation between two 3D objects.
+// This removes the volume of mesh2 from mesh1, creating a carved result.
+// @param mesh1 - Primary 3D object to subtract from (Three.js Mesh or Polytree instance).
+// @param mesh2 - 3D object to subtract away (Three.js Mesh or Polytree instance).
+// @param async - Whether to perform operation asynchronously (default: true).
+// @return Three.js Mesh with subtracted geometry, Polytree instance, or Promise.
+Polytree.subtract = function(mesh1, mesh2, async = true) {
+  var polytreeA, polytreeB, resultMesh, resultPolytree, targetMaterial;
+  // Handle async request - delegate to async module.
+  if (async) {
+    // Convert meshes to polytrees if needed for async processing.
+    if (mesh1.isPolytree && mesh2.isPolytree) {
+      return Polytree.async.subtract(mesh1, mesh2, true);
+    } else {
+      // Convert meshes to polytrees and return Promise that resolves to mesh.
+      polytreeA = Polytree.fromMesh(mesh1);
+      polytreeB = Polytree.fromMesh(mesh2);
+      // Get material from first mesh for final result.
+      targetMaterial = Array.isArray(mesh1.material) ? mesh1.material[0] : mesh1.material;
+      targetMaterial = targetMaterial.clone();
+      return Polytree.async.subtract(polytreeA, polytreeB, false).then(function(resultPolytree) {
+        var resultMesh;
+        resultMesh = Polytree.toMesh(resultPolytree, targetMaterial);
+        disposePolytreeResources(polytreeA, polytreeB, resultPolytree);
+        return resultMesh;
+      });
+    }
+  }
+  // Handle both mesh and polytree inputs for backward compatibility.
+  if (mesh1.isPolytree && mesh2.isPolytree) {
+    // Direct polytree-to-polytree operation - most efficient path.
+    polytreeA = mesh1;
+    polytreeB = mesh2;
+    return this.subtractCore(polytreeA, polytreeB, true);
+  } else {
+    // Mesh-to-mesh operation (default behavior) - converts to polytrees internally.
+    polytreeA = Polytree.fromMesh(mesh1);
+    polytreeB = Polytree.fromMesh(mesh2);
+    // Always use material from first mesh (cloned for safety).
+    targetMaterial = Array.isArray(mesh1.material) ? mesh1.material[0] : mesh1.material;
+    targetMaterial = targetMaterial.clone();
+    // Perform subtract operation and convert result back to mesh.
+    resultPolytree = this.subtractCore(polytreeA, polytreeB, false);
+    resultMesh = Polytree.toMesh(resultPolytree, targetMaterial);
+    disposePolytreeResources(polytreeA, polytreeB, resultPolytree);
+    return resultMesh;
+  }
+};
+// === CORE CSG IMPLEMENTATION ===
+// Core subtract operation implementation working with polytree objects.
+// This method performs the actual CSG boolean logic for difference operations.
+// @param polytreeA - Primary polytree object to subtract from.
+// @param polytreeB - Polytree object to subtract away from A.
+// @param buildTargetPolytree - Whether to build spatial tree structure in result.
+// @return Polytree containing the subtracted geometry.
+Polytree.subtractCore = function(polytreeA, polytreeB, buildTargetPolytree = true) {
+  var currentMeshSideA, currentMeshSideB, polytree, trianglesSet;
+  // Initialize result polytree and triangle tracking set.
+  polytree = new Polytree();
+  trianglesSet = new Set();
+  // Only process intersection if bounding boxes overlap.
+  if (polytreeA.box.intersectsBox(polytreeB.box)) {
+    // Store original material sides for restoration later.
+    currentMeshSideA = void 0;
+    currentMeshSideB = void 0;
+    // Temporarily set materials to DoubleSide for accurate intersection detection.
+    if (polytreeA.mesh) {
+      currentMeshSideA = polytreeA.mesh.material.side;
+      polytreeA.mesh.material.side = DoubleSide;
+    }
+    if (polytreeB.mesh) {
+      currentMeshSideB = polytreeB.mesh.material.side;
+      polytreeB.mesh.material.side = DoubleSide;
+    }
+    // === CSG PROCESSING PIPELINE ===
+    // Step 1: Reset polygon states for fresh classification.
+    polytreeA.resetPolygons(false);
+    polytreeB.resetPolygons(false);
+    // Step 2: Mark polygons that intersect between the two objects.
+    // Note: Method name has typo but is consistently used throughout codebase.
+    polytreeA.markIntesectingPolygons(polytreeB);
+    polytreeB.markIntesectingPolygons(polytreeA);
+    // Step 3: Handle intersecting polygons by splitting and classifying them.
+    handleIntersectingPolytrees(polytreeA, polytreeB);
+    // Step 4: Clean up replaced polygons from splitting operations.
+    polytreeA.deleteReplacedPolygons();
+    polytreeB.deleteReplacedPolygons();
+    // Step 5: Apply subtract-specific rules to remove unwanted polygons.
+    polytreeA.deletePolygonsByStateRules(subtractRules.a);
+    polytreeB.deletePolygonsByStateRules(subtractRules.b);
+    // Step 6: Special processing for subtract operation.
+    // Remove intersecting polygons from B and invert B's normals for cavity formation.
+    polytreeB.deletePolygonsByIntersection(false);
+    polytreeB.invert();
+    // Step 7: Copy remaining polygons to result polytree.
+    polytreeA.getPolygonCloneCallback(polytree.addPolygon.bind(polytree), trianglesSet);
+    polytreeB.getPolygonCloneCallback(polytree.addPolygon.bind(polytree), trianglesSet);
+    // Restore original material sides.
+    if (polytreeA.mesh && polytreeA.mesh.material.side !== currentMeshSideA) {
+      polytreeA.mesh.material.side = currentMeshSideA;
+    }
+    if (polytreeB.mesh && polytreeB.mesh.material.side !== currentMeshSideB) {
+      polytreeB.mesh.material.side = currentMeshSideB;
+    }
+  } else {
+    // No intersection detected - return only object A since B doesn't affect it.
+    polytreeA.getPolygonCloneCallback(polytree.addPolygon.bind(polytree), trianglesSet);
+  }
+  // === FINALIZATION ===
+  // Clean up temporary triangle tracking.
+  trianglesSet.clear();
+  trianglesSet = void 0;
+  // Mark polygons as original (not generated by CSG operations).
+  polytree.markPolygonsAsOriginal();
+  // Build spatial tree structure if requested for optimization.
+  buildTargetPolytree && polytree.buildTree();
+  return polytree;
+};
+// Generated by CoffeeScript 2.7.0
+// ============================================================================
+// Intersect CSG Operation for Polytree
+// ============================================================================
+// This module implements the intersection boolean operation for Constructive
+// Solid Geometry (CSG). The intersect operation keeps only the overlapping
+// volume that is common to both input objects.
+// Algorithm Overview:
+// The intersect operation preserves only polygons that contribute to the
+// volume where both objects overlap. It removes extensive sets of polygons:
+// - From A: inside+coplanar-back, outside+coplanar-front/back, and outside
+// - From B: inside+coplanar-front/back, outside+coplanar-front/back, and outside
+// The operation supports both mesh-to-mesh and polytree-to-polytree inputs
+// for backward compatibility and provides optimized processing paths.
+// === POLYGON CLASSIFICATION RULES FOR INTERSECT OPERATION ===
+// Define which polygons to remove during intersect operation.
+// Rules specify polygon states that should be deleted from each object.
+// Intersect keeps only the overlapping volume, so most polygons are removed.
+var intersectRules;
+intersectRules = {
+  // Rules for object A: Remove inside+coplanar-back, outside+coplanar-front/back, and outside.
+  a: [
+    {
+      array: true,
+      rule: ["inside",
+    "coplanar-back"]
+    },
+    {
+      array: true,
+      rule: ["outside",
+    "coplanar-front"]
+    },
+    {
+      array: true,
+      rule: ["outside",
+    "coplanar-back"]
+    },
+    {
+      array: false,
+      rule: "outside"
+    }
+  ],
+  // Rules for object B: Remove inside+coplanar-front/back, outside+coplanar-front/back, and outside.
+  b: [
+    {
+      array: true,
+      rule: ["inside",
+    "coplanar-front"]
+    },
+    {
+      array: true,
+      rule: ["inside",
+    "coplanar-back"]
+    },
+    {
+      array: true,
+      rule: ["outside",
+    "coplanar-front"]
+    },
+    {
+      array: true,
+      rule: ["outside",
+    "coplanar-back"]
+    },
+    {
+      array: false,
+      rule: "outside"
+    }
+  ]
+};
+// === PUBLIC CSG OPERATIONS ===
+// Perform intersect operation between two 3D objects.
+// This keeps only the overlapping volume common to both objects.
+// @param mesh1 - First 3D object to intersect (Three.js Mesh or Polytree instance).
+// @param mesh2 - Second 3D object to intersect (Three.js Mesh or Polytree instance).
+// @param async - Whether to perform operation asynchronously (default: true).
+// @return Three.js Mesh with intersected geometry, Polytree instance, or Promise.
+Polytree.intersect = function(mesh1, mesh2, async = true) {
+  var polytreeA, polytreeB, resultMesh, resultPolytree, targetMaterial;
+  // Handle async request - delegate to async module.
+  if (async) {
+    // Convert meshes to polytrees if needed for async processing.
+    if (mesh1.isPolytree && mesh2.isPolytree) {
+      return Polytree.async.intersect(mesh1, mesh2, true);
+    } else {
+      // Convert meshes to polytrees and return Promise that resolves to mesh.
+      polytreeA = Polytree.fromMesh(mesh1);
+      polytreeB = Polytree.fromMesh(mesh2);
+      // Get material from first mesh for final result.
+      targetMaterial = Array.isArray(mesh1.material) ? mesh1.material[0] : mesh1.material;
+      targetMaterial = targetMaterial.clone();
+      return Polytree.async.intersect(polytreeA, polytreeB, false).then(function(resultPolytree) {
+        var resultMesh;
+        resultMesh = Polytree.toMesh(resultPolytree, targetMaterial);
+        disposePolytreeResources(polytreeA, polytreeB, resultPolytree);
+        return resultMesh;
+      });
+    }
+  }
+  // Handle both mesh and polytree inputs for backward compatibility.
+  if (mesh1.isPolytree && mesh2.isPolytree) {
+    // Direct polytree-to-polytree operation - most efficient path.
+    polytreeA = mesh1;
+    polytreeB = mesh2;
+    return this.intersectCore(polytreeA, polytreeB, true);
+  } else {
+    // Mesh-to-mesh operation (default behavior) - converts to polytrees internally.
+    polytreeA = Polytree.fromMesh(mesh1);
+    polytreeB = Polytree.fromMesh(mesh2);
+    // Always use material from first mesh (cloned for safety).
+    targetMaterial = Array.isArray(mesh1.material) ? mesh1.material[0] : mesh1.material;
+    targetMaterial = targetMaterial.clone();
+    // Perform intersect operation and convert result back to mesh.
+    resultPolytree = this.intersectCore(polytreeA, polytreeB, false);
+    resultMesh = Polytree.toMesh(resultPolytree, targetMaterial);
+    disposePolytreeResources(polytreeA, polytreeB, resultPolytree);
+    return resultMesh;
+  }
+};
+// === CORE CSG IMPLEMENTATION ===
+// Core intersect operation implementation working with polytree objects.
+// This method performs the actual CSG boolean logic for intersection operations.
+// @param polytreeA - First polytree object to intersect.
+// @param polytreeB - Second polytree object to intersect.
+// @param buildTargetPolytree - Whether to build spatial tree structure in result.
+// @return Polytree containing the intersected geometry.
+Polytree.intersectCore = function(polytreeA, polytreeB, buildTargetPolytree = true) {
+  var currentMeshSideA, currentMeshSideB, polytree, trianglesSet;
+  // Initialize result polytree and triangle tracking set.
+  polytree = new Polytree();
+  trianglesSet = new Set();
+  // Only process intersection if bounding boxes overlap.
+  if (polytreeA.box.intersectsBox(polytreeB.box)) {
+    // Store original material sides for restoration later.
+    currentMeshSideA = void 0;
+    currentMeshSideB = void 0;
+    // Temporarily set materials to DoubleSide for accurate intersection detection.
+    if (polytreeA.mesh) {
+      currentMeshSideA = polytreeA.mesh.material.side;
+      polytreeA.mesh.material.side = DoubleSide;
+    }
+    if (polytreeB.mesh) {
+      currentMeshSideB = polytreeB.mesh.material.side;
+      polytreeB.mesh.material.side = DoubleSide;
+    }
+    // === CSG PROCESSING PIPELINE ===
+    // Step 1: Reset polygon states for fresh classification.
+    polytreeA.resetPolygons(false);
+    polytreeB.resetPolygons(false);
+    // Step 2: Mark polygons that intersect between the two objects.
+    // Note: Method name has typo but is consistently used throughout codebase.
+    polytreeA.markIntesectingPolygons(polytreeB);
+    polytreeB.markIntesectingPolygons(polytreeA);
+    // Step 3: Handle intersecting polygons by splitting and classifying them.
+    handleIntersectingPolytrees(polytreeA, polytreeB);
+    // Step 4: Clean up replaced polygons from splitting operations.
+    polytreeA.deleteReplacedPolygons();
+    polytreeB.deleteReplacedPolygons();
+    // Step 5: Apply intersect-specific rules to remove unwanted polygons.
+    polytreeA.deletePolygonsByStateRules(intersectRules.a);
+    polytreeB.deletePolygonsByStateRules(intersectRules.b);
+    // Step 6: Special processing for intersect operation.
+    // Remove intersecting polygons from both objects to clean up overlapping geometry.
+    polytreeA.deletePolygonsByIntersection(false);
+    polytreeB.deletePolygonsByIntersection(false);
+    // Step 7: Copy remaining polygons to result polytree.
+    polytreeA.getPolygonCloneCallback(polytree.addPolygon.bind(polytree), trianglesSet);
+    polytreeB.getPolygonCloneCallback(polytree.addPolygon.bind(polytree), trianglesSet);
+    // Restore original material sides.
+    if (polytreeA.mesh && polytreeA.mesh.material.side !== currentMeshSideA) {
+      polytreeA.mesh.material.side = currentMeshSideA;
+    }
+    if (polytreeB.mesh && polytreeB.mesh.material.side !== currentMeshSideB) {
+      polytreeB.mesh.material.side = currentMeshSideB;
+    }
+  }
+  // Note: If no intersection, result is empty (no polygons added).
+  // === FINALIZATION ===
+  // Clean up temporary triangle tracking.
+  trianglesSet.clear();
+  trianglesSet = void 0;
+  // Mark polygons as original (not generated by CSG operations).
+  polytree.markPolygonsAsOriginal();
+  // Build spatial tree structure if requested for optimization.
+  buildTargetPolytree && polytree.buildTree();
+  return polytree;
+};
+// Generated by CoffeeScript 2.7.0
+// === ASYNC CSG OPERATIONS FOR POLYTREE ===
+// This module provides asynchronous implementations of Constructive Solid Geometry (CSG) operations.
+// All operations are Promise-based and include proper resource management and error handling.
+// The async operations allow for better performance in web environments by preventing UI blocking.
+Polytree.async = {
+  // Default batch size for processing large arrays of objects.
+  // Objects arrays larger than this size will be processed in batches to prevent memory issues.
+  batchSize: DEFAULT_BUFFER_SIZE,
+  // Maximum worker threads hint for parallel processing (informational).
+  // Set to Infinity for unlimited parallelism when supported by the environment.
+  maxWorkerThreads: MAX_WORKER_THREADS,
+  // Perform asynchronous union operation between two polytree objects.
+  // Creates a new polytree containing the combined volume of both input polytrees.
+  // @param polytreeA - First polytree operand for the union operation.
+  // @param polytreeB - Second polytree operand for the union operation.
+  // @param buildTargetPolytree - Whether to build the target polytree structure (default: true).
+  // @return Promise that resolves to the resulting polytree from the union operation.
+  unite: function(polytreeA, polytreeB, buildTargetPolytree = true) {
+    return new Promise(function(resolve, reject) {
+      var error, result, timeoutId;
+      timeoutId = null; // Set up operation timeout only if not infinite.
+      if (ASYNC_OPERATION_TIMEOUT !== 2e308) {
+        timeoutId = setTimeout(function() {
+          return reject(new Error(`Union operation timed out after ${ASYNC_OPERATION_TIMEOUT}ms`));
+        }, ASYNC_OPERATION_TIMEOUT);
+      }
+      try {
+        result = Polytree.uniteCore(polytreeA, polytreeB, buildTargetPolytree);
+        disposePolytreeResources(polytreeA, polytreeB);
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        return resolve(result);
+      } catch (error1) {
+        error = error1;
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        disposePolytreeResources(polytreeA, polytreeB);
+        return reject(error);
+      }
+    });
+  },
+  // Perform asynchronous subtraction operation between two polytree objects.
+  // Creates a new polytree by removing the volume of polytreeB from polytreeA.
+  // @param polytreeA - The polytree to subtract from (minuend).
+  // @param polytreeB - The polytree to subtract (subtrahend).
+  // @param buildTargetPolytree - Whether to build the target polytree structure (default: true).
+  // @return Promise that resolves to the resulting polytree from the subtraction operation.
+  subtract: function(polytreeA, polytreeB, buildTargetPolytree = true) {
+    return new Promise(function(resolve, reject) {
+      var error, result, timeoutId;
+      timeoutId = null; // Set up operation timeout only if not infinite.
+      if (ASYNC_OPERATION_TIMEOUT !== 2e308) {
+        timeoutId = setTimeout(function() {
+          return reject(new Error(`Subtract operation timed out after ${ASYNC_OPERATION_TIMEOUT}ms`));
+        }, ASYNC_OPERATION_TIMEOUT);
+      }
+      try {
+        result = Polytree.subtractCore(polytreeA, polytreeB, buildTargetPolytree);
+        disposePolytreeResources(polytreeA, polytreeB);
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        return resolve(result);
+      } catch (error1) {
+        error = error1;
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        disposePolytreeResources(polytreeA, polytreeB);
+        return reject(error);
+      }
+    });
+  },
+  // Perform asynchronous intersection operation between two polytree objects.
+  // Creates a new polytree containing only the overlapping volume of both input polytrees.
+  // @param polytreeA - First polytree operand for the intersection operation.
+  // @param polytreeB - Second polytree operand for the intersection operation.
+  // @param buildTargetPolytree - Whether to build the target polytree structure (default: true).
+  // @return Promise that resolves to the resulting polytree from the intersection operation.
+  intersect: function(polytreeA, polytreeB, buildTargetPolytree = true) {
+    return new Promise(function(resolve, reject) {
+      var error, result, timeoutId;
+      timeoutId = null; // Set up operation timeout only if not infinite.
+      if (ASYNC_OPERATION_TIMEOUT !== 2e308) {
+        timeoutId = setTimeout(function() {
+          return reject(new Error(`Intersect operation timed out after ${ASYNC_OPERATION_TIMEOUT}ms`));
+        }, ASYNC_OPERATION_TIMEOUT);
+      }
+      try {
+        result = Polytree.intersectCore(polytreeA, polytreeB, buildTargetPolytree);
+        disposePolytreeResources(polytreeA, polytreeB);
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        return resolve(result);
+      } catch (error1) {
+        error = error1;
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+        }
+        disposePolytreeResources(polytreeA, polytreeB);
+        return reject(error);
+      }
+    });
+  },
+  // Perform asynchronous union operation on an array of objects.
+  // Efficiently processes large arrays using batching and parallel execution.
+  // This method can handle arrays of meshes or polytrees and will convert them as needed.
+  // @param objectArray - Array of meshes or polytrees to unite.
+  // @param materialIndexMax - Maximum material index for assignment (default: Infinity).
+  // @return Promise that resolves to a single polytree containing the union of all objects.
+  uniteArray: function(objectArray, materialIndexMax = 2e308) {
+    return Polytree.async.processArrayWithOperation(objectArray, materialIndexMax, Polytree.async.unite, Polytree.async.uniteArray, 'union');
+  },
+  // Perform asynchronous subtraction operation on an array of objects.
+  // Efficiently processes large arrays using batching and parallel execution.
+  // This method subtracts all subsequent objects from the first object in the array.
+  // @param objectArray - Array of meshes or polytrees to process with subtraction.
+  // @param materialIndexMax - Maximum material index for assignment (default: Infinity).
+  // @return Promise that resolves to a single polytree with all subtractions applied.
+  subtractArray: function(objectArray, materialIndexMax = 2e308) {
+    return Polytree.async.processArrayWithOperation(objectArray, materialIndexMax, Polytree.async.subtract, Polytree.async.subtractArray, 'subtraction');
+  },
+  // Perform asynchronous intersection operation on an array of objects.
+  // Efficiently processes large arrays using batching and parallel execution.
+  // This method finds the overlapping volume common to all objects in the array.
+  // @param objectArray - Array of meshes or polytrees to intersect.
+  // @param materialIndexMax - Maximum material index for assignment (default: Infinity).
+  // @return Promise that resolves to a single polytree containing the intersection of all objects.
+  intersectArray: function(objectArray, materialIndexMax = 2e308) {
+    return Polytree.async.processArrayWithOperation(objectArray, materialIndexMax, Polytree.async.intersect, Polytree.async.intersectArray, 'intersection');
+  },
+  // Main operation handler that delegates to the synchronous operation method.
+  // This provides a unified interface for complex CSG operations with async support.
+  // @param operationObject - Object containing the operation definition.
+  // @param returnPolytrees - Whether to return polytree objects instead of meshes.
+  // @param buildTargetPolytree - Whether to build the target polytree structure.
+  // @param options - Configuration options including objCounter for unique IDs.
+  // @param firstRun - Whether this is the top-level operation call.
+  // @return Result of the operation (mesh, polytree, or operation tree).
+  operation: function(operationObject, returnPolytrees = false, buildTargetPolytree = true, options = {
+      objCounter: 0
+    }, firstRun = true) {
+    return Polytree.operation(operationObject, returnPolytrees, buildTargetPolytree, options, firstRun, true);
+  },
+  // Generic helper method for processing array operations with any CSG operation.
+  // This reduces code duplication between uniteArray, subtractArray, and intersectArray.
+  // @param objectArray - Array of meshes or polytrees to process.
+  // @param materialIndexMax - Maximum material index for assignment.
+  // @param operationMethod - The async CSG method to use (unite, subtract, or intersect).
+  // @param arrayOperationMethod - The corresponding array method for recursive calls.
+  // @param operationName - Name of the operation for error messages.
+  // @return Promise that resolves to the final result polytree.
+  processArrayWithOperation: function(objectArray, materialIndexMax, operationMethod, arrayOperationMethod, operationName) {
+    return new Promise(function(resolve, reject) {
+      var batchArray, batchPromise, convertedPolytree, currentBatch, currentBatchIndex, error, i, isMainPolytreeUsed, j, leftOverPolytree, leftOverPromise, mainPolytree, materialIndex, objectIndex, operationPromises, pairPromise, pairStartIndex, polytreesArray, ref, ref1, shouldUseBatching;
+      try {
+        // Determine if we should use batching based on array size and batch configuration.
+        shouldUseBatching = Polytree.async.batchSize > 4 && Polytree.async.batchSize < objectArray.length;
+        mainPolytree = void 0;
+        isMainPolytreeUsed = false;
+        operationPromises = [];
+        if (shouldUseBatching) {
+          // Process large arrays in batches to prevent memory issues.
+          batchArray = [];
+          currentBatchIndex = 0;
+          while (currentBatchIndex < objectArray.length) {
+            batchArray.push(objectArray.slice(currentBatchIndex, currentBatchIndex + Polytree.async.batchSize));
+            currentBatchIndex += Polytree.async.batchSize;
+          }
+          currentBatch = batchArray.shift();
+          while (currentBatch) {
+            batchPromise = arrayOperationMethod(currentBatch, 0);
+            operationPromises.push(batchPromise);
+            currentBatch = batchArray.shift();
+          }
+          // Mark that we're using batching and clear the original array.
+          shouldUseBatching = true;
+          isMainPolytreeUsed = true;
+          objectArray.length = 0;
+        } else {
+          // Process smaller arrays directly without batching.
+          polytreesArray = [];
+          for (objectIndex = i = 0, ref = objectArray.length; (0 <= ref ? i < ref : i > ref); objectIndex = 0 <= ref ? ++i : --i) {
+            materialIndex = objectIndex > materialIndexMax ? materialIndexMax : objectIndex;
+            convertedPolytree = void 0;
+            // Convert mesh to polytree if necessary.
+            if (objectArray[objectIndex].isMesh) {
+              convertedPolytree = Polytree.fromMesh(objectArray[objectIndex], materialIndexMax > -1 ? materialIndex : void 0);
+            } else {
+              convertedPolytree = objectArray[objectIndex];
+              if (materialIndexMax > -1) {
+                convertedPolytree.setPolygonIndex(materialIndex);
+              }
+            }
+            // Set tracking index for debugging and traceability.
+            convertedPolytree.polytreeIndex = objectIndex;
+            polytreesArray.push(convertedPolytree);
+          }
+          // Extract the first polytree as the main polytree.
+          mainPolytree = polytreesArray.shift();
+          leftOverPolytree = void 0;
+// Process polytrees in pairs for parallel execution.
+          for (pairStartIndex = j = 0, ref1 = polytreesArray.length; j < ref1; pairStartIndex = j += 2) {
+            if (pairStartIndex + 1 >= polytreesArray.length) {
+              // Handle odd number of polytrees - save the leftover.
+              leftOverPolytree = polytreesArray[pairStartIndex];
+              break;
+            }
+            pairPromise = operationMethod(polytreesArray[pairStartIndex], polytreesArray[pairStartIndex + 1]);
+            operationPromises.push(pairPromise);
+          }
+          // If there's a leftover polytree, apply operation with the main polytree.
+          if (leftOverPolytree) {
+            leftOverPromise = operationMethod(mainPolytree, leftOverPolytree);
+            operationPromises.push(leftOverPromise);
+            isMainPolytreeUsed = true;
+          }
+        }
+        // Wait for all parallel operations to complete and process results.
+        return Promise.allSettled(operationPromises).then(function(promiseResults) {
+          var successfulPolytrees;
+          successfulPolytrees = [];
+          // Extract successful results from the promise results.
+          promiseResults.forEach(function(promiseResult) {
+            if (promiseResult.status === "fulfilled") {
+              return successfulPolytrees.push(promiseResult.value);
+            }
+          });
+          // Add the main polytree if it wasn't used in operations.
+          if (!isMainPolytreeUsed) {
+            successfulPolytrees.unshift(mainPolytree);
+          }
+          // Process the final results based on count.
+          if (successfulPolytrees.length > 0) {
+            if (successfulPolytrees.length === 1) {
+              return resolve(successfulPolytrees[0]);
+            } else if (successfulPolytrees.length > 3) {
+              // Use recursive processing for large result sets.
+              return arrayOperationMethod(successfulPolytrees, shouldUseBatching ? 0 : -1).then(function(finalResult) {
+                return resolve(finalResult);
+              }).catch(function(error) {
+                return reject(error);
+              });
+            } else {
+              // Handle 2-3 results directly for efficiency.
+              return operationMethod(successfulPolytrees[0], successfulPolytrees[1]).then(function(intermediateResult) {
+                if (successfulPolytrees.length === 3) {
+                  return operationMethod(intermediateResult, successfulPolytrees[2]).then(function(finalResult) {
+                    return resolve(finalResult);
+                  }).catch(function(error) {
+                    return reject(error);
+                  });
+                } else {
+                  return resolve(intermediateResult);
+                }
+              }).catch(function(error) {
+                return reject(error);
+              });
+            }
+          } else {
+            return reject(`Unable to find any result polytree after ${operationName} operation.`);
+          }
+        });
+      } catch (error1) {
+        error = error1;
+        return reject(error);
+      }
+    });
+  }
+};
+// Generated by CoffeeScript 2.7.0
+// Main class for representing geometric planes in 3D space.
+// Planes are defined by a normal vector and a distance from the origin.
+// Used extensively in CSG operations for polygon classification and splitting.
+var Plane;
+Plane = class Plane {
+  // Main constructor for creating plane instances.
+  // Creates a plane defined by the equation: normal·point = distanceFromOrigin
+  // @param normal - Three.js Vector3 representing the plane's normal direction.
+  // @param distanceFromOrigin - Distance from origin along the normal direction.
+  constructor(normal, distanceFromOrigin) {
+    // Core geometric properties.
+    this.normal = normal; // Normal vector defining plane orientation.
+    this.distanceFromOrigin = distanceFromOrigin; // Distance parameter in plane equation.
+  }
+  
+    // === OBJECT CREATION AND COPYING ===
+  clone() { // Create a deep copy of this plane with all properties.
+    return new Plane(this.normal.clone(), this.distanceFromOrigin);
+  }
+  // === GEOMETRIC TRANSFORMATIONS ===
+  flip() { // Flip the plane orientation (reverse normal and negate distance).
+    this.normal.negate();
+    return this.distanceFromOrigin = -this.distanceFromOrigin;
+  }
+  // === COMPARISON OPERATIONS ===
+    // Test if this plane is identical to another plane.
+  // Compares both normal vector and distance parameter for equality.
+  // @param otherPlane - The other plane to compare against.
+  // @return Boolean indicating whether planes are identical.
+  equals(otherPlane) {
+    return this.normal.equals(otherPlane.normal) && this.distanceFromOrigin === otherPlane.distanceFromOrigin;
+  }
+  // === CLEANUP AND DISPOSAL METHODS ===
+    // Clean up plane data by setting all properties to undefined.
+  // Used for memory management during intensive operations.
+  delete() {
+    this.normal = void 0;
+    return this.distanceFromOrigin = void 0;
+  }
+  // === STATIC FACTORY METHODS ===
+    // Create a plane from three points in 3D space.
+  // Uses cross product to compute normal and dot product for distance.
+  // Points should be ordered counter-clockwise when viewed from the front face.
+  // @param firstPoint - First point (Three.js Vector3).
+  // @param secondPoint - Second point (Three.js Vector3).
+  // @param thirdPoint - Third point (Three.js Vector3).
+  // @return New Plane instance passing through the three points.
+  static fromPoints(firstPoint, secondPoint, thirdPoint) {
+    var planeNormal;
+    planeNormal = temporaryTriangleVertex.copy(secondPoint).sub(firstPoint).cross(temporaryTriangleVertexSecondary.copy(thirdPoint).sub(firstPoint)).normalize().clone();
+    return new Plane(planeNormal, planeNormal.dot(firstPoint));
+  }
+};
+// Generated by CoffeeScript 2.7.0
+// Main class for representing polygons (triangular faces) in 3D space for CSG operations.
+// Polygons are fundamental building blocks for geometric operations and mesh generation.
+var Polygon;
+Polygon = class Polygon {
+  // Main constructor for creating polygon instances.
+  // Initializes all geometric and state properties for CSG processing.
+  // @param vertices - Array of Vertex instances representing the polygon corners.
+  // @param shared - Material or shared data index for grouping polygons.
+  constructor(vertices, shared) {
+    // Core geometric properties.
+    this.id = polygonID++; // Unique identifier for this polygon.
+    this.vertices = vertices.map(function(vertex) {
+      return vertex.clone(); // Deep copy of vertex array.
+    });
+    this.shared = shared; // Material index or shared data.
+    
+    // Geometric calculations.
+    this.plane = Plane.fromPoints(this.vertices[0].pos, this.vertices[1].pos, this.vertices[2].pos);
+    this.triangle = new Triangle(this.vertices[0].pos, this.vertices[1].pos, this.vertices[2].pos);
+    // CSG operation state properties.
+    this.intersects = false; // Whether polygon intersects with other geometry.
+    this.state = "undecided"; // Current classification state.
+    this.previousState = "undecided"; // Previous classification state.
+    this.previousStates = []; // History of all previous states.
+    
+    // Validity and processing flags.
+    this.valid = true; // Whether polygon is valid for processing.
+    this.coplanar = false; // Whether polygon is coplanar with splitting plane.
+    this.originalValid = false; // Whether polygon was part of original input.
+    this.newPolygon = false; // Whether polygon was created during processing.
+  }
+  
+    // === SMALL HELPERS AND GETTERS ===
+    // Get the midpoint of the polygon triangle.
+  // Caches the result for performance optimization.
+  // @return Three.js Vector3 representing the triangle midpoint.
+  getMidpoint() {
+    if (this.triangle.midPoint) {
+      return this.triangle.midPoint;
+    } else {
+      return this.triangle.midPoint = this.triangle.getMidpoint(new Vector3());
+    }
+  }
+  // === GEOMETRIC TRANSFORMATIONS ===
+    // Apply a transformation matrix to the polygon vertices and update derived geometry.
+  // Updates vertex positions, normals, and recalculates plane and triangle data.
+  // @param matrix - Three.js Matrix4 transformation to apply to vertices.
+  // @param normalMatrix - Three.js Matrix3 for transforming normals (auto-calculated if not provided).
+  applyMatrix(matrix, normalMatrix) {
+    normalMatrix = normalMatrix || temporaryMatrixWithNormalCalc.getNormalMatrix(matrix);
+    this.vertices.forEach(function(vertex) {
+      vertex.pos.applyMatrix4(matrix);
+      return vertex.normal.applyMatrix3(normalMatrix);
+    });
+    this.plane.delete();
+    this.plane = Plane.fromPoints(this.vertices[0].pos, this.vertices[1].pos, this.vertices[2].pos);
+    this.triangle.set(this.vertices[0].pos, this.vertices[1].pos, this.vertices[2].pos);
+    if (this.triangle.midPoint) {
+      return this.triangle.getMidpoint(this.triangle.midPoint);
+    }
+  }
+  // Flip the polygon orientation by reversing vertex order and flipping normals.
+  // Used for changing polygon winding and surface normal direction.
+  flip() {
+    var tmp;
+    this.vertices.reverse().forEach(function(vertex) {
+      return vertex.flip();
+    });
+    tmp = this.triangle.a;
+    this.triangle.a = this.triangle.c;
+    this.triangle.c = tmp;
+    return this.plane.flip();
+  }
+  // === CSG STATE MANAGEMENT ===
+    // Reset polygon state to initial values for fresh CSG operations.
+  // Clears intersection flags and classification states.
+  // @param resetOriginal - Whether to reset the originalValid flag (default: true).
+  reset(resetOriginal = true) {
+    this.intersects = false;
+    this.state = "undecided";
+    this.previousState = "undecided";
+    this.previousStates.length = 0;
+    this.valid = true;
+    this.coplanar = false;
+    resetOriginal && (this.originalValid = false);
+    return this.newPolygon = false;
+  }
+  // Set the classification state of the polygon during CSG operations.
+  // Maintains state history for complex CSG rule evaluation.
+  // @param state - New state to assign ("inside", "outside", "coplanar-front", etc.).
+  // @param keepState - State to preserve (won't change if current state matches this).
+  setState(state, keepState) {
+    if (this.state === keepState) {
+      return;
+    }
+    this.previousState = this.state;
+    this.state !== "undecided" && this.previousStates.push(this.state);
+    return this.state = state;
+  }
+  // Check if polygon has consistently been in the specified state.
+  // Used for CSG rule evaluation requiring state consistency.
+  // @param state - State to check for consistency.
+  // @return Boolean indicating if all states match the specified state.
+  checkAllStates(state) {
+    var i, len, previousState, ref;
+    if ((this.state !== state) || ((this.previousState !== state) && (this.previousState !== "undecided"))) {
+      return false;
+    }
+    ref = this.previousStates;
+    for (i = 0, len = ref.length; i < len; i++) {
+      previousState = ref[i];
+      if (previousState !== state) {
+        return false;
+      }
+    }
+    return true;
+  }
+  // === VALIDITY MANAGEMENT ===
+    // Mark polygon as invalid (will be excluded from processing).
+  setInvalid() {
+    return this.valid = false;
+  }
+  // Mark polygon as valid (will be included in processing).
+  setValid() {
+    return this.valid = true;
+  }
+  // === OBJECT CREATION AND COPYING ===
+    // Create a polygon with default material index.
+  // Convenience method for creating polygons without specifying material.
+  // @param vertices - Array of Vertex instances representing the polygon corners.
+  // @return New Polygon instance with default material.
+  static createWithDefaultMaterial(vertices) {
+    return new Polygon(vertices, DEFAULT_MATERIAL_INDEX);
+  }
+  // Create a deep copy of this polygon with all properties.
+  // Preserves all state information and geometric data.
+  // @return New Polygon instance with copied data.
+  clone() {
+    var polygon;
+    polygon = new Polygon(this.vertices.map(function(vertex) {
+      return vertex.clone();
+    }), this.shared);
+    polygon.intersects = this.intersects;
+    polygon.valid = this.valid;
+    polygon.coplanar = this.coplanar;
+    polygon.state = this.state;
+    polygon.originalValid = this.originalValid;
+    polygon.newPolygon = this.newPolygon;
+    polygon.previousState = this.previousState;
+    polygon.previousStates = this.previousStates.slice();
+    if (this.triangle.midPoint) {
+      polygon.triangle.midPoint = this.triangle.midPoint.clone();
+    }
+    return polygon;
+  }
+  // === CLEANUP AND DISPOSAL METHODS ===
+    // Clean up polygon data and free memory.
+  // Deletes vertices, geometric objects, and marks polygon as invalid.
+  delete() {
+    this.vertices.forEach(function(vertex) {
+      return vertex.delete();
+    });
+    this.vertices.length = 0;
+    if (this.plane) {
+      this.plane.delete();
+      this.plane = void 0;
+    }
+    this.triangle = void 0;
+    this.shared = void 0;
+    return this.setInvalid();
+  }
+};
+// Generated by CoffeeScript 2.7.0
+/* Validate a triangle (three distinct vertices) in 3D space.
+Notes:
+- This does NOT check for area > 0 beyond coincident points (collinear but distinct points are treated as valid).
+- Use additional orientation/area tests if you need to exclude collinear triangles. */
+/* Determines the intersection segment (if any) between two triangles in 3D space.
+    If an intersection segment exists, its endpoints are written to `additions.source` and `additions.target`.
+@param {Vector3} vertex1TriangleA, vertex2TriangleA, vertex3TriangleA - Vertices of triangle A
+@param {Vector3} vertex1TriangleB, vertex2TriangleB, vertex3TriangleB - Vertices of triangle B
+@param {Object} additions - Data object used for storing extra intersection info:
+    - coplanar {Boolean} whether the triangles lie in the same plane.
+    - source {Vector3} intersection segment start (if applicable).
+    - target {Vector3} intersection segment end (if applicable).
+    - normal1 {Vector3} normal of Triangle A (used in coplanar case).
+    - normal2 {Vector3} normal of Triangle B (used in coplanar case).
+@return {Boolean} True if intersection segment exists, false otherwise. */
+    /* Checks for edge intersection between two triangles in 2D.
+    @param {Vector2} vertex1TriangleA, vertex2TriangleA, vertex3TriangleA - Vertices of triangle A
+    @param {Vector2} vertex1TriangleB, vertex2TriangleB, vertex3TriangleB - Vertices of triangle B
+    @return {Boolean} True if an edge intersection is found, false otherwise. */
+    /* Checks for vertex intersection between two triangles in 2D.
+    @param {Vector2} vertex1TriangleA, vertex2TriangleA, vertex3TriangleA - Vertices of triangle A
+    @param {Vector2} vertex1TriangleB, vertex2TriangleB, vertex3TriangleB - Vertices of triangle B
+    @return {Boolean} True if a vertex intersection is found, false otherwise. */
+    /* Check and register triangle uniqueness in a Set/Map.
+    Hash Scheme:
+    - Generates a directional hash using the ordered vertex triplet (a,b,c).
+    - Different vertex order permutations of the same geometric triangle will be treated as different unless normalized before calling.
+    Usage Guidance:
+    - For order-invariant uniqueness, sort or canonicalize vertices first (e.g., by lexicographic (x,y,z)) before invoking.
+    - For performance, this function only creates a single concatenated string and performs a Set lookup. */
+    /* Resolves intersection between two coplanar triangles in 3D space.
+        Since the triangles lie in the same plane, the problem is reduced from 3D to 2D.
+        By projecting both triangles onto the axis-aligned plane (XY, YZ, or XZ) that maximizes the projected area.
+        This minimizes numerical errors when working in 2D. The function then delegates the overlap test to `trianglesOverlap2D`.
+    @param {Vector2} vertex1TriangleA, vertex2TriangleA, vertex3TriangleA - Vertices of triangle A
+    @param {Vector2} vertex1TriangleB, vertex2TriangleB, vertex3TriangleB - Vertices of triangle B
+    @param {Vector3} normalTriangleA - Normal vector of Triangle A.
+    @param {Vector3} normalTriangleB - Normal vector of Triangle B.
+    @returns {Boolean} - True if the coplanar triangles overlap in 2D, false otherwise. */
+    /* Determines the intersection between two 3D triangles given their vertices and the signed distances of Triangle B’s vertices to the plane of Triangle A.
+        Goal: Always pass to `constructIntersection` the triangles arranged so the first vertex of each lies alone on one side of the other triangle’s plane (or is on the plane), and the remaining two share the opposite side.
+        This function chooses one of several vertex orderings based on the sign pattern of (distanceVertex1B, distanceVertex2B, distanceVertex3B).
+        If all three distances for Triangle B are zero → triangles are coplanar and handled by `resolveCoplanarTriangleIntersection`.
+    @param {Vector2} vertex1TriangleA, vertex2TriangleA, vertex3TriangleA - Vertices of triangle A
+    @param {Vector2} vertex1TriangleB, vertex2TriangleB, vertex3TriangleB - Vertices of triangle B
+    @param {Number} distanceVertex1B - Signed distance of vertex1TriangleB to Triangle A’s plane.
+    @param {Number} distanceVertex2B - Signed distance of vertex2TriangleB to Triangle A’s plane.
+    @param {Number} distanceVertex3B - Signed distance of vertex3TriangleB to Triangle A’s plane.
+    @param {Object} additions - Data object used for storing extra intersection info:
+        - coplanar {Boolean} whether the triangles lie in the same plane.
+        - source {Vector3} intersection segment start (if applicable).
+        - target {Vector3} intersection segment end (if applicable).
+        - normal1 {Vector3} normal of Triangle A (used in coplanar case).
+        - normal2 {Vector3} normal of Triangle B (used in coplanar case).
+    @returns {Boolean} - True if an intersection is found, false otherwise. */
+    /* Determines if two counter-clockwise (CCW) triangles in 2D overlap.
+        The function checks the relative orientation of triangle B's vertices with respect to triangle A.
+        Then recursively tests for edge or vertex intersection depending on the configuration.
+    @param {Vector2} vertex1TriangleA, vertex2TriangleA, vertex3TriangleA - Vertices of triangle A (CCW order)
+    @param {Vector2} vertex1TriangleB, vertex2TriangleB, vertex3TriangleB - Vertices of triangle B (CCW order)
+    @return {Boolean} True if triangles overlap, false otherwise. */
+    /* Checks whether two triangles in 3D space intersect.
+    @param {Object} triangleA - First triangle, with properties {a, b, c} (Vector3 vertices).
+    @param {Object} triangleB - Second triangle, with properties {a, b, c} (Vector3 vertices).
+    @param {Object} additions - Optional data object used for storing extra intersection info:
+        - coplanar {Boolean} whether the triangles lie in the same plane.
+        - source {Vector3} intersection segment start (if applicable).
+        - target {Vector3} intersection segment end (if applicable).
+    @returns {Boolean} - True if the triangles intersect, false otherwise. */
+    /* Computes the orientation (signed area) of a 2D triangle defined by three vertices.
+        The result indicates whether the points are arranged clockwise (CW), counter-clockwise (CCW), or collinear.
+        Note: This returns the raw signed area (twice the triangle area), without applying an epsilon threshold.
+        Callers should compare against a small EPS (e.g., TRIANGLE_2D_EPSILON) when classifying near-collinear inputs.
+        Formula: orientation(a, b, c) = (a.x - c.x) * (b.y - c.y) - (a.y - c.y) * (b.x - c.x)
+        - If result > 0 → counter-clockwise (CCW).
+        - If result < 0 → clockwise (CW).
+        - If result = 0 → points are collinear.
+    @param {Vector2} a - First vertex.
+    @param {Vector2} b - Second vertex.
+    @param {Vector2} c - Third vertex.
+    @returns {Number} - Positive if CCW, negative if CW, zero if collinear. */
+    /* Determines whether two triangles in 2D overlap.
+        Behavior and notes:
+        - Orientation: Triangles may be CW or CCW; inputs are normalized to CCW before testing.
+        - Inclusivity: Overlap is inclusive of shared edges and shared vertices.
+        - Degenerate handling:
+            - If one triangle degenerates to a point, returns whether that point lies in (or on) the other triangle.
+            - If both degenerate to points, returns true only if the points coincide within TRIANGLE_2D_EPSILON.
+            - Degenerate line triangles are handled by the main CCW intersection routine and by point/segment checks where applicable.
+    @param {Vector2} vertex1TriangleA, vertex2TriangleA, vertex3TriangleA - Vertices of triangle A
+    @param {Vector2} vertex1TriangleB, vertex2TriangleB, vertex3TriangleB - Vertices of triangle B
+    @returns {Boolean} - True if the triangles overlap in 2D, false otherwise. */
+var constructIntersection, intersectionTestEdge2D, intersectionTestVertex2D, isUniqueTriangle, isValidTriangle, pointInTriangleInclusive2D, pointOnSegmentInclusive2D, pointsEqual2D, resolveCoplanarTriangleIntersection, resolveTriangleIntersection, triangleIntersectionCCW2D, triangleIntersectsTriangle, triangleOrientation2D, trianglesOverlap2D;
+isValidTriangle = function(triangle) {
+  if (DEBUG_GEOMETRY_VALIDATION) {
+    console.log("Validating triangle:", triangle.a, triangle.b, triangle.c);
+  }
+  if (triangle.a.equals(triangle.b)) {
+    return false;
+  }
+  if (triangle.a.equals(triangle.c)) {
+    return false;
+  }
+  if (triangle.b.equals(triangle.c)) {
+    return false;
+  }
+  if (DEBUG_GEOMETRY_VALIDATION) {
+    console.log("Triangle validation passed.");
+  }
+  return true;
+};
+isUniqueTriangle = function(triangle, set, map) {
+  var hash1;
+  hash1 = `{${triangle.a.x},${triangle.a.y},${triangle.a.z}}-{${triangle.b.x},${triangle.b.y},${triangle.b.z}}-{${triangle.c.x},${triangle.c.y},${triangle.c.z}}`;
+  if (set.has(hash1) === true) {
+    return false;
+  } else {
+    set.add(hash1);
+    if (map) {
+      map.set(triangle, triangle);
+    }
+    return true;
+  }
+};
+// Epsilon-aware 2D point equality.
+pointsEqual2D = function(p, q, eps = TRIANGLE_2D_EPSILON) {
+  return Math.abs(p.x - q.x) <= eps && Math.abs(p.y - q.y) <= eps;
+};
+// Inclusive point-on-segment check for collinear points.
+pointOnSegmentInclusive2D = function(p, a, b, eps = TRIANGLE_2D_EPSILON) {
+  var maxX, maxY, minX, minY;
+  if (pointsEqual2D(a, b, eps)) {
+    return pointsEqual2D(p, a, eps) || pointsEqual2D(p, b, eps);
+  }
+  if (Math.abs(triangleOrientation2D(p, a, b)) > eps) {
+    return false;
+  }
+  minX = Math.min(a.x, b.x) - eps;
+  maxX = Math.max(a.x, b.x) + eps;
+  minY = Math.min(a.y, b.y) - eps;
+  maxY = Math.max(a.y, b.y) + eps;
+  return p.x >= minX && p.x <= maxX && p.y >= minY && p.y <= maxY;
+};
+// Inclusive point-in-triangle test using orientations.
+// - Works for CW or CCW input (auto-detects orientation).
+// - Inclusive of edges/vertices.
+// - Handles degenerate triangles (point or segment) robustly.
+pointInTriangleInclusive2D = function(p, a, b, c, eps = TRIANGLE_2D_EPSILON) {
+  var o, s1, s2, s3;
+  o = triangleOrientation2D(a, b, c);
+  if (o > eps) {
+    s1 = triangleOrientation2D(p, a, b);
+    s2 = triangleOrientation2D(p, b, c);
+    s3 = triangleOrientation2D(p, c, a);
+    return (s1 >= -eps) && (s2 >= -eps) && (s3 >= -eps);
+  } else if (o < -eps) {
+    s1 = triangleOrientation2D(p, a, b);
+    s2 = triangleOrientation2D(p, b, c);
+    s3 = triangleOrientation2D(p, c, a);
+    return (s1 <= eps) && (s2 <= eps) && (s3 <= eps);
+  } else {
+    // Degenerate triangle: either a point (all equal) or a segment (collinear).
+    if (pointsEqual2D(a, b, eps) && pointsEqual2D(b, c, eps)) {
+      return pointsEqual2D(p, a, eps);
+    }
+    // Reduce to the non-degenerate segment and test inclusively.
+    if (pointsEqual2D(a, b, eps)) {
+      return pointOnSegmentInclusive2D(p, b, c, eps);
+    }
+    if (pointsEqual2D(b, c, eps)) {
+      return pointOnSegmentInclusive2D(p, a, b, eps);
+    }
+    if (pointsEqual2D(c, a, eps)) {
+      return pointOnSegmentInclusive2D(p, a, b, eps);
+    }
+    // All three distinct but collinear: test against hull segments.
+    return pointOnSegmentInclusive2D(p, a, b, eps) || pointOnSegmentInclusive2D(p, b, c, eps) || pointOnSegmentInclusive2D(p, c, a, eps);
+  }
+};
+triangleIntersectsTriangle = function(triangleA, triangleB, additions = {
+    coplanar: false,
+    source: new Vector3(),
+    target: new Vector3()
+  }) {
+  var distanceVertex1A, distanceVertex1B, distanceVertex2A, distanceVertex2B, distanceVertex3A, distanceVertex3B, normal1, normal2, vertex1TriangleA, vertex1TriangleB, vertex2TriangleA, vertex2TriangleB, vertex3TriangleA, vertex3TriangleB;
+  // Extract vertices of triangle A.
+  vertex1TriangleA = triangleA.a;
+  vertex2TriangleA = triangleA.b;
+  vertex3TriangleA = triangleA.c;
+  // Extract vertices of triangle B.
+  vertex1TriangleB = triangleB.a;
+  vertex2TriangleB = triangleB.b;
+  vertex3TriangleB = triangleB.c;
+  // Step 1: Compute signed distances of Triangle A’s vertices relative to the plane defined by Triangle B.
+  temporaryVector3Primary.copy(vertex1TriangleB).sub(vertex3TriangleB);
+  temporaryVector3Secondary.copy(vertex2TriangleB).sub(vertex3TriangleB);
+  normal2 = (new Vector3()).copy(temporaryVector3Primary).cross(temporaryVector3Secondary);
+  temporaryVector3Primary.copy(vertex1TriangleA).sub(vertex3TriangleB);
+  distanceVertex1A = temporaryVector3Primary.dot(normal2);
+  temporaryVector3Primary.copy(vertex2TriangleA).sub(vertex3TriangleB);
+  distanceVertex2A = temporaryVector3Primary.dot(normal2);
+  temporaryVector3Primary.copy(vertex3TriangleA).sub(vertex3TriangleB);
+  distanceVertex3A = temporaryVector3Primary.dot(normal2);
+  if (((distanceVertex1A * distanceVertex2A) > 0) && ((distanceVertex1A * distanceVertex3A) > 0)) {
+    return false; // All vertices of Triangle A are on the same side of Triangle B’s plane.
+  }
+  
+  // Step 2: Compute signed distances of Triangle B’s vertices relative to the plane defined by Triangle A.
+  temporaryVector3Primary.copy(vertex2TriangleA).sub(vertex1TriangleA);
+  temporaryVector3Secondary.copy(vertex3TriangleA).sub(vertex1TriangleA);
+  normal1 = (new Vector3()).copy(temporaryVector3Primary).cross(temporaryVector3Secondary);
+  temporaryVector3Primary.copy(vertex1TriangleB).sub(vertex3TriangleA);
+  distanceVertex1B = temporaryVector3Primary.dot(normal1);
+  temporaryVector3Primary.copy(vertex2TriangleB).sub(vertex3TriangleA);
+  distanceVertex2B = temporaryVector3Primary.dot(normal1);
+  temporaryVector3Primary.copy(vertex3TriangleB).sub(vertex3TriangleA);
+  distanceVertex3B = temporaryVector3Primary.dot(normal1);
+  if (((distanceVertex1B * distanceVertex2B) > 0) && ((distanceVertex1B * distanceVertex3B) > 0)) {
+    return false; // All vertices of Triangle B are on the same side of Triangle A’s plane.
+  }
+  
+  // Step 3: At this point, neither triangle is fully on one side of the other’s plane. This means the triangles potentially intersect.
+  // Next, we use the vertex signed distances to decide which configuration applies and call `resolveTriangleIntersection` (or `resolveCoplanarTriangleIntersection` if the triangles are coplanar).
+  additions.normal1 = normal1;
+  additions.normal2 = normal2;
+  // Decide how to proceed by looking at the signs of distanceVertex1A, distanceVertex2A and distanceVertex3A.
+  // These numbers tell us whether each vertex of Triangle A sits above the flat surface of Triangle B (positive), below it (negative), or exactly on it (zero).
+  // We then pass the vertices to the resolver in a stable order: the single “different-side” vertex first, followed by the two vertices that are on the same side.
+  if (distanceVertex1A > 0) {
+    // If distanceVertex1A is positive (the first vertex of Triangle A is above Triangle B's surface):
+    if (distanceVertex2A > 0) {
+      // Then distanceVertex2A is also positive, while distanceVertex3A is zero or negative.
+      // In plain terms: the third vertex of Triangle A lies on the other side of Triangle B’s surface (or exactly on it).
+      return resolveTriangleIntersection(vertex3TriangleA, vertex1TriangleA, vertex2TriangleA, vertex1TriangleB, vertex3TriangleB, vertex2TriangleB, distanceVertex1B, distanceVertex3B, distanceVertex2B, additions);
+    } else if (distanceVertex3A > 0) {
+      // Then distanceVertex3A is positive, while distanceVertex2A is zero or negative.
+      // That means the second vertex of Triangle A is the one on the other side (or exactly on the surface).
+      return resolveTriangleIntersection(vertex2TriangleA, vertex3TriangleA, vertex1TriangleA, vertex1TriangleB, vertex3TriangleB, vertex2TriangleB, distanceVertex1B, distanceVertex3B, distanceVertex2B, additions);
+    } else {
+      // Here only the first vertex is above the surface; the second and third are on or below it.
+      return resolveTriangleIntersection(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, distanceVertex1B, distanceVertex2B, distanceVertex3B, additions);
+    }
+  } else if (distanceVertex1A < 0) {
+    // If distanceVertex1A is negative (the first vertex of Triangle A is below Triangle B's surface):
+    if (distanceVertex2A < 0) {
+      // Then distanceVertex2A is also negative, while distanceVertex3A is zero or positive.
+      // In other words: the third vertex of Triangle A is on the other side (or exactly on the surface).
+      return resolveTriangleIntersection(vertex3TriangleA, vertex1TriangleA, vertex2TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, distanceVertex1B, distanceVertex2B, distanceVertex3B, additions);
+    } else if (distanceVertex3A < 0) {
+      // Then distanceVertex3A is negative, while distanceVertex2A is zero or positive.
+      // So the second vertex is the one on the other side (or exactly on the surface).
+      return resolveTriangleIntersection(vertex2TriangleA, vertex3TriangleA, vertex1TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, distanceVertex1B, distanceVertex2B, distanceVertex3B, additions);
+    } else {
+      // Only the first vertex is below the surface; the second and third are on or above it.
+      // Note: We also swap the order of Triangle B’s vertices here to keep a consistent “one different, two the same” pattern for the resolver.
+      return resolveTriangleIntersection(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex3TriangleB, vertex2TriangleB, distanceVertex1B, distanceVertex3B, distanceVertex2B, additions);
+    }
+  } else {
+    // Then the first vertex of Triangle A lies exactly on Triangle B’s surface (distanceVertex1A is zero).
+    // We look at distanceVertex2A and distanceVertex3A to decide which side the other vertices are on.
+    if (distanceVertex2A < 0) {
+      if (distanceVertex3A >= 0) {
+        // The second vertex is below the surface, while the third is on or above it.
+        return resolveTriangleIntersection(vertex2TriangleA, vertex3TriangleA, vertex1TriangleA, vertex1TriangleB, vertex3TriangleB, vertex2TriangleB, distanceVertex1B, distanceVertex3B, distanceVertex2B, additions);
+      } else {
+        // Both the second and third vertices are below the surface.
+        return resolveTriangleIntersection(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, distanceVertex1B, distanceVertex2B, distanceVertex3B, additions);
+      }
+    } else if (distanceVertex2A > 0) {
+      if (distanceVertex3A > 0) {
+        // Both the second and third vertices are above the surface.
+        return resolveTriangleIntersection(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex3TriangleB, vertex2TriangleB, distanceVertex1B, distanceVertex3B, distanceVertex2B, additions);
+      } else {
+        // The second vertex is above the surface, while the third is on or below it.
+        return resolveTriangleIntersection(vertex2TriangleA, vertex3TriangleA, vertex1TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, distanceVertex1B, distanceVertex2B, distanceVertex3B, additions);
+      }
+    } else {
+      if (distanceVertex3A > 0) {
+        // The second vertex is exactly on the surface, and the third is above it.
+        return resolveTriangleIntersection(vertex3TriangleA, vertex1TriangleA, vertex2TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, distanceVertex1B, distanceVertex2B, distanceVertex3B, additions);
+      } else if (distanceVertex3A < 0) {
+        // The second vertex is exactly on the surface, and the third is below it.
+        return resolveTriangleIntersection(vertex3TriangleA, vertex1TriangleA, vertex2TriangleA, vertex1TriangleB, vertex3TriangleB, vertex2TriangleB, distanceVertex1B, distanceVertex3B, distanceVertex2B, additions);
+      } else {
+        additions.coplanar = true; // All three vertices of Triangle A lie in Triangle B's plane.
+        return resolveCoplanarTriangleIntersection(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, normal1, normal2);
+      }
+    }
+  }
+};
+resolveTriangleIntersection = function(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, distanceVertex1B, distanceVertex2B, distanceVertex3B, additions) {
+  // Early exit → If all B's distances are strictly positive (totally outside/above) or negative (totally outside/below), there's no intersection.
+  if ((distanceVertex1B > 0 && distanceVertex2B > 0 && distanceVertex3B > 0) || (distanceVertex1B < 0 && distanceVertex2B < 0 && distanceVertex3B < 0)) {
+    return false;
+  }
+  if (distanceVertex1B > 0) { // First vertex of Triangle B is above (positive side of) Triangle A's plane.
+    if (distanceVertex2B > 0) { // First two vertices of B are positive, third is zero or negative.
+      return constructIntersection(vertex1TriangleA, vertex3TriangleA, vertex2TriangleA, vertex3TriangleB, vertex1TriangleB, vertex2TriangleB, additions); // Reorder B as (C, A, B) so differing vertex is last.
+    } else if (distanceVertex3B > 0) { // First and third vertices of B are positive, second is zero or negative.
+      return constructIntersection(vertex1TriangleA, vertex3TriangleA, vertex2TriangleA, vertex2TriangleB, vertex3TriangleB, vertex1TriangleB, additions); // Reorder B as (B, C, A).
+// Only first vertex of B is positive.
+    } else {
+      return constructIntersection(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, additions); // Pass original B ordering.
+    }
+  } else if (distanceVertex1B < 0) { // First vertex of Triangle B is below (negative side of) Triangle A's plane.
+    if (distanceVertex2B < 0) { // First two vertices of B are negative, third is zero or positive.
+      return constructIntersection(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex3TriangleB, vertex1TriangleB, vertex2TriangleB, additions); // Reorder B as (C, A, B) so differing vertex is last.
+    } else if (distanceVertex3B < 0) { // First and third vertices of B are negative, second is zero or positive.
+      return constructIntersection(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex2TriangleB, vertex3TriangleB, vertex1TriangleB, additions); // Reorder B as (B, C, A).
+// Only first vertex of B is negative.
+    } else {
+      return constructIntersection(vertex1TriangleA, vertex3TriangleA, vertex2TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, additions); // Pass A, reordered B.
+  // First vertex of Triangle B is exactly on the plane (distance zero).
+    }
+  } else {
+    if (distanceVertex2B < 0) { // Second vertex is negative, third will decide.
+      if (distanceVertex3B >= 0) { // Second negative, third zero or positive.
+        return constructIntersection(vertex1TriangleA, vertex3TriangleA, vertex2TriangleA, vertex2TriangleB, vertex3TriangleB, vertex1TriangleB, additions); // Mixed across the plane.
+// Second & third negative.
+      } else {
+        return constructIntersection(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, additions); // Only first on the plane.
+      }
+    } else if (distanceVertex2B > 0) { // Second vertex is positive.
+      if (distanceVertex3B > 0) { // Both second and third are positive.
+        return constructIntersection(vertex1TriangleA, vertex3TriangleA, vertex2TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, additions); // Both above the plane.
+// Second positive, third zero or negative.
+      } else {
+        return constructIntersection(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex2TriangleB, vertex3TriangleB, vertex1TriangleB, additions); // Mixed, split across plane.
+    // Second vertex is exactly on the plane (zero).
+      }
+    } else {
+      if (distanceVertex3B > 0) { // Only third is positive.
+        return constructIntersection(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex3TriangleB, vertex1TriangleB, vertex2TriangleB, additions); // Third above, first/second on plane.
+      } else if (distanceVertex3B < 0) { // Only third is negative.
+        return constructIntersection(vertex1TriangleA, vertex3TriangleA, vertex2TriangleA, vertex3TriangleB, vertex1TriangleB, vertex2TriangleB, additions); // Third below plane.
+// All three B vertices are exactly on the plane (coplanar).
+      } else {
+        additions.coplanar = true; // Mark coplanar.
+        return resolveCoplanarTriangleIntersection(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, additions.normal1, additions.normal2);
+      }
+    }
+  }
+};
+resolveCoplanarTriangleIntersection = function(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, normalTriangleA, normalTriangleB) {
+  var normalAbsX, normalAbsY, normalAbsZ, vertex1TriangleA2D, vertex1TriangleB2D, vertex2TriangleA2D, vertex2TriangleB2D, vertex3TriangleA2D, vertex3TriangleB2D;
+  // Prepare 2D projected vertices.
+  vertex1TriangleA2D = new Vector2();
+  vertex2TriangleA2D = new Vector2();
+  vertex3TriangleA2D = new Vector2();
+  vertex1TriangleB2D = new Vector2();
+  vertex2TriangleB2D = new Vector2();
+  vertex3TriangleB2D = new Vector2();
+  // Absolute values of the triangle's normal components.
+  // Used to determine the dominant axis, which we drop during 2D projection.
+  normalAbsX = Math.abs(normalTriangleA.x);
+  normalAbsY = Math.abs(normalTriangleA.y);
+  normalAbsZ = Math.abs(normalTriangleA.z);
+  // Project triangles into 2D by dropping the dominant axis of the normal.
+  if ((normalAbsX > normalAbsZ) && (normalAbsX >= normalAbsY)) { // Project onto YZ plane.
+    vertex1TriangleA2D.set(vertex1TriangleA.y, vertex1TriangleA.z);
+    vertex2TriangleA2D.set(vertex2TriangleA.y, vertex2TriangleA.z);
+    vertex3TriangleA2D.set(vertex3TriangleA.y, vertex3TriangleA.z);
+    vertex1TriangleB2D.set(vertex1TriangleB.y, vertex1TriangleB.z);
+    vertex2TriangleB2D.set(vertex2TriangleB.y, vertex2TriangleB.z);
+    vertex3TriangleB2D.set(vertex3TriangleB.y, vertex3TriangleB.z);
+  } else if ((normalAbsY > normalAbsZ) && (normalAbsY >= normalAbsX)) { // Project onto XZ plane.
+    vertex1TriangleA2D.set(vertex1TriangleA.x, vertex1TriangleA.z);
+    vertex2TriangleA2D.set(vertex2TriangleA.x, vertex2TriangleA.z);
+    vertex3TriangleA2D.set(vertex3TriangleA.x, vertex3TriangleA.z);
+    vertex1TriangleB2D.set(vertex1TriangleB.x, vertex1TriangleB.z);
+    vertex2TriangleB2D.set(vertex2TriangleB.x, vertex2TriangleB.z);
+    vertex3TriangleB2D.set(vertex3TriangleB.x, vertex3TriangleB.z); // Project onto XY plane
+  } else {
+    vertex1TriangleA2D.set(vertex1TriangleA.x, vertex1TriangleA.y);
+    vertex2TriangleA2D.set(vertex2TriangleA.x, vertex2TriangleA.y);
+    vertex3TriangleA2D.set(vertex3TriangleA.x, vertex3TriangleA.y);
+    vertex1TriangleB2D.set(vertex1TriangleB.x, vertex1TriangleB.y);
+    vertex2TriangleB2D.set(vertex2TriangleB.x, vertex2TriangleB.y);
+    vertex3TriangleB2D.set(vertex3TriangleB.x, vertex3TriangleB.y);
+  }
+  return trianglesOverlap2D(vertex1TriangleA2D, vertex2TriangleA2D, vertex3TriangleA2D, vertex1TriangleB2D, vertex2TriangleB2D, vertex3TriangleB2D);
+};
+trianglesOverlap2D = function(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB) {
+  var aE, aMax, aMin, aS, bE, bMax, bMin, bS, extractSegment, isLineDegenerate, maxAx, maxAy, maxBx, maxBy, minAx, minAy, minBx, minBy, spanAx, spanAy;
+  // Early handle point-degenerate cases explicitly and efficiently.
+  if (pointsEqual2D(vertex1TriangleB, vertex2TriangleB, TRIANGLE_2D_EPSILON) && pointsEqual2D(vertex2TriangleB, vertex3TriangleB, TRIANGLE_2D_EPSILON)) {
+    return pointInTriangleInclusive2D(vertex1TriangleB, vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, TRIANGLE_2D_EPSILON);
+  }
+  if (pointsEqual2D(vertex1TriangleA, vertex2TriangleA, TRIANGLE_2D_EPSILON) && pointsEqual2D(vertex2TriangleA, vertex3TriangleA, TRIANGLE_2D_EPSILON)) {
+    return pointInTriangleInclusive2D(vertex1TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, TRIANGLE_2D_EPSILON);
+  }
+  // If both are line-degenerate (not points): reduce to segment overlap test.
+  isLineDegenerate = function(v1, v2, v3) {
+    return (pointsEqual2D(v1, v2, TRIANGLE_2D_EPSILON) && !pointsEqual2D(v2, v3, TRIANGLE_2D_EPSILON)) || (pointsEqual2D(v2, v3, TRIANGLE_2D_EPSILON) && !pointsEqual2D(v1, v2, TRIANGLE_2D_EPSILON)) || (pointsEqual2D(v3, v1, TRIANGLE_2D_EPSILON) && !pointsEqual2D(v1, v2, TRIANGLE_2D_EPSILON));
+  };
+  extractSegment = function(v1, v2, v3) {
+    // Return the two distinct endpoints in stable order.
+    if (pointsEqual2D(v1, v2, TRIANGLE_2D_EPSILON)) {
+      return [v2, v3];
+    } else if (pointsEqual2D(v2, v3, TRIANGLE_2D_EPSILON)) {
+      return [v1, v2];
+    } else {
+      return [
+        v1,
+        v2 // fallback (should not reach if collinear case handled earlier)
+      ];
+    }
+  };
+  if (isLineDegenerate(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA) && isLineDegenerate(vertex1TriangleB, vertex2TriangleB, vertex3TriangleB)) {
+    [aS, aE] = extractSegment(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA);
+    [bS, bE] = extractSegment(vertex1TriangleB, vertex2TriangleB, vertex3TriangleB);
+    // Fast reject by axis-aligned bounding boxes.
+    minAx = Math.min(aS.x, aE.x);
+    maxAx = Math.max(aS.x, aE.x);
+    minAy = Math.min(aS.y, aE.y);
+    maxAy = Math.max(aS.y, aE.y);
+    minBx = Math.min(bS.x, bE.x);
+    maxBx = Math.max(bS.x, bE.x);
+    minBy = Math.min(bS.y, bE.y);
+    maxBy = Math.max(bS.y, bE.y);
+    if (maxAx < minBx - TRIANGLE_2D_EPSILON || maxBx < minAx - TRIANGLE_2D_EPSILON || maxAy < minBy - TRIANGLE_2D_EPSILON || maxBy < minAy - TRIANGLE_2D_EPSILON) {
+      return false;
+    }
+    // Collinear check: orientation of any mixed triple should be ~0; since we know each triangle is a line, test one.
+    if (Math.abs(triangleOrientation2D(aS, aE, bS)) > TRIANGLE_2D_EPSILON) {
+      return false;
+    }
+    // 1D overlap test along dominant axis (choose axis with larger span to reduce precision issues).
+    spanAx = Math.abs(aE.x - aS.x);
+    spanAy = Math.abs(aE.y - aS.y);
+    if (spanAx >= spanAy) {
+      // Project onto X.
+      aMin = Math.min(aS.x, aE.x) - TRIANGLE_2D_EPSILON;
+      aMax = Math.max(aS.x, aE.x) + TRIANGLE_2D_EPSILON;
+      bMin = Math.min(bS.x, bE.x) - TRIANGLE_2D_EPSILON;
+      bMax = Math.max(bS.x, bE.x) + TRIANGLE_2D_EPSILON;
+      return !(aMax < bMin || bMax < aMin);
+    } else {
+      aMin = Math.min(aS.y, aE.y) - TRIANGLE_2D_EPSILON;
+      aMax = Math.max(aS.y, aE.y) + TRIANGLE_2D_EPSILON;
+      bMin = Math.min(bS.y, bE.y) - TRIANGLE_2D_EPSILON;
+      bMax = Math.max(bS.y, bE.y) + TRIANGLE_2D_EPSILON;
+      return !(aMax < bMin || bMax < aMin);
+    }
+  }
+  if (triangleOrientation2D(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA) < 0) { // If triangle A is CW.
+    if (triangleOrientation2D(vertex1TriangleB, vertex2TriangleB, vertex3TriangleB) < 0) { // If both A and B are CW → reorder both.
+      return triangleIntersectionCCW2D(vertex1TriangleA, vertex3TriangleA, vertex2TriangleA, vertex1TriangleB, vertex3TriangleB, vertex2TriangleB); // Only A is CW → reorder A.
+    } else {
+      return triangleIntersectionCCW2D(vertex1TriangleA, vertex3TriangleA, vertex2TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB); // Triangle A is CCW.
+    }
+  } else {
+    if (triangleOrientation2D(vertex1TriangleB, vertex2TriangleB, vertex3TriangleB) < 0) { // If only B is CW → reorder B.
+      return triangleIntersectionCCW2D(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex3TriangleB, vertex2TriangleB); // Both A and B are CCW → no reordering.
+    } else {
+      return triangleIntersectionCCW2D(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB);
+    }
+  }
+};
+triangleOrientation2D = function(a, b, c) {
+  // Compute the signed area of the triangle (a, b, c).
+  return (a.x - c.x) * (b.y - c.y) - (a.y - c.y) * (b.x - c.x);
+};
+triangleIntersectionCCW2D = function(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB) {
+  // If vertex1TriangleB is on or to the left of edge vertex1TriangleA-vertex2TriangleA-vertex3TriangleA.
+  if (triangleOrientation2D(vertex1TriangleB, vertex2TriangleB, vertex1TriangleA) >= 0) {
+    // If vertex2TriangleB is on or to the left of edge vertex2TriangleA-vertex3TriangleA-vertex1TriangleA.
+    if (triangleOrientation2D(vertex2TriangleB, vertex3TriangleB, vertex1TriangleA) >= 0) {
+      // If vertex3TriangleB is on or to the left of edge vertex3TriangleA-vertex1TriangleA-vertex1TriangleA.
+      if (triangleOrientation2D(vertex3TriangleB, vertex1TriangleB, vertex1TriangleA) >= 0) {
+        return true; // All vertices of B are inside A.
+// Then vertex3TriangleB is outside, test edge intersection.
+      } else {
+        return intersectionTestEdge2D(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB); // Then vertex2TriangleB is outside.
+      }
+    } else {
+      
+      // If vertex3TriangleB is on or to the left of edge vertex3TriangleA-vertex1TriangleA-vertex1TriangleA, test edge intersection.
+      if (triangleOrientation2D(vertex3TriangleB, vertex1TriangleB, vertex1TriangleA) >= 0) {
+        return intersectionTestEdge2D(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex3TriangleB, vertex1TriangleB, vertex2TriangleB); // Then both vertex2TriangleB and vertex3TriangleB are outside, test vertex intersection.
+      } else {
+        return intersectionTestVertex2D(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB); // Then vertex2TriangleB is on or to the left of edge vertex2TriangleA-vertex3TriangleA-vertex1TriangleA.
+      }
+    }
+  } else {
+    
+    // If vertex2TriangleB is on or to the left of edge vertex2TriangleA-vertex3TriangleA-vertex1TriangleA.
+    if (triangleOrientation2D(vertex2TriangleB, vertex3TriangleB, vertex1TriangleA) >= 0) {
+      // If vertex3TriangleB is on or to the left of edge vertex3TriangleA-vertex1TriangleA-vertex1TriangleA, test edge intersection.
+      if (triangleOrientation2D(vertex3TriangleB, vertex1TriangleB, vertex1TriangleA) >= 0) {
+        return intersectionTestEdge2D(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex2TriangleB, vertex3TriangleB, vertex1TriangleB); // Then vertex3TriangleB is outside, test vertex intersection.
+      } else {
+        return intersectionTestVertex2D(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex2TriangleB, vertex3TriangleB, vertex1TriangleB); // Then both vertex1TriangleB and vertex2TriangleB are outside, test vertex intersection.
+      }
+    } else {
+      return intersectionTestVertex2D(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex3TriangleB, vertex1TriangleB, vertex2TriangleB);
+    }
+  }
+};
+intersectionTestEdge2D = function(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB) {
+  var a1, a2, b1, b2, edgesA, edgesB, i, j, len, len1, segmentIntersectsInclusive;
+  segmentIntersectsInclusive = function(a1, a2, b1, b2) {
+    var maxAx, maxAy, maxBx, maxBy, minAx, minAy, minBx, minBy, o1, o2, o3, o4;
+    // Fast reject by bounding boxes.
+    minAx = Math.min(a1.x, a2.x);
+    maxAx = Math.max(a1.x, a2.x);
+    minAy = Math.min(a1.y, a2.y);
+    maxAy = Math.max(a1.y, a2.y);
+    minBx = Math.min(b1.x, b2.x);
+    maxBx = Math.max(b1.x, b2.x);
+    minBy = Math.min(b1.y, b2.y);
+    maxBy = Math.max(b1.y, b2.y);
+    if (maxAx < minBx || maxBx < minAx || maxAy < minBy || maxBy < minAy) {
+      return false;
+    }
+    o1 = triangleOrientation2D(a1, a2, b1);
+    o2 = triangleOrientation2D(a1, a2, b2);
+    o3 = triangleOrientation2D(b1, b2, a1);
+    o4 = triangleOrientation2D(b1, b2, a2);
+    if ((o1 > 0 && o2 < 0 || o1 < 0 && o2 > 0) && (o3 > 0 && o4 < 0 || o3 < 0 && o4 > 0)) {
+      return true; // Proper intersection.
+    }
+    
+    // Collinear / endpoint inclusion checks.
+    if (Math.abs(o1) <= TRIANGLE_2D_EPSILON && pointOnSegmentInclusive2D(b1, a1, a2, TRIANGLE_2D_EPSILON)) {
+      return true;
+    }
+    if (Math.abs(o2) <= TRIANGLE_2D_EPSILON && pointOnSegmentInclusive2D(b2, a1, a2, TRIANGLE_2D_EPSILON)) {
+      return true;
+    }
+    if (Math.abs(o3) <= TRIANGLE_2D_EPSILON && pointOnSegmentInclusive2D(a1, b1, b2, TRIANGLE_2D_EPSILON)) {
+      return true;
+    }
+    if (Math.abs(o4) <= TRIANGLE_2D_EPSILON && pointOnSegmentInclusive2D(a2, b1, b2, TRIANGLE_2D_EPSILON)) {
+      return true;
+    }
+    return false;
+  };
+  edgesA = [[vertex1TriangleA, vertex2TriangleA], [vertex2TriangleA, vertex3TriangleA], [vertex3TriangleA, vertex1TriangleA]];
+  edgesB = [[vertex1TriangleB, vertex2TriangleB], [vertex2TriangleB, vertex3TriangleB], [vertex3TriangleB, vertex1TriangleB]];
+  for (i = 0, len = edgesA.length; i < len; i++) {
+    [a1, a2] = edgesA[i];
+    for (j = 0, len1 = edgesB.length; j < len1; j++) {
+      [b1, b2] = edgesB[j];
+      if (segmentIntersectsInclusive(a1, a2, b1, b2)) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+intersectionTestVertex2D = function(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB) {
+  if (pointInTriangleInclusive2D(vertex1TriangleB, vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, TRIANGLE_2D_EPSILON)) {
+    // Returns true if any vertex of triangle B lies inside (or on) triangle A OR any vertex of triangle A lies inside (or on) triangle B.
+    return true;
+  }
+  if (pointInTriangleInclusive2D(vertex2TriangleB, vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, TRIANGLE_2D_EPSILON)) {
+    return true;
+  }
+  if (pointInTriangleInclusive2D(vertex3TriangleB, vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, TRIANGLE_2D_EPSILON)) {
+    return true;
+  }
+  if (pointInTriangleInclusive2D(vertex1TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, TRIANGLE_2D_EPSILON)) {
+    return true;
+  }
+  if (pointInTriangleInclusive2D(vertex2TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, TRIANGLE_2D_EPSILON)) {
+    return true;
+  }
+  if (pointInTriangleInclusive2D(vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, TRIANGLE_2D_EPSILON)) {
+    return true;
+  }
+  return false;
+};
+constructIntersection = function(vertex1TriangleA, vertex2TriangleA, vertex3TriangleA, vertex1TriangleB, vertex2TriangleB, vertex3TriangleB, additions) {
+  var alpha, crossNormal;
+  alpha = void 0;
+  crossNormal = new Vector3();
+  // Compute cross product for triangle orientation.
+  temporaryVector3Primary.subVectors(vertex2TriangleA, vertex1TriangleA);
+  temporaryVector3Secondary.subVectors(vertex3TriangleB, vertex1TriangleA);
+  crossNormal.copy(temporaryVector3Primary).cross(temporaryVector3Secondary);
+  temporaryVector3Quaternary.subVectors(vertex1TriangleB, vertex1TriangleA);
+  if (temporaryVector3Quaternary.dot(crossNormal) > 0) {
+    // Check orientation with triangle A's third vertex.
+    temporaryVector3Primary.subVectors(vertex3TriangleA, vertex1TriangleA);
+    crossNormal.copy(temporaryVector3Primary).cross(temporaryVector3Secondary);
+    if (temporaryVector3Quaternary.dot(crossNormal) <= 0) {
+      // Check orientation with triangle B's second vertex.
+      temporaryVector3Secondary.subVectors(vertex2TriangleB, vertex1TriangleA);
+      crossNormal.copy(temporaryVector3Primary).cross(temporaryVector3Secondary);
+      if (temporaryVector3Quaternary.dot(crossNormal) > 0) {
+        // Compute intersection segment endpoints (case 1).
+        temporaryVector3Primary.subVectors(vertex1TriangleA, vertex1TriangleB);
+        temporaryVector3Secondary.subVectors(vertex1TriangleA, vertex3TriangleA);
+        alpha = temporaryVector3Primary.dot(additions.normal2) / temporaryVector3Secondary.dot(additions.normal2);
+        if (!isFinite(alpha)) {
+          return false;
+        }
+        temporaryVector3Primary.copy(temporaryVector3Secondary).multiplyScalar(alpha);
+        additions.source.subVectors(vertex1TriangleA, temporaryVector3Primary);
+        temporaryVector3Primary.subVectors(vertex1TriangleB, vertex1TriangleA);
+        temporaryVector3Secondary.subVectors(vertex1TriangleB, vertex3TriangleB);
+        alpha = temporaryVector3Primary.dot(additions.normal1) / temporaryVector3Secondary.dot(additions.normal1);
+        if (!isFinite(alpha)) {
+          return false;
+        }
+        temporaryVector3Primary.copy(temporaryVector3Secondary).multiplyScalar(alpha);
+        additions.target.subVectors(vertex1TriangleB, temporaryVector3Primary);
+        return true;
+      } else {
+        // Compute intersection segment endpoints (case 2).
+        temporaryVector3Primary.subVectors(vertex1TriangleB, vertex1TriangleA);
+        temporaryVector3Secondary.subVectors(vertex1TriangleB, vertex2TriangleB);
+        alpha = temporaryVector3Primary.dot(additions.normal1) / temporaryVector3Secondary.dot(additions.normal1);
+        if (!isFinite(alpha)) {
+          return false;
+        }
+        temporaryVector3Primary.copy(temporaryVector3Secondary).multiplyScalar(alpha);
+        additions.source.subVectors(vertex1TriangleB, temporaryVector3Primary);
+        temporaryVector3Primary.subVectors(vertex1TriangleB, vertex1TriangleA);
+        temporaryVector3Secondary.subVectors(vertex1TriangleB, vertex3TriangleB);
+        alpha = temporaryVector3Primary.dot(additions.normal1) / temporaryVector3Secondary.dot(additions.normal1);
+        if (!isFinite(alpha)) {
+          return false;
+        }
+        temporaryVector3Primary.copy(temporaryVector3Secondary).multiplyScalar(alpha);
+        additions.target.subVectors(vertex1TriangleB, temporaryVector3Primary);
+        return true;
+      }
+    } else {
+      return false; // No intersection, orientation test failed.
+    }
+  } else {
+    temporaryVector3Secondary.subVectors(vertex2TriangleB, vertex1TriangleA);
+    crossNormal.copy(temporaryVector3Primary).cross(temporaryVector3Secondary);
+    if (temporaryVector3Quaternary.dot(crossNormal) < 0) {
+      return false; // No intersection, orientation test failed.
+    } else {
+      temporaryVector3Primary.subVectors(vertex3TriangleA, vertex1TriangleA);
+      crossNormal.copy(temporaryVector3Primary).cross(temporaryVector3Secondary);
+      if (temporaryVector3Quaternary.dot(crossNormal) < 0) {
+        // Compute intersection segment endpoints (case 3).
+        temporaryVector3Primary.subVectors(vertex1TriangleB, vertex1TriangleA);
+        temporaryVector3Secondary.subVectors(vertex1TriangleB, vertex2TriangleB);
+        alpha = temporaryVector3Primary.dot(additions.normal1) / temporaryVector3Secondary.dot(additions.normal1);
+        if (!isFinite(alpha)) {
+          return false;
+        }
+        temporaryVector3Primary.copy(temporaryVector3Secondary).multiplyScalar(alpha);
+        additions.source.subVectors(vertex1TriangleB, temporaryVector3Primary);
+        temporaryVector3Primary.subVectors(vertex1TriangleB, vertex1TriangleA);
+        temporaryVector3Secondary.subVectors(vertex1TriangleB, vertex3TriangleB);
+        alpha = temporaryVector3Primary.dot(additions.normal1) / temporaryVector3Secondary.dot(additions.normal1);
+        if (!isFinite(alpha)) {
+          return false;
+        }
+        temporaryVector3Primary.copy(temporaryVector3Secondary).multiplyScalar(alpha);
+        additions.target.subVectors(vertex1TriangleB, temporaryVector3Primary);
+        return true;
+      } else {
+        // Compute intersection segment endpoints (case 4).
+        temporaryVector3Primary.subVectors(vertex1TriangleA, vertex1TriangleB);
+        temporaryVector3Secondary.subVectors(vertex1TriangleA, vertex3TriangleA);
+        alpha = temporaryVector3Primary.dot(additions.normal2) / temporaryVector3Secondary.dot(additions.normal2);
+        if (!isFinite(alpha)) {
+          return false;
+        }
+        temporaryVector3Primary.copy(temporaryVector3Secondary).multiplyScalar(alpha);
+        additions.source.subVectors(vertex1TriangleA, temporaryVector3Primary);
+        temporaryVector3Primary.subVectors(vertex1TriangleA, vertex1TriangleB);
+        temporaryVector3Secondary.subVectors(vertex1TriangleA, vertex2TriangleA);
+        alpha = temporaryVector3Primary.dot(additions.normal2) / temporaryVector3Secondary.dot(additions.normal2);
+        if (!isFinite(alpha)) {
+          return false;
+        }
+        temporaryVector3Primary.copy(temporaryVector3Secondary).multiplyScalar(alpha);
+        additions.target.subVectors(vertex1TriangleA, temporaryVector3Primary);
+        return true;
+      }
+    }
+  }
+  return false; // If none of the above, no intersection found.
+};
+// Generated by CoffeeScript 2.7.0
+// Main class for representing vertices in 3D space with optional texture and color data.
+// Vertices are the fundamental building blocks for polygons and meshes in the geometry system.
+var Vertex;
+Vertex = class Vertex {
+  // Main constructor for creating vertex instances.
+  // Initializes position, normal, and optional texture/color attributes.
+  // @param pos - Three.js Vector3 representing the vertex position in 3D space.
+  // @param normal - Three.js Vector3 representing the surface normal at this vertex.
+  // @param uv - Optional Three.js Vector2 for texture coordinates.
+  // @param color - Optional Three.js Vector3 for vertex color information.
+  constructor(pos, normal, uv, color) {
+    // Core geometric properties.
+    this.pos = new Vector3().copy(pos); // 3D position coordinates.
+    this.normal = new Vector3().copy(normal); // Surface normal vector.
+    
+    // Optional texture and visual properties.
+    uv && (this.uv = new Vector2().copy(uv)); // Texture coordinates (UV mapping).
+    color && (this.color = new Vector3().copy(color)); // Vertex color data.
+  }
+  
+    // === OBJECT CREATION AND COPYING ===
+  clone() { // Create a deep copy of this vertex with all properties.
+    return new Vertex(this.pos.clone(), this.normal.clone(), this.uv && this.uv.clone(), this.color && this.color.clone());
+  }
+  // === GEOMETRIC TRANSFORMATIONS ===
+  flip() { // Flip the normal vector direction (invert surface orientation).
+    return this.normal.negate();
+  }
+  // Creates a new vertex interpolated between this vertex and another.
+  // All properties (position, normal, UV, color) are interpolated if present on both vertices.
+  // @param other - The target vertex to interpolate towards.
+  // @param interpolationFactor - Factor from 0.0 (this vertex) to 1.0 (other vertex).
+  // @return New interpolated Vertex instance.
+  interpolate(other, interpolationFactor) {
+    return new Vertex(this.pos.clone().lerp(other.pos, interpolationFactor), this.normal.clone().lerp(other.normal, interpolationFactor), this.uv && other.uv && this.uv.clone().lerp(other.uv, interpolationFactor), this.color && other.color && this.color.clone().lerp(other.color, interpolationFactor));
+  }
+  // === CLEANUP AND DISPOSAL METHODS ===
+    // Clean up vertex data by setting all properties to undefined.
+  // Used for memory management during intensive operations.
+  delete() {
+    this.pos = void 0;
+    this.normal = void 0;
+    this.uv && (this.uv = void 0);
+    return this.color && (this.color = void 0);
+  }
+};
+// Generated by CoffeeScript 2.7.0
+// === CORE GEOMETRY CLASSES ===
+// Primary geometric data structures for CSG operations.
+// === BUFFER UTILITIES ===
+// Efficient storage and writing of vector data for geometric calculations.
+// === TRIANGLE VALIDATION AND INTERSECTION ===
+// Core triangle operations including validation, uniqueness checking, and intersection testing.
+// === TRIANGLE INTERSECTION RESOLUTION ===
+// Advanced intersection resolution for both general and coplanar triangle cases.
+// === GEOMETRIC UTILITIES ===
+// Point manipulation, coordinate extraction, and spatial calculations.
+// === POLYGON OPERATIONS ===
+// Polygon splitting, buffer preparation, and CSG-related polygon management.
+// === WINDING NUMBER AND INSIDE/OUTSIDE TESTING ===
+// Robust point-in-polygon testing using winding number algorithms.
+// === RAY-TRIANGLE INTERSECTION ===
+// High-performance ray-triangle intersection testing for raycasting operations.
+// === POLYTREE RESOURCE MANAGEMENT ===
+// Memory management and cleanup utilities for Polytree operations.
+// === 2D TRIANGLE OPERATIONS ===
+// Specialized 2D triangle overlap and intersection testing for planar geometry.
+// === 2D INTERSECTION TESTING ===
+// Low-level 2D edge and vertex intersection tests for triangle operations.
+// === INTERSECTION CONSTRUCTION ===
+// Low-level intersection construction utilities for building intersection results.
+
+// ES module exports
+export default Polytree;
+export { GEOMETRIC_EPSILON as GEOMETRIC_EPSILON };
+export { RAY_INTERSECTION_EPSILON as RAY_INTERSECTION_EPSILON };
+export { TRIANGLE_2D_EPSILON as TRIANGLE_2D_EPSILON };
+export { WINDING_NUMBER_FULL_ROTATION as WINDING_NUMBER_FULL_ROTATION };
+export { POLYGON_COPLANAR as POLYGON_COPLANAR };
+export { POLYGON_FRONT as POLYGON_FRONT };
+export { POLYGON_BACK as POLYGON_BACK };
+export { POLYGON_SPANNING as POLYGON_SPANNING };
+export { temporaryVector3Primary as temporaryVector3Primary };
+export { temporaryVector3Secondary as temporaryVector3Secondary };
+export { temporaryVector3Tertiary as temporaryVector3Tertiary };
+export { temporaryVector3Quaternary as temporaryVector3Quaternary };
+export { temporaryBoundingBox as temporaryBoundingBox };
+export { temporaryRaycaster as temporaryRaycaster };
+export { temporaryRay as temporaryRay };
+export { defaultRayDirection as defaultRayDirection };
+export { windingNumberVector1 as windingNumberVector1 };
+export { windingNumberVector2 as windingNumberVector2 };
+export { windingNumberVector3 as windingNumberVector3 };
+export { windingNumberTestPoint as windingNumberTestPoint };
+export { windingNumberEpsilonOffsets as windingNumberEpsilonOffsets };
+export { windingNumberEpsilonOffsetsCount as windingNumberEpsilonOffsetsCount };
+export { windingNumberMatrix3 as windingNumberMatrix3 };
+export { rayTriangleEdge1 as rayTriangleEdge1 };
+export { rayTriangleEdge2 as rayTriangleEdge2 };
+export { rayTriangleHVector as rayTriangleHVector };
+export { rayTriangleSVector as rayTriangleSVector };
+export { rayTriangleQVector as rayTriangleQVector };
+export { temporaryTriangleVertex as temporaryTriangleVertex };
+export { temporaryTriangleVertexSecondary as temporaryTriangleVertexSecondary };
+export { temporaryMatrix3 as temporaryMatrix3 };
+export { temporaryMatrixWithNormalCalc as temporaryMatrixWithNormalCalc };
+export { meshOperationNormalVector as meshOperationNormalVector };
+export { meshOperationVertexVector as meshOperationVertexVector };
+export { POLYTREE_MAX_DEPTH as POLYTREE_MAX_DEPTH };
+export { POLYTREE_MAX_POLYGONS_PER_NODE as POLYTREE_MAX_POLYGONS_PER_NODE };
+export { POLYTREE_MIN_NODE_SIZE as POLYTREE_MIN_NODE_SIZE };
+export { DEFAULT_MATERIAL_INDEX as DEFAULT_MATERIAL_INDEX };
+export { MAX_REFINEMENT_ITERATIONS as MAX_REFINEMENT_ITERATIONS };
+export { DEFAULT_COORDINATE_PRECISION as DEFAULT_COORDINATE_PRECISION };
+export { POINT_COINCIDENCE_THRESHOLD as POINT_COINCIDENCE_THRESHOLD };
+export { DEFAULT_BUFFER_SIZE as DEFAULT_BUFFER_SIZE };
+export { MAX_WORKER_THREADS as MAX_WORKER_THREADS };
+export { ASYNC_OPERATION_TIMEOUT as ASYNC_OPERATION_TIMEOUT };
+export { GARBAGE_COLLECTION_THRESHOLD as GARBAGE_COLLECTION_THRESHOLD };
+export { MEMORY_USAGE_WARNING_LIMIT as MEMORY_USAGE_WARNING_LIMIT };
+export { GEOMETRY_CACHE_SIZE as GEOMETRY_CACHE_SIZE };
+export { INTERSECTION_CACHE_SIZE as INTERSECTION_CACHE_SIZE };
+export { polygonID as polygonID };
+export { DEBUG_VERBOSE_LOGGING as DEBUG_VERBOSE_LOGGING };
+export { DEBUG_PERFORMANCE_TIMING as DEBUG_PERFORMANCE_TIMING };
+export { DEBUG_GEOMETRY_VALIDATION as DEBUG_GEOMETRY_VALIDATION };
+export { DEBUG_INTERSECTION_VERIFICATION as DEBUG_INTERSECTION_VERIFICATION };
+export { DEBUG_COLOR_FRONT as DEBUG_COLOR_FRONT };
+export { DEBUG_COLOR_BACK as DEBUG_COLOR_BACK };
+export { DEBUG_COLOR_COPLANAR as DEBUG_COLOR_COPLANAR };
+export { DEBUG_COLOR_SPANNING as DEBUG_COLOR_SPANNING };
+export { Polytree as Polytree };
+export { Plane as Plane };
+export { Vertex as Vertex };
+export { Polygon as Polygon };
+export { createVector2Buffer as createVector2Buffer };
+export { createVector3Buffer as createVector3Buffer };
+export { isValidTriangle as isValidTriangle };
+export { isUniqueTriangle as isUniqueTriangle };
+export { testRayTriangleIntersection as rayIntersectsTriangle };
+export { triangleIntersectsTriangle as triangleIntersectsTriangle };
+export { resolveTriangleIntersection as resolveTriangleIntersection };
+export { resolveCoplanarTriangleIntersection as resolveCoplanarTriangleIntersection };
+export { sortRaycastIntersectionsByDistance as sortRaycastIntersectionsByDistance };
+export { roundPointCoordinates as roundPointCoordinates };
+export { extractCoordinatesFromArray as extractCoordinatesFromArray };
+export { splitPolygonByPlane as splitPolygonByPlane };
+export { splitPolygonVertexArray as splitPolygonVertexArray };
+export { prepareTriangleBufferFromPolygons as prepareTriangleBufferFromPolygons };
+export { calculateWindingNumberFromBuffer as calculateWindingNumberFromBuffer };
+export { testPolygonInsideUsingWindingNumber as testPolygonInsideUsingWindingNumber };
+export { testRayTriangleIntersection as testRayTriangleIntersection };
+export { handleIntersectingPolytrees as handleIntersectingPolytrees };
+export { disposePolytreeResources as disposePolytreeResources };
+export { trianglesOverlap2D as trianglesOverlap2D };
+export { triangleOrientation2D as triangleOrientation2D };
+export { triangleIntersectionCCW2D as triangleIntersectionCCW2D };
+export { intersectionTestEdge2D as intersectionTestEdge2D };
+export { intersectionTestVertex2D as intersectionTestVertex2D };
+export { constructIntersection as constructIntersection };