@selvajs/visualization 1.6.0-beta.1 → 1.6.0-beta.11

package/dist/render.js

@@ -1,12 +1,1618 @@
-import{a as e,c as t,d as n,f as r,g as i,h as a,l as o,m as s,p as c,r as l,s as u,t as d,u as f}from"./gpu-dispose-Dich0oW7.js";import{i as p,n as m,o as h,r as g,t as _}from"./merged-draw-BPhBYH-v.js";import*as v from"three";import{Line2 as y}from"three/addons/lines/Line2.js";import{LineGeometry as b}from"three/addons/lines/LineGeometry.js";import{LineMaterial as x}from"three/addons/lines/LineMaterial.js";import{RoomEnvironment as S}from"three/addons/environments/RoomEnvironment.js";import{LineSegments2 as C}from"three/addons/lines/LineSegments2.js";import{LineSegmentsGeometry as w}from"three/addons/lines/LineSegmentsGeometry.js";import{CSS2DObject as T,CSS2DRenderer as E}from"three/addons/renderers/CSS2DRenderer.js";import{ViewHelper as D}from"three/addons/helpers/ViewHelper.js";import{EffectComposer as O}from"three/addons/postprocessing/EffectComposer.js";import{RenderPass as k}from"three/addons/postprocessing/RenderPass.js";import{GTAOPass as A}from"three/addons/postprocessing/GTAOPass.js";import{SMAAPass as j}from"three/addons/postprocessing/SMAAPass.js";import{OutputPass as M}from"three/addons/postprocessing/OutputPass.js";import{FullScreenQuad as ee,Pass as N}from"three/addons/postprocessing/Pass.js";import{OrbitControls as P}from"three/addons/controls/OrbitControls.js";import{HDRLoader as F}from"three/addons/loaders/HDRLoader.js";const te=[`technical`,`studio`,`showcase`,`arctic`,`xray`,`lineart`,`wireframe`],ne=`compute`,re=`user`,I=`app:`;function L(e){return`${I}${e}`}function R(e){return typeof e!=`string`||!e.startsWith(I)?null:e.slice(4)||null}function z(e){let t=e.userData?.source;return t===`user`||R(t)!==null}function ie(e,t){return t===void 0?z(e):e.userData?.source===L(t)}const B=`selvaReflectionEnvironment`;function V(e,t,n){let r=new v.PMREMGenerator(t),i=new S,a=r.fromScene(i,.04).texture;i.dispose(),r.dispose(),ae(e,a,n)}function ae(e,t,n){let r={texture:t,rotation:n.clone()};e.userData[B]=r,H(e,e)}function oe(e){e.userData[B]?.texture.dispose(),delete e.userData[B]}function H(e,t){let n=t.userData[B];n&&e.traverse(e=>{if(e.userData.source!==`compute`)return;let t=e,r=Array.isArray(t.material)?t.material:t.material?[t.material]:[];for(let e of r){if(!(e instanceof v.MeshStandardMaterial)||e.envMap&&e.envMap!==n.texture)continue;let t=e.metalness>.5?n.texture:null;e.envMap!==t&&(e.envMap=t,e.envMapRotation.copy(n.rotation),e.needsUpdate=!0)}})}function U(e){let t=e.clone().normalize(),n=new v.Vector3(0,0,1),r=new v.Vector3(0,1,0),i=Math.abs(t.dot(n))>.9?r:n,a=new v.Vector3().crossVectors(i,t).normalize();return{up:t,forward:new v.Vector3().crossVectors(t,a).normalize(),right:a}}function se(e,t){let{forward:n,right:r,up:i}=U(e);return n.clone().multiplyScalar(-1).add(r.clone().multiplyScalar(-1)).add(i).normalize().multiplyScalar(t)}function ce(e,t,n){let{forward:r,right:i,up:a}=U(e);return i.clone().multiplyScalar(t).add(r.clone().multiplyScalar(t)).add(a.clone().multiplyScalar(n))}function le(e){let t=e.clone().normalize(),n=new v.Vector3(0,1,0);if(t.dot(n)>.9999)return new v.Euler;if(t.dot(n)<-.9999)return new v.Euler(Math.PI,0,0);let r=new v.Quaternion().setFromUnitVectors(n,t);return new v.Euler().setFromQuaternion(r)}function ue(e){let t=Math.abs(e.x),n=Math.abs(e.y),r=Math.abs(e.z);return t>=n&&t>=r?`x`:n>=r?`y`:`z`}const W={HUGE_THRESHOLD:1e4,LARGE_THRESHOLD:1e3,SCALE_RATIO_THRESHOLD:100,NEAR_PLANE_FACTOR:{TINY:1e-4,SMALL:.001,NORMAL:.01},FAR_PLANE_FACTOR:{HUGE:100,LARGE:50,NORMAL:20},INITIAL_DISTANCE_MULTIPLIER:4};function de(t,n,r,i,a){if(ge(t),n.length===0)return;n.forEach(e=>{t.add(e),H(e,t)});let o=e(n),s=o.getCenter(new v.Vector3),c=o.getSize(new v.Vector3),l=Math.max(c.x,c.y,c.z);if(l/Math.min(c.x||1,c.y||1,c.z||1)>W.SCALE_RATIO_THRESHOLD||l>W.HUGE_THRESHOLD?(r.near=l*W.NEAR_PLANE_FACTOR.TINY,r.far=l*W.FAR_PLANE_FACTOR.HUGE):l>W.LARGE_THRESHOLD?(r.near=l*W.NEAR_PLANE_FACTOR.SMALL,r.far=l*W.FAR_PLANE_FACTOR.LARGE):(r.near=Math.max(.01,l*W.NEAR_PLANE_FACTOR.NORMAL),r.far=Math.max(2e3,l*W.FAR_PLANE_FACTOR.NORMAL)),r.updateProjectionMatrix(),!a){let e=l*W.INITIAL_DISTANCE_MULTIPLIER;r.position.copy(s).add(se(r.up,e)),i.target.copy(s),i.update()}}const fe=new Set([`grid`,`floor`,`label-layer`,`measure`]);function pe(e){return typeof e.userData.id==`string`&&fe.has(e.userData.id)}function me(e){let t=e;for(;t;){if(pe(t))return!0;t=t.parent}return!1}function G(e){e.updateMatrixWorld(!0);let t=new v.Box3;return e.traverse(e=>{let n=e;e.visible&&!me(e)&&n.geometry&&t.expandByObject(e)}),t}const he=new Set([`floor`,`grid`,`label-layer`]);function ge(e){[...e.children].forEach(e=>{he.has(e.userData.id)||z(e)||(d(e),e.removeFromParent())})}function _e(e){let{up:t,forward:n,right:r}=U(e),i=n.clone().negate(),a=r.clone();return{top:t.clone(),bottom:t.clone().negate(),front:i.clone(),back:i.clone().negate(),right:a.clone(),left:a.clone().negate(),iso:i.clone().multiplyScalar(1.2).add(a.clone()).add(t.clone()).normalize()}}function ve(e){let{scene:t,perspective:n,controls:r,onActiveCameraChange:i}=e,a=(e.up??n.up).clone().normalize(),o=_e(a),s=new v.OrthographicCamera(-1,1,1,-1,n.near,n.far);s.up.copy(a);let c=`perspective`,l=n.aspect,u=()=>c===`perspective`?n:s,d=null,f=()=>{d?.cancel(),d=null},p=()=>{let e=(c===`orthographic`?s:n).position.distanceTo(r.target)*Math.tan(n.fov*Math.PI/360),t=e*l;s.left=-t,s.right=t,s.top=e,s.bottom=-e,s.near=n.near,s.far=n.far,s.updateProjectionMatrix()},m=e=>{if(e!==c){if(f(),e===`orthographic`)s.position.copy(n.position),s.up.copy(n.up),s.lookAt(r.target),s.zoom=1,p();else{let e=(s.top-s.bottom)/(2*s.zoom)/Math.tan(n.fov*Math.PI/360),t=s.position.clone().sub(r.target);t.lengthSq()<1e-12&&t.copy(a),t.normalize(),n.position.copy(r.target).add(t.multiplyScalar(e))}c=e,r.object=u(),r.update(),i(u())}},h=(e,t,i,o)=>{let l=n.fov*(Math.PI/180),m=t/(2*Math.tan(l/2))*1.5,h=ye(i,a),g=e.clone().add(h.clone().multiplyScalar(m)),_=u();c===`orthographic`&&(s.zoom=1),f(),o?d=xe(_,r,g,e,()=>{c===`orthographic`&&p()}):(_.position.copy(g),r.target.copy(e),c===`orthographic`&&p(),r.update())},g=(e,n=!0)=>{let i=G(t),a=i.isEmpty()?r.target.clone():i.getCenter(new v.Vector3),o=i.isEmpty()?new v.Vector3(1,1,1):i.getSize(new v.Vector3),s=Math.max(o.x,o.y,o.z)||1;h(a,s,e,n)};return{getActiveCamera:u,getProjection:()=>c,setProjection:m,toggleProjection:()=>(m(c===`perspective`?`orthographic`:`perspective`),c),setView:(e,t=!0)=>{g(o[e],t)},setViewDirection:g,frameBounds:(e,t=!0)=>{if(e.isEmpty())return;let n=e.getCenter(new v.Vector3),i=e.getSize(new v.Vector3),a=Math.max(i.x,i.y,i.z)||1,s=u().position.clone().sub(r.target);s.lengthSq()<1e-12&&s.copy(o.iso),h(n,a,s.normalize(),t)},setRotateEnabled:e=>{r.enableRotate=e},isRotateEnabled:()=>r.enableRotate,updateAspect:(e,t)=>{l=t===0?l:e/t,c===`orthographic`&&p()},dispose:f}}function ye(e,t){let{up:n,forward:r}=U(t),i=e.clone().normalize();if(Math.abs(i.dot(n))<.9999)return e;let a=r.clone().negate(),o=.5*Math.PI/180;return i.multiplyScalar(Math.cos(o)).add(a.multiplyScalar(Math.sin(o))).normalize()}const be=e=>1-(1-e)**3;function xe(e,t,n,r,i,a=250){let o=e.position.clone(),s=t.target.clone(),c=performance.now(),l=null,u=()=>{l=null;let d=be(Math.min((performance.now()-c)/a,1));e.position.lerpVectors(o,n,d),t.target.lerpVectors(s,r,d),i(),t.update(),d<1&&(l=requestAnimationFrame(u))};return l=requestAnimationFrame(u),{cancel:()=>{l!==null&&(cancelAnimationFrame(l),l=null)}}}function Se(e){let t=Math.floor(e.length/6);if(t===0)return 1/0;let n=Math.max(1,Math.ceil(t/4096)),r=[];for(let i=0;i<t;i+=n){let t=i*6,n=Math.hypot(e[t+3]-e[t],e[t+4]-e[t+1],e[t+5]-e[t+2]);n>0&&r.push(n)}return r.length===0?1/0:(r.sort((e,t)=>e-t),r[Math.min(r.length-1,Math.floor(r.length*.15))])}function Ce(e){let t=new w;return t.setPositions(e),{geometry:t,segmentCount:e.length/6,edgeSpacing:Se(e)}}function K(e,t,n){let r=1e4,i=67108864,a=Math.cos(Math.PI/180*n),o=e.length/3;if(o>=i)throw Error(`extractEdgeSegments: ${o} vertices exceeds 2^26 limit`);let s=new Float64Array(o),c=new Float64Array(o),l=new Float64Array(o);for(let t=0;t<o;t++)s[t]=Math.round(e[3*t]*r),c[t]=Math.round(e[3*t+1]*r),l[t]=Math.round(e[3*t+2]*r);let u=16;for(;u<o*2;)u<<=1;let d=u-1,f=new Int32Array(u).fill(-1),p=new Int32Array(o);for(let e=0;e<o;e++){let t=(Math.imul(s[e]|0,73856093)^Math.imul(c[e]|0,19349663)^Math.imul(l[e]|0,83492791))&d;for(;;){let n=f[t];if(n===-1){f[t]=e,p[e]=e;break}if(s[n]===s[e]&&c[n]===c[e]&&l[n]===l[e]){p[e]=n;break}t=t+1&d}}let m=new Float32Array(6144),h=0,g=new Uint32Array(1024),_=(t,n,r)=>{if(h+6>m.length){let e=new Float32Array(m.length*2);e.set(m),m=e;let t=new Uint32Array(m.length/6);t.set(g),g=t}g[h/6]=r,m[h++]=e[3*t],m[h++]=e[3*t+1],m[h++]=e[3*t+2],m[h++]=e[3*n],m[h++]=e[3*n+1],m[h++]=e[3*n+2]},v=new Map,y=[],b=[],x=[],S=[],C=(t?t.length:o)/3;for(let n=0;n<C;n++){let r=t?t[3*n]:3*n,o=t?t[3*n+1]:3*n+1,s=t?t[3*n+2]:3*n+2,c=p[r],l=p[o],u=p[s];if(c===l||l===u||u===c)continue;let d=e[3*s]-e[3*o],f=e[3*s+1]-e[3*o+1],m=e[3*s+2]-e[3*o+2],h=e[3*r]-e[3*o],g=e[3*r+1]-e[3*o+1],C=e[3*r+2]-e[3*o+2],w=f*C-m*g,T=m*h-d*C,E=d*g-f*h,D=w*w+T*T+E*E;if(D>0){let e=1/Math.sqrt(D);w*=e,T*=e,E*=e}else w=0,T=0,E=0;for(let e=0;e<3;e++){let t,d,f,p;e===0?(t=r,d=o,f=c,p=l):e===1?(t=o,d=s,f=l,p=u):(t=s,d=r,f=u,p=c);let m=p*i+f,h=v.get(m);if(h!==void 0&&h!==-1)w*x[3*h]+T*x[3*h+1]+E*x[3*h+2]<=a&&_(t,d,n),v.set(m,-1);else{let e=f*i+p;if(!v.has(e)){let r=y.length;v.set(e,r),y.push(t),b.push(d),x.push(w,T,E),S.push(n)}}}}for(let e of v.values())e!==-1&&_(y[e],b[e],S[e]);return{segments:m.slice(0,h),faces:g.slice(0,h/6)}}function we(){return[`const extract = ${K.toString()};`,`self.onmessage = (event) => {`,`  const { id, positions, index, thresholdAngle } = event.data;`,`  try {`,`    const { segments, faces } = extract(positions, index, thresholdAngle);`,`    self.postMessage({ id, segments, faces }, [segments.buffer, faces.buffer]);`,`  } catch (error) {`,`    self.postMessage({ id, error: String((error && error.message) || error) });`,`  }`,`};`].join(`
-`)}const Te=`edge-overlay`;function Ee(e){return{forcedColor:e.color==null?null:new v.Color(e.color),darken:v.MathUtils.clamp(e.darken??.75,0,1),width:e.width??1.5,thresholdAngle:e.thresholdAngle??44,distanceFade:e.distanceFade??!0,maxTriangles:e.maxTriangles??4e6,maxSegments:e.maxSegments??2e6,maxOverlays:e.maxOverlays??1500}}function De(e){let t=e.getAttribute(`position`);return t?(e.index?e.index.count:t.count)/3:0}function Oe(e){let t=e.getAttribute(`position`);if(!t||t.isInterleavedBufferAttribute||t.itemSize!==3||!(t.array instanceof Float32Array)||t.count>=67108864)return null;let n=e.index;return n&&!(n.array instanceof Uint32Array)&&!(n.array instanceof Uint16Array)?null:{positions:t.array,index:n?n.array:null}}function ke(e,t){let n=4096,r=2166136261,i=e=>{r^=e,r=Math.imul(r,16777619)},a=new Uint32Array(e.positions.buffer,e.positions.byteOffset,e.positions.length),o=Math.min(n,a.length);for(let e=0;e<o;e++)i(a[e]);for(let e=Math.max(o,a.length-n);e<a.length;e++)i(a[e]);let s=0;if(e.index){s=e.index.length;let t=Math.min(n,s);for(let n=0;n<t;n++)i(e.index[n]);for(let r=Math.max(t,s-n);r<s;r++)i(e.index[r])}return`${t}:${e.positions.length}:${s}:${r>>>0}`}function Ae(e,t){let n=new v.EdgesGeometry(e,t),r=n.attributes.position?n.attributes.position.array:new Float32Array;return n.dispose(),{segments:r,faces:null}}function je(e,t){let n=Oe(e);return n?K(n.positions,n.index,t):Ae(e,t)}let q;const J=new Map;let Me=1;function Ne(){if(q!==void 0)return q;if(typeof Worker>`u`||typeof Blob>`u`||typeof URL>`u`||typeof URL.createObjectURL!=`function`)return q=null,null;try{let e=URL.createObjectURL(new Blob([we()],{type:`text/javascript`})),t=new Worker(e);t.onmessage=e=>{let{id:t,segments:n,faces:r,error:i}=e.data,a=J.get(t);a&&(J.delete(t),n?a.resolve({segments:n,faces:r??null}):a.reject(Error(i??`edge extraction failed in worker`)))},t.onerror=()=>{for(let e of J.values())e.reject(Error(`edge extraction worker crashed`));J.clear(),t.terminate(),q=null},q=t}catch{q=null}return q}function Pe(e,t,n){return new Promise((r,i)=>{let a=Me++;J.set(a,{resolve:r,reject:i});let o=t.positions.slice(),s=t.index?t.index.slice():null,c=[o.buffer];s&&c.push(s.buffer),e.postMessage({id:a,positions:o,index:s,thresholdAngle:n},c)})}const Y=new Map;function Fe(e,t){let n=Oe(e);if(!n||De(e)<25e3)return Promise.resolve(je(e,t));let r=ke(n,t),i=Y.get(r);if(i)return i;let a=Ne();if(!a)return Promise.resolve(je(e,t));let o=Pe(a,n,t).catch(()=>K(n.positions,n.index,t)).finally(()=>{Y.delete(r)});return Y.set(r,o),o}function X(e){let t=e.userData?.members;return Array.isArray(t)&&t.length>0?t:null}function Ie(e){let t=X(e.object);if(!t||e.faceIndex==null)return null;let n=e.faceIndex*3,r=0,i=t.length-1;for(;r<=i;){let e=r+i>>1,a=t[e];if(a.indexStart==null||a.indexCount==null)return null;if(n<a.indexStart)i=e-1;else if(n>=a.indexStart+a.indexCount)r=e+1;else return{member:a,index:e}}return null}function Le(e,t){let n=new v.Box3,r=e.geometry.getIndex(),i=e.geometry.getAttribute(`position`);if(!r||!i||t.indexStart==null||t.indexCount==null)return n;e.updateMatrixWorld();let a=new v.Vector3,o=Math.min(t.indexStart+t.indexCount,r.count);for(let s=t.indexStart;s<o;s++)a.fromBufferAttribute(i,r.getX(s)).applyMatrix4(e.matrixWorld),n.expandByPoint(a);return n}function Re(e,t,n){let r=X(e)?.indexOf(t)??-1;return r<0||t.indexStart==null||t.indexCount==null?()=>{}:(h(e,r,n),()=>_(e))}function ze(e,t){let n=X(e);if(!n)return null;let r=[];for(let e of n){if(e.indexStart==null)return null;r.push(e.indexStart)}let i=new Uint32Array(t.length);for(let e=0;e<t.length;e++){let n=t[e]*3,a=0,o=r.length-1;for(;a<o;){let e=a+o+1>>1;r[e]<=n?a=e:o=e-1}i[e]=a}return i}function Be(e,t,n){let r=0;for(let e=0;e<t.length;e++)n.has(t[e])||r++;let i=new Float32Array(r*6),a=0;for(let r=0;r<t.length;r++)n.has(t[r])||(i.set(e.subarray(r*6,r*6+6),a),a+=6);return i}function Ve(e,t,n){let{segments:r,faces:i}=n;if(!i||!X(t))return;let a,o=!1,s=()=>{let n=g(t);if(n.size===0&&!o||(a??=ze(t,i),!a))return;let s=n.size===0?r:Be(r,a,n);e.geometry.dispose(),e.geometry=Ce(s).geometry,o=n.size>0};s();let c=p(t,s);e.addEventListener(`removed`,c)}function He(e,t){let n=(Array.isArray(e.material)?e.material[0]:e.material)?.color;return n?n.clone().multiplyScalar(1-t):new v.Color(2236962)}var Ue=class{options;byKey=new Map;constructor(e){this.options=e}for(e,t){let n=this.options.forcedColor??He(e,this.options.darken),r=n.getHex()*2+ +!!t,i=this.byKey.get(r);return i||(i=We(n,this.options.width,t),this.byKey.set(r,i)),i}disposeUnused(e){let t=new Set(e.map(e=>e.material));for(let e of this.byKey.values())t.has(e)||e.dispose()}};function We(e,t,n){let r=new x({color:e});return r.linewidth=t,r.polygonOffset=!0,r.polygonOffsetFactor=0,r.polygonOffsetUnits=-1,n&&(r.transparent=!0),r}function Ge(e,t,n){let r=new C(e.geometry,t);return r.userData.kind=Te,r.raycast=()=>{},n&&Ye(r,e.edgeSpacing),r}const Ke=new v.Vector3,qe=new v.Vector3;function Je(e,t,n){e.geometry.boundingSphere||e.geometry.computeBoundingSphere();let r=e.geometry.boundingSphere;if(!r)return 1/0;if(t.isPerspectiveCamera){let i=t;Ke.copy(r.center).applyMatrix4(e.matrixWorld);let a=qe.setFromMatrixPosition(t.matrixWorld).distanceTo(Ke);if(a<=r.radius*e.matrixWorld.getMaxScaleOnAxis())return 1/0;let o=Math.tan(v.MathUtils.degToRad(i.fov)*.5),s=2*a*o;return s>0?n/s:1/0}if(t.isOrthographicCamera){let e=t,r=(e.top-e.bottom)/e.zoom;return r>0?n/r:1/0}return 1/0}function Ye(e,t){e.onBeforeRender=(n,r,i)=>{C.prototype.onBeforeRender.call(e,n);let a=e.material,o=t*Je(e,i,a.resolution.y);a.opacity=v.MathUtils.clamp((o-1)/3,0,1)}}function Xe(e){return e.userData?.kind===Te}function Ze(e,t){let n=[],r=0;e.traverse(e=>{if(e instanceof v.Mesh&&e.userData.id!==`floor`&&e.userData.id!==`grid`&&e.userData.kind!==`edge-overlay`){if(e.children.some(e=>e.userData?.kind===`edge-overlay`)){r++;return}if(e.geometry){if(De(e.geometry)>t.maxTriangles){e.userData.edgesSkipped=`triangle-cap`;return}n.push(e)}}});let i=Math.max(0,t.maxOverlays-r),a=n.slice(0,i);for(let e of a)delete e.userData.edgesSkipped;for(let e of n.slice(i))e.userData.edgesSkipped=`overlay-budget`;return n.length>i&&console.debug(`[edges] overlay budget reached: ${n.length} meshes want overlays, ${i} allowed — the rest fall back to the screen-space edge pass.`),a}function Qe(e,t,n,r){let i=Ce(t.segments),a=r.distanceFade&&i.segmentCount<=r.maxSegments,o=Ge(i,n.for(e,a),a);return e.add(o),Ve(o,e,t),o}const $e=new WeakMap;function Z(e){return $e.get(e)??0}function et(e,t){for(let n=e;n;n=n.parent)if(n===t)return!0;return!1}async function tt(e,t={}){let n=Ee(t),r=new Ue(n),i=Z(e),a=[],o=Ze(e,n).map(async t=>{let o=await Fe(t.geometry,n.thresholdAngle);Z(e)===i&&et(t,e)&&(t.children.some(e=>e.userData?.kind===`edge-overlay`)||a.push(Qe(t,o,r,n)))});return await Promise.all(o),r.disposeUnused(a),a}function nt(e){$e.set(e,Z(e)+1);let t=[];e.traverse(e=>{e instanceof C&&Xe(e)&&t.push(e)});let n=new Set;for(let e of t)e.geometry.dispose(),n.add(e.material),e.removeFromParent();return n.forEach(e=>e.dispose()),t.length}function rt(e){if(!(e>0)||!Number.isFinite(e))return 1;let t=10**Math.floor(Math.log10(e)),n=e/t;return(n>=5?5:n>=2?2:1)*t}function it(e={}){let{cellSize:t=1,majorEvery:n=10,cellColor:r=8947848,majorColor:i=4473924,fadeDistance:a=100,plane:o=`y`}=e,s=o===`y`?new v.Vector2(0,2):o===`z`?new v.Vector2(0,1):new v.Vector2(1,2),c=2.5,l=new v.PlaneGeometry(1,1);o===`y`?l.rotateX(-Math.PI/2):o===`x`&&l.rotateY(Math.PI/2);let u=new v.ShaderMaterial({vertexShader:`
+import { _ as setLogger, a as computeCombinedBoundingBox, c as EMISSIVE_LIGHT, d as OWN_ENV_MAP_INTENSITY, f as lookEnvMapIntensity, g as getLogger, h as enableDebugLogging, l as LOOK_PRESETS, m as materialAppearanceForLook, p as lookPreset, r as publishMaxAnisotropy, s as DEFAULT_LOOK, t as disposeObjectTree, v as ErrorCodes, y as VisualizationError } from "./gpu-dispose-BKp7iijv.js";
+import { n as cachedSourceOf } from "./gpu-ownership-Bs9l7hrU.js";
+import { a as onMemberDrawChange, i as getHiddenMembers, n as cloneForTint, r as getBaseMaterial, s as setMemberHighlight, t as clearMemberHighlight } from "./merged-draw-CO4rr2Co.js";
+import * as THREE from "three";
+import { Line2 } from "three/addons/lines/Line2.js";
+import { LineGeometry } from "three/addons/lines/LineGeometry.js";
+import { LineMaterial } from "three/addons/lines/LineMaterial.js";
+import { LineSegments2 } from "three/addons/lines/LineSegments2.js";
+import { LineSegmentsGeometry } from "three/addons/lines/LineSegmentsGeometry.js";
+import { CSS2DObject, CSS2DRenderer } from "three/addons/renderers/CSS2DRenderer.js";
+import { MeshBVH } from "three-mesh-bvh";
+import { ViewHelper } from "three/addons/helpers/ViewHelper.js";
+import { EffectComposer } from "three/addons/postprocessing/EffectComposer.js";
+import { RenderPass } from "three/addons/postprocessing/RenderPass.js";
+import { ShaderPass } from "three/addons/postprocessing/ShaderPass.js";
+import { GTAOPass } from "three/addons/postprocessing/GTAOPass.js";
+import { SMAAPass } from "three/addons/postprocessing/SMAAPass.js";
+import { OutputPass } from "three/addons/postprocessing/OutputPass.js";
+import { FullScreenQuad, Pass } from "three/addons/postprocessing/Pass.js";
+import { UnrealBloomPass } from "three/addons/postprocessing/UnrealBloomPass.js";
+import { OrbitControls } from "three/addons/controls/OrbitControls.js";
+import { HDRLoader } from "three/addons/loaders/HDRLoader.js";
+// src/shared/types.ts
+/** Source of truth for {@link Look} — lets consumers (e.g. a style picker) iterate instead of hardcoding names. */
+const LOOKS = [
+	"technical",
+	"studio",
+	"showcase",
+	"arctic",
+	"xray",
+	"lineart",
+	"wireframe",
+	"night"
+];
+// src/render/scene-ownership.ts
+/** Geometry produced by a solve. Replaced wholesale on the next one. */
+const SOURCE_COMPUTE = "compute";
+/**
+* Host-added geometry with no owner id. Predates scoped ownership and still honoured everywhere
+* an `app:` scope is — new code should prefer {@link appSource}.
+*/
+const SOURCE_USER = "user";
+const APP_PREFIX = "app:";
+/** The `userData.source` tag for geometry owned by app `id` (`'pointcloud'` → `'app:pointcloud'`). */
+function appSource(id) {
+	return `${APP_PREFIX}${id}`;
+}
+/** The app id from a source tag, or null if the tag isn't app-owned. */
+function appIdFromSource(source) {
+	if (typeof source !== "string" || !source.startsWith(APP_PREFIX)) return null;
+	return source.slice(4) || null;
+}
+/**
+* True for anything a host added rather than the solve — `'user'` or any `app:` scope. This is
+* the predicate `clearScene` uses, so it decides what survives a solve.
+*/
+function isHostOwned(object) {
+	const source = object.userData?.source;
+	return source === "user" || appIdFromSource(source) !== null;
+}
+/**
+* True for objects owned by `id`. Passing no id matches every host-owned object, which is what
+* `clearUserGeometry()` does.
+*/
+function isOwnedBy(object, id) {
+	if (id === void 0) return isHostOwned(object);
+	return object.userData?.source === appSource(id);
+}
+// src/render/scene-setup/studio-environment.ts
+/** What a softbox costs to set up, in radiance: only their ratio to the room matters to a reflection. */
+const OVERHEAD = 8;
+const KEY_STRIP = 11;
+const FILL_STRIP = 4.5;
+const RIM = 3.5;
+const WALLS = .14;
+const FLOOR = .05;
+const ROOM_SIZE = 10;
+function softbox(radiance, width, height, position) {
+	const panel = new THREE.Mesh(new THREE.PlaneGeometry(width, height), new THREE.MeshBasicMaterial({
+		color: new THREE.Color().setScalar(radiance),
+		side: THREE.DoubleSide
+	}));
+	panel.position.set(...position);
+	panel.lookAt(0, 0, 0);
+	return panel;
+}
+/**
+* A photographer's table, for PMREM to bake into a reflection probe: softboxes on a dark room.
+* Shape comes from the gaps between lights. A surface that reflects light everywhere has no contour,
+* which is why three's `RoomEnvironment`, bright on all sides, leaves metal looking like flat paint.
+* The floor stays dark so an underside reads as turned away from the light.
+*/
+function createStudioScene() {
+	const scene = new THREE.Scene();
+	const room = new THREE.Mesh(new THREE.BoxGeometry(ROOM_SIZE, ROOM_SIZE, ROOM_SIZE), new THREE.MeshBasicMaterial({
+		color: new THREE.Color().setScalar(WALLS),
+		side: THREE.BackSide
+	}));
+	const floor = new THREE.Mesh(new THREE.PlaneGeometry(ROOM_SIZE, ROOM_SIZE), new THREE.MeshBasicMaterial({ color: new THREE.Color().setScalar(FLOOR) }));
+	floor.rotation.x = -Math.PI / 2;
+	floor.position.y = -4;
+	scene.add(room, floor, softbox(OVERHEAD, 6.5, 4.5, [
+		0,
+		4.8,
+		.6
+	]), softbox(KEY_STRIP, 1.4, 5.5, [
+		-4.7,
+		.8,
+		1.6
+	]), softbox(FILL_STRIP, .9, 5, [
+		4.7,
+		.5,
+		2.4
+	]), softbox(RIM, 5, .8, [
+		.6,
+		2.2,
+		-4.7
+	]));
+	return scene;
+}
+/** Frees what {@link createStudioScene} built, once PMREM has baked it. */
+function disposeStudioScene(scene) {
+	scene.traverse((object) => {
+		const mesh = object;
+		mesh.geometry?.dispose();
+		mesh.material?.dispose();
+	});
+}
+// src/render/scene-setup/reflection-environment.ts
+const METAL = .5;
+/** Above PMREM's blur for a mirror, so a softbox has an edge in chrome without showing as a shape. */
+const STUDIO_BLUR = .03;
+const KEY = "selvaReflectionEnvironment";
+/**
+* Builds the studio probe once per scene. `rotation` turns its Y-up room to the scene's up, the same
+* rotation the HDR gets.
+*/
+function createReflectionEnvironment(scene, renderer, rotation) {
+	const pmrem = new THREE.PMREMGenerator(renderer);
+	const studio = createStudioScene();
+	const texture = pmrem.fromScene(studio, STUDIO_BLUR).texture;
+	disposeStudioScene(studio);
+	pmrem.dispose();
+	installReflectionEnvironment(scene, texture, rotation);
+}
+/** The GPU-free half of {@link createReflectionEnvironment}; tests call it with a plain texture. */
+function installReflectionEnvironment(scene, texture, rotation) {
+	const environment = {
+		texture,
+		rotation: rotation.clone()
+	};
+	scene.userData[KEY] = environment;
+	applyReflectionEnvironment(scene, scene);
+}
+function disposeReflectionEnvironment(scene) {
+	scene.userData[KEY]?.texture.dispose();
+	delete scene.userData[KEY];
+}
+/**
+* Points every metallic solve material under `root` at the studio probe, and every other one back
+* at `scene.environment`. Run after meshes are added and after a look changes metalness.
+*
+* A material's own `envMap` also makes three honour its `envMapIntensity`: with only
+* `scene.environment`, three overwrites it with `scene.environmentIntensity` on every draw.
+*/
+function applyReflectionEnvironment(root, scene) {
+	const environment = scene.userData[KEY];
+	if (!environment) return;
+	root.traverse((object) => {
+		if (object.userData.source !== "compute") return;
+		const mesh = object;
+		const materials = Array.isArray(mesh.material) ? mesh.material : mesh.material ? [mesh.material] : [];
+		for (const material of materials) {
+			if (!(material instanceof THREE.MeshStandardMaterial)) continue;
+			if (material.envMap && material.envMap !== environment.texture) continue;
+			const wanted = material.metalness > METAL ? environment.texture : null;
+			if (material.envMap === wanted) continue;
+			material.envMap = wanted;
+			material.envMapRotation.copy(environment.rotation);
+			material.needsUpdate = true;
+		}
+	});
+}
+// src/render/up-axis.ts
+/** Ground-plane axes for a given up vector: Z-up yields forward = +Y, right = +X (Rhino's Front/Right). */
+function buildUpBasis(up) {
+	const u = up.clone().normalize();
+	const worldZ = new THREE.Vector3(0, 0, 1);
+	const worldY = new THREE.Vector3(0, 1, 0);
+	const seed = Math.abs(u.dot(worldZ)) > .9 ? worldY : worldZ;
+	const right = new THREE.Vector3().crossVectors(seed, u).normalize();
+	return {
+		up: u,
+		forward: new THREE.Vector3().crossVectors(u, right).normalize(),
+		right
+	};
+}
+/** Default 3/4 iso camera offset from the target (behind-left, above), scaled to `distance`. */
+function isoOffset(up, distance) {
+	const { forward, right, up: u } = buildUpBasis(up);
+	return forward.clone().multiplyScalar(-1).add(right.clone().multiplyScalar(-1)).add(u).normalize().multiplyScalar(distance);
+}
+/** Default sun position: high above the model, offset to one side for a directional gradient. */
+function sunOffset(up, sideDistance, height) {
+	const { forward, right, up: u } = buildUpBasis(up);
+	return right.clone().multiplyScalar(sideDistance).add(forward.clone().multiplyScalar(sideDistance)).add(u.clone().multiplyScalar(height));
+}
+/**
+* Rotates an equirectangular environment map's horizon onto the scene's ground plane.
+*
+* Three's equirect mapping is hardcoded to Y-up: the HDR's horizon is assumed to lie in the XZ
+* plane with zenith along +Y. In a Z-up scene that leaves the environment on its side — horizon
+* vertical, lighting arriving from +Y instead of overhead. A neutral studio HDR hides this; any
+* sky/ground HDR makes it obvious.
+*
+* Returns the Euler rotating the map's native +Y zenith onto `up` (identity for Y-up). Apply to
+* BOTH `scene.environmentRotation` and `scene.backgroundRotation` — they're independent, and
+* setting only one desyncs background from lighting.
+*/
+function environmentRotationFor(up) {
+	const u = up.clone().normalize();
+	const mapZenith = new THREE.Vector3(0, 1, 0);
+	if (u.dot(mapZenith) > .9999) return new THREE.Euler();
+	if (u.dot(mapZenith) < -.9999) return new THREE.Euler(Math.PI, 0, 0);
+	const quaternion = new THREE.Quaternion().setFromUnitVectors(mapZenith, u);
+	return new THREE.Euler().setFromQuaternion(quaternion);
+}
+/** Which world axis the up vector most closely aligns with. */
+function upToAxis(up) {
+	const ax = Math.abs(up.x);
+	const ay = Math.abs(up.y);
+	const az = Math.abs(up.z);
+	if (ax >= ay && ax >= az) return "x";
+	if (ay >= az) return "y";
+	return "z";
+}
+// src/render/scene-setup/defaults.ts
+/** Rhino's convention, and the frame all geometry arrives in — Selva is Z-up end to end. */
+const defaultUp = new THREE.Vector3(0, 0, 1);
+/**
+* Decided once, from the device: reacting to slow frames would change the light count, which
+* recompiles every shader on the device least able to. A coarse pointer alone would catch tablets;
+* 600px is the narrowest tablet.
+*/
+function isPhone() {
+	return (window.matchMedia?.("(pointer: coarse)").matches ?? false) && Math.min(window.screen.width, window.screen.height) < 600;
+}
+function applyDefaults(options) {
+	const scale = options.sceneScale || "m";
+	const defaults = {
+		mm: {
+			cameraDistance: 20,
+			near: .1,
+			far: 2e3,
+			floorSize: 100,
+			lightDistance: 10,
+			lightHeight: 20,
+			minDistance: .1,
+			shadowSize: 100,
+			scaleFactor: 1e3
+		},
+		cm: {
+			cameraDistance: 20,
+			near: .1,
+			far: 2e3,
+			floorSize: 100,
+			lightDistance: 25,
+			lightHeight: 50,
+			minDistance: .1,
+			shadowSize: 100,
+			scaleFactor: 100
+		},
+		m: {
+			cameraDistance: 10,
+			near: .01,
+			far: 2e3,
+			floorSize: 50,
+			lightDistance: 25,
+			lightHeight: 50,
+			minDistance: .001,
+			shadowSize: 100,
+			scaleFactor: 1
+		},
+		inches: {
+			cameraDistance: 15,
+			near: .1,
+			far: 2e3,
+			floorSize: 80,
+			lightDistance: 20,
+			lightHeight: 40,
+			minDistance: .1,
+			shadowSize: 80,
+			scaleFactor: 39.37
+		},
+		feet: {
+			cameraDistance: 8,
+			near: .1,
+			far: 2e3,
+			floorSize: 40,
+			lightDistance: 15,
+			lightHeight: 30,
+			minDistance: .1,
+			shadowSize: 60,
+			scaleFactor: 3.28084
+		}
+	}[scale];
+	const look = options.look ?? "technical";
+	const lowPower = options.render?.lowPower ?? isPhone();
+	const preset = lookPreset(look, lowPower);
+	return {
+		sceneScale: scale,
+		look,
+		camera: {
+			position: options.camera?.position || isoOffset(options.environment?.sceneUp ?? defaultUp, defaults.cameraDistance * Math.sqrt(3)),
+			fov: options.camera?.fov || 20,
+			near: options.camera?.near || defaults.near,
+			far: options.camera?.far || defaults.far,
+			target: options.camera?.target || new THREE.Vector3(0, 0, 0),
+			dynamicNear: options.camera?.dynamicNear ?? true
+		},
+		lighting: {
+			enableSunlight: options.lighting?.enableSunlight ?? true,
+			sunlightIntensity: options.lighting?.sunlightIntensity ?? preset.sunlightIntensity,
+			sunlightPosition: options.lighting?.sunlightPosition || sunOffset(options.environment?.sceneUp ?? defaultUp, defaults.lightDistance, defaults.lightHeight),
+			ambientLightColor: options.lighting?.ambientLightColor || new THREE.Color(4210752),
+			ambientLightIntensity: options.lighting?.ambientLightIntensity ?? preset.ambientIntensity,
+			sunlightColor: options.lighting?.sunlightColor || 16777215,
+			enableHemisphereLight: options.lighting?.enableHemisphereLight ?? preset.hemisphereIntensity > 0,
+			hemisphereSkyColor: options.lighting?.hemisphereSkyColor ?? 14673663,
+			hemisphereGroundColor: options.lighting?.hemisphereGroundColor ?? 7036754,
+			hemisphereIntensity: options.lighting?.hemisphereIntensity ?? preset.hemisphereIntensity
+		},
+		environment: {
+			hdrPath: options.environment?.hdrPath || "/baseHDR.hdr",
+			backgroundColor: options.environment?.backgroundColor || new THREE.Color(15790320),
+			enableEnvironmentLighting: options.environment?.enableEnvironmentLighting ?? true,
+			sceneUp: options.environment?.sceneUp || defaultUp,
+			showEnvironment: options.environment?.showEnvironment ?? false,
+			environmentIntensity: options.environment?.environmentIntensity ?? preset.environmentIntensity
+		},
+		floor: {
+			enabled: options.floor?.enabled ?? false,
+			size: options.floor?.size || defaults.floorSize,
+			color: options.floor?.color || new THREE.Color(8421504),
+			roughness: options.floor?.roughness ?? .7,
+			metalness: options.floor?.metalness ?? 0,
+			receiveShadow: options.floor?.receiveShadow ?? true
+		},
+		render: {
+			enableShadows: options.render?.enableShadows ?? true,
+			shadowMapSize: options.render?.shadowMapSize || 1024,
+			antialias: options.render?.antialias ?? true,
+			pixelRatio: options.render?.pixelRatio || Math.min(window.devicePixelRatio, 2),
+			toneMapping: options.render?.toneMapping ?? preset.toneMapping,
+			toneMappingExposure: options.render?.toneMappingExposure ?? preset.toneMappingExposure,
+			preserveDrawingBuffer: options.render?.preserveDrawingBuffer ?? false,
+			lowPower,
+			idleRefineFrames: options.render?.idleRefineFrames ?? (lowPower ? 0 : 32),
+			lightOrbitFrameMs: options.render?.lightOrbitFrameMs ?? 22,
+			ambientOcclusion: options.render?.ambientOcclusion ?? preset.ambientOcclusion,
+			aoIntensity: options.render?.aoIntensity ?? 1,
+			bloom: options.render?.bloom ?? preset.bloom,
+			aoPixelRatio: options.render?.aoPixelRatio ?? 1,
+			onDemand: options.render?.onDemand ?? true
+		},
+		controls: {
+			enableDamping: options.controls?.enableDamping ?? false,
+			dampingFactor: options.controls?.dampingFactor || .05,
+			autoRotate: options.controls?.autoRotate ?? false,
+			autoRotateSpeed: options.controls?.autoRotateSpeed || .5,
+			enableZoom: options.controls?.enableZoom ?? true,
+			enablePan: options.controls?.enablePan ?? true,
+			minDistance: options.controls?.minDistance || defaults.minDistance,
+			maxDistance: options.controls?.maxDistance || Infinity
+		},
+		grid: {
+			enabled: options.grid?.enabled ?? false,
+			cellSize: options.grid?.cellSize ?? 1,
+			majorEvery: options.grid?.majorEvery ?? 10,
+			cellColor: options.grid?.cellColor ?? 8947848,
+			majorColor: options.grid?.majorColor ?? 4473924,
+			fadeDistance: options.grid?.fadeDistance ?? 100,
+			plane: options.grid?.plane ?? upToAxis(options.environment?.sceneUp ?? defaultUp)
+		},
+		gizmo: { enabled: options.gizmo?.enabled ?? false },
+		edges: {
+			enabled: options.edges?.enabled ?? false,
+			color: options.edges?.color,
+			darken: options.edges?.darken,
+			width: options.edges?.width ?? 1.5,
+			thresholdAngle: options.edges?.thresholdAngle ?? 44,
+			distanceFade: options.edges?.distanceFade ?? true,
+			maxTriangles: options.edges?.maxTriangles,
+			maxSegments: options.edges?.maxSegments,
+			maxOverlays: options.edges?.maxOverlays,
+			screenSpaceFallback: options.edges?.screenSpaceFallback
+		},
+		measure: {
+			enabled: options.measure?.enabled ?? false,
+			snapPixels: options.measure?.snapPixels,
+			color: options.measure?.color,
+			labelClassName: options.measure?.labelClassName,
+			displayUnit: options.measure?.displayUnit,
+			format: options.measure?.format
+		},
+		events: {
+			onBackgroundClicked: options.events?.onBackgroundClicked,
+			onObjectSelected: options.events?.onObjectSelected,
+			onMeshMetadataClicked: options.events?.onMeshMetadataClicked,
+			onMeshDoubleClicked: options.events?.onMeshDoubleClicked,
+			selectionColor: options.events?.selectionColor || "#ff0000",
+			enableEventHandlers: options.events?.enableEventHandlers ?? true,
+			enableKeyboardControls: options.events?.enableKeyboardControls ?? true,
+			enableClickToFocus: options.events?.enableClickToFocus ?? true,
+			enableDoubleClickZoom: options.events?.enableDoubleClickZoom ?? true,
+			onReady: options.events?.onReady,
+			onFrame: options.events?.onFrame
+		},
+		onMaxAnisotropy: options.onMaxAnisotropy
+	};
+}
+// src/render/scene-setup/idle-refine.ts
+/** Long enough to skip the pauses inside an orbit, or a drag would keep restarting the average. */
+const SETTLE_MS = 150;
+/** Ambient occlusion is the largest cost of a frame, and the only one that can fade without a pop. */
+const AO_FADE_FRAMES = 8;
+/** Enough moving frames that one hitch can't decide it. */
+const ORBIT_SAMPLES = 12;
+/** Low-discrepancy sequence in [0, 1): N samples cover the range far more evenly than random ones. */
+function halton(index, base) {
+	let result = 0;
+	let fraction = 1 / base;
+	for (let i = index; i > 0; i = Math.floor(i / base)) {
+		result += i % base * fraction;
+		fraction /= base;
+	}
+	return result;
+}
+/** Counts what a forgotten `invalidate()` most likely changed: visibility and materials. */
+function sceneStamp(scene) {
+	let stamp = 0;
+	scene.traverseVisible((object) => {
+		stamp += 1;
+		const { material } = object;
+		for (const each of Array.isArray(material) ? material : material ? [material] : []) stamp += each.version * 31;
+	});
+	return stamp;
+}
+/**
+* Softens the picture while nothing moves. Each frame moves the camera by under a pixel and every
+* light within its real size, and the average of those frames has true penumbras and clean edges at
+* no cost to orbiting. The averaged image would be lost to the render loop's safety repaint, so
+* while it holds, that repaint only checks whether the scene changed.
+*
+* It also keeps orbiting smooth on a slow GPU. Once frames run over `lightOrbitFrameMs`, ambient
+* occlusion fades out while the camera moves and back in as it rests. Decided once, so a machine
+* near the limit doesn't flip between the two, and a fast one never sees it.
+*/
+function createIdleRefiner(params) {
+	const { scene, renderer, getPipeline, frames, lightOrbitFrameMs, jitterLights, restoreLights } = params;
+	let index = 0;
+	let changedAt = 0;
+	let stamp = 0;
+	const size = new THREE.Vector2();
+	let lightOrbit = frames > 0 && lightOrbitFrameMs <= 0;
+	let aoWeight = 1;
+	const orbitSamples = [];
+	const setAoWeight = (weight) => {
+		aoWeight = Math.min(1, Math.max(0, weight));
+		getPipeline()?.setAoWeight(aoWeight);
+	};
+	const measureOrbit = (deltaMs) => {
+		orbitSamples.push(deltaMs);
+		if (orbitSamples.length < ORBIT_SAMPLES) return;
+		orbitSamples.sort((a, b) => a - b);
+		lightOrbit = orbitSamples[6] > lightOrbitFrameMs;
+		orbitSamples.length = 0;
+	};
+	const jitterCamera = (camera, sample) => {
+		const lens = camera;
+		if (!lens.setViewOffset) return;
+		renderer.getDrawingBufferSize(size);
+		const x = sample ? halton(sample, 2) - .5 : 0;
+		const y = sample ? halton(sample, 3) - .5 : 0;
+		lens.setViewOffset(size.x, size.y, x, y, size.x, size.y);
+	};
+	return {
+		reset: (now) => {
+			index = 0;
+			changedAt = now;
+		},
+		moving: (deltaMs) => {
+			if (frames === 0) return;
+			if (lightOrbit) setAoWeight(aoWeight - 1 / AO_FADE_FRAMES);
+			else measureOrbit(deltaMs);
+		},
+		wants: (now) => (index < frames || aoWeight < 1) && now - changedAt >= SETTLE_MS && !!getPipeline(),
+		step: (camera) => {
+			const pipeline = getPipeline();
+			if (!pipeline) return;
+			if (aoWeight < 1) {
+				setAoWeight(aoWeight + 1 / AO_FADE_FRAMES);
+				pipeline.setCamera(camera);
+				pipeline.accumulate(0);
+				return;
+			}
+			if (index > 0) jitterLights(index);
+			jitterCamera(camera, index);
+			pipeline.setCamera(camera);
+			pipeline.accumulate(index);
+			camera.clearViewOffset?.();
+			if (index > 0) restoreLights();
+			index += 1;
+			if (index === frames) stamp = sceneStamp(scene);
+		},
+		present: () => {
+			if (frames === 0 || index < frames) return false;
+			getPipeline()?.presentAccumulated();
+			return !!getPipeline();
+		},
+		isHolding: () => frames > 0 && index >= frames && !!getPipeline() && stamp === sceneStamp(scene)
+	};
+}
+// src/render/scene-setup/setup-lighting.ts
+const SHADOW_NORMAL_BIAS = .02;
+/**
+* In shadow-map texels, and the map always spans the model, so the penumbra stays about 1.5% of the
+* model at any scale. A sharp edge reads as a sticker; a real sky never gives one.
+*/
+const SUN_SHADOW_BLUR = 6;
+/** Sky and bounce always fill a shadow in, so a fully dark one looks painted on. */
+const SUN_SHADOW_DENSITY = .62;
+/**
+* How far the sun moves while the view refines, as a tangent: about 1 degree. The real sun's 0.27
+* looks hard on a model this size, and much past 1 a small part's shadow dissolves completely.
+*/
+const SUN_DISC_RADIUS = .018;
+/** Survives a solve with the sun, which would otherwise aim at a target outside the scene. */
+const SUN_TARGET_ID = "sun-target";
+function setupLighting(scene, config) {
+	const ambient = new THREE.AmbientLight(config.lighting.ambientLightColor, config.lighting.ambientLightIntensity);
+	scene.add(ambient);
+	let hemisphere = null;
+	if (config.lighting.enableHemisphereLight) {
+		hemisphere = new THREE.HemisphereLight(config.lighting.hemisphereSkyColor, config.lighting.hemisphereGroundColor, config.lighting.hemisphereIntensity);
+		const up = config.environment.sceneUp ?? defaultUp;
+		hemisphere.position.copy(up);
+		scene.add(hemisphere);
+	}
+	if (!config.lighting.enableSunlight) return {
+		ambient,
+		hemisphere,
+		sun: null
+	};
+	const sunlight = new THREE.DirectionalLight(config.lighting.sunlightColor ?? 16777215, config.lighting.sunlightIntensity);
+	const pos = config.lighting.sunlightPosition;
+	if (pos) sunlight.position.set(pos.x, pos.y, pos.z);
+	if (!config.render.enableShadows) {
+		scene.add(sunlight);
+		return {
+			ambient,
+			hemisphere,
+			sun: null
+		};
+	}
+	sunlight.castShadow = true;
+	sunlight.shadow.mapSize.width = config.render.shadowMapSize;
+	sunlight.shadow.mapSize.height = config.render.shadowMapSize;
+	sunlight.shadow.bias = -1e-4;
+	sunlight.shadow.normalBias = SHADOW_NORMAL_BIAS;
+	sunlight.shadow.radius = SUN_SHADOW_BLUR;
+	sunlight.shadow.blurSamples = 12;
+	sunlight.shadow.intensity = SUN_SHADOW_DENSITY;
+	scene.add(sunlight);
+	sunlight.target.userData.id = SUN_TARGET_ID;
+	scene.add(sunlight.target);
+	return {
+		ambient,
+		hemisphere,
+		sun: sunlight
+	};
+}
+/** Moves the sun within its disc and returns how to put it back. */
+function jitterSun(light, index) {
+	const home = light.position.clone();
+	const toSun = home.clone().sub(light.target.position);
+	const side = new THREE.Vector3(0, 0, 1).cross(toSun);
+	if (side.lengthSq() === 0) side.set(1, 0, 0);
+	side.setLength(toSun.length() * SUN_DISC_RADIUS);
+	const across = toSun.clone().cross(side).setLength(side.length());
+	const angle = halton(index, 2) * Math.PI * 2;
+	const reach = Math.sqrt(halton(index, 3));
+	light.position.addScaledVector(side, Math.cos(angle) * reach).addScaledVector(across, Math.sin(angle) * reach);
+	return () => light.position.copy(home);
+}
+/**
+* Sizes a directional light's orthographic shadow frustum to the scene content's bounding sphere —
+* the dominant lever on shadow crispness. No-op on an empty or zero-size box: the frustum would
+* collapse to a point, and the sun would land on its target and lose its direction for good.
+*/
+function fitShadowToContent(light, bounds) {
+	if (bounds.isEmpty()) return;
+	const center = bounds.getCenter(new THREE.Vector3());
+	const radius = bounds.getSize(new THREE.Vector3()).length() * .5 * 1.2;
+	if (radius === 0) return;
+	light.shadow.normalBias = Math.min(SHADOW_NORMAL_BIAS, radius * .0015);
+	const cam = light.shadow.camera;
+	cam.left = -radius;
+	cam.right = radius;
+	cam.top = radius;
+	cam.bottom = -radius;
+	const direction = light.position.clone().sub(light.target.position).normalize();
+	light.target.position.copy(center);
+	light.target.updateMatrixWorld();
+	const lightDistance = radius * 2;
+	light.position.copy(center).addScaledVector(direction, lightDistance);
+	light.updateMatrixWorld();
+	cam.near = lightDistance - radius;
+	cam.far = lightDistance + radius;
+	cam.updateProjectionMatrix();
+}
+// src/render/three-helpers.ts
+const CAMERA_CONFIG = {
+	HUGE_THRESHOLD: 1e4,
+	LARGE_THRESHOLD: 1e3,
+	SCALE_RATIO_THRESHOLD: 100,
+	NEAR_PLANE_FACTOR: {
+		TINY: 1e-4,
+		SMALL: .001,
+		NORMAL: .01
+	},
+	FAR_PLANE_FACTOR: {
+		HUGE: 100,
+		LARGE: 50,
+		NORMAL: 20
+	},
+	INITIAL_DISTANCE_MULTIPLIER: 4
+};
+/** Replaces scene content with `meshes`, rescales the camera frustum to fit, and (first call only) positions the camera/controls. */
+function updateScene(scene, meshes, camera, controls, initialPositionSet) {
+	clearScene(scene, cachedGeometriesOf(meshes));
+	if (meshes.length === 0) return;
+	meshes.forEach((mesh) => {
+		scene.add(mesh);
+		applyReflectionEnvironment(mesh, scene);
+	});
+	const unionBoundingBox = computeCombinedBoundingBox(meshes);
+	const center = unionBoundingBox.getCenter(new THREE.Vector3());
+	const size = unionBoundingBox.getSize(new THREE.Vector3());
+	const maxDim = Math.max(size.x, size.y, size.z);
+	if (maxDim / Math.min(size.x || 1, size.y || 1, size.z || 1) > CAMERA_CONFIG.SCALE_RATIO_THRESHOLD || maxDim > CAMERA_CONFIG.HUGE_THRESHOLD) {
+		camera.near = maxDim * CAMERA_CONFIG.NEAR_PLANE_FACTOR.TINY;
+		camera.far = maxDim * CAMERA_CONFIG.FAR_PLANE_FACTOR.HUGE;
+	} else if (maxDim > CAMERA_CONFIG.LARGE_THRESHOLD) {
+		camera.near = maxDim * CAMERA_CONFIG.NEAR_PLANE_FACTOR.SMALL;
+		camera.far = maxDim * CAMERA_CONFIG.FAR_PLANE_FACTOR.LARGE;
+	} else {
+		camera.near = Math.max(.01, maxDim * CAMERA_CONFIG.NEAR_PLANE_FACTOR.NORMAL);
+		camera.far = Math.max(2e3, maxDim * CAMERA_CONFIG.FAR_PLANE_FACTOR.NORMAL);
+	}
+	camera.updateProjectionMatrix();
+	if (!initialPositionSet) {
+		const distance = maxDim * CAMERA_CONFIG.INITIAL_DISTANCE_MULTIPLIER;
+		camera.position.copy(center).add(isoOffset(camera.up, distance));
+		controls.target.copy(center);
+		controls.update();
+	}
+}
+const VIEWER_AID_IDS = /* @__PURE__ */ new Set([
+	"grid",
+	"floor",
+	"label-layer",
+	"measure",
+	SUN_TARGET_ID
+]);
+/** True if `object` itself roots a viewer aid; {@link isViewerAid} also checks ancestors. */
+function isViewerAidRoot(object) {
+	return typeof object.userData.id === "string" && VIEWER_AID_IDS.has(object.userData.id);
+}
+/** True if `object` or any ancestor is a viewer aid (grid/floor/labels/measure). */
+function isViewerAid(object) {
+	let current = object;
+	while (current) {
+		if (isViewerAidRoot(current)) return true;
+		current = current.parent;
+	}
+	return false;
+}
+/**
+* Bounds of the scene's renderable content, excluding viewer aids (grid/floor/labels/measure).
+* Shared by fit-to-view, pick-threshold scaling, camera framing (`setView`), and shadow-frustum
+* fitting so they all measure exactly the same box.
+*/
+function computeContentBounds(scene) {
+	scene.updateMatrixWorld(true);
+	const box = new THREE.Box3();
+	scene.traverse((object) => {
+		const renderable = object;
+		if (object.visible && !isViewerAid(object) && renderable.geometry) box.expandByObject(object);
+	});
+	return box;
+}
+function cachedGeometriesOf(objects) {
+	const cached = /* @__PURE__ */ new Set();
+	for (const root of objects) root.traverse((object) => {
+		const geometry = object.geometry;
+		const source = geometry && cachedSourceOf(geometry);
+		if (source) cached.add(source);
+	});
+	return cached;
+}
+const PERSISTENT_SCENE_IDS = /* @__PURE__ */ new Set([
+	"floor",
+	"grid",
+	"label-layer",
+	SUN_TARGET_ID
+]);
+/** Frees the solve content. `keepUploaded` names the cached geometries the next content draws. */
+function clearScene(scene, keepUploaded = /* @__PURE__ */ new Set()) {
+	const kept = [];
+	const removed = [];
+	for (const object of scene.children) if (object.isLight === true || PERSISTENT_SCENE_IDS.has(object.userData.id) || isHostOwned(object)) kept.push(object);
+	else removed.push(object);
+	scene.children.length = 0;
+	for (const object of kept) scene.children.push(object);
+	for (const object of removed) {
+		disposeObjectTree(object, { keepUploaded });
+		object.parent = null;
+		object.dispatchEvent({ type: "removed" });
+		scene.dispatchEvent({
+			type: "childremoved",
+			child: object
+		});
+	}
+}
+// src/render/camera-controller.ts
+/**
+* Seven preset view directions (target → camera, unit vectors), derived from `up` rather than a
+* fixed Y-up table so Top/Front/… stay meaningful for Z-up Rhino scenes.
+*
+* `buildUpBasis`'s `forward` is camera→model; these are camera positions relative to target, so
+* "front" is `-forward`. Flipping this puts the camera behind the model and swaps left/right.
+*/
+function buildViewDirections(up) {
+	const { up: u, forward, right } = buildUpBasis(up);
+	const frontPosition = forward.clone().negate();
+	const rightPosition = right.clone();
+	return {
+		top: u.clone(),
+		bottom: u.clone().negate(),
+		front: frontPosition.clone(),
+		back: frontPosition.clone().negate(),
+		right: rightPosition.clone(),
+		left: rightPosition.clone().negate(),
+		iso: frontPosition.clone().multiplyScalar(1.2).add(rightPosition.clone()).add(u.clone()).normalize()
+	};
+}
+function createCameraController(deps) {
+	const { scene, perspective, controls, onActiveCameraChange } = deps;
+	const up = (deps.up ?? perspective.up).clone().normalize();
+	const VIEW_DIRECTIONS = buildViewDirections(up);
+	const ortho = new THREE.OrthographicCamera(-1, 1, 1, -1, perspective.near, perspective.far);
+	ortho.up.copy(up);
+	let projection = "perspective";
+	let aspect = perspective.aspect;
+	const active = () => projection === "perspective" ? perspective : ortho;
+	let activeTween = null;
+	const cancelTween = () => {
+		activeTween?.cancel();
+		activeTween = null;
+	};
+	const syncOrthoFrustum = () => {
+		const halfH = (projection === "orthographic" ? ortho : perspective).position.distanceTo(controls.target) * Math.tan(perspective.fov * Math.PI / 360);
+		const halfW = halfH * aspect;
+		ortho.left = -halfW;
+		ortho.right = halfW;
+		ortho.top = halfH;
+		ortho.bottom = -halfH;
+		ortho.near = perspective.near;
+		ortho.far = perspective.far;
+		ortho.updateProjectionMatrix();
+	};
+	const setProjection = (next) => {
+		if (next === projection) return;
+		cancelTween();
+		if (next === "orthographic") {
+			ortho.position.copy(perspective.position);
+			ortho.up.copy(perspective.up);
+			ortho.lookAt(controls.target);
+			ortho.zoom = 1;
+			syncOrthoFrustum();
+		} else {
+			const distance = (ortho.top - ortho.bottom) / (2 * ortho.zoom) / Math.tan(perspective.fov * Math.PI / 360);
+			const direction = ortho.position.clone().sub(controls.target);
+			if (direction.lengthSq() < 1e-12) direction.copy(up);
+			direction.normalize();
+			perspective.position.copy(controls.target).add(direction.multiplyScalar(distance));
+		}
+		projection = next;
+		controls.object = active();
+		controls.update();
+		onActiveCameraChange(active());
+	};
+	const frame = (center, maxDim, direction, animate) => {
+		const fov = perspective.fov * (Math.PI / 180);
+		const distance = maxDim / (2 * Math.tan(fov / 2)) * 1.5;
+		const dir = nudgeOffPole(direction, up);
+		const toPosition = center.clone().add(dir.clone().multiplyScalar(distance));
+		const cam = active();
+		if (projection === "orthographic") ortho.zoom = 1;
+		cancelTween();
+		if (animate) activeTween = animateMove(cam, controls, toPosition, center, () => {
+			if (projection === "orthographic") syncOrthoFrustum();
+		});
+		else {
+			cam.position.copy(toPosition);
+			controls.target.copy(center);
+			if (projection === "orthographic") syncOrthoFrustum();
+			controls.update();
+		}
+	};
+	const setViewDirection = (direction, animate = true) => {
+		const box = computeContentBounds(scene);
+		const center = box.isEmpty() ? controls.target.clone() : box.getCenter(new THREE.Vector3());
+		const size = box.isEmpty() ? new THREE.Vector3(1, 1, 1) : box.getSize(new THREE.Vector3());
+		const maxDim = Math.max(size.x, size.y, size.z) || 1;
+		frame(center, maxDim, direction, animate);
+	};
+	const frameBounds = (box, animate = true) => {
+		if (box.isEmpty()) return;
+		const center = box.getCenter(new THREE.Vector3());
+		const size = box.getSize(new THREE.Vector3());
+		const maxDim = Math.max(size.x, size.y, size.z) || 1;
+		const direction = active().position.clone().sub(controls.target);
+		if (direction.lengthSq() < 1e-12) direction.copy(VIEW_DIRECTIONS.iso);
+		frame(center, maxDim, direction.normalize(), animate);
+	};
+	const setView = (preset, animate = true) => {
+		setViewDirection(VIEW_DIRECTIONS[preset], animate);
+	};
+	const setRotateEnabled = (enabled) => {
+		controls.enableRotate = enabled;
+	};
+	const updateAspect = (width, height) => {
+		aspect = height === 0 ? aspect : width / height;
+		if (projection === "orthographic") syncOrthoFrustum();
+	};
+	return {
+		getActiveCamera: active,
+		getProjection: () => projection,
+		setProjection,
+		toggleProjection: () => {
+			setProjection(projection === "perspective" ? "orthographic" : "perspective");
+			return projection;
+		},
+		setView,
+		setViewDirection,
+		frameBounds,
+		setRotateEnabled,
+		isRotateEnabled: () => controls.enableRotate,
+		updateAspect,
+		dispose: cancelTween
+	};
+}
+/**
+* Nudges a top/bottom view direction a ~0.5° tilt off the up axis; other presets pass through
+* unchanged. Looking exactly down `up` is an OrbitControls singularity: camera direction coincides
+* with `camera.up`, azimuth is undefined, and the first drag snaps the view.
+*
+* At the pole, `camera.up` can't define roll, so the tilt direction does instead. Both poles lean
+* toward `-forward` to reproduce Rhino's convention (Top has +forward at screen-top; Bottom mirrors
+* about the horizontal axis, matching Rhino where the far side reads backwards too) — leaning the
+* poles opposite ways also mirrors correctly, but rolled 180° from Rhino.
+*/
+function nudgeOffPole(dir, up) {
+	const { up: u, forward } = buildUpBasis(up);
+	const d = dir.clone().normalize();
+	if (Math.abs(d.dot(u)) < .9999) return dir;
+	const inPlane = forward.clone().negate();
+	const tilt = .5 * Math.PI / 180;
+	return d.multiplyScalar(Math.cos(tilt)).add(inPlane.multiplyScalar(Math.sin(tilt))).normalize();
+}
+const easeOut = (t) => 1 - Math.pow(1 - t, 3);
+/** Tweens camera position + controls target; returns a cancel handle for teardown/preemption. */
+function animateMove(camera, controls, toPosition, toTarget, onTick, durationMs = 250) {
+	const fromPosition = camera.position.clone();
+	const fromTarget = controls.target.clone();
+	const startTime = performance.now();
+	let rafId = null;
+	const tick = () => {
+		rafId = null;
+		const t = easeOut(Math.min((performance.now() - startTime) / durationMs, 1));
+		camera.position.lerpVectors(fromPosition, toPosition, t);
+		controls.target.lerpVectors(fromTarget, toTarget, t);
+		onTick();
+		controls.update();
+		if (t < 1) rafId = requestAnimationFrame(tick);
+	};
+	rafId = requestAnimationFrame(tick);
+	return { cancel: () => {
+		if (rafId !== null) {
+			cancelAnimationFrame(rafId);
+			rafId = null;
+		}
+	} };
+}
+// src/render/edges/line-geometry.ts
+const SPACING_PERCENTILE = .15;
+const SPACING_SAMPLE_LIMIT = 4096;
+function edgeSpacingOf(segments) {
+	const segmentCount = Math.floor(segments.length / 6);
+	if (segmentCount === 0) return Infinity;
+	const stride = Math.max(1, Math.ceil(segmentCount / SPACING_SAMPLE_LIMIT));
+	const lengths = [];
+	for (let s = 0; s < segmentCount; s += stride) {
+		const i = s * 6;
+		const length = Math.hypot(segments[i + 3] - segments[i], segments[i + 4] - segments[i + 1], segments[i + 5] - segments[i + 2]);
+		if (length > 0) lengths.push(length);
+	}
+	if (lengths.length === 0) return Infinity;
+	lengths.sort((a, b) => a - b);
+	return lengths[Math.min(lengths.length - 1, Math.floor(lengths.length * SPACING_PERCENTILE))];
+}
+function buildLineGeometry(segments) {
+	const geometry = new LineSegmentsGeometry();
+	geometry.setPositions(segments);
+	return {
+		geometry,
+		segmentCount: segments.length / 6,
+		edgeSpacing: edgeSpacingOf(segments)
+	};
+}
+/**
+* @param index - Triangle indices, or null for non-indexed soup.
+* @returns `segments`: endpoint pairs, same layout as `EdgesGeometry.attributes.position.array`.
+*   `faces`: per segment, the triangle it came from, so a merged mesh can drop a hidden member's
+*   edges without extracting again.
+* @throws If `positions` holds ≥ 2^26 vertices ({@link MAX_EXTRACT_VERTICES}) — callers fall
+*   back to `THREE.EdgesGeometry`.
+*/
+function extractEdgeSegments(positions, index, thresholdAngleDeg) {
+	const PRECISION = 1e4;
+	const ID_BITS = 67108864;
+	const thresholdDot = Math.cos(Math.PI / 180 * thresholdAngleDeg);
+	const vertexCount = positions.length / 3;
+	if (vertexCount >= ID_BITS) throw new Error(`extractEdgeSegments: ${vertexCount} vertices exceeds 2^26 limit`);
+	const quantX = new Float64Array(vertexCount);
+	const quantY = new Float64Array(vertexCount);
+	const quantZ = new Float64Array(vertexCount);
+	for (let v = 0; v < vertexCount; v++) {
+		quantX[v] = Math.round(positions[3 * v] * PRECISION);
+		quantY[v] = Math.round(positions[3 * v + 1] * PRECISION);
+		quantZ[v] = Math.round(positions[3 * v + 2] * PRECISION);
+	}
+	let capacity = 16;
+	while (capacity < vertexCount * 2) capacity <<= 1;
+	const mask = capacity - 1;
+	const table = new Int32Array(capacity).fill(-1);
+	const canonical = new Int32Array(vertexCount);
+	for (let v = 0; v < vertexCount; v++) {
+		let slot = (Math.imul(quantX[v] | 0, 73856093) ^ Math.imul(quantY[v] | 0, 19349663) ^ Math.imul(quantZ[v] | 0, 83492791)) & mask;
+		for (;;) {
+			const existing = table[slot];
+			if (existing === -1) {
+				table[slot] = v;
+				canonical[v] = v;
+				break;
+			}
+			if (quantX[existing] === quantX[v] && quantY[existing] === quantY[v] && quantZ[existing] === quantZ[v]) {
+				canonical[v] = existing;
+				break;
+			}
+			slot = slot + 1 & mask;
+		}
+	}
+	let out = /* @__PURE__ */ new Float32Array(6144);
+	let outLength = 0;
+	let outFaces = /* @__PURE__ */ new Uint32Array(1024);
+	const emit = (i0, i1, face) => {
+		if (outLength + 6 > out.length) {
+			const grown = new Float32Array(out.length * 2);
+			grown.set(out);
+			out = grown;
+			const grownFaces = new Uint32Array(out.length / 6);
+			grownFaces.set(outFaces);
+			outFaces = grownFaces;
+		}
+		outFaces[outLength / 6] = face;
+		out[outLength++] = positions[3 * i0];
+		out[outLength++] = positions[3 * i0 + 1];
+		out[outLength++] = positions[3 * i0 + 2];
+		out[outLength++] = positions[3 * i1];
+		out[outLength++] = positions[3 * i1 + 1];
+		out[outLength++] = positions[3 * i1 + 2];
+	};
+	const triCount = (index ? index.length : vertexCount) / 3;
+	const rowStart = new Int32Array(vertexCount + 1);
+	for (let t = 0; t < triCount; t++) {
+		const a = canonical[index ? index[3 * t] : 3 * t];
+		const b = canonical[index ? index[3 * t + 1] : 3 * t + 1];
+		const c = canonical[index ? index[3 * t + 2] : 3 * t + 2];
+		if (a === b || b === c || c === a) continue;
+		rowStart[a + 1]++;
+		rowStart[b + 1]++;
+		rowStart[c + 1]++;
+	}
+	for (let v = 0; v < vertexCount; v++) rowStart[v + 1] += rowStart[v];
+	const cellTo = new Int32Array(rowStart[vertexCount]);
+	{
+		const cursor = rowStart.slice(0, vertexCount);
+		for (let t = 0; t < triCount; t++) {
+			const a = canonical[index ? index[3 * t] : 3 * t];
+			const b = canonical[index ? index[3 * t + 1] : 3 * t + 1];
+			const c = canonical[index ? index[3 * t + 2] : 3 * t + 2];
+			if (a === b || b === c || c === a) continue;
+			cellTo[cursor[a]++] = b;
+			cellTo[cursor[b]++] = c;
+			cellTo[cursor[c]++] = a;
+		}
+	}
+	const UNSEEN = -2;
+	const MATCHED = -1;
+	const cellState = new Int32Array(cellTo.length).fill(UNSEEN);
+	const findCell = (from, to) => {
+		for (let k = rowStart[from], end = rowStart[from + 1]; k < end; k++) if (cellTo[k] === to) return k;
+		return -1;
+	};
+	const cornerOf = (t, k) => index ? index[3 * t + k] : 3 * t + k;
+	const normal = /* @__PURE__ */ new Float64Array(3);
+	const faceNormal = (t) => {
+		const i0 = cornerOf(t, 0);
+		const i1 = cornerOf(t, 1);
+		const i2 = cornerOf(t, 2);
+		const e0x = positions[3 * i2] - positions[3 * i1];
+		const e0y = positions[3 * i2 + 1] - positions[3 * i1 + 1];
+		const e0z = positions[3 * i2 + 2] - positions[3 * i1 + 2];
+		const e1x = positions[3 * i0] - positions[3 * i1];
+		const e1y = positions[3 * i0 + 1] - positions[3 * i1 + 1];
+		const e1z = positions[3 * i0 + 2] - positions[3 * i1 + 2];
+		let nx = e0y * e1z - e0z * e1y;
+		let ny = e0z * e1x - e0x * e1z;
+		let nz = e0x * e1y - e0y * e1x;
+		const lengthSq = nx * nx + ny * ny + nz * nz;
+		if (lengthSq > 0) {
+			const inverseLength = 1 / Math.sqrt(lengthSq);
+			nx *= inverseLength;
+			ny *= inverseLength;
+			nz *= inverseLength;
+		} else {
+			nx = 0;
+			ny = 0;
+			nz = 0;
+		}
+		normal[0] = nx;
+		normal[1] = ny;
+		normal[2] = nz;
+	};
+	let pendingCount = 0;
+	let pendingCorners = new Uint32Array(Math.max(16, cellTo.length >> 1));
+	let pendingCells = new Int32Array(pendingCorners.length);
+	const growPending = () => {
+		const corners = new Uint32Array(pendingCorners.length * 2);
+		corners.set(pendingCorners);
+		pendingCorners = corners;
+		const cells = new Int32Array(corners.length);
+		cells.set(pendingCells);
+		pendingCells = cells;
+	};
+	for (let t = 0; t < triCount; t++) {
+		const i0 = cornerOf(t, 0);
+		const i1 = cornerOf(t, 1);
+		const i2 = cornerOf(t, 2);
+		const a = canonical[i0];
+		const b = canonical[i1];
+		const c = canonical[i2];
+		if (a === b || b === c || c === a) continue;
+		let haveNormal = false;
+		let nx = 0;
+		let ny = 0;
+		let nz = 0;
+		for (let j = 0; j < 3; j++) {
+			const fromCanonical = j === 0 ? a : j === 1 ? b : c;
+			const toCanonical = j === 0 ? b : j === 1 ? c : a;
+			const reverseCell = findCell(toCanonical, fromCanonical);
+			const reverseSlot = reverseCell === -1 ? UNSEEN : cellState[reverseCell];
+			if (reverseSlot >= 0) {
+				if (!haveNormal) {
+					faceNormal(t);
+					nx = normal[0];
+					ny = normal[1];
+					nz = normal[2];
+					haveNormal = true;
+				}
+				faceNormal(Math.floor(pendingCorners[reverseSlot] / 3));
+				if (nx * normal[0] + ny * normal[1] + nz * normal[2] <= thresholdDot) emit(j === 0 ? i0 : j === 1 ? i1 : i2, j === 0 ? i1 : j === 1 ? i2 : i0, t);
+				cellState[reverseCell] = MATCHED;
+			} else {
+				const forwardCell = findCell(fromCanonical, toCanonical);
+				if (cellState[forwardCell] === UNSEEN) {
+					if (pendingCount === pendingCorners.length) growPending();
+					const slot = pendingCount++;
+					cellState[forwardCell] = slot;
+					pendingCorners[slot] = 3 * t + j;
+					pendingCells[slot] = forwardCell;
+				}
+			}
+		}
+	}
+	for (let slot = 0; slot < pendingCount; slot++) {
+		if (cellState[pendingCells[slot]] !== slot) continue;
+		const corner = pendingCorners[slot];
+		const t = Math.floor(corner / 3);
+		const j = corner - 3 * t;
+		emit(cornerOf(t, j), cornerOf(t, j === 2 ? 0 : j + 1), t);
+	}
+	return {
+		segments: out.slice(0, outLength),
+		faces: outFaces.slice(0, outLength / 6)
+	};
+}
+/**
+* Worker source running {@link extractEdgeSegments} off the main thread. Protocol: receives
+* `{id, positions, index, thresholdAngle}`, replies `{id, segments, faces}` (buffers transferred) or
+* `{id, error}`.
+*
+* Relies on `extractEdgeSegments` stringifying to standalone code — guarded by a unit test that
+* evals this source in isolation.
+*/
+function edgeExtractWorkerSource() {
+	return [
+		`const extract = ${extractEdgeSegments.toString()};`,
+		`self.onmessage = (event) => {`,
+		`  const { id, positions, index, thresholdAngle } = event.data;`,
+		`  try {`,
+		`    const { segments, faces } = extract(positions, index, thresholdAngle);`,
+		`    self.postMessage({ id, segments, faces }, [segments.buffer, faces.buffer]);`,
+		`  } catch (error) {`,
+		`    self.postMessage({ id, error: String((error && error.message) || error) });`,
+		`  }`,
+		`};`
+	].join("\n");
+}
+// src/render/edges/options.ts
+/** Tag on edge overlays so pick/fit/clear logic can recognize and skip or dispose them. */
+const EDGE_USERDATA_KIND = "edge-overlay";
+/** `userData.edgesSkipped` value; see {@link EdgeOptions.maxTriangles}. */
+const EDGES_SKIPPED_TRIANGLE_CAP = "triangle-cap";
+/** `userData.edgesSkipped` value; see {@link EdgeOptions.maxOverlays}. */
+const EDGES_SKIPPED_OVERLAY_BUDGET = "overlay-budget";
+const DEFAULT_EDGE_COLOR = 2236962;
+const DEFAULT_EDGE_WIDTH = 1.5;
+const DEFAULT_THRESHOLD_ANGLE = 44;
+const DEFAULT_DARKEN = .75;
+const DEFAULT_MAX_TRIANGLES = 8e6;
+const DEFAULT_MAX_SEGMENTS = 2e6;
+const DEFAULT_MAX_OVERLAYS = 1500;
+function resolveOptions(options) {
+	return {
+		forcedColor: options.color != null ? new THREE.Color(options.color) : null,
+		darken: THREE.MathUtils.clamp(options.darken ?? DEFAULT_DARKEN, 0, 1),
+		width: options.width ?? DEFAULT_EDGE_WIDTH,
+		thresholdAngle: options.thresholdAngle ?? DEFAULT_THRESHOLD_ANGLE,
+		distanceFade: options.distanceFade ?? true,
+		maxTriangles: options.maxTriangles ?? DEFAULT_MAX_TRIANGLES,
+		maxSegments: options.maxSegments ?? DEFAULT_MAX_SEGMENTS,
+		maxOverlays: options.maxOverlays ?? DEFAULT_MAX_OVERLAYS
+	};
+}
+// src/render/edges/extraction.ts
+function triangleCountOf(geometry) {
+	const position = geometry.getAttribute("position");
+	if (!position) return 0;
+	return (geometry.index ? geometry.index.count : position.count) / 3;
+}
+function fastPathData(geometry) {
+	const position = geometry.getAttribute("position");
+	if (!position || position.isInterleavedBufferAttribute || position.itemSize !== 3 || !(position.array instanceof Float32Array) || position.count >= 67108864) return null;
+	const index = geometry.index;
+	if (index && !(index.array instanceof Uint32Array) && !(index.array instanceof Uint16Array)) return null;
+	return {
+		positions: position.array,
+		index: index ? index.array : null,
+		version: `${position.version}:${index?.version ?? 0}`
+	};
+}
+function contentKey(data, thresholdAngle) {
+	const SAMPLE_WORDS = 4096;
+	let hash = 2166136261;
+	const mix = (word) => {
+		hash ^= word;
+		hash = Math.imul(hash, 16777619);
+	};
+	const words = new Uint32Array(data.positions.buffer, data.positions.byteOffset, data.positions.length);
+	const head = Math.min(SAMPLE_WORDS, words.length);
+	for (let i = 0; i < head; i++) mix(words[i]);
+	for (let i = Math.max(head, words.length - SAMPLE_WORDS); i < words.length; i++) mix(words[i]);
+	let indexLength = 0;
+	if (data.index) {
+		indexLength = data.index.length;
+		const headIndex = Math.min(SAMPLE_WORDS, indexLength);
+		for (let i = 0; i < headIndex; i++) mix(data.index[i]);
+		for (let i = Math.max(headIndex, indexLength - SAMPLE_WORDS); i < indexLength; i++) mix(data.index[i]);
+	}
+	return `${thresholdAngle}:${data.positions.length}:${indexLength}:${hash >>> 0}`;
+}
+function extractViaThree(geometry, thresholdAngle) {
+	const edges = new THREE.EdgesGeometry(geometry, thresholdAngle);
+	const positions = edges.attributes.position ? edges.attributes.position.array : /* @__PURE__ */ new Float32Array(0);
+	edges.dispose();
+	return {
+		segments: positions,
+		faces: null
+	};
+}
+const extracted = /* @__PURE__ */ new WeakMap();
+const NO_INDEX = {};
+function recall(data, thresholdAngle) {
+	const known = extracted.get(data.positions)?.get(data.index ?? NO_INDEX)?.get(thresholdAngle);
+	return known?.version === data.version ? known.edges : void 0;
+}
+function remember(data, thresholdAngle, edges) {
+	let byIndex = extracted.get(data.positions);
+	if (!byIndex) extracted.set(data.positions, byIndex = /* @__PURE__ */ new WeakMap());
+	let byAngle = byIndex.get(data.index ?? NO_INDEX);
+	if (!byAngle) byIndex.set(data.index ?? NO_INDEX, byAngle = /* @__PURE__ */ new Map());
+	byAngle.set(thresholdAngle, {
+		version: data.version,
+		edges
+	});
+	return edges;
+}
+function extractSegmentsSync(geometry, thresholdAngle) {
+	const data = fastPathData(geometry);
+	if (!data) return extractViaThree(geometry, thresholdAngle);
+	return recall(data, thresholdAngle) ?? remember(data, thresholdAngle, extractEdgeSegments(data.positions, data.index, thresholdAngle));
+}
+let extractionWorker;
+const pendingRequests = /* @__PURE__ */ new Map();
+let nextRequestId = 1;
+function getExtractionWorker() {
+	if (extractionWorker !== void 0) return extractionWorker;
+	if (typeof Worker === "undefined" || typeof Blob === "undefined" || typeof URL === "undefined" || typeof URL.createObjectURL !== "function") {
+		extractionWorker = null;
+		return null;
+	}
+	try {
+		const url = URL.createObjectURL(new Blob([edgeExtractWorkerSource()], { type: "text/javascript" }));
+		const worker = new Worker(url);
+		worker.onmessage = (event) => {
+			const { id, segments, faces, error } = event.data;
+			const pending = pendingRequests.get(id);
+			if (!pending) return;
+			pendingRequests.delete(id);
+			if (segments) pending.resolve({
+				segments,
+				faces: faces ?? null
+			});
+			else pending.reject(new Error(error ?? "edge extraction failed in worker"));
+		};
+		worker.onerror = () => {
+			for (const pending of pendingRequests.values()) pending.reject(/* @__PURE__ */ new Error("edge extraction worker crashed"));
+			pendingRequests.clear();
+			worker.terminate();
+			extractionWorker = null;
+		};
+		extractionWorker = worker;
+	} catch {
+		extractionWorker = null;
+	}
+	return extractionWorker;
+}
+function extractInWorker(worker, data, thresholdAngle) {
+	return new Promise((resolve, reject) => {
+		const id = nextRequestId++;
+		pendingRequests.set(id, {
+			resolve,
+			reject
+		});
+		const positions = data.positions.slice();
+		const index = data.index ? data.index.slice() : null;
+		const transfer = [positions.buffer];
+		if (index) transfer.push(index.buffer);
+		worker.postMessage({
+			id,
+			positions,
+			index,
+			thresholdAngle
+		}, transfer);
+	});
+}
+const inFlightExtractions = /* @__PURE__ */ new Map();
+function extractSegmentsAsync(geometry, thresholdAngle) {
+	const data = fastPathData(geometry);
+	if (!data || triangleCountOf(geometry) < 25e3) return Promise.resolve(extractSegmentsSync(geometry, thresholdAngle));
+	const known = recall(data, thresholdAngle);
+	if (known) return Promise.resolve(known);
+	const key = contentKey(data, thresholdAngle);
+	const inFlight = inFlightExtractions.get(key);
+	if (inFlight) return inFlight;
+	const worker = getExtractionWorker();
+	if (!worker) return Promise.resolve(extractSegmentsSync(geometry, thresholdAngle));
+	const request = extractInWorker(worker, data, thresholdAngle).catch(() => extractEdgeSegments(data.positions, data.index, thresholdAngle)).then((edges) => remember(data, thresholdAngle, edges)).finally(() => {
+		inFlightExtractions.delete(key);
+	});
+	inFlightExtractions.set(key, request);
+	return request;
+}
+// src/render/scene-setup/merged-picking.ts
+/** Members of a merged mesh, or null for an ordinary one. */
+function membersOf(object) {
+	const members = object.userData?.members;
+	return Array.isArray(members) && members.length > 0 ? members : null;
+}
+/**
+* The source object a raycast hit landed on, or null when this isn't a merged mesh or the hit
+* carries no face (points/lines, or a member written without an index window).
+*
+* Members are laid out in ascending, contiguous index order, so this is a binary search rather
+* than a scan — a merged group can hold thousands of members and picking runs per click.
+*/
+function resolveHitMember(hit) {
+	const members = membersOf(hit.object);
+	if (!members || hit.faceIndex == null) return null;
+	const hitIndex = hit.faceIndex * 3;
+	let low = 0;
+	let high = members.length - 1;
+	while (low <= high) {
+		const mid = low + high >> 1;
+		const member = members[mid];
+		if (member.indexStart == null || member.indexCount == null) return null;
+		if (hitIndex < member.indexStart) high = mid - 1;
+		else if (hitIndex >= member.indexStart + member.indexCount) low = mid + 1;
+		else return {
+			member,
+			index: mid
+		};
+	}
+	return null;
+}
+/**
+* World-space bounds of one member inside a merged mesh, walking only that member's index window.
+* `Box3.setFromObject` would return the whole merged group's bounds.
+*/
+function memberBounds(mesh, member) {
+	const box = new THREE.Box3();
+	const index = mesh.geometry.getIndex();
+	const position = mesh.geometry.getAttribute("position");
+	if (!index || !position || member.indexStart == null || member.indexCount == null) return box;
+	mesh.updateMatrixWorld();
+	const vertex = new THREE.Vector3();
+	const end = Math.min(member.indexStart + member.indexCount, index.count);
+	for (let i = member.indexStart; i < end; i++) {
+		vertex.fromBufferAttribute(position, index.getX(i)).applyMatrix4(mesh.matrixWorld);
+		box.expandByPoint(vertex);
+	}
+	return box;
+}
+/**
+* Draws members of a merged mesh with `highlight`. Returns a restore function; call it before
+* applying a different highlight. Members hidden by the outliner stay hidden either way.
+*/
+function highlightMembers(mesh, members, highlight, kind) {
+	setMemberHighlight(mesh, members, highlight, kind);
+	return () => clearMemberHighlight(mesh, kind);
+}
+// src/render/edges/member-filter.ts
+/** Per segment, the index of the member whose index window holds its source triangle. */
+function memberOfSegments(mesh, faces) {
+	const members = membersOf(mesh);
+	if (!members) return null;
+	const starts = [];
+	for (const member of members) {
+		if (member.indexStart == null) return null;
+		starts.push(member.indexStart);
+	}
+	const result = new Uint32Array(faces.length);
+	for (let s = 0; s < faces.length; s++) {
+		const indexPosition = faces[s] * 3;
+		let low = 0;
+		let high = starts.length - 1;
+		while (low < high) {
+			const mid = low + high + 1 >> 1;
+			if (starts[mid] <= indexPosition) low = mid;
+			else high = mid - 1;
+		}
+		result[s] = low;
+	}
+	return result;
+}
+function visibleSegments(segments, memberOf, hidden) {
+	let count = 0;
+	for (let s = 0; s < memberOf.length; s++) if (!hidden.has(memberOf[s])) count++;
+	const out = new Float32Array(count * 6);
+	let offset = 0;
+	for (let s = 0; s < memberOf.length; s++) {
+		if (hidden.has(memberOf[s])) continue;
+		out.set(segments.subarray(s * 6, s * 6 + 6), offset);
+		offset += 6;
+	}
+	return out;
+}
+/** Keeps `overlay` in step with the hidden members of `mesh`, its parent. */
+function followHiddenMembers(overlay, mesh, edges) {
+	const { segments, faces } = edges;
+	if (!faces || !membersOf(mesh)) return;
+	let memberOf;
+	let filtered = false;
+	const apply = () => {
+		const hidden = getHiddenMembers(mesh);
+		if (hidden.size === 0 && !filtered) return;
+		memberOf ??= memberOfSegments(mesh, faces);
+		if (!memberOf) return;
+		const next = hidden.size === 0 ? segments : visibleSegments(segments, memberOf, hidden);
+		overlay.geometry.dispose();
+		overlay.geometry = buildLineGeometry(next).geometry;
+		filtered = hidden.size > 0;
+	};
+	apply();
+	const unsubscribe = onMemberDrawChange(mesh, apply);
+	overlay.addEventListener("removed", unsubscribe);
+}
+// src/render/edges/overlay.ts
+function deriveEdgeColor(mesh, darken) {
+	const source = (Array.isArray(mesh.material) ? mesh.material[0] : mesh.material)?.color;
+	if (!source) return new THREE.Color(DEFAULT_EDGE_COLOR);
+	return source.clone().multiplyScalar(1 - darken);
+}
+/** Pools materials by color+fade so overlays sharing both share one `LineMaterial` instance. */
+var MaterialPool = class {
+	options;
+	byKey = /* @__PURE__ */ new Map();
+	constructor(options) {
+		this.options = options;
+	}
+	for(mesh, fade) {
+		const color = this.options.forcedColor ?? deriveEdgeColor(mesh, this.options.darken);
+		const key = color.getHex() * 2 + (fade ? 1 : 0);
+		let material = this.byKey.get(key);
+		if (!material) {
+			material = createEdgeMaterial(color, this.options.width, fade);
+			this.byKey.set(key, material);
+		}
+		return material;
+	}
+	/** Dispose any material no overlay adopted (e.g. every mesh was skipped or cancelled). */
+	disposeUnused(created) {
+		const used = new Set(created.map((overlay) => overlay.material));
+		for (const material of this.byKey.values()) if (!used.has(material)) material.dispose();
+	}
+};
+function createEdgeMaterial(color, width, distanceFade) {
+	const material = new LineMaterial({ color });
+	material.linewidth = width;
+	material.polygonOffset = true;
+	material.polygonOffsetFactor = 0;
+	material.polygonOffsetUnits = -1;
+	if (distanceFade) material.transparent = true;
+	return material;
+}
+function buildEdgeOverlay(entry, material, distanceFade) {
+	const overlay = new LineSegments2(entry.geometry, material);
+	overlay.userData.kind = EDGE_USERDATA_KIND;
+	overlay.raycast = () => {};
+	if (distanceFade) enableDistanceFade(overlay, entry.edgeSpacing);
+	return overlay;
+}
+const _fadeCenter = new THREE.Vector3();
+const _fadeCameraPos = new THREE.Vector3();
+function pixelsPerWorldUnit(overlay, camera, viewportHeightPx) {
+	if (!overlay.geometry.boundingSphere) overlay.geometry.computeBoundingSphere();
+	const sphere = overlay.geometry.boundingSphere;
+	if (!sphere) return Infinity;
+	if (camera.isPerspectiveCamera) {
+		const perspective = camera;
+		_fadeCenter.copy(sphere.center).applyMatrix4(overlay.matrixWorld);
+		const distance = _fadeCameraPos.setFromMatrixPosition(camera.matrixWorld).distanceTo(_fadeCenter);
+		if (distance <= sphere.radius * overlay.matrixWorld.getMaxScaleOnAxis()) return Infinity;
+		const tanHalfFov = Math.tan(THREE.MathUtils.degToRad(perspective.fov) * .5);
+		const worldHeightAtCentre = 2 * distance * tanHalfFov;
+		return worldHeightAtCentre > 0 ? viewportHeightPx / worldHeightAtCentre : Infinity;
+	}
+	if (camera.isOrthographicCamera) {
+		const ortho = camera;
+		const worldHeight = (ortho.top - ortho.bottom) / ortho.zoom;
+		return worldHeight > 0 ? viewportHeightPx / worldHeight : Infinity;
+	}
+	return Infinity;
+}
+function enableDistanceFade(overlay, edgeSpacing) {
+	overlay.onBeforeRender = (renderer, _scene, camera) => {
+		LineSegments2.prototype.onBeforeRender.call(overlay, renderer);
+		const material = overlay.material;
+		const gapPx = edgeSpacing * pixelsPerWorldUnit(overlay, camera, material.resolution.y);
+		material.opacity = THREE.MathUtils.clamp((gapPx - 1) / 3, 0, 1);
+	};
+}
+// src/render/edges.ts
+/** For pick/fit filters elsewhere to exclude overlays from hit-testing. */
+function isEdgeOverlay(object) {
+	return object.userData?.kind === EDGE_USERDATA_KIND;
+}
+/**
+* Meshes under `root` that should get an overlay: content meshes without one, caps applied.
+*
+* Two caps, and they fail in opposite directions. `maxTriangles` is per mesh and rejects the rare
+* enormous one; `maxOverlays` is a budget over the whole set and rejects the far more common case
+* of thousands of small ones, which no per-mesh test can see. Overlays already attached from an
+* earlier apply are counted against the budget, so a re-apply can't creep past it.
+*/
+function collectTargets(root, resolved) {
+	const candidates = [];
+	let existingOverlays = 0;
+	root.traverse((object) => {
+		if (!(object instanceof THREE.Mesh)) return;
+		if (object.userData.id === "floor" || object.userData.id === "grid") return;
+		if (object.userData.kind === "edge-overlay") return;
+		if (object.children.some((c) => c.userData?.kind === "edge-overlay")) {
+			existingOverlays++;
+			return;
+		}
+		if (!object.geometry) return;
+		if (triangleCountOf(object.geometry) > resolved.maxTriangles) {
+			object.userData.edgesSkipped = EDGES_SKIPPED_TRIANGLE_CAP;
+			return;
+		}
+		candidates.push(object);
+	});
+	const budget = Math.max(0, resolved.maxOverlays - existingOverlays);
+	const targets = candidates.slice(0, budget);
+	for (const mesh of targets) delete mesh.userData.edgesSkipped;
+	for (const mesh of candidates.slice(budget)) mesh.userData.edgesSkipped = EDGES_SKIPPED_OVERLAY_BUDGET;
+	if (candidates.length > budget) console.debug(`[edges] overlay budget reached: ${candidates.length} meshes want overlays, ${budget} allowed — the rest fall back to the screen-space edge pass.`);
+	return targets;
+}
+function attachOverlay(mesh, edges, materials, resolved) {
+	const entry = buildLineGeometry(edges.segments);
+	const fade = resolved.distanceFade && entry.segmentCount <= resolved.maxSegments;
+	const overlay = buildEdgeOverlay(entry, materials.for(mesh, fade), fade);
+	mesh.add(overlay);
+	followHiddenMembers(overlay, mesh, edges);
+	return overlay;
+}
+/**
+* {@link removeEdges} bumps this per root; async attaches landing after a bump are dropped, so
+* "toggle off while extracting" can't resurrect overlays.
+*/
+const rootGenerations = /* @__PURE__ */ new WeakMap();
+function generationOf(root) {
+	return rootGenerations.get(root) ?? 0;
+}
+/** Is `mesh` still reachable from `root`? Guards attaches racing scene clears. */
+function isConnected(mesh, root) {
+	for (let node = mesh; node; node = node.parent) if (node === root) return true;
+	return false;
+}
+/**
+* Like {@link addEdges}, but large-mesh extraction runs in a Worker so the main thread never
+* stalls; small meshes still attach synchronously before this resolves. Resolves with every
+* overlay actually attached — late results are dropped if the mesh left the subtree,
+* {@link removeEdges} ran for this root meanwhile, or another apply already attached one to that
+* mesh.
+*/
+async function addEdgesAsync(root, options = {}) {
+	const resolved = resolveOptions(options);
+	const materials = new MaterialPool(resolved);
+	const generation = generationOf(root);
+	const created = [];
+	const attaches = collectTargets(root, resolved).map(async (mesh) => {
+		const edges = await extractSegmentsAsync(mesh.geometry, resolved.thresholdAngle);
+		if (generationOf(root) !== generation) return;
+		if (!isConnected(mesh, root)) return;
+		if (mesh.children.some((c) => c.userData?.kind === "edge-overlay")) return;
+		created.push(attachOverlay(mesh, edges, materials, resolved));
+	});
+	await Promise.all(attaches);
+	materials.disposeUnused(created);
+	return created;
+}
+/**
+* Remove every edge overlay under `root`, disposing geometry and material, and cancels any
+* in-flight async attaches for `root`. Inverse of {@link addEdges}/{@link addEdgesAsync}. Returns
+* the count removed.
+*/
+function removeEdges(root) {
+	rootGenerations.set(root, generationOf(root) + 1);
+	const overlays = [];
+	root.traverse((object) => {
+		if (object instanceof LineSegments2 && isEdgeOverlay(object)) overlays.push(object);
+	});
+	const materials = /* @__PURE__ */ new Set();
+	for (const overlay of overlays) {
+		overlay.geometry.dispose();
+		materials.add(overlay.material);
+		overlay.removeFromParent();
+	}
+	materials.forEach((material) => material.dispose());
+	return overlays.length;
+}
+// src/render/grid.ts
+/** Rounds to a "nice" 1/2/5 × 10ⁿ step (CAD ruler convention) so cells never come out finer than the target and alias into a solid sheet. */
+function niceStep(value) {
+	if (!(value > 0) || !Number.isFinite(value)) return 1;
+	const power = Math.pow(10, Math.floor(Math.log10(value)));
+	const mantissa = value / power;
+	return (mantissa >= 5 ? 5 : mantissa >= 2 ? 2 : 1) * power;
+}
+const GRID_VERTEX = `
 	varying vec3 vWorldPos;
 	void main() {
 		vec4 world = modelMatrix * vec4(position, 1.0);
 		vWorldPos = world.xyz;
 		gl_Position = projectionMatrix * viewMatrix * world;
 	}
-`,fragmentShader:`
+`;
+const GRID_FRAGMENT = `
 	precision highp float;
 	varying vec3 vWorldPos;
 
@@ -50,13 +1656,1642 @@ import{a as e,c as t,d as n,f as r,g as i,h as a,l as o,m as s,p as c,r as l,s a
 		if (alpha < 0.001) discard;
 		gl_FragColor = vec4(color, alpha);
 	}
-`,transparent:!0,depthWrite:!1,side:v.DoubleSide,uniforms:{uAxes:{value:s},uCell:{value:t},uMajor:{value:n},uCellColor:{value:new v.Color(r)},uMajorColor:{value:new v.Color(i)},uCenter:{value:new v.Vector3},uFade:{value:a}}}),d=new v.Mesh(l,u);d.name=`grid`,d.userData.id=`grid`,d.renderOrder=-1;let f=a,p=a*c,m=new v.Vector3;return{object:d,update:e=>{o===`y`?(d.position.set(e.x,0,e.z),m.set(e.x,0,e.z)):o===`z`?(d.position.set(e.x,e.y,0),m.set(e.x,e.y,0)):(d.position.set(0,e.y,e.z),m.set(0,e.y,e.z)),u.uniforms.uCenter.value.copy(m),d.scale.setScalar(p)},fitToContent:e=>{if(e.isEmpty())return;let t=e.getSize(new v.Vector3),n=(e,t)=>t===0?e.x:t===1?e.y:e.z,r=Math.max(n(t,s.x),n(t,s.y));r>0&&Number.isFinite(r)&&(u.uniforms.uCell.value=rt(r/20),f=r*2,u.uniforms.uFade.value=f,p=f*c)},setVisible:e=>{d.visible=e},dispose:()=>{d.removeFromParent(),l.dispose(),u.dispose()}}}function at(e,t){let n=new E,r=n.domElement;r.style.position=`absolute`,r.style.top=`0`,r.style.left=`0`,r.style.overflow=`hidden`,r.style.pointerEvents=`none`,r.style.zIndex=`30`,getComputedStyle(e).position===`static`&&(e.style.position=`relative`),e.appendChild(r);let i={width:e.clientWidth||1,height:e.clientHeight||1};n.setSize(i.width,i.height);let a=new v.Group;a.name=`label-layer`,a.userData.id=`label-layer`,t.add(a);let o=new Set;return{addLabel:(e,t,n)=>{let r=document.createElement(`div`);r.textContent=e,n?r.className=n:Object.assign(r.style,{padding:`2px 6px`,borderRadius:`4px`,background:`rgba(20, 20, 20, 0.78)`,color:`#fff`,font:`12px/1.3 system-ui, sans-serif`,whiteSpace:`pre`,textAlign:`center`,userSelect:`none`}),r.style.pointerEvents=`none`;let i=new T(r);return i.position.copy(t),a.add(i),o.add(i),{object:i,setPosition:e=>i.position.copy(e),setText:e=>{r.textContent=e},remove:()=>{i.removeFromParent(),r.remove(),o.delete(i)}}},render:(e,t)=>n.render(e,t),setSize:(e,t)=>n.setSize(e,t),dispose:()=>{o.forEach(e=>{e.removeFromParent(),e.element.remove()}),o.clear(),a.removeFromParent(),r.remove()}}}const ot=.015,st={Millimeters:{metersPerUnit:1/1e3,suffix:`mm`},Centimeters:{metersPerUnit:1/100,suffix:`cm`},Meters:{metersPerUnit:1,suffix:`m`},Inches:{metersPerUnit:1/39.37,suffix:`in`},Feet:{metersPerUnit:1/3.28084,suffix:`ft`}};function ct(e){let t=e&&st[e]||st.Meters;return e=>`${(e/t.metersPerUnit).toPrecision(3)} ${t.suffix}`}function lt(e,t){if(e.isOrthographicCamera){let t=e;return Math.abs(t.top-t.bottom)/(t.zoom||1)*ot}return((t?e.position.distanceTo(t):e.position.length())||1)*ot}function ut(e){let t=e.object;if(t instanceof v.Mesh)return e.face?[e.face.a,e.face.b,e.face.c]:null;if(t instanceof v.Points)return e.index==null?null:[e.index];if(t instanceof v.Line){if(e.index==null)return null;let n=t.geometry.index;return n?e.index+1>=n.count?null:[n.getX(e.index),n.getX(e.index+1)]:[e.index,e.index+1]}return null}function dt(e,t,n,r){let i=e.point.clone(),a=e.object,o=ut(e);if(!o||!a.geometry)return i;let s=a.geometry.attributes.position;if(!s)return i;let c=e=>{let r=e.clone().project(t);return new v.Vector2((r.x+1)/2*n.width,(1-r.y)/2*n.height)},l=c(i),u=i,d=r;for(let e of o){if(e>=s.count)continue;let t=new v.Vector3().fromBufferAttribute(s,e).applyMatrix4(a.matrixWorld),n=c(t).distanceTo(l);n<d&&(d=n,u=t)}return u}function ft(e){let{canvas:t,scene:n,getActiveCamera:r,getViewTarget:i,labelLayer:a,options:o={}}=e,s=o.snapPixels??12,c=new v.Color(o.color??16763904),l=ct(o.displayUnit),u=o.format??((e,t)=>`${l(e)}\nΔx ${l(t.x)}  Δy ${l(t.y)}  Δz ${l(t.z)}`),d=new v.Raycaster,f=new v.Vector2,p=!1,m=[],h=[],g=null,_=null,S=new v.PointsMaterial({color:c,size:8,sizeAttenuation:!1,depthTest:!1}),C=new v.PointsMaterial({color:c,size:11,sizeAttenuation:!1,depthTest:!1,transparent:!0,opacity:.5}),w=null,T=e=>{if(!e){w&&(w.visible=!1);return}if(!w){let e=new v.BufferGeometry;e.setAttribute(`position`,new v.Float32BufferAttribute([0,0,0],3)),w=new v.Points(e,C),w.renderOrder=1e3,w.userData.id=`measure`,w.raycast=()=>{},n.add(w)}w.position.copy(e),w.visible=!0},E=e=>{let t=new v.BufferGeometry;t.setAttribute(`position`,new v.Float32BufferAttribute([e.x,e.y,e.z],3));let r=new v.Points(t,S);return r.renderOrder=999,r.userData.id=`measure`,r.raycast=()=>{},n.add(r),r},D=()=>{m.length=0,h.forEach(e=>{e.geometry.dispose(),e.removeFromParent()}),h.length=0,g&&=(g.geometry.dispose(),g.material.dispose(),g.removeFromParent(),null),_?.remove(),_=null},O=()=>{if(m.length!==2)return;let[e,t]=m,r=new b;r.setPositions([e.x,e.y,e.z,t.x,t.y,t.z]);let i=new x({color:c});i.linewidth=2,i.depthTest=!1,g=new y(r,i),g.renderOrder=998,g.userData.id=`measure`,g.raycast=()=>{},n.add(g);let s=e.clone().add(t).multiplyScalar(.5),l=new v.Vector3(Math.abs(t.x-e.x),Math.abs(t.y-e.y),Math.abs(t.z-e.z));_=a.addLabel(u(e.distanceTo(t),l),s,o.labelClassName)},k=e=>{let a=t.getBoundingClientRect();f.x=(e.clientX-a.left)/a.width*2-1,f.y=-((e.clientY-a.top)/a.height)*2+1;let o=r();d.setFromCamera(f,o);let c=lt(o,i?.());d.params.Line.threshold=c,d.params.Points.threshold=c;let l=d.intersectObjects(n.children,!0).filter(e=>e.object.userData.id!==`measure`&&e.object.userData.id!==`grid`);return l.length===0?null:dt(l[0],o,{width:a.width,height:a.height},s)},A=null,j=0,M=()=>{j&&=(cancelAnimationFrame(j),0),A=null};return{setEnabled:e=>{p=e,e||(M(),D(),T(null))},isEnabled:()=>p,handleClick:e=>{if(!p)return!1;m.length===2&&D();let t=k(e);return t===null||(m.push(t),h.push(E(t)),m.length===2&&O(),!0)},handleMove:e=>{p&&(A=e,!j&&(j=requestAnimationFrame(()=>{j=0;let e=A;A=null,p&&e&&T(k(e))})))},clear:D,dispose:()=>{M(),D(),w&&=(w.geometry.dispose(),w.removeFromParent(),null),S.dispose(),C.dispose()}}}const pt=[];function mt({camera:e,scene:t,groundNormals:n=()=>pt}){let r=e.near,i=e.near,a=ht();return{update:()=>{e.near!==i&&(r=e.near);let o=a.measure(t,e),s=r;if(o!==null){let t=o;for(let r of n())t=Math.min(t,Math.abs(e.position.dot(r)));s=v.MathUtils.clamp(t*.5,r,e.far*.01)}Math.abs(s-i)>i*.05&&(e.near=s,e.updateProjectionMatrix(),i=s)}}}function ht(){let e=new WeakMap,t=new v.Frustum,n=new v.Matrix4,r=new v.Vector3,i=new v.Box3,a=new Float64Array(20),o=new Float64Array(20),s=new Float32Array(6),c=new Float64Array(21),l=new Float64Array(21),u=1/0,d=!1,f=(t,n)=>{let r=n.getAttribute(`position`),i=n.getIndex(),a=e.get(n);if(a&&a.position===r&&a.positionVersion===_t(r)&&a.index===i&&a.indexVersion===(i?.version??-1))return a;let o={...yt(r,i,vt(t)),position:r,positionVersion:_t(r),index:i,indexVersion:i?.version??-1};return e.set(n,o),o},p=(e,t,n)=>{let{position:r,index:i}=e,a=i?.array,o=1/0;for(let i=e.ranges[t*2];i<e.ranges[t*2+1];i++){for(let e=0;e<3;e++){let t=a?a[i*3+e]:i*3+e;c[e*3]=r.getX(t),c[e*3+1]=r.getY(t),c[e*3+2]=r.getZ(t)}let e=3;for(let t=0;t<16&&e>0;t+=4){let r=n[t],i=n[t+1],a=n[t+2],o=n[t+3],s=0;for(let t=0;t<e;t++){let n=(t+1)%e,u=c[t*3],d=c[t*3+1],f=c[t*3+2],p=c[n*3],m=c[n*3+1],h=c[n*3+2],g=r*u+i*d+a*f+o,_=r*p+i*m+a*h+o;if(g>=0&&(l[s*3]=u,l[s*3+1]=d,l[s*3+2]=f,s++),g>=0!=_>=0){let e=g/(g-_);l[s*3]=u+(p-u)*e,l[s*3+1]=d+(m-d)*e,l[s*3+2]=f+(h-f)*e,s++}}[c,l]=[l,c],e=s}for(let t=0;t<e;t++){let e=n[16]*c[t*3]+n[17]*c[t*3+1]+n[18]*c[t*3+2]+n[19];e<o&&(o=e)}}return o},m=e=>{let t=e.elements;for(let e=0;e<20;e+=4){let n=a[e],r=a[e+1],i=a[e+2];o[e]=t[0]*n+t[1]*r+t[2]*i,o[e+1]=t[4]*n+t[5]*r+t[6]*i,o[e+2]=t[8]*n+t[9]*r+t[10]*i,o[e+3]=n*t[12]+r*t[13]+i*t[14]+a[e+3]}return o},h=(e,t,n)=>{outer:for(let r=0;r<e.length;r+=6){let i=e[r],a=e[r+1],o=e[r+2],s=e[r+3],c=e[r+4],l=e[r+5];for(let e=0;e<16;e+=4){let n=t[e],r=t[e+1],u=t[e+2];if(n*(n>0?s:i)+r*(r>0?c:a)+u*(u>0?l:o)+t[e+3]<0)continue outer}let d=t[16],f=t[17],m=t[18],h=d*(d>0?i:s)+f*(f>0?a:c)+m*(m>0?o:l)+t[19];h>=u||(u=n?Math.min(u,p(n,r/6,t)):h)}},g=e=>{let t=e.geometry;if(!t?.getAttribute?.(`position`))return;if(d=!0,gt(e)){let n=f(e,t);h(n.boxes,m(e.matrixWorld),n);return}let n=e;n.isInstancedMesh?(n.boundingBox||n.computeBoundingBox(),i.copy(n.boundingBox)):(t.boundingBox||t.computeBoundingBox(),i.copy(t.boundingBox)),!i.isEmpty()&&(s[0]=i.min.x,s[1]=i.min.y,s[2]=i.min.z,s[3]=i.max.x,s[4]=i.max.y,s[5]=i.max.z,h(s,m(e.matrixWorld)))},_=e=>{if(e.visible&&!pe(e)&&e.userData.kind!==`edge-overlay`){g(e);for(let t of e.children)_(t)}};return{measure:(e,i)=>{e.updateMatrixWorld(),i.updateMatrixWorld(),n.multiplyMatrices(i.projectionMatrix,i.matrixWorldInverse),t.setFromProjectionMatrix(n);for(let e=0;e<4;e++){let n=t.planes[e];a[e*4]=n.normal.x,a[e*4+1]=n.normal.y,a[e*4+2]=n.normal.z,a[e*4+3]=n.constant}i.getWorldDirection(r),a[16]=r.x,a[17]=r.y,a[18]=r.z,a[19]=-r.dot(i.position),u=1/0,d=!1;for(let t of e.children)_(t);return d?u:null}}}function gt(e){let t=e;if(!t.isMesh||t.isInstancedMesh||t.isSkinnedMesh)return!1;let n=t.geometry;return!n.isInstancedBufferGeometry&&Object.keys(n.morphAttributes).length===0}function _t(e){return e.isInterleavedBufferAttribute?e.data.version:e.version}function vt(e){let t=[];for(let n of X(e)??[])n.indexStart!==void 0&&t.push(n.indexStart/3);return t.sort((e,t)=>e-t)}function yt(e,t,n){let r=Math.floor((t?t.count:e.count)/3),i=[],a=0;for(let e=0;e<r;){for(;a<n.length&&n[a]<=e;)a++;let t=Math.min(r,e+256,n[a]??r);i.push(e,t),e=t}let o=i.length/2,s=new Float32Array(o*6),c=!e.isInterleavedBufferAttribute,l=e.array,u=c&&e.itemSize===3&&!e.normalized,d=t?.array;for(let t=0;t<o;t++){let n=1/0,r=1/0,a=1/0,o=-1/0,c=-1/0,f=-1/0,p=i[t*2+1]*3;for(let s=i[t*2]*3;s<p;s++){let t=d?d[s]:s,i=u?l[t*3]:e.getX(t),p=u?l[t*3+1]:e.getY(t),m=u?l[t*3+2]:e.getZ(t);i<n&&(n=i),p<r&&(r=p),m<a&&(a=m),i>o&&(o=i),p>c&&(c=p),m>f&&(f=m)}let m=t*6;s[m]=n,s[m+1]=r,s[m+2]=a,s[m+3]=o,s[m+4]=c,s[m+5]=f}return{boxes:s,ranges:Uint32Array.from(i)}}function bt(){let e=[],t=null,n=()=>e.sort((e,t)=>t.priority-e.priority),r=t=>e.findIndex(e=>e.id===t),i=n=>{let i=r(n);i!==-1&&(e.splice(i,1),t===n&&(t=null))};return{register:({id:t,tool:r,priority:a=0})=>(i(t),e.push({id:t,tool:r,priority:a}),n(),()=>i(t)),unregister:i,get:t=>e[r(t)]?.tool??null,setActive:n=>{t=n;for(let t of e)t.tool.setEnabled?.(t.id===n)},getActive:()=>t,handleClick:t=>{for(let n of[...e])if(n.tool.handleClick(t))return!0;return!1},handleMove:t=>{for(let n of[...e])n.tool.handleMove?.(t)}}}function xt(e,t){let n=t.getBoundingClientRect();return{x:(e.clientX-n.left)/n.width*2-1,y:-((e.clientY-n.top)/n.height)*2+1}}function St(e){let{camera:t,domElement:n,controller:r}=e,i=new D(t,n);i.setLabels(`X`,`Y`,`Z`);let a=!0,o=new v.Raycaster,s=new v.OrthographicCamera(-2,2,2,-2,0,4);s.position.set(0,0,2),s.updateMatrixWorld();let c={posX:new v.Vector3(1,0,0),negX:new v.Vector3(-1,0,0),posY:new v.Vector3(0,1,0),negY:new v.Vector3(0,-1,0),posZ:new v.Vector3(0,0,1),negZ:new v.Vector3(0,0,-1)},l=e=>{let r=n.getBoundingClientRect(),a=r.left+n.offsetWidth-128-i.location.right,l=r.top+n.offsetHeight-128-i.location.bottom,u=new v.Vector2((e.clientX-a)/128*2-1,-((e.clientY-l)/128)*2+1);if(Math.abs(u.x)>1||Math.abs(u.y)>1)return null;i.quaternion.copy(t.quaternion).invert(),i.updateMatrixWorld(),o.setFromCamera(u,s);let d=o.intersectObjects(i.children,!1);for(let e of d){let t=e.object.userData?.type;if(typeof t==`string`&&t in c)return t}return null};return{render:e=>{if(!a)return;let t=e.autoClear;e.autoClear=!1,i.render(e),e.autoClear=t},handleClick:e=>{if(!a)return!1;let t=l(e);return t?(r.getProjection()===`orthographic`&&r.setProjection(`perspective`),r.setViewDirection(c[t],!1),!0):!1},setVisible:e=>{a=e},isVisible:()=>a,dispose:()=>i.dispose()}}function Ct(e,t,n,r,i,a,o,s,c,l,u,d,f,p,m=!0){let h=null,g=performance.now(),_=!0,y=0,b=new v.Matrix4,x=new v.Matrix4,S=null,C=()=>{_=!0},w=e=>{e.updateMatrixWorld();let t=S!==e||!b.equals(e.matrixWorld)||!x.equals(e.projectionMatrix);return t&&(S=e,b.copy(e.matrixWorld),x.copy(e.projectionMatrix)),t},T=e.domElement,E=[`pointerdown`,`pointerup`,`wheel`];if(m)for(let e of E)T.addEventListener(e,C,{passive:!0});let D=()=>{let{width:t,height:r}=o();if(t===0||r===0)return;let a=Math.floor(t*s),c=Math.floor(r*s);(e.domElement.width!==a||e.domElement.height!==c)&&(e.setPixelRatio(s),e.setSize(t,r,!1),n.aspect=t/r,n.updateProjectionMatrix(),i.updateAspect(t,r),d?.()?.setSize(t,r,s),f?.setSize(t,r),C())},O=(n,r)=>{let i=d?.();i?(i.setCamera(n),i.render(r)):e.render(t,n),f&&f.render(t,n),u&&u.render(e)},k=()=>{O(r(),0)},A=function(){h=requestAnimationFrame(A);let e=performance.now(),t=(e-g)/1e3;g=e,D(),(a.enableDamping||a.autoRotate)&&a.update(),l&&l.update(r().position),p&&p.update(),c?.(t);let n=r();if(m){if(!(_||w(n)||e-y>=500))return;_=!1,y=e}O(n,t)};return{animate:A,dispose:()=>{if(h!==null&&(cancelAnimationFrame(h),h=null),m)for(let e of E)T.removeEventListener(e,C)},invalidate:C,renderNow:k}}const Q=new v.Vector3(0,0,1);function wt(e){let n=e.sceneScale||`m`,r={mm:{cameraDistance:20,near:.1,far:2e3,floorSize:100,lightDistance:10,lightHeight:20,minDistance:.1,shadowSize:100,scaleFactor:1e3},cm:{cameraDistance:20,near:.1,far:2e3,floorSize:100,lightDistance:25,lightHeight:50,minDistance:.1,shadowSize:100,scaleFactor:100},m:{cameraDistance:10,near:.01,far:2e3,floorSize:50,lightDistance:25,lightHeight:50,minDistance:.001,shadowSize:100,scaleFactor:1},inches:{cameraDistance:15,near:.1,far:2e3,floorSize:80,lightDistance:20,lightHeight:40,minDistance:.1,shadowSize:80,scaleFactor:39.37},feet:{cameraDistance:8,near:.1,far:2e3,floorSize:40,lightDistance:15,lightHeight:30,minDistance:.1,shadowSize:60,scaleFactor:3.28084}}[n],i=e.look??`technical`,a=t[i];return{sceneScale:n,look:i,camera:{position:e.camera?.position||se(e.environment?.sceneUp??Q,r.cameraDistance*Math.sqrt(3)),fov:e.camera?.fov||20,near:e.camera?.near||r.near,far:e.camera?.far||r.far,target:e.camera?.target||new v.Vector3(0,0,0),dynamicNear:e.camera?.dynamicNear??!0},lighting:{enableSunlight:e.lighting?.enableSunlight??!0,sunlightIntensity:e.lighting?.sunlightIntensity??a.sunlightIntensity,sunlightPosition:e.lighting?.sunlightPosition||ce(e.environment?.sceneUp??Q,r.lightDistance,r.lightHeight),ambientLightColor:e.lighting?.ambientLightColor||new v.Color(4210752),ambientLightIntensity:e.lighting?.ambientLightIntensity??a.ambientIntensity,sunlightColor:e.lighting?.sunlightColor||16777215,enableHemisphereLight:e.lighting?.enableHemisphereLight??a.hemisphereIntensity>0,hemisphereSkyColor:e.lighting?.hemisphereSkyColor??14673663,hemisphereGroundColor:e.lighting?.hemisphereGroundColor??7036754,hemisphereIntensity:e.lighting?.hemisphereIntensity??a.hemisphereIntensity},environment:{hdrPath:e.environment?.hdrPath||`/baseHDR.hdr`,backgroundColor:e.environment?.backgroundColor||new v.Color(15790320),enableEnvironmentLighting:e.environment?.enableEnvironmentLighting??!0,sceneUp:e.environment?.sceneUp||Q,showEnvironment:e.environment?.showEnvironment??!1,environmentIntensity:e.environment?.environmentIntensity??a.environmentIntensity},floor:{enabled:e.floor?.enabled??!1,size:e.floor?.size||r.floorSize,color:e.floor?.color||new v.Color(8421504),roughness:e.floor?.roughness??.7,metalness:e.floor?.metalness??0,receiveShadow:e.floor?.receiveShadow??!0},render:{enableShadows:e.render?.enableShadows??!0,shadowMapSize:e.render?.shadowMapSize||2048,antialias:e.render?.antialias??!0,pixelRatio:e.render?.pixelRatio||Math.min(window.devicePixelRatio,2),toneMapping:e.render?.toneMapping??a.toneMapping,toneMappingExposure:e.render?.toneMappingExposure??a.toneMappingExposure,preserveDrawingBuffer:e.render?.preserveDrawingBuffer??!1,ambientOcclusion:e.render?.ambientOcclusion??a.ambientOcclusion,aoIntensity:e.render?.aoIntensity??1,aoPixelRatio:e.render?.aoPixelRatio??1,onDemand:e.render?.onDemand??!0},controls:{enableDamping:e.controls?.enableDamping??!1,dampingFactor:e.controls?.dampingFactor||.05,autoRotate:e.controls?.autoRotate??!1,autoRotateSpeed:e.controls?.autoRotateSpeed||.5,enableZoom:e.controls?.enableZoom??!0,enablePan:e.controls?.enablePan??!0,minDistance:e.controls?.minDistance||r.minDistance,maxDistance:e.controls?.maxDistance||1/0},grid:{enabled:e.grid?.enabled??!1,cellSize:e.grid?.cellSize??1,majorEvery:e.grid?.majorEvery??10,cellColor:e.grid?.cellColor??8947848,majorColor:e.grid?.majorColor??4473924,fadeDistance:e.grid?.fadeDistance??100,plane:e.grid?.plane??ue(e.environment?.sceneUp??Q)},gizmo:{enabled:e.gizmo?.enabled??!1},edges:{enabled:e.edges?.enabled??!1,color:e.edges?.color,darken:e.edges?.darken,width:e.edges?.width??1.5,thresholdAngle:e.edges?.thresholdAngle??44,distanceFade:e.edges?.distanceFade??!0,maxTriangles:e.edges?.maxTriangles,maxSegments:e.edges?.maxSegments,maxOverlays:e.edges?.maxOverlays,screenSpaceFallback:e.edges?.screenSpaceFallback},measure:{enabled:e.measure?.enabled??!1,snapPixels:e.measure?.snapPixels,color:e.measure?.color,labelClassName:e.measure?.labelClassName,displayUnit:e.measure?.displayUnit,format:e.measure?.format},events:{onBackgroundClicked:e.events?.onBackgroundClicked,onObjectSelected:e.events?.onObjectSelected,onMeshMetadataClicked:e.events?.onMeshMetadataClicked,onMeshDoubleClicked:e.events?.onMeshDoubleClicked,selectionColor:e.events?.selectionColor||`#ff0000`,enableEventHandlers:e.events?.enableEventHandlers??!0,enableKeyboardControls:e.events?.enableKeyboardControls??!0,enableClickToFocus:e.events?.enableClickToFocus??!0,enableDoubleClickZoom:e.events?.enableDoubleClickZoom??!0,onReady:e.events?.onReady,onFrame:e.events?.onFrame},onMaxAnisotropy:e.onMaxAnisotropy}}const $=`__selvaLookBaseline`;function Tt(e,t){e.color?.setHex(t.color),e.metalness!==void 0&&(e.metalness=t.metalness),e.roughness!==void 0&&(e.roughness=t.roughness),e.opacity=t.opacity,e.transparent=t.transparent,e.depthWrite=t.depthWrite,e.wireframe!==void 0&&(e.wireframe=t.wireframe),e.side=t.side}function Et(e){let t=e[$];t&&(Tt(e,t),delete e[$])}function Dt(e,t){let n=e;if(!t){Et(n),n.needsUpdate=!0;return}n[$]?Tt(n,n[$]):n[$]={color:n.color?.getHex()??16777215,metalness:n.metalness??0,roughness:n.roughness??1,opacity:n.opacity,transparent:n.transparent,depthWrite:n.depthWrite,wireframe:n.wireframe??!1,side:n.side},t.color!==void 0&&n.color?.setHex(t.color),t.metalness!==void 0&&n.metalness!==void 0&&(n.metalness=t.metalness),t.roughness!==void 0&&n.roughness!==void 0&&(n.roughness=t.roughness),t.opacity!==void 0&&(n.opacity=t.opacity,n.transparent=t.opacity<1),t.depthWrite!==void 0&&(n.depthWrite=t.depthWrite),t.wireframe!==void 0&&n.wireframe!==void 0&&(n.wireframe=t.wireframe),t.side!==void 0&&(n.side=t.side),n.needsUpdate=!0}function Ot(e,t){if(t.materialOverride)return t.envMapIntensity;let n=e.userData[o];if(n!=null)return n;let r=e,i=r[$]?.metalness??r.metalness??0;return f(t.envMapIntensity,i)}function kt(e){let{scene:r,renderer:i,lights:a,config:o,pipeline:s,requestRender:c}=e,l=o.look,u=e=>{e.ambientIntensity!==void 0&&(a.ambient.intensity=e.ambientIntensity),e.hemisphereIntensity!==void 0&&!a.hemisphere&&e.hemisphereIntensity>0&&(a.hemisphere=new v.HemisphereLight(e.hemisphereSkyColor??o.lighting.hemisphereSkyColor,e.hemisphereGroundColor??o.lighting.hemisphereGroundColor,e.hemisphereIntensity),a.hemisphere.position.copy(o.environment.sceneUp??Q),r.add(a.hemisphere)),a.hemisphere&&(e.hemisphereIntensity!==void 0&&(a.hemisphere.intensity=e.hemisphereIntensity),e.hemisphereSkyColor!==void 0&&a.hemisphere.color.set(e.hemisphereSkyColor),e.hemisphereGroundColor!==void 0&&a.hemisphere.groundColor.set(e.hemisphereGroundColor)),c()},d=e=>{o.environment.environmentIntensity=e,r.environmentIntensity=e,c()};return{setFillLights:u,setEnvironmentIntensity:d,setToneMappingExposure:e=>{o.render.toneMappingExposure=e,i.toneMappingExposure=e,s.get()&&s.rebuild()},setAoIntensity:e=>{o.render.aoIntensity=e,s.get()&&s.rebuild()},setLook:e=>{let n=t[e];l=e,i.toneMapping=n.toneMapping,i.toneMappingExposure=n.toneMappingExposure,o.render.toneMapping=n.toneMapping,o.render.toneMappingExposure=n.toneMappingExposure,u({hemisphereIntensity:n.hemisphereIntensity,ambientIntensity:n.ambientIntensity}),d(n.environmentIntensity),a.sun&&(a.sun.intensity=n.sunlightIntensity,o.lighting.sunlightIntensity=n.sunlightIntensity);let f=s.get()!==null;s.setAmbientOcclusion(n.ambientOcclusion),f&&s.rebuild(),r.traverse(e=>{if(e.userData.source!==`compute`)return;let t=e,r=Array.isArray(t.material)?t.material:t.material?[t.material]:[];for(let e of r)`envMapIntensity`in e&&(e.envMapIntensity=Ot(e,n)),Dt(e,n.materialOverride)}),H(r,r),c()},getMaterialAppearance:()=>n(l)}}function At(e,t){let n=t.parentElement,r=n?n.clientWidth:window.innerWidth,i=n?n.clientHeight:window.innerHeight,a=new v.PerspectiveCamera(e.camera.fov,r/i,e.camera.near,e.camera.far),o=e.camera.position;return o&&a.position.set(o.x,o.y,o.z),a}function jt(e){let t=new v.Scene;return t.background=(typeof e.environment.backgroundColor==`string`?new v.Color(e.environment.backgroundColor):e.environment.backgroundColor)||null,t}function Mt(e,t){d(e,t),e.environment?.dispose(),oe(e),e.background instanceof v.Texture&&e.background.dispose()}const Nt={uniforms:{tDiffuse:{value:null},tNormal:{value:null},tDepth:{value:null},uResolution:{value:new v.Vector2(1,1)},uColor:{value:new v.Color(2236962)},uOpacity:{value:1},uNormalThreshold:{value:.4},uDepthThreshold:{value:.02},uThickness:{value:1},uNear:{value:.1},uFar:{value:1e3},uPerspective:{value:1}},vertexShader:`
+`;
+function createGrid(options = {}) {
+	const { cellSize = 1, majorEvery = 10, cellColor = 8947848, majorColor = 4473924, fadeDistance = 100, plane = "y" } = options;
+	const axes = plane === "y" ? new THREE.Vector2(0, 2) : plane === "z" ? new THREE.Vector2(0, 1) : new THREE.Vector2(1, 2);
+	const PLANE_TO_FADE_RATIO = 2.5;
+	const geometry = new THREE.PlaneGeometry(1, 1);
+	if (plane === "y") geometry.rotateX(-Math.PI / 2);
+	else if (plane === "x") geometry.rotateY(Math.PI / 2);
+	const material = new THREE.ShaderMaterial({
+		vertexShader: GRID_VERTEX,
+		fragmentShader: GRID_FRAGMENT,
+		transparent: true,
+		depthWrite: false,
+		side: THREE.DoubleSide,
+		uniforms: {
+			uAxes: { value: axes },
+			uCell: { value: cellSize },
+			uMajor: { value: majorEvery },
+			uCellColor: { value: new THREE.Color(cellColor) },
+			uMajorColor: { value: new THREE.Color(majorColor) },
+			uCenter: { value: new THREE.Vector3() },
+			uFade: { value: fadeDistance }
+		}
+	});
+	const mesh = new THREE.Mesh(geometry, material);
+	mesh.name = "grid";
+	mesh.userData.id = "grid";
+	mesh.renderOrder = -1;
+	let fadeRadius = fadeDistance;
+	let planeScale = fadeDistance * PLANE_TO_FADE_RATIO;
+	const center = new THREE.Vector3();
+	return {
+		object: mesh,
+		update: (cameraPosition) => {
+			if (plane === "y") {
+				mesh.position.set(cameraPosition.x, 0, cameraPosition.z);
+				center.set(cameraPosition.x, 0, cameraPosition.z);
+			} else if (plane === "z") {
+				mesh.position.set(cameraPosition.x, cameraPosition.y, 0);
+				center.set(cameraPosition.x, cameraPosition.y, 0);
+			} else {
+				mesh.position.set(0, cameraPosition.y, cameraPosition.z);
+				center.set(0, cameraPosition.y, cameraPosition.z);
+			}
+			material.uniforms.uCenter.value.copy(center);
+			mesh.scale.setScalar(planeScale);
+		},
+		fitToContent: (bounds) => {
+			if (bounds.isEmpty()) return;
+			const sizeVec = bounds.getSize(new THREE.Vector3());
+			const axisComponent = (v, i) => i === 0 ? v.x : i === 1 ? v.y : v.z;
+			const inPlaneExtent = Math.max(axisComponent(sizeVec, axes.x), axisComponent(sizeVec, axes.y));
+			if (!(inPlaneExtent > 0) || !Number.isFinite(inPlaneExtent)) return;
+			const TARGET_CELLS_ACROSS = 20;
+			material.uniforms.uCell.value = niceStep(inPlaneExtent / TARGET_CELLS_ACROSS);
+			fadeRadius = inPlaneExtent * 2;
+			material.uniforms.uFade.value = fadeRadius;
+			planeScale = fadeRadius * PLANE_TO_FADE_RATIO;
+		},
+		setVisible: (visible) => {
+			mesh.visible = visible;
+		},
+		dispose: () => {
+			mesh.removeFromParent();
+			geometry.dispose();
+			material.dispose();
+		}
+	};
+}
+// src/render/label-layer.ts
+function createLabelLayer(container, scene) {
+	const renderer = new CSS2DRenderer();
+	const dom = renderer.domElement;
+	dom.style.position = "absolute";
+	dom.style.top = "0";
+	dom.style.left = "0";
+	dom.style.overflow = "hidden";
+	dom.style.pointerEvents = "none";
+	dom.style.zIndex = "30";
+	if (getComputedStyle(container).position === "static") container.style.position = "relative";
+	container.appendChild(dom);
+	const size = {
+		width: container.clientWidth || 1,
+		height: container.clientHeight || 1
+	};
+	renderer.setSize(size.width, size.height);
+	const group = new THREE.Group();
+	group.name = "label-layer";
+	group.userData.id = "label-layer";
+	scene.add(group);
+	const labels = /* @__PURE__ */ new Set();
+	const addLabel = (text, position, className) => {
+		const el = document.createElement("div");
+		el.textContent = text;
+		if (className) el.className = className;
+		else Object.assign(el.style, {
+			padding: "2px 6px",
+			borderRadius: "4px",
+			background: "rgba(20, 20, 20, 0.78)",
+			color: "#fff",
+			font: "12px/1.3 system-ui, sans-serif",
+			whiteSpace: "pre",
+			textAlign: "center",
+			userSelect: "none"
+		});
+		el.style.pointerEvents = "none";
+		const object = new CSS2DObject(el);
+		object.position.copy(position);
+		group.add(object);
+		labels.add(object);
+		return {
+			object,
+			setPosition: (p) => object.position.copy(p),
+			setText: (t) => {
+				el.textContent = t;
+			},
+			remove: () => {
+				object.removeFromParent();
+				el.remove();
+				labels.delete(object);
+			}
+		};
+	};
+	return {
+		addLabel,
+		render: (scene, camera) => renderer.render(scene, camera),
+		setSize: (width, height) => renderer.setSize(width, height),
+		dispose: () => {
+			labels.forEach((object) => {
+				object.removeFromParent();
+				object.element.remove();
+			});
+			labels.clear();
+			group.removeFromParent();
+			dom.remove();
+		}
+	};
+}
+// src/render/scene-pick.ts
+const bvhCache = /* @__PURE__ */ new WeakMap();
+function versionOf$1(attribute) {
+	return attribute?.version ?? 0;
+}
+/** BVH for a mesh geometry, building it on first use. Null when the geometry can't take one. */
+function bvhFor(geometry) {
+	const position = geometry.attributes.position;
+	if (!position || position.count === 0) return null;
+	const index = geometry.index;
+	const key = index ?? position;
+	const cached = bvhCache.get(key);
+	if (cached === null) return null;
+	if (cached && cached.position === position && cached.positionVersion === versionOf$1(position) && cached.indexVersion === versionOf$1(index)) return cached.bvh;
+	const proxy = new THREE.BufferGeometry();
+	proxy.setAttribute("position", position);
+	if (index) proxy.setIndex(index);
+	try {
+		const bvh = new MeshBVH(proxy, { indirect: true });
+		bvhCache.set(key, {
+			position,
+			positionVersion: versionOf$1(position),
+			indexVersion: versionOf$1(index),
+			bvh
+		});
+		return bvh;
+	} catch {
+		bvhCache.set(key, null);
+		return null;
+	}
+}
+function isBvhMesh(object) {
+	const o = object;
+	return o.isMesh === true && !o.isInstancedMesh && !o.isSkinnedMesh && !o.isBatchedMesh && !o.isLineSegments2 && !object.morphTargetInfluences?.length;
+}
+/**
+* Visible, pickable objects under `root`: hidden subtrees, viewer aids and edge overlays are
+* skipped. Overlays are skipped because they double the mesh's own edges and, as fat lines, cost a
+* linear scan of every segment per ray.
+*/
+function collectPickable(root, out = []) {
+	for (const child of root.children) {
+		if (!child.visible || isViewerAidRoot(child) || isEdgeOverlay(child)) continue;
+		out.push(child);
+		collectPickable(child, out);
+	}
+	return out;
+}
+/**
+* Index-buffer ranges a merged mesh currently draws, or null when it draws everything. Hidden
+* members are the gaps between groups (`shared/merged-draw.ts`).
+*/
+function drawnRanges(mesh) {
+	const { groups } = mesh.geometry;
+	if (!Array.isArray(mesh.material) || groups.length === 0) return null;
+	const materials = mesh.material;
+	return groups.filter((g) => materials[g.materialIndex ?? 0]?.visible !== false).map((g) => ({
+		start: g.start,
+		end: g.start + g.count
+	}));
+}
+const _inverse = new THREE.Matrix4();
+const _localRay = new THREE.Ray();
+const _sphere = new THREE.Sphere();
+function raycastMeshBvh(mesh, bvh, raycaster) {
+	_inverse.copy(mesh.matrixWorld).invert();
+	_localRay.copy(raycaster.ray).applyMatrix4(_inverse);
+	const ranges = drawnRanges(mesh);
+	let best = null;
+	if (!ranges) best = bvh.raycastFirst(_localRay, THREE.DoubleSide);
+	else for (const hit of bvh.raycast(_localRay, THREE.DoubleSide)) {
+		const at = (hit.faceIndex ?? 0) * 3;
+		if (!ranges.some((r) => at >= r.start && at < r.end)) continue;
+		if (!best || hit.distance < best.distance) best = hit;
+	}
+	if (!best) return null;
+	best.point.applyMatrix4(mesh.matrixWorld);
+	best.distance = best.point.distanceTo(raycaster.ray.origin);
+	best.object = mesh;
+	if (best.distance < raycaster.near || best.distance > raycaster.far) return null;
+	return best;
+}
+/**
+* Every hit along `raycaster`'s ray over the visible content of `scene`, nearest first. Meshes use
+* the BVH; lines, points and instanced meshes fall back to their own `raycast`.
+*/
+function raycastVisible(scene, raycaster) {
+	const hits = [];
+	for (const object of collectPickable(scene)) {
+		if (!object.layers.test(raycaster.layers)) continue;
+		if (isBvhMesh(object)) {
+			const { geometry } = object;
+			if (!geometry.boundingSphere) geometry.computeBoundingSphere();
+			if (!geometry.boundingSphere) continue;
+			_sphere.copy(geometry.boundingSphere).applyMatrix4(object.matrixWorld);
+			if (!raycaster.ray.intersectsSphere(_sphere)) continue;
+			const bvh = bvhFor(geometry);
+			if (bvh) {
+				const hit = raycastMeshBvh(object, bvh, raycaster);
+				if (hit) hits.push(hit);
+				continue;
+			}
+		}
+		object.raycast(raycaster, hits);
+	}
+	return hits.sort((a, b) => a.distance - b.distance);
+}
+/**
+* Builds BVHs for the visible meshes under `root` one per idle slice, so the first hover over a
+* large model doesn't pay for all of them at once. Returns a cancel function.
+*/
+function warmPickIndex(root) {
+	const queue = collectPickable(root).filter(isBvhMesh);
+	const idle = typeof requestIdleCallback === "function" ? (fn) => requestIdleCallback(fn, { timeout: 500 }) : (fn) => setTimeout(fn, 16);
+	const cancelIdle = typeof cancelIdleCallback === "function" ? cancelIdleCallback : (id) => clearTimeout(id);
+	let handle = 0;
+	let cancelled = false;
+	const step = () => {
+		if (cancelled) return;
+		const mesh = queue.shift();
+		if (!mesh) return;
+		bvhFor(mesh.geometry);
+		handle = idle(step);
+	};
+	handle = idle(step);
+	return () => {
+		cancelled = true;
+		cancelIdle(handle);
+	};
+}
+// src/render/measure.ts
+const DEFAULT_SNAP_PIXELS = 12;
+const DEFAULT_COLOR = 16763904;
+const LINE_PICK_FRACTION = .015;
+const RENDER_ORDER_LINE = 998;
+const RENDER_ORDER_MARKER = 999;
+const RENDER_ORDER_HOVER = 1e3;
+const UNIT_DISPLAY = {
+	Millimeters: {
+		metersPerUnit: 1 / 1e3,
+		suffix: "mm"
+	},
+	Centimeters: {
+		metersPerUnit: 1 / 100,
+		suffix: "cm"
+	},
+	Meters: {
+		metersPerUnit: 1,
+		suffix: "m"
+	},
+	Inches: {
+		metersPerUnit: 1 / 39.37,
+		suffix: "in"
+	},
+	Feet: {
+		metersPerUnit: 1 / 3.28084,
+		suffix: "ft"
+	}
+};
+/**
+* Three significant figures below 1000, whole units above. `toPrecision(3)` alone switches to
+* exponent notation past 999 ("1.23e+4 mm"), which is unreadable on a building-scale model.
+*
+* @internal exported for tests
+*/
+function makeFormatter(displayUnit) {
+	const unit = displayUnit && UNIT_DISPLAY[displayUnit] || UNIT_DISPLAY.Meters;
+	return (meters) => {
+		const value = meters / unit.metersPerUnit;
+		const abs = Math.abs(value);
+		const decimals = abs === 0 ? 0 : Math.min(6, Math.max(0, 2 - Math.floor(Math.log10(abs))));
+		return `${value.toFixed(decimals)} ${unit.suffix}`;
+	};
+}
+/** @internal exported for tests */
+function makeDefaultFormat(fmt) {
+	return (distance, delta) => {
+		const eps = distance * 1e-6;
+		const axes = [
+			"x",
+			"y",
+			"z"
+		].filter((axis) => delta[axis] > eps);
+		if (axes.length < 2) return fmt(distance);
+		return `${fmt(distance)}\n${axes.map((axis) => `Δ${axis} ${fmt(delta[axis])}`).join("  ")}`;
+	};
+}
+/**
+* Raycast threshold for picking lines/points, as a fixed fraction of view size so the grab band
+* stays constant on screen while zooming. Perspective uses camera→target distance (see
+* `MeasureDeps.getViewTarget`); orthographic uses frustum height `(top − bottom) / zoom`, since
+* ortho zoom changes `camera.zoom` rather than position.
+*
+* Shared with any tool doing its own picking, so grab bands stay consistent across tools.
+*/
+function pickThreshold(camera, viewTarget) {
+	if (camera.isOrthographicCamera) {
+		const ortho = camera;
+		return Math.abs(ortho.top - ortho.bottom) / (ortho.zoom || 1) * LINE_PICK_FRACTION;
+	}
+	return ((viewTarget ? camera.position.distanceTo(viewTarget) : camera.position.length()) || 1) * LINE_PICK_FRACTION;
+}
+/**
+* Local-space vertices to consider snapping to, by object type: Mesh → struck triangle's 3
+* vertices; Line/LineSegments and fat Line2/LineSegments2 → struck segment's 2 endpoints; Points →
+* the struck vertex. Null when the hit carries no usable index, so the caller keeps the raw point.
+*/
+function snapCandidates(hit) {
+	const obj = hit.object;
+	const geometry = obj.geometry;
+	if (!geometry) return null;
+	if (obj.isLineSegments2) {
+		const start = geometry.attributes.instanceStart;
+		const end = geometry.attributes.instanceEnd;
+		const i = hit.faceIndex;
+		if (!start || !end || i == null || i >= start.count) return null;
+		return [new THREE.Vector3().fromBufferAttribute(start, i), new THREE.Vector3().fromBufferAttribute(end, i)];
+	}
+	const pos = geometry.attributes.position;
+	if (!pos) return null;
+	const at = (indices) => indices.filter((i) => i < pos.count).map((i) => new THREE.Vector3().fromBufferAttribute(pos, i));
+	if (obj instanceof THREE.Mesh) return hit.face ? at([
+		hit.face.a,
+		hit.face.b,
+		hit.face.c
+	]) : null;
+	if (obj instanceof THREE.Points) return hit.index != null ? at([hit.index]) : null;
+	if (obj instanceof THREE.Line) {
+		if (hit.index == null) return null;
+		const index = geometry.index;
+		if (index) {
+			if (hit.index + 1 >= index.count) return null;
+			return at([index.getX(hit.index), index.getX(hit.index + 1)]);
+		}
+		return at([hit.index, hit.index + 1]);
+	}
+	return null;
+}
+function toScreen(world, camera, screenSize) {
+	const ndc = world.clone().project(camera);
+	return new THREE.Vector2((ndc.x + 1) / 2 * screenSize.width, (1 - ndc.y) / 2 * screenSize.height);
+}
+/** Where a hit sits on screen: fat lines report the nearest point on the line separately. */
+function hitPoint(hit) {
+	return hit.pointOnLine ?? hit.point;
+}
+function snapHit(hit, camera, screenSize, snapPixels) {
+	const raw = hitPoint(hit).clone();
+	const candidates = snapCandidates(hit);
+	if (!candidates) return {
+		point: raw,
+		snapped: false
+	};
+	const rawScreen = toScreen(raw, camera, screenSize);
+	let best = {
+		point: raw,
+		snapped: false
+	};
+	let bestPx = snapPixels;
+	for (const local of candidates) {
+		const world = local.applyMatrix4(hit.object.matrixWorld);
+		const px = toScreen(world, camera, screenSize).distanceTo(rawScreen);
+		if (px < bestPx) {
+			bestPx = px;
+			best = {
+				point: world,
+				snapped: true
+			};
+		}
+	}
+	return best;
+}
+/** Snap a raycast hit to the nearest geometry vertex within `snapPixels` on screen, else the raw hit point. */
+function snapToVertex(hit, camera, screenSize, snapPixels) {
+	return snapHit(hit, camera, screenSize, snapPixels).point;
+}
+function createMeasureTool(deps) {
+	const { canvas, scene, getActiveCamera, getViewTarget, labelLayer, options = {} } = deps;
+	const requestRender = deps.requestRender ?? (() => {});
+	const snapPixels = options.snapPixels ?? DEFAULT_SNAP_PIXELS;
+	const color = new THREE.Color(options.color ?? DEFAULT_COLOR);
+	const format = options.format ?? makeDefaultFormat(makeFormatter(options.displayUnit));
+	const raycaster = new THREE.Raycaster();
+	const pointer = new THREE.Vector2();
+	let enabled = false;
+	let start = null;
+	const measurements = [];
+	const markerMaterial = new THREE.PointsMaterial({
+		color,
+		size: 8,
+		sizeAttenuation: false,
+		depthTest: false
+	});
+	const hoverSnappedMaterial = new THREE.PointsMaterial({
+		color,
+		size: 12,
+		sizeAttenuation: false,
+		depthTest: false
+	});
+	const hoverFreeMaterial = new THREE.PointsMaterial({
+		color,
+		size: 7,
+		sizeAttenuation: false,
+		depthTest: false,
+		transparent: true,
+		opacity: .6
+	});
+	const tag = (object, renderOrder) => {
+		object.renderOrder = renderOrder;
+		object.userData.id = "measure";
+		object.raycast = () => {};
+		object.frustumCulled = false;
+		return object;
+	};
+	const makePoints = (...ps) => {
+		const geometry = new THREE.BufferGeometry();
+		geometry.setAttribute("position", new THREE.Float32BufferAttribute(ps.flatMap((p) => [
+			p.x,
+			p.y,
+			p.z
+		]), 3));
+		const points = tag(new THREE.Points(geometry, markerMaterial), RENDER_ORDER_MARKER);
+		scene.add(points);
+		return points;
+	};
+	const makeLine = (a, b, opacity = 1) => {
+		const geometry = new LineGeometry();
+		geometry.setPositions([
+			a.x,
+			a.y,
+			a.z,
+			b.x,
+			b.y,
+			b.z
+		]);
+		const material = new LineMaterial({
+			color,
+			transparent: opacity < 1,
+			opacity
+		});
+		material.linewidth = 2;
+		material.depthTest = false;
+		const line = tag(new Line2(geometry, material), RENDER_ORDER_LINE);
+		scene.add(line);
+		return line;
+	};
+	const moveLine = (line, a, b) => {
+		const buffer = line.geometry.attributes.instanceStart.data;
+		buffer.array.set([
+			a.x,
+			a.y,
+			a.z,
+			b.x,
+			b.y,
+			b.z
+		]);
+		buffer.needsUpdate = true;
+	};
+	const disposeLine = (line) => {
+		line.geometry.dispose();
+		line.material.dispose();
+		line.removeFromParent();
+	};
+	const disposePoints = (points) => {
+		points.geometry.dispose();
+		points.removeFromParent();
+	};
+	const labelText = (a, b) => {
+		const delta = new THREE.Vector3(Math.abs(b.x - a.x), Math.abs(b.y - a.y), Math.abs(b.z - a.z));
+		return format(a.distanceTo(b), delta);
+	};
+	const midpoint = (a, b) => a.clone().add(b).multiplyScalar(.5);
+	let hoverMarker = null;
+	let rubberBand = null;
+	let rubberLabel = null;
+	const hidePreview = () => {
+		if (hoverMarker) hoverMarker.visible = false;
+		if (rubberBand) rubberBand.visible = false;
+		rubberLabel?.remove();
+		rubberLabel = null;
+	};
+	const showPreview = (snap) => {
+		if (!snap) {
+			hidePreview();
+			return;
+		}
+		if (!hoverMarker) {
+			hoverMarker = makePoints(new THREE.Vector3());
+			hoverMarker.renderOrder = RENDER_ORDER_HOVER;
+		}
+		hoverMarker.material = snap.snapped ? hoverSnappedMaterial : hoverFreeMaterial;
+		hoverMarker.position.copy(snap.point);
+		hoverMarker.visible = true;
+		if (!start) {
+			if (rubberBand) rubberBand.visible = false;
+			rubberLabel?.remove();
+			rubberLabel = null;
+			return;
+		}
+		if (!rubberBand) rubberBand = makeLine(start.point, snap.point, .7);
+		moveLine(rubberBand, start.point, snap.point);
+		rubberBand.visible = true;
+		const text = labelText(start.point, snap.point);
+		const mid = midpoint(start.point, snap.point);
+		if (rubberLabel) {
+			rubberLabel.setText(text);
+			rubberLabel.setPosition(mid);
+		} else rubberLabel = labelLayer.addLabel(text, mid, options.labelClassName);
+	};
+	const pick = (event) => {
+		const rect = canvas.getBoundingClientRect();
+		const cursorX = event.clientX - rect.left;
+		const cursorY = event.clientY - rect.top;
+		pointer.x = cursorX / rect.width * 2 - 1;
+		pointer.y = -(cursorY / rect.height) * 2 + 1;
+		const camera = getActiveCamera();
+		raycaster.setFromCamera(pointer, camera);
+		const threshold = pickThreshold(camera, getViewTarget?.()) * 2;
+		raycaster.params.Line.threshold = threshold;
+		raycaster.params.Points.threshold = threshold;
+		raycaster.params.Line2 = { threshold: snapPixels / 2 };
+		const screen = {
+			width: rect.width,
+			height: rect.height
+		};
+		const cursor = new THREE.Vector2(cursorX, cursorY);
+		for (const hit of raycastVisible(scene, raycaster)) {
+			if (!(hit.object.isMesh && hit.face != null) && toScreen(hitPoint(hit), camera, screen).distanceTo(cursor) > snapPixels) continue;
+			return snapHit(hit, camera, screen, snapPixels);
+		}
+		return null;
+	};
+	let pendingMove = null;
+	let moveRaf = 0;
+	const cancelPendingMove = () => {
+		if (moveRaf) {
+			cancelAnimationFrame(moveRaf);
+			moveRaf = 0;
+		}
+		pendingMove = null;
+	};
+	const handleMove = (event) => {
+		if (!enabled) return;
+		pendingMove = event;
+		if (moveRaf) return;
+		moveRaf = requestAnimationFrame(() => {
+			moveRaf = 0;
+			const latest = pendingMove;
+			pendingMove = null;
+			if (!enabled || !latest) return;
+			showPreview(pick(latest));
+			requestRender();
+		});
+	};
+	const handleLeave = () => {
+		cancelPendingMove();
+		hidePreview();
+		requestRender();
+	};
+	const dropStart = () => {
+		if (!start) return;
+		disposePoints(start.marker);
+		start = null;
+	};
+	const clear = () => {
+		dropStart();
+		for (const m of measurements) {
+			disposePoints(m.markers);
+			disposeLine(m.line);
+			m.label.remove();
+		}
+		measurements.length = 0;
+		hidePreview();
+		requestRender();
+	};
+	const cancel = () => {
+		if (start) {
+			dropStart();
+			hidePreview();
+			requestRender();
+		} else clear();
+	};
+	const handleClick = (event) => {
+		if (!enabled) return false;
+		cancelPendingMove();
+		const snap = pick(event);
+		if (!snap) return true;
+		if (!start) start = {
+			point: snap.point,
+			marker: makePoints(snap.point)
+		};
+		else if (!snap.point.equals(start.point)) {
+			const a = start.point;
+			const b = snap.point;
+			dropStart();
+			measurements.push({
+				markers: makePoints(a, b),
+				line: makeLine(a, b),
+				label: labelLayer.addLabel(labelText(a, b), midpoint(a, b), options.labelClassName)
+			});
+		}
+		showPreview(snap);
+		requestRender();
+		return true;
+	};
+	const handleKey = (event) => {
+		if (event.key !== "Escape") return;
+		if (event.target?.closest?.("input, textarea, select, [contenteditable]")) return;
+		cancel();
+	};
+	let previousCursor = "";
+	let cancelWarm = null;
+	const setEnabled = (value) => {
+		if (value === enabled) return;
+		enabled = value;
+		if (value) {
+			previousCursor = canvas.style.cursor;
+			canvas.style.cursor = "crosshair";
+			canvas.addEventListener("mouseleave", handleLeave);
+			window.addEventListener("keydown", handleKey);
+			cancelWarm = warmPickIndex(scene);
+		} else {
+			canvas.style.cursor = previousCursor;
+			canvas.removeEventListener("mouseleave", handleLeave);
+			window.removeEventListener("keydown", handleKey);
+			cancelWarm?.();
+			cancelWarm = null;
+			cancelPendingMove();
+			clear();
+		}
+	};
+	return {
+		setEnabled,
+		isEnabled: () => enabled,
+		handleClick,
+		handleMove,
+		cancel,
+		clear,
+		dispose: () => {
+			setEnabled(false);
+			clear();
+			if (hoverMarker) disposePoints(hoverMarker);
+			if (rubberBand) disposeLine(rubberBand);
+			hoverMarker = null;
+			rubberBand = null;
+			markerMaterial.dispose();
+			hoverSnappedMaterial.dispose();
+			hoverFreeMaterial.dispose();
+		}
+	};
+}
+// src/render/near-plane.ts
+/**
+* Depth-buffer precision is ∝ near/z²: at the 0.01 m floor a 24-bit buffer resolves ~0.15 mm at
+* 5 m and ~0.25 m at 200 m, so a sheet's two faces fight up close and coplanar surfaces fight far
+* away. Pushing `near` up to a fraction of the view depth of the nearest geometry in view recovers
+* that precision without clipping anything.
+*
+* The nearest geometry is measured on per-chunk triangle bounds, not the scene's bounding sphere:
+* zoomed in on a detail, the camera sits inside the whole model's sphere, which pinned near to the
+* floor exactly when precision mattered most. Chunks outside the frustum's side planes are skipped,
+* since geometry nobody sees can't be clipped.
+*
+* `far` stays owned by config/`updateScene` (must keep covering grid fade, floor). External writes
+* to `camera.near` are adopted as the new lower bound rather than fought — the fitter only ever
+* *raises* near above that floor.
+*
+* Ortho camera needs no fitting (linear depth) and is left untouched.
+*/
+/** Safety margin: a host's `onFrame` can still move the camera after the fit. */
+const NEAR_GAP_FRACTION = .5;
+/** Caps near so the frustum stays sane if the camera flies out. */
+const MAX_NEAR_TO_FAR = .01;
+/** Skip sub-5% changes so the projection matrix isn't rebuilt every frame while orbiting. */
+const APPLY_THRESHOLD = .05;
+/**
+* Triangles per bounding box. Smaller fits tighter up close but costs more box tests per frame:
+* at 256, a 2M-triangle model is ~8k tests, well under a millisecond.
+*/
+const TRIANGLES_PER_CHUNK = 256;
+const NO_GROUND_NORMALS = [];
+function createNearPlaneFitter({ camera, scene, groundNormals = () => NO_GROUND_NORMALS }) {
+	let baseNear = camera.near;
+	let appliedNear = camera.near;
+	const nearest = createNearestDepthQuery();
+	const update = () => {
+		if (camera.near !== appliedNear) baseNear = camera.near;
+		const depth = nearest.measure(scene, camera);
+		let near = baseNear;
+		if (depth !== null) {
+			let gap = depth;
+			for (const normal of groundNormals()) gap = Math.min(gap, Math.abs(camera.position.dot(normal)));
+			near = THREE.MathUtils.clamp(gap * NEAR_GAP_FRACTION, baseNear, camera.far * MAX_NEAR_TO_FAR);
+		}
+		if (Math.abs(near - appliedNear) > appliedNear * APPLY_THRESHOLD) {
+			camera.near = near;
+			camera.updateProjectionMatrix();
+			appliedNear = near;
+		}
+	};
+	return { update };
+}
+/**
+* Smallest view depth (distance along the camera's forward axis) of any content inside the
+* frustum's side planes: `null` when the scene has no content, `Infinity` when none of it is in
+* view.
+*
+* A chunk's box only bounds that depth from below, and loosely: a big box reaches beside and behind
+* the camera even when its triangles are all well ahead. One 60-triangle wall around a building is
+* one box the size of the building, which used to pin near to the floor from anywhere in it. So a
+* box that could still be the nearest has its triangles clipped to the frustum and measured
+* exactly; boxes already further than the best so far are skipped.
+*/
+function createNearestDepthQuery() {
+	const chunkCache = /* @__PURE__ */ new WeakMap();
+	const frustum = new THREE.Frustum();
+	const viewProjection = new THREE.Matrix4();
+	const forward = new THREE.Vector3();
+	const box = new THREE.Box3();
+	const worldPlanes = /* @__PURE__ */ new Float64Array(20);
+	const localPlanes = /* @__PURE__ */ new Float64Array(20);
+	const singleBox = /* @__PURE__ */ new Float32Array(6);
+	let polygon = /* @__PURE__ */ new Float64Array(21);
+	let clipped = /* @__PURE__ */ new Float64Array(21);
+	let nearest = Infinity;
+	let sawContent = false;
+	const chunksOf = (object, geometry) => {
+		const position = geometry.getAttribute("position");
+		const index = geometry.getIndex();
+		const cached = chunkCache.get(geometry);
+		if (cached && cached.position === position && cached.positionVersion === versionOf(position) && cached.index === index && cached.indexVersion === (index?.version ?? -1)) return cached;
+		const built = {
+			...buildChunkBoxes(position, index, memberStarts(object)),
+			position,
+			positionVersion: versionOf(position),
+			index,
+			indexVersion: index?.version ?? -1
+		};
+		chunkCache.set(geometry, built);
+		return built;
+	};
+	/** Exact nearest depth of a chunk's triangles inside the frustum's side planes. */
+	const chunkDepth = (chunks, chunk, planes) => {
+		const { position, index } = chunks;
+		const indices = index?.array;
+		let best = Infinity;
+		for (let t = chunks.ranges[chunk * 2]; t < chunks.ranges[chunk * 2 + 1]; t++) {
+			for (let corner = 0; corner < 3; corner++) {
+				const v = indices ? indices[t * 3 + corner] : t * 3 + corner;
+				polygon[corner * 3] = position.getX(v);
+				polygon[corner * 3 + 1] = position.getY(v);
+				polygon[corner * 3 + 2] = position.getZ(v);
+			}
+			let count = 3;
+			for (let p = 0; p < 16 && count > 0; p += 4) {
+				const a = planes[p];
+				const b = planes[p + 1];
+				const c = planes[p + 2];
+				const d = planes[p + 3];
+				let kept = 0;
+				for (let i = 0; i < count; i++) {
+					const j = (i + 1) % count;
+					const ix = polygon[i * 3];
+					const iy = polygon[i * 3 + 1];
+					const iz = polygon[i * 3 + 2];
+					const jx = polygon[j * 3];
+					const jy = polygon[j * 3 + 1];
+					const jz = polygon[j * 3 + 2];
+					const di = a * ix + b * iy + c * iz + d;
+					const dj = a * jx + b * jy + c * jz + d;
+					if (di >= 0) {
+						clipped[kept * 3] = ix;
+						clipped[kept * 3 + 1] = iy;
+						clipped[kept * 3 + 2] = iz;
+						kept++;
+					}
+					if (di >= 0 !== dj >= 0) {
+						const f = di / (di - dj);
+						clipped[kept * 3] = ix + (jx - ix) * f;
+						clipped[kept * 3 + 1] = iy + (jy - iy) * f;
+						clipped[kept * 3 + 2] = iz + (jz - iz) * f;
+						kept++;
+					}
+				}
+				[polygon, clipped] = [clipped, polygon];
+				count = kept;
+			}
+			for (let i = 0; i < count; i++) {
+				const depth = planes[16] * polygon[i * 3] + planes[17] * polygon[i * 3 + 1] + planes[18] * polygon[i * 3 + 2] + planes[19];
+				if (depth < best) best = depth;
+			}
+		}
+		return best;
+	};
+	const toLocalPlanes = (matrix) => {
+		const e = matrix.elements;
+		for (let i = 0; i < 20; i += 4) {
+			const nx = worldPlanes[i];
+			const ny = worldPlanes[i + 1];
+			const nz = worldPlanes[i + 2];
+			localPlanes[i] = e[0] * nx + e[1] * ny + e[2] * nz;
+			localPlanes[i + 1] = e[4] * nx + e[5] * ny + e[6] * nz;
+			localPlanes[i + 2] = e[8] * nx + e[9] * ny + e[10] * nz;
+			localPlanes[i + 3] = nx * e[12] + ny * e[13] + nz * e[14] + worldPlanes[i + 3];
+		}
+		return localPlanes;
+	};
+	const testBoxes = (boxes, planes, chunks) => {
+		outer: for (let b = 0; b < boxes.length; b += 6) {
+			const minX = boxes[b];
+			const minY = boxes[b + 1];
+			const minZ = boxes[b + 2];
+			const maxX = boxes[b + 3];
+			const maxY = boxes[b + 4];
+			const maxZ = boxes[b + 5];
+			for (let p = 0; p < 16; p += 4) {
+				const a = planes[p];
+				const bb = planes[p + 1];
+				const c = planes[p + 2];
+				if (a * (a > 0 ? maxX : minX) + bb * (bb > 0 ? maxY : minY) + c * (c > 0 ? maxZ : minZ) + planes[p + 3] < 0) continue outer;
+			}
+			const a = planes[16];
+			const bb = planes[17];
+			const c = planes[18];
+			const depth = a * (a > 0 ? minX : maxX) + bb * (bb > 0 ? minY : maxY) + c * (c > 0 ? minZ : maxZ) + planes[19];
+			if (depth >= nearest) continue;
+			nearest = chunks ? Math.min(nearest, chunkDepth(chunks, b / 6, planes)) : depth;
+		}
+	};
+	const measureObject = (object) => {
+		const geometry = object.geometry;
+		if (!geometry?.getAttribute?.("position")) return;
+		sawContent = true;
+		if (isPlainTriangleMesh(object)) {
+			const chunks = chunksOf(object, geometry);
+			testBoxes(chunks.boxes, toLocalPlanes(object.matrixWorld), chunks);
+			return;
+		}
+		const instanced = object;
+		if (instanced.isInstancedMesh) {
+			if (!instanced.boundingBox) instanced.computeBoundingBox();
+			box.copy(instanced.boundingBox);
+		} else {
+			if (!geometry.boundingBox) geometry.computeBoundingBox();
+			box.copy(geometry.boundingBox);
+		}
+		if (box.isEmpty()) return;
+		singleBox[0] = box.min.x;
+		singleBox[1] = box.min.y;
+		singleBox[2] = box.min.z;
+		singleBox[3] = box.max.x;
+		singleBox[4] = box.max.y;
+		singleBox[5] = box.max.z;
+		testBoxes(singleBox, toLocalPlanes(object.matrixWorld));
+	};
+	const visit = (object) => {
+		if (!object.visible || isViewerAidRoot(object)) return;
+		if (object.userData.kind === "edge-overlay") return;
+		measureObject(object);
+		for (const child of object.children) visit(child);
+	};
+	const measure = (scene, camera) => {
+		scene.updateMatrixWorld();
+		camera.updateMatrixWorld();
+		viewProjection.multiplyMatrices(camera.projectionMatrix, camera.matrixWorldInverse);
+		frustum.setFromProjectionMatrix(viewProjection);
+		for (let i = 0; i < 4; i++) {
+			const plane = frustum.planes[i];
+			worldPlanes[i * 4] = plane.normal.x;
+			worldPlanes[i * 4 + 1] = plane.normal.y;
+			worldPlanes[i * 4 + 2] = plane.normal.z;
+			worldPlanes[i * 4 + 3] = plane.constant;
+		}
+		camera.getWorldDirection(forward);
+		worldPlanes[16] = forward.x;
+		worldPlanes[17] = forward.y;
+		worldPlanes[18] = forward.z;
+		worldPlanes[19] = -forward.dot(camera.position);
+		nearest = Infinity;
+		sawContent = false;
+		for (const child of scene.children) visit(child);
+		return sawContent ? nearest : null;
+	};
+	return { measure };
+}
+function isPlainTriangleMesh(object) {
+	const mesh = object;
+	if (!mesh.isMesh || mesh.isInstancedMesh || mesh.isSkinnedMesh) return false;
+	const geometry = mesh.geometry;
+	if (geometry.isInstancedBufferGeometry) return false;
+	return Object.keys(geometry.morphAttributes).length === 0;
+}
+function versionOf(attribute) {
+	return attribute.isInterleavedBufferAttribute ? attribute.data.version : attribute.version;
+}
+/**
+* Triangle offsets where a merged mesh's source objects begin. A chunk spanning two of them would
+* box the empty space between, and a camera parked in that space would read as touching geometry.
+*/
+function memberStarts(object) {
+	const starts = [];
+	for (const member of membersOf(object) ?? []) if (member.indexStart !== void 0) starts.push(member.indexStart / 3);
+	return starts.sort((a, b) => a - b);
+}
+/**
+* Bounds of consecutive runs of triangles, never crossing a `breaks` offset. Grouped by triangle,
+* not by vertex, so each box holds whole triangles: a big face whose corners all sit off-screen
+* still overlaps the frustum.
+*/
+function buildChunkBoxes(position, index, breaks) {
+	const triangleCount = Math.floor((index ? index.count : position.count) / 3);
+	const ranges = [];
+	let nextBreak = 0;
+	for (let start = 0; start < triangleCount;) {
+		while (nextBreak < breaks.length && breaks[nextBreak] <= start) nextBreak++;
+		const end = Math.min(triangleCount, start + TRIANGLES_PER_CHUNK, breaks[nextBreak] ?? triangleCount);
+		ranges.push(start, end);
+		start = end;
+	}
+	const chunkCount = ranges.length / 2;
+	const boxes = new Float32Array(chunkCount * 6);
+	const plain = !position.isInterleavedBufferAttribute;
+	const array = position.array;
+	const fast = plain && position.itemSize === 3 && !position.normalized;
+	const indices = index?.array;
+	for (let chunk = 0; chunk < chunkCount; chunk++) {
+		let minX = Infinity;
+		let minY = Infinity;
+		let minZ = Infinity;
+		let maxX = -Infinity;
+		let maxY = -Infinity;
+		let maxZ = -Infinity;
+		const end = ranges[chunk * 2 + 1] * 3;
+		for (let corner = ranges[chunk * 2] * 3; corner < end; corner++) {
+			const v = indices ? indices[corner] : corner;
+			const x = fast ? array[v * 3] : position.getX(v);
+			const y = fast ? array[v * 3 + 1] : position.getY(v);
+			const z = fast ? array[v * 3 + 2] : position.getZ(v);
+			if (x < minX) minX = x;
+			if (y < minY) minY = y;
+			if (z < minZ) minZ = z;
+			if (x > maxX) maxX = x;
+			if (y > maxY) maxY = y;
+			if (z > maxZ) maxZ = z;
+		}
+		const o = chunk * 6;
+		boxes[o] = minX;
+		boxes[o + 1] = minY;
+		boxes[o + 2] = minZ;
+		boxes[o + 3] = maxX;
+		boxes[o + 4] = maxY;
+		boxes[o + 5] = maxZ;
+	}
+	return {
+		boxes,
+		ranges: Uint32Array.from(ranges)
+	};
+}
+// src/render/tool-registry.ts
+function createToolRegistry() {
+	const entries = [];
+	let activeId = null;
+	const sort = () => entries.sort((a, b) => b.priority - a.priority);
+	const indexOf = (id) => entries.findIndex((entry) => entry.id === id);
+	const unregister = (id) => {
+		const index = indexOf(id);
+		if (index === -1) return;
+		entries.splice(index, 1);
+		if (activeId === id) activeId = null;
+	};
+	const register = ({ id, tool, priority = 0 }) => {
+		unregister(id);
+		entries.push({
+			id,
+			tool,
+			priority
+		});
+		sort();
+		return () => unregister(id);
+	};
+	const setActive = (id) => {
+		activeId = id;
+		for (const entry of entries) entry.tool.setEnabled?.(entry.id === id);
+	};
+	return {
+		register,
+		unregister,
+		get: (id) => entries[indexOf(id)]?.tool ?? null,
+		setActive,
+		getActive: () => activeId,
+		handleClick: (event) => {
+			for (const entry of [...entries]) if (entry.tool.handleClick(event)) return true;
+			return false;
+		},
+		handleMove: (event) => {
+			for (const entry of [...entries]) entry.tool.handleMove?.(event);
+		}
+	};
+}
+/**
+* Screen-space ray from a canvas mouse event, for tools doing their own picking. Handles the
+* canvas's position and size, so it stays correct under CSS scaling and in fullscreen.
+*/
+function pointerToNdc(event, canvas) {
+	const rect = canvas.getBoundingClientRect();
+	return {
+		x: (event.clientX - rect.left) / rect.width * 2 - 1,
+		y: -((event.clientY - rect.top) / rect.height) * 2 + 1
+	};
+}
+// src/render/view-gizmo.ts
+function createViewGizmo(deps) {
+	const { camera, domElement, controller } = deps;
+	const helper = new ViewHelper(camera, domElement);
+	helper.setLabels("X", "Y", "Z");
+	let visible = true;
+	const DIM = 128;
+	const raycaster = new THREE.Raycaster();
+	const gizmoCamera = new THREE.OrthographicCamera(-2, 2, 2, -2, 0, 4);
+	gizmoCamera.position.set(0, 0, 2);
+	gizmoCamera.updateMatrixWorld();
+	const AXIS_DIRECTIONS = {
+		posX: new THREE.Vector3(1, 0, 0),
+		negX: new THREE.Vector3(-1, 0, 0),
+		posY: new THREE.Vector3(0, 1, 0),
+		negY: new THREE.Vector3(0, -1, 0),
+		posZ: new THREE.Vector3(0, 0, 1),
+		negZ: new THREE.Vector3(0, 0, -1)
+	};
+	const pickAxis = (event) => {
+		const rect = domElement.getBoundingClientRect();
+		const offsetX = rect.left + domElement.offsetWidth - DIM - helper.location.right;
+		const offsetY = rect.top + domElement.offsetHeight - DIM - helper.location.bottom;
+		const mouse = new THREE.Vector2((event.clientX - offsetX) / DIM * 2 - 1, -((event.clientY - offsetY) / DIM) * 2 + 1);
+		if (Math.abs(mouse.x) > 1 || Math.abs(mouse.y) > 1) return null;
+		helper.quaternion.copy(camera.quaternion).invert();
+		helper.updateMatrixWorld();
+		raycaster.setFromCamera(mouse, gizmoCamera);
+		const hits = raycaster.intersectObjects(helper.children, false);
+		for (const hit of hits) {
+			const type = hit.object.userData?.type;
+			if (typeof type === "string" && type in AXIS_DIRECTIONS) return type;
+		}
+		return null;
+	};
+	const handleClick = (event) => {
+		if (!visible) return false;
+		const axis = pickAxis(event);
+		if (!axis) return false;
+		if (controller.getProjection() === "orthographic") controller.setProjection("perspective");
+		controller.setViewDirection(AXIS_DIRECTIONS[axis], false);
+		return true;
+	};
+	return {
+		render: (renderer) => {
+			if (!visible) return;
+			const prevAutoClear = renderer.autoClear;
+			renderer.autoClear = false;
+			helper.render(renderer);
+			renderer.autoClear = prevAutoClear;
+		},
+		handleClick,
+		setVisible: (value) => {
+			visible = value;
+		},
+		isVisible: () => visible,
+		dispose: () => helper.dispose()
+	};
+}
+// src/render/scene-setup/animation-loop.ts
+function createAnimationLoop(renderer, scene, camera, getActiveCamera, cameraController, controls, getCanvasSize, getPixelRatio, onFrame, grid, gizmo, getRenderPipeline, labelLayer, nearFitter, onDemand = true, refiner) {
+	let animationId = null;
+	let lastTime = performance.now();
+	let renderRequested = true;
+	let lastRenderTime = 0;
+	const IDLE_REPAINT_INTERVAL_MS = 500;
+	const lastWorldMatrix = new THREE.Matrix4();
+	const lastProjectionMatrix = new THREE.Matrix4();
+	let lastCamera = null;
+	const invalidate = () => {
+		renderRequested = true;
+	};
+	const cameraMoved = (activeCamera) => {
+		activeCamera.updateMatrixWorld();
+		const moved = lastCamera !== activeCamera || !lastWorldMatrix.equals(activeCamera.matrixWorld) || !lastProjectionMatrix.equals(activeCamera.projectionMatrix);
+		if (moved) {
+			lastCamera = activeCamera;
+			lastWorldMatrix.copy(activeCamera.matrixWorld);
+			lastProjectionMatrix.copy(activeCamera.projectionMatrix);
+		}
+		return moved;
+	};
+	const canvas = renderer.domElement;
+	const pointerEvents = [
+		"pointerdown",
+		"pointerup",
+		"wheel"
+	];
+	if (onDemand) for (const type of pointerEvents) canvas.addEventListener(type, invalidate, { passive: true });
+	const checkResize = () => {
+		const { width, height } = getCanvasSize();
+		if (width === 0 || height === 0) return;
+		const pixelRatio = getPixelRatio();
+		const newW = Math.floor(width * pixelRatio);
+		const newH = Math.floor(height * pixelRatio);
+		if (renderer.domElement.width !== newW || renderer.domElement.height !== newH) {
+			renderer.setPixelRatio(pixelRatio);
+			renderer.setSize(width, height, false);
+			camera.aspect = width / height;
+			camera.updateProjectionMatrix();
+			cameraController.updateAspect(width, height);
+			getRenderPipeline?.()?.setSize(width, height, pixelRatio);
+			labelLayer?.setSize(width, height);
+			invalidate();
+		}
+	};
+	const drawOverlays = (activeCamera) => {
+		if (labelLayer) labelLayer.render(scene, activeCamera);
+		if (gizmo) gizmo.render(renderer);
+	};
+	const drawFrame = (activeCamera, delta) => {
+		const renderPipeline = getRenderPipeline?.();
+		if (renderPipeline) {
+			renderPipeline.setCamera(activeCamera);
+			renderPipeline.render(delta);
+		} else renderer.render(scene, activeCamera);
+		drawOverlays(activeCamera);
+	};
+	const renderNow = () => {
+		const activeCamera = getActiveCamera();
+		if (refiner?.present()) drawOverlays(activeCamera);
+		else drawFrame(activeCamera, 0);
+	};
+	const animate = function() {
+		animationId = requestAnimationFrame(animate);
+		const now = performance.now();
+		const delta = (now - lastTime) / 1e3;
+		lastTime = now;
+		checkResize();
+		if (controls.enableDamping || controls.autoRotate) controls.update();
+		if (grid) grid.update(getActiveCamera().position);
+		if (nearFitter) nearFitter.update();
+		onFrame?.(delta);
+		const activeCamera = getActiveCamera();
+		if (onDemand) {
+			const moved = cameraMoved(activeCamera);
+			if (moved) refiner?.moving(delta * 1e3);
+			const changed = renderRequested || moved;
+			if (!changed && refiner?.wants(now)) {
+				refiner.step(activeCamera);
+				drawOverlays(activeCamera);
+				return;
+			}
+			const repaint = now - lastRenderTime >= IDLE_REPAINT_INTERVAL_MS;
+			if (!changed && !repaint) return;
+			lastRenderTime = now;
+			if (!changed && refiner?.isHolding()) return;
+			renderRequested = false;
+			refiner?.reset(now);
+		}
+		drawFrame(activeCamera, delta);
+	};
+	const dispose = () => {
+		if (animationId !== null) {
+			cancelAnimationFrame(animationId);
+			animationId = null;
+		}
+		if (onDemand) for (const type of pointerEvents) canvas.removeEventListener(type, invalidate);
+	};
+	return {
+		animate,
+		dispose,
+		invalidate,
+		renderNow
+	};
+}
+// src/render/scene-setup/emissive-lights.ts
+/** Point lights are expensive: every lit material pays for each one in its shader. */
+const DEFAULT_MAX_LIGHTS = 3;
+/** Six shadow-map faces per light, each drawing the whole scene. */
+const MAX_SHADOWED_LIGHTS = 2;
+const SHADOW_MAP_SIZE = 1024;
+/** A glow this far below the strongest is a lit surface, not a source: a diffuser, not the bulb. */
+const MIN_RELATIVE_STRENGTH = 1 / 3;
+/** Parts this close, as a share of the larger one's diagonal, are one lamp: a bulb and its reflector. */
+const SAME_LAMP_GAP = .05;
+/**
+* three's point lights are in candela, so brightness falls off with the scene's units squared.
+* Scaling by the scene's radius squared makes one strength read the same in millimetres and metres.
+*/
+const INTENSITY_PER_STRENGTH = .17;
+/** Share of a source's light that comes back off the room, with no shadow to stop it. */
+const BOUNCE_SHARE = .07;
+/** A lamp's source has a size, so its shadow has a penumbra; three's default edge is a hard line. */
+const SHADOW_SOFTNESS = 7;
+/** A source wider than this share of the scene isn't a point. */
+const MAX_POINT_SOURCE_SPREAD = .15;
+function emissiveMaterialOf(mesh) {
+	const material = getBaseMaterial(mesh);
+	return material?.userData["selvaEmissive"] ? material : null;
+}
+function drawnBounds(mesh) {
+	const members = membersOf(mesh);
+	if (!members) return [new THREE.Box3().setFromObject(mesh)];
+	const hidden = getHiddenMembers(mesh);
+	return members.filter((_, index) => !hidden.has(index)).map((member) => memberBounds(mesh, member)).filter((bounds) => !bounds.isEmpty());
+}
+function touches(a, b) {
+	const diagonal = (box) => box.getSize(new THREE.Vector3()).length();
+	const gap = Math.max(diagonal(a), diagonal(b)) * SAME_LAMP_GAP;
+	return a.clone().expandByScalar(gap).intersectsBox(b);
+}
+/**
+* Groups parts of one glow into lamps by contact. More lamps than lights get one light in the
+* middle: lighting three of a street's lamps would pick them by mesh order.
+*/
+function lampsOf(parts, maxLights) {
+	let lamps = [];
+	for (const part of parts) {
+		const lamp = {
+			bounds: part.bounds.clone(),
+			meshes: /* @__PURE__ */ new Set([part.mesh])
+		};
+		const separate = [];
+		for (const other of lamps) if (touches(other.bounds, part.bounds)) {
+			lamp.bounds.union(other.bounds);
+			for (const mesh of other.meshes) lamp.meshes.add(mesh);
+		} else separate.push(other);
+		lamps = [...separate, lamp];
+		if (lamps.length > maxLights) {
+			const bounds = new THREE.Box3();
+			for (const each of parts) bounds.union(each.bounds);
+			return [{
+				bounds,
+				meshes: new Set(parts.map((each) => each.mesh))
+			}];
+		}
+	}
+	return lamps;
+}
+function sourcesFrom(parts, maxLights) {
+	const byGlow = /* @__PURE__ */ new Map();
+	for (const part of parts) {
+		const { emissive, emissiveIntensity, userData } = part.material;
+		const glow = `${emissive.getHexString()}|${emissiveIntensity}|${userData[EMISSIVE_LIGHT]}`;
+		const same = byGlow.get(glow);
+		if (same) same.push(part);
+		else byGlow.set(glow, [part]);
+	}
+	return [...byGlow.values()].flatMap((same) => {
+		const { emissive, emissiveIntensity, userData } = same[0].material;
+		return lampsOf(same, maxLights).map((lamp) => ({
+			...lamp,
+			color: emissive,
+			strength: emissiveIntensity,
+			light: userData[EMISSIVE_LIGHT]
+		}));
+	});
+}
+/**
+* Picks the strongest emissive materials to light the scene. Exported for tests: which surface
+* counts as a source decides whether a lamp's desk gets one pool of light or a washed-out pair.
+*/
+function pickLightSources(sources, maxLights = DEFAULT_MAX_LIGHTS) {
+	const strongest = Math.max(0, ...sources.map((s) => s.strength));
+	return sources.filter((s) => s.strength >= strongest * MIN_RELATIVE_STRENGTH).sort((a, b) => b.strength - a.strength).slice(0, maxLights);
+}
+/**
+* An emissive surface only looks bright, it lights nothing, so a look that wants real light from
+* glowing parts gets a point light at each lamp. A picked lamp stops casting shadows meanwhile, and
+* so does a dimmer glow around its light: a bulb or its diffuser would otherwise block the light.
+*/
+function createEmissiveLights(scene) {
+	const lights = [];
+	const silenced = /* @__PURE__ */ new Set();
+	const offset = new THREE.Vector3();
+	const addLight = (shadowed) => {
+		const key = new THREE.PointLight(16777215, 1, 0, 2);
+		const bounce = new THREE.PointLight(16777215, 1, 0, 1);
+		if (shadowed) {
+			key.castShadow = true;
+			key.shadow.mapSize.setScalar(SHADOW_MAP_SIZE);
+			key.shadow.radius = SHADOW_SOFTNESS;
+			key.shadow.autoUpdate = false;
+		}
+		const pair = {
+			key,
+			bounce,
+			home: new THREE.Vector3(),
+			size: new THREE.Vector3()
+		};
+		lights.push(pair);
+		scene.add(key, bounce);
+		return pair;
+	};
+	const collect = () => {
+		const content = new THREE.Box3();
+		const parts = [];
+		scene.traverseVisible((object) => {
+			const mesh = object;
+			if (!mesh.isMesh || object.userData.source !== "compute") return;
+			content.union(new THREE.Box3().setFromObject(mesh));
+			const material = emissiveMaterialOf(mesh);
+			if (!material) return;
+			for (const bounds of drawnBounds(mesh)) parts.push({
+				mesh,
+				material,
+				bounds
+			});
+		});
+		return {
+			parts,
+			radius: content.getSize(new THREE.Vector3()).length() / 2
+		};
+	};
+	const silence = (parts, sources) => {
+		for (const { mesh, bounds } of parts) if (sources.some((source, index) => source.meshes.has(mesh) || bounds.containsPoint(lights[index].key.position)) && mesh.castShadow) {
+			mesh.castShadow = false;
+			silenced.add(mesh);
+		}
+	};
+	const sync = (enabled, maxLights = DEFAULT_MAX_LIGHTS) => {
+		for (const mesh of silenced) mesh.castShadow = true;
+		silenced.clear();
+		const { parts, radius } = enabled ? collect() : {
+			parts: [],
+			radius: 0
+		};
+		const sources = pickLightSources(sourcesFrom(parts, maxLights), maxLights);
+		sources.forEach((source, index) => {
+			const { key, bounce, home, size } = lights[index] ?? addLight(index < MAX_SHADOWED_LIGHTS);
+			const intensity = source.light ?? source.strength * INTENSITY_PER_STRENGTH * radius * radius;
+			key.color.copy(source.color);
+			const spread = source.bounds.getSize(new THREE.Vector3()).length() / 2 / radius;
+			key.intensity = !source.light && spread > MAX_POINT_SOURCE_SPREAD ? 0 : intensity;
+			source.bounds.getCenter(key.position);
+			home.copy(key.position);
+			source.bounds.getSize(size);
+			bounce.color.copy(source.color);
+			bounce.intensity = intensity * BOUNCE_SHARE / radius;
+			bounce.position.copy(key.position);
+			if (key.castShadow) {
+				key.shadow.camera.near = radius * .005;
+				key.shadow.camera.far = radius * 4;
+				key.shadow.camera.updateProjectionMatrix();
+				key.shadow.bias = -.002;
+				key.shadow.normalBias = radius * .002;
+				key.shadow.needsUpdate = true;
+			}
+		});
+		while (lights.length > sources.length) {
+			const { key, bounce } = lights.pop();
+			scene.remove(key, bounce);
+			key.dispose();
+			bounce.dispose();
+		}
+		silence(parts, sources);
+	};
+	const place = (position) => {
+		for (const { key, home, size } of lights) {
+			key.position.copy(position(home, size));
+			if (key.castShadow) key.shadow.needsUpdate = true;
+		}
+	};
+	return {
+		sync,
+		jitter: (index) => place((home, size) => offset.set(halton(index, 2) - .5, halton(index, 3) - .5, halton(index, 5) - .5).multiply(size).add(home)),
+		settle: () => place((home) => home),
+		dispose: () => sync(false)
+	};
+}
+// src/render/scene-setup/appearance.ts
+const BASELINE_KEY = "__selvaLookBaseline";
+function applyBaseline(target, baseline) {
+	target.color?.setHex(baseline.color);
+	if (target.metalness !== void 0) target.metalness = baseline.metalness;
+	if (target.roughness !== void 0) target.roughness = baseline.roughness;
+	if (target.emissiveIntensity !== void 0) target.emissiveIntensity = baseline.emissiveIntensity;
+	target.opacity = baseline.opacity;
+	target.transparent = baseline.transparent;
+	target.depthWrite = baseline.depthWrite;
+	if (target.wireframe !== void 0) target.wireframe = baseline.wireframe;
+	target.side = baseline.side;
+}
+/** Restores the parsed values and forgets the baseline. No-op when nothing was overridden. */
+function restoreBaseline(target) {
+	const baseline = target[BASELINE_KEY];
+	if (!baseline) return;
+	applyBaseline(target, baseline);
+	delete target[BASELINE_KEY];
+}
+/**
+* Applies a look's material overrides, or restores the parsed values when the look has none.
+* `needsUpdate` is set because switching `transparent` changes the shader program, not just a
+* uniform.
+*
+* Exported for tests: the leak this guards against is invisible until two overriding looks are
+* applied in sequence, which no single-look check catches.
+*
+* Every apply restores the baseline first, so an override only has to describe what *it* wants.
+* Without that reset, switching between two looks that both override leaves behind whatever the
+* previous one set and the new one is silent about — `wireframe` surviving out of the wireframe
+* look, or `opacity`/`depthWrite` surviving out of xray, since no other look mentions them.
+*/
+function applyMaterialOverride(material, override) {
+	const target = material;
+	if (!override) {
+		restoreBaseline(target);
+		target.needsUpdate = true;
+		return;
+	}
+	if (!target[BASELINE_KEY]) target[BASELINE_KEY] = {
+		color: target.color?.getHex() ?? 16777215,
+		metalness: target.metalness ?? 0,
+		roughness: target.roughness ?? 1,
+		emissiveIntensity: target.emissiveIntensity ?? 0,
+		opacity: target.opacity,
+		transparent: target.transparent,
+		depthWrite: target.depthWrite,
+		wireframe: target.wireframe ?? false,
+		side: target.side
+	};
+	else applyBaseline(target, target[BASELINE_KEY]);
+	if (override.color !== void 0) target.color?.setHex(override.color);
+	if (override.metalness !== void 0 && target.metalness !== void 0) target.metalness = override.metalness;
+	if (override.roughness !== void 0 && target.roughness !== void 0) target.roughness = override.roughness;
+	if (override.emissiveIntensity !== void 0 && target.userData["selvaEmissive"]) target.emissiveIntensity = override.emissiveIntensity;
+	if (override.opacity !== void 0) {
+		target.opacity = override.opacity;
+		target.transparent = override.opacity < 1;
+	}
+	if (override.depthWrite !== void 0) target.depthWrite = override.depthWrite;
+	if (override.wireframe !== void 0 && target.wireframe !== void 0) target.wireframe = override.wireframe;
+	if (override.side !== void 0) target.side = override.side;
+	target.needsUpdate = true;
+}
+/** A material's own value (see `OWN_ENV_MAP_INTENSITY`) unless the look restyles every material. */
+function envMapIntensityForLook(material, preset) {
+	if (preset.materialOverride) return preset.envMapIntensity;
+	const own = material.userData[OWN_ENV_MAP_INTENSITY];
+	if (own != null) return own;
+	const target = material;
+	const metalness = target[BASELINE_KEY]?.metalness ?? target.metalness ?? 0;
+	return lookEnvMapIntensity(preset.envMapIntensity, metalness);
+}
+function lookPixelRatio(fullPixelRatio, preset) {
+	return Math.min(fullPixelRatio, preset.maxPixelRatio ?? fullPixelRatio);
+}
+function createAppearanceController(params) {
+	const { scene, renderer, lights, config, pipeline, fullPixelRatio, requestRender } = params;
+	const presetOf = (look) => lookPreset(look, config.render.lowPower);
+	let activeLook = config.look;
+	const emissiveLights = createEmissiveLights(scene);
+	const ownShadowType = renderer.shadowMap.type;
+	const applyShadowType = (preset) => {
+		const type = preset.emissiveLights ? THREE.PCFShadowMap : ownShadowType;
+		if (renderer.shadowMap.type === type) return;
+		renderer.shadowMap.type = type;
+		renderer.shadowMap.needsUpdate = true;
+	};
+	let ownBackground;
+	const applyBackground = (preset) => {
+		if (preset.background === void 0) {
+			if (ownBackground !== void 0) scene.background = ownBackground;
+			ownBackground = void 0;
+			return;
+		}
+		ownBackground ??= scene.background;
+		scene.background = new THREE.Color(preset.background);
+	};
+	applyBackground(presetOf(activeLook));
+	applyShadowType(presetOf(activeLook));
+	const setFillLights = (opts) => {
+		if (opts.ambientIntensity !== void 0) lights.ambient.intensity = opts.ambientIntensity;
+		if (opts.hemisphereIntensity !== void 0 && !lights.hemisphere && opts.hemisphereIntensity > 0) {
+			lights.hemisphere = new THREE.HemisphereLight(opts.hemisphereSkyColor ?? config.lighting.hemisphereSkyColor, opts.hemisphereGroundColor ?? config.lighting.hemisphereGroundColor, opts.hemisphereIntensity);
+			lights.hemisphere.position.copy(config.environment.sceneUp ?? defaultUp);
+			scene.add(lights.hemisphere);
+		}
+		if (lights.hemisphere) {
+			if (opts.hemisphereIntensity !== void 0) lights.hemisphere.intensity = opts.hemisphereIntensity;
+			if (opts.hemisphereSkyColor !== void 0) lights.hemisphere.color.set(opts.hemisphereSkyColor);
+			if (opts.hemisphereGroundColor !== void 0) lights.hemisphere.groundColor.set(opts.hemisphereGroundColor);
+		}
+		requestRender();
+	};
+	const setEnvironmentIntensity = (intensity) => {
+		config.environment.environmentIntensity = intensity;
+		scene.environmentIntensity = intensity;
+		requestRender();
+	};
+	const setToneMappingExposure = (exposure) => {
+		config.render.toneMappingExposure = exposure;
+		renderer.toneMappingExposure = exposure;
+		if (pipeline.get()) pipeline.rebuild();
+	};
+	const setAoIntensity = (intensity) => {
+		config.render.aoIntensity = intensity;
+		if (pipeline.get()) pipeline.rebuild();
+	};
+	const syncEmissiveLights = () => {
+		const { emissiveLights: enabled, maxEmissiveLights } = presetOf(activeLook);
+		emissiveLights.sync(!!enabled, maxEmissiveLights);
+		requestRender();
+	};
+	const setLook = (look, options) => {
+		const preset = presetOf(look);
+		activeLook = look;
+		renderer.toneMapping = preset.toneMapping;
+		renderer.toneMappingExposure = preset.toneMappingExposure;
+		config.render.toneMapping = preset.toneMapping;
+		config.render.toneMappingExposure = preset.toneMappingExposure;
+		setFillLights({
+			hemisphereIntensity: preset.hemisphereIntensity,
+			ambientIntensity: preset.ambientIntensity
+		});
+		setEnvironmentIntensity(preset.environmentIntensity);
+		if (lights.sun) {
+			lights.sun.intensity = preset.sunlightIntensity;
+			config.lighting.sunlightIntensity = preset.sunlightIntensity;
+		}
+		applyBackground(preset);
+		applyShadowType(preset);
+		config.render.bloom = preset.bloom;
+		config.render.pixelRatio = lookPixelRatio(fullPixelRatio, preset);
+		pipeline.setAmbientOcclusion(preset.ambientOcclusion);
+		scene.traverse((object) => {
+			if (object.userData.source !== "compute") return;
+			const mesh = object;
+			const materials = Array.isArray(mesh.material) ? mesh.material : mesh.material ? [mesh.material] : [];
+			for (const material of materials) {
+				if ("envMapIntensity" in material) material.envMapIntensity = envMapIntensityForLook(material, preset);
+				applyMaterialOverride(material, preset.materialOverride);
+			}
+		});
+		applyReflectionEnvironment(scene, scene);
+		if (!options?.deferEmissiveLights) syncEmissiveLights();
+	};
+	return {
+		setFillLights,
+		setEnvironmentIntensity,
+		setToneMappingExposure,
+		setAoIntensity,
+		setLook,
+		syncEmissiveLights,
+		jitterEmissiveLights: emissiveLights.jitter,
+		settleEmissiveLights: emissiveLights.settle,
+		getMaterialAppearance: () => materialAppearanceForLook(activeLook)
+	};
+}
+// src/render/scene-setup/create-camera.ts
+function createCamera(config, canvas) {
+	const parent = canvas.parentElement;
+	const width = parent ? parent.clientWidth : window.innerWidth;
+	const height = parent ? parent.clientHeight : window.innerHeight;
+	const camera = new THREE.PerspectiveCamera(config.camera.fov, width / height, config.camera.near, config.camera.far);
+	const pos = config.camera.position;
+	if (pos) camera.position.set(pos.x, pos.y, pos.z);
+	return camera;
+}
+// src/render/scene-setup/create-scene.ts
+function createScene(config) {
+	const scene = new THREE.Scene();
+	scene.background = (typeof config.environment.backgroundColor === "string" ? new THREE.Color(config.environment.backgroundColor) : config.environment.backgroundColor) || null;
+	return scene;
+}
+// src/render/scene-setup/dispose.ts
+/** Sweeps every renderable plus the scene-level textures the object traversal can't reach. */
+function disposeSceneResources(scene, options) {
+	disposeObjectTree(scene, options);
+	scene.environment?.dispose();
+	disposeReflectionEnvironment(scene);
+	if (scene.background instanceof THREE.Texture) scene.background.dispose();
+}
+// src/render/edge-detection-pass.ts
+const EDGE_SHADER = {
+	uniforms: {
+		tDiffuse: { value: null },
+		tNormal: { value: null },
+		tDepth: { value: null },
+		uResolution: { value: new THREE.Vector2(1, 1) },
+		uColor: { value: new THREE.Color(2236962) },
+		uOpacity: { value: 1 },
+		uNormalThreshold: { value: .4 },
+		uDepthThreshold: { value: .02 },
+		uThickness: { value: 1 },
+		uNear: { value: .1 },
+		uFar: { value: 1e3 },
+		uPerspective: { value: 1 }
+	},
+	vertexShader: `
 		varying vec2 vUv;
 		void main() {
 			vUv = uv;
 			gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
 		}
-	`,fragmentShader:`
+	`,
+	fragmentShader: `
 		uniform sampler2D tDiffuse;
 		uniform sampler2D tNormal;
 		uniform sampler2D tDepth;
@@ -104,5 +3339,1045 @@ import{a as e,c as t,d as n,f as r,g as i,h as a,l as o,m as s,p as c,r as l,s a
 			float edge = max(depthEdge, normalEdge) * uOpacity;
 			gl_FragColor = vec4(mix(color.rgb, uColor, edge), color.a);
 		}
-	`};var Pt=class extends N{camera;scene;normalMaterial;edgeMaterial;fsQuad;normalTarget=null;width;height;constructor(e,t,n,r,i={}){super(),this.scene=e,this.camera=t,this.width=Math.max(1,n),this.height=Math.max(1,r),this.normalMaterial=new v.MeshNormalMaterial,this.normalMaterial.blending=v.NoBlending,this.edgeMaterial=new v.ShaderMaterial({uniforms:v.UniformsUtils.clone(Nt.uniforms),vertexShader:Nt.vertexShader,fragmentShader:Nt.fragmentShader});let a=this.edgeMaterial.uniforms;a.uColor.value=new v.Color(i.color??2236962),a.uOpacity.value=i.opacity??1,a.uNormalThreshold.value=i.normalThreshold??.4,a.uDepthThreshold.value=i.depthThreshold??.02,a.uThickness.value=i.thickness??1,this.fsQuad=new ee(this.edgeMaterial),this.needsSwap=!0}acquireNormalTarget(){if(!this.normalTarget){let e=new v.DepthTexture(this.width,this.height);this.normalTarget=new v.WebGLRenderTarget(this.width,this.height,{minFilter:v.NearestFilter,magFilter:v.NearestFilter,depthTexture:e})}return this.normalTarget}setSize(e,t){this.width=Math.max(1,e),this.height=Math.max(1,t),this.normalTarget?.setSize(this.width,this.height)}render(e,t,n){let r=this.acquireNormalTarget(),i=e.getRenderTarget(),a=e.autoClear,o=e.getClearColor(new v.Color),s=e.getClearAlpha(),c=this.scene.overrideMaterial;e.setRenderTarget(r),e.setClearColor(7829503,1),e.autoClear=!0,this.scene.overrideMaterial=this.normalMaterial,e.render(this.scene,this.camera),this.scene.overrideMaterial=c,e.setClearColor(o,s),e.autoClear=a;let l=this.edgeMaterial.uniforms;l.tDiffuse.value=n.texture,l.tNormal.value=r.texture,l.tDepth.value=r.depthTexture,l.uResolution.value.set(this.width,this.height);let u=this.camera;l.uPerspective.value=+!!u.isPerspectiveCamera,l.uNear.value=this.camera.near??.1,l.uFar.value=this.camera.far??1e3,e.setRenderTarget(this.renderToScreen?null:t),this.fsQuad.render(e),e.setRenderTarget(i)}dispose(){this.normalTarget?.dispose(),this.normalMaterial.dispose(),this.edgeMaterial.dispose(),this.fsQuad.dispose()}};function Ft(e){return e>=2?0:4}function It(e,t,n,r,i,a){let o=new v.WebGLRenderTarget(r,i,{type:v.HalfFloatType}),s=new O(e,o);s.renderTarget2.samples=0;let c=e=>{s.readBuffer=o,s.writeBuffer=s.renderTarget2,s.render(e)},l=new k(t,n);s.addPass(l);let u=null;(a.ambientOcclusion??!0)&&(u=new A(t,n,r,i),u.blendIntensity=a.aoIntensity??1,u.updateGtaoMaterial({screenSpaceRadius:!0}),s.addPass(u));let d=new Pt(t,n,r,i,typeof a.edgeDetection==`object`?a.edgeDetection:{});d.enabled=!!a.edgeDetection,s.addPass(d);let f=new j;s.addPass(f);let p=new M;s.addPass(p),e.toneMapping=a.toneMapping,e.toneMappingExposure=a.toneMappingExposure;let m=a.aoPixelRatio??1,h=1;if(u){let e=u.setSize.bind(u);u.setSize=(t,n)=>e(Math.max(1,Math.round(t*h)),Math.max(1,Math.round(n*h)))}let g=e=>{h=Math.min(e,m)/e;let t=Ft(e);o.samples!==t&&(o.samples=t,o.dispose()),s.setPixelRatio(e)};return g(e.getPixelRatio()),s.setSize(r,i),{render:c,setSize:(e,t,n)=>{g(n),s.setSize(e,t)},setCamera:e=>{if(l.camera=e,d.camera=e,!u)return;u.camera=e;let t=+!!e.isPerspectiveCamera;u.gtaoMaterial.defines.PERSPECTIVE_CAMERA!==t&&(u.gtaoMaterial.defines.PERSPECTIVE_CAMERA=t,u.gtaoMaterial.needsUpdate=!0)},setEdgeDetection:e=>{d.enabled=e},edgeDetectionEnabled:()=>d.enabled,dispose:()=>{s.dispose(),u?.dispose(),d.dispose(),f.dispose(),p.dispose()}}}function Lt(e){let{renderer:t,scene:n,getActiveCamera:r,getCanvasSize:i,pixelRatio:a,config:o,requestRender:s}=e,c=null,l=!!o.render.ambientOcclusion,u=!1,d=!1,f=e=>{let{width:s,height:c}=i(),l=It(t,n,r(),Math.max(1,s),Math.max(1,c),{toneMapping:o.render.toneMapping??v.NeutralToneMapping,toneMappingExposure:o.render.toneMappingExposure??1,ambientOcclusion:e,aoIntensity:o.render.aoIntensity,aoPixelRatio:o.render.aoPixelRatio,edgeDetection:!1});return l.setSize(Math.max(1,s),Math.max(1,c),a),l},p=()=>{if(!(l||u)){c?.dispose(),c=null,s();return}(!c||d!==l)&&(c?.dispose(),c=f(l),d=l),c.setEdgeDetection(u),s()};return{get:()=>c,sync:p,rebuild:()=>{c?.dispose(),c=null,p()},setAmbientOcclusion:e=>{l=e,p()},setEdgeFallback:e=>{e!==u&&(u=e,p())},isEdgeFallbackActive:()=>u,dispose:()=>{c?.dispose(),c=null}}}function Rt(e,t,n){let r=new P(e,t),i=n.camera.target;return i&&r.target.set(i.x,i.y,i.z),r.enableDamping=n.controls.enableDamping||!1,r.dampingFactor=n.controls.dampingFactor||.05,r.autoRotate=n.controls.autoRotate||!1,r.autoRotateSpeed=n.controls.autoRotateSpeed||.5,r.enableZoom=n.controls.enableZoom??!0,r.enablePan=n.controls.enablePan??!0,r.minDistance=n.controls.minDistance||.001,r.maxDistance=n.controls.maxDistance||1/0,r.screenSpacePanning=!1,r.maxPolarAngle=Math.PI,r.update(),r}function zt(e,t,n,r){n.environment.enableEnvironmentLighting?(V(e,t,le(n.environment.sceneUp??Q)),new F().load(n.environment.hdrPath||`/baseHDR.hdr`,function(i){if(r()){i.dispose();return}if(!i?.image){c().warn(`HDR loaded without image data; skipping environment map.`),i?.dispose(),n.events.onReady?.();return}i.mapping=v.EquirectangularReflectionMapping;let a=new v.PMREMGenerator(t);a.compileEquirectangularShader();let o=a.fromEquirectangular(i).texture;a.dispose(),e.environment=o,e.environmentIntensity=n.environment.environmentIntensity??1;let s=le(n.environment.sceneUp??Q);e.environmentRotation.copy(s),n.environment.showEnvironment?(e.background=i,e.backgroundRotation.copy(s)):i.dispose(),n.events.onReady?.()},void 0,function(e){r()||(c().warn(`HDR texture could not be loaded, falling back to basic lighting:`,e),n.events.onReady?.())})):n.events.onReady?.()}function Bt(e,t){let n=t.floor.size,r=new v.PlaneGeometry(n,n),i=typeof t.floor.color==`string`?new v.Color(t.floor.color):t.floor.color,a=new v.MeshStandardMaterial({color:i,roughness:t.floor.roughness,metalness:t.floor.metalness,side:v.DoubleSide}),o=new v.Mesh(r,a);o.userData.id=`floor`,o.name=`floor`;let s=(t.environment?.sceneUp||Q).clone().normalize();o.quaternion.setFromUnitVectors(new v.Vector3(0,0,1),s),o.position.set(0,0,0),t.floor.receiveShadow&&t.render.enableShadows&&(o.receiveShadow=!0),e.add(o)}function Vt(e,t,n){if(n&&`emissive`in e){let n=e;n.emissive=t.clone(),n.emissiveIntensity=.6,n.color.lerp(t,.75),n.metalness=Math.min(n.metalness,.2),n.opacity<1&&(n.opacity=1,n.transparent=!1,n.depthWrite=!0);return}`color`in e&&(e.color=t.clone())}function Ht(e,t,n,r){let i=new Set,a=new Map,o=null,s=null,l=null,u=new v.Raycaster,d=new v.Vector2,f=new v.Vector2,p=()=>n.getActiveCamera(),h=e=>{let t=e;for(;t;){if(!t.visible)return!1;t=t.parent}return!0},g=()=>{let e=G(t);if(e.isEmpty()){c().warn(`No objects to fit to view`);return}n.frameBounds(e,!1)},_=typeof r.events.selectionColor==`string`?new v.Color(r.events.selectionColor):r.events.selectionColor instanceof v.Color?r.events.selectionColor:new v.Color(`#ff0000`),y=()=>{o&&(o(),o=null,l?.dispose(),l=null),i.forEach(e=>{let n=e;if(a.has(e)){let r=a.get(e),i=n.material;i instanceof v.Material?i.dispose():Array.isArray(i)&&i.forEach(e=>e.dispose()),n.material=r,a.delete(e);let o=e;for(;o.parent;)o=o.parent;o!==t&&(r instanceof v.Material?r.dispose():r.forEach(e=>e.dispose()))}}),i.clear(),s=null},b=(e,t)=>{if(t&&e instanceof v.Mesh){let n=m(e).clone();return Vt(n,_,!0),l=n,o=Re(e,t,n),!0}let n=e;if(!(n.material instanceof v.Material))return!1;let r=n.material.clone();return Vt(r,_,e instanceof v.Mesh),a.set(e,n.material),n.material=r,!0},x=null,S=-1,C=()=>{if(x===null||t.children.length!==S){let e=G(t);x=e.isEmpty()?1:e.getSize(new v.Vector3).length(),S=t.children.length}u.params.Points.threshold=x*.01},w=(n,r)=>{let i=e.getBoundingClientRect();d.x=(n-i.left)/i.width*2-1,d.y=-((r-i.top)/i.height)*2+1,C(),u.setFromCamera(d,p());for(let e of u.intersectObjects(t.children,!0))if(h(e.object)&&!me(e.object))return e;return null},T=e=>{f.set(e.clientX,e.clientY)},E=e=>{let t=new v.Vector2(e.clientX,e.clientY);if(f.distanceTo(t)>5)return;let n=w(e.clientX,e.clientY);if(!n){y(),r.events?.onBackgroundClicked?.({x:d.x,y:d.y});return}let a=n.object,o=Ie(n),c=o?.index??null;i.has(a)&&c===s||(y(),i.add(a),s=c,b(a,o?.member??null),r.events?.onObjectSelected?.(a),o?r.events?.onMeshMetadataClicked?.({source:a.userData?.source,name:o.member.name,layer:o.member.layer,trackingKey:o.member.trackingKey,metadata:o.member.metadata}):a instanceof v.Mesh&&Object.keys(a.userData).length>0&&r.events?.onMeshMetadataClicked?.(a.userData))},D=e=>{let i=w(e.clientX,e.clientY);if(!i){r.events?.enableDoubleClickZoom&&n.frameBounds(G(t),!0);return}let a=i.object;if(r.events?.onMeshDoubleClicked?.(a),!r.events?.enableDoubleClickZoom)return;let o=Ie(i),s=o&&a instanceof v.Mesh?Le(a,o.member):new v.Box3().setFromObject(a);s.isEmpty()||n.frameBounds(s,!0)},O=e=>{if(r.events?.enableKeyboardControls)switch(e.key.toLowerCase()){case`f`:e.preventDefault(),g();break;case`escape`:e.preventDefault(),y();break;case` `:e.preventDefault(),g()}};return r.events?.enableClickToFocus&&(e.addEventListener(`mousedown`,T),e.addEventListener(`click`,E),e.addEventListener(`dblclick`,D)),r.events?.enableKeyboardControls&&(e.setAttribute(`tabindex`,`0`),e.addEventListener(`keydown`,O)),{dispose:()=>{e.removeEventListener(`mousedown`,T),e.removeEventListener(`click`,E),e.removeEventListener(`dblclick`,D),e.removeEventListener(`keydown`,O),y()},fitToView:g,clearSelection:y}}function Ut(e,t){let n=new v.AmbientLight(t.lighting.ambientLightColor,t.lighting.ambientLightIntensity);e.add(n);let r=null;if(t.lighting.enableHemisphereLight){r=new v.HemisphereLight(t.lighting.hemisphereSkyColor,t.lighting.hemisphereGroundColor,t.lighting.hemisphereIntensity);let n=t.environment.sceneUp??Q;r.position.copy(n),e.add(r)}if(!t.lighting.enableSunlight)return{ambient:n,hemisphere:r,sun:null};let i=new v.DirectionalLight(t.lighting.sunlightColor??16777215,t.lighting.sunlightIntensity),a=t.lighting.sunlightPosition;return a&&i.position.set(a.x,a.y,a.z),t.render.enableShadows?(i.castShadow=!0,i.shadow.mapSize.width=t.render.shadowMapSize||2048,i.shadow.mapSize.height=t.render.shadowMapSize||2048,i.shadow.bias=-1e-4,i.shadow.normalBias=.02,i.shadow.radius=4,e.add(i),e.add(i.target),{ambient:n,hemisphere:r,sun:i}):(e.add(i),{ambient:n,hemisphere:r,sun:null})}function Wt(e,t){if(t.isEmpty())return;let n=t.getCenter(new v.Vector3),r=t.getSize(new v.Vector3).length()*.5*1.2,i=e.shadow.camera;i.left=-r,i.right=r,i.top=r,i.bottom=-r,e.target.position.copy(n),e.target.updateMatrixWorld();let a=e.position.distanceTo(n);i.near=Math.max(r*.01,a-r),i.far=a+r,i.updateProjectionMatrix()}function Gt(e,t,n){let r=new v.WebGLRenderer({antialias:t.render.antialias,canvas:e,alpha:!0,powerPreference:`high-performance`,preserveDrawingBuffer:t.render.preserveDrawingBuffer,logarithmicDepthBuffer:!1}),i=e.parentElement,a=i?i.clientWidth:window.innerWidth,o=i?i.clientHeight:window.innerHeight;return i&&(e.style.width=`100%`,e.style.height=`100%`,e.style.display=`block`),r.setSize(a,o,!1),r.setPixelRatio(n),t.render.enableShadows&&(r.shadowMap.enabled=!0,r.shadowMap.type=v.VSMShadowMap),r.toneMapping=t.render.toneMapping,r.toneMappingExposure=t.render.toneMappingExposure??1,r.outputColorSpace=v.SRGBColorSpace,r.sortObjects=!0,r}const Kt=function(e,t){let n=wt(t||{}),r=n.environment?.sceneUp||Q,i=n.render.pixelRatio??Math.min(window.devicePixelRatio,2),a=jt(n),o=At(n,e);o.up.copy(r);let s=Gt(e,n,i);l(s.capabilities.getMaxAnisotropy()),t?.onMaxAnisotropy?.(s.capabilities.getMaxAnisotropy());let c=Rt(o,e,n),u=ve({scene:a,perspective:o,controls:c,onActiveCameraChange:()=>{},up:r}),f=()=>u.getActiveCamera(),p=!1;zt(a,s,n,()=>p);let m=Ut(a,n),h=m.sun,g=()=>{h&&Wt(h,G(a))};n.floor?.enabled&&Bt(a,n);let _=n.floor?.enabled?a.children.find(e=>e.userData.id===`floor`)??null:null,y=n.grid.enabled?it({cellSize:n.grid.cellSize,majorEvery:n.grid.majorEvery,cellColor:n.grid.cellColor,majorColor:n.grid.majorColor,fadeDistance:n.grid.fadeDistance,plane:n.grid.plane}):null;y&&a.add(y.object);let b=()=>{y&&y.fitToContent(G(a))},x=n.gizmo.enabled?St({camera:o,domElement:e,controller:u}):null,S=n.grid.plane??ue(r),C=new v.Vector3(+(S===`x`),+(S===`y`),+(S===`z`)),w=r.clone().normalize(),T=n.camera.dynamicNear?mt({camera:o,scene:a,groundNormals:()=>{let e=[];return y?.object.visible&&e.push(C),n.floor.enabled&&_?.visible&&e.push(w),e}}):null,E=at(e.parentElement??e,a),D=n.measure.enabled?ft({canvas:e,scene:a,getActiveCamera:f,labelLayer:E,options:{snapPixels:n.measure.snapPixels,color:n.measure.color,labelClassName:n.measure.labelClassName,displayUnit:n.measure.displayUnit,format:n.measure.format}}):null,O=n.events.enableEventHandlers===!1?{dispose:()=>{},fitToView:()=>{},clearSelection:()=>{}}:Ht(e,a,u,n),k=bt();D&&k.register({id:`measure`,tool:D,priority:0}),x&&k.register({id:`gizmo`,tool:x,priority:-100});let A=0,j=0,M=e=>{A=e.clientX,j=e.clientY},ee=e=>Math.hypot(e.clientX-A,e.clientY-j)>5,N=e=>{ee(e)||k.handleClick(e)&&e.stopImmediatePropagation()};e.addEventListener(`mousedown`,M,{capture:!0}),e.addEventListener(`click`,N,{capture:!0});let P=e=>k.handleMove(e);e.addEventListener(`mousemove`,P,{passive:!0});let F=()=>{},te=(e,t)=>{tt(e,{color:n.edges.color,darken:n.edges.darken,width:n.edges.width,thresholdAngle:n.edges.thresholdAngle,distanceFade:n.edges.distanceFade,maxTriangles:n.edges.maxTriangles,maxSegments:n.edges.maxSegments,maxOverlays:n.edges.maxOverlays,...t}).then(()=>{ne(e),F()})},ne=e=>{if(n.edges.screenSpaceFallback===!1)return;let t=!1;e.traverse(e=>{let n=e.userData?.edgesSkipped;(n===`triangle-cap`||n===`overlay-budget`)&&(t=!0)}),B.setEdgeFallback(t)},I=e=>{nt(e),B.setEdgeFallback(!1),F()},R=e.parentElement,z=()=>R?{width:R.clientWidth,height:R.clientHeight}:{width:window.innerWidth,height:window.innerHeight},B=Lt({renderer:s,scene:a,getActiveCamera:f,getCanvasSize:z,pixelRatio:i,config:n,requestRender:()=>F()});B.sync();let V=kt({scene:a,renderer:s,lights:m,config:n,pipeline:B,requestRender:()=>F()}),{animate:ae,dispose:oe,invalidate:H,renderNow:U}=Ct(s,a,o,f,u,c,z,i,n.events.onFrame,y,x,()=>B.get(),E,T,n.render.onDemand??!0);return F=H,ae(),a.up.set(r.x,r.y,r.z),g(),b(),{scene:a,camera:o,controls:c,renderer:s,cameraController:u,grid:y,gizmo:x,measureTool:D,labelLayer:E,tools:k,applyEdges:te,clearEdges:I,invalidate:H,captureImage:(e=`image/png`,t)=>(U(),new Promise(n=>s.domElement.toBlob(n,e,t))),setAmbientOcclusion:B.setAmbientOcclusion,setLook:V.setLook,setFillLights:V.setFillLights,setEnvironmentIntensity:V.setEnvironmentIntensity,setToneMappingExposure:V.setToneMappingExposure,setAoIntensity:V.setAoIntensity,getMaterialAppearance:V.getMaterialAppearance,updateShadowBounds:g,updateGridScale:b,dispose:()=>{p||(p=!0,oe(),O.dispose(),e.removeEventListener(`mousedown`,M,{capture:!0}),e.removeEventListener(`click`,N,{capture:!0}),e.removeEventListener(`mousemove`,P),D?.dispose(),E?.dispose(),x?.dispose(),y?.dispose(),B.dispose(),u.dispose(),c.dispose(),s.dispose(),s.forceContextLoss(),Mt(a))},fitToView:O.fitToView,clearSelection:O.clearSelection,addUserGeometry:(e,t)=>{e.userData.source=t===void 0?re:L(t),a.add(e),F()},removeUserGeometry:e=>{e.removeFromParent(),d(e),F()},clearUserGeometry:e=>{a.children.filter(t=>ie(t,e)).forEach(e=>{e.removeFromParent(),d(e)}),F()}}};export{u as DEFAULT_LOOK,a as ErrorCodes,te as LOOKS,t as LOOK_PRESETS,ne as SOURCE_COMPUTE,re as SOURCE_USER,i as VisualizationError,R as appIdFromSource,L as appSource,r as enableDebugLogging,c as getLogger,Kt as initThree,z as isHostOwned,ie as isOwnedBy,n as materialAppearanceForLook,lt as pickThreshold,xt as pointerToNdc,s as setLogger,dt as snapToVertex,de as updateScene};
+	`
+};
+var EdgeDetectionPass = class extends Pass {
+	camera;
+	scene;
+	normalMaterial;
+	edgeMaterial;
+	fsQuad;
+	normalTarget = null;
+	width;
+	height;
+	constructor(scene, camera, width, height, options = {}) {
+		super();
+		this.scene = scene;
+		this.camera = camera;
+		this.width = Math.max(1, width);
+		this.height = Math.max(1, height);
+		this.normalMaterial = new THREE.MeshNormalMaterial();
+		this.normalMaterial.blending = THREE.NoBlending;
+		this.edgeMaterial = new THREE.ShaderMaterial({
+			uniforms: THREE.UniformsUtils.clone(EDGE_SHADER.uniforms),
+			vertexShader: EDGE_SHADER.vertexShader,
+			fragmentShader: EDGE_SHADER.fragmentShader
+		});
+		const uniforms = this.edgeMaterial.uniforms;
+		uniforms.uColor.value = new THREE.Color(options.color ?? 2236962);
+		uniforms.uOpacity.value = options.opacity ?? 1;
+		uniforms.uNormalThreshold.value = options.normalThreshold ?? .4;
+		uniforms.uDepthThreshold.value = options.depthThreshold ?? .02;
+		uniforms.uThickness.value = options.thickness ?? 1;
+		this.fsQuad = new FullScreenQuad(this.edgeMaterial);
+		this.needsSwap = true;
+	}
+	acquireNormalTarget() {
+		if (!this.normalTarget) {
+			const depthTexture = new THREE.DepthTexture(this.width, this.height);
+			this.normalTarget = new THREE.WebGLRenderTarget(this.width, this.height, {
+				minFilter: THREE.NearestFilter,
+				magFilter: THREE.NearestFilter,
+				depthTexture
+			});
+		}
+		return this.normalTarget;
+	}
+	setSize(width, height) {
+		this.width = Math.max(1, width);
+		this.height = Math.max(1, height);
+		this.normalTarget?.setSize(this.width, this.height);
+	}
+	render(renderer, writeBuffer, readBuffer) {
+		const normalTarget = this.acquireNormalTarget();
+		const previousTarget = renderer.getRenderTarget();
+		const previousAutoClear = renderer.autoClear;
+		const previousClearColor = renderer.getClearColor(new THREE.Color());
+		const previousClearAlpha = renderer.getClearAlpha();
+		const previousOverride = this.scene.overrideMaterial;
+		renderer.setRenderTarget(normalTarget);
+		renderer.setClearColor(7829503, 1);
+		renderer.autoClear = true;
+		this.scene.overrideMaterial = this.normalMaterial;
+		renderer.render(this.scene, this.camera);
+		this.scene.overrideMaterial = previousOverride;
+		renderer.setClearColor(previousClearColor, previousClearAlpha);
+		renderer.autoClear = previousAutoClear;
+		const uniforms = this.edgeMaterial.uniforms;
+		uniforms.tDiffuse.value = readBuffer.texture;
+		uniforms.tNormal.value = normalTarget.texture;
+		uniforms.tDepth.value = normalTarget.depthTexture;
+		uniforms.uResolution.value.set(this.width, this.height);
+		const perspective = this.camera;
+		uniforms.uPerspective.value = perspective.isPerspectiveCamera ? 1 : 0;
+		uniforms.uNear.value = this.camera.near ?? .1;
+		uniforms.uFar.value = this.camera.far ?? 1e3;
+		renderer.setRenderTarget(this.renderToScreen ? null : writeBuffer);
+		this.fsQuad.render(renderer);
+		renderer.setRenderTarget(previousTarget);
+	}
+	dispose() {
+		this.normalTarget?.dispose();
+		this.normalMaterial.dispose();
+		this.edgeMaterial.dispose();
+		this.fsQuad.dispose();
+	}
+};
+// src/render/render-pipeline.ts
+/**
+* A highlight beside a point light overflows the half-float target to infinity, and bloom's blur
+* turns that one pixel into NaN across the whole frame: the viewer goes blank. Clamping first keeps
+* a hot pixel hot without letting it reach the blur.
+*/
+const HDR_CLAMP_SHADER = {
+	name: "HdrClamp",
+	uniforms: { tDiffuse: { value: null } },
+	vertexShader: `
+		varying vec2 vUv;
+		void main() {
+			vUv = uv;
+			gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+		}`,
+	fragmentShader: `
+		uniform sampler2D tDiffuse;
+		varying vec2 vUv;
+		const float MAX_RADIANCE = 64.0;
+		float safe(float v) {
+			return isnan(v) ? 0.0 : clamp(v, 0.0, MAX_RADIANCE);
+		}
+		void main() {
+			vec4 color = texture2D(tDiffuse, vUv);
+			gl_FragColor = vec4(safe(color.r), safe(color.g), safe(color.b), color.a);
+		}`
+};
+const AVERAGE_SHADER = {
+	vertexShader: `
+		varying vec2 vUv;
+		void main() {
+			vUv = uv;
+			gl_Position = vec4(position.xy, 0.0, 1.0);
+		}`,
+	fragmentShader: `
+		uniform sampler2D tFrame;
+		varying vec2 vUv;
+		void main() {
+			gl_FragColor = texture2D(tFrame, vUv);
+		}`
+};
+/**
+* Keeps the running average of the composer's finished frames. They're already tone mapped, which
+* suits what gets averaged here: shadows and edges, not HDR highlights. Half float, because 32
+* frames blended into 8 bits would band in a soft shadow.
+*/
+function createAccumulator(renderer) {
+	const target = new THREE.WebGLRenderTarget(1, 1, {
+		type: THREE.HalfFloatType,
+		depthBuffer: false
+	});
+	const material = new THREE.ShaderMaterial({
+		...AVERAGE_SHADER,
+		uniforms: { tFrame: { value: null } },
+		depthTest: false,
+		depthWrite: false,
+		toneMapped: false,
+		blending: THREE.CustomBlending,
+		blendSrc: THREE.ConstantAlphaFactor,
+		blendDst: THREE.OneMinusConstantAlphaFactor
+	});
+	const quad = new FullScreenQuad(material);
+	const draw = (texture, weight) => {
+		material.uniforms.tFrame.value = texture;
+		material.blendAlpha = weight;
+		const autoClear = renderer.autoClear;
+		renderer.autoClear = false;
+		quad.render(renderer);
+		renderer.autoClear = autoClear;
+	};
+	const present = () => {
+		renderer.setRenderTarget(null);
+		draw(target.texture, 1);
+	};
+	return {
+		add: (frame, index, width, height) => {
+			if (target.width !== width || target.height !== height) target.setSize(width, height);
+			renderer.setRenderTarget(target);
+			draw(frame, 1 / (index + 1));
+			present();
+		},
+		present,
+		dispose: () => {
+			target.dispose();
+			material.dispose();
+			quad.dispose();
+		}
+	};
+}
+/**
+* Without MSAA a sub-pixel feature (a sheet's bright hem edge) comes out as a dashed line, which
+* SMAA can't rebuild. At 2× DPR each CSS pixel already holds four samples, and 4× MSAA on top
+* would cost ~250 MB on a 4K target for no visible gain.
+*/
+function msaaSamplesFor(pixelRatio) {
+	return pixelRatio >= 2 ? 0 : 4;
+}
+function createRenderPipeline(renderer, scene, camera, width, height, options) {
+	const sceneTarget = new THREE.WebGLRenderTarget(width, height, { type: THREE.HalfFloatType });
+	const composer = new EffectComposer(renderer, sceneTarget);
+	composer.renderTarget2.samples = 0;
+	const renderFrame = (deltaTime) => {
+		composer.readBuffer = sceneTarget;
+		composer.writeBuffer = composer.renderTarget2;
+		composer.render(deltaTime);
+	};
+	const renderPass = new RenderPass(scene, camera);
+	composer.addPass(renderPass);
+	let gtaoPass = null;
+	if (options.ambientOcclusion ?? true) {
+		gtaoPass = new GTAOPass(scene, camera, width, height);
+		gtaoPass.blendIntensity = options.aoIntensity ?? 1;
+		gtaoPass.updateGtaoMaterial({ screenSpaceRadius: true });
+		composer.addPass(gtaoPass);
+	}
+	let clampPass = null;
+	let bloomPass = null;
+	if (options.bloom) {
+		const { strength, radius, threshold } = options.bloom;
+		clampPass = new ShaderPass(HDR_CLAMP_SHADER);
+		composer.addPass(clampPass);
+		bloomPass = new UnrealBloomPass(new THREE.Vector2(width, height), strength, radius, threshold);
+		composer.addPass(bloomPass);
+	}
+	const edgePass = new EdgeDetectionPass(scene, camera, width, height, typeof options.edgeDetection === "object" ? options.edgeDetection : {});
+	edgePass.enabled = !!options.edgeDetection;
+	composer.addPass(edgePass);
+	const smaaPass = new SMAAPass();
+	composer.addPass(smaaPass);
+	const outputPass = new OutputPass();
+	composer.addPass(outputPass);
+	renderer.toneMapping = options.toneMapping;
+	renderer.toneMappingExposure = options.toneMappingExposure;
+	let accumulator = null;
+	const aoPixelRatioCap = options.aoPixelRatio ?? 1;
+	let aoScale = 1;
+	if (gtaoPass) {
+		const setAoSize = gtaoPass.setSize.bind(gtaoPass);
+		gtaoPass.setSize = (w, h) => setAoSize(Math.max(1, Math.round(w * aoScale)), Math.max(1, Math.round(h * aoScale)));
+	}
+	const applyPixelRatio = (pixelRatio) => {
+		aoScale = Math.min(pixelRatio, aoPixelRatioCap) / pixelRatio;
+		const samples = msaaSamplesFor(pixelRatio);
+		if (sceneTarget.samples !== samples) {
+			sceneTarget.samples = samples;
+			sceneTarget.dispose();
+		}
+		composer.setPixelRatio(pixelRatio);
+	};
+	applyPixelRatio(renderer.getPixelRatio());
+	composer.setSize(width, height);
+	return {
+		render: renderFrame,
+		setSize: (w, h, pixelRatio) => {
+			applyPixelRatio(pixelRatio);
+			composer.setSize(w, h);
+		},
+		setCamera: (cam) => {
+			renderPass.camera = cam;
+			edgePass.camera = cam;
+			if (!gtaoPass) return;
+			gtaoPass.camera = cam;
+			const isPerspective = cam.isPerspectiveCamera ? 1 : 0;
+			if (gtaoPass.gtaoMaterial.defines.PERSPECTIVE_CAMERA !== isPerspective) {
+				gtaoPass.gtaoMaterial.defines.PERSPECTIVE_CAMERA = isPerspective;
+				gtaoPass.gtaoMaterial.needsUpdate = true;
+			}
+		},
+		setEdgeDetection: (enabled) => {
+			edgePass.enabled = enabled;
+		},
+		edgeDetectionEnabled: () => edgePass.enabled,
+		accumulate: (index) => {
+			composer.renderToScreen = false;
+			renderFrame(0);
+			composer.renderToScreen = true;
+			accumulator ??= createAccumulator(renderer);
+			const { texture, width, height } = composer.readBuffer;
+			accumulator.add(texture, index, width, height);
+		},
+		presentAccumulated: () => accumulator?.present(),
+		setAoWeight: (weight) => {
+			if (!gtaoPass) return;
+			gtaoPass.enabled = weight > 0;
+			gtaoPass.blendIntensity = (options.aoIntensity ?? 1) * weight;
+		},
+		dispose: () => {
+			composer.dispose();
+			accumulator?.dispose();
+			gtaoPass?.dispose();
+			clampPass?.dispose();
+			bloomPass?.dispose();
+			edgePass.dispose();
+			smaaPass.dispose();
+			outputPass.dispose();
+		}
+	};
+}
+// src/render/scene-setup/pipeline-controller.ts
+function createPipelineController(params) {
+	const { renderer, scene, getActiveCamera, getCanvasSize, config, requestRender } = params;
+	let pipeline = null;
+	let aoEnabled = !!config.render.ambientOcclusion;
+	let edgeFallbackActive = false;
+	const bakedOptions = () => ({
+		ambientOcclusion: aoEnabled,
+		bloom: config.render.bloom,
+		toneMapping: config.render.toneMapping,
+		toneMappingExposure: config.render.toneMappingExposure
+	});
+	let baked = bakedOptions();
+	const isStale = () => {
+		const wanted = bakedOptions();
+		return wanted.ambientOcclusion !== baked.ambientOcclusion || wanted.bloom !== baked.bloom || wanted.toneMapping !== baked.toneMapping || wanted.toneMappingExposure !== baked.toneMappingExposure;
+	};
+	const build = () => {
+		const { width, height } = getCanvasSize();
+		const built = createRenderPipeline(renderer, scene, getActiveCamera(), Math.max(1, width), Math.max(1, height), {
+			toneMapping: config.render.toneMapping ?? THREE.NeutralToneMapping,
+			toneMappingExposure: config.render.toneMappingExposure ?? 1,
+			ambientOcclusion: aoEnabled,
+			aoIntensity: config.render.aoIntensity,
+			aoPixelRatio: config.render.aoPixelRatio,
+			bloom: config.render.bloom,
+			edgeDetection: false
+		});
+		built.setSize(Math.max(1, width), Math.max(1, height), config.render.pixelRatio);
+		return built;
+	};
+	const sync = () => {
+		if (!(aoEnabled || edgeFallbackActive || !!config.render.bloom)) {
+			pipeline?.dispose();
+			pipeline = null;
+			requestRender();
+			return;
+		}
+		if (!pipeline || isStale()) {
+			pipeline?.dispose();
+			pipeline = build();
+			baked = bakedOptions();
+		}
+		pipeline.setEdgeDetection(edgeFallbackActive);
+		requestRender();
+	};
+	return {
+		get: () => pipeline,
+		sync,
+		rebuild: () => {
+			pipeline?.dispose();
+			pipeline = null;
+			sync();
+		},
+		setAmbientOcclusion: (enabled) => {
+			aoEnabled = enabled;
+			sync();
+		},
+		setEdgeFallback: (active) => {
+			if (active === edgeFallbackActive) return;
+			edgeFallbackActive = active;
+			sync();
+		},
+		isEdgeFallbackActive: () => edgeFallbackActive,
+		dispose: () => {
+			pipeline?.dispose();
+			pipeline = null;
+		}
+	};
+}
+// src/render/scene-setup/setup-controls.ts
+function setupControls(camera, canvas, config) {
+	const controls = new OrbitControls(camera, canvas);
+	const target = config.camera.target;
+	if (target) controls.target.set(target.x, target.y, target.z);
+	controls.enableDamping = config.controls.enableDamping || false;
+	controls.dampingFactor = config.controls.dampingFactor || .05;
+	controls.autoRotate = config.controls.autoRotate || false;
+	controls.autoRotateSpeed = config.controls.autoRotateSpeed || .5;
+	controls.enableZoom = config.controls.enableZoom ?? true;
+	controls.enablePan = config.controls.enablePan ?? true;
+	controls.minDistance = config.controls.minDistance || .001;
+	controls.maxDistance = config.controls.maxDistance || Infinity;
+	controls.screenSpacePanning = false;
+	controls.maxPolarAngle = Math.PI;
+	controls.update();
+	return controls;
+}
+// src/render/scene-setup/setup-environment.ts
+function setupEnvironment(scene, renderer, config, isDisposed) {
+	if (config.environment.enableEnvironmentLighting) {
+		createReflectionEnvironment(scene, renderer, environmentRotationFor(config.environment.sceneUp ?? defaultUp));
+		new HDRLoader().load(config.environment.hdrPath || "/baseHDR.hdr", function(envMap) {
+			if (isDisposed()) {
+				envMap.dispose();
+				return;
+			}
+			if (!envMap?.image) {
+				getLogger().warn("HDR loaded without image data; skipping environment map.");
+				envMap?.dispose();
+				config.events.onReady?.();
+				return;
+			}
+			envMap.mapping = THREE.EquirectangularReflectionMapping;
+			const pmrem = new THREE.PMREMGenerator(renderer);
+			pmrem.compileEquirectangularShader();
+			const prefiltered = pmrem.fromEquirectangular(envMap).texture;
+			pmrem.dispose();
+			scene.environment = prefiltered;
+			scene.environmentIntensity = config.environment.environmentIntensity ?? 1;
+			const envRotation = environmentRotationFor(config.environment.sceneUp ?? defaultUp);
+			scene.environmentRotation.copy(envRotation);
+			if (config.environment.showEnvironment) {
+				scene.background = envMap;
+				scene.backgroundRotation.copy(envRotation);
+			} else envMap.dispose();
+			config.events.onReady?.();
+		}, void 0, function(error) {
+			if (isDisposed()) return;
+			getLogger().warn("HDR texture could not be loaded, falling back to basic lighting:", error);
+			config.events.onReady?.();
+		});
+	} else config.events.onReady?.();
+}
+function addFloor(scene, config) {
+	const floorSize = config.floor.size;
+	const floorGeometry = new THREE.PlaneGeometry(floorSize, floorSize);
+	const floorColor = typeof config.floor.color === "string" ? new THREE.Color(config.floor.color) : config.floor.color;
+	const floorMaterial = new THREE.MeshStandardMaterial({
+		color: floorColor,
+		roughness: config.floor.roughness,
+		metalness: config.floor.metalness,
+		side: THREE.DoubleSide
+	});
+	const floor = new THREE.Mesh(floorGeometry, floorMaterial);
+	floor.userData.id = "floor";
+	floor.name = "floor";
+	const up = (config.environment?.sceneUp || defaultUp).clone().normalize();
+	floor.quaternion.setFromUnitVectors(new THREE.Vector3(0, 0, 1), up);
+	floor.position.set(0, 0, 0);
+	if (config.floor.receiveShadow && config.render.enableShadows) floor.receiveShadow = true;
+	scene.add(floor);
+}
+// src/render/scene-setup/setup-events.ts
+/** How far the base color moves toward the selection color. 1 would discard the texture underneath. */
+const SELECTION_COLOR_MIX = .75;
+/** Above ~2 the tint clips to pure red and the geometry's shading disappears with it. */
+const SELECTION_EMISSIVE_INTENSITY = .6;
+/** A metallic surface reflects the environment rather than showing its albedo tint. */
+const SELECTION_MAX_METALNESS = .2;
+/** Below this a highlight reads as a ghost, so the selection is forced opaque. */
+const SELECTION_MIN_OPACITY = 1;
+/**
+* Lighter than the default selection red on purpose: amber and red are close hues under red-green
+* color blindness, so what tells hover from selected there is brightness.
+*/
+const HOVER_COLOR = "#ffb020";
+/** Linear RGB distance. Closer than this, a tint barely changes the surface. */
+const MIN_TINT_DISTANCE = .35;
+/** Taken by a surface already close to the tint. Blue stays distinct under every common deficiency. */
+const FALLBACK_TINT = new THREE.Color("#2f7bff");
+function readableTint(material, tint) {
+	const base = material.color;
+	if (!base) return tint;
+	return Math.hypot(base.r - tint.r, base.g - tint.g, base.b - tint.b) < MIN_TINT_DISTANCE ? FALLBACK_TINT : tint;
+}
+/**
+* Recolors a material clone to mark it selected. Exported for tests: the highlight reads against
+* whatever the active look does to lighting, and that coupling has broken it silently before.
+*
+* Meshes tint via `emissive` AND base color. Emissive alone is additive on top of what the surface
+* already reflects, so on a bright white model under a key light it only shifts the surface slightly
+* pink — the brighter the look, the weaker the highlight. Moving the albedo toward the selection
+* color is what makes it hold at any exposure; the emissive on top keeps it reading as lit rather
+* than as a flat sticker in shadowed areas. Lines/points have no emissive channel, so their `color`
+* is replaced outright.
+*
+* Mutates `material` in place — pass a clone, never a material the scene still shares.
+*/
+function tintForSelection(material, color, isMesh) {
+	const selectionColor = readableTint(material, color);
+	if (isMesh && "emissive" in material) {
+		const mesh = material;
+		mesh.emissive = selectionColor.clone();
+		mesh.emissiveIntensity = SELECTION_EMISSIVE_INTENSITY;
+		mesh.color.lerp(selectionColor, SELECTION_COLOR_MIX);
+		mesh.metalness = Math.min(mesh.metalness, SELECTION_MAX_METALNESS);
+		if (mesh.opacity < SELECTION_MIN_OPACITY) {
+			mesh.opacity = SELECTION_MIN_OPACITY;
+			mesh.transparent = false;
+			mesh.depthWrite = true;
+		}
+		return;
+	}
+	if ("color" in material) material.color = selectionColor.clone();
+}
+function setupEventHandlers(canvas, scene, cameraController, config) {
+	const selectedObjects = /* @__PURE__ */ new Set();
+	const originalMaterials = /* @__PURE__ */ new Map();
+	const memberHighlights = [];
+	/** Which member of a merged mesh is selected, so a click on a sibling isn't a no-op. */
+	let selectedMemberIndex = null;
+	let selectedByEntries = false;
+	const raycaster = new THREE.Raycaster();
+	const mouse = new THREE.Vector2();
+	const mouseDownPosition = new THREE.Vector2();
+	const getActiveCamera = () => cameraController.getActiveCamera();
+	const isFullyVisible = (object) => {
+		let current = object;
+		while (current) {
+			if (!current.visible) return false;
+			current = current.parent;
+		}
+		return true;
+	};
+	const fitToView = () => {
+		const box = computeContentBounds(scene);
+		if (box.isEmpty()) {
+			getLogger().warn("No objects to fit to view");
+			return;
+		}
+		cameraController.frameBounds(box, false);
+	};
+	const selectionColorObj = typeof config.events.selectionColor === "string" ? new THREE.Color(config.events.selectionColor) : config.events.selectionColor instanceof THREE.Color ? config.events.selectionColor : new THREE.Color("#ff0000");
+	const hoverColorObj = new THREE.Color(HOVER_COLOR);
+	let hoverObject = null;
+	let hoverOriginal = null;
+	let hoverMember = null;
+	const disposeIfDetached = (object, original) => {
+		let root = object;
+		while (root.parent) root = root.parent;
+		if (root === scene) return;
+		if (original instanceof THREE.Material) original.dispose();
+		else original.forEach((m) => m.dispose());
+	};
+	const clearHover = () => {
+		hoverMember?.restore();
+		hoverMember?.material.dispose();
+		hoverMember = null;
+		if (hoverObject && hoverOriginal) {
+			const clone = hoverObject.material;
+			if (clone instanceof THREE.Material) clone.dispose();
+			hoverObject.material = hoverOriginal;
+			disposeIfDetached(hoverObject, hoverOriginal);
+		}
+		hoverObject = null;
+		hoverOriginal = null;
+	};
+	/**
+	* Previews an outliner row in the viewport. Fires no events, and yields to a selection already
+	* tinting the same thing.
+	*/
+	const setHover = (object, memberIndex = null) => {
+		clearHover();
+		if (!object) return;
+		if (memberIndex !== null && object instanceof THREE.Mesh) {
+			const material = getBaseMaterial(object).clone();
+			tintForSelection(material, hoverColorObj, true);
+			hoverMember = {
+				restore: highlightMembers(object, /* @__PURE__ */ new Set([memberIndex]), material, "hover"),
+				material
+			};
+			return;
+		}
+		if (selectedObjects.has(object)) return;
+		const target = object;
+		if (!(target.material instanceof THREE.Material)) return;
+		const clone = cloneForTint(target.material);
+		tintForSelection(clone, hoverColorObj, object instanceof THREE.Mesh);
+		hoverObject = target;
+		hoverOriginal = target.material;
+		target.material = clone;
+	};
+	const clearSelection = () => {
+		for (const { restore, material } of memberHighlights) {
+			restore();
+			material.dispose();
+		}
+		memberHighlights.length = 0;
+		selectedObjects.forEach((obj) => {
+			const restorable = obj;
+			if (originalMaterials.has(obj)) {
+				const original = originalMaterials.get(obj);
+				const clone = restorable.material;
+				if (clone instanceof THREE.Material) clone.dispose();
+				else if (Array.isArray(clone)) clone.forEach((m) => m.dispose());
+				restorable.material = original;
+				originalMaterials.delete(obj);
+				disposeIfDetached(obj, original);
+			}
+		});
+		selectedObjects.clear();
+		selectedMemberIndex = null;
+		selectedByEntries = false;
+	};
+	/**
+	* Tints the picked object. On a merged mesh only the given members are tinted, so clicking one
+	* wall doesn't light up every wall sharing its material — see `merged-picking.ts`.
+	*/
+	const applyHighlight = (object, members) => {
+		if (members && object instanceof THREE.Mesh) {
+			const clone = getBaseMaterial(object).clone();
+			tintForSelection(clone, selectionColorObj, true);
+			memberHighlights.push({
+				restore: highlightMembers(object, members, clone),
+				material: clone
+			});
+			return true;
+		}
+		const target = object;
+		if (!(target.material instanceof THREE.Material)) return false;
+		const clone = cloneForTint(target.material);
+		tintForSelection(clone, selectionColorObj, object instanceof THREE.Mesh);
+		originalMaterials.set(object, target.material);
+		target.material = clone;
+		return true;
+	};
+	/**
+	* Selection made outside the viewport. An empty list only drops such a selection, so a host
+	* syncing its own empty state can't wipe what a click on the canvas just selected.
+	*/
+	const selectEntries = (targets) => {
+		if (targets.length === 0 && !selectedByEntries) return;
+		clearHover();
+		clearSelection();
+		const membersByMesh = /* @__PURE__ */ new Map();
+		for (const { object, memberIndex } of targets) {
+			if (memberIndex === null) {
+				selectedObjects.add(object);
+				applyHighlight(object, null);
+				continue;
+			}
+			let members = membersByMesh.get(object);
+			if (!members) membersByMesh.set(object, members = /* @__PURE__ */ new Set());
+			members.add(memberIndex);
+		}
+		for (const [object, members] of membersByMesh) {
+			selectedObjects.add(object);
+			applyHighlight(object, members);
+		}
+		selectedByEntries = targets.length > 0;
+	};
+	let cachedDiagonal = null;
+	let cachedChildCount = -1;
+	const updatePickThresholds = () => {
+		if (cachedDiagonal === null || scene.children.length !== cachedChildCount) {
+			const box = computeContentBounds(scene);
+			cachedDiagonal = box.isEmpty() ? 1 : box.getSize(new THREE.Vector3()).length();
+			cachedChildCount = scene.children.length;
+		}
+		raycaster.params.Points.threshold = cachedDiagonal * .01;
+	};
+	/**
+	* Nearest visible, pickable object under the pointer, or null. Viewer aids are excluded: the grid
+	* is a huge camera-following plane, so double-clicking through a thin curve onto it would frame a
+	* box the size of the fade radius and fling the camera out.
+	*/
+	const pickAt = (clientX, clientY) => {
+		const rect = canvas.getBoundingClientRect();
+		mouse.x = (clientX - rect.left) / rect.width * 2 - 1;
+		mouse.y = -((clientY - rect.top) / rect.height) * 2 + 1;
+		updatePickThresholds();
+		raycaster.setFromCamera(mouse, getActiveCamera());
+		for (const hit of raycaster.intersectObjects(scene.children, true)) if (isFullyVisible(hit.object) && !isViewerAid(hit.object)) return hit;
+		return null;
+	};
+	const handleMouseDown = (event) => {
+		mouseDownPosition.set(event.clientX, event.clientY);
+	};
+	const handleCanvasClick = (event) => {
+		const currentMousePosition = new THREE.Vector2(event.clientX, event.clientY);
+		if (mouseDownPosition.distanceTo(currentMousePosition) > 5) return;
+		const hit = pickAt(event.clientX, event.clientY);
+		if (!hit) {
+			clearSelection();
+			config.events?.onBackgroundClicked?.({
+				x: mouse.x,
+				y: mouse.y
+			});
+			return;
+		}
+		const clickedObject = hit.object;
+		const resolved = resolveHitMember(hit);
+		const hitMemberIndex = resolved?.index ?? null;
+		if (!selectedByEntries && selectedObjects.has(clickedObject) && hitMemberIndex === selectedMemberIndex) return;
+		clearHover();
+		clearSelection();
+		selectedObjects.add(clickedObject);
+		selectedMemberIndex = hitMemberIndex;
+		applyHighlight(clickedObject, resolved ? /* @__PURE__ */ new Set([resolved.index]) : null);
+		config.events?.onObjectSelected?.(clickedObject);
+		if (resolved) config.events?.onMeshMetadataClicked?.({
+			source: clickedObject.userData?.source,
+			name: resolved.member.name,
+			layer: resolved.member.layer,
+			trackingKey: resolved.member.trackingKey,
+			metadata: resolved.member.metadata
+		});
+		else if (clickedObject instanceof THREE.Mesh && Object.keys(clickedObject.userData).length > 0) config.events?.onMeshMetadataClicked?.(clickedObject.userData);
+	};
+	const handleDoubleClick = (event) => {
+		const hit = pickAt(event.clientX, event.clientY);
+		if (!hit) {
+			if (config.events?.enableDoubleClickZoom) cameraController.frameBounds(computeContentBounds(scene), true);
+			return;
+		}
+		const target = hit.object;
+		config.events?.onMeshDoubleClicked?.(target);
+		if (!config.events?.enableDoubleClickZoom) return;
+		const resolved = resolveHitMember(hit);
+		const box = resolved && target instanceof THREE.Mesh ? memberBounds(target, resolved.member) : new THREE.Box3().setFromObject(target);
+		if (box.isEmpty()) return;
+		cameraController.frameBounds(box, true);
+	};
+	const handleKeydown = (event) => {
+		if (!config.events?.enableKeyboardControls) return;
+		switch (event.key.toLowerCase()) {
+			case "f":
+				event.preventDefault();
+				fitToView();
+				break;
+			case "escape":
+				event.preventDefault();
+				clearSelection();
+				break;
+			case " ":
+				event.preventDefault();
+				fitToView();
+		}
+	};
+	if (config.events?.enableClickToFocus) {
+		canvas.addEventListener("mousedown", handleMouseDown);
+		canvas.addEventListener("click", handleCanvasClick);
+		canvas.addEventListener("dblclick", handleDoubleClick);
+	}
+	if (config.events?.enableKeyboardControls) {
+		canvas.setAttribute("tabindex", "0");
+		canvas.addEventListener("keydown", handleKeydown);
+	}
+	const dispose = () => {
+		canvas.removeEventListener("mousedown", handleMouseDown);
+		canvas.removeEventListener("click", handleCanvasClick);
+		canvas.removeEventListener("dblclick", handleDoubleClick);
+		canvas.removeEventListener("keydown", handleKeydown);
+		clearHover();
+		clearSelection();
+	};
+	return {
+		dispose,
+		fitToView,
+		clearSelection,
+		selectEntries,
+		setHover
+	};
+}
+// src/render/scene-setup/setup-renderer.ts
+function setupRenderer(canvas, config, pixelRatio) {
+	const renderer = new THREE.WebGLRenderer({
+		antialias: config.render.antialias,
+		canvas,
+		alpha: true,
+		powerPreference: "high-performance",
+		preserveDrawingBuffer: config.render.preserveDrawingBuffer,
+		logarithmicDepthBuffer: false
+	});
+	const parent = canvas.parentElement;
+	const width = parent ? parent.clientWidth : window.innerWidth;
+	const height = parent ? parent.clientHeight : window.innerHeight;
+	if (parent) {
+		canvas.style.width = "100%";
+		canvas.style.height = "100%";
+		canvas.style.display = "block";
+	}
+	renderer.setSize(width, height, false);
+	renderer.setPixelRatio(pixelRatio);
+	if (config.render.enableShadows) {
+		renderer.shadowMap.enabled = true;
+		renderer.shadowMap.type = THREE.VSMShadowMap;
+	}
+	renderer.toneMapping = config.render.toneMapping;
+	renderer.toneMappingExposure = config.render.toneMappingExposure ?? 1;
+	renderer.outputColorSpace = THREE.SRGBColorSpace;
+	renderer.sortObjects = true;
+	return renderer;
+}
+// src/render/scene-setup/init-three.ts
+const initThree = function(canvas, options) {
+	const config = applyDefaults(options || {});
+	const sceneUp = config.environment?.sceneUp || defaultUp;
+	const fullPixelRatio = config.render.pixelRatio ?? Math.min(window.devicePixelRatio, 2);
+	const pixelRatio = lookPixelRatio(fullPixelRatio, lookPreset(config.look, config.render.lowPower));
+	config.render.pixelRatio = pixelRatio;
+	const scene = createScene(config);
+	const camera = createCamera(config, canvas);
+	camera.up.copy(sceneUp);
+	const renderer = setupRenderer(canvas, config, pixelRatio);
+	publishMaxAnisotropy(renderer.capabilities.getMaxAnisotropy());
+	options?.onMaxAnisotropy?.(renderer.capabilities.getMaxAnisotropy());
+	const controls = setupControls(camera, canvas, config);
+	const cameraController = createCameraController({
+		scene,
+		perspective: camera,
+		controls,
+		onActiveCameraChange: () => {},
+		up: sceneUp
+	});
+	const getActiveCamera = () => cameraController.getActiveCamera();
+	let disposed = false;
+	setupEnvironment(scene, renderer, config, () => disposed);
+	const lights = setupLighting(scene, config);
+	const sunlight = lights.sun;
+	const updateShadowBounds = () => {
+		if (sunlight) fitShadowToContent(sunlight, computeContentBounds(scene));
+	};
+	if (config.floor?.enabled) addFloor(scene, config);
+	const floorMesh = config.floor?.enabled ? scene.children.find((child) => child.userData.id === "floor") ?? null : null;
+	const grid = config.grid.enabled ? createGrid({
+		cellSize: config.grid.cellSize,
+		majorEvery: config.grid.majorEvery,
+		cellColor: config.grid.cellColor,
+		majorColor: config.grid.majorColor,
+		fadeDistance: config.grid.fadeDistance,
+		plane: config.grid.plane
+	}) : null;
+	if (grid) scene.add(grid.object);
+	const updateGridScale = () => {
+		if (grid) grid.fitToContent(computeContentBounds(scene));
+	};
+	const gizmo = config.gizmo.enabled ? createViewGizmo({
+		camera,
+		domElement: canvas,
+		controller: cameraController
+	}) : null;
+	const gridPlane = config.grid.plane ?? upToAxis(sceneUp);
+	const gridNormal = new THREE.Vector3(gridPlane === "x" ? 1 : 0, gridPlane === "y" ? 1 : 0, gridPlane === "z" ? 1 : 0);
+	const floorNormal = sceneUp.clone().normalize();
+	const groundNormals = () => {
+		const normals = [];
+		if (grid?.object.visible) normals.push(gridNormal);
+		if (config.floor.enabled && floorMesh?.visible) normals.push(floorNormal);
+		return normals;
+	};
+	const nearFitter = config.camera.dynamicNear ? createNearPlaneFitter({
+		camera,
+		scene,
+		groundNormals
+	}) : null;
+	const labelLayer = createLabelLayer(canvas.parentElement ?? canvas, scene);
+	const measureTool = config.measure.enabled ? createMeasureTool({
+		canvas,
+		scene,
+		getActiveCamera,
+		getViewTarget: () => controls.target,
+		requestRender: () => requestRender(),
+		labelLayer,
+		options: {
+			snapPixels: config.measure.snapPixels,
+			color: config.measure.color,
+			labelClassName: config.measure.labelClassName,
+			displayUnit: config.measure.displayUnit,
+			format: config.measure.format
+		}
+	}) : null;
+	const eventHandlers = config.events.enableEventHandlers !== false ? setupEventHandlers(canvas, scene, cameraController, config) : {
+		dispose: () => {},
+		fitToView: () => {},
+		clearSelection: () => {},
+		selectEntries: () => {},
+		setHover: () => {}
+	};
+	const tools = createToolRegistry();
+	if (measureTool) tools.register({
+		id: "measure",
+		tool: measureTool,
+		priority: 0
+	});
+	if (gizmo) tools.register({
+		id: "gizmo",
+		tool: gizmo,
+		priority: -100
+	});
+	const DRAG_SLOP_PX = 5;
+	let pressX = 0;
+	let pressY = 0;
+	const handlePointerDown = (event) => {
+		pressX = event.clientX;
+		pressY = event.clientY;
+	};
+	const wasDrag = (event) => Math.hypot(event.clientX - pressX, event.clientY - pressY) > DRAG_SLOP_PX;
+	const handleToolClick = (event) => {
+		if (wasDrag(event)) return;
+		if (tools.handleClick(event)) event.stopImmediatePropagation();
+	};
+	canvas.addEventListener("mousedown", handlePointerDown, { capture: true });
+	canvas.addEventListener("click", handleToolClick, { capture: true });
+	const handleToolMove = (event) => tools.handleMove(event);
+	canvas.addEventListener("mousemove", handleToolMove, { passive: true });
+	let requestRender = () => {};
+	const applyEdges = (root, overrides) => {
+		addEdgesAsync(root, {
+			color: config.edges.color,
+			darken: config.edges.darken,
+			width: config.edges.width,
+			thresholdAngle: config.edges.thresholdAngle,
+			distanceFade: config.edges.distanceFade,
+			maxTriangles: config.edges.maxTriangles,
+			maxSegments: config.edges.maxSegments,
+			maxOverlays: config.edges.maxOverlays,
+			...overrides
+		}).then(() => {
+			updateEdgeFallback(root);
+			requestRender();
+		});
+	};
+	const updateEdgeFallback = (root) => {
+		if (config.edges.screenSpaceFallback === false) return;
+		let hasSkippedMeshes = false;
+		root.traverse((object) => {
+			const skipped = object.userData?.edgesSkipped;
+			if (skipped === "triangle-cap" || skipped === "overlay-budget") hasSkippedMeshes = true;
+		});
+		pipeline.setEdgeFallback(hasSkippedMeshes);
+	};
+	const clearEdges = (root) => {
+		removeEdges(root);
+		pipeline.setEdgeFallback(false);
+		requestRender();
+	};
+	const parent = canvas.parentElement;
+	const getCanvasSize = () => parent ? {
+		width: parent.clientWidth,
+		height: parent.clientHeight
+	} : {
+		width: window.innerWidth,
+		height: window.innerHeight
+	};
+	const pipeline = createPipelineController({
+		renderer,
+		scene,
+		getActiveCamera,
+		getCanvasSize,
+		config,
+		requestRender: () => requestRender()
+	});
+	pipeline.sync();
+	const appearance = createAppearanceController({
+		scene,
+		renderer,
+		lights,
+		config,
+		pipeline,
+		fullPixelRatio,
+		requestRender: () => requestRender()
+	});
+	let restoreSun;
+	const refiner = createIdleRefiner({
+		scene,
+		renderer,
+		getPipeline: () => pipeline.get(),
+		frames: config.render.idleRefineFrames,
+		lightOrbitFrameMs: config.render.lightOrbitFrameMs,
+		jitterLights: (index) => {
+			if (sunlight) restoreSun = jitterSun(sunlight, index);
+			appearance.jitterEmissiveLights(index);
+		},
+		restoreLights: () => {
+			restoreSun?.();
+			appearance.settleEmissiveLights();
+		}
+	});
+	const { animate, dispose: disposeAnimation, invalidate, renderNow } = createAnimationLoop(renderer, scene, camera, getActiveCamera, cameraController, controls, getCanvasSize, () => config.render.pixelRatio, config.events.onFrame, grid, gizmo, () => pipeline.get(), labelLayer, nearFitter, config.render.onDemand ?? true, refiner);
+	requestRender = invalidate;
+	animate();
+	scene.up.set(sceneUp.x, sceneUp.y, sceneUp.z);
+	updateShadowBounds();
+	updateGridScale();
+	const captureImage = (type = "image/png", quality) => {
+		renderNow();
+		return new Promise((resolve) => renderer.domElement.toBlob(resolve, type, quality));
+	};
+	const addUserGeometry = (object, appId) => {
+		object.userData.source = appId === void 0 ? SOURCE_USER : appSource(appId);
+		scene.add(object);
+		requestRender();
+	};
+	const removeUserGeometry = (object) => {
+		object.removeFromParent();
+		disposeObjectTree(object);
+		requestRender();
+	};
+	const clearUserGeometry = (appId) => {
+		scene.children.filter((child) => isOwnedBy(child, appId)).forEach((object) => {
+			object.removeFromParent();
+			disposeObjectTree(object);
+		});
+		requestRender();
+	};
+	const dispose = () => {
+		if (disposed) return;
+		disposed = true;
+		disposeAnimation();
+		eventHandlers.dispose();
+		canvas.removeEventListener("mousedown", handlePointerDown, { capture: true });
+		canvas.removeEventListener("click", handleToolClick, { capture: true });
+		canvas.removeEventListener("mousemove", handleToolMove);
+		measureTool?.dispose();
+		labelLayer?.dispose();
+		gizmo?.dispose();
+		grid?.dispose();
+		pipeline.dispose();
+		cameraController.dispose();
+		controls.dispose();
+		renderer.dispose();
+		renderer.forceContextLoss();
+		disposeSceneResources(scene);
+	};
+	return {
+		scene,
+		camera,
+		controls,
+		renderer,
+		cameraController,
+		grid,
+		gizmo,
+		measureTool,
+		labelLayer,
+		tools,
+		applyEdges,
+		clearEdges,
+		invalidate,
+		captureImage,
+		setAmbientOcclusion: pipeline.setAmbientOcclusion,
+		setLook: appearance.setLook,
+		syncEmissiveLights: appearance.syncEmissiveLights,
+		setFillLights: appearance.setFillLights,
+		setEnvironmentIntensity: appearance.setEnvironmentIntensity,
+		setToneMappingExposure: appearance.setToneMappingExposure,
+		setAoIntensity: appearance.setAoIntensity,
+		getMaterialAppearance: appearance.getMaterialAppearance,
+		updateShadowBounds,
+		updateGridScale,
+		dispose,
+		fitToView: eventHandlers.fitToView,
+		clearSelection: eventHandlers.clearSelection,
+		selectEntries: (targets) => {
+			eventHandlers.selectEntries(targets);
+			invalidate();
+		},
+		setHover: (object, memberIndex) => {
+			eventHandlers.setHover(object, memberIndex);
+			invalidate();
+		},
+		addUserGeometry,
+		removeUserGeometry,
+		clearUserGeometry
+	};
+};
+export { DEFAULT_LOOK, ErrorCodes, LOOKS, LOOK_PRESETS, SOURCE_COMPUTE, SOURCE_USER, VisualizationError, appIdFromSource, appSource, enableDebugLogging, getLogger, initThree, isHostOwned, isOwnedBy, materialAppearanceForLook, pickThreshold, pointerToNdc, setLogger, snapToVertex, updateScene };
+
 //# sourceMappingURL=render.js.map