@selvajs/visualization 1.6.0-beta.7 → 1.6.0-beta.9

package/dist/render.cjs

@@ -1,12 +1,1436 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./gpu-ownership-ilj3JEdn.cjs"),t=require("./gpu-dispose-Cestx__L.cjs"),n=require("./merged-draw-CLtLo5Bh.cjs");let r=require("three");r=e.s(r,1);let i=require("three/addons/lines/Line2.js"),a=require("three/addons/lines/LineGeometry.js"),o=require("three/addons/lines/LineMaterial.js"),s=require("three/addons/environments/RoomEnvironment.js"),c=require("three/addons/lines/LineSegments2.js"),l=require("three/addons/lines/LineSegmentsGeometry.js"),u=require("three/addons/renderers/CSS2DRenderer.js"),d=require("three/addons/helpers/ViewHelper.js"),f=require("three/addons/postprocessing/EffectComposer.js"),p=require("three/addons/postprocessing/RenderPass.js"),m=require("three/addons/postprocessing/GTAOPass.js"),h=require("three/addons/postprocessing/SMAAPass.js"),g=require("three/addons/postprocessing/OutputPass.js"),_=require("three/addons/postprocessing/Pass.js"),v=require("three/addons/controls/OrbitControls.js"),y=require("three/addons/loaders/HDRLoader.js");const b=[`technical`,`studio`,`showcase`,`arctic`,`xray`,`lineart`,`wireframe`],x=`user`,S=`app:`;function C(e){return`${S}${e}`}function w(e){return typeof e!=`string`||!e.startsWith(S)?null:e.slice(4)||null}function T(e){let t=e.userData?.source;return t===`user`||w(t)!==null}function E(e,t){return t===void 0?T(e):e.userData?.source===C(t)}const D=`selvaReflectionEnvironment`;function O(e,t,n){let i=new r.PMREMGenerator(t),a=new s.RoomEnvironment,o=i.fromScene(a,.04).texture;a.dispose(),i.dispose(),k(e,o,n)}function k(e,t,n){let r={texture:t,rotation:n.clone()};e.userData[D]=r,j(e,e)}function A(e){e.userData[D]?.texture.dispose(),delete e.userData[D]}function j(e,t){let n=t.userData[D];n&&e.traverse(e=>{if(e.userData.source!==`compute`)return;let t=e,i=Array.isArray(t.material)?t.material:t.material?[t.material]:[];for(let e of i){if(!(e instanceof r.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 M(e){let t=e.clone().normalize(),n=new r.Vector3(0,0,1),i=new r.Vector3(0,1,0),a=Math.abs(t.dot(n))>.9?i:n,o=new r.Vector3().crossVectors(a,t).normalize();return{up:t,forward:new r.Vector3().crossVectors(t,o).normalize(),right:o}}function N(e,t){let{forward:n,right:r,up:i}=M(e);return n.clone().multiplyScalar(-1).add(r.clone().multiplyScalar(-1)).add(i).normalize().multiplyScalar(t)}function P(e,t,n){let{forward:r,right:i,up:a}=M(e);return i.clone().multiplyScalar(t).add(r.clone().multiplyScalar(t)).add(a.clone().multiplyScalar(n))}function F(e){let t=e.clone().normalize(),n=new r.Vector3(0,1,0);if(t.dot(n)>.9999)return new r.Euler;if(t.dot(n)<-.9999)return new r.Euler(Math.PI,0,0);let i=new r.Quaternion().setFromUnitVectors(n,t);return new r.Euler().setFromQuaternion(i)}function ee(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 I={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 te(e,n,i,a,o){if(B(e,re(n)),n.length===0)return;n.forEach(t=>{e.add(t),j(t,e)});let s=t.a(n),c=s.getCenter(new r.Vector3),l=s.getSize(new r.Vector3),u=Math.max(l.x,l.y,l.z);if(u/Math.min(l.x||1,l.y||1,l.z||1)>I.SCALE_RATIO_THRESHOLD||u>I.HUGE_THRESHOLD?(i.near=u*I.NEAR_PLANE_FACTOR.TINY,i.far=u*I.FAR_PLANE_FACTOR.HUGE):u>I.LARGE_THRESHOLD?(i.near=u*I.NEAR_PLANE_FACTOR.SMALL,i.far=u*I.FAR_PLANE_FACTOR.LARGE):(i.near=Math.max(.01,u*I.NEAR_PLANE_FACTOR.NORMAL),i.far=Math.max(2e3,u*I.FAR_PLANE_FACTOR.NORMAL)),i.updateProjectionMatrix(),!o){let e=u*I.INITIAL_DISTANCE_MULTIPLIER;i.position.copy(c).add(N(i.up,e)),a.target.copy(c),a.update()}}const ne=/* @__PURE__ */ new Set([`grid`,`floor`,`label-layer`,`measure`]);function L(e){return typeof e.userData.id==`string`&&ne.has(e.userData.id)}function R(e){let t=e;for(;t;){if(L(t))return!0;t=t.parent}return!1}function z(e){e.updateMatrixWorld(!0);let t=new r.Box3;return e.traverse(e=>{let n=e;e.visible&&!R(e)&&n.geometry&&t.expandByObject(e)}),t}function re(t){let n=/* @__PURE__ */ new Set;for(let r of t)r.traverse(t=>{let r=t.geometry,i=r&&e.n(r);i&&n.add(i)});return n}const ie=/* @__PURE__ */ new Set([`floor`,`grid`,`label-layer`]);function B(e,n=/* @__PURE__ */ new Set){let r=[],i=[];for(let t of e.children)ie.has(t.userData.id)||T(t)?r.push(t):i.push(t);e.children.length=0;for(let t of r)e.children.push(t);for(let r of i)t.t(r,{keepUploaded:n}),r.parent=null,r.dispatchEvent({type:`removed`}),e.dispatchEvent({type:`childremoved`,child:r})}function V(e){let{up:t,forward:n,right:r}=M(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 ae(e){let{scene:t,perspective:n,controls:i,onActiveCameraChange:a}=e,o=(e.up??n.up).clone().normalize(),s=V(o),c=new r.OrthographicCamera(-1,1,1,-1,n.near,n.far);c.up.copy(o);let l=`perspective`,u=n.aspect,d=()=>l===`perspective`?n:c,f=null,p=()=>{f?.cancel(),f=null},m=()=>{let e=(l===`orthographic`?c:n).position.distanceTo(i.target)*Math.tan(n.fov*Math.PI/360),t=e*u;c.left=-t,c.right=t,c.top=e,c.bottom=-e,c.near=n.near,c.far=n.far,c.updateProjectionMatrix()},h=e=>{if(e!==l){if(p(),e===`orthographic`)c.position.copy(n.position),c.up.copy(n.up),c.lookAt(i.target),c.zoom=1,m();else{let e=(c.top-c.bottom)/(2*c.zoom)/Math.tan(n.fov*Math.PI/360),t=c.position.clone().sub(i.target);t.lengthSq()<1e-12&&t.copy(o),t.normalize(),n.position.copy(i.target).add(t.multiplyScalar(e))}l=e,i.object=d(),i.update(),a(d())}},g=(e,t,r,a)=>{let s=n.fov*(Math.PI/180),u=t/(2*Math.tan(s/2))*1.5,h=H(r,o),g=e.clone().add(h.clone().multiplyScalar(u)),_=d();l===`orthographic`&&(c.zoom=1),p(),a?f=oe(_,i,g,e,()=>{l===`orthographic`&&m()}):(_.position.copy(g),i.target.copy(e),l===`orthographic`&&m(),i.update())},_=(e,n=!0)=>{let a=z(t),o=a.isEmpty()?i.target.clone():a.getCenter(new r.Vector3),s=a.isEmpty()?new r.Vector3(1,1,1):a.getSize(new r.Vector3),c=Math.max(s.x,s.y,s.z)||1;g(o,c,e,n)};return{getActiveCamera:d,getProjection:()=>l,setProjection:h,toggleProjection:()=>(h(l===`perspective`?`orthographic`:`perspective`),l),setView:(e,t=!0)=>{_(s[e],t)},setViewDirection:_,frameBounds:(e,t=!0)=>{if(e.isEmpty())return;let n=e.getCenter(new r.Vector3),a=e.getSize(new r.Vector3),o=Math.max(a.x,a.y,a.z)||1,c=d().position.clone().sub(i.target);c.lengthSq()<1e-12&&c.copy(s.iso),g(n,o,c.normalize(),t)},setRotateEnabled:e=>{i.enableRotate=e},isRotateEnabled:()=>i.enableRotate,updateAspect:(e,t)=>{u=t===0?u:e/t,l===`orthographic`&&m()},dispose:p}}function H(e,t){let{up:n,forward:r}=M(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 U=e=>1-(1-e)**3;function oe(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=U(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 W(e){let t=new l.LineSegmentsGeometry;return t.setPositions(e),{geometry:t,segmentCount:e.length/6,edgeSpacing:se(e)}}function G(e,t,n){let r=1e4,i=Math.cos(Math.PI/180*n),a=e.length/3;if(a>=67108864)throw Error(`extractEdgeSegments: ${a} vertices exceeds 2^26 limit`);let o=new Float64Array(a),s=new Float64Array(a),c=new Float64Array(a);for(let t=0;t<a;t++)o[t]=Math.round(e[3*t]*r),s[t]=Math.round(e[3*t+1]*r),c[t]=Math.round(e[3*t+2]*r);let l=16;for(;l<a*2;)l<<=1;let u=l-1,d=new Int32Array(l).fill(-1),f=new Int32Array(a);for(let e=0;e<a;e++){let t=(Math.imul(o[e]|0,73856093)^Math.imul(s[e]|0,19349663)^Math.imul(c[e]|0,83492791))&u;for(;;){let n=d[t];if(n===-1){d[t]=e,f[e]=e;break}if(o[n]===o[e]&&s[n]===s[e]&&c[n]===c[e]){f[e]=n;break}t=t+1&u}}let p=/* @__PURE__ */ new Float32Array(6144),m=0,h=/* @__PURE__ */ new Uint32Array(1024),g=(t,n,r)=>{if(m+6>p.length){let e=new Float32Array(p.length*2);e.set(p),p=e;let t=new Uint32Array(p.length/6);t.set(h),h=t}h[m/6]=r,p[m++]=e[3*t],p[m++]=e[3*t+1],p[m++]=e[3*t+2],p[m++]=e[3*n],p[m++]=e[3*n+1],p[m++]=e[3*n+2]},_=(t?t.length:a)/3,v=new Int32Array(a+1);for(let e=0;e<_;e++){let n=f[t?t[3*e]:3*e],r=f[t?t[3*e+1]:3*e+1],i=f[t?t[3*e+2]:3*e+2];n!==r&&r!==i&&i!==n&&(v[n+1]++,v[r+1]++,v[i+1]++)}for(let e=0;e<a;e++)v[e+1]+=v[e];let y=new Int32Array(v[a]);{let e=v.slice(0,a);for(let n=0;n<_;n++){let r=f[t?t[3*n]:3*n],i=f[t?t[3*n+1]:3*n+1],a=f[t?t[3*n+2]:3*n+2];r!==i&&i!==a&&a!==r&&(y[e[r]++]=i,y[e[i]++]=a,y[e[a]++]=r)}}let b=new Int32Array(y.length).fill(-2),x=(e,t)=>{for(let n=v[e],r=v[e+1];n<r;n++)if(y[n]===t)return n;return-1},S=(e,n)=>t?t[3*e+n]:3*e+n,C=/* @__PURE__ */ new Float64Array(3),w=t=>{let n=S(t,0),r=S(t,1),i=S(t,2),a=e[3*i]-e[3*r],o=e[3*i+1]-e[3*r+1],s=e[3*i+2]-e[3*r+2],c=e[3*n]-e[3*r],l=e[3*n+1]-e[3*r+1],u=e[3*n+2]-e[3*r+2],d=o*u-s*l,f=s*c-a*u,p=a*l-o*c,m=d*d+f*f+p*p;if(m>0){let e=1/Math.sqrt(m);d*=e,f*=e,p*=e}else d=0,f=0,p=0;C[0]=d,C[1]=f,C[2]=p},T=0,E=new Uint32Array(Math.max(16,y.length>>1)),D=new Int32Array(E.length),O=()=>{let e=new Uint32Array(E.length*2);e.set(E),E=e;let t=new Int32Array(e.length);t.set(D),D=t};for(let e=0;e<_;e++){let t=S(e,0),n=S(e,1),r=S(e,2),a=f[t],o=f[n],s=f[r];if(a===o||o===s||s===a)continue;let c=!1,l=0,u=0,d=0;for(let f=0;f<3;f++){let p=f===0?a:f===1?o:s,m=f===0?o:f===1?s:a,h=x(m,p),_=h===-1?-2:b[h];if(_>=0)c||=(w(e),l=C[0],u=C[1],d=C[2],!0),w(Math.floor(E[_]/3)),l*C[0]+u*C[1]+d*C[2]<=i&&g(f===0?t:f===1?n:r,f===0?n:f===1?r:t,e),b[h]=-1;else{let t=x(p,m);if(b[t]===-2){T===E.length&&O();let n=T++;b[t]=n,E[n]=3*e+f,D[n]=t}}}}for(let e=0;e<T;e++){if(b[D[e]]!==e)continue;let t=E[e],n=Math.floor(t/3),r=t-3*n;g(S(n,r),S(n,r===2?0:r+1),n)}return{segments:p.slice(0,m),faces:h.slice(0,m/6)}}function ce(){return[`const extract = ${G.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 le=`edge-overlay`;function ue(e){return{forcedColor:e.color==null?null:new r.Color(e.color),darken:r.MathUtils.clamp(e.darken??.75,0,1),width:e.width??1.5,thresholdAngle:e.thresholdAngle??44,distanceFade:e.distanceFade??!0,maxTriangles:e.maxTriangles??8e6,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 fe(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,version:`${t.version}:${n?.version??0}`}}function pe(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 me(e,t){let n=new r.EdgesGeometry(e,t),i=n.attributes.position?n.attributes.position.array:/* @__PURE__ */ new Float32Array;return n.dispose(),{segments:i,faces:null}}const K=/* @__PURE__ */ new WeakMap,q={};function he(e,t){let n=K.get(e.positions)?.get(e.index??q)?.get(t);return n?.version===e.version?n.edges:void 0}function ge(e,t,n){let r=K.get(e.positions);r||K.set(e.positions,r=/* @__PURE__ */ new WeakMap);let i=r.get(e.index??q);return i||r.set(e.index??q,i=/* @__PURE__ */ new Map),i.set(t,{version:e.version,edges:n}),n}function _e(e,t){let n=fe(e);return n?he(n,t)??ge(n,t,G(n.positions,n.index,t)):me(e,t)}let J;const Y=/* @__PURE__ */ new Map;let ve=1;function ye(){if(J!==void 0)return J;if(typeof Worker>`u`||typeof Blob>`u`||typeof URL>`u`||typeof URL.createObjectURL!=`function`)return J=null,null;try{let e=URL.createObjectURL(new Blob([ce()],{type:`text/javascript`})),t=new Worker(e);t.onmessage=e=>{let{id:t,segments:n,faces:r,error:i}=e.data,a=Y.get(t);a&&(Y.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 Y.values())e.reject(/* @__PURE__ */ Error(`edge extraction worker crashed`));Y.clear(),t.terminate(),J=null},J=t}catch{J=null}return J}function be(e,t,n){return new Promise((r,i)=>{let a=ve++;Y.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 X=/* @__PURE__ */ new Map;function xe(e,t){let n=fe(e);if(!n||de(e)<25e3)return Promise.resolve(_e(e,t));let r=he(n,t);if(r)return Promise.resolve(r);let i=pe(n,t),a=X.get(i);if(a)return a;let o=ye();if(!o)return Promise.resolve(_e(e,t));let s=be(o,n,t).catch(()=>G(n.positions,n.index,t)).then(e=>ge(n,t,e)).finally(()=>{X.delete(i)});return X.set(i,s),s}function Z(e){let t=e.userData?.members;return Array.isArray(t)&&t.length>0?t:null}function Se(e){let t=Z(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 Ce(e,t){let n=new r.Box3,i=e.geometry.getIndex(),a=e.geometry.getAttribute(`position`);if(!i||!a||t.indexStart==null||t.indexCount==null)return n;e.updateMatrixWorld();let o=new r.Vector3,s=Math.min(t.indexStart+t.indexCount,i.count);for(let r=t.indexStart;r<s;r++)o.fromBufferAttribute(a,i.getX(r)).applyMatrix4(e.matrixWorld),n.expandByPoint(o);return n}function we(e,t,r){return n.o(e,t,r),()=>n.t(e)}function Te(e,t){let n=Z(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 Ee(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 De(e,t,r){let{segments:i,faces:a}=r;if(!a||!Z(t))return;let o,s=!1,c=()=>{let r=n.r(t);if(r.size===0&&!s||(o??=Te(t,a),!o))return;let c=r.size===0?i:Ee(i,o,r);e.geometry.dispose(),e.geometry=W(c).geometry,s=r.size>0};c();let l=n.i(t,c);e.addEventListener(`removed`,l)}function Oe(e,t){let n=(Array.isArray(e.material)?e.material[0]:e.material)?.color;return n?n.clone().multiplyScalar(1-t):new r.Color(2236962)}var ke=class{options;byKey=/* @__PURE__ */ new Map;constructor(e){this.options=e}for(e,t){let n=this.options.forcedColor??Oe(e,this.options.darken),r=n.getHex()*2+ +!!t,i=this.byKey.get(r);return i||(i=Ae(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 Ae(e,t,n){let r=new o.LineMaterial({color:e});return r.linewidth=t,r.polygonOffset=!0,r.polygonOffsetFactor=0,r.polygonOffsetUnits=-1,n&&(r.transparent=!0),r}function je(e,t,n){let r=new c.LineSegments2(e.geometry,t);return r.userData.kind=le,r.raycast=()=>{},n&&Fe(r,e.edgeSpacing),r}const Me=new r.Vector3,Ne=new r.Vector3;function Pe(e,t,n){e.geometry.boundingSphere||e.geometry.computeBoundingSphere();let i=e.geometry.boundingSphere;if(!i)return 1/0;if(t.isPerspectiveCamera){let a=t;Me.copy(i.center).applyMatrix4(e.matrixWorld);let o=Ne.setFromMatrixPosition(t.matrixWorld).distanceTo(Me);if(o<=i.radius*e.matrixWorld.getMaxScaleOnAxis())return 1/0;let s=Math.tan(r.MathUtils.degToRad(a.fov)*.5),c=2*o*s;return c>0?n/c: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 Fe(e,t){e.onBeforeRender=(n,i,a)=>{c.LineSegments2.prototype.onBeforeRender.call(e,n);let o=e.material,s=t*Pe(e,a,o.resolution.y);o.opacity=r.MathUtils.clamp((s-1)/3,0,1)}}function Ie(e){return e.userData?.kind===le}function Le(e,t){let n=[],i=0;e.traverse(e=>{e instanceof r.Mesh&&e.userData.id!==`floor`&&e.userData.id!==`grid`&&e.userData.kind!==`edge-overlay`&&(e.children.some(e=>e.userData?.kind===`edge-overlay`)?i++:e.geometry&&(de(e.geometry)>t.maxTriangles?e.userData.edgesSkipped=`triangle-cap`:n.push(e)))});let a=Math.max(0,t.maxOverlays-i),o=n.slice(0,a);for(let e of o)delete e.userData.edgesSkipped;for(let e of n.slice(a))e.userData.edgesSkipped=`overlay-budget`;return n.length>a&&console.debug(`[edges] overlay budget reached: ${n.length} meshes want overlays, ${a} allowed — the rest fall back to the screen-space edge pass.`),o}function Re(e,t,n,r){let i=W(t.segments),a=r.distanceFade&&i.segmentCount<=r.maxSegments,o=je(i,n.for(e,a),a);return e.add(o),De(o,e,t),o}const ze=/* @__PURE__ */ new WeakMap;function Be(e){return ze.get(e)??0}function Ve(e,t){for(let n=e;n;n=n.parent)if(n===t)return!0;return!1}async function He(e,t={}){let n=ue(t),r=new ke(n),i=Be(e),a=[],o=Le(e,n).map(async t=>{let o=await xe(t.geometry,n.thresholdAngle);Be(e)===i&&Ve(t,e)&&(t.children.some(e=>e.userData?.kind===`edge-overlay`)||a.push(Re(t,o,r,n)))});return await Promise.all(o),r.disposeUnused(a),a}function Ue(e){ze.set(e,Be(e)+1);let t=[];e.traverse(e=>{e instanceof c.LineSegments2&&Ie(e)&&t.push(e)});let n=/* @__PURE__ */ 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 We(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 Ge(e={}){let{cellSize:t=1,majorEvery:n=10,cellColor:i=8947848,majorColor:a=4473924,fadeDistance:o=100,plane:s=`y`}=e,c=s===`y`?new r.Vector2(0,2):s===`z`?new r.Vector2(0,1):new r.Vector2(1,2),l=2.5,u=new r.PlaneGeometry(1,1);s===`y`?u.rotateX(-Math.PI/2):s===`x`&&u.rotateY(Math.PI/2);let d=new r.ShaderMaterial({vertexShader:`
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_gpu_ownership = require("./gpu-ownership-ADRZBxxs.cjs");
+const require_gpu_dispose = require("./gpu-dispose-fRI12OCL.cjs");
+const require_merged_draw = require("./merged-draw-ma_2r4N8.cjs");
+let three = require("three");
+three = require_gpu_ownership.__toESM(three, 1);
+let three_addons_lines_Line2_js = require("three/addons/lines/Line2.js");
+let three_addons_lines_LineGeometry_js = require("three/addons/lines/LineGeometry.js");
+let three_addons_lines_LineMaterial_js = require("three/addons/lines/LineMaterial.js");
+let three_addons_environments_RoomEnvironment_js = require("three/addons/environments/RoomEnvironment.js");
+let three_addons_lines_LineSegments2_js = require("three/addons/lines/LineSegments2.js");
+let three_addons_lines_LineSegmentsGeometry_js = require("three/addons/lines/LineSegmentsGeometry.js");
+let three_addons_renderers_CSS2DRenderer_js = require("three/addons/renderers/CSS2DRenderer.js");
+let three_addons_helpers_ViewHelper_js = require("three/addons/helpers/ViewHelper.js");
+let three_addons_postprocessing_EffectComposer_js = require("three/addons/postprocessing/EffectComposer.js");
+let three_addons_postprocessing_RenderPass_js = require("three/addons/postprocessing/RenderPass.js");
+let three_addons_postprocessing_ShaderPass_js = require("three/addons/postprocessing/ShaderPass.js");
+let three_addons_postprocessing_GTAOPass_js = require("three/addons/postprocessing/GTAOPass.js");
+let three_addons_postprocessing_SMAAPass_js = require("three/addons/postprocessing/SMAAPass.js");
+let three_addons_postprocessing_OutputPass_js = require("three/addons/postprocessing/OutputPass.js");
+let three_addons_postprocessing_UnrealBloomPass_js = require("three/addons/postprocessing/UnrealBloomPass.js");
+let three_addons_postprocessing_Pass_js = require("three/addons/postprocessing/Pass.js");
+let three_addons_controls_OrbitControls_js = require("three/addons/controls/OrbitControls.js");
+let three_addons_loaders_HDRLoader_js = require("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/reflection-environment.ts
+const METAL = .5;
+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 room = new three_addons_environments_RoomEnvironment_js.RoomEnvironment();
+	const texture = pmrem.fromScene(room, .04).texture;
+	room.dispose();
+	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 = require_gpu_dispose.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,
+			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/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;
+/** 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
+	};
+}
+/**
+* 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 = require_gpu_dispose.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 && require_gpu_ownership.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) {
+		require_gpu_dispose.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 three_addons_lines_LineSegmentsGeometry_js.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) {
+	require_merged_draw.setMemberHighlight(mesh, members, highlight, kind);
+	return () => require_merged_draw.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 = require_merged_draw.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 = require_merged_draw.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 three_addons_lines_LineMaterial_js.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 three_addons_lines_LineSegments2_js.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) => {
+		three_addons_lines_LineSegments2_js.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 three_addons_lines_LineSegments2_js.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 +1474,1333 @@ Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=requi
 		if (alpha < 0.001) discard;
 		gl_FragColor = vec4(color, alpha);
 	}
-`,transparent:!0,depthWrite:!1,side:r.DoubleSide,uniforms:{uAxes:{value:c},uCell:{value:t},uMajor:{value:n},uCellColor:{value:new r.Color(i)},uMajorColor:{value:new r.Color(a)},uCenter:{value:new r.Vector3},uFade:{value:o}}}),f=new r.Mesh(u,d);f.name=`grid`,f.userData.id=`grid`,f.renderOrder=-1;let p=o,m=o*l,h=new r.Vector3;return{object:f,update:e=>{s===`y`?(f.position.set(e.x,0,e.z),h.set(e.x,0,e.z)):s===`z`?(f.position.set(e.x,e.y,0),h.set(e.x,e.y,0)):(f.position.set(0,e.y,e.z),h.set(0,e.y,e.z)),d.uniforms.uCenter.value.copy(h),f.scale.setScalar(m)},fitToContent:e=>{if(e.isEmpty())return;let t=e.getSize(new r.Vector3),n=(e,t)=>t===0?e.x:t===1?e.y:e.z,i=Math.max(n(t,c.x),n(t,c.y));i>0&&Number.isFinite(i)&&(d.uniforms.uCell.value=We(i/20),p=i*2,d.uniforms.uFade.value=p,m=p*l)},setVisible:e=>{f.visible=e},dispose:()=>{f.removeFromParent(),u.dispose(),d.dispose()}}}function Ke(e,t){let n=new u.CSS2DRenderer,i=n.domElement;i.style.position=`absolute`,i.style.top=`0`,i.style.left=`0`,i.style.overflow=`hidden`,i.style.pointerEvents=`none`,i.style.zIndex=`30`,getComputedStyle(e).position===`static`&&(e.style.position=`relative`),e.appendChild(i);let a={width:e.clientWidth||1,height:e.clientHeight||1};n.setSize(a.width,a.height);let o=new r.Group;o.name=`label-layer`,o.userData.id=`label-layer`,t.add(o);let s=/* @__PURE__ */ 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 u.CSS2DObject(r);return i.position.copy(t),o.add(i),s.add(i),{object:i,setPosition:e=>i.position.copy(e),setText:e=>{r.textContent=e},remove:()=>{i.removeFromParent(),r.remove(),s.delete(i)}}},render:(e,t)=>n.render(e,t),setSize:(e,t)=>n.setSize(e,t),dispose:()=>{s.forEach(e=>{e.removeFromParent(),e.element.remove()}),s.clear(),o.removeFromParent(),i.remove()}}}const qe=.015,Je={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 Ye(e){let t=e&&Je[e]||Je.Meters;return e=>`${(e/t.metersPerUnit).toPrecision(3)} ${t.suffix}`}function Xe(e,t){if(e.isOrthographicCamera){let t=e;return Math.abs(t.top-t.bottom)/(t.zoom||1)*qe}return((t?e.position.distanceTo(t):e.position.length())||1)*qe}function Ze(e){let t=e.object;if(t instanceof r.Mesh)return e.face?[e.face.a,e.face.b,e.face.c]:null;if(t instanceof r.Points)return e.index==null?null:[e.index];if(t instanceof r.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 Qe(e,t,n,i){let a=e.point.clone(),o=e.object,s=Ze(e);if(!s||!o.geometry)return a;let c=o.geometry.attributes.position;if(!c)return a;let l=e=>{let i=e.clone().project(t);return new r.Vector2((i.x+1)/2*n.width,(1-i.y)/2*n.height)},u=l(a),d=a,f=i;for(let e of s){if(e>=c.count)continue;let t=new r.Vector3().fromBufferAttribute(c,e).applyMatrix4(o.matrixWorld),n=l(t).distanceTo(u);n<f&&(f=n,d=t)}return d}function $e(e){let{canvas:t,scene:n,getActiveCamera:s,getViewTarget:c,labelLayer:l,options:u={}}=e,d=u.snapPixels??12,f=new r.Color(u.color??16763904),p=Ye(u.displayUnit),m=u.format??((e,t)=>`${p(e)}\nΔx ${p(t.x)}  Δy ${p(t.y)}  Δz ${p(t.z)}`),h=new r.Raycaster,g=new r.Vector2,_=!1,v=[],y=[],b=null,x=null,S=new r.PointsMaterial({color:f,size:8,sizeAttenuation:!1,depthTest:!1}),C=new r.PointsMaterial({color:f,size:11,sizeAttenuation:!1,depthTest:!1,transparent:!0,opacity:.5}),w=null,T=e=>{if(!e)w&&(w.visible=!1);else{if(!w){let e=new r.BufferGeometry;e.setAttribute(`position`,new r.Float32BufferAttribute([0,0,0],3)),w=new r.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 r.BufferGeometry;t.setAttribute(`position`,new r.Float32BufferAttribute([e.x,e.y,e.z],3));let i=new r.Points(t,S);return i.renderOrder=999,i.userData.id=`measure`,i.raycast=()=>{},n.add(i),i},D=()=>{v.length=0,y.forEach(e=>{e.geometry.dispose(),e.removeFromParent()}),y.length=0,b&&=(b.geometry.dispose(),b.material.dispose(),b.removeFromParent(),null),x?.remove(),x=null},O=()=>{if(v.length!==2)return;let[e,t]=v,s=new a.LineGeometry;s.setPositions([e.x,e.y,e.z,t.x,t.y,t.z]);let c=new o.LineMaterial({color:f});c.linewidth=2,c.depthTest=!1,b=new i.Line2(s,c),b.renderOrder=998,b.userData.id=`measure`,b.raycast=()=>{},n.add(b);let d=e.clone().add(t).multiplyScalar(.5),p=new r.Vector3(Math.abs(t.x-e.x),Math.abs(t.y-e.y),Math.abs(t.z-e.z));x=l.addLabel(m(e.distanceTo(t),p),d,u.labelClassName)},k=e=>{let r=t.getBoundingClientRect();g.x=(e.clientX-r.left)/r.width*2-1,g.y=-((e.clientY-r.top)/r.height)*2+1;let i=s();h.setFromCamera(g,i);let a=Xe(i,c?.());h.params.Line.threshold=a,h.params.Points.threshold=a;let o=h.intersectObjects(n.children,!0).filter(e=>e.object.userData.id!==`measure`&&e.object.userData.id!==`grid`);return o.length===0?null:Qe(o[0],i,{width:r.width,height:r.height},d)},A=null,j=0,M=()=>{j&&=(cancelAnimationFrame(j),0),A=null};return{setEnabled:e=>{_=e,e||(M(),D(),T(null))},isEnabled:()=>_,handleClick:e=>{if(!_)return!1;v.length===2&&D();let t=k(e);return t===null||(v.push(t),y.push(E(t)),v.length===2&&O()),!0},handleMove:e=>{_&&(A=e,!j&&(j=requestAnimationFrame(()=>{j=0;let e=A;A=null,_&&e&&T(k(e))})))},clear:D,dispose:()=>{M(),D(),w&&=(w.geometry.dispose(),w.removeFromParent(),null),S.dispose(),C.dispose()}}}const et=[];function tt({camera:e,scene:t,groundNormals:n=()=>et}){let i=e.near,a=e.near,o=nt();return{update:()=>{e.near!==a&&(i=e.near);let s=o.measure(t,e),c=i;if(s!==null){let t=s;for(let r of n())t=Math.min(t,Math.abs(e.position.dot(r)));c=r.MathUtils.clamp(t*.5,i,e.far*.01)}Math.abs(c-a)>a*.05&&(e.near=c,e.updateProjectionMatrix(),a=c)}}}function nt(){let e=/* @__PURE__ */ new WeakMap,t=new r.Frustum,n=new r.Matrix4,i=new r.Vector3,a=new r.Box3,o=/* @__PURE__ */ new Float64Array(20),s=/* @__PURE__ */ new Float64Array(20),c=/* @__PURE__ */ new Float32Array(6),l=/* @__PURE__ */ new Float64Array(21),u=/* @__PURE__ */ new Float64Array(21),d=1/0,f=!1,p=(t,n)=>{let r=n.getAttribute(`position`),i=n.getIndex(),a=e.get(n);if(a&&a.position===r&&a.positionVersion===it(r)&&a.index===i&&a.indexVersion===(i?.version??-1))return a;let o={...ot(r,i,at(t)),position:r,positionVersion:it(r),index:i,indexVersion:i?.version??-1};return e.set(n,o),o},m=(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;l[e*3]=r.getX(t),l[e*3+1]=r.getY(t),l[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,c=l[t*3],d=l[t*3+1],f=l[t*3+2],p=l[n*3],m=l[n*3+1],h=l[n*3+2],g=r*c+i*d+a*f+o,_=r*p+i*m+a*h+o;if(g>=0&&(u[s*3]=c,u[s*3+1]=d,u[s*3+2]=f,s++),g>=0!=_>=0){let e=g/(g-_);u[s*3]=c+(p-c)*e,u[s*3+1]=d+(m-d)*e,u[s*3+2]=f+(h-f)*e,s++}}[l,u]=[u,l],e=s}for(let t=0;t<e;t++){let e=n[16]*l[t*3]+n[17]*l[t*3+1]+n[18]*l[t*3+2]+n[19];e<o&&(o=e)}}return o},h=e=>{let t=e.elements;for(let e=0;e<20;e+=4){let n=o[e],r=o[e+1],i=o[e+2];s[e]=t[0]*n+t[1]*r+t[2]*i,s[e+1]=t[4]*n+t[5]*r+t[6]*i,s[e+2]=t[8]*n+t[9]*r+t[10]*i,s[e+3]=n*t[12]+r*t[13]+i*t[14]+o[e+3]}return s},g=(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 u=t[16],f=t[17],p=t[18],h=u*(u>0?i:s)+f*(f>0?a:c)+p*(p>0?o:l)+t[19];h>=d||(d=n?Math.min(d,m(n,r/6,t)):h)}},_=e=>{let t=e.geometry;if(!t?.getAttribute?.(`position`))return;if(f=!0,rt(e)){let n=p(e,t);g(n.boxes,h(e.matrixWorld),n);return}let n=e;n.isInstancedMesh?(n.boundingBox||n.computeBoundingBox(),a.copy(n.boundingBox)):(t.boundingBox||t.computeBoundingBox(),a.copy(t.boundingBox)),!a.isEmpty()&&(c[0]=a.min.x,c[1]=a.min.y,c[2]=a.min.z,c[3]=a.max.x,c[4]=a.max.y,c[5]=a.max.z,g(c,h(e.matrixWorld)))},v=e=>{if(e.visible&&!L(e)&&e.userData.kind!==`edge-overlay`){_(e);for(let t of e.children)v(t)}};return{measure:(e,r)=>{e.updateMatrixWorld(),r.updateMatrixWorld(),n.multiplyMatrices(r.projectionMatrix,r.matrixWorldInverse),t.setFromProjectionMatrix(n);for(let e=0;e<4;e++){let n=t.planes[e];o[e*4]=n.normal.x,o[e*4+1]=n.normal.y,o[e*4+2]=n.normal.z,o[e*4+3]=n.constant}r.getWorldDirection(i),o[16]=i.x,o[17]=i.y,o[18]=i.z,o[19]=-i.dot(r.position),d=1/0,f=!1;for(let t of e.children)v(t);return f?d:null}}}function rt(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 it(e){return e.isInterleavedBufferAttribute?e.data.version:e.version}function at(e){let t=[];for(let n of Z(e)??[])n.indexStart!==void 0&&t.push(n.indexStart/3);return t.sort((e,t)=>e-t)}function ot(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 st(){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 ct(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 lt(e){let{camera:t,domElement:n,controller:i}=e,a=new d.ViewHelper(t,n);a.setLabels(`X`,`Y`,`Z`);let o=!0,s=new r.Raycaster,c=new r.OrthographicCamera(-2,2,2,-2,0,4);c.position.set(0,0,2),c.updateMatrixWorld();let l={posX:new r.Vector3(1,0,0),negX:new r.Vector3(-1,0,0),posY:new r.Vector3(0,1,0),negY:new r.Vector3(0,-1,0),posZ:new r.Vector3(0,0,1),negZ:new r.Vector3(0,0,-1)},u=e=>{let i=n.getBoundingClientRect(),o=i.left+n.offsetWidth-128-a.location.right,u=i.top+n.offsetHeight-128-a.location.bottom,d=new r.Vector2((e.clientX-o)/128*2-1,-((e.clientY-u)/128)*2+1);if(Math.abs(d.x)>1||Math.abs(d.y)>1)return null;a.quaternion.copy(t.quaternion).invert(),a.updateMatrixWorld(),s.setFromCamera(d,c);let f=s.intersectObjects(a.children,!1);for(let e of f){let t=e.object.userData?.type;if(typeof t==`string`&&t in l)return t}return null};return{render:e=>{if(!o)return;let t=e.autoClear;e.autoClear=!1,a.render(e),e.autoClear=t},handleClick:e=>{if(!o)return!1;let t=u(e);return t?(i.getProjection()===`orthographic`&&i.setProjection(`perspective`),i.setViewDirection(l[t],!1),!0):!1},setVisible:e=>{o=e},isVisible:()=>o,dispose:()=>a.dispose()}}function ut(e,t,n,i,a,o,s,c,l,u,d,f,p,m,h=!0,g){let _=null,v=performance.now(),y=!0,b=0,x=new r.Matrix4,S=new r.Matrix4,C=null,w=()=>{y=!0},T=e=>{e.updateMatrixWorld();let t=C!==e||!x.equals(e.matrixWorld)||!S.equals(e.projectionMatrix);return t&&(C=e,x.copy(e.matrixWorld),S.copy(e.projectionMatrix)),t},E=e.domElement,D=[`pointerdown`,`pointerup`,`wheel`];if(h)for(let e of D)E.addEventListener(e,w,{passive:!0});let O=()=>{let{width:t,height:r}=s();if(t===0||r===0)return;let i=Math.floor(t*c),o=Math.floor(r*c);(e.domElement.width!==i||e.domElement.height!==o)&&(e.setPixelRatio(c),e.setSize(t,r,!1),n.aspect=t/r,n.updateProjectionMatrix(),a.updateAspect(t,r),f?.()?.setSize(t,r,c),p?.setSize(t,r),w())},k=(n,r)=>{let i=f?.();i?(i.setCamera(n),i.render(r)):e.render(t,n),g&&g.render(n),p&&p.render(t,n),d&&d.render(e)},A=()=>{k(i(),0)},j=function(){_=requestAnimationFrame(j);let e=performance.now(),t=(e-v)/1e3;v=e,O(),(o.enableDamping||o.autoRotate)&&o.update(),u&&u.update(i().position),m&&m.update(),l?.(t);let n=i();if(h){if(!(y||T(n)||e-b>=500))return;y=!1,b=e}k(n,t)};return{animate:j,dispose:()=>{if(_!==null&&(cancelAnimationFrame(_),_=null),h)for(let e of D)E.removeEventListener(e,w)},invalidate:w,renderNow:A}}const Q=new r.Vector3(0,0,1);function dt(e){let n=e.sceneScale||`m`,i={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],a=e.look??`technical`,o=t.c[a];return{sceneScale:n,look:a,camera:{position:e.camera?.position||N(e.environment?.sceneUp??Q,i.cameraDistance*Math.sqrt(3)),fov:e.camera?.fov||20,near:e.camera?.near||i.near,far:e.camera?.far||i.far,target:e.camera?.target||new r.Vector3(0,0,0),dynamicNear:e.camera?.dynamicNear??!0},lighting:{enableSunlight:e.lighting?.enableSunlight??!0,sunlightIntensity:e.lighting?.sunlightIntensity??o.sunlightIntensity,sunlightPosition:e.lighting?.sunlightPosition||P(e.environment?.sceneUp??Q,i.lightDistance,i.lightHeight),ambientLightColor:e.lighting?.ambientLightColor||new r.Color(4210752),ambientLightIntensity:e.lighting?.ambientLightIntensity??o.ambientIntensity,sunlightColor:e.lighting?.sunlightColor||16777215,enableHemisphereLight:e.lighting?.enableHemisphereLight??o.hemisphereIntensity>0,hemisphereSkyColor:e.lighting?.hemisphereSkyColor??14673663,hemisphereGroundColor:e.lighting?.hemisphereGroundColor??7036754,hemisphereIntensity:e.lighting?.hemisphereIntensity??o.hemisphereIntensity},environment:{hdrPath:e.environment?.hdrPath||`/baseHDR.hdr`,backgroundColor:e.environment?.backgroundColor||new r.Color(15790320),enableEnvironmentLighting:e.environment?.enableEnvironmentLighting??!0,sceneUp:e.environment?.sceneUp||Q,showEnvironment:e.environment?.showEnvironment??!1,environmentIntensity:e.environment?.environmentIntensity??o.environmentIntensity},floor:{enabled:e.floor?.enabled??!1,size:e.floor?.size||i.floorSize,color:e.floor?.color||new r.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??o.toneMapping,toneMappingExposure:e.render?.toneMappingExposure??o.toneMappingExposure,preserveDrawingBuffer:e.render?.preserveDrawingBuffer??!1,ambientOcclusion:e.render?.ambientOcclusion??o.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||i.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??ee(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 ft(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 pt(e){let t=e[$];t&&(ft(e,t),delete e[$])}function mt(e,t){let n=e;t?(n[$]?ft(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):(pt(n),n.needsUpdate=!0)}function ht(e,n){if(n.materialOverride)return n.envMapIntensity;let r=e.userData[t.l];if(r!=null)return r;let i=e,a=i[$]?.metalness??i.metalness??0;return t.u(n.envMapIntensity,a)}function gt(e){let{scene:n,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 r.HemisphereLight(e.hemisphereSkyColor??o.lighting.hemisphereSkyColor,e.hemisphereGroundColor??o.lighting.hemisphereGroundColor,e.hemisphereIntensity),a.hemisphere.position.copy(o.environment.sceneUp??Q),n.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,n.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 r=t.c[e];l=e,i.toneMapping=r.toneMapping,i.toneMappingExposure=r.toneMappingExposure,o.render.toneMapping=r.toneMapping,o.render.toneMappingExposure=r.toneMappingExposure,u({hemisphereIntensity:r.hemisphereIntensity,ambientIntensity:r.ambientIntensity}),d(r.environmentIntensity),a.sun&&(a.sun.intensity=r.sunlightIntensity,o.lighting.sunlightIntensity=r.sunlightIntensity);let f=s.get()!==null;s.setAmbientOcclusion(r.ambientOcclusion),f&&s.rebuild(),n.traverse(e=>{if(e.userData.source!==`compute`)return;let t=e,n=Array.isArray(t.material)?t.material:t.material?[t.material]:[];for(let e of n)`envMapIntensity`in e&&(e.envMapIntensity=ht(e,r)),mt(e,r.materialOverride)}),j(n,n),c()},getMaterialAppearance:()=>t.d(l)}}function _t(e,t){let n=t.parentElement,i=n?n.clientWidth:window.innerWidth,a=n?n.clientHeight:window.innerHeight,o=new r.PerspectiveCamera(e.camera.fov,i/a,e.camera.near,e.camera.far),s=e.camera.position;return s&&o.position.set(s.x,s.y,s.z),o}function vt(e){let t=new r.Scene;return t.background=(typeof e.environment.backgroundColor==`string`?new r.Color(e.environment.backgroundColor):e.environment.backgroundColor)||null,t}function yt(e,n){t.t(e,n),e.environment?.dispose(),A(e),e.background instanceof r.Texture&&e.background.dispose()}const bt={uniforms:{tDiffuse:{value:null},tNormal:{value:null},tDepth:{value:null},uResolution:{value:new r.Vector2(1,1)},uColor:{value:new r.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 three_addons_renderers_CSS2DRenderer_js.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 three_addons_renderers_CSS2DRenderer_js.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/measure.ts
+const DEFAULT_SNAP_PIXELS = 12;
+const DEFAULT_COLOR = 16763904;
+const LINE_PICK_FRACTION = .015;
+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"
+	}
+};
+/** @internal exported for tests */
+function makeFormatter(displayUnit) {
+	const unit = displayUnit && UNIT_DISPLAY[displayUnit] || UNIT_DISPLAY.Meters;
+	return (meters) => `${(meters / unit.metersPerUnit).toPrecision(3)} ${unit.suffix}`;
+}
+/**
+* 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;
+}
+/**
+* Vertex indices to consider snapping to, by object type: Mesh → struck triangle's 3 vertices;
+* Line/LineSegments → struck segment's 2 endpoints; Points → the struck vertex. Null when the hit
+* carries no usable index (e.g. a fat `Line2`), so the caller keeps the raw hit point.
+*/
+function snapCandidateIndices(hit) {
+	const obj = hit.object;
+	if (obj instanceof three.Mesh) return hit.face ? [
+		hit.face.a,
+		hit.face.b,
+		hit.face.c
+	] : null;
+	if (obj instanceof three.Points) return hit.index != null ? [hit.index] : null;
+	if (obj instanceof three.Line) {
+		if (hit.index == null) return null;
+		const index = obj.geometry.index;
+		if (index) {
+			if (hit.index + 1 >= index.count) return null;
+			return [index.getX(hit.index), index.getX(hit.index + 1)];
+		}
+		return [hit.index, hit.index + 1];
+	}
+	return null;
+}
+/** Snap a raycast hit to the nearest geometry vertex within `snapPixels` on screen, else the raw hit point. */
+function snapToVertex(hit, camera, screenSize, snapPixels) {
+	const raw = hit.point.clone();
+	const obj = hit.object;
+	const indices = snapCandidateIndices(hit);
+	if (!indices || !obj.geometry) return raw;
+	const pos = obj.geometry.attributes.position;
+	if (!pos) return raw;
+	const toScreen = (worldP) => {
+		const ndc = worldP.clone().project(camera);
+		return new three.Vector2((ndc.x + 1) / 2 * screenSize.width, (1 - ndc.y) / 2 * screenSize.height);
+	};
+	const rawScreen = toScreen(raw);
+	let best = raw;
+	let bestPx = snapPixels;
+	for (const idx of indices) {
+		if (idx >= pos.count) continue;
+		const world = new three.Vector3().fromBufferAttribute(pos, idx).applyMatrix4(obj.matrixWorld);
+		const px = toScreen(world).distanceTo(rawScreen);
+		if (px < bestPx) {
+			bestPx = px;
+			best = world;
+		}
+	}
+	return best;
+}
+function createMeasureTool(deps) {
+	const { canvas, scene, getActiveCamera, getViewTarget, labelLayer, options = {} } = deps;
+	const snapPixels = options.snapPixels ?? DEFAULT_SNAP_PIXELS;
+	const color = new three.Color(options.color ?? DEFAULT_COLOR);
+	const fmt = makeFormatter(options.displayUnit);
+	const defaultFormat = (d, delta) => `${fmt(d)}\nΔx ${fmt(delta.x)}  Δy ${fmt(delta.y)}  Δz ${fmt(delta.z)}`;
+	const format = options.format ?? defaultFormat;
+	const raycaster = new three.Raycaster();
+	const pointer = new three.Vector2();
+	let enabled = false;
+	const points = [];
+	const markers = [];
+	let line = null;
+	let label = null;
+	const markerMaterial = new three.PointsMaterial({
+		color,
+		size: 8,
+		sizeAttenuation: false,
+		depthTest: false
+	});
+	const hoverMaterial = new three.PointsMaterial({
+		color,
+		size: 11,
+		sizeAttenuation: false,
+		depthTest: false,
+		transparent: true,
+		opacity: .5
+	});
+	let hoverMarker = null;
+	const showHover = (p) => {
+		if (!p) {
+			if (hoverMarker) hoverMarker.visible = false;
+			return;
+		}
+		if (!hoverMarker) {
+			const geometry = new three.BufferGeometry();
+			geometry.setAttribute("position", new three.Float32BufferAttribute([
+				0,
+				0,
+				0
+			], 3));
+			hoverMarker = new three.Points(geometry, hoverMaterial);
+			hoverMarker.renderOrder = 1e3;
+			hoverMarker.userData.id = "measure";
+			hoverMarker.raycast = () => {};
+			scene.add(hoverMarker);
+		}
+		hoverMarker.position.copy(p);
+		hoverMarker.visible = true;
+	};
+	const makeMarker = (p) => {
+		const geometry = new three.BufferGeometry();
+		geometry.setAttribute("position", new three.Float32BufferAttribute([
+			p.x,
+			p.y,
+			p.z
+		], 3));
+		const marker = new three.Points(geometry, markerMaterial);
+		marker.renderOrder = 999;
+		marker.userData.id = "measure";
+		marker.raycast = () => {};
+		scene.add(marker);
+		return marker;
+	};
+	const clear = () => {
+		points.length = 0;
+		markers.forEach((m) => {
+			m.geometry.dispose();
+			m.removeFromParent();
+		});
+		markers.length = 0;
+		if (line) {
+			line.geometry.dispose();
+			line.material.dispose();
+			line.removeFromParent();
+			line = null;
+		}
+		label?.remove();
+		label = null;
+	};
+	const drawMeasurement = () => {
+		if (points.length !== 2) return;
+		const [a, b] = points;
+		const geometry = new three_addons_lines_LineGeometry_js.LineGeometry();
+		geometry.setPositions([
+			a.x,
+			a.y,
+			a.z,
+			b.x,
+			b.y,
+			b.z
+		]);
+		const material = new three_addons_lines_LineMaterial_js.LineMaterial({ color });
+		material.linewidth = 2;
+		material.depthTest = false;
+		line = new three_addons_lines_Line2_js.Line2(geometry, material);
+		line.renderOrder = 998;
+		line.userData.id = "measure";
+		line.raycast = () => {};
+		scene.add(line);
+		const mid = a.clone().add(b).multiplyScalar(.5);
+		const delta = new three.Vector3(Math.abs(b.x - a.x), Math.abs(b.y - a.y), Math.abs(b.z - a.z));
+		label = labelLayer.addLabel(format(a.distanceTo(b), delta), mid, options.labelClassName);
+	};
+	const pickPoint = (event) => {
+		const rect = canvas.getBoundingClientRect();
+		pointer.x = (event.clientX - rect.left) / rect.width * 2 - 1;
+		pointer.y = -((event.clientY - rect.top) / rect.height) * 2 + 1;
+		const camera = getActiveCamera();
+		raycaster.setFromCamera(pointer, camera);
+		const threshold = pickThreshold(camera, getViewTarget?.());
+		raycaster.params.Line.threshold = threshold;
+		raycaster.params.Points.threshold = threshold;
+		const hits = raycaster.intersectObjects(scene.children, true).filter((i) => i.object.userData.id !== "measure" && i.object.userData.id !== "grid");
+		if (hits.length === 0) return null;
+		return snapToVertex(hits[0], camera, {
+			width: rect.width,
+			height: rect.height
+		}, snapPixels);
+	};
+	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;
+			showHover(pickPoint(latest));
+		});
+	};
+	const handleClick = (event) => {
+		if (!enabled) return false;
+		if (points.length === 2) clear();
+		const point = pickPoint(event);
+		if (point === null) return true;
+		points.push(point);
+		markers.push(makeMarker(point));
+		if (points.length === 2) drawMeasurement();
+		return true;
+	};
+	return {
+		setEnabled: (value) => {
+			enabled = value;
+			if (!value) {
+				cancelPendingMove();
+				clear();
+				showHover(null);
+			}
+		},
+		isEnabled: () => enabled,
+		handleClick,
+		handleMove,
+		clear,
+		dispose: () => {
+			cancelPendingMove();
+			clear();
+			if (hoverMarker) {
+				hoverMarker.geometry.dispose();
+				hoverMarker.removeFromParent();
+				hoverMarker = null;
+			}
+			markerMaterial.dispose();
+			hoverMaterial.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 three_addons_helpers_ViewHelper_js.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) {
+	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 drawFrame = (activeCamera, delta) => {
+		const renderPipeline = getRenderPipeline?.();
+		if (renderPipeline) {
+			renderPipeline.setCamera(activeCamera);
+			renderPipeline.render(delta);
+		} else renderer.render(scene, activeCamera);
+		if (labelLayer) labelLayer.render(scene, activeCamera);
+		if (gizmo) gizmo.render(renderer);
+	};
+	const renderNow = () => {
+		drawFrame(getActiveCamera(), 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) {
+			if (!(renderRequested || cameraMoved(activeCamera) || now - lastRenderTime >= IDLE_REPAINT_INTERVAL_MS)) return;
+			renderRequested = false;
+			lastRenderTime = 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 = require_merged_draw.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 = require_merged_draw.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[require_gpu_dispose.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[require_gpu_dispose.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 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
+		};
+		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 } = 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);
+			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);
+	};
+	return {
+		sync,
+		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[require_gpu_dispose.OWN_ENV_MAP_INTENSITY];
+	if (own != null) return own;
+	const target = material;
+	const metalness = target[BASELINE_KEY]?.metalness ?? target.metalness ?? 0;
+	return require_gpu_dispose.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) => require_gpu_dispose.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,
+		getMaterialAppearance: () => require_gpu_dispose.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) {
+	require_gpu_dispose.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,34 +2848,968 @@ Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=requi
 			float edge = max(depthEdge, normalEdge) * uOpacity;
 			gl_FragColor = vec4(mix(color.rgb, uColor, edge), color.a);
 		}
-	`};var xt=class extends _.Pass{camera;scene;normalMaterial;edgeMaterial;fsQuad;normalTarget=null;width;height;constructor(e,t,n,i,a={}){super(),this.scene=e,this.camera=t,this.width=Math.max(1,n),this.height=Math.max(1,i),this.normalMaterial=new r.MeshNormalMaterial,this.normalMaterial.blending=r.NoBlending,this.edgeMaterial=new r.ShaderMaterial({uniforms:r.UniformsUtils.clone(bt.uniforms),vertexShader:bt.vertexShader,fragmentShader:bt.fragmentShader});let o=this.edgeMaterial.uniforms;o.uColor.value=new r.Color(a.color??2236962),o.uOpacity.value=a.opacity??1,o.uNormalThreshold.value=a.normalThreshold??.4,o.uDepthThreshold.value=a.depthThreshold??.02,o.uThickness.value=a.thickness??1,this.fsQuad=new _.FullScreenQuad(this.edgeMaterial),this.needsSwap=!0}acquireNormalTarget(){if(!this.normalTarget){let e=new r.DepthTexture(this.width,this.height);this.normalTarget=new r.WebGLRenderTarget(this.width,this.height,{minFilter:r.NearestFilter,magFilter:r.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 i=this.acquireNormalTarget(),a=e.getRenderTarget(),o=e.autoClear,s=e.getClearColor(new r.Color),c=e.getClearAlpha(),l=this.scene.overrideMaterial;e.setRenderTarget(i),e.setClearColor(7829503,1),e.autoClear=!0,this.scene.overrideMaterial=this.normalMaterial,e.render(this.scene,this.camera),this.scene.overrideMaterial=l,e.setClearColor(s,c),e.autoClear=o;let u=this.edgeMaterial.uniforms;u.tDiffuse.value=n.texture,u.tNormal.value=i.texture,u.tDepth.value=i.depthTexture,u.uResolution.value.set(this.width,this.height);let d=this.camera;u.uPerspective.value=+!!d.isPerspectiveCamera,u.uNear.value=this.camera.near??.1,u.uFar.value=this.camera.far??1e3,e.setRenderTarget(this.renderToScreen?null:t),this.fsQuad.render(e),e.setRenderTarget(a)}dispose(){this.normalTarget?.dispose(),this.normalMaterial.dispose(),this.edgeMaterial.dispose(),this.fsQuad.dispose()}};function St(e){return e>=2?0:4}function Ct(e,t,n,i,a,o){let s=new r.WebGLRenderTarget(i,a,{type:r.HalfFloatType}),c=new f.EffectComposer(e,s);c.renderTarget2.samples=0;let l=e=>{c.readBuffer=s,c.writeBuffer=c.renderTarget2,c.render(e)},u=new p.RenderPass(t,n);c.addPass(u);let d=null;(o.ambientOcclusion??!0)&&(d=new m.GTAOPass(t,n,i,a),d.blendIntensity=o.aoIntensity??1,d.updateGtaoMaterial({screenSpaceRadius:!0}),c.addPass(d));let _=new xt(t,n,i,a,typeof o.edgeDetection==`object`?o.edgeDetection:{});_.enabled=!!o.edgeDetection,c.addPass(_);let v=new h.SMAAPass;c.addPass(v);let y=new g.OutputPass;c.addPass(y),e.toneMapping=o.toneMapping,e.toneMappingExposure=o.toneMappingExposure;let b=o.aoPixelRatio??1,x=1;if(d){let e=d.setSize.bind(d);d.setSize=(t,n)=>e(Math.max(1,Math.round(t*x)),Math.max(1,Math.round(n*x)))}let S=e=>{x=Math.min(e,b)/e;let t=St(e);s.samples!==t&&(s.samples=t,s.dispose()),c.setPixelRatio(e)};return S(e.getPixelRatio()),c.setSize(i,a),{render:l,setSize:(e,t,n)=>{S(n),c.setSize(e,t)},setCamera:e=>{if(u.camera=e,_.camera=e,!d)return;d.camera=e;let t=+!!e.isPerspectiveCamera;d.gtaoMaterial.defines.PERSPECTIVE_CAMERA!==t&&(d.gtaoMaterial.defines.PERSPECTIVE_CAMERA=t,d.gtaoMaterial.needsUpdate=!0)},setEdgeDetection:e=>{_.enabled=e},edgeDetectionEnabled:()=>_.enabled,dispose:()=>{c.dispose(),d?.dispose(),_.dispose(),v.dispose(),y.dispose()}}}function wt(e){let{renderer:t,scene:n,getActiveCamera:i,getCanvasSize:a,pixelRatio:o,config:s,requestRender:c}=e,l=null,u=!!s.render.ambientOcclusion,d=!1,f=!1,p=e=>{let{width:c,height:l}=a(),u=Ct(t,n,i(),Math.max(1,c),Math.max(1,l),{toneMapping:s.render.toneMapping??r.NeutralToneMapping,toneMappingExposure:s.render.toneMappingExposure??1,ambientOcclusion:e,aoIntensity:s.render.aoIntensity,aoPixelRatio:s.render.aoPixelRatio,edgeDetection:!1});return u.setSize(Math.max(1,c),Math.max(1,l),o),u},m=()=>{u||d?(l&&f===u||(l?.dispose(),l=p(u),f=u),l.setEdgeDetection(d),c()):(l?.dispose(),l=null,c())};return{get:()=>l,sync:m,rebuild:()=>{l?.dispose(),l=null,m()},setAmbientOcclusion:e=>{u=e,m()},setEdgeFallback:e=>{e!==d&&(d=e,m())},isEdgeFallbackActive:()=>d,dispose:()=>{l?.dispose(),l=null}}}function Tt(e,t,n){let r=new v.OrbitControls(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 Et(e,n,i,a){i.environment.enableEnvironmentLighting?(O(e,n,F(i.environment.sceneUp??Q)),new y.HDRLoader().load(i.environment.hdrPath||`/baseHDR.hdr`,function(o){if(a()){o.dispose();return}if(!o?.image){t.p().warn(`HDR loaded without image data; skipping environment map.`),o?.dispose(),i.events.onReady?.();return}o.mapping=r.EquirectangularReflectionMapping;let s=new r.PMREMGenerator(n);s.compileEquirectangularShader();let c=s.fromEquirectangular(o).texture;s.dispose(),e.environment=c,e.environmentIntensity=i.environment.environmentIntensity??1;let l=F(i.environment.sceneUp??Q);e.environmentRotation.copy(l),i.environment.showEnvironment?(e.background=o,e.backgroundRotation.copy(l)):o.dispose(),i.events.onReady?.()},void 0,function(e){a()||(t.p().warn(`HDR texture could not be loaded, falling back to basic lighting:`,e),i.events.onReady?.())})):i.events.onReady?.()}function Dt(e,t){let n=t.floor.size,i=new r.PlaneGeometry(n,n),a=typeof t.floor.color==`string`?new r.Color(t.floor.color):t.floor.color,o=new r.MeshStandardMaterial({color:a,roughness:t.floor.roughness,metalness:t.floor.metalness,side:r.DoubleSide}),s=new r.Mesh(i,o);s.userData.id=`floor`,s.name=`floor`;let c=(t.environment?.sceneUp||Q).clone().normalize();s.quaternion.setFromUnitVectors(new r.Vector3(0,0,1),c),s.position.set(0,0,0),t.floor.receiveShadow&&t.render.enableShadows&&(s.receiveShadow=!0),e.add(s)}const Ot=`#f5a524`,kt={vertexShader:`
+	`
+};
+var EdgeDetectionPass = class extends three_addons_postprocessing_Pass_js.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 three_addons_postprocessing_Pass_js.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 = vec4(position.xy, 0.0, 1.0);
-		}
-	`,fragmentShader:`
-		uniform sampler2D tMask;
-		uniform vec2 uTexel;
-		uniform float uRadius;
-		uniform vec3 uColor;
+			gl_Position = projectionMatrix * modelViewMatrix * vec4(position, 1.0);
+		}`,
+	fragmentShader: `
+		uniform sampler2D tDiffuse;
 		varying vec2 vUv;
-
-		const int DIRECTIONS = 16;
-		const float TAU = 6.2831853;
-
+		const float MAX_RADIANCE = 64.0;
+		float safe(float v) {
+			return isnan(v) ? 0.0 : clamp(v, 0.0, MAX_RADIANCE);
+		}
 		void main() {
-			if (texture2D(tMask, vUv).r > 0.5) discard;
-
-			float coverage = 0.0;
-			for (int i = 0; i < DIRECTIONS; i++) {
-				float angle = TAU * float(i) / float(DIRECTIONS);
-				vec2 offset = vec2(cos(angle), sin(angle)) * uRadius * uTexel;
-				coverage = max(coverage, texture2D(tMask, vUv + offset).r);
-				coverage = max(coverage, texture2D(tMask, vUv + offset * 0.5).r);
+			vec4 color = texture2D(tDiffuse, vUv);
+			gl_FragColor = vec4(safe(color.r), safe(color.g), safe(color.b), color.a);
+		}`
+};
+/**
+* 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 three_addons_postprocessing_EffectComposer_js.EffectComposer(renderer, sceneTarget);
+	composer.renderTarget2.samples = 0;
+	const renderFrame = (deltaTime) => {
+		composer.readBuffer = sceneTarget;
+		composer.writeBuffer = composer.renderTarget2;
+		composer.render(deltaTime);
+	};
+	const renderPass = new three_addons_postprocessing_RenderPass_js.RenderPass(scene, camera);
+	composer.addPass(renderPass);
+	let gtaoPass = null;
+	if (options.ambientOcclusion ?? true) {
+		gtaoPass = new three_addons_postprocessing_GTAOPass_js.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 three_addons_postprocessing_ShaderPass_js.ShaderPass(HDR_CLAMP_SHADER);
+		composer.addPass(clampPass);
+		bloomPass = new three_addons_postprocessing_UnrealBloomPass_js.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 three_addons_postprocessing_SMAAPass_js.SMAAPass();
+	composer.addPass(smaaPass);
+	const outputPass = new three_addons_postprocessing_OutputPass_js.OutputPass();
+	composer.addPass(outputPass);
+	renderer.toneMapping = options.toneMapping;
+	renderer.toneMappingExposure = options.toneMappingExposure;
+	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,
+		dispose: () => {
+			composer.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 three_addons_controls_OrbitControls_js.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 three_addons_loaders_HDRLoader_js.HDRLoader().load(config.environment.hdrPath || "/baseHDR.hdr", function(envMap) {
+			if (isDisposed()) {
+				envMap.dispose();
+				return;
+			}
+			if (!envMap?.image) {
+				require_gpu_dispose.getLogger().warn("HDR loaded without image data; skipping environment map.");
+				envMap?.dispose();
+				config.events.onReady?.();
+				return;
 			}
-			if (coverage <= 0.0) discard;
-			gl_FragColor = vec4(uColor, coverage);
+			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;
+			require_gpu_dispose.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()) {
+			require_gpu_dispose.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);
 		}
-	`};function At(e){return e instanceof r.Mesh&&!(e instanceof r.InstancedMesh)&&!e.geometry.isInstancedBufferGeometry}function jt(e){let t=new r.BufferGeometry,i=new r.MeshBasicMaterial({side:r.DoubleSide,toneMapped:!1}),a=new r.Mesh(t,i);a.frustumCulled=!1,a.matrixWorldAutoUpdate=!1;let o=new r.WebGLRenderTarget(1,1,{depthBuffer:!1}),s=new r.ShaderMaterial({...kt,uniforms:{tMask:{value:o.texture},uTexel:{value:new r.Vector2},uRadius:{value:1},uColor:{value:new r.Color(Ot).convertLinearToSRGB()}},transparent:!0,depthTest:!1,depthWrite:!1,toneMapped:!1}),c=new _.FullScreenQuad(s),l=null,u=null,d=new r.Vector2,f=new r.Color,p=()=>{l=null,u=null,t.deleteAttribute(`position`),t.setIndex(null)},m=(e,n)=>{if(p(),!e||!At(e))return!1;let r=e.geometry.getAttribute(`position`);if(!r)return!1;if(n===null)t.setDrawRange(0,1/0);else{let r=Z(e)?.[n];if(r?.indexStart==null||r.indexCount==null)return!1;t.setDrawRange(r.indexStart,r.indexCount)}return t.setAttribute(`position`,r),t.setIndex(e.geometry.getIndex()),e.updateWorldMatrix(!0,!1),a.matrixWorld.copy(e.matrixWorld),l=e,u=n,!0},h=()=>l?.visible?u===null||!n.r(l).has(u):!1;return{show:m,render:t=>{if(!h())return;e.getDrawingBufferSize(d),o.setSize(d.x,d.y),s.uniforms.uTexel.value.set(1/d.x,1/d.y),s.uniforms.uRadius.value=2*e.getPixelRatio();let n=e.autoClear,r=e.getClearAlpha();e.getClearColor(f),e.setRenderTarget(o),e.setClearColor(0,0),e.clear(),e.autoClear=!1,e.render(a,t),e.setRenderTarget(null),e.setClearColor(f,r),c.render(e),e.autoClear=n},dispose:()=>{p(),t.dispose(),i.dispose(),s.dispose(),c.dispose(),o.dispose()}}}function Mt(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)}else`color`in e&&(e.color=t.clone())}function Nt(e,i,a,o){let s=/* @__PURE__ */ new Set,c=/* @__PURE__ */ new Map,l=[],u=null,d=!1,f=new r.Raycaster,p=new r.Vector2,m=new r.Vector2,h=()=>a.getActiveCamera(),g=e=>{let t=e;for(;t;){if(!t.visible)return!1;t=t.parent}return!0},_=()=>{let e=z(i);e.isEmpty()?t.p().warn(`No objects to fit to view`):a.frameBounds(e,!1)},v=typeof o.events.selectionColor==`string`?new r.Color(o.events.selectionColor):o.events.selectionColor instanceof r.Color?o.events.selectionColor:new r.Color(`#ff0000`),y=new r.Color(Ot),b=null,x=null,S=()=>{if(b&&x){let e=b.material;e instanceof r.Material&&e.dispose(),b.material=x}b=null,x=null},C=e=>{if(S(),!e||s.has(e))return;let t=e;if(!(t.material instanceof r.Material))return;let n=t.material.clone();Mt(n,y,e instanceof r.Mesh),b=t,x=t.material,t.material=n},w=()=>{for(let{restore:e,material:t}of l)e(),t.dispose();l.length=0,s.forEach(e=>{let t=e;if(c.has(e)){let n=c.get(e),a=t.material;a instanceof r.Material?a.dispose():Array.isArray(a)&&a.forEach(e=>e.dispose()),t.material=n,c.delete(e);let o=e;for(;o.parent;)o=o.parent;o!==i&&(n instanceof r.Material?n.dispose():n.forEach(e=>e.dispose()))}}),s.clear(),u=null,d=!1},T=(e,t)=>{if(t&&e instanceof r.Mesh){let r=n.n(e).clone();return Mt(r,v,!0),l.push({restore:we(e,t,r),material:r}),!0}let i=e;if(!(i.material instanceof r.Material))return!1;let a=i.material.clone();return Mt(a,v,e instanceof r.Mesh),c.set(e,i.material),i.material=a,!0},E=e=>{if(e.length===0&&!d)return;S(),w();let t=/* @__PURE__ */ new Map;for(let{object:n,memberIndex:r}of e){if(r===null){s.add(n),T(n,null);continue}let e=t.get(n);e||t.set(n,e=/* @__PURE__ */ new Set),e.add(r)}for(let[e,n]of t)s.add(e),T(e,n);d=e.length>0},D=null,O=-1,k=()=>{if(D===null||i.children.length!==O){let e=z(i);D=e.isEmpty()?1:e.getSize(new r.Vector3).length(),O=i.children.length}f.params.Points.threshold=D*.01},A=(t,n)=>{let r=e.getBoundingClientRect();p.x=(t-r.left)/r.width*2-1,p.y=-((n-r.top)/r.height)*2+1,k(),f.setFromCamera(p,h());for(let e of f.intersectObjects(i.children,!0))if(g(e.object)&&!R(e.object))return e;return null},j=e=>{m.set(e.clientX,e.clientY)},M=e=>{let t=new r.Vector2(e.clientX,e.clientY);if(m.distanceTo(t)>5)return;let n=A(e.clientX,e.clientY);if(!n){w(),o.events?.onBackgroundClicked?.({x:p.x,y:p.y});return}let i=n.object,a=Se(n),c=a?.index??null;(d||!s.has(i)||c!==u)&&(S(),w(),s.add(i),u=c,T(i,a?/* @__PURE__ */ new Set([a.index]):null),o.events?.onObjectSelected?.(i),a?o.events?.onMeshMetadataClicked?.({source:i.userData?.source,name:a.member.name,layer:a.member.layer,trackingKey:a.member.trackingKey,metadata:a.member.metadata}):i instanceof r.Mesh&&Object.keys(i.userData).length>0&&o.events?.onMeshMetadataClicked?.(i.userData))},N=e=>{let t=A(e.clientX,e.clientY);if(!t){o.events?.enableDoubleClickZoom&&a.frameBounds(z(i),!0);return}let n=t.object;if(o.events?.onMeshDoubleClicked?.(n),!o.events?.enableDoubleClickZoom)return;let s=Se(t),c=s&&n instanceof r.Mesh?Ce(n,s.member):new r.Box3().setFromObject(n);c.isEmpty()||a.frameBounds(c,!0)},P=e=>{if(o.events?.enableKeyboardControls)switch(e.key.toLowerCase()){case`f`:e.preventDefault(),_();break;case`escape`:e.preventDefault(),w();break;case` `:e.preventDefault(),_()}};return o.events?.enableClickToFocus&&(e.addEventListener(`mousedown`,j),e.addEventListener(`click`,M),e.addEventListener(`dblclick`,N)),o.events?.enableKeyboardControls&&(e.setAttribute(`tabindex`,`0`),e.addEventListener(`keydown`,P)),{dispose:()=>{e.removeEventListener(`mousedown`,j),e.removeEventListener(`click`,M),e.removeEventListener(`dblclick`,N),e.removeEventListener(`keydown`,P),S(),w()},fitToView:_,clearSelection:w,selectEntries:E,setHoverTint:C}}function Pt(e,t){let n=new r.AmbientLight(t.lighting.ambientLightColor,t.lighting.ambientLightIntensity);e.add(n);let i=null;if(t.lighting.enableHemisphereLight){i=new r.HemisphereLight(t.lighting.hemisphereSkyColor,t.lighting.hemisphereGroundColor,t.lighting.hemisphereIntensity);let n=t.environment.sceneUp??Q;i.position.copy(n),e.add(i)}if(!t.lighting.enableSunlight)return{ambient:n,hemisphere:i,sun:null};let a=new r.DirectionalLight(t.lighting.sunlightColor??16777215,t.lighting.sunlightIntensity),o=t.lighting.sunlightPosition;return o&&a.position.set(o.x,o.y,o.z),t.render.enableShadows?(a.castShadow=!0,a.shadow.mapSize.width=t.render.shadowMapSize||2048,a.shadow.mapSize.height=t.render.shadowMapSize||2048,a.shadow.bias=-1e-4,a.shadow.normalBias=.02,a.shadow.radius=4,e.add(a),e.add(a.target),{ambient:n,hemisphere:i,sun:a}):(e.add(a),{ambient:n,hemisphere:i,sun:null})}function Ft(e,t){if(t.isEmpty())return;let n=t.getCenter(new r.Vector3),i=t.getSize(new r.Vector3).length()*.5*1.2,a=e.shadow.camera;a.left=-i,a.right=i,a.top=i,a.bottom=-i,e.target.position.copy(n),e.target.updateMatrixWorld();let o=e.position.distanceTo(n);a.near=Math.max(i*.01,o-i),a.far=o+i,a.updateProjectionMatrix()}function It(e,t,n){let i=new r.WebGLRenderer({antialias:t.render.antialias,canvas:e,alpha:!0,powerPreference:`high-performance`,preserveDrawingBuffer:t.render.preserveDrawingBuffer,logarithmicDepthBuffer:!1}),a=e.parentElement,o=a?a.clientWidth:window.innerWidth,s=a?a.clientHeight:window.innerHeight;return a&&(e.style.width=`100%`,e.style.height=`100%`,e.style.display=`block`),i.setSize(o,s,!1),i.setPixelRatio(n),t.render.enableShadows&&(i.shadowMap.enabled=!0,i.shadowMap.type=r.VSMShadowMap),i.toneMapping=t.render.toneMapping,i.toneMappingExposure=t.render.toneMappingExposure??1,i.outputColorSpace=r.SRGBColorSpace,i.sortObjects=!0,i}const Lt=function(e,n){let i=dt(n||{}),a=i.environment?.sceneUp||Q,o=i.render.pixelRatio??Math.min(window.devicePixelRatio,2),s=vt(i),c=_t(i,e);c.up.copy(a);let l=It(e,i,o);t.r(l.capabilities.getMaxAnisotropy()),n?.onMaxAnisotropy?.(l.capabilities.getMaxAnisotropy());let u=Tt(c,e,i),d=ae({scene:s,perspective:c,controls:u,onActiveCameraChange:()=>{},up:a}),f=()=>d.getActiveCamera(),p=!1;Et(s,l,i,()=>p);let m=Pt(s,i),h=m.sun,g=()=>{h&&Ft(h,z(s))};i.floor?.enabled&&Dt(s,i);let _=i.floor?.enabled?s.children.find(e=>e.userData.id===`floor`)??null:null,v=i.grid.enabled?Ge({cellSize:i.grid.cellSize,majorEvery:i.grid.majorEvery,cellColor:i.grid.cellColor,majorColor:i.grid.majorColor,fadeDistance:i.grid.fadeDistance,plane:i.grid.plane}):null;v&&s.add(v.object);let y=()=>{v&&v.fitToContent(z(s))},b=i.gizmo.enabled?lt({camera:c,domElement:e,controller:d}):null,S=i.grid.plane??ee(a),w=new r.Vector3(+(S===`x`),+(S===`y`),+(S===`z`)),T=a.clone().normalize(),D=i.camera.dynamicNear?tt({camera:c,scene:s,groundNormals:()=>{let e=[];return v?.object.visible&&e.push(w),i.floor.enabled&&_?.visible&&e.push(T),e}}):null,O=Ke(e.parentElement??e,s),k=i.measure.enabled?$e({canvas:e,scene:s,getActiveCamera:f,labelLayer:O,options:{snapPixels:i.measure.snapPixels,color:i.measure.color,labelClassName:i.measure.labelClassName,displayUnit:i.measure.displayUnit,format:i.measure.format}}):null,A=i.events.enableEventHandlers===!1?{dispose:()=>{},fitToView:()=>{},clearSelection:()=>{},selectEntries:()=>{},setHoverTint:()=>{}}:Nt(e,s,d,i),j=jt(l),M=st();k&&M.register({id:`measure`,tool:k,priority:0}),b&&M.register({id:`gizmo`,tool:b,priority:-100});let N=0,P=0,F=e=>{N=e.clientX,P=e.clientY},I=e=>Math.hypot(e.clientX-N,e.clientY-P)>5,te=e=>{I(e)||M.handleClick(e)&&e.stopImmediatePropagation()};e.addEventListener(`mousedown`,F,{capture:!0}),e.addEventListener(`click`,te,{capture:!0});let ne=e=>M.handleMove(e);e.addEventListener(`mousemove`,ne,{passive:!0});let L=()=>{},R=(e,t)=>{He(e,{color:i.edges.color,darken:i.edges.darken,width:i.edges.width,thresholdAngle:i.edges.thresholdAngle,distanceFade:i.edges.distanceFade,maxTriangles:i.edges.maxTriangles,maxSegments:i.edges.maxSegments,maxOverlays:i.edges.maxOverlays,...t}).then(()=>{re(e),L()})},re=e=>{if(i.edges.screenSpaceFallback===!1)return;let t=!1;e.traverse(e=>{let n=e.userData?.edgesSkipped;(n===`triangle-cap`||n===`overlay-budget`)&&(t=!0)}),H.setEdgeFallback(t)},ie=e=>{Ue(e),H.setEdgeFallback(!1),L()},B=e.parentElement,V=()=>B?{width:B.clientWidth,height:B.clientHeight}:{width:window.innerWidth,height:window.innerHeight},H=wt({renderer:l,scene:s,getActiveCamera:f,getCanvasSize:V,pixelRatio:o,config:i,requestRender:()=>L()});H.sync();let U=gt({scene:s,renderer:l,lights:m,config:i,pipeline:H,requestRender:()=>L()}),{animate:oe,dispose:se,invalidate:W,renderNow:G}=ut(l,s,c,f,d,u,V,o,i.events.onFrame,v,b,()=>H.get(),O,D,i.render.onDemand??!0,j);return L=W,oe(),s.up.set(a.x,a.y,a.z),g(),y(),{scene:s,camera:c,controls:u,renderer:l,cameraController:d,grid:v,gizmo:b,measureTool:k,labelLayer:O,tools:M,applyEdges:R,clearEdges:ie,invalidate:W,captureImage:(e=`image/png`,t)=>(G(),new Promise(n=>l.domElement.toBlob(n,e,t))),setAmbientOcclusion:H.setAmbientOcclusion,setLook:U.setLook,setFillLights:U.setFillLights,setEnvironmentIntensity:U.setEnvironmentIntensity,setToneMappingExposure:U.setToneMappingExposure,setAoIntensity:U.setAoIntensity,getMaterialAppearance:U.getMaterialAppearance,updateShadowBounds:g,updateGridScale:y,dispose:()=>{p||(p=!0,se(),A.dispose(),e.removeEventListener(`mousedown`,F,{capture:!0}),e.removeEventListener(`click`,te,{capture:!0}),e.removeEventListener(`mousemove`,ne),k?.dispose(),O?.dispose(),j.dispose(),b?.dispose(),v?.dispose(),H.dispose(),d.dispose(),u.dispose(),l.dispose(),l.forceContextLoss(),yt(s))},fitToView:A.fitToView,clearSelection:A.clearSelection,selectEntries:e=>{A.selectEntries(e),W()},setHover:(e,t=null)=>{let n=j.show(e,t);A.setHoverTint(n?null:e),W()},addUserGeometry:(e,t)=>{e.userData.source=t===void 0?x:C(t),s.add(e),L()},removeUserGeometry:e=>{e.removeFromParent(),t.t(e),L()},clearUserGeometry:e=>{s.children.filter(t=>E(t,e)).forEach(e=>{e.removeFromParent(),t.t(e)}),L()}}};exports.DEFAULT_LOOK=t.s,exports.ErrorCodes=t.h,exports.LOOKS=b,exports.LOOK_PRESETS=t.c,exports.SOURCE_COMPUTE=`compute`,exports.SOURCE_USER=x,exports.VisualizationError=t.g,exports.appIdFromSource=w,exports.appSource=C,exports.enableDebugLogging=t.f,exports.getLogger=t.p,exports.initThree=Lt,exports.isHostOwned=T,exports.isOwnedBy=E,exports.materialAppearanceForLook=t.d,exports.pickThreshold=Xe,exports.pointerToNdc=ct,exports.setLogger=t.m,exports.snapToVertex=Qe,exports.updateScene=te;
+		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 = require_merged_draw.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 = require_merged_draw.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 = require_merged_draw.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 = require_merged_draw.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, require_gpu_dispose.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);
+	require_gpu_dispose.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,
+		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()
+	});
+	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);
+	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();
+		require_gpu_dispose.disposeObjectTree(object);
+		requestRender();
+	};
+	const clearUserGeometry = (appId) => {
+		scene.children.filter((child) => isOwnedBy(child, appId)).forEach((object) => {
+			object.removeFromParent();
+			require_gpu_dispose.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
+	};
+};
+exports.DEFAULT_LOOK = require_gpu_dispose.DEFAULT_LOOK;
+exports.ErrorCodes = require_gpu_dispose.ErrorCodes;
+exports.LOOKS = LOOKS;
+exports.LOOK_PRESETS = require_gpu_dispose.LOOK_PRESETS;
+exports.SOURCE_COMPUTE = SOURCE_COMPUTE;
+exports.SOURCE_USER = SOURCE_USER;
+exports.VisualizationError = require_gpu_dispose.VisualizationError;
+exports.appIdFromSource = appIdFromSource;
+exports.appSource = appSource;
+exports.enableDebugLogging = require_gpu_dispose.enableDebugLogging;
+exports.getLogger = require_gpu_dispose.getLogger;
+exports.initThree = initThree;
+exports.isHostOwned = isHostOwned;
+exports.isOwnedBy = isOwnedBy;
+exports.materialAppearanceForLook = require_gpu_dispose.materialAppearanceForLook;
+exports.pickThreshold = pickThreshold;
+exports.pointerToNdc = pointerToNdc;
+exports.setLogger = require_gpu_dispose.setLogger;
+exports.snapToVertex = snapToVertex;
+exports.updateScene = updateScene;
+
 //# sourceMappingURL=render.cjs.map