forgecad 0.10.3 → 0.10.4

package/dist/assets/{app-D6ccu2Xx.js → app-BsRYSfxY.js}

@@ -1,10 +1,10 @@
-const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/EditorApp-C5f24ZN9.css","assets/landing-proof-driven-ORyigZ6p.css","assets/BenchmarkPage-BAbsyMaF.css","assets/PricingPage-BPF6HKyO.css","assets/LegalPage-BRlScr9A.css"])))=>i.map(i=>d[i]);
+const __vite__mapDeps=(i,m=__vite__mapDeps,d=(m.f||(m.f=["assets/EditorApp-C5f24ZN9.css","assets/landing-proof-driven-Cpf-MIbI.css","assets/BenchmarkPage-BAbsyMaF.css","assets/PricingPage-BPF6HKyO.css","assets/LegalPage-BRlScr9A.css"])))=>i.map(i=>d[i]);
 var __defProp = Object.defineProperty;
 var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
 var _a2;
 import { c as create, j as jsxRuntimeExports, r as reactExports, a as createWithEqualityFn, R as React, T as Tb, s as schedulerExports, b as clientExports, d as reactDomExports, u as useParams, e as useSearchParams, f as useNavigate, L as Link, g as useLocation, B as BrowserRouter, h as Routes, i as Route, N as Navigate } from "./vendor-react-6j1Kke-Y.js";
-import { _ as __vitePreload, S as SDF_PROGRAM_OP, z as zipSync, s as strToU8, W as WebGLRenderer, R as Raycaster, O as OrthographicCamera$1, P as PerspectiveCamera$1, a as Scene, b as PCFSoftShadowMap, V as VSMShadowMap, c as PCFShadowMap, B as BasicShadowMap, C as ColorManagement, L as LinearSRGBColorSpace, d as SRGBColorSpace, N as NoToneMapping, A as ACESFilmicToneMapping, e as Layers, f as Color, g as RGBAFormat, U as UnsignedByteType, h as Vector3, i as Vector2, j as Clock, T as THREE, D as DoubleSide, k as REVISION, M as Mesh, I as IcosahedronGeometry, l as ShaderMaterial, m as Spherical, Q as Quaternion, n as MOUSE, o as TOUCH, p as Ray, q as Plane, r as DataTextureLoader, H as HalfFloatType, F as FloatType, t as DataUtils, u as LinearFilter, v as RedFormat, w as InstancedBufferGeometry, x as Float32BufferAttribute, y as InstancedInterleavedBuffer, E as InterleavedBufferAttribute, G as WireframeGeometry, J as Box3, K as Sphere, X as UniformsUtils, Y as UniformsLib, Z as Vector4, $ as Line3, a0 as Matrix4, a1 as MathUtils, a2 as Uniform, a3 as WebGLRenderTarget, a4 as DepthTexture, a5 as BackSide, a6 as BufferAttribute, a7 as Triangle, a8 as FrontSide, a9 as BatchedMesh, aa as ClampToEdgeWrapping, ab as PlaneGeometry, ac as UVMapping, ad as DataTexture, ae as Texture, af as MeshBasicMaterial, ag as IntType, ah as ShortType, ai as ByteType, aj as UnsignedIntType, ak as Loader, al as LoadingManager, am as LinearMipMapLinearFilter, an as FileLoader, ao as NoBlending, ap as CubeReflectionMapping, aq as EquirectangularReflectionMapping, ar as CubeTextureLoader, as as WebGLCubeRenderTarget, at as ConstraintSketch, au as setSketchPlacement3D, av as Sketch, aw as PROFILE_BACKEND_MARKER, ax as FrozenShape, ay as setShapeCompilePlan, az as hasAnyPorts, aA as setShapePortsInternal, aB as markShapePortsUsed, aC as resolveColormapName, aD as setParamOverrides, aE as resolveForgeRenderStyle, aF as DEFAULT_ACTIVE_BACKEND, aG as isConstraintSketch, aH as updateConstraintValue, aI as linearizeMultiObjectSteps, aJ as getShapeCompilePlan, aK as SCAN_PROXY_GRANULARITY_DEFAULT, aL as publishSolverWasmRunDebug, aM as resolveForgeQualityPreset, aN as SCAN_PROXY_MATRIX_GRANULARITY_MAX, aO as findJointAnimationClip, aP as resolveJointAnimation, aQ as resolveJointViewValues, aR as resolveImportPath, aS as resolveScanProxyGranularity, aT as BufferGeometry, aU as LineBasicMaterial, aV as Line$1, aW as LineDashedMaterial, aX as CanvasTexture, aY as Object3D, aZ as FogExp2, a_ as Fog, a$ as AmbientLight, b0 as HemisphereLight, b1 as SpotLight, b2 as PointLight, b3 as DirectionalLight, b4 as heatPointsForSide, b5 as COMPARISON_COLORS, b6 as comparisonHeatDepthTest, b7 as comparisonHeatEdgeOpacity, b8 as comparisonHeatPatchOpacity, b9 as shapeToGeometry, ba as buildComparisonHeatPatchGeometry, bb as EdgesGeometry, bc as buildShapeFromCompilePlan, bd as VIEWPORT_CAMERA_STORAGE_KEY, be as parseViewportCameraState, bf as getKernelFaceNameForTriangle, bg as OBJECT_CONTEXT_MENU_MARGIN, bh as buildVisibleHistoryStacks, bi as sketchToSvg, bj as sketchToDxf, bk as runScript, bl as MeshPhysicalMaterial, bm as LineSegments, bn as findDesignTraceNodeForConstructionStep, bo as formatDesignTraceAnchor, bp as waitForAnimationFrame, bq as selectBuildLedgerNodes, br as NoColorSpace, bs as worldAuthorPlaneToLocal, bt as compileSdfProgramEvaluator3, bu as SDF_LINEAR_OUTPUT_COLOR_GLSL, bv as GLSL3, bw as BoxGeometry, bx as Data3DTexture, by as buildSdfRaymarchFragmentShader, bz as SDF_RAYMARCH_PROXY_VERTEX_SHADER, bA as scanProxySourceBytes, bB as disposeScanProxyGeometry, bC as scanProxyGeometryFromPayload, bD as AdditiveBlending, bE as geometryWithVisibleVertexColors, bF as colorScaleLUT, bG as getRenderStylePreset, bH as SCAN_RENDER_COLORS, bI as NormalBlending, bJ as scanMaterialShellColor, bK as ZEBRA_STRIPE_SOFTNESS, bL as ZEBRA_STRIPE_SCALE, bM as ZEBRA_LIGHT_COLOR, bN as ZEBRA_DARK_COLOR, bO as ZEBRA_ACCENT_COLOR, bP as ZEBRA_STRIPE_FRAGMENT_SHADER, bQ as ZEBRA_STRIPE_VERTEX_SHADER, bR as SCAN_PROXY_LAYER_STYLES, bS as scanMaterialLayerStyles, bT as SURFACE_FIELD_FRAGMENT_SHADER, bU as SURFACE_FIELD_VERTEX_SHADER, bV as WORLD_UP$1, bW as CatmullRomCurve3, bX as TubeGeometry, bY as DEFAULT_COLORMAP, bZ as colorScaleHexStops, b_ as PERFORMANCE_SAMPLE_INTERVAL_SEC, b$ as formatPerformanceCount, c0 as NON_TEXT_INPUT_TYPES, c1 as MeshStandardMaterial, c2 as Shape, c3 as ShapeGeometry, c4 as ShaderLib, c5 as CylinderGeometry, c6 as createResolvedExplodeConfig, c7 as explodeBoundsCenter, c8 as explodeMergeBounds, c9 as resolveExplodeDirective, ca as computeExplodeMotion, cb as getSketchWorldMatrix, cc as explodeAdd, cd as hasExplodeOverride, ce as resolveExplodeLocalFanDirection, cf as explodeMul, cg as explodeLeafFanStage, ch as normalizeCutPlane, ci as toClippingPlane, cj as isObjectExcludedFromCutPlane, ck as getShapePorts, cl as getShapeUsedPorts, cm as DEFAULT_VIEW_CONFIG, cn as SECTION_EXPLORER_PLANE_NAME, co as ZERO_OFFSET, cp as scanProxyGridForBounds, cq as IDENTITY_MATRIX$2, cr as OBJECT_CONTEXT_MENU_WIDTH, cs as OBJECT_CONTEXT_MENU_HEIGHT, ct as triangleSoupFromMeshes, cu as compareTriangleSoups, cv as buildGeometryComparisonPointCloud, cw as aabbOverlaps, cx as aabbOverlapVolume, cy as DEFAULT_COLLISION_INSPECTION_OPTIONS, cz as resolveScalarSceneSampleBudget, cA as FOCUS_MODE_DIM_OPACITY, cB as DEFAULT_THICKNESS_INSPECTION_OPTIONS, cC as comparisonCandidateContextOpacity, cD as Matrix3, cE as initBackendForEvaluation } from "./backendInit-DbTkQN9J.js";
+import { _ as __vitePreload, S as SDF_PROGRAM_OP, z as zipSync, s as strToU8, W as WebGLRenderer, R as Raycaster, O as OrthographicCamera$1, P as PerspectiveCamera$1, a as Scene, b as PCFSoftShadowMap, V as VSMShadowMap, c as PCFShadowMap, B as BasicShadowMap, C as ColorManagement, L as LinearSRGBColorSpace, d as SRGBColorSpace, N as NoToneMapping, A as ACESFilmicToneMapping, e as Layers, f as Color, g as RGBAFormat, U as UnsignedByteType, h as Vector3, i as Vector2, j as Clock, T as THREE, D as DoubleSide, k as REVISION, M as Mesh, I as IcosahedronGeometry, l as ShaderMaterial, m as Spherical, Q as Quaternion, n as MOUSE, o as TOUCH, p as Ray, q as Plane, r as DataTextureLoader, H as HalfFloatType, F as FloatType, t as DataUtils, u as LinearFilter, v as RedFormat, w as InstancedBufferGeometry, x as Float32BufferAttribute, y as InstancedInterleavedBuffer, E as InterleavedBufferAttribute, G as WireframeGeometry, J as Box3, K as Sphere, X as UniformsUtils, Y as UniformsLib, Z as Vector4, $ as Line3, a0 as Matrix4, a1 as MathUtils, a2 as Uniform, a3 as WebGLRenderTarget, a4 as DepthTexture, a5 as BackSide, a6 as ClampToEdgeWrapping, a7 as PlaneGeometry, a8 as UVMapping, a9 as DataTexture, aa as Texture, ab as MeshBasicMaterial, ac as IntType, ad as ShortType, ae as ByteType, af as UnsignedIntType, ag as Loader, ah as LoadingManager, ai as LinearMipMapLinearFilter, aj as FileLoader, ak as NoBlending, al as CubeReflectionMapping, am as EquirectangularReflectionMapping, an as CubeTextureLoader, ao as WebGLCubeRenderTarget, ap as ConstraintSketch, aq as setSketchPlacement3D, ar as Sketch, as as PROFILE_BACKEND_MARKER, at as FrozenShape, au as setShapeCompilePlan, av as hasAnyPorts, aw as setShapePortsInternal, ax as markShapePortsUsed, ay as writeViewPreferences, az as setParamOverrides, aA as readViewPreferences, aB as resolveForgeRenderStyle, aC as isConstraintSketch, aD as updateConstraintValue, aE as linearizeMultiObjectSteps, aF as getShapeCompilePlan, aG as resolveCameraControlMode, aH as resolveComparisonOpacity, aI as resolveComparisonInspectMode, aJ as resolveBooleanPref, aK as resolveInspectQuantizeBands, aL as resolveInspectIsolineSpacing, aM as resolveInspectColormap, aN as resolveThicknessColorRange, aO as resolveInspectPointSampleCount, aP as SCAN_PROXY_GRANULARITY_DEFAULT, aQ as DEFAULT_MANUAL_SCENE_SETTINGS, aR as resolveManualSceneSettings, aS as publishSolverWasmRunDebug, aT as resolveForgeQualityPreset, aU as DEFAULT_INSPECT_ISOLINES_ENABLED, aV as SCAN_PROXY_MATRIX_GRANULARITY_MAX, aW as findJointAnimationClip, aX as resolveJointAnimation, aY as resolveJointViewValues, aZ as resolveImportPath, a_ as DEFAULT_INSPECT_CRITICAL_LINE_ENABLED, a$ as resolveScanProxyGranularity, b0 as DEFAULT_COMPARISON_REFERENCE_OPACITY, b1 as DEFAULT_COMPARISON_CANDIDATE_OPACITY, b2 as BufferGeometry, b3 as LineBasicMaterial, b4 as Line$1, b5 as LineDashedMaterial, b6 as CanvasTexture, b7 as Object3D, b8 as FogExp2, b9 as Fog, ba as AmbientLight, bb as HemisphereLight, bc as SpotLight, bd as PointLight, be as DirectionalLight, bf as BufferAttribute, bg as heatPointsForSide, bh as COMPARISON_COLORS, bi as comparisonHeatDepthTest, bj as comparisonHeatEdgeOpacity, bk as comparisonHeatPatchOpacity, bl as shapeToGeometry, bm as buildComparisonHeatPatchGeometry, bn as EdgesGeometry, bo as buildShapeFromCompilePlan, bp as VIEWPORT_CAMERA_STORAGE_KEY, bq as parseViewportCameraState, br as getKernelFaceNameForTriangle, bs as OBJECT_CONTEXT_MENU_MARGIN, bt as buildVisibleHistoryStacks, bu as sketchToSvg, bv as sketchToDxf, bw as runScript, bx as MeshPhysicalMaterial, by as LineSegments, bz as findDesignTraceNodeForConstructionStep, bA as formatDesignTraceAnchor, bB as waitForAnimationFrame, bC as selectBuildLedgerNodes, bD as worldAuthorPlaneToLocal, bE as compileSdfProgramEvaluator3, bF as SDF_LINEAR_OUTPUT_COLOR_GLSL, bG as GLSL3, bH as BoxGeometry, bI as Data3DTexture, bJ as buildSdfRaymarchFragmentShader, bK as SDF_RAYMARCH_PROXY_VERTEX_SHADER, bL as scanProxySourceBytes, bM as disposeScanProxyGeometry, bN as scanProxyGeometryFromPayload, bO as AdditiveBlending, bP as geometryWithVisibleVertexColors, bQ as MeshBVH, bR as makeColorScaleTexture, bS as colorScaleLUT, bT as makeInspectScalarUniforms, bU as updateInspectScalarUniforms, bV as descriptorToThreeTexture, bW as applyProjectedTexture, bX as getRenderStylePreset, bY as SCAN_RENDER_COLORS, bZ as NormalBlending, b_ as acceleratedRaycast, b$ as INSPECT_SCALAR_FRAGMENT_SHADER, c0 as INSPECT_SCALAR_VERTEX_SHADER, c1 as scanMaterialShellColor, c2 as ZEBRA_STRIPE_SOFTNESS, c3 as ZEBRA_STRIPE_SCALE, c4 as ZEBRA_LIGHT_COLOR, c5 as ZEBRA_DARK_COLOR, c6 as ZEBRA_ACCENT_COLOR, c7 as ZEBRA_STRIPE_FRAGMENT_SHADER, c8 as ZEBRA_STRIPE_VERTEX_SHADER, c9 as SCAN_PROXY_LAYER_STYLES, ca as scanMaterialLayerStyles, cb as SURFACE_FIELD_FRAGMENT_SHADER, cc as SURFACE_FIELD_VERTEX_SHADER, cd as WORLD_UP$1, ce as CatmullRomCurve3, cf as TubeGeometry, cg as DEFAULT_THICKNESS_COLOR_RANGE, ch as DEFAULT_COLORMAP, ci as colorScaleHexStops, cj as PERFORMANCE_SAMPLE_INTERVAL_SEC, ck as formatPerformanceCount, cl as NON_TEXT_INPUT_TYPES, cm as MeshStandardMaterial, cn as Shape, co as ShapeGeometry, cp as ShaderLib, cq as CylinderGeometry, cr as createResolvedExplodeConfig, cs as explodeBoundsCenter, ct as explodeMergeBounds, cu as resolveExplodeDirective, cv as computeExplodeMotion, cw as getSketchWorldMatrix, cx as explodeAdd, cy as hasExplodeOverride, cz as resolveExplodeLocalFanDirection, cA as explodeMul, cB as explodeLeafFanStage, cC as normalizeCutPlane, cD as toClippingPlane, cE as isObjectExcludedFromCutPlane, cF as getShapePorts, cG as getShapeUsedPorts, cH as DEFAULT_VIEW_CONFIG, cI as SECTION_EXPLORER_PLANE_NAME, cJ as ZERO_OFFSET, cK as scanProxyGridForBounds, cL as IDENTITY_MATRIX$2, cM as OBJECT_CONTEXT_MENU_WIDTH, cN as OBJECT_CONTEXT_MENU_HEIGHT, cO as triangleSoupFromMeshes, cP as compareTriangleSoups, cQ as buildGeometryComparisonPointCloud, cR as aabbOverlaps, cS as aabbOverlapVolume, cT as DEFAULT_COLLISION_INSPECTION_OPTIONS, cU as resolveScalarSceneSampleBudget, cV as INSPECT_POINT_SAMPLE_COUNT_MIN, cW as FOCUS_MODE_DIM_OPACITY, cX as DEFAULT_THICKNESS_INSPECTION_OPTIONS, cY as comparisonCandidateContextOpacity, cZ as Matrix3, c_ as initBackendForEvaluation } from "./backendInit-6C0DLgH0.js";
 function getCsrfToken() {
   const match = document.cookie.match(/(?:^|;\s*)fc-csrf-token=([^;]+)/);
   return match == null ? void 0 : match[1];
@@ -13391,3329 +13391,6 @@ const Grid = /* @__PURE__ */ reactExports.forwardRef(({
     args
   }));
 });
-const CENTER = 0;
-const AVERAGE = 1;
-const SAH = 2;
-const CONTAINED = 2;
-const TRIANGLE_INTERSECT_COST = 1.25;
-const TRAVERSAL_COST = 1;
-const BYTES_PER_NODE = 6 * 4 + 4 + 4;
-const IS_LEAFNODE_FLAG = 65535;
-const FLOAT32_EPSILON = Math.pow(2, -24);
-const SKIP_GENERATION = Symbol("SKIP_GENERATION");
-function getVertexCount(geo) {
-  return geo.index ? geo.index.count : geo.attributes.position.count;
-}
-function getTriCount(geo) {
-  return getVertexCount(geo) / 3;
-}
-function getIndexArray(vertexCount, BufferConstructor = ArrayBuffer) {
-  if (vertexCount > 65535) {
-    return new Uint32Array(new BufferConstructor(4 * vertexCount));
-  } else {
-    return new Uint16Array(new BufferConstructor(2 * vertexCount));
-  }
-}
-function ensureIndex(geo, options) {
-  if (!geo.index) {
-    const vertexCount = geo.attributes.position.count;
-    const BufferConstructor = options.useSharedArrayBuffer ? SharedArrayBuffer : ArrayBuffer;
-    const index = getIndexArray(vertexCount, BufferConstructor);
-    geo.setIndex(new BufferAttribute(index, 1));
-    for (let i = 0; i < vertexCount; i++) {
-      index[i] = i;
-    }
-  }
-}
-function getFullGeometryRange(geo, range) {
-  const triCount = getTriCount(geo);
-  const drawRange = range ? range : geo.drawRange;
-  const start = drawRange.start / 3;
-  const end = (drawRange.start + drawRange.count) / 3;
-  const offset = Math.max(0, start);
-  const count = Math.min(triCount, end) - offset;
-  return [{
-    offset: Math.floor(offset),
-    count: Math.floor(count)
-  }];
-}
-function getRootIndexRanges(geo, range) {
-  if (!geo.groups || !geo.groups.length) {
-    return getFullGeometryRange(geo, range);
-  }
-  const ranges = [];
-  const rangeBoundaries = /* @__PURE__ */ new Set();
-  const drawRange = range ? range : geo.drawRange;
-  const drawRangeStart = drawRange.start / 3;
-  const drawRangeEnd = (drawRange.start + drawRange.count) / 3;
-  for (const group of geo.groups) {
-    const groupStart = group.start / 3;
-    const groupEnd = (group.start + group.count) / 3;
-    rangeBoundaries.add(Math.max(drawRangeStart, groupStart));
-    rangeBoundaries.add(Math.min(drawRangeEnd, groupEnd));
-  }
-  const sortedBoundaries = Array.from(rangeBoundaries.values()).sort((a2, b2) => a2 - b2);
-  for (let i = 0; i < sortedBoundaries.length - 1; i++) {
-    const start = sortedBoundaries[i];
-    const end = sortedBoundaries[i + 1];
-    ranges.push({
-      offset: Math.floor(start),
-      count: Math.floor(end - start)
-    });
-  }
-  return ranges;
-}
-function hasGroupGaps(geometry, range) {
-  const vertexCount = getTriCount(geometry);
-  const groups = getRootIndexRanges(geometry, range).sort((a2, b2) => a2.offset - b2.offset);
-  const finalGroup = groups[groups.length - 1];
-  finalGroup.count = Math.min(vertexCount - finalGroup.offset, finalGroup.count);
-  let total = 0;
-  groups.forEach(({ count }) => total += count);
-  return vertexCount !== total;
-}
-function getBounds(triangleBounds, offset, count, target, centroidTarget) {
-  let minx = Infinity;
-  let miny = Infinity;
-  let minz = Infinity;
-  let maxx = -Infinity;
-  let maxy = -Infinity;
-  let maxz = -Infinity;
-  let cminx = Infinity;
-  let cminy = Infinity;
-  let cminz = Infinity;
-  let cmaxx = -Infinity;
-  let cmaxy = -Infinity;
-  let cmaxz = -Infinity;
-  for (let i = offset * 6, end = (offset + count) * 6; i < end; i += 6) {
-    const cx = triangleBounds[i + 0];
-    const hx = triangleBounds[i + 1];
-    const lx = cx - hx;
-    const rx = cx + hx;
-    if (lx < minx) minx = lx;
-    if (rx > maxx) maxx = rx;
-    if (cx < cminx) cminx = cx;
-    if (cx > cmaxx) cmaxx = cx;
-    const cy = triangleBounds[i + 2];
-    const hy = triangleBounds[i + 3];
-    const ly = cy - hy;
-    const ry = cy + hy;
-    if (ly < miny) miny = ly;
-    if (ry > maxy) maxy = ry;
-    if (cy < cminy) cminy = cy;
-    if (cy > cmaxy) cmaxy = cy;
-    const cz = triangleBounds[i + 4];
-    const hz = triangleBounds[i + 5];
-    const lz = cz - hz;
-    const rz = cz + hz;
-    if (lz < minz) minz = lz;
-    if (rz > maxz) maxz = rz;
-    if (cz < cminz) cminz = cz;
-    if (cz > cmaxz) cmaxz = cz;
-  }
-  target[0] = minx;
-  target[1] = miny;
-  target[2] = minz;
-  target[3] = maxx;
-  target[4] = maxy;
-  target[5] = maxz;
-  centroidTarget[0] = cminx;
-  centroidTarget[1] = cminy;
-  centroidTarget[2] = cminz;
-  centroidTarget[3] = cmaxx;
-  centroidTarget[4] = cmaxy;
-  centroidTarget[5] = cmaxz;
-}
-function computeTriangleBounds(geo, target = null, offset = null, count = null) {
-  const posAttr = geo.attributes.position;
-  const index = geo.index ? geo.index.array : null;
-  const triCount = getTriCount(geo);
-  const normalized = posAttr.normalized;
-  let triangleBounds;
-  if (target === null) {
-    triangleBounds = new Float32Array(triCount * 6);
-    offset = 0;
-    count = triCount;
-  } else {
-    triangleBounds = target;
-    offset = offset || 0;
-    count = count || triCount;
-  }
-  const posArr = posAttr.array;
-  const bufferOffset = posAttr.offset || 0;
-  let stride = 3;
-  if (posAttr.isInterleavedBufferAttribute) {
-    stride = posAttr.data.stride;
-  }
-  const getters = ["getX", "getY", "getZ"];
-  for (let tri = offset; tri < offset + count; tri++) {
-    const tri3 = tri * 3;
-    const tri6 = tri * 6;
-    let ai = tri3 + 0;
-    let bi = tri3 + 1;
-    let ci = tri3 + 2;
-    if (index) {
-      ai = index[ai];
-      bi = index[bi];
-      ci = index[ci];
-    }
-    if (!normalized) {
-      ai = ai * stride + bufferOffset;
-      bi = bi * stride + bufferOffset;
-      ci = ci * stride + bufferOffset;
-    }
-    for (let el = 0; el < 3; el++) {
-      let a2, b2, c2;
-      if (normalized) {
-        a2 = posAttr[getters[el]](ai);
-        b2 = posAttr[getters[el]](bi);
-        c2 = posAttr[getters[el]](ci);
-      } else {
-        a2 = posArr[ai + el];
-        b2 = posArr[bi + el];
-        c2 = posArr[ci + el];
-      }
-      let min = a2;
-      if (b2 < min) min = b2;
-      if (c2 < min) min = c2;
-      let max2 = a2;
-      if (b2 > max2) max2 = b2;
-      if (c2 > max2) max2 = c2;
-      const halfExtents = (max2 - min) / 2;
-      const el2 = el * 2;
-      triangleBounds[tri6 + el2 + 0] = min + halfExtents;
-      triangleBounds[tri6 + el2 + 1] = halfExtents + (Math.abs(min) + halfExtents) * FLOAT32_EPSILON;
-    }
-  }
-  return triangleBounds;
-}
-function arrayToBox(nodeIndex32, array, target) {
-  target.min.x = array[nodeIndex32];
-  target.min.y = array[nodeIndex32 + 1];
-  target.min.z = array[nodeIndex32 + 2];
-  target.max.x = array[nodeIndex32 + 3];
-  target.max.y = array[nodeIndex32 + 4];
-  target.max.z = array[nodeIndex32 + 5];
-  return target;
-}
-function getLongestEdgeIndex(bounds) {
-  let splitDimIdx = -1;
-  let splitDist = -Infinity;
-  for (let i = 0; i < 3; i++) {
-    const dist = bounds[i + 3] - bounds[i];
-    if (dist > splitDist) {
-      splitDist = dist;
-      splitDimIdx = i;
-    }
-  }
-  return splitDimIdx;
-}
-function copyBounds(source, target) {
-  target.set(source);
-}
-function unionBounds(a2, b2, target) {
-  let aVal, bVal;
-  for (let d = 0; d < 3; d++) {
-    const d3 = d + 3;
-    aVal = a2[d];
-    bVal = b2[d];
-    target[d] = aVal < bVal ? aVal : bVal;
-    aVal = a2[d3];
-    bVal = b2[d3];
-    target[d3] = aVal > bVal ? aVal : bVal;
-  }
-}
-function expandByTriangleBounds(startIndex, triangleBounds, bounds) {
-  for (let d = 0; d < 3; d++) {
-    const tCenter = triangleBounds[startIndex + 2 * d];
-    const tHalf = triangleBounds[startIndex + 2 * d + 1];
-    const tMin = tCenter - tHalf;
-    const tMax = tCenter + tHalf;
-    if (tMin < bounds[d]) {
-      bounds[d] = tMin;
-    }
-    if (tMax > bounds[d + 3]) {
-      bounds[d + 3] = tMax;
-    }
-  }
-}
-function computeSurfaceArea(bounds) {
-  const d0 = bounds[3] - bounds[0];
-  const d1 = bounds[4] - bounds[1];
-  const d2 = bounds[5] - bounds[2];
-  return 2 * (d0 * d1 + d1 * d2 + d2 * d0);
-}
-const BIN_COUNT = 32;
-const binsSort = (a2, b2) => a2.candidate - b2.candidate;
-const sahBins = new Array(BIN_COUNT).fill().map(() => {
-  return {
-    count: 0,
-    bounds: new Float32Array(6),
-    rightCacheBounds: new Float32Array(6),
-    leftCacheBounds: new Float32Array(6),
-    candidate: 0
-  };
-});
-const leftBounds = new Float32Array(6);
-function getOptimalSplit(nodeBoundingData, centroidBoundingData, triangleBounds, offset, count, strategy) {
-  let axis = -1;
-  let pos = 0;
-  if (strategy === CENTER) {
-    axis = getLongestEdgeIndex(centroidBoundingData);
-    if (axis !== -1) {
-      pos = (centroidBoundingData[axis] + centroidBoundingData[axis + 3]) / 2;
-    }
-  } else if (strategy === AVERAGE) {
-    axis = getLongestEdgeIndex(nodeBoundingData);
-    if (axis !== -1) {
-      pos = getAverage(triangleBounds, offset, count, axis);
-    }
-  } else if (strategy === SAH) {
-    const rootSurfaceArea = computeSurfaceArea(nodeBoundingData);
-    let bestCost = TRIANGLE_INTERSECT_COST * count;
-    const cStart = offset * 6;
-    const cEnd = (offset + count) * 6;
-    for (let a2 = 0; a2 < 3; a2++) {
-      const axisLeft = centroidBoundingData[a2];
-      const axisRight = centroidBoundingData[a2 + 3];
-      const axisLength = axisRight - axisLeft;
-      const binWidth = axisLength / BIN_COUNT;
-      if (count < BIN_COUNT / 4) {
-        const truncatedBins = [...sahBins];
-        truncatedBins.length = count;
-        let b2 = 0;
-        for (let c2 = cStart; c2 < cEnd; c2 += 6, b2++) {
-          const bin = truncatedBins[b2];
-          bin.candidate = triangleBounds[c2 + 2 * a2];
-          bin.count = 0;
-          const {
-            bounds,
-            leftCacheBounds,
-            rightCacheBounds
-          } = bin;
-          for (let d = 0; d < 3; d++) {
-            rightCacheBounds[d] = Infinity;
-            rightCacheBounds[d + 3] = -Infinity;
-            leftCacheBounds[d] = Infinity;
-            leftCacheBounds[d + 3] = -Infinity;
-            bounds[d] = Infinity;
-            bounds[d + 3] = -Infinity;
-          }
-          expandByTriangleBounds(c2, triangleBounds, bounds);
-        }
-        truncatedBins.sort(binsSort);
-        let splitCount = count;
-        for (let bi = 0; bi < splitCount; bi++) {
-          const bin = truncatedBins[bi];
-          while (bi + 1 < splitCount && truncatedBins[bi + 1].candidate === bin.candidate) {
-            truncatedBins.splice(bi + 1, 1);
-            splitCount--;
-          }
-        }
-        for (let c2 = cStart; c2 < cEnd; c2 += 6) {
-          const center = triangleBounds[c2 + 2 * a2];
-          for (let bi = 0; bi < splitCount; bi++) {
-            const bin = truncatedBins[bi];
-            if (center >= bin.candidate) {
-              expandByTriangleBounds(c2, triangleBounds, bin.rightCacheBounds);
-            } else {
-              expandByTriangleBounds(c2, triangleBounds, bin.leftCacheBounds);
-              bin.count++;
-            }
-          }
-        }
-        for (let bi = 0; bi < splitCount; bi++) {
-          const bin = truncatedBins[bi];
-          const leftCount = bin.count;
-          const rightCount = count - bin.count;
-          const leftBounds2 = bin.leftCacheBounds;
-          const rightBounds = bin.rightCacheBounds;
-          let leftProb = 0;
-          if (leftCount !== 0) {
-            leftProb = computeSurfaceArea(leftBounds2) / rootSurfaceArea;
-          }
-          let rightProb = 0;
-          if (rightCount !== 0) {
-            rightProb = computeSurfaceArea(rightBounds) / rootSurfaceArea;
-          }
-          const cost = TRAVERSAL_COST + TRIANGLE_INTERSECT_COST * (leftProb * leftCount + rightProb * rightCount);
-          if (cost < bestCost) {
-            axis = a2;
-            bestCost = cost;
-            pos = bin.candidate;
-          }
-        }
-      } else {
-        for (let i = 0; i < BIN_COUNT; i++) {
-          const bin = sahBins[i];
-          bin.count = 0;
-          bin.candidate = axisLeft + binWidth + i * binWidth;
-          const bounds = bin.bounds;
-          for (let d = 0; d < 3; d++) {
-            bounds[d] = Infinity;
-            bounds[d + 3] = -Infinity;
-          }
-        }
-        for (let c2 = cStart; c2 < cEnd; c2 += 6) {
-          const triCenter = triangleBounds[c2 + 2 * a2];
-          const relativeCenter = triCenter - axisLeft;
-          let binIndex = ~~(relativeCenter / binWidth);
-          if (binIndex >= BIN_COUNT) binIndex = BIN_COUNT - 1;
-          const bin = sahBins[binIndex];
-          bin.count++;
-          expandByTriangleBounds(c2, triangleBounds, bin.bounds);
-        }
-        const lastBin = sahBins[BIN_COUNT - 1];
-        copyBounds(lastBin.bounds, lastBin.rightCacheBounds);
-        for (let i = BIN_COUNT - 2; i >= 0; i--) {
-          const bin = sahBins[i];
-          const nextBin = sahBins[i + 1];
-          unionBounds(bin.bounds, nextBin.rightCacheBounds, bin.rightCacheBounds);
-        }
-        let leftCount = 0;
-        for (let i = 0; i < BIN_COUNT - 1; i++) {
-          const bin = sahBins[i];
-          const binCount = bin.count;
-          const bounds = bin.bounds;
-          const nextBin = sahBins[i + 1];
-          const rightBounds = nextBin.rightCacheBounds;
-          if (binCount !== 0) {
-            if (leftCount === 0) {
-              copyBounds(bounds, leftBounds);
-            } else {
-              unionBounds(bounds, leftBounds, leftBounds);
-            }
-          }
-          leftCount += binCount;
-          let leftProb = 0;
-          let rightProb = 0;
-          if (leftCount !== 0) {
-            leftProb = computeSurfaceArea(leftBounds) / rootSurfaceArea;
-          }
-          const rightCount = count - leftCount;
-          if (rightCount !== 0) {
-            rightProb = computeSurfaceArea(rightBounds) / rootSurfaceArea;
-          }
-          const cost = TRAVERSAL_COST + TRIANGLE_INTERSECT_COST * (leftProb * leftCount + rightProb * rightCount);
-          if (cost < bestCost) {
-            axis = a2;
-            bestCost = cost;
-            pos = bin.candidate;
-          }
-        }
-      }
-    }
-  } else {
-    console.warn(`MeshBVH: Invalid build strategy value ${strategy} used.`);
-  }
-  return { axis, pos };
-}
-function getAverage(triangleBounds, offset, count, axis) {
-  let avg = 0;
-  for (let i = offset, end = offset + count; i < end; i++) {
-    avg += triangleBounds[i * 6 + axis * 2];
-  }
-  return avg / count;
-}
-class MeshBVHNode {
-  constructor() {
-    this.boundingData = new Float32Array(6);
-  }
-}
-function partition(indirectBuffer, index, triangleBounds, offset, count, split) {
-  let left = offset;
-  let right = offset + count - 1;
-  const pos = split.pos;
-  const axisOffset = split.axis * 2;
-  while (true) {
-    while (left <= right && triangleBounds[left * 6 + axisOffset] < pos) {
-      left++;
-    }
-    while (left <= right && triangleBounds[right * 6 + axisOffset] >= pos) {
-      right--;
-    }
-    if (left < right) {
-      for (let i = 0; i < 3; i++) {
-        let t02 = index[left * 3 + i];
-        index[left * 3 + i] = index[right * 3 + i];
-        index[right * 3 + i] = t02;
-      }
-      for (let i = 0; i < 6; i++) {
-        let tb = triangleBounds[left * 6 + i];
-        triangleBounds[left * 6 + i] = triangleBounds[right * 6 + i];
-        triangleBounds[right * 6 + i] = tb;
-      }
-      left++;
-      right--;
-    } else {
-      return left;
-    }
-  }
-}
-function partition_indirect(indirectBuffer, index, triangleBounds, offset, count, split) {
-  let left = offset;
-  let right = offset + count - 1;
-  const pos = split.pos;
-  const axisOffset = split.axis * 2;
-  while (true) {
-    while (left <= right && triangleBounds[left * 6 + axisOffset] < pos) {
-      left++;
-    }
-    while (left <= right && triangleBounds[right * 6 + axisOffset] >= pos) {
-      right--;
-    }
-    if (left < right) {
-      let t2 = indirectBuffer[left];
-      indirectBuffer[left] = indirectBuffer[right];
-      indirectBuffer[right] = t2;
-      for (let i = 0; i < 6; i++) {
-        let tb = triangleBounds[left * 6 + i];
-        triangleBounds[left * 6 + i] = triangleBounds[right * 6 + i];
-        triangleBounds[right * 6 + i] = tb;
-      }
-      left++;
-      right--;
-    } else {
-      return left;
-    }
-  }
-}
-function IS_LEAF(n16, uint16Array2) {
-  return uint16Array2[n16 + 15] === 65535;
-}
-function OFFSET(n32, uint32Array2) {
-  return uint32Array2[n32 + 6];
-}
-function COUNT(n16, uint16Array2) {
-  return uint16Array2[n16 + 14];
-}
-function LEFT_NODE(n32) {
-  return n32 + 8;
-}
-function RIGHT_NODE(n32, uint32Array2) {
-  return uint32Array2[n32 + 6];
-}
-function SPLIT_AXIS(n32, uint32Array2) {
-  return uint32Array2[n32 + 7];
-}
-function BOUNDING_DATA_INDEX(n32) {
-  return n32;
-}
-let float32Array, uint32Array, uint16Array, uint8Array;
-const MAX_POINTER = Math.pow(2, 32);
-function countNodes(node) {
-  if ("count" in node) {
-    return 1;
-  } else {
-    return 1 + countNodes(node.left) + countNodes(node.right);
-  }
-}
-function populateBuffer(byteOffset, node, buffer) {
-  float32Array = new Float32Array(buffer);
-  uint32Array = new Uint32Array(buffer);
-  uint16Array = new Uint16Array(buffer);
-  uint8Array = new Uint8Array(buffer);
-  return _populateBuffer(byteOffset, node);
-}
-function _populateBuffer(byteOffset, node) {
-  const stride4Offset = byteOffset / 4;
-  const stride2Offset = byteOffset / 2;
-  const isLeaf = "count" in node;
-  const boundingData = node.boundingData;
-  for (let i = 0; i < 6; i++) {
-    float32Array[stride4Offset + i] = boundingData[i];
-  }
-  if (isLeaf) {
-    if (node.buffer) {
-      const buffer = node.buffer;
-      uint8Array.set(new Uint8Array(buffer), byteOffset);
-      for (let offset = byteOffset, l2 = byteOffset + buffer.byteLength; offset < l2; offset += BYTES_PER_NODE) {
-        const offset2 = offset / 2;
-        if (!IS_LEAF(offset2, uint16Array)) {
-          uint32Array[offset / 4 + 6] += stride4Offset;
-        }
-      }
-      return byteOffset + buffer.byteLength;
-    } else {
-      const offset = node.offset;
-      const count = node.count;
-      uint32Array[stride4Offset + 6] = offset;
-      uint16Array[stride2Offset + 14] = count;
-      uint16Array[stride2Offset + 15] = IS_LEAFNODE_FLAG;
-      return byteOffset + BYTES_PER_NODE;
-    }
-  } else {
-    const left = node.left;
-    const right = node.right;
-    const splitAxis = node.splitAxis;
-    let nextUnusedPointer;
-    nextUnusedPointer = _populateBuffer(byteOffset + BYTES_PER_NODE, left);
-    if (nextUnusedPointer / 4 > MAX_POINTER) {
-      throw new Error("MeshBVH: Cannot store child pointer greater than 32 bits.");
-    }
-    uint32Array[stride4Offset + 6] = nextUnusedPointer / 4;
-    nextUnusedPointer = _populateBuffer(nextUnusedPointer, right);
-    uint32Array[stride4Offset + 7] = splitAxis;
-    return nextUnusedPointer;
-  }
-}
-function generateIndirectBuffer(geometry, useSharedArrayBuffer) {
-  const triCount = (geometry.index ? geometry.index.count : geometry.attributes.position.count) / 3;
-  const useUint32 = triCount > 2 ** 16;
-  const byteCount = useUint32 ? 4 : 2;
-  const buffer = useSharedArrayBuffer ? new SharedArrayBuffer(triCount * byteCount) : new ArrayBuffer(triCount * byteCount);
-  const indirectBuffer = useUint32 ? new Uint32Array(buffer) : new Uint16Array(buffer);
-  for (let i = 0, l2 = indirectBuffer.length; i < l2; i++) {
-    indirectBuffer[i] = i;
-  }
-  return indirectBuffer;
-}
-function buildTree(bvh, triangleBounds, offset, count, options) {
-  const {
-    maxDepth,
-    verbose,
-    maxLeafTris,
-    strategy,
-    onProgress,
-    indirect
-  } = options;
-  const indirectBuffer = bvh._indirectBuffer;
-  const geometry = bvh.geometry;
-  const indexArray = geometry.index ? geometry.index.array : null;
-  const partionFunc = indirect ? partition_indirect : partition;
-  const totalTriangles = getTriCount(geometry);
-  const cacheCentroidBoundingData = new Float32Array(6);
-  let reachedMaxDepth = false;
-  const root = new MeshBVHNode();
-  getBounds(triangleBounds, offset, count, root.boundingData, cacheCentroidBoundingData);
-  splitNode(root, offset, count, cacheCentroidBoundingData);
-  return root;
-  function triggerProgress(trianglesProcessed) {
-    if (onProgress) {
-      onProgress(trianglesProcessed / totalTriangles);
-    }
-  }
-  function splitNode(node, offset2, count2, centroidBoundingData = null, depth = 0) {
-    if (!reachedMaxDepth && depth >= maxDepth) {
-      reachedMaxDepth = true;
-      if (verbose) {
-        console.warn(`MeshBVH: Max depth of ${maxDepth} reached when generating BVH. Consider increasing maxDepth.`);
-        console.warn(geometry);
-      }
-    }
-    if (count2 <= maxLeafTris || depth >= maxDepth) {
-      triggerProgress(offset2 + count2);
-      node.offset = offset2;
-      node.count = count2;
-      return node;
-    }
-    const split = getOptimalSplit(node.boundingData, centroidBoundingData, triangleBounds, offset2, count2, strategy);
-    if (split.axis === -1) {
-      triggerProgress(offset2 + count2);
-      node.offset = offset2;
-      node.count = count2;
-      return node;
-    }
-    const splitOffset = partionFunc(indirectBuffer, indexArray, triangleBounds, offset2, count2, split);
-    if (splitOffset === offset2 || splitOffset === offset2 + count2) {
-      triggerProgress(offset2 + count2);
-      node.offset = offset2;
-      node.count = count2;
-    } else {
-      node.splitAxis = split.axis;
-      const left = new MeshBVHNode();
-      const lstart = offset2;
-      const lcount = splitOffset - offset2;
-      node.left = left;
-      getBounds(triangleBounds, lstart, lcount, left.boundingData, cacheCentroidBoundingData);
-      splitNode(left, lstart, lcount, cacheCentroidBoundingData, depth + 1);
-      const right = new MeshBVHNode();
-      const rstart = splitOffset;
-      const rcount = count2 - lcount;
-      node.right = right;
-      getBounds(triangleBounds, rstart, rcount, right.boundingData, cacheCentroidBoundingData);
-      splitNode(right, rstart, rcount, cacheCentroidBoundingData, depth + 1);
-    }
-    return node;
-  }
-}
-function buildPackedTree(bvh, options) {
-  const geometry = bvh.geometry;
-  if (options.indirect) {
-    bvh._indirectBuffer = generateIndirectBuffer(geometry, options.useSharedArrayBuffer);
-    if (hasGroupGaps(geometry, options.range) && !options.verbose) {
-      console.warn(
-        'MeshBVH: Provided geometry contains groups or a range that do not fully span the vertex contents while using the "indirect" option. BVH may incorrectly report intersections on unrendered portions of the geometry.'
-      );
-    }
-  }
-  if (!bvh._indirectBuffer) {
-    ensureIndex(geometry, options);
-  }
-  const BufferConstructor = options.useSharedArrayBuffer ? SharedArrayBuffer : ArrayBuffer;
-  const triangleBounds = computeTriangleBounds(geometry);
-  const geometryRanges = options.indirect ? getFullGeometryRange(geometry, options.range) : getRootIndexRanges(geometry, options.range);
-  bvh._roots = geometryRanges.map((range) => {
-    const root = buildTree(bvh, triangleBounds, range.offset, range.count, options);
-    const nodeCount = countNodes(root);
-    const buffer = new BufferConstructor(BYTES_PER_NODE * nodeCount);
-    populateBuffer(0, root, buffer);
-    return buffer;
-  });
-}
-class SeparatingAxisBounds {
-  constructor() {
-    this.min = Infinity;
-    this.max = -Infinity;
-  }
-  setFromPointsField(points, field) {
-    let min = Infinity;
-    let max2 = -Infinity;
-    for (let i = 0, l2 = points.length; i < l2; i++) {
-      const p2 = points[i];
-      const val = p2[field];
-      min = val < min ? val : min;
-      max2 = val > max2 ? val : max2;
-    }
-    this.min = min;
-    this.max = max2;
-  }
-  setFromPoints(axis, points) {
-    let min = Infinity;
-    let max2 = -Infinity;
-    for (let i = 0, l2 = points.length; i < l2; i++) {
-      const p2 = points[i];
-      const val = axis.dot(p2);
-      min = val < min ? val : min;
-      max2 = val > max2 ? val : max2;
-    }
-    this.min = min;
-    this.max = max2;
-  }
-  isSeparated(other) {
-    return this.min > other.max || other.min > this.max;
-  }
-}
-SeparatingAxisBounds.prototype.setFromBox = (function() {
-  const p2 = new Vector3();
-  return function setFromBox(axis, box2) {
-    const boxMin = box2.min;
-    const boxMax = box2.max;
-    let min = Infinity;
-    let max2 = -Infinity;
-    for (let x = 0; x <= 1; x++) {
-      for (let y = 0; y <= 1; y++) {
-        for (let z = 0; z <= 1; z++) {
-          p2.x = boxMin.x * x + boxMax.x * (1 - x);
-          p2.y = boxMin.y * y + boxMax.y * (1 - y);
-          p2.z = boxMin.z * z + boxMax.z * (1 - z);
-          const val = axis.dot(p2);
-          min = Math.min(val, min);
-          max2 = Math.max(val, max2);
-        }
-      }
-    }
-    this.min = min;
-    this.max = max2;
-  };
-})();
-const closestPointLineToLine = (function() {
-  const dir1 = new Vector3();
-  const dir2 = new Vector3();
-  const v02 = new Vector3();
-  return function closestPointLineToLine2(l1, l2, result) {
-    const v0 = l1.start;
-    const v10 = dir1;
-    const v22 = l2.start;
-    const v32 = dir2;
-    v02.subVectors(v0, v22);
-    dir1.subVectors(l1.end, l1.start);
-    dir2.subVectors(l2.end, l2.start);
-    const d0232 = v02.dot(v32);
-    const d3210 = v32.dot(v10);
-    const d3232 = v32.dot(v32);
-    const d0210 = v02.dot(v10);
-    const d1010 = v10.dot(v10);
-    const denom = d1010 * d3232 - d3210 * d3210;
-    let d, d2;
-    if (denom !== 0) {
-      d = (d0232 * d3210 - d0210 * d3232) / denom;
-    } else {
-      d = 0;
-    }
-    d2 = (d0232 + d * d3210) / d3232;
-    result.x = d;
-    result.y = d2;
-  };
-})();
-const closestPointsSegmentToSegment = (function() {
-  const paramResult = new Vector2();
-  const temp12 = new Vector3();
-  const temp22 = new Vector3();
-  return function closestPointsSegmentToSegment2(l1, l2, target1, target2) {
-    closestPointLineToLine(l1, l2, paramResult);
-    let d = paramResult.x;
-    let d2 = paramResult.y;
-    if (d >= 0 && d <= 1 && d2 >= 0 && d2 <= 1) {
-      l1.at(d, target1);
-      l2.at(d2, target2);
-      return;
-    } else if (d >= 0 && d <= 1) {
-      if (d2 < 0) {
-        l2.at(0, target2);
-      } else {
-        l2.at(1, target2);
-      }
-      l1.closestPointToPoint(target2, true, target1);
-      return;
-    } else if (d2 >= 0 && d2 <= 1) {
-      if (d < 0) {
-        l1.at(0, target1);
-      } else {
-        l1.at(1, target1);
-      }
-      l2.closestPointToPoint(target1, true, target2);
-      return;
-    } else {
-      let p2;
-      if (d < 0) {
-        p2 = l1.start;
-      } else {
-        p2 = l1.end;
-      }
-      let p22;
-      if (d2 < 0) {
-        p22 = l2.start;
-      } else {
-        p22 = l2.end;
-      }
-      const closestPoint = temp12;
-      const closestPoint2 = temp22;
-      l1.closestPointToPoint(p22, true, temp12);
-      l2.closestPointToPoint(p2, true, temp22);
-      if (closestPoint.distanceToSquared(p22) <= closestPoint2.distanceToSquared(p2)) {
-        target1.copy(closestPoint);
-        target2.copy(p22);
-        return;
-      } else {
-        target1.copy(p2);
-        target2.copy(closestPoint2);
-        return;
-      }
-    }
-  };
-})();
-const sphereIntersectTriangle = (function() {
-  const closestPointTemp = new Vector3();
-  const projectedPointTemp = new Vector3();
-  const planeTemp = new Plane();
-  const lineTemp = new Line3();
-  return function sphereIntersectTriangle2(sphere, triangle3) {
-    const { radius, center } = sphere;
-    const { a: a2, b: b2, c: c2 } = triangle3;
-    lineTemp.start = a2;
-    lineTemp.end = b2;
-    const closestPoint1 = lineTemp.closestPointToPoint(center, true, closestPointTemp);
-    if (closestPoint1.distanceTo(center) <= radius) return true;
-    lineTemp.start = a2;
-    lineTemp.end = c2;
-    const closestPoint2 = lineTemp.closestPointToPoint(center, true, closestPointTemp);
-    if (closestPoint2.distanceTo(center) <= radius) return true;
-    lineTemp.start = b2;
-    lineTemp.end = c2;
-    const closestPoint3 = lineTemp.closestPointToPoint(center, true, closestPointTemp);
-    if (closestPoint3.distanceTo(center) <= radius) return true;
-    const plane = triangle3.getPlane(planeTemp);
-    const dp = Math.abs(plane.distanceToPoint(center));
-    if (dp <= radius) {
-      const pp = plane.projectPoint(center, projectedPointTemp);
-      const cp = triangle3.containsPoint(pp);
-      if (cp) return true;
-    }
-    return false;
-  };
-})();
-const ZERO_EPSILON = 1e-15;
-function isNearZero(value) {
-  return Math.abs(value) < ZERO_EPSILON;
-}
-class ExtendedTriangle extends Triangle {
-  constructor(...args) {
-    super(...args);
-    this.isExtendedTriangle = true;
-    this.satAxes = new Array(4).fill().map(() => new Vector3());
-    this.satBounds = new Array(4).fill().map(() => new SeparatingAxisBounds());
-    this.points = [this.a, this.b, this.c];
-    this.sphere = new Sphere();
-    this.plane = new Plane();
-    this.needsUpdate = true;
-  }
-  intersectsSphere(sphere) {
-    return sphereIntersectTriangle(sphere, this);
-  }
-  update() {
-    const a2 = this.a;
-    const b2 = this.b;
-    const c2 = this.c;
-    const points = this.points;
-    const satAxes = this.satAxes;
-    const satBounds = this.satBounds;
-    const axis0 = satAxes[0];
-    const sab0 = satBounds[0];
-    this.getNormal(axis0);
-    sab0.setFromPoints(axis0, points);
-    const axis1 = satAxes[1];
-    const sab1 = satBounds[1];
-    axis1.subVectors(a2, b2);
-    sab1.setFromPoints(axis1, points);
-    const axis2 = satAxes[2];
-    const sab2 = satBounds[2];
-    axis2.subVectors(b2, c2);
-    sab2.setFromPoints(axis2, points);
-    const axis3 = satAxes[3];
-    const sab3 = satBounds[3];
-    axis3.subVectors(c2, a2);
-    sab3.setFromPoints(axis3, points);
-    this.sphere.setFromPoints(this.points);
-    this.plane.setFromNormalAndCoplanarPoint(axis0, a2);
-    this.needsUpdate = false;
-  }
-}
-ExtendedTriangle.prototype.closestPointToSegment = (function() {
-  const point1 = new Vector3();
-  const point2 = new Vector3();
-  const edge = new Line3();
-  return function distanceToSegment(segment, target1 = null, target2 = null) {
-    const { start, end } = segment;
-    const points = this.points;
-    let distSq;
-    let closestDistanceSq = Infinity;
-    for (let i = 0; i < 3; i++) {
-      const nexti = (i + 1) % 3;
-      edge.start.copy(points[i]);
-      edge.end.copy(points[nexti]);
-      closestPointsSegmentToSegment(edge, segment, point1, point2);
-      distSq = point1.distanceToSquared(point2);
-      if (distSq < closestDistanceSq) {
-        closestDistanceSq = distSq;
-        if (target1) target1.copy(point1);
-        if (target2) target2.copy(point2);
-      }
-    }
-    this.closestPointToPoint(start, point1);
-    distSq = start.distanceToSquared(point1);
-    if (distSq < closestDistanceSq) {
-      closestDistanceSq = distSq;
-      if (target1) target1.copy(point1);
-      if (target2) target2.copy(start);
-    }
-    this.closestPointToPoint(end, point1);
-    distSq = end.distanceToSquared(point1);
-    if (distSq < closestDistanceSq) {
-      closestDistanceSq = distSq;
-      if (target1) target1.copy(point1);
-      if (target2) target2.copy(end);
-    }
-    return Math.sqrt(closestDistanceSq);
-  };
-})();
-ExtendedTriangle.prototype.intersectsTriangle = (function() {
-  const saTri2 = new ExtendedTriangle();
-  const arr1 = new Array(3);
-  const arr2 = new Array(3);
-  const cachedSatBounds = new SeparatingAxisBounds();
-  const cachedSatBounds2 = new SeparatingAxisBounds();
-  const cachedAxis = new Vector3();
-  const dir = new Vector3();
-  const dir1 = new Vector3();
-  const dir2 = new Vector3();
-  const tempDir = new Vector3();
-  const edge = new Line3();
-  const edge1 = new Line3();
-  const edge2 = new Line3();
-  const tempPoint = new Vector3();
-  function triIntersectPlane(tri, plane, targetEdge) {
-    const points = tri.points;
-    let count = 0;
-    let startPointIntersection = -1;
-    for (let i = 0; i < 3; i++) {
-      const { start, end } = edge;
-      start.copy(points[i]);
-      end.copy(points[(i + 1) % 3]);
-      edge.delta(dir);
-      const startIntersects = isNearZero(plane.distanceToPoint(start));
-      if (isNearZero(plane.normal.dot(dir)) && startIntersects) {
-        targetEdge.copy(edge);
-        count = 2;
-        break;
-      }
-      const doesIntersect = plane.intersectLine(edge, tempPoint);
-      if (!doesIntersect && startIntersects) {
-        tempPoint.copy(start);
-      }
-      if ((doesIntersect || startIntersects) && !isNearZero(tempPoint.distanceTo(end))) {
-        if (count <= 1) {
-          const point = count === 1 ? targetEdge.start : targetEdge.end;
-          point.copy(tempPoint);
-          if (startIntersects) {
-            startPointIntersection = count;
-          }
-        } else if (count >= 2) {
-          const point = startPointIntersection === 1 ? targetEdge.start : targetEdge.end;
-          point.copy(tempPoint);
-          count = 2;
-          break;
-        }
-        count++;
-        if (count === 2 && startPointIntersection === -1) {
-          break;
-        }
-      }
-    }
-    return count;
-  }
-  return function intersectsTriangle(other, target = null, suppressLog = false) {
-    if (this.needsUpdate) {
-      this.update();
-    }
-    if (!other.isExtendedTriangle) {
-      saTri2.copy(other);
-      saTri2.update();
-      other = saTri2;
-    } else if (other.needsUpdate) {
-      other.update();
-    }
-    const plane1 = this.plane;
-    const plane2 = other.plane;
-    if (Math.abs(plane1.normal.dot(plane2.normal)) > 1 - 1e-10) {
-      const satBounds1 = this.satBounds;
-      const satAxes1 = this.satAxes;
-      arr2[0] = other.a;
-      arr2[1] = other.b;
-      arr2[2] = other.c;
-      for (let i = 0; i < 4; i++) {
-        const sb = satBounds1[i];
-        const sa = satAxes1[i];
-        cachedSatBounds.setFromPoints(sa, arr2);
-        if (sb.isSeparated(cachedSatBounds)) return false;
-      }
-      const satBounds2 = other.satBounds;
-      const satAxes2 = other.satAxes;
-      arr1[0] = this.a;
-      arr1[1] = this.b;
-      arr1[2] = this.c;
-      for (let i = 0; i < 4; i++) {
-        const sb = satBounds2[i];
-        const sa = satAxes2[i];
-        cachedSatBounds.setFromPoints(sa, arr1);
-        if (sb.isSeparated(cachedSatBounds)) return false;
-      }
-      for (let i = 0; i < 4; i++) {
-        const sa1 = satAxes1[i];
-        for (let i2 = 0; i2 < 4; i2++) {
-          const sa2 = satAxes2[i2];
-          cachedAxis.crossVectors(sa1, sa2);
-          cachedSatBounds.setFromPoints(cachedAxis, arr1);
-          cachedSatBounds2.setFromPoints(cachedAxis, arr2);
-          if (cachedSatBounds.isSeparated(cachedSatBounds2)) return false;
-        }
-      }
-      if (target) {
-        if (!suppressLog) {
-          console.warn("ExtendedTriangle.intersectsTriangle: Triangles are coplanar which does not support an output edge. Setting edge to 0, 0, 0.");
-        }
-        target.start.set(0, 0, 0);
-        target.end.set(0, 0, 0);
-      }
-      return true;
-    } else {
-      const count1 = triIntersectPlane(this, plane2, edge1);
-      if (count1 === 1 && other.containsPoint(edge1.end)) {
-        if (target) {
-          target.start.copy(edge1.end);
-          target.end.copy(edge1.end);
-        }
-        return true;
-      } else if (count1 !== 2) {
-        return false;
-      }
-      const count2 = triIntersectPlane(other, plane1, edge2);
-      if (count2 === 1 && this.containsPoint(edge2.end)) {
-        if (target) {
-          target.start.copy(edge2.end);
-          target.end.copy(edge2.end);
-        }
-        return true;
-      } else if (count2 !== 2) {
-        return false;
-      }
-      edge1.delta(dir1);
-      edge2.delta(dir2);
-      if (dir1.dot(dir2) < 0) {
-        let tmp = edge2.start;
-        edge2.start = edge2.end;
-        edge2.end = tmp;
-      }
-      const s1 = edge1.start.dot(dir1);
-      const e1 = edge1.end.dot(dir1);
-      const s2 = edge2.start.dot(dir1);
-      const e2 = edge2.end.dot(dir1);
-      const separated1 = e1 < s2;
-      const separated2 = s1 < e2;
-      if (s1 !== e2 && s2 !== e1 && separated1 === separated2) {
-        return false;
-      }
-      if (target) {
-        tempDir.subVectors(edge1.start, edge2.start);
-        if (tempDir.dot(dir1) > 0) {
-          target.start.copy(edge1.start);
-        } else {
-          target.start.copy(edge2.start);
-        }
-        tempDir.subVectors(edge1.end, edge2.end);
-        if (tempDir.dot(dir1) < 0) {
-          target.end.copy(edge1.end);
-        } else {
-          target.end.copy(edge2.end);
-        }
-      }
-      return true;
-    }
-  };
-})();
-ExtendedTriangle.prototype.distanceToPoint = (function() {
-  const target = new Vector3();
-  return function distanceToPoint(point) {
-    this.closestPointToPoint(point, target);
-    return point.distanceTo(target);
-  };
-})();
-ExtendedTriangle.prototype.distanceToTriangle = (function() {
-  const point = new Vector3();
-  const point2 = new Vector3();
-  const cornerFields = ["a", "b", "c"];
-  const line1 = new Line3();
-  const line2 = new Line3();
-  return function distanceToTriangle(other, target1 = null, target2 = null) {
-    const lineTarget = target1 || target2 ? line1 : null;
-    if (this.intersectsTriangle(other, lineTarget)) {
-      if (target1 || target2) {
-        if (target1) lineTarget.getCenter(target1);
-        if (target2) lineTarget.getCenter(target2);
-      }
-      return 0;
-    }
-    let closestDistanceSq = Infinity;
-    for (let i = 0; i < 3; i++) {
-      let dist;
-      const field = cornerFields[i];
-      const otherVec = other[field];
-      this.closestPointToPoint(otherVec, point);
-      dist = otherVec.distanceToSquared(point);
-      if (dist < closestDistanceSq) {
-        closestDistanceSq = dist;
-        if (target1) target1.copy(point);
-        if (target2) target2.copy(otherVec);
-      }
-      const thisVec = this[field];
-      other.closestPointToPoint(thisVec, point);
-      dist = thisVec.distanceToSquared(point);
-      if (dist < closestDistanceSq) {
-        closestDistanceSq = dist;
-        if (target1) target1.copy(thisVec);
-        if (target2) target2.copy(point);
-      }
-    }
-    for (let i = 0; i < 3; i++) {
-      const f11 = cornerFields[i];
-      const f12 = cornerFields[(i + 1) % 3];
-      line1.set(this[f11], this[f12]);
-      for (let i2 = 0; i2 < 3; i2++) {
-        const f21 = cornerFields[i2];
-        const f22 = cornerFields[(i2 + 1) % 3];
-        line2.set(other[f21], other[f22]);
-        closestPointsSegmentToSegment(line1, line2, point, point2);
-        const dist = point.distanceToSquared(point2);
-        if (dist < closestDistanceSq) {
-          closestDistanceSq = dist;
-          if (target1) target1.copy(point);
-          if (target2) target2.copy(point2);
-        }
-      }
-    }
-    return Math.sqrt(closestDistanceSq);
-  };
-})();
-class OrientedBox {
-  constructor(min, max2, matrix) {
-    this.isOrientedBox = true;
-    this.min = new Vector3();
-    this.max = new Vector3();
-    this.matrix = new Matrix4();
-    this.invMatrix = new Matrix4();
-    this.points = new Array(8).fill().map(() => new Vector3());
-    this.satAxes = new Array(3).fill().map(() => new Vector3());
-    this.satBounds = new Array(3).fill().map(() => new SeparatingAxisBounds());
-    this.alignedSatBounds = new Array(3).fill().map(() => new SeparatingAxisBounds());
-    this.needsUpdate = false;
-    if (min) this.min.copy(min);
-    if (max2) this.max.copy(max2);
-    if (matrix) this.matrix.copy(matrix);
-  }
-  set(min, max2, matrix) {
-    this.min.copy(min);
-    this.max.copy(max2);
-    this.matrix.copy(matrix);
-    this.needsUpdate = true;
-  }
-  copy(other) {
-    this.min.copy(other.min);
-    this.max.copy(other.max);
-    this.matrix.copy(other.matrix);
-    this.needsUpdate = true;
-  }
-}
-OrientedBox.prototype.update = /* @__PURE__ */ (function() {
-  return function update2() {
-    const matrix = this.matrix;
-    const min = this.min;
-    const max2 = this.max;
-    const points = this.points;
-    for (let x = 0; x <= 1; x++) {
-      for (let y = 0; y <= 1; y++) {
-        for (let z = 0; z <= 1; z++) {
-          const i = (1 << 0) * x | (1 << 1) * y | (1 << 2) * z;
-          const v = points[i];
-          v.x = x ? max2.x : min.x;
-          v.y = y ? max2.y : min.y;
-          v.z = z ? max2.z : min.z;
-          v.applyMatrix4(matrix);
-        }
-      }
-    }
-    const satBounds = this.satBounds;
-    const satAxes = this.satAxes;
-    const minVec = points[0];
-    for (let i = 0; i < 3; i++) {
-      const axis = satAxes[i];
-      const sb = satBounds[i];
-      const index = 1 << i;
-      const pi = points[index];
-      axis.subVectors(minVec, pi);
-      sb.setFromPoints(axis, points);
-    }
-    const alignedSatBounds = this.alignedSatBounds;
-    alignedSatBounds[0].setFromPointsField(points, "x");
-    alignedSatBounds[1].setFromPointsField(points, "y");
-    alignedSatBounds[2].setFromPointsField(points, "z");
-    this.invMatrix.copy(this.matrix).invert();
-    this.needsUpdate = false;
-  };
-})();
-OrientedBox.prototype.intersectsBox = (function() {
-  const aabbBounds = new SeparatingAxisBounds();
-  return function intersectsBox(box2) {
-    if (this.needsUpdate) {
-      this.update();
-    }
-    const min = box2.min;
-    const max2 = box2.max;
-    const satBounds = this.satBounds;
-    const satAxes = this.satAxes;
-    const alignedSatBounds = this.alignedSatBounds;
-    aabbBounds.min = min.x;
-    aabbBounds.max = max2.x;
-    if (alignedSatBounds[0].isSeparated(aabbBounds)) return false;
-    aabbBounds.min = min.y;
-    aabbBounds.max = max2.y;
-    if (alignedSatBounds[1].isSeparated(aabbBounds)) return false;
-    aabbBounds.min = min.z;
-    aabbBounds.max = max2.z;
-    if (alignedSatBounds[2].isSeparated(aabbBounds)) return false;
-    for (let i = 0; i < 3; i++) {
-      const axis = satAxes[i];
-      const sb = satBounds[i];
-      aabbBounds.setFromBox(axis, box2);
-      if (sb.isSeparated(aabbBounds)) return false;
-    }
-    return true;
-  };
-})();
-OrientedBox.prototype.intersectsTriangle = (function() {
-  const saTri = new ExtendedTriangle();
-  const pointsArr = new Array(3);
-  const cachedSatBounds = new SeparatingAxisBounds();
-  const cachedSatBounds2 = new SeparatingAxisBounds();
-  const cachedAxis = new Vector3();
-  return function intersectsTriangle(triangle3) {
-    if (this.needsUpdate) {
-      this.update();
-    }
-    if (!triangle3.isExtendedTriangle) {
-      saTri.copy(triangle3);
-      saTri.update();
-      triangle3 = saTri;
-    } else if (triangle3.needsUpdate) {
-      triangle3.update();
-    }
-    const satBounds = this.satBounds;
-    const satAxes = this.satAxes;
-    pointsArr[0] = triangle3.a;
-    pointsArr[1] = triangle3.b;
-    pointsArr[2] = triangle3.c;
-    for (let i = 0; i < 3; i++) {
-      const sb = satBounds[i];
-      const sa = satAxes[i];
-      cachedSatBounds.setFromPoints(sa, pointsArr);
-      if (sb.isSeparated(cachedSatBounds)) return false;
-    }
-    const triSatBounds = triangle3.satBounds;
-    const triSatAxes = triangle3.satAxes;
-    const points = this.points;
-    for (let i = 0; i < 3; i++) {
-      const sb = triSatBounds[i];
-      const sa = triSatAxes[i];
-      cachedSatBounds.setFromPoints(sa, points);
-      if (sb.isSeparated(cachedSatBounds)) return false;
-    }
-    for (let i = 0; i < 3; i++) {
-      const sa1 = satAxes[i];
-      for (let i2 = 0; i2 < 4; i2++) {
-        const sa2 = triSatAxes[i2];
-        cachedAxis.crossVectors(sa1, sa2);
-        cachedSatBounds.setFromPoints(cachedAxis, pointsArr);
-        cachedSatBounds2.setFromPoints(cachedAxis, points);
-        if (cachedSatBounds.isSeparated(cachedSatBounds2)) return false;
-      }
-    }
-    return true;
-  };
-})();
-OrientedBox.prototype.closestPointToPoint = /* @__PURE__ */ (function() {
-  return function closestPointToPoint2(point, target1) {
-    if (this.needsUpdate) {
-      this.update();
-    }
-    target1.copy(point).applyMatrix4(this.invMatrix).clamp(this.min, this.max).applyMatrix4(this.matrix);
-    return target1;
-  };
-})();
-OrientedBox.prototype.distanceToPoint = (function() {
-  const target = new Vector3();
-  return function distanceToPoint(point) {
-    this.closestPointToPoint(point, target);
-    return point.distanceTo(target);
-  };
-})();
-OrientedBox.prototype.distanceToBox = (function() {
-  const xyzFields = ["x", "y", "z"];
-  const segments1 = new Array(12).fill().map(() => new Line3());
-  const segments2 = new Array(12).fill().map(() => new Line3());
-  const point1 = new Vector3();
-  const point2 = new Vector3();
-  return function distanceToBox(box2, threshold = 0, target1 = null, target2 = null) {
-    if (this.needsUpdate) {
-      this.update();
-    }
-    if (this.intersectsBox(box2)) {
-      if (target1 || target2) {
-        box2.getCenter(point2);
-        this.closestPointToPoint(point2, point1);
-        box2.closestPointToPoint(point1, point2);
-        if (target1) target1.copy(point1);
-        if (target2) target2.copy(point2);
-      }
-      return 0;
-    }
-    const threshold2 = threshold * threshold;
-    const min = box2.min;
-    const max2 = box2.max;
-    const points = this.points;
-    let closestDistanceSq = Infinity;
-    for (let i = 0; i < 8; i++) {
-      const p2 = points[i];
-      point2.copy(p2).clamp(min, max2);
-      const dist = p2.distanceToSquared(point2);
-      if (dist < closestDistanceSq) {
-        closestDistanceSq = dist;
-        if (target1) target1.copy(p2);
-        if (target2) target2.copy(point2);
-        if (dist < threshold2) return Math.sqrt(dist);
-      }
-    }
-    let count = 0;
-    for (let i = 0; i < 3; i++) {
-      for (let i1 = 0; i1 <= 1; i1++) {
-        for (let i2 = 0; i2 <= 1; i2++) {
-          const nextIndex = (i + 1) % 3;
-          const nextIndex2 = (i + 2) % 3;
-          const index = i1 << nextIndex | i2 << nextIndex2;
-          const index2 = 1 << i | i1 << nextIndex | i2 << nextIndex2;
-          const p1 = points[index];
-          const p2 = points[index2];
-          const line1 = segments1[count];
-          line1.set(p1, p2);
-          const f1 = xyzFields[i];
-          const f2 = xyzFields[nextIndex];
-          const f3 = xyzFields[nextIndex2];
-          const line2 = segments2[count];
-          const start = line2.start;
-          const end = line2.end;
-          start[f1] = min[f1];
-          start[f2] = i1 ? min[f2] : max2[f2];
-          start[f3] = i2 ? min[f3] : max2[f2];
-          end[f1] = max2[f1];
-          end[f2] = i1 ? min[f2] : max2[f2];
-          end[f3] = i2 ? min[f3] : max2[f2];
-          count++;
-        }
-      }
-    }
-    for (let x = 0; x <= 1; x++) {
-      for (let y = 0; y <= 1; y++) {
-        for (let z = 0; z <= 1; z++) {
-          point2.x = x ? max2.x : min.x;
-          point2.y = y ? max2.y : min.y;
-          point2.z = z ? max2.z : min.z;
-          this.closestPointToPoint(point2, point1);
-          const dist = point2.distanceToSquared(point1);
-          if (dist < closestDistanceSq) {
-            closestDistanceSq = dist;
-            if (target1) target1.copy(point1);
-            if (target2) target2.copy(point2);
-            if (dist < threshold2) return Math.sqrt(dist);
-          }
-        }
-      }
-    }
-    for (let i = 0; i < 12; i++) {
-      const l1 = segments1[i];
-      for (let i2 = 0; i2 < 12; i2++) {
-        const l2 = segments2[i2];
-        closestPointsSegmentToSegment(l1, l2, point1, point2);
-        const dist = point1.distanceToSquared(point2);
-        if (dist < closestDistanceSq) {
-          closestDistanceSq = dist;
-          if (target1) target1.copy(point1);
-          if (target2) target2.copy(point2);
-          if (dist < threshold2) return Math.sqrt(dist);
-        }
-      }
-    }
-    return Math.sqrt(closestDistanceSq);
-  };
-})();
-class PrimitivePool {
-  constructor(getNewPrimitive) {
-    this._getNewPrimitive = getNewPrimitive;
-    this._primitives = [];
-  }
-  getPrimitive() {
-    const primitives = this._primitives;
-    if (primitives.length === 0) {
-      return this._getNewPrimitive();
-    } else {
-      return primitives.pop();
-    }
-  }
-  releasePrimitive(primitive) {
-    this._primitives.push(primitive);
-  }
-}
-class ExtendedTrianglePoolBase extends PrimitivePool {
-  constructor() {
-    super(() => new ExtendedTriangle());
-  }
-}
-const ExtendedTrianglePool = /* @__PURE__ */ new ExtendedTrianglePoolBase();
-class _BufferStack {
-  constructor() {
-    this.float32Array = null;
-    this.uint16Array = null;
-    this.uint32Array = null;
-    const stack = [];
-    let prevBuffer = null;
-    this.setBuffer = (buffer) => {
-      if (prevBuffer) {
-        stack.push(prevBuffer);
-      }
-      prevBuffer = buffer;
-      this.float32Array = new Float32Array(buffer);
-      this.uint16Array = new Uint16Array(buffer);
-      this.uint32Array = new Uint32Array(buffer);
-    };
-    this.clearBuffer = () => {
-      prevBuffer = null;
-      this.float32Array = null;
-      this.uint16Array = null;
-      this.uint32Array = null;
-      if (stack.length !== 0) {
-        this.setBuffer(stack.pop());
-      }
-    };
-  }
-}
-const BufferStack = new _BufferStack();
-let _box1, _box2;
-const boxStack = [];
-const boxPool = /* @__PURE__ */ new PrimitivePool(() => new Box3());
-function shapecast(bvh, root, intersectsBounds, intersectsRange, boundsTraverseOrder, byteOffset) {
-  _box1 = boxPool.getPrimitive();
-  _box2 = boxPool.getPrimitive();
-  boxStack.push(_box1, _box2);
-  BufferStack.setBuffer(bvh._roots[root]);
-  const result = shapecastTraverse(0, bvh.geometry, intersectsBounds, intersectsRange, boundsTraverseOrder, byteOffset);
-  BufferStack.clearBuffer();
-  boxPool.releasePrimitive(_box1);
-  boxPool.releasePrimitive(_box2);
-  boxStack.pop();
-  boxStack.pop();
-  const length = boxStack.length;
-  if (length > 0) {
-    _box2 = boxStack[length - 1];
-    _box1 = boxStack[length - 2];
-  }
-  return result;
-}
-function shapecastTraverse(nodeIndex32, geometry, intersectsBoundsFunc, intersectsRangeFunc, nodeScoreFunc = null, nodeIndexByteOffset = 0, depth = 0) {
-  const { float32Array: float32Array2, uint16Array: uint16Array2, uint32Array: uint32Array2 } = BufferStack;
-  let nodeIndex16 = nodeIndex32 * 2;
-  const isLeaf = IS_LEAF(nodeIndex16, uint16Array2);
-  if (isLeaf) {
-    const offset = OFFSET(nodeIndex32, uint32Array2);
-    const count = COUNT(nodeIndex16, uint16Array2);
-    arrayToBox(BOUNDING_DATA_INDEX(nodeIndex32), float32Array2, _box1);
-    return intersectsRangeFunc(offset, count, false, depth, nodeIndexByteOffset + nodeIndex32, _box1);
-  } else {
-    let getLeftOffset = function(nodeIndex322) {
-      const { uint16Array: uint16Array3, uint32Array: uint32Array3 } = BufferStack;
-      let nodeIndex162 = nodeIndex322 * 2;
-      while (!IS_LEAF(nodeIndex162, uint16Array3)) {
-        nodeIndex322 = LEFT_NODE(nodeIndex322);
-        nodeIndex162 = nodeIndex322 * 2;
-      }
-      return OFFSET(nodeIndex322, uint32Array3);
-    }, getRightEndOffset = function(nodeIndex322) {
-      const { uint16Array: uint16Array3, uint32Array: uint32Array3 } = BufferStack;
-      let nodeIndex162 = nodeIndex322 * 2;
-      while (!IS_LEAF(nodeIndex162, uint16Array3)) {
-        nodeIndex322 = RIGHT_NODE(nodeIndex322, uint32Array3);
-        nodeIndex162 = nodeIndex322 * 2;
-      }
-      return OFFSET(nodeIndex322, uint32Array3) + COUNT(nodeIndex162, uint16Array3);
-    };
-    const left = LEFT_NODE(nodeIndex32);
-    const right = RIGHT_NODE(nodeIndex32, uint32Array2);
-    let c1 = left;
-    let c2 = right;
-    let score1, score2;
-    let box1, box2;
-    if (nodeScoreFunc) {
-      box1 = _box1;
-      box2 = _box2;
-      arrayToBox(BOUNDING_DATA_INDEX(c1), float32Array2, box1);
-      arrayToBox(BOUNDING_DATA_INDEX(c2), float32Array2, box2);
-      score1 = nodeScoreFunc(box1);
-      score2 = nodeScoreFunc(box2);
-      if (score2 < score1) {
-        c1 = right;
-        c2 = left;
-        const temp5 = score1;
-        score1 = score2;
-        score2 = temp5;
-        box1 = box2;
-      }
-    }
-    if (!box1) {
-      box1 = _box1;
-      arrayToBox(BOUNDING_DATA_INDEX(c1), float32Array2, box1);
-    }
-    const isC1Leaf = IS_LEAF(c1 * 2, uint16Array2);
-    const c1Intersection = intersectsBoundsFunc(box1, isC1Leaf, score1, depth + 1, nodeIndexByteOffset + c1);
-    let c1StopTraversal;
-    if (c1Intersection === CONTAINED) {
-      const offset = getLeftOffset(c1);
-      const end = getRightEndOffset(c1);
-      const count = end - offset;
-      c1StopTraversal = intersectsRangeFunc(offset, count, true, depth + 1, nodeIndexByteOffset + c1, box1);
-    } else {
-      c1StopTraversal = c1Intersection && shapecastTraverse(
-        c1,
-        geometry,
-        intersectsBoundsFunc,
-        intersectsRangeFunc,
-        nodeScoreFunc,
-        nodeIndexByteOffset,
-        depth + 1
-      );
-    }
-    if (c1StopTraversal) return true;
-    box2 = _box2;
-    arrayToBox(BOUNDING_DATA_INDEX(c2), float32Array2, box2);
-    const isC2Leaf = IS_LEAF(c2 * 2, uint16Array2);
-    const c2Intersection = intersectsBoundsFunc(box2, isC2Leaf, score2, depth + 1, nodeIndexByteOffset + c2);
-    let c2StopTraversal;
-    if (c2Intersection === CONTAINED) {
-      const offset = getLeftOffset(c2);
-      const end = getRightEndOffset(c2);
-      const count = end - offset;
-      c2StopTraversal = intersectsRangeFunc(offset, count, true, depth + 1, nodeIndexByteOffset + c2, box2);
-    } else {
-      c2StopTraversal = c2Intersection && shapecastTraverse(
-        c2,
-        geometry,
-        intersectsBoundsFunc,
-        intersectsRangeFunc,
-        nodeScoreFunc,
-        nodeIndexByteOffset,
-        depth + 1
-      );
-    }
-    if (c2StopTraversal) return true;
-    return false;
-  }
-}
-const temp = /* @__PURE__ */ new Vector3();
-const temp1$2 = /* @__PURE__ */ new Vector3();
-function closestPointToPoint(bvh, point, target = {}, minThreshold = 0, maxThreshold = Infinity) {
-  const minThresholdSq = minThreshold * minThreshold;
-  const maxThresholdSq = maxThreshold * maxThreshold;
-  let closestDistanceSq = Infinity;
-  let closestDistanceTriIndex = null;
-  bvh.shapecast(
-    {
-      boundsTraverseOrder: (box2) => {
-        temp.copy(point).clamp(box2.min, box2.max);
-        return temp.distanceToSquared(point);
-      },
-      intersectsBounds: (box2, isLeaf, score) => {
-        return score < closestDistanceSq && score < maxThresholdSq;
-      },
-      intersectsTriangle: (tri, triIndex) => {
-        tri.closestPointToPoint(point, temp);
-        const distSq = point.distanceToSquared(temp);
-        if (distSq < closestDistanceSq) {
-          temp1$2.copy(temp);
-          closestDistanceSq = distSq;
-          closestDistanceTriIndex = triIndex;
-        }
-        if (distSq < minThresholdSq) {
-          return true;
-        } else {
-          return false;
-        }
-      }
-    }
-  );
-  if (closestDistanceSq === Infinity) return null;
-  const closestDistance = Math.sqrt(closestDistanceSq);
-  if (!target.point) target.point = temp1$2.clone();
-  else target.point.copy(temp1$2);
-  target.distance = closestDistance, target.faceIndex = closestDistanceTriIndex;
-  return target;
-}
-const IS_GT_REVISION_169 = parseInt(REVISION) >= 169;
-const _vA = /* @__PURE__ */ new Vector3();
-const _vB = /* @__PURE__ */ new Vector3();
-const _vC = /* @__PURE__ */ new Vector3();
-const _uvA = /* @__PURE__ */ new Vector2();
-const _uvB = /* @__PURE__ */ new Vector2();
-const _uvC = /* @__PURE__ */ new Vector2();
-const _normalA = /* @__PURE__ */ new Vector3();
-const _normalB = /* @__PURE__ */ new Vector3();
-const _normalC = /* @__PURE__ */ new Vector3();
-const _intersectionPoint = /* @__PURE__ */ new Vector3();
-function checkIntersection(ray2, pA, pB, pC, point, side, near, far) {
-  let intersect;
-  if (side === BackSide) {
-    intersect = ray2.intersectTriangle(pC, pB, pA, true, point);
-  } else {
-    intersect = ray2.intersectTriangle(pA, pB, pC, side !== DoubleSide, point);
-  }
-  if (intersect === null) return null;
-  const distance = ray2.origin.distanceTo(point);
-  if (distance < near || distance > far) return null;
-  return {
-    distance,
-    point: point.clone()
-  };
-}
-function checkBufferGeometryIntersection(ray2, position, normal, uv, uv1, a2, b2, c2, side, near, far) {
-  _vA.fromBufferAttribute(position, a2);
-  _vB.fromBufferAttribute(position, b2);
-  _vC.fromBufferAttribute(position, c2);
-  const intersection = checkIntersection(ray2, _vA, _vB, _vC, _intersectionPoint, side, near, far);
-  if (intersection) {
-    const barycoord = new Vector3();
-    Triangle.getBarycoord(_intersectionPoint, _vA, _vB, _vC, barycoord);
-    if (uv) {
-      _uvA.fromBufferAttribute(uv, a2);
-      _uvB.fromBufferAttribute(uv, b2);
-      _uvC.fromBufferAttribute(uv, c2);
-      intersection.uv = Triangle.getInterpolation(_intersectionPoint, _vA, _vB, _vC, _uvA, _uvB, _uvC, new Vector2());
-    }
-    if (uv1) {
-      _uvA.fromBufferAttribute(uv1, a2);
-      _uvB.fromBufferAttribute(uv1, b2);
-      _uvC.fromBufferAttribute(uv1, c2);
-      intersection.uv1 = Triangle.getInterpolation(_intersectionPoint, _vA, _vB, _vC, _uvA, _uvB, _uvC, new Vector2());
-    }
-    if (normal) {
-      _normalA.fromBufferAttribute(normal, a2);
-      _normalB.fromBufferAttribute(normal, b2);
-      _normalC.fromBufferAttribute(normal, c2);
-      intersection.normal = Triangle.getInterpolation(_intersectionPoint, _vA, _vB, _vC, _normalA, _normalB, _normalC, new Vector3());
-      if (intersection.normal.dot(ray2.direction) > 0) {
-        intersection.normal.multiplyScalar(-1);
-      }
-    }
-    const face = {
-      a: a2,
-      b: b2,
-      c: c2,
-      normal: new Vector3(),
-      materialIndex: 0
-    };
-    Triangle.getNormal(_vA, _vB, _vC, face.normal);
-    intersection.face = face;
-    intersection.faceIndex = a2;
-    if (IS_GT_REVISION_169) {
-      intersection.barycoord = barycoord;
-    }
-  }
-  return intersection;
-}
-function intersectTri(geo, side, ray2, tri, intersections, near, far) {
-  const triOffset = tri * 3;
-  let a2 = triOffset + 0;
-  let b2 = triOffset + 1;
-  let c2 = triOffset + 2;
-  const index = geo.index;
-  if (geo.index) {
-    a2 = index.getX(a2);
-    b2 = index.getX(b2);
-    c2 = index.getX(c2);
-  }
-  const { position, normal, uv, uv1 } = geo.attributes;
-  const intersection = checkBufferGeometryIntersection(ray2, position, normal, uv, uv1, a2, b2, c2, side, near, far);
-  if (intersection) {
-    intersection.faceIndex = tri;
-    if (intersections) intersections.push(intersection);
-    return intersection;
-  }
-  return null;
-}
-function setTriangle(tri, i, index, pos) {
-  const ta = tri.a;
-  const tb = tri.b;
-  const tc = tri.c;
-  let i0 = i;
-  let i1 = i + 1;
-  let i2 = i + 2;
-  if (index) {
-    i0 = index.getX(i0);
-    i1 = index.getX(i1);
-    i2 = index.getX(i2);
-  }
-  ta.x = pos.getX(i0);
-  ta.y = pos.getY(i0);
-  ta.z = pos.getZ(i0);
-  tb.x = pos.getX(i1);
-  tb.y = pos.getY(i1);
-  tb.z = pos.getZ(i1);
-  tc.x = pos.getX(i2);
-  tc.y = pos.getY(i2);
-  tc.z = pos.getZ(i2);
-}
-function intersectTris(bvh, side, ray2, offset, count, intersections, near, far) {
-  const { geometry, _indirectBuffer } = bvh;
-  for (let i = offset, end = offset + count; i < end; i++) {
-    intersectTri(geometry, side, ray2, i, intersections, near, far);
-  }
-}
-function intersectClosestTri(bvh, side, ray2, offset, count, near, far) {
-  const { geometry, _indirectBuffer } = bvh;
-  let dist = Infinity;
-  let res = null;
-  for (let i = offset, end = offset + count; i < end; i++) {
-    let intersection;
-    intersection = intersectTri(geometry, side, ray2, i, null, near, far);
-    if (intersection && intersection.distance < dist) {
-      res = intersection;
-      dist = intersection.distance;
-    }
-  }
-  return res;
-}
-function iterateOverTriangles(offset, count, bvh, intersectsTriangleFunc, contained, depth, triangle3) {
-  const { geometry } = bvh;
-  const { index } = geometry;
-  const pos = geometry.attributes.position;
-  for (let i = offset, l2 = count + offset; i < l2; i++) {
-    let tri;
-    tri = i;
-    setTriangle(triangle3, tri * 3, index, pos);
-    triangle3.needsUpdate = true;
-    if (intersectsTriangleFunc(triangle3, tri, contained, depth)) {
-      return true;
-    }
-  }
-  return false;
-}
-function refit(bvh, nodeIndices = null) {
-  if (nodeIndices && Array.isArray(nodeIndices)) {
-    nodeIndices = new Set(nodeIndices);
-  }
-  const geometry = bvh.geometry;
-  const indexArr = geometry.index ? geometry.index.array : null;
-  const posAttr = geometry.attributes.position;
-  let buffer, uint32Array2, uint16Array2, float32Array2;
-  let byteOffset = 0;
-  const roots = bvh._roots;
-  for (let i = 0, l2 = roots.length; i < l2; i++) {
-    buffer = roots[i];
-    uint32Array2 = new Uint32Array(buffer);
-    uint16Array2 = new Uint16Array(buffer);
-    float32Array2 = new Float32Array(buffer);
-    _traverse2(0, byteOffset);
-    byteOffset += buffer.byteLength;
-  }
-  function _traverse2(node32Index, byteOffset2, force = false) {
-    const node16Index = node32Index * 2;
-    const isLeaf = uint16Array2[node16Index + 15] === IS_LEAFNODE_FLAG;
-    if (isLeaf) {
-      const offset = uint32Array2[node32Index + 6];
-      const count = uint16Array2[node16Index + 14];
-      let minx = Infinity;
-      let miny = Infinity;
-      let minz = Infinity;
-      let maxx = -Infinity;
-      let maxy = -Infinity;
-      let maxz = -Infinity;
-      for (let i = 3 * offset, l2 = 3 * (offset + count); i < l2; i++) {
-        let index = indexArr[i];
-        const x = posAttr.getX(index);
-        const y = posAttr.getY(index);
-        const z = posAttr.getZ(index);
-        if (x < minx) minx = x;
-        if (x > maxx) maxx = x;
-        if (y < miny) miny = y;
-        if (y > maxy) maxy = y;
-        if (z < minz) minz = z;
-        if (z > maxz) maxz = z;
-      }
-      if (float32Array2[node32Index + 0] !== minx || float32Array2[node32Index + 1] !== miny || float32Array2[node32Index + 2] !== minz || float32Array2[node32Index + 3] !== maxx || float32Array2[node32Index + 4] !== maxy || float32Array2[node32Index + 5] !== maxz) {
-        float32Array2[node32Index + 0] = minx;
-        float32Array2[node32Index + 1] = miny;
-        float32Array2[node32Index + 2] = minz;
-        float32Array2[node32Index + 3] = maxx;
-        float32Array2[node32Index + 4] = maxy;
-        float32Array2[node32Index + 5] = maxz;
-        return true;
-      } else {
-        return false;
-      }
-    } else {
-      const left = node32Index + 8;
-      const right = uint32Array2[node32Index + 6];
-      const offsetLeft = left + byteOffset2;
-      const offsetRight = right + byteOffset2;
-      let forceChildren = force;
-      let includesLeft = false;
-      let includesRight = false;
-      if (nodeIndices) {
-        if (!forceChildren) {
-          includesLeft = nodeIndices.has(offsetLeft);
-          includesRight = nodeIndices.has(offsetRight);
-          forceChildren = !includesLeft && !includesRight;
-        }
-      } else {
-        includesLeft = true;
-        includesRight = true;
-      }
-      const traverseLeft = forceChildren || includesLeft;
-      const traverseRight = forceChildren || includesRight;
-      let leftChange = false;
-      if (traverseLeft) {
-        leftChange = _traverse2(left, byteOffset2, forceChildren);
-      }
-      let rightChange = false;
-      if (traverseRight) {
-        rightChange = _traverse2(right, byteOffset2, forceChildren);
-      }
-      const didChange = leftChange || rightChange;
-      if (didChange) {
-        for (let i = 0; i < 3; i++) {
-          const lefti = left + i;
-          const righti = right + i;
-          const minLeftValue = float32Array2[lefti];
-          const maxLeftValue = float32Array2[lefti + 3];
-          const minRightValue = float32Array2[righti];
-          const maxRightValue = float32Array2[righti + 3];
-          float32Array2[node32Index + i] = minLeftValue < minRightValue ? minLeftValue : minRightValue;
-          float32Array2[node32Index + i + 3] = maxLeftValue > maxRightValue ? maxLeftValue : maxRightValue;
-        }
-      }
-      return didChange;
-    }
-  }
-}
-function intersectRay(nodeIndex32, array, ray2, near, far) {
-  let tmin, tmax, tymin, tymax, tzmin, tzmax;
-  const invdirx = 1 / ray2.direction.x, invdiry = 1 / ray2.direction.y, invdirz = 1 / ray2.direction.z;
-  const ox = ray2.origin.x;
-  const oy = ray2.origin.y;
-  const oz = ray2.origin.z;
-  let minx = array[nodeIndex32];
-  let maxx = array[nodeIndex32 + 3];
-  let miny = array[nodeIndex32 + 1];
-  let maxy = array[nodeIndex32 + 3 + 1];
-  let minz = array[nodeIndex32 + 2];
-  let maxz = array[nodeIndex32 + 3 + 2];
-  if (invdirx >= 0) {
-    tmin = (minx - ox) * invdirx;
-    tmax = (maxx - ox) * invdirx;
-  } else {
-    tmin = (maxx - ox) * invdirx;
-    tmax = (minx - ox) * invdirx;
-  }
-  if (invdiry >= 0) {
-    tymin = (miny - oy) * invdiry;
-    tymax = (maxy - oy) * invdiry;
-  } else {
-    tymin = (maxy - oy) * invdiry;
-    tymax = (miny - oy) * invdiry;
-  }
-  if (tmin > tymax || tymin > tmax) return false;
-  if (tymin > tmin || isNaN(tmin)) tmin = tymin;
-  if (tymax < tmax || isNaN(tmax)) tmax = tymax;
-  if (invdirz >= 0) {
-    tzmin = (minz - oz) * invdirz;
-    tzmax = (maxz - oz) * invdirz;
-  } else {
-    tzmin = (maxz - oz) * invdirz;
-    tzmax = (minz - oz) * invdirz;
-  }
-  if (tmin > tzmax || tzmin > tmax) return false;
-  if (tzmin > tmin || tmin !== tmin) tmin = tzmin;
-  if (tzmax < tmax || tmax !== tmax) tmax = tzmax;
-  return tmin <= far && tmax >= near;
-}
-function intersectTris_indirect(bvh, side, ray2, offset, count, intersections, near, far) {
-  const { geometry, _indirectBuffer } = bvh;
-  for (let i = offset, end = offset + count; i < end; i++) {
-    let vi = _indirectBuffer ? _indirectBuffer[i] : i;
-    intersectTri(geometry, side, ray2, vi, intersections, near, far);
-  }
-}
-function intersectClosestTri_indirect(bvh, side, ray2, offset, count, near, far) {
-  const { geometry, _indirectBuffer } = bvh;
-  let dist = Infinity;
-  let res = null;
-  for (let i = offset, end = offset + count; i < end; i++) {
-    let intersection;
-    intersection = intersectTri(geometry, side, ray2, _indirectBuffer ? _indirectBuffer[i] : i, null, near, far);
-    if (intersection && intersection.distance < dist) {
-      res = intersection;
-      dist = intersection.distance;
-    }
-  }
-  return res;
-}
-function iterateOverTriangles_indirect(offset, count, bvh, intersectsTriangleFunc, contained, depth, triangle3) {
-  const { geometry } = bvh;
-  const { index } = geometry;
-  const pos = geometry.attributes.position;
-  for (let i = offset, l2 = count + offset; i < l2; i++) {
-    let tri;
-    tri = bvh.resolveTriangleIndex(i);
-    setTriangle(triangle3, tri * 3, index, pos);
-    triangle3.needsUpdate = true;
-    if (intersectsTriangleFunc(triangle3, tri, contained, depth)) {
-      return true;
-    }
-  }
-  return false;
-}
-function raycast(bvh, root, side, ray2, intersects, near, far) {
-  BufferStack.setBuffer(bvh._roots[root]);
-  _raycast$1(0, bvh, side, ray2, intersects, near, far);
-  BufferStack.clearBuffer();
-}
-function _raycast$1(nodeIndex32, bvh, side, ray2, intersects, near, far) {
-  const { float32Array: float32Array2, uint16Array: uint16Array2, uint32Array: uint32Array2 } = BufferStack;
-  const nodeIndex16 = nodeIndex32 * 2;
-  const isLeaf = IS_LEAF(nodeIndex16, uint16Array2);
-  if (isLeaf) {
-    const offset = OFFSET(nodeIndex32, uint32Array2);
-    const count = COUNT(nodeIndex16, uint16Array2);
-    intersectTris(bvh, side, ray2, offset, count, intersects, near, far);
-  } else {
-    const leftIndex = LEFT_NODE(nodeIndex32);
-    if (intersectRay(leftIndex, float32Array2, ray2, near, far)) {
-      _raycast$1(leftIndex, bvh, side, ray2, intersects, near, far);
-    }
-    const rightIndex = RIGHT_NODE(nodeIndex32, uint32Array2);
-    if (intersectRay(rightIndex, float32Array2, ray2, near, far)) {
-      _raycast$1(rightIndex, bvh, side, ray2, intersects, near, far);
-    }
-  }
-}
-const _xyzFields$1 = ["x", "y", "z"];
-function raycastFirst(bvh, root, side, ray2, near, far) {
-  BufferStack.setBuffer(bvh._roots[root]);
-  const result = _raycastFirst$1(0, bvh, side, ray2, near, far);
-  BufferStack.clearBuffer();
-  return result;
-}
-function _raycastFirst$1(nodeIndex32, bvh, side, ray2, near, far) {
-  const { float32Array: float32Array2, uint16Array: uint16Array2, uint32Array: uint32Array2 } = BufferStack;
-  let nodeIndex16 = nodeIndex32 * 2;
-  const isLeaf = IS_LEAF(nodeIndex16, uint16Array2);
-  if (isLeaf) {
-    const offset = OFFSET(nodeIndex32, uint32Array2);
-    const count = COUNT(nodeIndex16, uint16Array2);
-    return intersectClosestTri(bvh, side, ray2, offset, count, near, far);
-  } else {
-    const splitAxis = SPLIT_AXIS(nodeIndex32, uint32Array2);
-    const xyzAxis = _xyzFields$1[splitAxis];
-    const rayDir = ray2.direction[xyzAxis];
-    const leftToRight = rayDir >= 0;
-    let c1, c2;
-    if (leftToRight) {
-      c1 = LEFT_NODE(nodeIndex32);
-      c2 = RIGHT_NODE(nodeIndex32, uint32Array2);
-    } else {
-      c1 = RIGHT_NODE(nodeIndex32, uint32Array2);
-      c2 = LEFT_NODE(nodeIndex32);
-    }
-    const c1Intersection = intersectRay(c1, float32Array2, ray2, near, far);
-    const c1Result = c1Intersection ? _raycastFirst$1(c1, bvh, side, ray2, near, far) : null;
-    if (c1Result) {
-      const point = c1Result.point[xyzAxis];
-      const isOutside = leftToRight ? point <= float32Array2[c2 + splitAxis] : (
-        // min bounding data
-        point >= float32Array2[c2 + splitAxis + 3]
-      );
-      if (isOutside) {
-        return c1Result;
-      }
-    }
-    const c2Intersection = intersectRay(c2, float32Array2, ray2, near, far);
-    const c2Result = c2Intersection ? _raycastFirst$1(c2, bvh, side, ray2, near, far) : null;
-    if (c1Result && c2Result) {
-      return c1Result.distance <= c2Result.distance ? c1Result : c2Result;
-    } else {
-      return c1Result || c2Result || null;
-    }
-  }
-}
-const boundingBox$1 = /* @__PURE__ */ new Box3();
-const triangle$1 = /* @__PURE__ */ new ExtendedTriangle();
-const triangle2$1 = /* @__PURE__ */ new ExtendedTriangle();
-const invertedMat$1 = /* @__PURE__ */ new Matrix4();
-const obb$4 = /* @__PURE__ */ new OrientedBox();
-const obb2$3 = /* @__PURE__ */ new OrientedBox();
-function intersectsGeometry(bvh, root, otherGeometry, geometryToBvh) {
-  BufferStack.setBuffer(bvh._roots[root]);
-  const result = _intersectsGeometry$1(0, bvh, otherGeometry, geometryToBvh);
-  BufferStack.clearBuffer();
-  return result;
-}
-function _intersectsGeometry$1(nodeIndex32, bvh, otherGeometry, geometryToBvh, cachedObb = null) {
-  const { float32Array: float32Array2, uint16Array: uint16Array2, uint32Array: uint32Array2 } = BufferStack;
-  let nodeIndex16 = nodeIndex32 * 2;
-  if (cachedObb === null) {
-    if (!otherGeometry.boundingBox) {
-      otherGeometry.computeBoundingBox();
-    }
-    obb$4.set(otherGeometry.boundingBox.min, otherGeometry.boundingBox.max, geometryToBvh);
-    cachedObb = obb$4;
-  }
-  const isLeaf = IS_LEAF(nodeIndex16, uint16Array2);
-  if (isLeaf) {
-    const thisGeometry = bvh.geometry;
-    const thisIndex = thisGeometry.index;
-    const thisPos = thisGeometry.attributes.position;
-    const index = otherGeometry.index;
-    const pos = otherGeometry.attributes.position;
-    const offset = OFFSET(nodeIndex32, uint32Array2);
-    const count = COUNT(nodeIndex16, uint16Array2);
-    invertedMat$1.copy(geometryToBvh).invert();
-    if (otherGeometry.boundsTree) {
-      arrayToBox(BOUNDING_DATA_INDEX(nodeIndex32), float32Array2, obb2$3);
-      obb2$3.matrix.copy(invertedMat$1);
-      obb2$3.needsUpdate = true;
-      const res = otherGeometry.boundsTree.shapecast({
-        intersectsBounds: (box2) => obb2$3.intersectsBox(box2),
-        intersectsTriangle: (tri) => {
-          tri.a.applyMatrix4(geometryToBvh);
-          tri.b.applyMatrix4(geometryToBvh);
-          tri.c.applyMatrix4(geometryToBvh);
-          tri.needsUpdate = true;
-          for (let i = offset * 3, l2 = (count + offset) * 3; i < l2; i += 3) {
-            setTriangle(triangle2$1, i, thisIndex, thisPos);
-            triangle2$1.needsUpdate = true;
-            if (tri.intersectsTriangle(triangle2$1)) {
-              return true;
-            }
-          }
-          return false;
-        }
-      });
-      return res;
-    } else {
-      for (let i = offset * 3, l2 = (count + offset) * 3; i < l2; i += 3) {
-        setTriangle(triangle$1, i, thisIndex, thisPos);
-        triangle$1.a.applyMatrix4(invertedMat$1);
-        triangle$1.b.applyMatrix4(invertedMat$1);
-        triangle$1.c.applyMatrix4(invertedMat$1);
-        triangle$1.needsUpdate = true;
-        for (let i2 = 0, l22 = index.count; i2 < l22; i2 += 3) {
-          setTriangle(triangle2$1, i2, index, pos);
-          triangle2$1.needsUpdate = true;
-          if (triangle$1.intersectsTriangle(triangle2$1)) {
-            return true;
-          }
-        }
-      }
-    }
-  } else {
-    const left = nodeIndex32 + 8;
-    const right = uint32Array2[nodeIndex32 + 6];
-    arrayToBox(BOUNDING_DATA_INDEX(left), float32Array2, boundingBox$1);
-    const leftIntersection = cachedObb.intersectsBox(boundingBox$1) && _intersectsGeometry$1(left, bvh, otherGeometry, geometryToBvh, cachedObb);
-    if (leftIntersection) return true;
-    arrayToBox(BOUNDING_DATA_INDEX(right), float32Array2, boundingBox$1);
-    const rightIntersection = cachedObb.intersectsBox(boundingBox$1) && _intersectsGeometry$1(right, bvh, otherGeometry, geometryToBvh, cachedObb);
-    if (rightIntersection) return true;
-    return false;
-  }
-}
-const tempMatrix$1 = /* @__PURE__ */ new Matrix4();
-const obb$3 = /* @__PURE__ */ new OrientedBox();
-const obb2$2 = /* @__PURE__ */ new OrientedBox();
-const temp1$1 = /* @__PURE__ */ new Vector3();
-const temp2$1 = /* @__PURE__ */ new Vector3();
-const temp3$1 = /* @__PURE__ */ new Vector3();
-const temp4$1 = /* @__PURE__ */ new Vector3();
-function closestPointToGeometry(bvh, otherGeometry, geometryToBvh, target1 = {}, target2 = {}, minThreshold = 0, maxThreshold = Infinity) {
-  if (!otherGeometry.boundingBox) {
-    otherGeometry.computeBoundingBox();
-  }
-  obb$3.set(otherGeometry.boundingBox.min, otherGeometry.boundingBox.max, geometryToBvh);
-  obb$3.needsUpdate = true;
-  const geometry = bvh.geometry;
-  const pos = geometry.attributes.position;
-  const index = geometry.index;
-  const otherPos = otherGeometry.attributes.position;
-  const otherIndex = otherGeometry.index;
-  const triangle3 = ExtendedTrianglePool.getPrimitive();
-  const triangle22 = ExtendedTrianglePool.getPrimitive();
-  let tempTarget1 = temp1$1;
-  let tempTargetDest1 = temp2$1;
-  let tempTarget2 = null;
-  let tempTargetDest2 = null;
-  if (target2) {
-    tempTarget2 = temp3$1;
-    tempTargetDest2 = temp4$1;
-  }
-  let closestDistance = Infinity;
-  let closestDistanceTriIndex = null;
-  let closestDistanceOtherTriIndex = null;
-  tempMatrix$1.copy(geometryToBvh).invert();
-  obb2$2.matrix.copy(tempMatrix$1);
-  bvh.shapecast(
-    {
-      boundsTraverseOrder: (box2) => {
-        return obb$3.distanceToBox(box2);
-      },
-      intersectsBounds: (box2, isLeaf, score) => {
-        if (score < closestDistance && score < maxThreshold) {
-          if (isLeaf) {
-            obb2$2.min.copy(box2.min);
-            obb2$2.max.copy(box2.max);
-            obb2$2.needsUpdate = true;
-          }
-          return true;
-        }
-        return false;
-      },
-      intersectsRange: (offset, count) => {
-        if (otherGeometry.boundsTree) {
-          const otherBvh = otherGeometry.boundsTree;
-          return otherBvh.shapecast({
-            boundsTraverseOrder: (box2) => {
-              return obb2$2.distanceToBox(box2);
-            },
-            intersectsBounds: (box2, isLeaf, score) => {
-              return score < closestDistance && score < maxThreshold;
-            },
-            intersectsRange: (otherOffset, otherCount) => {
-              for (let i2 = otherOffset, l2 = otherOffset + otherCount; i2 < l2; i2++) {
-                setTriangle(triangle22, 3 * i2, otherIndex, otherPos);
-                triangle22.a.applyMatrix4(geometryToBvh);
-                triangle22.b.applyMatrix4(geometryToBvh);
-                triangle22.c.applyMatrix4(geometryToBvh);
-                triangle22.needsUpdate = true;
-                for (let i = offset, l3 = offset + count; i < l3; i++) {
-                  setTriangle(triangle3, 3 * i, index, pos);
-                  triangle3.needsUpdate = true;
-                  const dist = triangle3.distanceToTriangle(triangle22, tempTarget1, tempTarget2);
-                  if (dist < closestDistance) {
-                    tempTargetDest1.copy(tempTarget1);
-                    if (tempTargetDest2) {
-                      tempTargetDest2.copy(tempTarget2);
-                    }
-                    closestDistance = dist;
-                    closestDistanceTriIndex = i;
-                    closestDistanceOtherTriIndex = i2;
-                  }
-                  if (dist < minThreshold) {
-                    return true;
-                  }
-                }
-              }
-            }
-          });
-        } else {
-          const triCount = getTriCount(otherGeometry);
-          for (let i2 = 0, l2 = triCount; i2 < l2; i2++) {
-            setTriangle(triangle22, 3 * i2, otherIndex, otherPos);
-            triangle22.a.applyMatrix4(geometryToBvh);
-            triangle22.b.applyMatrix4(geometryToBvh);
-            triangle22.c.applyMatrix4(geometryToBvh);
-            triangle22.needsUpdate = true;
-            for (let i = offset, l3 = offset + count; i < l3; i++) {
-              setTriangle(triangle3, 3 * i, index, pos);
-              triangle3.needsUpdate = true;
-              const dist = triangle3.distanceToTriangle(triangle22, tempTarget1, tempTarget2);
-              if (dist < closestDistance) {
-                tempTargetDest1.copy(tempTarget1);
-                if (tempTargetDest2) {
-                  tempTargetDest2.copy(tempTarget2);
-                }
-                closestDistance = dist;
-                closestDistanceTriIndex = i;
-                closestDistanceOtherTriIndex = i2;
-              }
-              if (dist < minThreshold) {
-                return true;
-              }
-            }
-          }
-        }
-      }
-    }
-  );
-  ExtendedTrianglePool.releasePrimitive(triangle3);
-  ExtendedTrianglePool.releasePrimitive(triangle22);
-  if (closestDistance === Infinity) {
-    return null;
-  }
-  if (!target1.point) {
-    target1.point = tempTargetDest1.clone();
-  } else {
-    target1.point.copy(tempTargetDest1);
-  }
-  target1.distance = closestDistance, target1.faceIndex = closestDistanceTriIndex;
-  if (target2) {
-    if (!target2.point) target2.point = tempTargetDest2.clone();
-    else target2.point.copy(tempTargetDest2);
-    target2.point.applyMatrix4(tempMatrix$1);
-    tempTargetDest1.applyMatrix4(tempMatrix$1);
-    target2.distance = tempTargetDest1.sub(target2.point).length();
-    target2.faceIndex = closestDistanceOtherTriIndex;
-  }
-  return target1;
-}
-function refit_indirect(bvh, nodeIndices = null) {
-  if (nodeIndices && Array.isArray(nodeIndices)) {
-    nodeIndices = new Set(nodeIndices);
-  }
-  const geometry = bvh.geometry;
-  const indexArr = geometry.index ? geometry.index.array : null;
-  const posAttr = geometry.attributes.position;
-  let buffer, uint32Array2, uint16Array2, float32Array2;
-  let byteOffset = 0;
-  const roots = bvh._roots;
-  for (let i = 0, l2 = roots.length; i < l2; i++) {
-    buffer = roots[i];
-    uint32Array2 = new Uint32Array(buffer);
-    uint16Array2 = new Uint16Array(buffer);
-    float32Array2 = new Float32Array(buffer);
-    _traverse2(0, byteOffset);
-    byteOffset += buffer.byteLength;
-  }
-  function _traverse2(node32Index, byteOffset2, force = false) {
-    const node16Index = node32Index * 2;
-    const isLeaf = uint16Array2[node16Index + 15] === IS_LEAFNODE_FLAG;
-    if (isLeaf) {
-      const offset = uint32Array2[node32Index + 6];
-      const count = uint16Array2[node16Index + 14];
-      let minx = Infinity;
-      let miny = Infinity;
-      let minz = Infinity;
-      let maxx = -Infinity;
-      let maxy = -Infinity;
-      let maxz = -Infinity;
-      for (let i = offset, l2 = offset + count; i < l2; i++) {
-        const t2 = 3 * bvh.resolveTriangleIndex(i);
-        for (let j2 = 0; j2 < 3; j2++) {
-          let index = t2 + j2;
-          index = indexArr ? indexArr[index] : index;
-          const x = posAttr.getX(index);
-          const y = posAttr.getY(index);
-          const z = posAttr.getZ(index);
-          if (x < minx) minx = x;
-          if (x > maxx) maxx = x;
-          if (y < miny) miny = y;
-          if (y > maxy) maxy = y;
-          if (z < minz) minz = z;
-          if (z > maxz) maxz = z;
-        }
-      }
-      if (float32Array2[node32Index + 0] !== minx || float32Array2[node32Index + 1] !== miny || float32Array2[node32Index + 2] !== minz || float32Array2[node32Index + 3] !== maxx || float32Array2[node32Index + 4] !== maxy || float32Array2[node32Index + 5] !== maxz) {
-        float32Array2[node32Index + 0] = minx;
-        float32Array2[node32Index + 1] = miny;
-        float32Array2[node32Index + 2] = minz;
-        float32Array2[node32Index + 3] = maxx;
-        float32Array2[node32Index + 4] = maxy;
-        float32Array2[node32Index + 5] = maxz;
-        return true;
-      } else {
-        return false;
-      }
-    } else {
-      const left = node32Index + 8;
-      const right = uint32Array2[node32Index + 6];
-      const offsetLeft = left + byteOffset2;
-      const offsetRight = right + byteOffset2;
-      let forceChildren = force;
-      let includesLeft = false;
-      let includesRight = false;
-      if (nodeIndices) {
-        if (!forceChildren) {
-          includesLeft = nodeIndices.has(offsetLeft);
-          includesRight = nodeIndices.has(offsetRight);
-          forceChildren = !includesLeft && !includesRight;
-        }
-      } else {
-        includesLeft = true;
-        includesRight = true;
-      }
-      const traverseLeft = forceChildren || includesLeft;
-      const traverseRight = forceChildren || includesRight;
-      let leftChange = false;
-      if (traverseLeft) {
-        leftChange = _traverse2(left, byteOffset2, forceChildren);
-      }
-      let rightChange = false;
-      if (traverseRight) {
-        rightChange = _traverse2(right, byteOffset2, forceChildren);
-      }
-      const didChange = leftChange || rightChange;
-      if (didChange) {
-        for (let i = 0; i < 3; i++) {
-          const lefti = left + i;
-          const righti = right + i;
-          const minLeftValue = float32Array2[lefti];
-          const maxLeftValue = float32Array2[lefti + 3];
-          const minRightValue = float32Array2[righti];
-          const maxRightValue = float32Array2[righti + 3];
-          float32Array2[node32Index + i] = minLeftValue < minRightValue ? minLeftValue : minRightValue;
-          float32Array2[node32Index + i + 3] = maxLeftValue > maxRightValue ? maxLeftValue : maxRightValue;
-        }
-      }
-      return didChange;
-    }
-  }
-}
-function raycast_indirect(bvh, root, side, ray2, intersects, near, far) {
-  BufferStack.setBuffer(bvh._roots[root]);
-  _raycast(0, bvh, side, ray2, intersects, near, far);
-  BufferStack.clearBuffer();
-}
-function _raycast(nodeIndex32, bvh, side, ray2, intersects, near, far) {
-  const { float32Array: float32Array2, uint16Array: uint16Array2, uint32Array: uint32Array2 } = BufferStack;
-  const nodeIndex16 = nodeIndex32 * 2;
-  const isLeaf = IS_LEAF(nodeIndex16, uint16Array2);
-  if (isLeaf) {
-    const offset = OFFSET(nodeIndex32, uint32Array2);
-    const count = COUNT(nodeIndex16, uint16Array2);
-    intersectTris_indirect(bvh, side, ray2, offset, count, intersects, near, far);
-  } else {
-    const leftIndex = LEFT_NODE(nodeIndex32);
-    if (intersectRay(leftIndex, float32Array2, ray2, near, far)) {
-      _raycast(leftIndex, bvh, side, ray2, intersects, near, far);
-    }
-    const rightIndex = RIGHT_NODE(nodeIndex32, uint32Array2);
-    if (intersectRay(rightIndex, float32Array2, ray2, near, far)) {
-      _raycast(rightIndex, bvh, side, ray2, intersects, near, far);
-    }
-  }
-}
-const _xyzFields = ["x", "y", "z"];
-function raycastFirst_indirect(bvh, root, side, ray2, near, far) {
-  BufferStack.setBuffer(bvh._roots[root]);
-  const result = _raycastFirst(0, bvh, side, ray2, near, far);
-  BufferStack.clearBuffer();
-  return result;
-}
-function _raycastFirst(nodeIndex32, bvh, side, ray2, near, far) {
-  const { float32Array: float32Array2, uint16Array: uint16Array2, uint32Array: uint32Array2 } = BufferStack;
-  let nodeIndex16 = nodeIndex32 * 2;
-  const isLeaf = IS_LEAF(nodeIndex16, uint16Array2);
-  if (isLeaf) {
-    const offset = OFFSET(nodeIndex32, uint32Array2);
-    const count = COUNT(nodeIndex16, uint16Array2);
-    return intersectClosestTri_indirect(bvh, side, ray2, offset, count, near, far);
-  } else {
-    const splitAxis = SPLIT_AXIS(nodeIndex32, uint32Array2);
-    const xyzAxis = _xyzFields[splitAxis];
-    const rayDir = ray2.direction[xyzAxis];
-    const leftToRight = rayDir >= 0;
-    let c1, c2;
-    if (leftToRight) {
-      c1 = LEFT_NODE(nodeIndex32);
-      c2 = RIGHT_NODE(nodeIndex32, uint32Array2);
-    } else {
-      c1 = RIGHT_NODE(nodeIndex32, uint32Array2);
-      c2 = LEFT_NODE(nodeIndex32);
-    }
-    const c1Intersection = intersectRay(c1, float32Array2, ray2, near, far);
-    const c1Result = c1Intersection ? _raycastFirst(c1, bvh, side, ray2, near, far) : null;
-    if (c1Result) {
-      const point = c1Result.point[xyzAxis];
-      const isOutside = leftToRight ? point <= float32Array2[c2 + splitAxis] : (
-        // min bounding data
-        point >= float32Array2[c2 + splitAxis + 3]
-      );
-      if (isOutside) {
-        return c1Result;
-      }
-    }
-    const c2Intersection = intersectRay(c2, float32Array2, ray2, near, far);
-    const c2Result = c2Intersection ? _raycastFirst(c2, bvh, side, ray2, near, far) : null;
-    if (c1Result && c2Result) {
-      return c1Result.distance <= c2Result.distance ? c1Result : c2Result;
-    } else {
-      return c1Result || c2Result || null;
-    }
-  }
-}
-const boundingBox = /* @__PURE__ */ new Box3();
-const triangle = /* @__PURE__ */ new ExtendedTriangle();
-const triangle2 = /* @__PURE__ */ new ExtendedTriangle();
-const invertedMat = /* @__PURE__ */ new Matrix4();
-const obb$2 = /* @__PURE__ */ new OrientedBox();
-const obb2$1 = /* @__PURE__ */ new OrientedBox();
-function intersectsGeometry_indirect(bvh, root, otherGeometry, geometryToBvh) {
-  BufferStack.setBuffer(bvh._roots[root]);
-  const result = _intersectsGeometry(0, bvh, otherGeometry, geometryToBvh);
-  BufferStack.clearBuffer();
-  return result;
-}
-function _intersectsGeometry(nodeIndex32, bvh, otherGeometry, geometryToBvh, cachedObb = null) {
-  const { float32Array: float32Array2, uint16Array: uint16Array2, uint32Array: uint32Array2 } = BufferStack;
-  let nodeIndex16 = nodeIndex32 * 2;
-  if (cachedObb === null) {
-    if (!otherGeometry.boundingBox) {
-      otherGeometry.computeBoundingBox();
-    }
-    obb$2.set(otherGeometry.boundingBox.min, otherGeometry.boundingBox.max, geometryToBvh);
-    cachedObb = obb$2;
-  }
-  const isLeaf = IS_LEAF(nodeIndex16, uint16Array2);
-  if (isLeaf) {
-    const thisGeometry = bvh.geometry;
-    const thisIndex = thisGeometry.index;
-    const thisPos = thisGeometry.attributes.position;
-    const index = otherGeometry.index;
-    const pos = otherGeometry.attributes.position;
-    const offset = OFFSET(nodeIndex32, uint32Array2);
-    const count = COUNT(nodeIndex16, uint16Array2);
-    invertedMat.copy(geometryToBvh).invert();
-    if (otherGeometry.boundsTree) {
-      arrayToBox(BOUNDING_DATA_INDEX(nodeIndex32), float32Array2, obb2$1);
-      obb2$1.matrix.copy(invertedMat);
-      obb2$1.needsUpdate = true;
-      const res = otherGeometry.boundsTree.shapecast({
-        intersectsBounds: (box2) => obb2$1.intersectsBox(box2),
-        intersectsTriangle: (tri) => {
-          tri.a.applyMatrix4(geometryToBvh);
-          tri.b.applyMatrix4(geometryToBvh);
-          tri.c.applyMatrix4(geometryToBvh);
-          tri.needsUpdate = true;
-          for (let i = offset, l2 = count + offset; i < l2; i++) {
-            setTriangle(triangle2, 3 * bvh.resolveTriangleIndex(i), thisIndex, thisPos);
-            triangle2.needsUpdate = true;
-            if (tri.intersectsTriangle(triangle2)) {
-              return true;
-            }
-          }
-          return false;
-        }
-      });
-      return res;
-    } else {
-      for (let i = offset, l2 = count + offset; i < l2; i++) {
-        const ti = bvh.resolveTriangleIndex(i);
-        setTriangle(triangle, 3 * ti, thisIndex, thisPos);
-        triangle.a.applyMatrix4(invertedMat);
-        triangle.b.applyMatrix4(invertedMat);
-        triangle.c.applyMatrix4(invertedMat);
-        triangle.needsUpdate = true;
-        for (let i2 = 0, l22 = index.count; i2 < l22; i2 += 3) {
-          setTriangle(triangle2, i2, index, pos);
-          triangle2.needsUpdate = true;
-          if (triangle.intersectsTriangle(triangle2)) {
-            return true;
-          }
-        }
-      }
-    }
-  } else {
-    const left = nodeIndex32 + 8;
-    const right = uint32Array2[nodeIndex32 + 6];
-    arrayToBox(BOUNDING_DATA_INDEX(left), float32Array2, boundingBox);
-    const leftIntersection = cachedObb.intersectsBox(boundingBox) && _intersectsGeometry(left, bvh, otherGeometry, geometryToBvh, cachedObb);
-    if (leftIntersection) return true;
-    arrayToBox(BOUNDING_DATA_INDEX(right), float32Array2, boundingBox);
-    const rightIntersection = cachedObb.intersectsBox(boundingBox) && _intersectsGeometry(right, bvh, otherGeometry, geometryToBvh, cachedObb);
-    if (rightIntersection) return true;
-    return false;
-  }
-}
-const tempMatrix = /* @__PURE__ */ new Matrix4();
-const obb$1 = /* @__PURE__ */ new OrientedBox();
-const obb2 = /* @__PURE__ */ new OrientedBox();
-const temp1 = /* @__PURE__ */ new Vector3();
-const temp2 = /* @__PURE__ */ new Vector3();
-const temp3 = /* @__PURE__ */ new Vector3();
-const temp4 = /* @__PURE__ */ new Vector3();
-function closestPointToGeometry_indirect(bvh, otherGeometry, geometryToBvh, target1 = {}, target2 = {}, minThreshold = 0, maxThreshold = Infinity) {
-  if (!otherGeometry.boundingBox) {
-    otherGeometry.computeBoundingBox();
-  }
-  obb$1.set(otherGeometry.boundingBox.min, otherGeometry.boundingBox.max, geometryToBvh);
-  obb$1.needsUpdate = true;
-  const geometry = bvh.geometry;
-  const pos = geometry.attributes.position;
-  const index = geometry.index;
-  const otherPos = otherGeometry.attributes.position;
-  const otherIndex = otherGeometry.index;
-  const triangle3 = ExtendedTrianglePool.getPrimitive();
-  const triangle22 = ExtendedTrianglePool.getPrimitive();
-  let tempTarget1 = temp1;
-  let tempTargetDest1 = temp2;
-  let tempTarget2 = null;
-  let tempTargetDest2 = null;
-  if (target2) {
-    tempTarget2 = temp3;
-    tempTargetDest2 = temp4;
-  }
-  let closestDistance = Infinity;
-  let closestDistanceTriIndex = null;
-  let closestDistanceOtherTriIndex = null;
-  tempMatrix.copy(geometryToBvh).invert();
-  obb2.matrix.copy(tempMatrix);
-  bvh.shapecast(
-    {
-      boundsTraverseOrder: (box2) => {
-        return obb$1.distanceToBox(box2);
-      },
-      intersectsBounds: (box2, isLeaf, score) => {
-        if (score < closestDistance && score < maxThreshold) {
-          if (isLeaf) {
-            obb2.min.copy(box2.min);
-            obb2.max.copy(box2.max);
-            obb2.needsUpdate = true;
-          }
-          return true;
-        }
-        return false;
-      },
-      intersectsRange: (offset, count) => {
-        if (otherGeometry.boundsTree) {
-          const otherBvh = otherGeometry.boundsTree;
-          return otherBvh.shapecast({
-            boundsTraverseOrder: (box2) => {
-              return obb2.distanceToBox(box2);
-            },
-            intersectsBounds: (box2, isLeaf, score) => {
-              return score < closestDistance && score < maxThreshold;
-            },
-            intersectsRange: (otherOffset, otherCount) => {
-              for (let i2 = otherOffset, l2 = otherOffset + otherCount; i2 < l2; i2++) {
-                const ti2 = otherBvh.resolveTriangleIndex(i2);
-                setTriangle(triangle22, 3 * ti2, otherIndex, otherPos);
-                triangle22.a.applyMatrix4(geometryToBvh);
-                triangle22.b.applyMatrix4(geometryToBvh);
-                triangle22.c.applyMatrix4(geometryToBvh);
-                triangle22.needsUpdate = true;
-                for (let i = offset, l3 = offset + count; i < l3; i++) {
-                  const ti = bvh.resolveTriangleIndex(i);
-                  setTriangle(triangle3, 3 * ti, index, pos);
-                  triangle3.needsUpdate = true;
-                  const dist = triangle3.distanceToTriangle(triangle22, tempTarget1, tempTarget2);
-                  if (dist < closestDistance) {
-                    tempTargetDest1.copy(tempTarget1);
-                    if (tempTargetDest2) {
-                      tempTargetDest2.copy(tempTarget2);
-                    }
-                    closestDistance = dist;
-                    closestDistanceTriIndex = i;
-                    closestDistanceOtherTriIndex = i2;
-                  }
-                  if (dist < minThreshold) {
-                    return true;
-                  }
-                }
-              }
-            }
-          });
-        } else {
-          const triCount = getTriCount(otherGeometry);
-          for (let i2 = 0, l2 = triCount; i2 < l2; i2++) {
-            setTriangle(triangle22, 3 * i2, otherIndex, otherPos);
-            triangle22.a.applyMatrix4(geometryToBvh);
-            triangle22.b.applyMatrix4(geometryToBvh);
-            triangle22.c.applyMatrix4(geometryToBvh);
-            triangle22.needsUpdate = true;
-            for (let i = offset, l3 = offset + count; i < l3; i++) {
-              const ti = bvh.resolveTriangleIndex(i);
-              setTriangle(triangle3, 3 * ti, index, pos);
-              triangle3.needsUpdate = true;
-              const dist = triangle3.distanceToTriangle(triangle22, tempTarget1, tempTarget2);
-              if (dist < closestDistance) {
-                tempTargetDest1.copy(tempTarget1);
-                if (tempTargetDest2) {
-                  tempTargetDest2.copy(tempTarget2);
-                }
-                closestDistance = dist;
-                closestDistanceTriIndex = i;
-                closestDistanceOtherTriIndex = i2;
-              }
-              if (dist < minThreshold) {
-                return true;
-              }
-            }
-          }
-        }
-      }
-    }
-  );
-  ExtendedTrianglePool.releasePrimitive(triangle3);
-  ExtendedTrianglePool.releasePrimitive(triangle22);
-  if (closestDistance === Infinity) {
-    return null;
-  }
-  if (!target1.point) {
-    target1.point = tempTargetDest1.clone();
-  } else {
-    target1.point.copy(tempTargetDest1);
-  }
-  target1.distance = closestDistance, target1.faceIndex = closestDistanceTriIndex;
-  if (target2) {
-    if (!target2.point) target2.point = tempTargetDest2.clone();
-    else target2.point.copy(tempTargetDest2);
-    target2.point.applyMatrix4(tempMatrix);
-    tempTargetDest1.applyMatrix4(tempMatrix);
-    target2.distance = tempTargetDest1.sub(target2.point).length();
-    target2.faceIndex = closestDistanceOtherTriIndex;
-  }
-  return target1;
-}
-function isSharedArrayBufferSupported() {
-  return typeof SharedArrayBuffer !== "undefined";
-}
-const _bufferStack1 = new BufferStack.constructor();
-const _bufferStack2 = new BufferStack.constructor();
-const _boxPool = new PrimitivePool(() => new Box3());
-const _leftBox1 = new Box3();
-const _rightBox1 = new Box3();
-const _leftBox2 = new Box3();
-const _rightBox2 = new Box3();
-let _active = false;
-function bvhcast(bvh, otherBvh, matrixToLocal, intersectsRanges) {
-  if (_active) {
-    throw new Error("MeshBVH: Recursive calls to bvhcast not supported.");
-  }
-  _active = true;
-  const roots = bvh._roots;
-  const otherRoots = otherBvh._roots;
-  let result;
-  let offset1 = 0;
-  let offset2 = 0;
-  const invMat = new Matrix4().copy(matrixToLocal).invert();
-  for (let i = 0, il = roots.length; i < il; i++) {
-    _bufferStack1.setBuffer(roots[i]);
-    offset2 = 0;
-    const localBox = _boxPool.getPrimitive();
-    arrayToBox(BOUNDING_DATA_INDEX(0), _bufferStack1.float32Array, localBox);
-    localBox.applyMatrix4(invMat);
-    for (let j2 = 0, jl = otherRoots.length; j2 < jl; j2++) {
-      _bufferStack2.setBuffer(otherRoots[j2]);
-      result = _traverse(
-        0,
-        0,
-        matrixToLocal,
-        invMat,
-        intersectsRanges,
-        offset1,
-        offset2,
-        0,
-        0,
-        localBox
-      );
-      _bufferStack2.clearBuffer();
-      offset2 += otherRoots[j2].length;
-      if (result) {
-        break;
-      }
-    }
-    _boxPool.releasePrimitive(localBox);
-    _bufferStack1.clearBuffer();
-    offset1 += roots[i].length;
-    if (result) {
-      break;
-    }
-  }
-  _active = false;
-  return result;
-}
-function _traverse(node1Index32, node2Index32, matrix2to1, matrix1to2, intersectsRangesFunc, node1IndexByteOffset = 0, node2IndexByteOffset = 0, depth1 = 0, depth2 = 0, currBox = null, reversed = false) {
-  let bufferStack1, bufferStack2;
-  if (reversed) {
-    bufferStack1 = _bufferStack2;
-    bufferStack2 = _bufferStack1;
-  } else {
-    bufferStack1 = _bufferStack1;
-    bufferStack2 = _bufferStack2;
-  }
-  const float32Array1 = bufferStack1.float32Array, uint32Array1 = bufferStack1.uint32Array, uint16Array1 = bufferStack1.uint16Array, float32Array2 = bufferStack2.float32Array, uint32Array2 = bufferStack2.uint32Array, uint16Array2 = bufferStack2.uint16Array;
-  const node1Index16 = node1Index32 * 2;
-  const node2Index16 = node2Index32 * 2;
-  const isLeaf1 = IS_LEAF(node1Index16, uint16Array1);
-  const isLeaf2 = IS_LEAF(node2Index16, uint16Array2);
-  let result = false;
-  if (isLeaf2 && isLeaf1) {
-    if (reversed) {
-      result = intersectsRangesFunc(
-        OFFSET(node2Index32, uint32Array2),
-        COUNT(node2Index32 * 2, uint16Array2),
-        OFFSET(node1Index32, uint32Array1),
-        COUNT(node1Index32 * 2, uint16Array1),
-        depth2,
-        node2IndexByteOffset + node2Index32,
-        depth1,
-        node1IndexByteOffset + node1Index32
-      );
-    } else {
-      result = intersectsRangesFunc(
-        OFFSET(node1Index32, uint32Array1),
-        COUNT(node1Index32 * 2, uint16Array1),
-        OFFSET(node2Index32, uint32Array2),
-        COUNT(node2Index32 * 2, uint16Array2),
-        depth1,
-        node1IndexByteOffset + node1Index32,
-        depth2,
-        node2IndexByteOffset + node2Index32
-      );
-    }
-  } else if (isLeaf2) {
-    const newBox = _boxPool.getPrimitive();
-    arrayToBox(BOUNDING_DATA_INDEX(node2Index32), float32Array2, newBox);
-    newBox.applyMatrix4(matrix2to1);
-    const cl1 = LEFT_NODE(node1Index32);
-    const cr1 = RIGHT_NODE(node1Index32, uint32Array1);
-    arrayToBox(BOUNDING_DATA_INDEX(cl1), float32Array1, _leftBox1);
-    arrayToBox(BOUNDING_DATA_INDEX(cr1), float32Array1, _rightBox1);
-    const intersectCl1 = newBox.intersectsBox(_leftBox1);
-    const intersectCr1 = newBox.intersectsBox(_rightBox1);
-    result = intersectCl1 && _traverse(
-      node2Index32,
-      cl1,
-      matrix1to2,
-      matrix2to1,
-      intersectsRangesFunc,
-      node2IndexByteOffset,
-      node1IndexByteOffset,
-      depth2,
-      depth1 + 1,
-      newBox,
-      !reversed
-    ) || intersectCr1 && _traverse(
-      node2Index32,
-      cr1,
-      matrix1to2,
-      matrix2to1,
-      intersectsRangesFunc,
-      node2IndexByteOffset,
-      node1IndexByteOffset,
-      depth2,
-      depth1 + 1,
-      newBox,
-      !reversed
-    );
-    _boxPool.releasePrimitive(newBox);
-  } else {
-    const cl2 = LEFT_NODE(node2Index32);
-    const cr2 = RIGHT_NODE(node2Index32, uint32Array2);
-    arrayToBox(BOUNDING_DATA_INDEX(cl2), float32Array2, _leftBox2);
-    arrayToBox(BOUNDING_DATA_INDEX(cr2), float32Array2, _rightBox2);
-    const leftIntersects = currBox.intersectsBox(_leftBox2);
-    const rightIntersects = currBox.intersectsBox(_rightBox2);
-    if (leftIntersects && rightIntersects) {
-      result = _traverse(
-        node1Index32,
-        cl2,
-        matrix2to1,
-        matrix1to2,
-        intersectsRangesFunc,
-        node1IndexByteOffset,
-        node2IndexByteOffset,
-        depth1,
-        depth2 + 1,
-        currBox,
-        reversed
-      ) || _traverse(
-        node1Index32,
-        cr2,
-        matrix2to1,
-        matrix1to2,
-        intersectsRangesFunc,
-        node1IndexByteOffset,
-        node2IndexByteOffset,
-        depth1,
-        depth2 + 1,
-        currBox,
-        reversed
-      );
-    } else if (leftIntersects) {
-      if (isLeaf1) {
-        result = _traverse(
-          node1Index32,
-          cl2,
-          matrix2to1,
-          matrix1to2,
-          intersectsRangesFunc,
-          node1IndexByteOffset,
-          node2IndexByteOffset,
-          depth1,
-          depth2 + 1,
-          currBox,
-          reversed
-        );
-      } else {
-        const newBox = _boxPool.getPrimitive();
-        newBox.copy(_leftBox2).applyMatrix4(matrix2to1);
-        const cl1 = LEFT_NODE(node1Index32);
-        const cr1 = RIGHT_NODE(node1Index32, uint32Array1);
-        arrayToBox(BOUNDING_DATA_INDEX(cl1), float32Array1, _leftBox1);
-        arrayToBox(BOUNDING_DATA_INDEX(cr1), float32Array1, _rightBox1);
-        const intersectCl1 = newBox.intersectsBox(_leftBox1);
-        const intersectCr1 = newBox.intersectsBox(_rightBox1);
-        result = intersectCl1 && _traverse(
-          cl2,
-          cl1,
-          matrix1to2,
-          matrix2to1,
-          intersectsRangesFunc,
-          node2IndexByteOffset,
-          node1IndexByteOffset,
-          depth2,
-          depth1 + 1,
-          newBox,
-          !reversed
-        ) || intersectCr1 && _traverse(
-          cl2,
-          cr1,
-          matrix1to2,
-          matrix2to1,
-          intersectsRangesFunc,
-          node2IndexByteOffset,
-          node1IndexByteOffset,
-          depth2,
-          depth1 + 1,
-          newBox,
-          !reversed
-        );
-        _boxPool.releasePrimitive(newBox);
-      }
-    } else if (rightIntersects) {
-      if (isLeaf1) {
-        result = _traverse(
-          node1Index32,
-          cr2,
-          matrix2to1,
-          matrix1to2,
-          intersectsRangesFunc,
-          node1IndexByteOffset,
-          node2IndexByteOffset,
-          depth1,
-          depth2 + 1,
-          currBox,
-          reversed
-        );
-      } else {
-        const newBox = _boxPool.getPrimitive();
-        newBox.copy(_rightBox2).applyMatrix4(matrix2to1);
-        const cl1 = LEFT_NODE(node1Index32);
-        const cr1 = RIGHT_NODE(node1Index32, uint32Array1);
-        arrayToBox(BOUNDING_DATA_INDEX(cl1), float32Array1, _leftBox1);
-        arrayToBox(BOUNDING_DATA_INDEX(cr1), float32Array1, _rightBox1);
-        const intersectCl1 = newBox.intersectsBox(_leftBox1);
-        const intersectCr1 = newBox.intersectsBox(_rightBox1);
-        result = intersectCl1 && _traverse(
-          cr2,
-          cl1,
-          matrix1to2,
-          matrix2to1,
-          intersectsRangesFunc,
-          node2IndexByteOffset,
-          node1IndexByteOffset,
-          depth2,
-          depth1 + 1,
-          newBox,
-          !reversed
-        ) || intersectCr1 && _traverse(
-          cr2,
-          cr1,
-          matrix1to2,
-          matrix2to1,
-          intersectsRangesFunc,
-          node2IndexByteOffset,
-          node1IndexByteOffset,
-          depth2,
-          depth1 + 1,
-          newBox,
-          !reversed
-        );
-        _boxPool.releasePrimitive(newBox);
-      }
-    }
-  }
-  return result;
-}
-const obb = /* @__PURE__ */ new OrientedBox();
-const tempBox = /* @__PURE__ */ new Box3();
-const DEFAULT_OPTIONS = {
-  strategy: CENTER,
-  maxDepth: 40,
-  maxLeafTris: 10,
-  useSharedArrayBuffer: false,
-  setBoundingBox: true,
-  onProgress: null,
-  indirect: false,
-  verbose: true,
-  range: null
-};
-class MeshBVH {
-  static serialize(bvh, options = {}) {
-    options = {
-      cloneBuffers: true,
-      ...options
-    };
-    const geometry = bvh.geometry;
-    const rootData = bvh._roots;
-    const indirectBuffer = bvh._indirectBuffer;
-    const indexAttribute = geometry.getIndex();
-    let result;
-    if (options.cloneBuffers) {
-      result = {
-        roots: rootData.map((root) => root.slice()),
-        index: indexAttribute ? indexAttribute.array.slice() : null,
-        indirectBuffer: indirectBuffer ? indirectBuffer.slice() : null
-      };
-    } else {
-      result = {
-        roots: rootData,
-        index: indexAttribute ? indexAttribute.array : null,
-        indirectBuffer
-      };
-    }
-    return result;
-  }
-  static deserialize(data, geometry, options = {}) {
-    options = {
-      setIndex: true,
-      indirect: Boolean(data.indirectBuffer),
-      ...options
-    };
-    const { index, roots, indirectBuffer } = data;
-    const bvh = new MeshBVH(geometry, { ...options, [SKIP_GENERATION]: true });
-    bvh._roots = roots;
-    bvh._indirectBuffer = indirectBuffer || null;
-    if (options.setIndex) {
-      const indexAttribute = geometry.getIndex();
-      if (indexAttribute === null) {
-        const newIndex = new BufferAttribute(data.index, 1, false);
-        geometry.setIndex(newIndex);
-      } else if (indexAttribute.array !== index) {
-        indexAttribute.array.set(index);
-        indexAttribute.needsUpdate = true;
-      }
-    }
-    return bvh;
-  }
-  get indirect() {
-    return !!this._indirectBuffer;
-  }
-  constructor(geometry, options = {}) {
-    if (!geometry.isBufferGeometry) {
-      throw new Error("MeshBVH: Only BufferGeometries are supported.");
-    } else if (geometry.index && geometry.index.isInterleavedBufferAttribute) {
-      throw new Error("MeshBVH: InterleavedBufferAttribute is not supported for the index attribute.");
-    }
-    options = Object.assign({
-      ...DEFAULT_OPTIONS,
-      // undocumented options
-      // Whether to skip generating the tree. Used for deserialization.
-      [SKIP_GENERATION]: false
-    }, options);
-    if (options.useSharedArrayBuffer && !isSharedArrayBufferSupported()) {
-      throw new Error("MeshBVH: SharedArrayBuffer is not available.");
-    }
-    this.geometry = geometry;
-    this._roots = null;
-    this._indirectBuffer = null;
-    if (!options[SKIP_GENERATION]) {
-      buildPackedTree(this, options);
-      if (!geometry.boundingBox && options.setBoundingBox) {
-        geometry.boundingBox = this.getBoundingBox(new Box3());
-      }
-    }
-    this.resolveTriangleIndex = options.indirect ? (i) => this._indirectBuffer[i] : (i) => i;
-  }
-  refit(nodeIndices = null) {
-    const refitFunc = this.indirect ? refit_indirect : refit;
-    return refitFunc(this, nodeIndices);
-  }
-  traverse(callback, rootIndex = 0) {
-    const buffer = this._roots[rootIndex];
-    const uint32Array2 = new Uint32Array(buffer);
-    const uint16Array2 = new Uint16Array(buffer);
-    _traverse2(0);
-    function _traverse2(node32Index, depth = 0) {
-      const node16Index = node32Index * 2;
-      const isLeaf = uint16Array2[node16Index + 15] === IS_LEAFNODE_FLAG;
-      if (isLeaf) {
-        const offset = uint32Array2[node32Index + 6];
-        const count = uint16Array2[node16Index + 14];
-        callback(depth, isLeaf, new Float32Array(buffer, node32Index * 4, 6), offset, count);
-      } else {
-        const left = node32Index + BYTES_PER_NODE / 4;
-        const right = uint32Array2[node32Index + 6];
-        const splitAxis = uint32Array2[node32Index + 7];
-        const stopTraversal = callback(depth, isLeaf, new Float32Array(buffer, node32Index * 4, 6), splitAxis);
-        if (!stopTraversal) {
-          _traverse2(left, depth + 1);
-          _traverse2(right, depth + 1);
-        }
-      }
-    }
-  }
-  /* Core Cast Functions */
-  raycast(ray2, materialOrSide = FrontSide, near = 0, far = Infinity) {
-    const roots = this._roots;
-    const geometry = this.geometry;
-    const intersects = [];
-    const isMaterial = materialOrSide.isMaterial;
-    const isArrayMaterial = Array.isArray(materialOrSide);
-    const groups = geometry.groups;
-    const side = isMaterial ? materialOrSide.side : materialOrSide;
-    const raycastFunc = this.indirect ? raycast_indirect : raycast;
-    for (let i = 0, l2 = roots.length; i < l2; i++) {
-      const materialSide = isArrayMaterial ? materialOrSide[groups[i].materialIndex].side : side;
-      const startCount = intersects.length;
-      raycastFunc(this, i, materialSide, ray2, intersects, near, far);
-      if (isArrayMaterial) {
-        const materialIndex = groups[i].materialIndex;
-        for (let j2 = startCount, jl = intersects.length; j2 < jl; j2++) {
-          intersects[j2].face.materialIndex = materialIndex;
-        }
-      }
-    }
-    return intersects;
-  }
-  raycastFirst(ray2, materialOrSide = FrontSide, near = 0, far = Infinity) {
-    const roots = this._roots;
-    const geometry = this.geometry;
-    const isMaterial = materialOrSide.isMaterial;
-    const isArrayMaterial = Array.isArray(materialOrSide);
-    let closestResult = null;
-    const groups = geometry.groups;
-    const side = isMaterial ? materialOrSide.side : materialOrSide;
-    const raycastFirstFunc = this.indirect ? raycastFirst_indirect : raycastFirst;
-    for (let i = 0, l2 = roots.length; i < l2; i++) {
-      const materialSide = isArrayMaterial ? materialOrSide[groups[i].materialIndex].side : side;
-      const result = raycastFirstFunc(this, i, materialSide, ray2, near, far);
-      if (result != null && (closestResult == null || result.distance < closestResult.distance)) {
-        closestResult = result;
-        if (isArrayMaterial) {
-          result.face.materialIndex = groups[i].materialIndex;
-        }
-      }
-    }
-    return closestResult;
-  }
-  intersectsGeometry(otherGeometry, geomToMesh) {
-    let result = false;
-    const roots = this._roots;
-    const intersectsGeometryFunc = this.indirect ? intersectsGeometry_indirect : intersectsGeometry;
-    for (let i = 0, l2 = roots.length; i < l2; i++) {
-      result = intersectsGeometryFunc(this, i, otherGeometry, geomToMesh);
-      if (result) {
-        break;
-      }
-    }
-    return result;
-  }
-  shapecast(callbacks) {
-    const triangle3 = ExtendedTrianglePool.getPrimitive();
-    const iterateFunc = this.indirect ? iterateOverTriangles_indirect : iterateOverTriangles;
-    let {
-      boundsTraverseOrder,
-      intersectsBounds,
-      intersectsRange,
-      intersectsTriangle
-    } = callbacks;
-    if (intersectsRange && intersectsTriangle) {
-      const originalIntersectsRange = intersectsRange;
-      intersectsRange = (offset, count, contained, depth, nodeIndex) => {
-        if (!originalIntersectsRange(offset, count, contained, depth, nodeIndex)) {
-          return iterateFunc(offset, count, this, intersectsTriangle, contained, depth, triangle3);
-        }
-        return true;
-      };
-    } else if (!intersectsRange) {
-      if (intersectsTriangle) {
-        intersectsRange = (offset, count, contained, depth) => {
-          return iterateFunc(offset, count, this, intersectsTriangle, contained, depth, triangle3);
-        };
-      } else {
-        intersectsRange = (offset, count, contained) => {
-          return contained;
-        };
-      }
-    }
-    let result = false;
-    let byteOffset = 0;
-    const roots = this._roots;
-    for (let i = 0, l2 = roots.length; i < l2; i++) {
-      const root = roots[i];
-      result = shapecast(this, i, intersectsBounds, intersectsRange, boundsTraverseOrder, byteOffset);
-      if (result) {
-        break;
-      }
-      byteOffset += root.byteLength;
-    }
-    ExtendedTrianglePool.releasePrimitive(triangle3);
-    return result;
-  }
-  bvhcast(otherBvh, matrixToLocal, callbacks) {
-    let {
-      intersectsRanges,
-      intersectsTriangles
-    } = callbacks;
-    const triangle1 = ExtendedTrianglePool.getPrimitive();
-    const indexAttr1 = this.geometry.index;
-    const positionAttr1 = this.geometry.attributes.position;
-    const assignTriangle1 = this.indirect ? (i1) => {
-      const ti = this.resolveTriangleIndex(i1);
-      setTriangle(triangle1, ti * 3, indexAttr1, positionAttr1);
-    } : (i1) => {
-      setTriangle(triangle1, i1 * 3, indexAttr1, positionAttr1);
-    };
-    const triangle22 = ExtendedTrianglePool.getPrimitive();
-    const indexAttr2 = otherBvh.geometry.index;
-    const positionAttr2 = otherBvh.geometry.attributes.position;
-    const assignTriangle2 = otherBvh.indirect ? (i2) => {
-      const ti2 = otherBvh.resolveTriangleIndex(i2);
-      setTriangle(triangle22, ti2 * 3, indexAttr2, positionAttr2);
-    } : (i2) => {
-      setTriangle(triangle22, i2 * 3, indexAttr2, positionAttr2);
-    };
-    if (intersectsTriangles) {
-      const iterateOverDoubleTriangles = (offset1, count1, offset2, count2, depth1, index1, depth2, index2) => {
-        for (let i2 = offset2, l2 = offset2 + count2; i2 < l2; i2++) {
-          assignTriangle2(i2);
-          triangle22.a.applyMatrix4(matrixToLocal);
-          triangle22.b.applyMatrix4(matrixToLocal);
-          triangle22.c.applyMatrix4(matrixToLocal);
-          triangle22.needsUpdate = true;
-          for (let i1 = offset1, l1 = offset1 + count1; i1 < l1; i1++) {
-            assignTriangle1(i1);
-            triangle1.needsUpdate = true;
-            if (intersectsTriangles(triangle1, triangle22, i1, i2, depth1, index1, depth2, index2)) {
-              return true;
-            }
-          }
-        }
-        return false;
-      };
-      if (intersectsRanges) {
-        const originalIntersectsRanges = intersectsRanges;
-        intersectsRanges = function(offset1, count1, offset2, count2, depth1, index1, depth2, index2) {
-          if (!originalIntersectsRanges(offset1, count1, offset2, count2, depth1, index1, depth2, index2)) {
-            return iterateOverDoubleTriangles(offset1, count1, offset2, count2, depth1, index1, depth2, index2);
-          }
-          return true;
-        };
-      } else {
-        intersectsRanges = iterateOverDoubleTriangles;
-      }
-    }
-    return bvhcast(this, otherBvh, matrixToLocal, intersectsRanges);
-  }
-  /* Derived Cast Functions */
-  intersectsBox(box2, boxToMesh) {
-    obb.set(box2.min, box2.max, boxToMesh);
-    obb.needsUpdate = true;
-    return this.shapecast(
-      {
-        intersectsBounds: (box3) => obb.intersectsBox(box3),
-        intersectsTriangle: (tri) => obb.intersectsTriangle(tri)
-      }
-    );
-  }
-  intersectsSphere(sphere) {
-    return this.shapecast(
-      {
-        intersectsBounds: (box2) => sphere.intersectsBox(box2),
-        intersectsTriangle: (tri) => tri.intersectsSphere(sphere)
-      }
-    );
-  }
-  closestPointToGeometry(otherGeometry, geometryToBvh, target1 = {}, target2 = {}, minThreshold = 0, maxThreshold = Infinity) {
-    const closestPointToGeometryFunc = this.indirect ? closestPointToGeometry_indirect : closestPointToGeometry;
-    return closestPointToGeometryFunc(
-      this,
-      otherGeometry,
-      geometryToBvh,
-      target1,
-      target2,
-      minThreshold,
-      maxThreshold
-    );
-  }
-  closestPointToPoint(point, target = {}, minThreshold = 0, maxThreshold = Infinity) {
-    return closestPointToPoint(
-      this,
-      point,
-      target,
-      minThreshold,
-      maxThreshold
-    );
-  }
-  getBoundingBox(target) {
-    target.makeEmpty();
-    const roots = this._roots;
-    roots.forEach((buffer) => {
-      arrayToBox(0, new Float32Array(buffer), tempBox);
-      target.union(tempBox);
-    });
-    return target;
-  }
-}
-function convertRaycastIntersect(hit, object, raycaster) {
-  if (hit === null) {
-    return null;
-  }
-  hit.point.applyMatrix4(object.matrixWorld);
-  hit.distance = hit.point.distanceTo(raycaster.ray.origin);
-  hit.object = object;
-  return hit;
-}
-const ray = /* @__PURE__ */ new Ray();
-const direction = /* @__PURE__ */ new Vector3();
-const tmpInverseMatrix = /* @__PURE__ */ new Matrix4();
-const origMeshRaycastFunc = Mesh.prototype.raycast;
-const origBatchedRaycastFunc = BatchedMesh.prototype.raycast;
-const _worldScale = /* @__PURE__ */ new Vector3();
-const _mesh = /* @__PURE__ */ new Mesh();
-const _batchIntersects = [];
-function acceleratedRaycast(raycaster, intersects) {
-  if (this.isBatchedMesh) {
-    acceleratedBatchedMeshRaycast.call(this, raycaster, intersects);
-  } else {
-    acceleratedMeshRaycast.call(this, raycaster, intersects);
-  }
-}
-function acceleratedBatchedMeshRaycast(raycaster, intersects) {
-  if (this.boundsTrees) {
-    const boundsTrees = this.boundsTrees;
-    const drawInfo = this._drawInfo || this._instanceInfo;
-    const drawRanges = this._drawRanges || this._geometryInfo;
-    const matrixWorld = this.matrixWorld;
-    _mesh.material = this.material;
-    _mesh.geometry = this.geometry;
-    const oldBoundsTree = _mesh.geometry.boundsTree;
-    const oldDrawRange = _mesh.geometry.drawRange;
-    if (_mesh.geometry.boundingSphere === null) {
-      _mesh.geometry.boundingSphere = new Sphere();
-    }
-    for (let i = 0, l2 = drawInfo.length; i < l2; i++) {
-      if (!this.getVisibleAt(i)) {
-        continue;
-      }
-      const geometryId = drawInfo[i].geometryIndex;
-      _mesh.geometry.boundsTree = boundsTrees[geometryId];
-      this.getMatrixAt(i, _mesh.matrixWorld).premultiply(matrixWorld);
-      if (!_mesh.geometry.boundsTree) {
-        this.getBoundingBoxAt(geometryId, _mesh.geometry.boundingBox);
-        this.getBoundingSphereAt(geometryId, _mesh.geometry.boundingSphere);
-        const drawRange = drawRanges[geometryId];
-        _mesh.geometry.setDrawRange(drawRange.start, drawRange.count);
-      }
-      _mesh.raycast(raycaster, _batchIntersects);
-      for (let j2 = 0, l3 = _batchIntersects.length; j2 < l3; j2++) {
-        const intersect = _batchIntersects[j2];
-        intersect.object = this;
-        intersect.batchId = i;
-        intersects.push(intersect);
-      }
-      _batchIntersects.length = 0;
-    }
-    _mesh.geometry.boundsTree = oldBoundsTree;
-    _mesh.geometry.drawRange = oldDrawRange;
-    _mesh.material = null;
-    _mesh.geometry = null;
-  } else {
-    origBatchedRaycastFunc.call(this, raycaster, intersects);
-  }
-}
-function acceleratedMeshRaycast(raycaster, intersects) {
-  if (this.geometry.boundsTree) {
-    if (this.material === void 0) return;
-    tmpInverseMatrix.copy(this.matrixWorld).invert();
-    ray.copy(raycaster.ray).applyMatrix4(tmpInverseMatrix);
-    _worldScale.setFromMatrixScale(this.matrixWorld);
-    direction.copy(ray.direction).multiply(_worldScale);
-    const scaleFactor = direction.length();
-    const near = raycaster.near / scaleFactor;
-    const far = raycaster.far / scaleFactor;
-    const bvh = this.geometry.boundsTree;
-    if (raycaster.firstHitOnly === true) {
-      const hit = convertRaycastIntersect(bvh.raycastFirst(ray, this.material, near, far), this, raycaster);
-      if (hit) {
-        intersects.push(hit);
-      }
-    } else {
-      const hits = bvh.raycast(ray, this.material, near, far);
-      for (let i = 0, l2 = hits.length; i < l2; i++) {
-        const hit = convertRaycastIntersect(hits[i], this, raycaster);
-        if (hit) {
-          intersects.push(hit);
-        }
-      }
-    }
-  } else {
-    origMeshRaycastFunc.call(this, raycaster, intersects);
-  }
-}
 const getBufferForType = (type, width, height) => {
   let out;
   switch (type) {
@@ -19042,7 +15719,7 @@ const movePath = (value, from, to) => {
   if (value.startsWith(`${from}/`)) return `${to}${value.slice(from.length)}`;
   return value;
 };
-const FORGE_IMPORT_RE = /\b(?:importMesh|importStep|importSvgSketch|Import\.mesh|Import\.step|Import\.svgSketch|Import\.dxfSketch|compareWith)\s*\(\s*(?:"([^"]+)"|'([^']+)')/g;
+const FORGE_IMPORT_RE = /\b(?:importMesh|importStep|importSvgSketch|Import\.mesh|Import\.step|Import\.image|Import\.svgSketch|Import\.dxfSketch|compareWith)\s*\(\s*(?:"([^"]+)"|'([^']+)')/g;
 const REQUIRE_RE = /\brequire\s*\(\s*(?:"([^"]+)"|'([^']+)')/g;
 const ES_IMPORT_RE = /\bfrom\s+(?:"([^"]+)"|'([^']+)')/g;
 const VIRTUAL_MODULES = /* @__PURE__ */ new Set(["forgecad", "@forge/runtime", "@forgecad/runtime"]);
@@ -19062,6 +15739,7 @@ function extractImports(code) {
     importSvgSketch: "forgeSvg",
     "Import.mesh": "forgeMesh",
     "Import.step": "forgeMesh",
+    "Import.image": "forgeMesh",
     "Import.svgSketch": "forgeSvg",
     "Import.dxfSketch": "forgeDxf",
     compareWith: "compareWith"
@@ -19071,7 +15749,7 @@ function extractImports(code) {
   while ((m2 = forgeRe.exec(code)) !== null) {
     const path = m2[1] ?? m2[2];
     const fn = (_a3 = m2[0].match(
-      /\b(importMesh|importStep|importSvgSketch|Import\.mesh|Import\.step|Import\.svgSketch|Import\.dxfSketch|compareWith)/
+      /\b(importMesh|importStep|importSvgSketch|Import\.mesh|Import\.step|Import\.image|Import\.svgSketch|Import\.dxfSketch|compareWith)/
     )) == null ? void 0 : _a3[1];
     add(path, kindMap[fn] ?? "forgeMesh");
   }
@@ -19298,7 +15976,7 @@ const CRASH_COOLDOWN_MS = 2e3;
 class EvalWorkerClient {
   constructor(workerFactory = () => new Worker(new URL(
     /* @vite-ignore */
-    "/assets/evalWorker-CS63PfZu.js",
+    "/assets/evalWorker-BssDYW9u.js",
     import.meta.url
   ), { type: "module" })) {
     __publicField(this, "worker", null);
@@ -20769,133 +17447,37 @@ function buildRunState(previewFile, runResult, state2) {
     nextObjectSettingsByFile
   };
 }
-function computeBackendFromParts(activeBackend, computeTarget) {
-  return computeTarget === "server" ? "server-occt" : activeBackend;
+const KERNELS = [
+  { id: "manifold", name: "manifold", location: "local", label: "Manifold" },
+  { id: "occt", name: "occt", location: "local", label: "OCCT" },
+  { id: "truck", name: "truck", location: "local", label: "Truck" },
+  { id: "sdf", name: "sdf", location: "local", label: "SDF" },
+  { id: "server-occt", name: "occt", location: "server", label: "Server OCCT" }
+];
+function availableKernels(canUseServer) {
+  return KERNELS.filter((kernel) => kernel.location === "local" || canUseServer);
+}
+function kernelId(kernel) {
+  return kernel.location === "server" ? "server-occt" : kernel.name;
 }
-function computeBackendParts(backend) {
-  return backend === "server-occt" ? { activeBackend: "occt", computeTarget: "server" } : { activeBackend: backend, computeTarget: "local" };
+function kernelFromId(id) {
+  const kernel = KERNELS.find((entry) => entry.id === id);
+  if (!kernel) throw new Error(`Unknown kernel: ${id}`);
+  return kernel;
+}
+function resolveAvailableKernel(preferred, kernels) {
+  if (kernels.length === 0) throw new Error("No kernels are available");
+  const exact = kernels.find((kernel) => kernel.name === preferred.name && kernel.location === preferred.location);
+  if (exact) return exact;
+  return kernels.find((kernel) => kernel.name === "manifold" && kernel.location === "local") ?? kernels[0];
+}
+function computeBackendFromParts(activeBackend, computeTarget) {
+  return kernelId({ name: activeBackend, location: computeTarget });
 }
 function formatComputeBackendLabel(backend) {
-  switch (backend) {
-    case "manifold":
-      return "Local Manifold";
-    case "occt":
-      return "Local OCCT";
-    case "truck":
-      return "Local Truck";
-    case "sdf":
-      return "Local SDF";
-    case "server-occt":
-      return "Server OCCT";
-  }
-}
-const VIEW_PREFERENCES_KEY = "fc-view-preferences-v1";
-const INSPECT_POINT_SAMPLE_COUNT_MIN = 100;
-const INSPECT_POINT_SAMPLE_COUNT_MAX = 2e4;
-const DEFAULT_INSPECT_POINT_SAMPLE_COUNT = 15e3;
-const DEFAULT_COMPARISON_INSPECT_MODE = "difference-only";
-const DEFAULT_COMPARISON_CANDIDATE_OPACITY = 0.42;
-const DEFAULT_COMPARISON_REFERENCE_OPACITY = 0.2;
-const THICKNESS_COLOR_RANGE_MIN = 0;
-const THICKNESS_COLOR_RANGE_MAX = 1e3;
-const THICKNESS_COLOR_RANGE_MIN_SPAN = 1e-3;
-const DEFAULT_THICKNESS_COLOR_RANGE = {
-  min: 0,
-  max: 6
-};
-const DEFAULT_INSPECT_ISOLINES_ENABLED = false;
-const DEFAULT_INSPECT_ISOLINE_SPACING = 1;
-const DEFAULT_INSPECT_CRITICAL_LINE_ENABLED = true;
-const DEFAULT_MANUAL_SCENE_SETTINGS = {
-  enabled: false,
-  backgroundColor: "#f6f7f8",
-  groundVisible: true,
-  groundColor: "#eef0f2",
-  ambientIntensity: 0.3,
-  keyIntensity: 1.45,
-  fillIntensity: 0.55,
-  rimIntensity: 0.2,
-  environmentIntensity: 0.9
-};
-const resolveInspectPointSampleCount = (value) => {
-  const numeric = typeof value === "number" ? value : Number(value);
-  if (!Number.isFinite(numeric)) return DEFAULT_INSPECT_POINT_SAMPLE_COUNT;
-  return Math.max(INSPECT_POINT_SAMPLE_COUNT_MIN, Math.min(INSPECT_POINT_SAMPLE_COUNT_MAX, Math.round(numeric)));
-};
-const resolveComparisonInspectMode = (value) => value === "difference-only" ? value : DEFAULT_COMPARISON_INSPECT_MODE;
-const resolveCameraControlMode = (value) => value === "fly" ? value : "orbit";
-const HEX_COLOR_RE = /^#[0-9a-f]{6}$/i;
-const resolveHexColor = (value, fallback) => {
-  return typeof value === "string" && HEX_COLOR_RE.test(value) ? value : fallback;
-};
-const resolveClampedNumber = (value, fallback, min, max2) => {
-  const numeric = typeof value === "number" ? value : Number(value);
-  if (!Number.isFinite(numeric)) return fallback;
-  return Math.max(min, Math.min(max2, numeric));
-};
-const resolveComparisonOpacity = (value, fallback) => resolveClampedNumber(value, fallback, 0, 1);
-const resolveThicknessColorRange = (value) => {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return DEFAULT_THICKNESS_COLOR_RANGE;
-  }
-  const raw = value;
-  const min = resolveClampedNumber(raw.min, DEFAULT_THICKNESS_COLOR_RANGE.min, THICKNESS_COLOR_RANGE_MIN, THICKNESS_COLOR_RANGE_MAX);
-  const max2 = resolveClampedNumber(raw.max, DEFAULT_THICKNESS_COLOR_RANGE.max, THICKNESS_COLOR_RANGE_MIN, THICKNESS_COLOR_RANGE_MAX);
-  if (max2 - min >= THICKNESS_COLOR_RANGE_MIN_SPAN) return { min, max: max2 };
-  const defaultSpan = DEFAULT_THICKNESS_COLOR_RANGE.max - DEFAULT_THICKNESS_COLOR_RANGE.min;
-  const expandedMax = Math.min(THICKNESS_COLOR_RANGE_MAX, min + defaultSpan);
-  if (expandedMax - min >= THICKNESS_COLOR_RANGE_MIN_SPAN) return { min, max: expandedMax };
-  const expandedMin = Math.max(THICKNESS_COLOR_RANGE_MIN, max2 - defaultSpan);
-  if (max2 - expandedMin >= THICKNESS_COLOR_RANGE_MIN_SPAN) return { min: expandedMin, max: max2 };
-  return DEFAULT_THICKNESS_COLOR_RANGE;
-};
-const resolveInspectColormap = (value) => resolveColormapName(value);
-const resolveBooleanPref = (value, fallback) => typeof value === "boolean" ? value : fallback;
-const resolveInspectIsolineSpacing = (value) => {
-  const numeric = typeof value === "number" ? value : Number(value);
-  if (!Number.isFinite(numeric) || numeric <= 0) return DEFAULT_INSPECT_ISOLINE_SPACING;
-  return numeric;
-};
-const resolveManualSceneSettings = (value) => {
-  if (!value || typeof value !== "object" || Array.isArray(value)) {
-    return DEFAULT_MANUAL_SCENE_SETTINGS;
-  }
-  const raw = value;
-  return {
-    enabled: typeof raw.enabled === "boolean" ? raw.enabled : DEFAULT_MANUAL_SCENE_SETTINGS.enabled,
-    backgroundColor: resolveHexColor(raw.backgroundColor, DEFAULT_MANUAL_SCENE_SETTINGS.backgroundColor),
-    groundVisible: typeof raw.groundVisible === "boolean" ? raw.groundVisible : DEFAULT_MANUAL_SCENE_SETTINGS.groundVisible,
-    groundColor: resolveHexColor(raw.groundColor, DEFAULT_MANUAL_SCENE_SETTINGS.groundColor),
-    ambientIntensity: resolveClampedNumber(raw.ambientIntensity, DEFAULT_MANUAL_SCENE_SETTINGS.ambientIntensity, 0, 3),
-    keyIntensity: resolveClampedNumber(raw.keyIntensity, DEFAULT_MANUAL_SCENE_SETTINGS.keyIntensity, 0, 5),
-    fillIntensity: resolveClampedNumber(raw.fillIntensity, DEFAULT_MANUAL_SCENE_SETTINGS.fillIntensity, 0, 3),
-    rimIntensity: resolveClampedNumber(raw.rimIntensity, DEFAULT_MANUAL_SCENE_SETTINGS.rimIntensity, 0, 3),
-    environmentIntensity: resolveClampedNumber(raw.environmentIntensity, DEFAULT_MANUAL_SCENE_SETTINGS.environmentIntensity, 0, 3)
-  };
-};
-const readViewPreferences = () => {
-  if (typeof window === "undefined") return {};
-  try {
-    const raw = localStorage.getItem(VIEW_PREFERENCES_KEY);
-    if (!raw) return {};
-    const parsed = JSON.parse(raw);
-    if (!parsed || typeof parsed !== "object") return {};
-    return parsed;
-  } catch {
-    return {};
-  }
-};
-const writeViewPreferences = (patch) => {
-  if (typeof window === "undefined") return;
-  try {
-    const next = { ...readViewPreferences(), ...patch };
-    if ("objectSettingsByFile" in patch) {
-      delete next.objectSettings;
-    }
-    localStorage.setItem(VIEW_PREFERENCES_KEY, JSON.stringify(next));
-  } catch {
-  }
-};
+  const kernel = kernelFromId(backend);
+  return kernel.location === "server" ? kernel.label : `Local ${kernel.label}`;
+}
 function computeServerSnapshot(state2, serverFiles, serverFolders, sharedModel2, sharedBundle2, initialFile) {
   const nextState = computeServerSnapshot$1(state2, serverFiles, serverFolders, sharedModel2, sharedBundle2, STARTUP_HASH_FILE, initialFile);
   writeViewPreferences({ objectSettingsByFile: nextState.objectSettingsByFile });
@@ -21095,6 +17677,14 @@ function recordViewCommandDebug(command) {
   console.debug("[forgecad view-command]", entry);
 }
 const initialViewPreferences = readViewPreferences();
+function resolveInitialKernel() {
+  const savedLocation = initialViewPreferences.computeTarget === "server" ? "server" : "local";
+  return resolveAvailableKernel(
+    { name: initialViewPreferences.activeBackend, location: savedLocation },
+    availableKernels(canUseServerCompute())
+  );
+}
+const initialKernel = resolveInitialKernel();
 const initialInspectChannel = resolveInitialViewInspectChannel(initialViewPreferences.inspectChannel);
 const initialInspectDisplayMode = resolveInspectDisplayMode(initialViewPreferences.inspectDisplayMode);
 const initialStoredRenderStyle = resolveForgeRenderStyle(initialViewPreferences.renderStyle);
@@ -21623,7 +18213,7 @@ const useForgeStore = create((set, get) => ({
     set({ meshPreviewFile: meshPath });
     if (meshPath) get().execute();
   },
-  activeBackend: initialViewPreferences.activeBackend || DEFAULT_ACTIVE_BACKEND,
+  activeBackend: initialKernel.name,
   setActiveBackend: (backend) => {
     writeViewPreferences({ activeBackend: backend, computeTarget: "local" });
     clearRunResultCache();
@@ -21631,23 +18221,26 @@ const useForgeStore = create((set, get) => ({
     get().execute();
   },
   setComputeBackend: (backend) => {
-    const parts = computeBackendParts(backend);
-    writeViewPreferences({ activeBackend: parts.activeBackend, computeTarget: parts.computeTarget });
+    const kernel = kernelFromId(backend);
+    if (!availableKernels(canUseServerCompute()).some((available) => available.id === kernel.id)) return;
+    writeViewPreferences({ activeBackend: kernel.name, computeTarget: kernel.location });
     clearRunResultCache();
-    set({ activeBackend: parts.activeBackend, computeTarget: parts.computeTarget });
-    if (parts.computeTarget === "server") {
+    set({ activeBackend: kernel.name, computeTarget: kernel.location });
+    if (kernel.location === "server") {
       startServerPolling();
     }
     get().execute();
   },
-  computeTarget: "local",
+  computeTarget: initialKernel.location,
   setComputeTarget: (target) => {
-    const nextTarget = target;
-    const nextBackend = nextTarget === "server" ? "occt" : get().activeBackend;
-    writeViewPreferences({ activeBackend: nextBackend, computeTarget: nextTarget });
+    const kernel = resolveAvailableKernel(
+      { name: target === "server" ? "occt" : get().activeBackend, location: target },
+      availableKernels(canUseServerCompute())
+    );
+    writeViewPreferences({ activeBackend: kernel.name, computeTarget: kernel.location });
     clearRunResultCache();
-    set({ activeBackend: nextBackend, computeTarget: nextTarget });
-    if (nextTarget === "server") {
+    set({ activeBackend: kernel.name, computeTarget: kernel.location });
+    if (kernel.location === "server") {
       startServerPolling();
     }
     get().execute();
@@ -22191,10 +18784,13 @@ const useForgeStore = create((set, get) => ({
     writeViewPreferences({ inspectIsolineSpacing: next });
     set({ inspectIsolineSpacing: next });
   },
-  inspectCriticalLineEnabled: resolveBooleanPref(
-    initialViewPreferences.inspectCriticalLineEnabled,
-    DEFAULT_INSPECT_CRITICAL_LINE_ENABLED
-  ),
+  inspectQuantizeBands: resolveInspectQuantizeBands(initialViewPreferences.inspectQuantizeBands),
+  setInspectQuantizeBands: (bands) => {
+    const next = resolveInspectQuantizeBands(bands);
+    writeViewPreferences({ inspectQuantizeBands: next });
+    set({ inspectQuantizeBands: next });
+  },
+  inspectCriticalLineEnabled: resolveBooleanPref(initialViewPreferences.inspectCriticalLineEnabled, DEFAULT_INSPECT_CRITICAL_LINE_ENABLED),
   setInspectCriticalLineEnabled: (enabled) => {
     const next = resolveBooleanPref(enabled, DEFAULT_INSPECT_CRITICAL_LINE_ENABLED);
     writeViewPreferences({ inspectCriticalLineEnabled: next });
@@ -27104,7 +23700,7 @@ function OrbitTargetPulseLayer() {
 class ConstructionHistoryWorkerClient {
   constructor(workerFactory = () => new Worker(new URL(
     /* @vite-ignore */
-    "/assets/constructionHistoryWorker-PCwXrTDB.js",
+    "/assets/constructionHistoryWorker-cTHWRJEi.js",
     import.meta.url
   ), { type: "module" })) {
     __publicField(this, "worker", null);
@@ -29616,7 +26212,7 @@ function generateReportInWorker(options) {
   return new Promise((resolve2, reject) => {
     const worker = new Worker(new URL(
       /* @vite-ignore */
-      "/assets/reportWorker-CWvn0CEv.js",
+      "/assets/reportWorker-Cb5eyM7D.js",
       import.meta.url
     ), { type: "module" });
     const cleanup = () => {
@@ -29776,7 +26372,7 @@ function tessellateArc(center, start, end, radius, clockwise, segments) {
   const startAngle = Math.atan2(start[1] - center[1], start[0] - center[0]);
   const endAngle = Math.atan2(end[1] - center[1], end[0] - center[0]);
   let sweep = endAngle - startAngle;
-  const direction2 = clockwise ? -1 : 1;
+  const direction = clockwise ? -1 : 1;
   if (clockwise) {
     if (sweep > 0) sweep -= 2 * Math.PI;
     sweep = -sweep;
@@ -29786,7 +26382,7 @@ function tessellateArc(center, start, end, radius, clockwise, segments) {
   const points = [start];
   for (let k2 = 1; k2 <= segments; k2++) {
     const t2 = k2 / segments * sweep;
-    const angle = startAngle + direction2 * t2;
+    const angle = startAngle + direction * t2;
     points.push([center[0] + radius * Math.cos(angle), center[1] + radius * Math.sin(angle)]);
   }
   return points;
@@ -30471,8 +27067,8 @@ const applyOrbitPose = (camera, target, radius, turn, pitchDeg) => {
   const yaw = normalizedTurn * Math.PI * 2;
   const pitch = MathUtils.degToRad(clampedPitch);
   const cosPitch = Math.cos(pitch);
-  const direction2 = new Vector3(Math.sin(yaw) * cosPitch, -Math.cos(yaw) * cosPitch, Math.sin(pitch)).normalize();
-  camera.position.copy(target).addScaledVector(direction2, radius);
+  const direction = new Vector3(Math.sin(yaw) * cosPitch, -Math.cos(yaw) * cosPitch, Math.sin(pitch)).normalize();
+  camera.position.copy(target).addScaledVector(direction, radius);
   camera.up.set(0, 0, 1);
   camera.lookAt(target);
   if ("updateProjectionMatrix" in camera && typeof camera.updateProjectionMatrix === "function") {
@@ -30512,8 +27108,8 @@ function setOverrideOrbitCamera(session, turn, pitchDeg) {
   const yaw = normalizedTurn * Math.PI * 2;
   const pitch = MathUtils.degToRad(clampedPitch);
   const cosPitch = Math.cos(pitch);
-  const direction2 = new Vector3(Math.sin(yaw) * cosPitch, -Math.cos(yaw) * cosPitch, Math.sin(pitch)).normalize();
-  session.camera.position.copy(session.center).addScaledVector(direction2, session.distance);
+  const direction = new Vector3(Math.sin(yaw) * cosPitch, -Math.cos(yaw) * cosPitch, Math.sin(pitch)).normalize();
+  session.camera.position.copy(session.center).addScaledVector(direction, session.distance);
   session.camera.lookAt(session.center);
   session.camera.updateProjectionMatrix();
 }
@@ -33384,144 +29980,6 @@ function LedgerMetric({ label, value }) {
     }
   );
 }
-const INSPECT_SCALAR_VERTEX_SHADER = `
-  attribute float aValue;
-  varying float vValue;
-  varying vec3 vViewNormal;
-  varying vec3 vViewDirection;
-  #include <clipping_planes_pars_vertex>
-
-  void main() {
-    vValue = aValue;
-    vViewNormal = normalize(normalMatrix * normal);
-    vec4 mvPosition = modelViewMatrix * vec4(position, 1.0);
-    vViewDirection = normalize(-mvPosition.xyz);
-    gl_Position = projectionMatrix * mvPosition;
-    #include <clipping_planes_vertex>
-  }
-`;
-const INSPECT_SCALAR_FRAGMENT_SHADER = `
-  uniform sampler2D uColorScale;
-  uniform float uDomainMin;
-  uniform float uDomainMax;
-  uniform bool uIsoEnabled;
-  uniform float uIsoSpacing;
-  uniform bool uCriticalEnabled;
-  uniform float uCriticalThreshold;
-  uniform bool uShadingEnabled;
-  uniform vec3 uLightDirection;
-  uniform float uAmbient;
-  varying float vValue;
-  varying vec3 vViewNormal;
-  varying vec3 vViewDirection;
-  #include <clipping_planes_pars_fragment>
-
-  void main() {
-    #include <clipping_planes_fragment>
-
-    float span = max(uDomainMax - uDomainMin, 1e-6);
-    float t = clamp((vValue - uDomainMin) / span, 0.0, 1.0);
-    // LUT is pre-baked perceptual sRGB; the texture is NoColorSpace so this fetch
-    // is NOT decoded. Do not apply any further linearization here (critique M1).
-    vec3 color = texture2D(uColorScale, vec2(t, 0.5)).rgb;
-
-    // Anti-aliased isolines / critical line via the fwidth contour trick.
-    if (uIsoEnabled || uCriticalEnabled) {
-      if (uIsoEnabled && uIsoSpacing > 1e-6) {
-        float f = vValue / uIsoSpacing;
-        float grad = fwidth(f);
-        // Distance (in cycles) to the nearest integer contour, anti-aliased by grad.
-        // grad * 1.3 matches the exact contour width of the validated lab preview
-        // (render.mjs) that the user signed off on.
-        float line = abs(fract(f - 0.5) - 0.5) / max(grad * 1.3, 1e-6);
-        float a = 1.0 - clamp(line, 0.0, 1.0);
-        color = mix(color, vec3(0.08, 0.094, 0.118), 0.85 * a);
-      }
-      if (uCriticalEnabled) {
-        float gradV = fwidth(vValue);
-        float dist = abs(vValue - uCriticalThreshold) / max(gradV * 1.6, 1e-6);
-        float a = 1.0 - clamp(dist, 0.0, 1.0);
-        color = mix(color, vec3(1.0, 0.235, 0.235), a);
-      }
-    }
-
-    if (uShadingEnabled) {
-      vec3 n = normalize(vViewNormal);
-      // Two-sided Lambert: inspection surfaces are viewed from either face.
-      float lambert = abs(dot(n, normalize(uLightDirection)));
-      float shade = uAmbient + (1.0 - uAmbient) * lambert;
-      color *= shade;
-      float rim = pow(1.0 - clamp(dot(n, normalize(vViewDirection)), 0.0, 1.0), 2.0);
-      color += vec3(0.025, 0.04, 0.055) * rim;
-    }
-
-    gl_FragColor = vec4(color, 1.0);
-  }
-`;
-const COLOR_SCALE_LUT_LENGTH = 256 * 4;
-function makeColorScaleTexture(lut) {
-  if (!(lut instanceof Uint8Array)) {
-    throw new TypeError("makeColorScaleTexture: lut must be a Uint8Array of RGBA bytes.");
-  }
-  if (lut.length !== COLOR_SCALE_LUT_LENGTH) {
-    throw new RangeError(
-      `makeColorScaleTexture: lut must be exactly ${COLOR_SCALE_LUT_LENGTH} bytes (256 RGBA stops), got ${lut.length}.`
-    );
-  }
-  const texture = new DataTexture(lut, 256, 1, RGBAFormat, UnsignedByteType);
-  texture.colorSpace = NoColorSpace;
-  texture.minFilter = LinearFilter;
-  texture.magFilter = LinearFilter;
-  texture.wrapS = ClampToEdgeWrapping;
-  texture.wrapT = ClampToEdgeWrapping;
-  texture.generateMipmaps = false;
-  texture.unpackAlignment = 1;
-  texture.needsUpdate = true;
-  return texture;
-}
-const DEFAULT_LIGHT_DIRECTION = new Vector3(0.45, 0.55, 0.75).normalize();
-const DEFAULT_AMBIENT = 0.42;
-function makeInspectScalarUniforms(params) {
-  if (!Number.isFinite(params.domainMin) || !Number.isFinite(params.domainMax)) {
-    throw new RangeError(
-      `makeInspectScalarUniforms: domainMin/domainMax must be finite, got [${params.domainMin}, ${params.domainMax}].`
-    );
-  }
-  return {
-    uColorScale: { value: params.colorScale },
-    uDomainMin: { value: params.domainMin },
-    uDomainMax: { value: params.domainMax },
-    uIsoEnabled: { value: params.isoEnabled ?? false },
-    uIsoSpacing: { value: params.isoSpacing ?? 0 },
-    uCriticalEnabled: { value: params.criticalEnabled ?? false },
-    uCriticalThreshold: { value: params.criticalThreshold ?? 0 },
-    uShadingEnabled: { value: params.shadingEnabled ?? true },
-    uLightDirection: { value: (params.lightDirection ?? DEFAULT_LIGHT_DIRECTION).clone() },
-    uAmbient: { value: params.ambient ?? DEFAULT_AMBIENT }
-  };
-}
-function updateInspectScalarUniforms(uniforms, params) {
-  if (params.colorScale !== void 0) uniforms.uColorScale.value = params.colorScale;
-  if (params.domainMin !== void 0) {
-    if (!Number.isFinite(params.domainMin)) {
-      throw new RangeError(`updateInspectScalarUniforms: domainMin must be finite, got ${params.domainMin}.`);
-    }
-    uniforms.uDomainMin.value = params.domainMin;
-  }
-  if (params.domainMax !== void 0) {
-    if (!Number.isFinite(params.domainMax)) {
-      throw new RangeError(`updateInspectScalarUniforms: domainMax must be finite, got ${params.domainMax}.`);
-    }
-    uniforms.uDomainMax.value = params.domainMax;
-  }
-  if (params.isoEnabled !== void 0) uniforms.uIsoEnabled.value = params.isoEnabled;
-  if (params.isoSpacing !== void 0) uniforms.uIsoSpacing.value = params.isoSpacing;
-  if (params.criticalEnabled !== void 0) uniforms.uCriticalEnabled.value = params.criticalEnabled;
-  if (params.criticalThreshold !== void 0) uniforms.uCriticalThreshold.value = params.criticalThreshold;
-  if (params.shadingEnabled !== void 0) uniforms.uShadingEnabled.value = params.shadingEnabled;
-  if (params.lightDirection !== void 0) uniforms.uLightDirection.value.copy(params.lightDirection);
-  if (params.ambient !== void 0) uniforms.uAmbient.value = params.ambient;
-}
 const PREVIEW_RENDER_ORDER_STEP = 1;
 const HATCH_DIRECTION_A = new Vector2(Math.cos(MathUtils.degToRad(35)), Math.sin(MathUtils.degToRad(35)));
 const HATCH_DIRECTION_B = new Vector2(Math.cos(MathUtils.degToRad(125)), Math.sin(MathUtils.degToRad(125)));
@@ -35054,7 +31512,7 @@ function ForgeObject({
   onDoubleClick,
   onContextMenu
 }) {
-  var _a3, _b2, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n;
+  var _a3, _b2, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o;
   const wantsDirectSdf = Boolean(
     canRenderSdfDirectly(obj.sdf) && inspectChannel === "none" && renderStyle !== "scan" && renderStyle !== "matrix" && renderMode !== "wireframe" && !debugHighlightColor
   );
@@ -35147,6 +31605,7 @@ function ForgeObject({
       colorScale: inspectColormapTexture,
       domainMin: effectiveColorScale.domainMin,
       domainMax: effectiveColorScale.domainMax,
+      quantizeBands: (inspectScalarParams == null ? void 0 : inspectScalarParams.quantizeBands) ?? 0,
       isoEnabled: (inspectScalarParams == null ? void 0 : inspectScalarParams.isolinesEnabled) ?? false,
       isoSpacing: (inspectScalarParams == null ? void 0 : inspectScalarParams.isolineSpacing) ?? 0,
       criticalEnabled: Boolean((inspectScalarParams == null ? void 0 : inspectScalarParams.criticalEnabled) && (inspectScalarParams == null ? void 0 : inspectScalarParams.criticalThreshold) != null),
@@ -35195,6 +31654,7 @@ function ForgeObject({
     updateInspectScalarUniforms(inspectScalarUniforms, {
       domainMin: effectiveColorScale.domainMin,
       domainMax: effectiveColorScale.domainMax,
+      quantizeBands: inspectScalarParams.quantizeBands,
       isoEnabled: inspectScalarParams.isolinesEnabled,
       isoSpacing: inspectScalarParams.isolineSpacing,
       criticalEnabled: inspectScalarParams.criticalEnabled && inspectScalarParams.criticalThreshold != null,
@@ -35208,13 +31668,35 @@ function ForgeObject({
       Object.values(scanAnalysisGeometries ?? {}).forEach((geometry) => geometry == null ? void 0 : geometry.dispose());
     };
   }, [scanAnalysisGeometries]);
+  const textureDescriptor = (_a3 = obj.materialProps) == null ? void 0 : _a3.texture;
+  const projectedTexture = reactExports.useMemo(() => {
+    if (!textureDescriptor) return null;
+    return descriptorToThreeTexture(textureDescriptor.image, { colorSpace: "srgb" });
+  }, [textureDescriptor]);
+  const solidMaterialRef = reactExports.useRef(null);
+  const setSolidMaterial = reactExports.useCallback(
+    (material) => {
+      solidMaterialRef.current = material;
+      if (material && projectedTexture && textureDescriptor) {
+        applyProjectedTexture(material, textureDescriptor.projection, projectedTexture);
+      }
+    },
+    [projectedTexture, textureDescriptor]
+  );
+  reactExports.useEffect(() => {
+    const material = solidMaterialRef.current;
+    if (material && projectedTexture && textureDescriptor) {
+      applyProjectedTexture(material, textureDescriptor.projection, projectedTexture);
+      invalidate2();
+    }
+  }, [projectedTexture, textureDescriptor, invalidate2]);
   if (!settings.visible) return null;
   const effectiveRenderMode = isInteracting && renderMode === "overlay" ? "solid" : renderMode;
   const renderStylePreset = getRenderStylePreset(renderStyle);
   const materialDefaults = renderStylePreset.material;
   const surfaceField = renderStylePreset.surfaceField;
-  const authoredMaterialOpacity = (_a3 = obj.materialProps) == null ? void 0 : _a3.opacity;
-  const authoredMaterialTransmission = (_b2 = obj.materialProps) == null ? void 0 : _b2.transmission;
+  const authoredMaterialOpacity = (_b2 = obj.materialProps) == null ? void 0 : _b2.opacity;
+  const authoredMaterialTransmission = (_c = obj.materialProps) == null ? void 0 : _c.transmission;
   const hasAuthoredTransparency = authoredMaterialOpacity !== void 0 && authoredMaterialOpacity < 0.99 || authoredMaterialTransmission !== void 0 && authoredMaterialTransmission > 0;
   const transparentDefaults = hasAuthoredTransparency ? materialDefaults.authoredTransparent : materialDefaults;
   const meshOpacity = settings.opacity;
@@ -35307,7 +31789,8 @@ function ForgeObject({
             polygonOffset: inspectChannel === "floating",
             polygonOffsetFactor: -1,
             polygonOffsetUnits: -1
-          }
+          },
+          hasInspectMeshColors ? "inspect-vertex-colors" : "inspect-solid-color"
         ) }),
         showSolid && inspectChannel === "normals" && /* @__PURE__ */ jsxRuntimeExports.jsx("mesh", { geometry: solidGeo, userData: { forgeMesh: true }, children: /* @__PURE__ */ jsxRuntimeExports.jsx(
           "meshNormalMaterial",
@@ -35492,25 +31975,26 @@ function ForgeObject({
         ) : /* @__PURE__ */ jsxRuntimeExports.jsx(
           "meshPhysicalMaterial",
           {
+            ref: setSolidMaterial,
             color: settings.color,
-            metalness: ((_c = obj.materialProps) == null ? void 0 : _c.metalness) ?? materialDefaults.metalness,
-            roughness: ((_d = obj.materialProps) == null ? void 0 : _d.roughness) ?? transparentDefaults.roughness,
-            clearcoat: ((_e = obj.materialProps) == null ? void 0 : _e.clearcoat) ?? transparentDefaults.clearcoat,
-            clearcoatRoughness: ((_f = obj.materialProps) == null ? void 0 : _f.clearcoatRoughness) ?? transparentDefaults.clearcoatRoughness,
+            metalness: ((_d = obj.materialProps) == null ? void 0 : _d.metalness) ?? materialDefaults.metalness,
+            roughness: ((_e = obj.materialProps) == null ? void 0 : _e.roughness) ?? transparentDefaults.roughness,
+            clearcoat: ((_f = obj.materialProps) == null ? void 0 : _f.clearcoat) ?? transparentDefaults.clearcoat,
+            clearcoatRoughness: ((_g = obj.materialProps) == null ? void 0 : _g.clearcoatRoughness) ?? transparentDefaults.clearcoatRoughness,
             transmission,
-            ior: ((_g = obj.materialProps) == null ? void 0 : _g.ior) ?? 1.5,
-            thickness: ((_h = obj.materialProps) == null ? void 0 : _h.thickness) ?? transparentDefaults.thickness,
-            reflectivity: ((_i = obj.materialProps) == null ? void 0 : _i.reflectivity) ?? transparentDefaults.reflectivity,
-            specularIntensity: ((_j = obj.materialProps) == null ? void 0 : _j.specularIntensity) ?? transparentDefaults.specularIntensity,
-            specularColor: ((_k = obj.materialProps) == null ? void 0 : _k.specularColor) ?? "#ffffff",
+            ior: ((_h = obj.materialProps) == null ? void 0 : _h.ior) ?? 1.5,
+            thickness: ((_i = obj.materialProps) == null ? void 0 : _i.thickness) ?? transparentDefaults.thickness,
+            reflectivity: ((_j = obj.materialProps) == null ? void 0 : _j.reflectivity) ?? transparentDefaults.reflectivity,
+            specularIntensity: ((_k = obj.materialProps) == null ? void 0 : _k.specularIntensity) ?? transparentDefaults.specularIntensity,
+            specularColor: ((_l = obj.materialProps) == null ? void 0 : _l.specularColor) ?? "#ffffff",
             flatShading: !hasSmoothNormals,
             side: DoubleSide,
             transparent: isTransparent,
             opacity: materialOpacity,
             depthWrite: !isTransparent,
-            emissive: isHovered ? settings.color : ((_l = obj.materialProps) == null ? void 0 : _l.emissive) ?? "#000000",
-            emissiveIntensity: isHovered ? 0.3 : ((_m = obj.materialProps) == null ? void 0 : _m.emissiveIntensity) ?? 0,
-            wireframe: ((_n = obj.materialProps) == null ? void 0 : _n.wireframe) ?? false,
+            emissive: isHovered ? settings.color : ((_m = obj.materialProps) == null ? void 0 : _m.emissive) ?? "#000000",
+            emissiveIntensity: isHovered ? 0.3 : ((_n = obj.materialProps) == null ? void 0 : _n.emissiveIntensity) ?? 0,
+            wireframe: ((_o = obj.materialProps) == null ? void 0 : _o.wireframe) ?? false,
             clippingPlanes: effectiveClippingPlanes
           }
         ) }),
@@ -35600,13 +32084,13 @@ const resolveArcReferenceDirection = (axisWorld) => {
   return fallback.normalize();
 };
 const resolveSegmentMeshTransform = (start, end) => {
-  const direction2 = end.clone().sub(start);
-  const length = direction2.length();
+  const direction = end.clone().sub(start);
+  const length = direction.length();
   if (length <= 1e-6) return null;
-  direction2.multiplyScalar(1 / length);
+  direction.multiplyScalar(1 / length);
   return {
     midpoint: start.clone().add(end).multiplyScalar(0.5),
-    quaternion: new Quaternion().setFromUnitVectors(WORLD_UP$1, direction2),
+    quaternion: new Quaternion().setFromUnitVectors(WORLD_UP$1, direction),
     length
   };
 };
@@ -35731,8 +32215,8 @@ function HoveredJointOverlay({ state: state2, config }) {
     const points = [];
     for (let i = 0; i <= steps; i += 1) {
       const theta = arcAngleRad * (i / steps);
-      const direction2 = arcStartDirection.clone().applyAxisAngle(state2.axisWorld, theta);
-      points.push(state2.pivotWorld.clone().addScaledVector(direction2, arcRadius));
+      const direction = arcStartDirection.clone().applyAxisAngle(state2.axisWorld, theta);
+      points.push(state2.pivotWorld.clone().addScaledVector(direction, arcRadius));
     }
     return points;
   }, [
@@ -36460,6 +32944,7 @@ function InspectionLegend({
   displayMode,
   warnings,
   details,
+  swatches: liveSwatches,
   thicknessColorRange,
   onThicknessColorRangeChange,
   colorScale,
@@ -36474,6 +32959,7 @@ function InspectionLegend({
     unitLabel,
     criticalValue
   });
+  const swatches = liveSwatches && liveSwatches.length > 0 ? liveSwatches : definition == null ? void 0 : definition.swatches;
   const sliderGradient = colorScaleHexStops((colorScale == null ? void 0 : colorScale.colormap) ?? "viridis");
   reactExports.useEffect(() => {
     var _a3;
@@ -36488,10 +32974,13 @@ function InspectionLegend({
   if (!definition) return null;
   const warning = warnings[0];
   const showThicknessControls = channel === "thickness" && thicknessColorRange !== void 0 && onThicknessColorRangeChange !== void 0;
+  const swatchCount = (swatches == null ? void 0 : swatches.length) ?? 0;
+  const hasScrollableSwatches = swatchCount > 10;
   const effectivePanelStyle = {
     ...panelStyle,
     ...compact ? { padding: "7px 8px" } : {},
-    ...showThicknessControls ? { pointerEvents: "auto" } : {}
+    ...showThicknessControls || hasScrollableSwatches ? { pointerEvents: "auto" } : {},
+    ...hasScrollableSwatches ? { maxHeight: "min(320px, calc(100vh - 24px))", overflowY: "auto" } : {}
   };
   return /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { ref: panelRef, className: "fc-viewport-floating-panel fc-inspection-legend", style: effectivePanelStyle, children: [
     /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { style: titleStyle, children: [
@@ -36513,14 +33002,14 @@ function InspectionLegend({
       "div",
       {
         style: {
-          marginBottom: definition.ramp || definition.swatches ? 8 : 0,
+          marginBottom: definition.ramp || swatches ? 8 : 0,
           color: "var(--fc-text)",
           minWidth: 0
         },
         children: details
       }
     ),
-    definition.swatches && /* @__PURE__ */ jsxRuntimeExports.jsx(
+    swatches && /* @__PURE__ */ jsxRuntimeExports.jsx(
       "div",
       {
         style: {
@@ -36528,7 +33017,7 @@ function InspectionLegend({
           gridTemplateColumns: compact ? "minmax(0, 1fr)" : swatchGridStyle.gridTemplateColumns,
           marginTop: definition.ramp ? 8 : 0
         },
-        children: definition.swatches.map((item) => /* @__PURE__ */ jsxRuntimeExports.jsx(Swatch, { item }, `${item.label}:${item.detail}`))
+        children: swatches.map((item) => /* @__PURE__ */ jsxRuntimeExports.jsx(Swatch, { item }, `${item.label}:${item.detail}`))
       }
     ),
     warning && /* @__PURE__ */ jsxRuntimeExports.jsx(
@@ -37943,16 +34432,16 @@ function releasePointerCapture(event) {
   const target = event.target;
   (_a3 = target.releasePointerCapture) == null ? void 0 : _a3.call(target, event.pointerId);
 }
-function calculateAxisDragDelta(clickPoint, axis, ray2) {
+function calculateAxisDragDelta(clickPoint, axis, ray) {
   const axisLenSq = axis.dot(axis);
   if (axisLenSq <= 1e-8) return 0;
-  const startOffset = axis.dot(clickPoint) - axis.dot(ray2.origin);
-  const rayAxisDot = axis.dot(ray2.direction);
+  const startOffset = axis.dot(clickPoint) - axis.dot(ray.origin);
+  const rayAxisDot = axis.dot(ray.direction);
   if (Math.abs(rayAxisDot) <= 1e-8) {
     return -startOffset / axisLenSq;
   }
-  dragAxisScratchA.copy(ray2.direction).multiplyScalar(axisLenSq / rayAxisDot).sub(axis);
-  dragAxisScratchB.copy(ray2.direction).multiplyScalar(startOffset / rayAxisDot).add(ray2.origin).sub(clickPoint);
+  dragAxisScratchA.copy(ray.direction).multiplyScalar(axisLenSq / rayAxisDot).sub(axis);
+  dragAxisScratchB.copy(ray.direction).multiplyScalar(startOffset / rayAxisDot).add(ray.origin).sub(clickPoint);
   const denom = dragAxisScratchA.dot(dragAxisScratchA);
   return denom <= 1e-8 ? 0 : -dragAxisScratchA.dot(dragAxisScratchB) / denom;
 }
@@ -38534,7 +35023,7 @@ function SectionCapMaterial({
     const objectColor = parseExportColor(color, 6003669);
     const baseColor = objectColor.clone().lerp(new Color("#f5f7fb"), 0.1);
     const lineColor = objectColor.clone().lerp(new Color("#111111"), 0.45);
-    const direction2 = new Vector2(Math.cos(hatchAngleRad), Math.sin(hatchAngleRad));
+    const direction = new Vector2(Math.cos(hatchAngleRad), Math.sin(hatchAngleRad));
     const mat = new MeshStandardMaterial({
       color: baseColor,
       roughness: 0.48,
@@ -38551,7 +35040,7 @@ function SectionCapMaterial({
     });
     mat.onBeforeCompile = (shader) => {
       shader.uniforms.hatchLineColor = { value: lineColor };
-      shader.uniforms.hatchDirection = { value: direction2 };
+      shader.uniforms.hatchDirection = { value: direction };
       shader.uniforms.hatchSpacing = { value: hatchSpacing };
       shader.uniforms.hatchLineWidth = { value: hatchLineWidth };
       shader.vertexShader = shader.vertexShader.replace("#include <common>", "#include <common>\nattribute vec2 planeUv;\nvarying vec2 vSectionPlaneUv;").replace("#include <begin_vertex>", "#include <begin_vertex>\nvSectionPlaneUv = planeUv;");
@@ -42045,11 +38534,11 @@ const computeExplodeTreeOffsets = (root, explodeAmount, explodeConfig) => {
     const center = explodeBoundsCenter(node.bounds) ?? parentCenter;
     const directive = resolveExplodeDirective([node.path.join("/")], node.label, void 0, config);
     const motion = depth > 1 && node.children.length === 0 && !hasExplodeOverride(directive) ? (() => {
-      const direction2 = resolveExplodeLocalFanDirection(center, parentCenter, parentDirection, node.key);
+      const direction = resolveExplodeLocalFanDirection(center, parentCenter, parentDirection, node.key);
       return {
-        direction: direction2,
-        branchDirection: parentDirection ?? direction2,
-        offset: explodeMul(direction2, config.amount * explodeLeafFanStage(config, depth))
+        direction,
+        branchDirection: parentDirection ?? direction,
+        offset: explodeMul(direction, config.amount * explodeLeafFanStage(config, depth))
       };
     })() : computeExplodeMotion({
       pathKeys: [node.path.join("/")],
@@ -42412,6 +38901,7 @@ function useViewportState() {
   const inspectColormap = useForgeStore((s) => s.inspectColormap);
   const inspectIsolinesEnabled = useForgeStore((s) => s.inspectIsolinesEnabled);
   const inspectIsolineSpacing = useForgeStore((s) => s.inspectIsolineSpacing);
+  const inspectQuantizeBands = useForgeStore((s) => s.inspectQuantizeBands);
   const inspectCriticalLineEnabled = useForgeStore((s) => s.inspectCriticalLineEnabled);
   const comparisonInspectMode = useForgeStore((s) => s.comparisonInspectMode);
   const comparisonCandidateOpacity = useForgeStore((s) => s.comparisonCandidateOpacity);
@@ -42827,6 +39317,7 @@ function useViewportState() {
     inspectColormap,
     inspectIsolinesEnabled,
     inspectIsolineSpacing,
+    inspectQuantizeBands,
     inspectCriticalLineEnabled,
     comparisonInspectMode,
     comparisonCandidateOpacity,
@@ -44513,6 +41004,7 @@ function mergeResults(results, channel, analysisId) {
     meshColorObjects: [],
     scalarSurfaceObjects: [],
     collisionGeometryObjects: [],
+    legendSwatches: [],
     warnings: []
   };
   for (const result of results) {
@@ -44521,6 +41013,7 @@ function mergeResults(results, channel, analysisId) {
     merged.meshColorObjects.push(...result.meshColorObjects);
     merged.scalarSurfaceObjects.push(...result.scalarSurfaceObjects);
     merged.collisionGeometryObjects.push(...result.collisionGeometryObjects);
+    merged.legendSwatches.push(...result.legendSwatches);
     merged.warnings.push(...result.warnings);
   }
   return merged;
@@ -44528,7 +41021,7 @@ function mergeResults(results, channel, analysisId) {
 class InspectWorkerClient {
   constructor(workerFactory = () => new Worker(new URL(
     /* @vite-ignore */
-    "/assets/inspectWorker-Y4cOzNyA.js",
+    "/assets/inspectWorker-ymhBV4Ll.js",
     import.meta.url
   ), { type: "module" })) {
     __publicField(this, "reqId", 0);
@@ -44940,6 +41433,7 @@ function resultToState(channel, result) {
         }
       ])
     ),
+    legendSwatches: result.legendSwatches,
     warnings: result.warnings,
     error: null
   };
@@ -44953,6 +41447,7 @@ function useInspectWorkerAnalysis(args) {
     pointClouds: {},
     scalarSurfaces: {},
     collisionGeometries: [],
+    legendSwatches: [],
     warnings: [],
     error: null
   });
@@ -44967,6 +41462,7 @@ function useInspectWorkerAnalysis(args) {
         pointClouds: {},
         scalarSurfaces: {},
         collisionGeometries: [],
+        legendSwatches: [],
         warnings: [],
         error: null
       });
@@ -44982,6 +41478,7 @@ function useInspectWorkerAnalysis(args) {
       pointClouds: {},
       scalarSurfaces: {},
       collisionGeometries: [],
+      legendSwatches: [],
       warnings: [],
       error: null
     });
@@ -45021,6 +41518,7 @@ function useInspectWorkerAnalysis(args) {
           pointClouds: {},
           scalarSurfaces: {},
           collisionGeometries: [],
+          legendSwatches: [],
           warnings: [],
           error: error instanceof Error ? error.message : String(error)
         });
@@ -45062,19 +41560,19 @@ function dominantAxis(normal) {
   if (ay >= ax && ay >= az) return "y";
   return "z";
 }
-function anchoredCellIndex(value, cellSize, direction2) {
+function anchoredCellIndex(value, cellSize, direction) {
   const scaled = value / cellSize;
   const base = Math.floor(scaled);
   const onBoundary = Math.abs(scaled - Math.round(scaled)) < 1e-7;
-  return onBoundary && direction2 < 0 ? base - 1 : base;
+  return onBoundary && direction < 0 ? base - 1 : base;
 }
 function voxelCellFromSurfaceAnchor(point, normal, cellSize, side) {
   const cell = voxelCellFromPoint(point, cellSize);
   const axis = dominantAxis(normal);
   const normalValue = normal[axis];
   const outsideDirection = normalValue < 0 ? -1 : 1;
-  const direction2 = side === "outside" ? outsideDirection : -outsideDirection;
-  cell[axis] = anchoredCellIndex(point[axis], cellSize, direction2);
+  const direction = side === "outside" ? outsideDirection : -outsideDirection;
+  cell[axis] = anchoredCellIndex(point[axis], cellSize, direction);
   return cell;
 }
 function parseVoxelCellKey(key) {
@@ -45526,6 +42024,7 @@ function Viewport() {
     inspectColormap,
     inspectIsolinesEnabled,
     inspectIsolineSpacing,
+    inspectQuantizeBands,
     inspectCriticalLineEnabled,
     comparisonInspectMode,
     comparisonCandidateOpacity,
@@ -45691,13 +42190,21 @@ function Viewport() {
     if (!scalarChannelInfo) return void 0;
     return {
       colorScale: inspectColorScale,
+      quantizeBands: inspectQuantizeBands,
       isolinesEnabled: inspectIsolinesEnabled,
       isolineSpacing: inspectIsolineSpacing,
       criticalEnabled: inspectCriticalLineEnabled,
       criticalThreshold: scalarChannelInfo.criticalThreshold,
       shadingEnabled: true
     };
-  }, [scalarChannelInfo, inspectColorScale, inspectIsolinesEnabled, inspectIsolineSpacing, inspectCriticalLineEnabled]);
+  }, [
+    scalarChannelInfo,
+    inspectColorScale,
+    inspectQuantizeBands,
+    inspectIsolinesEnabled,
+    inspectIsolineSpacing,
+    inspectCriticalLineEnabled
+  ]);
   const comparisonAnalysis = useGeometryComparison({
     enabled: comparisonInspectActive,
     candidate: result,
@@ -45709,6 +42216,23 @@ function Viewport() {
   const inspectLoading = inspectChannelActive && (comparisonInspectActive ? comparisonAnalysis.status === "loading" : inspectAnalysis.status === "loading");
   const inspectError = comparisonInspectActive ? comparisonAnalysis.error : inspectAnalysis.error;
   const inspectWarnings = comparisonInspectActive ? comparisonAnalysis.warnings : inspectAnalysis.warnings;
+  const maskLegendSwatches = reactExports.useMemo(() => {
+    const swatches = [];
+    objects.forEach((obj, objIndex) => {
+      const settings = objectSettings[obj.id] ?? DEFAULT_OBJECT_SETTINGS;
+      if (settings.visible === false) return;
+      swatches.push({
+        label: obj.name || `Object ${objIndex + 1}`,
+        detail: obj.id,
+        color: maskColorForIndex(objIndex)
+      });
+    });
+    return swatches;
+  }, [objectSettings, objects]);
+  const inspectLegendSwatches = reactExports.useMemo(() => {
+    if (inspectChannel === "mask") return maskLegendSwatches;
+    return inspectAnalysis.legendSwatches.length > 0 ? inspectAnalysis.legendSwatches : void 0;
+  }, [inspectAnalysis.legendSwatches, inspectChannel, maskLegendSwatches]);
   const historyGeometryLoading = historyMode && historyGeometryStatus.status === "loading";
   const viewportBusyPhase = isEvaluating || evaluationPhase === "exporting" ? evaluationPhase : historyGeometryLoading ? "history" : inspectLoading ? "inspecting" : null;
   const viewportBusyLabel = historyGeometryLoading ? "Building timeline geometry" : inspectLoading ? `Generating ${inspectChannelLabel(inspectChannel)} inspect view` : void 0;
@@ -45779,7 +42303,7 @@ function Viewport() {
     candidates.sort((a2, b2) => a2.distance - b2.distance);
     return candidates[0].normal;
   };
-  const voxelBlockHitsOnRay = (ray2, cellSize) => {
+  const voxelBlockHitsOnRay = (ray, cellSize) => {
     const hits = [];
     const halfExtent = cellSize * 0.55;
     const hitPoint = new Vector3();
@@ -45790,9 +42314,9 @@ function Viewport() {
         new Vector3(center.x - halfExtent, center.y - halfExtent, center.z - halfExtent),
         new Vector3(center.x + halfExtent, center.y + halfExtent, center.z + halfExtent)
       );
-      const intersection = ray2.intersectBox(bounds, hitPoint);
+      const intersection = ray.intersectBox(bounds, hitPoint);
       if (!intersection) continue;
-      const alongRay = intersection.clone().sub(ray2.origin).dot(ray2.direction);
+      const alongRay = intersection.clone().sub(ray.origin).dot(ray.direction);
       hits.push({ cell: { x, y, z }, normal: voxelNormalFromBoxHit(intersection, bounds), alongRay });
     }
     hits.sort((a2, b2) => a2.alongRay - b2.alongRay);
@@ -45915,6 +42439,7 @@ function Viewport() {
           channel: inspectChannel,
           displayMode: inspectDisplayMode,
           warnings: inspectWarnings,
+          swatches: inspectLegendSwatches,
           thicknessColorRange,
           onThicknessColorRangeChange: setThicknessColorRange,
           colorScale: scalarChannelInfo ? inspectColorScale : void 0,
@@ -46969,7 +43494,7 @@ function Viewport() {
     }
   );
 }
-const EditorApp$1 = reactExports.lazy(() => __vitePreload(() => import("./EditorApp-HLoKfe15.js"), true ? __vite__mapDeps([0]) : void 0).then((m2) => ({ default: m2.EditorApp })));
+const EditorApp$1 = reactExports.lazy(() => __vitePreload(() => import("./EditorApp-BWUGCdD5.js"), true ? __vite__mapDeps([0]) : void 0).then((m2) => ({ default: m2.EditorApp })));
 const PENDING_SHARE_COPY_KEY = "fc-pending-share-copy";
 function storePendingShareCopy(shareId) {
   sessionStorage.setItem(PENDING_SHARE_COPY_KEY, shareId);
@@ -47158,7 +43683,7 @@ const PublishedModelPage$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Objec
 }, Symbol.toStringTag, { value: "Module" }));
 const siteUrl = "https://forgecad.io";
 const defaultImage = "https://forgecad.io/brand/social-card.png";
-const pages$1 = [{ "path": "/", "title": "ForgeCAD - AI-Native CAD for Manufacturable Models", "description": "ForgeCAD turns prompts, JavaScript, and product ideas into editable parametric CAD with agent validation, manufacturing feedback, and STEP/STL exports.", "priority": "1.0", "changefreq": "weekly" }, { "path": "/docs", "title": "ForgeCAD Documentation - AI-Native Parametric CAD", "description": "Learn ForgeCAD's JavaScript CAD API, agent workflow, validation loop, exports, assemblies, sketches, and manufacturing-ready model checks.", "priority": "0.8", "changefreq": "weekly" }, { "path": "/docs/ai-native-cad", "title": "AI-Native CAD Workflow - ForgeCAD", "description": "How ForgeCAD supports AI-driven CAD: editable code, validation evidence, manufacturing feedback, and parallel product idea iteration.", "priority": "0.9", "changefreq": "weekly" }, { "path": "/docs/ai-usage", "title": "AI CAD Agent Setup - ForgeCAD", "description": "Set up Codex, Claude Code, OpenCode, or another agent to build, validate, inspect, export, and publish ForgeCAD models.", "priority": "0.8", "changefreq": "weekly" }, { "path": "/docs/cli", "title": "ForgeCAD CLI - Validate, Inspect, Export, Publish", "description": "Use the ForgeCAD CLI to run .forge.js models, render evidence, inspect manufacturability, export STEP/STL/3MF, and sync projects.", "priority": "0.7", "changefreq": "weekly" }, { "path": "/docs/simready-quickstart", "title": "ForgeCAD SimReady Quickstart - Source-Authored Simulation Metadata", "description": "Author ForgeCAD assemblies with physical bodies, materials, colliders, joints, controllers, offline SimReady checks, and simulator exports.", "priority": "0.8", "changefreq": "weekly" }, { "path": "/docs/simulation-workflow", "title": "ForgeCAD Simulation Workflow - MuJoCo, Gym, and Isaac Lab Handoff", "description": "Take a ForgeCAD robot through MJCF export, MuJoCo playback, Gymnasium training, force-push interaction tests, and Isaac Lab integration planning.", "priority": "0.8", "changefreq": "weekly" }, { "path": "/docs/skills/forgecad-make-a-model", "title": "AI CAD Model-Making Skill - ForgeCAD", "description": "A workflow for AI agents to create manufacture-realistic ForgeCAD models with validation, renders, inspection evidence, and exports.", "priority": "0.7", "changefreq": "weekly" }, { "path": "/benchmark", "title": "ForgeCAD Benchmark - AI CAD Model Generation", "description": "Benchmark AI agents generating real ForgeCAD models with executable code, visual evidence, validation output, and geometry checks.", "priority": "0.7", "changefreq": "weekly" }, { "path": "/blog", "title": "ForgeCAD Blog - AI-Native CAD and Manufacturing Workflows", "description": "Product notes, tutorials, examples, and technical updates on AI-native CAD, parametric modeling, validation, and manufacturing exports.", "priority": "0.6", "changefreq": "weekly" }, { "path": "/pricing", "title": "ForgeCAD Pricing", "description": "ForgeCAD plans for browser CAD, local CLI workflows, AI agent model generation, project publishing, and commercial use.", "priority": "0.5", "changefreq": "monthly" }, { "path": "/terms", "title": "ForgeCAD Terms of Service", "description": "Terms for ForgeCAD accounts, projects, hosted services, CLI use, commercial use, automation, and AI-assisted workflows.", "priority": "0.3", "changefreq": "yearly" }, { "path": "/privacy", "title": "ForgeCAD Privacy Policy", "description": "How ForgeCAD handles account, project, billing, analytics, and service data for the website, CLI, and hosted app.", "priority": "0.3", "changefreq": "yearly" }, { "path": "/license", "title": "ForgeCAD Software License", "description": "ForgeCAD license terms for Free, Pro, Enterprise, embedded, backend, local CLI, and AI workflow usage.", "priority": "0.3", "changefreq": "yearly" }];
+const pages$1 = [{ "path": "/", "title": "ForgeCAD - AI-Native CAD for Products, Manufacturing, and Robotics", "description": "ForgeCAD generates editable parametric CAD for real products, manufacturing components, robotics simulation assets, and AI training data with validation evidence and STEP/STL/3MF exports.", "priority": "1.0", "changefreq": "weekly" }, { "path": "/docs", "title": "ForgeCAD Documentation - AI-Native Parametric CAD", "description": "Learn ForgeCAD's AI-native CAD API, agent workflow, validation loop, exports, assemblies, sketches, simulation metadata, and manufacturing-ready model checks.", "priority": "0.8", "changefreq": "weekly" }, { "path": "/docs/ai-native-cad", "title": "AI-Native CAD Workflow - ForgeCAD", "description": "How ForgeCAD supports AI-driven CAD: editable code, validation evidence, manufacturing feedback, and parallel product idea iteration.", "priority": "0.9", "changefreq": "weekly" }, { "path": "/docs/ai-usage", "title": "AI CAD Agent Setup - ForgeCAD", "description": "Set up Codex, Claude Code, OpenCode, or another agent to build, validate, inspect, export, and publish ForgeCAD models.", "priority": "0.8", "changefreq": "weekly" }, { "path": "/docs/cli", "title": "ForgeCAD CLI - Validate, Inspect, Export, Publish", "description": "Use the ForgeCAD CLI to run .forge.js models, render evidence, inspect manufacturability, export STEP/STL/3MF, and sync projects.", "priority": "0.7", "changefreq": "weekly" }, { "path": "/docs/simready-quickstart", "title": "ForgeCAD SimReady Quickstart - Source-Authored Simulation Metadata", "description": "Author ForgeCAD assemblies with physical bodies, materials, colliders, joints, controllers, offline SimReady checks, and simulator exports.", "priority": "0.8", "changefreq": "weekly" }, { "path": "/docs/simulation-workflow", "title": "ForgeCAD Simulation Workflow - MuJoCo, Gym, and Isaac Lab Handoff", "description": "Take a ForgeCAD robot through MJCF export, MuJoCo playback, Gymnasium training, force-push interaction tests, and Isaac Lab integration planning.", "priority": "0.8", "changefreq": "weekly" }, { "path": "/docs/skills/forgecad-build-model", "title": "AI CAD Model-Making Skill - ForgeCAD", "description": "A workflow for AI agents to create manufacture-realistic ForgeCAD models with validation, renders, inspection evidence, and exports.", "priority": "0.7", "changefreq": "weekly" }, { "path": "/benchmark", "title": "ForgeCAD Benchmark - AI CAD Model Generation", "description": "Benchmark AI agents generating real ForgeCAD models with executable code, visual evidence, validation output, and geometry checks.", "priority": "0.7", "changefreq": "weekly" }, { "path": "/blog", "title": "ForgeCAD Blog - AI-Native CAD and Manufacturing Workflows", "description": "Product notes, tutorials, examples, and technical updates on AI-native CAD, parametric modeling, validation, and manufacturing exports.", "priority": "0.6", "changefreq": "weekly" }, { "path": "/pricing", "title": "ForgeCAD Pricing", "description": "ForgeCAD plans for browser CAD, local CLI workflows, AI agent model generation, project publishing, and commercial use.", "priority": "0.5", "changefreq": "monthly" }, { "path": "/terms", "title": "ForgeCAD Terms of Service", "description": "Terms for ForgeCAD accounts, projects, hosted services, CLI use, commercial use, automation, and AI-assisted workflows.", "priority": "0.3", "changefreq": "yearly" }, { "path": "/privacy", "title": "ForgeCAD Privacy Policy", "description": "How ForgeCAD handles account, project, billing, analytics, and service data for the website, CLI, and hosted app.", "priority": "0.3", "changefreq": "yearly" }, { "path": "/license", "title": "ForgeCAD Software License", "description": "ForgeCAD license terms for Free, Pro, Enterprise, embedded, backend, local CLI, and AI workflow usage.", "priority": "0.3", "changefreq": "yearly" }];
 const seoConfig = {
   siteUrl,
   defaultImage,
@@ -47235,17 +43760,17 @@ function SeoMetadata() {
   }, [location.pathname]);
   return null;
 }
-reactExports.lazy(() => __vitePreload(() => import("./LandingPageProofDriven-C_LssmnA.js"), true ? __vite__mapDeps([1]) : void 0).then((m2) => ({ default: m2.LandingPageProofDriven })));
-const DocsPage = reactExports.lazy(() => __vitePreload(() => import("./DocsPage-vZb3b3Y0.js"), true ? [] : void 0).then((m2) => ({ default: m2.DocsPage })));
-reactExports.lazy(() => __vitePreload(() => import("./BlogPage-DlPbpt6A.js"), true ? [] : void 0).then((m2) => ({ default: m2.BlogPage })));
-reactExports.lazy(() => __vitePreload(() => import("./BenchmarkPage-Ds7Z2doN.js"), true ? __vite__mapDeps([1,2]) : void 0).then((m2) => ({ default: m2.BenchmarkPage })));
-reactExports.lazy(() => __vitePreload(() => import("./AdminPage-CK7ObBz3.js"), true ? [] : void 0).then((m2) => ({ default: m2.AdminPage })));
+reactExports.lazy(() => __vitePreload(() => import("./LandingPageProofDriven-BoVE7JGY.js"), true ? __vite__mapDeps([1]) : void 0).then((m2) => ({ default: m2.LandingPageProofDriven })));
+const DocsPage = reactExports.lazy(() => __vitePreload(() => import("./DocsPage-BPGGwht1.js"), true ? [] : void 0).then((m2) => ({ default: m2.DocsPage })));
+reactExports.lazy(() => __vitePreload(() => import("./BlogPage-B7BWxOCg.js"), true ? [] : void 0).then((m2) => ({ default: m2.BlogPage })));
+reactExports.lazy(() => __vitePreload(() => import("./BenchmarkPage-DXKVXMrJ.js"), true ? __vite__mapDeps([1,2]) : void 0).then((m2) => ({ default: m2.BenchmarkPage })));
+reactExports.lazy(() => __vitePreload(() => import("./AdminPage-B3L3W1Uo.js"), true ? [] : void 0).then((m2) => ({ default: m2.AdminPage })));
 reactExports.lazy(() => __vitePreload(() => Promise.resolve().then(() => PublishedModelPage$1), true ? void 0 : void 0).then((m2) => ({ default: m2.PublishedModelPage })));
-reactExports.lazy(() => __vitePreload(() => import("./SettingsPage-f47cnk39.js"), true ? [] : void 0).then((m2) => ({ default: m2.SettingsPage })));
-reactExports.lazy(() => __vitePreload(() => import("./PricingPage-BOE27B-R.js"), true ? __vite__mapDeps([1,3]) : void 0).then((m2) => ({ default: m2.PricingPage })));
-reactExports.lazy(() => __vitePreload(() => import("./LegalPage-DGsyo4n1.js"), true ? __vite__mapDeps([1,4]) : void 0).then((m2) => ({ default: m2.LegalPage })));
-const EditorApp = reactExports.lazy(() => __vitePreload(() => import("./EditorApp-HLoKfe15.js"), true ? __vite__mapDeps([0]) : void 0).then((m2) => ({ default: m2.EditorApp })));
-const EmbedViewer = reactExports.lazy(() => __vitePreload(() => import("./EmbedViewer--KnqBKrJ.js"), true ? [] : void 0).then((m2) => ({ default: m2.EmbedViewer })));
+reactExports.lazy(() => __vitePreload(() => import("./SettingsPage-BlJDCRe8.js"), true ? [] : void 0).then((m2) => ({ default: m2.SettingsPage })));
+reactExports.lazy(() => __vitePreload(() => import("./PricingPage-C2PMzmDc.js"), true ? __vite__mapDeps([1,3]) : void 0).then((m2) => ({ default: m2.PricingPage })));
+reactExports.lazy(() => __vitePreload(() => import("./LegalPage-Din8wv8d.js"), true ? __vite__mapDeps([1,4]) : void 0).then((m2) => ({ default: m2.LegalPage })));
+const EditorApp = reactExports.lazy(() => __vitePreload(() => import("./EditorApp-BWUGCdD5.js"), true ? __vite__mapDeps([0]) : void 0).then((m2) => ({ default: m2.EditorApp })));
+const EmbedViewer = reactExports.lazy(() => __vitePreload(() => import("./EmbedViewer-DygByZS2.js"), true ? [] : void 0).then((m2) => ({ default: m2.EmbedViewer })));
 const embedMode = isEmbedMode() && !window.location.pathname.startsWith("/m/");
 const EDITABLE_CRASH_FILE = /\.(?:forge\.js|[cm]?[jt]sx?|json|md|txt|svg|dxf)$/i;
 function firstMeaningfulLine(text) {
@@ -47465,7 +43990,7 @@ function App() {
 applyTheme(localStorage.getItem("fc-theme") || "dark");
 clientExports.createRoot(document.getElementById("root")).render(/* @__PURE__ */ jsxRuntimeExports.jsx(App, {}));
 export {
-  INSPECT_POINT_SAMPLE_COUNT_MIN as $,
+  VOXEL_INTENT_TOOL_ORDER as $,
   AuthApiError as A,
   BrandMark as B,
   captureViewportImageBlobFromStore as C,
@@ -47490,49 +44015,48 @@ export {
   animationSpeedToSlider as V,
   formatAnimationSpeed as W,
   resolveJointRange as X,
-  useJointsConfig as Y,
-  useJointAnimationValues as Z,
-  INSPECT_POINT_SAMPLE_COUNT_MAX as _,
+  availableKernels as Y,
+  useJointsConfig as Z,
+  useJointAnimationValues as _,
   applyTheme as a,
-  VOXEL_INTENT_TOOL_ORDER as a0,
-  VOXEL_INTENT_TOOL_LABELS as a1,
-  VOXEL_INTENT_TOOL_COLORS as a2,
-  VOXEL_INTENT_PLACEMENT_ORDER as a3,
-  VOXEL_INTENT_PLACEMENT_LABELS as a4,
-  highlightLanguageForProjectFile as a5,
-  hasProjectTextFileExtension as a6,
-  expandBoundsByTransformedAabb as a7,
-  Canvas as a8,
-  ActiveCameraBridge as a9,
-  storePendingShareCopy as aA,
-  buildShareUrl as aB,
-  share as aC,
-  PerspectiveCamera as aa,
-  ControlsInteractionBridge as ab,
-  SceneConfigurator as ac,
-  LocalEnvironment as ad,
-  ForgeObject as ae,
-  RenderLabelsOverlay as af,
-  Grid as ag,
-  OrbitControls2 as ah,
-  TOUCH_GESTURES_3D as ai,
-  MOUSE_BUTTONS_3D as aj,
-  ViewController as ak,
-  ModelJourneyBar as al,
-  useJointAnimationLoop as am,
-  computeJointNodeMatrices as an,
-  computeObjectJointMatrices as ao,
-  readLastActiveFileForUser as ap,
-  ToastContainer as aq,
-  isMobile as ar,
-  useFeatureFlag as as,
-  decodeSharedHash as at,
-  decodeSharedBundle as au,
-  getExternalUrl as av,
-  getGistId as aw,
-  Viewport as ax,
-  shouldBlockBrowserShortcut as ay,
-  useDrawStore as az,
+  VOXEL_INTENT_TOOL_LABELS as a0,
+  VOXEL_INTENT_TOOL_COLORS as a1,
+  VOXEL_INTENT_PLACEMENT_ORDER as a2,
+  VOXEL_INTENT_PLACEMENT_LABELS as a3,
+  highlightLanguageForProjectFile as a4,
+  hasProjectTextFileExtension as a5,
+  expandBoundsByTransformedAabb as a6,
+  Canvas as a7,
+  ActiveCameraBridge as a8,
+  PerspectiveCamera as a9,
+  buildShareUrl as aA,
+  share as aB,
+  ControlsInteractionBridge as aa,
+  SceneConfigurator as ab,
+  LocalEnvironment as ac,
+  ForgeObject as ad,
+  RenderLabelsOverlay as ae,
+  Grid as af,
+  OrbitControls2 as ag,
+  TOUCH_GESTURES_3D as ah,
+  MOUSE_BUTTONS_3D as ai,
+  ViewController as aj,
+  ModelJourneyBar as ak,
+  useJointAnimationLoop as al,
+  computeJointNodeMatrices as am,
+  computeObjectJointMatrices as an,
+  readLastActiveFileForUser as ao,
+  ToastContainer as ap,
+  isMobile as aq,
+  useFeatureFlag as ar,
+  decodeSharedHash as as,
+  decodeSharedBundle as at,
+  getExternalUrl as au,
+  getGistId as av,
+  Viewport as aw,
+  shouldBlockBrowserShortcut as ax,
+  useDrawStore as ay,
+  storePendingShareCopy as az,
   authFetch as b,
   authApi as c,
   showToast as d,