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

package/dist/parse.cjs

@@ -1,5 +1,1835 @@
-Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=require("./rolldown-runtime-BocRIvOZ.cjs"),t=require("./gpu-dispose-GZmNW-gK.cjs");let n=require("three");n=e.t(n,1);let r=require("three/addons/lines/Line2.js"),i=require("three/addons/lines/LineGeometry.js"),a=require("three/addons/lines/LineMaterial.js"),o=require("fflate");function s(){let e=globalThis.Buffer;return typeof e==`function`?e:void 0}function c(e){let t=e.replace(/[\t\n\f\r ]/g,``);return t.length%4==0&&(t=t.replace(/={1,2}$/,``)),t.length%4==1?null:t}function l(e){let n=c(e),r=n===null?null:u(n);if(r===null)throw new t.g(`Invalid base64 input.`,t.h.ENCODING_ERROR,{context:{inputLength:e.length}});return r}function u(e){let n=s();if(n){if(n.byteLength(e,`utf8`)!==e.length||e.includes(`-`)||e.includes(`_`))return null;let t=n.from(e,`base64`);return t.length===Math.floor(e.length*3/4)?t.byteOffset===0&&t.buffer.byteLength===t.length?new Uint8Array(t.buffer,0,t.length):new Uint8Array(t):null}if(typeof globalThis.atob==`function`){let t;try{t=globalThis.atob(e)}catch{return null}let n=new Uint8Array(t.length);for(let e=0;e<t.length;e++)n[e]=t.charCodeAt(e)&255;return n}throw new t.g(`Base64 decoding not supported in this environment.`,t.h.INVALID_STATE,{context:{environmentInfo:`atob or Buffer not available`}})}function d(e){return e.map(e=>{let t=e.clone(!0),n=[];e.traverse(e=>n.push(e));let r=0;return t.traverse(e=>{let t=n[r++],i=e;t.geometry&&(i.geometry=t.geometry.clone())}),t})}function f(e){e.forEach(e=>t.t(e,{materials:!1}))}const p={clone:d,release:f};function m(e,t){let r=t??1;return{color:new n.Color(e??`#ffffff`),transparent:r<1,opacity:r}}function h(e){let t=g(e);if(!t)return null;let n=new i.LineGeometry;n.setPositions(t);let o=m(e.color,e.opacity),s=new a.LineMaterial({color:o.color}),c=s;c.linewidth=e.width??2,c.transparent=o.transparent,c.opacity=o.opacity;let l=new r.Line2(n,s);return l.computeLineDistances(),l.name=e.name,l.userData={source:`compute`,id:e.id,layer:e.layer,kind:`curve`,metadata:e.metadata},l}function g(e){if(!e.points)throw new t.g(`Curve display item '${e.id}' has no tessellated points. It was produced by an outdated Display component — upgrade it in Grasshopper (Solution → Upgrade obsolete components) and re-save the definition.`,t.h.INVALID_CONFIG,{context:{itemId:e.id,kind:e.kind}});return e.points.length>=6?e.points:null}function _(e){let{position:r}=e;if(!r||typeof r.X!=`number`||!Number.isFinite(r.X)||typeof r.Y!=`number`||!Number.isFinite(r.Y)||typeof r.Z!=`number`||!Number.isFinite(r.Z))return t.p().warn(`Skipping point display item with missing or non-finite position (id: ${String(e.id)}).`),null;let i=new n.BufferGeometry;i.setAttribute(`position`,new n.Float32BufferAttribute([r.X,r.Y,r.Z],3));let a=new n.PointsMaterial({...m(e.color,e.opacity),size:6,sizeAttenuation:!1}),o=new n.Points(i,a);return o.name=e.name,o.userData={source:`compute`,id:e.id,layer:e.layer,kind:`point`,metadata:e.metadata},o}function v(e){if(!e||e.length===0)return[];let n=[];for(let r of e)switch(r.kind){case`curve`:{let e=h(r);e&&n.push(e);break}case`point`:{let e=_(r);e&&n.push(e);break}default:{let e=r;t.p().warn(`Skipping unknown display item kind: ${String(e.kind)}`);break}}return n}const y=new Uint16Array(new Uint8Array([1,0]).buffer)[0]===1;function b(e){return typeof e==`string`?l(e):e instanceof Uint8Array?e:new Uint8Array(e)}function x(e){if(e.byteLength<8)return e;let t=new DataView(e.buffer,e.byteOffset,e.byteLength);if(t.getUint32(0,!0)!==1515605075)return e;let n=t.getUint32(4,!0),r=e.subarray(8),i=Math.max(r.byteLength*1032+1024,1<<20);if(n>i)throw F(`SLVZ header declares an implausible uncompressed length`,{uncompressedLen:n,deflatedBytes:r.byteLength,maxPlausibleLen:i});let a;try{a=(0,o.inflateSync)(r,{out:new Uint8Array(n+1)})}catch(e){throw F(`Failed to inflate SLVZ blob: ${e instanceof Error?e.message:String(e)}`,{uncompressedLen:n,deflatedBytes:r.byteLength})}if(a.byteLength!==n)throw F(`SLVZ payload inflated to a different size than the header declares.`,{declaredLen:n,actualLen:a.byteLength,deflatedBytes:r.byteLength});return a}function S(e){if(typeof TextDecoder<`u`)return new TextDecoder(`utf-8`).decode(e);if(globalThis.Buffer!==void 0)return globalThis.Buffer.from(e).toString(`utf-8`);throw new t.g(`No UTF-8 decoder available in this environment.`,t.h.INVALID_STATE)}function C(e,t,n){if(n===0)return new Int16Array;if(t%2==0)return new Int16Array(e,t,n);let r=new Uint8Array(n*2);return r.set(new Uint8Array(e,t,n*2)),new Int16Array(r.buffer)}function w(e,t,n){if(n===0)return new Float32Array;if(t%4==0)return new Float32Array(e,t,n);let r=new Uint8Array(n*4);return r.set(new Uint8Array(e,t,n*4)),new Float32Array(r.buffer)}function T(e,t,n){if(n===0)return new Uint16Array;if(t%2==0)return new Uint16Array(e,t,n);let r=new Uint8Array(n*2);return r.set(new Uint8Array(e,t,n*2)),new Uint16Array(r.buffer)}function E(e,t,n){if(n===0)return new Uint32Array;if(t%4==0)return new Uint32Array(e,t,n);let r=new Uint8Array(n*4);return r.set(new Uint8Array(e,t,n*4)),new Uint32Array(r.buffer)}function D(e,t){if(e.length!==0&&!(e instanceof Uint16Array&&t>65535)){for(let n=0;n<e.length;n++)if(e[n]>=t)throw F(`Index out of range of vertexCount.`,{indexPosition:n,indexValue:e[n],vertexCount:t})}}function O(e){return e>>>1^-(e&1)}function k(e){let t=new Int16Array(e.length),n=0,r=0,i=0;for(let a=0;a<e.length;a+=3)n=n+O(e[a])<<16>>16,r=r+O(e[a+1])<<16>>16,i=i+O(e[a+2])<<16>>16,t[a]=n,t[a+1]=r,t[a+2]=i;return t}function A(e,t){let n=new Int16Array(t*3),r=t,i=0,a=0,o=0;for(let t=0;t<r;t++)i=i+O(e[t]|e[r*3+t]<<8)<<16>>16,a=a+O(e[r+t]|e[r*4+t]<<8)<<16>>16,o=o+O(e[r*2+t]|e[r*5+t]<<8)<<16>>16,n[t*3]=i,n[t*3+1]=a,n[t*3+2]=o;return n}function j(e,t){let n=new Uint16Array(t),r=0;for(let i=0;i<t;i++)r=r+O(e[i]|e[t+i]<<8)&65535,n[i]=r;return n}function M(e,t){let n=new Uint32Array(t),r=0;for(let i=0;i<t;i++){let a=(e[i]|e[t+i]<<8|e[t*2+i]<<16|e[t*3+i]<<24)>>>0;r=r+O(a)>>>0,n[i]=r}return n}function N(e){let t=new Uint16Array(e.length),n=0;for(let r=0;r<e.length;r++)n=n+O(e[r])&65535,t[r]=n;return t}function P(e){let t=new Uint32Array(e.length),n=0;for(let r=0;r<e.length;r++)n=n+O(e[r])>>>0,t[r]=n;return t}function F(e,n){return new t.g(e,t.h.VALIDATION_ERROR,{context:n})}function ee(e,t,n,r,i,a=!1){if(n+36>e.byteLength)throw F(`Insufficient data to read UV chunk header.`,{expectedBytes:36,availableBytes:e.byteLength-n,offset:n});let o=t.getUint32(n,!0);n+=4;let s=t.getFloat64(n,!0);n+=8;let c=t.getFloat64(n,!0);n+=8;let l=t.getFloat64(n,!0);n+=8;let u=t.getFloat64(n,!0);n+=8;let d=r*2,f=o===1,p=d*(f?4:2);if(n+p>e.byteLength)throw F(`Insufficient data to read UV chunk.`,{expectedBytes:p,availableBytes:e.byteLength-n,offset:n,uvFormat:o,vertexCount:r});let m=e.byteOffset+n,h;if(f)h=w(e.buffer,m,d).slice();else if(a){let t=e.subarray(n,n+p),i=r;h=new Float32Array(d);let a=0,o=0;for(let e=0;e<i;e++)a=a+O(t[e]|t[i*2+e]<<8)&65535,o=o+O(t[i+e]|t[i*3+e]<<8)&65535,h[e*2]=s+a*l,h[e*2+1]=c+o*u}else{let t=T(e.buffer,m,d);h=new Float32Array(d);let n=0,r=0;for(let e=0;e<d;e+=2)i?(n=n+O(t[e])&65535,r=r+O(t[e+1])&65535):(n=t[e],r=t[e+1]),h[e]=s+n*l,h[e+1]=c+r*u}return{uvs:h,offset:n+p}}function te(e,t,n,r){let i=n*3;if(t+i>e.byteLength)throw F(`Insufficient data to read vertex-color chunk.`,{expectedBytes:i,availableBytes:e.byteLength-t,offset:t,vertexCount:n});let a=e.subarray(t,t+i);if(!r)return a.slice();let o=new Uint8Array(i),s=0,c=0,l=0;for(let e=0;e<i;e+=3)s=s+O(a[e])&255,c=c+O(a[e+1])&255,l=l+O(a[e+2])&255,o[e]=s,o[e+1]=c,o[e+2]=l;return o}function ne(e){return e.byteLength>=4&&new DataView(e.buffer,e.byteOffset,4).getUint32(0,!0)===1297501267}function re(e){let t=I(e),n=null,r=null,i=null,a=[];for(let{type:e,payload:o}of t)switch(e){case 1297040711:n=o;break;case 1279410516:r=x(o);break;case 1280590157:i=S(o);break;case 1381516628:a.push(o)}if(n===null)throw F(`SLVM container has no GEOM chunk.`,{chunkCount:t.length});if(r===null)throw F(`SLVM container has no TABL chunk.`,{chunkCount:t.length});let{groups:o}=z(r),s=B(i,a);return{geometryBlob:n,metadata:{materials:s,groups:o}}}function I(e){let t=new DataView(e.buffer,e.byteOffset,e.byteLength);if(e.byteLength<12||t.getUint32(0,!0)!==1297501267)throw F(`Not an SLVM container (bad magic).`,{byteLength:e.byteLength});let n=t.getUint32(4,!0);if(n!==3)throw F(`Unsupported SLVM version: ${n}`,{expectedVersion:3});let r=t.getUint32(8,!0),i=[],a=12;for(let n=0;n<r;n++){if(a+8>e.byteLength)throw F(`Truncated SLVM chunk header.`,{offset:a,chunkIndex:n});let r=t.getUint32(a,!0),o=t.getUint32(a+4,!0);if(a+=8,a+o>e.byteLength)throw F(`Truncated SLVM chunk payload.`,{offset:a,chunkIndex:n,byteLen:o});i.push({type:r,payload:e.subarray(a,a+o)}),a+=o+(4-o%4)%4}return i}function L(e){let t=0,n=0;for(;;){if(e.pos>=e.bytes.byteLength||n>28)throw F(`Malformed varint in SLVM table.`,{pos:e.pos});let r=e.bytes[e.pos++];if(t|=(r&127)<<n,!(r&128))return t>>>0;n+=7}}function R(e,t,n){let r=e.bytes[e.pos++],i=Array(t);switch(r){case 0:i.fill(``);break;case 1:for(let e=0;e<t;e++)i[e]=String(e+1);break;case 2:for(let r=0;r<t;r++)i[r]=n[L(e)]??``;break;default:throw F(`Unknown SLVM string column mode: ${r}`,{pos:e.pos})}return i}function z(e){let t={bytes:e,pos:0},n=L(t),r=L(t),i=L(t),a=n+r+i,o=L(t),s=Array(o);for(let n=0;n<o;n++){let r=L(t);s[n]=S(e.subarray(t.pos,t.pos+r)),t.pos+=r}let c=Array(n),l=Array(n);for(let e=0;e<n;e++)c[e]=L(t),l[e]=L(t);for(let e=0;e<r;e++)L(t);let u=L(t),d=[];for(let e=0;e<u;e++)d.push({materialId:L(t),meshCount:L(t)});let f=R(t,a,s),p=R(t,a,s),m=Array(a),h=L(t);for(let e=0;e<h;e++){let e=s[L(t)]??``,n=L(t),r=Array(n),i=0;for(let e=0;e<n;e++)i+=L(t),r[e]=i;for(let i=0;i<n;i++){let n=s[L(t)]??``,a=r[i];(m[a]??={})[e]=n}}let g=d.length>0||n===0?d:[{materialId:0,meshCount:n}],_=[],v=0,y=0,b=0;for(let e of g){let t=[];for(let r=0;r<e.meshCount&&v<n;r++,v++){let e=m[v],n=e?.id;e!==void 0&&delete e.id,t.push({id:n,name:f[v],layer:p[v],vertexCount:c[v],indexCount:l[v]*3,vertexStart:y,indexStart:b,metadata:e??{}}),y+=c[v],b+=l[v]*3}_.push({materialId:e.materialId,meshes:t})}return{groups:_}}function B(e,t){if(e===null)return[];let n;try{n=JSON.parse(e).materials??[]}catch(t){throw F(`Failed to parse SLVM materials JSON: ${t instanceof Error?t.message:String(t)}`,{byteLength:e.length})}for(let e of n)for(let n of ie){let r=e[n];if(r?.startsWith(`slvm:tex:`)){let i=t[Number(r.slice(9))];i!==void 0&&(e[n]=ae(i))}}return n}const ie=[`map`,`roughnessMap`,`normalMap`];function ae(e){let t={bytes:e,pos:0},n=L(t),r=S(e.subarray(t.pos,t.pos+n)),i=e.subarray(t.pos+n),a=``,o=32768;for(let e=0;e<i.byteLength;e+=o)a+=String.fromCharCode(...i.subarray(e,e+o));return`data:${r};base64,${btoa(a)}`}function oe(e){let t=V(e),n;n=t.isFloat32?t.vertexData:t.planarByteSplit?A(t.vertexData,t.vertexCount):t.deltaEncoded?k(t.vertexData):t.vertexData;let r;if(t.planarByteSplit){let e=t.indexData;r=t.uint16Indices?j(e,e.length/2):M(e,e.length/4)}else r=t.deltaEncoded?t.indexData instanceof Uint16Array?N(t.indexData):P(t.indexData):t.indexData;return D(r,t.vertexCount),{metadata:t.metadata,flags:t.flags,vertices:n,indices:r,origin:t.origin,scale:t.scale,uvs:t.uvs,colors:t.colors}}function V(e){if(!y)throw new t.g(`SLVA parsing requires a little-endian host: the zero-copy geometry readers view the wire bytes in host byte order.`,t.h.ENVIRONMENT_ERROR);let n=b(e);if(ne(n)){let e=re(n),t=V(e.geometryBlob);return t.metadata=e.metadata,t}let r=x(n),i=new DataView(r.buffer,r.byteOffset,r.byteLength);if(r.byteLength<12)throw F(`Blob too small to contain SLVA header.`,{expectedBytes:12,availableBytes:r.byteLength});let a=0,o=i.getUint32(a,!0);if(a+=4,o!==1096174675)throw F(`Invalid SLVA magic: 0x${o.toString(16)}`,{expectedMagic:`0x41564c53`,actualMagic:`0x${o.toString(16)}`});let s=i.getUint32(a,!0);if(a+=4,s<1||s>4)throw F(`Unsupported SLVA version: ${s}`,{minSupportedVersion:1,maxSupportedVersion:4,actualVersion:s});let c=i.getUint32(a,!0);if(a+=4,a+c>r.byteLength)throw F(`Insufficient data to read metadata JSON.`,{expectedBytes:c,availableBytes:r.byteLength-a,offset:a});let l=r.subarray(a,a+c);a+=c;let u;try{u=c===0?{}:JSON.parse(S(l))}catch(e){throw F(`Failed to parse metadata JSON: ${e instanceof Error?e.message:String(e)}`,{metadataLen:c})}if(a+56>r.byteLength)throw F(`Insufficient data to read geometry header.`,{expectedBytes:56,availableBytes:r.byteLength-a,offset:a});let d=i.getUint32(a,!0);a+=4;let f=i.getFloat64(a,!0);a+=8;let p=i.getFloat64(a,!0);a+=8;let m=i.getFloat64(a,!0);a+=8;let h=i.getFloat64(a,!0);a+=8;let g=i.getFloat64(a,!0);a+=8;let _=i.getFloat64(a,!0);a+=8;let v=i.getUint32(a,!0);a+=4;let D=!!(d&1),O=!!(d&4),k=!!(d&32),A=v*3,j=A*(D?4:2);if(a+j>r.byteLength)throw F(`Insufficient data to read vertices.`,{expectedBytes:j,availableBytes:r.byteLength-a,offset:a,useFloat32:D,vertexCount:v});let M=r.byteOffset+a,N;if(N=D?w(r.buffer,M,A):k?r.subarray(a,a+j):O?T(r.buffer,M,A):C(r.buffer,M,A),a+=j,a+4>r.byteLength)throw F(`Insufficient data to read index count.`,{expectedBytes:4,availableBytes:r.byteLength-a,offset:a});let P=i.getUint32(a,!0);a+=4;let I=!!(d&2),L=P*(I?2:4);if(a+L>r.byteLength)throw F(`Insufficient data to read indices.`,{expectedBytes:L,availableBytes:r.byteLength-a,offset:a,indexCount:P,useUint16Indices:I});let R=k?r.subarray(a,a+L):I?T(r.buffer,r.byteOffset+a,P):E(r.buffer,r.byteOffset+a,P);a+=L;let z=null;if(d&8){let e=ee(r,i,a,v,O,k);z=e.uvs,a=e.offset}let B=null;return d&16&&(B=te(r,a,v,O)),{metadata:u,flags:d,vertexData:N,indexData:R,isFloat32:D,deltaEncoded:O,planarByteSplit:k,uint16Indices:I,vertexCount:v,origin:[f,p,m],scale:[h,g,_],uvs:z,colors:B}}function se(e,t,n){if(n.length===0)return!1;let r=e=>{let t=16;for(;t<e*2;)t*=2;return t},i=(n,i)=>{if(i<12||i%3!=0)return!1;let a=0;for(let r=0;r<i;r++){let i=t[n+r]*3;a=Math.max(a,Math.abs(e[i]),Math.abs(e[i+1]),Math.abs(e[i+2]))}if(!(a>0)||!Number.isFinite(a))return!1;let o=1/(2*2**(Math.floor(Math.log2(a))-23)),s=r(i),c=s-1,l=new Int32Array(s).fill(-1),u=new Int32Array(s),d=new Int32Array(s),f=new Int32Array(s),p=(e,t,n)=>{let r=Math.imul(e,2654435761)^Math.imul(t,2246822519)^Math.imul(n,3266489917);for(r=(r^r>>>15)&c;l[r]!==-1&&(u[r]!==e||d[r]!==t||f[r]!==n);)r=r+1&c;return r},m=(e,t)=>{let n=e-t;return n>.25?t+1:n<-.25?t-1:t},h=new Int32Array(i);for(let r=0;r<i;r++){let i=t[n+r],a=e[i*3]*o,s=e[i*3+1]*o,c=e[i*3+2]*o,g=Math.round(a),_=Math.round(s),v=Math.round(c),y=m(a,g),b=m(s,_),x=m(c,v),S=-1;for(let e=0;e<8&&S===-1;e++){if(e&1&&y===g||e&2&&b===_||e&4&&x===v)continue;let t=p(e&1?y:g,e&2?b:_,e&4?x:v);l[t]!==-1&&(S=l[t])}if(S===-1){let e=p(g,_,v);l[e]=i,u[e]=g,d[e]=_,f[e]=v,S=i}h[r]=S}let g=r(i),_=g-1,v=new Int32Array(g).fill(-1),y=new Int32Array(g),b=(e,t)=>{let n=(Math.imul(e,2654435761)^Math.imul(t,2246822519))&_;for(;v[n]!==-1&&(v[n]!==e||y[n]!==t);)n=n+1&_;return n},x=(e,t)=>{let n=b(e,t);return v[n]===-1&&(v[n]=e,y[n]=t,!0)},S=(e,t)=>v[b(e,t)]!==-1,C=0;for(let e=0;e<i;e+=3){let t=h[e],n=h[e+1],r=h[e+2];if(t!==n&&n!==r&&r!==t){if(!x(t,n)||!x(n,r)||!x(r,t))return!1;C++}}if(C<4)return!1;for(let e=0;e<i;e+=3){let t=h[e],n=h[e+1],r=h[e+2];if(t!==n&&n!==r&&r!==t&&(!S(n,t)||!S(r,n)||!S(t,r)))return!1}let w=h[0]*3,T=e[w],E=e[w+1],D=e[w+2],O=0;for(let t=0;t<i;t+=3){let n=h[t]*3,r=h[t+1]*3,i=h[t+2]*3,a=e[n]-T,o=e[n+1]-E,s=e[n+2]-D,c=e[r]-T,l=e[r+1]-E,u=e[r+2]-D,d=e[i]-T,f=e[i+1]-E,p=e[i+2]-D;O+=a*(l*p-u*f)+o*(u*d-c*p)+s*(c*f-l*d)}return O>0},a=0;for(let e of n){if(!i(a,e))return!1;a+=e}return!0}function ce(e,t,n,r){let i=Math.cos(30*Math.PI/180),a=e.length/3,o=t.length,s=o/3;{let i=new Uint32Array(e.buffer,e.byteOffset,e.length),s=n?new Uint32Array(n.buffer,n.byteOffset,n.length):null,c=(e,t)=>e[t]===2147483648?0:e[t],l=(e,t)=>{for(let n=0;n<3;n++)if(c(i,e*3+n)!==c(i,t*3+n)||r&&r[e*3+n]!==r[t*3+n])return!1;return!s||s[e*2]===s[t*2]&&s[e*2+1]===s[t*2+1]},u=16;for(;u<a*2;)u*=2;let d=u-1,f=new Int32Array(u).fill(-1),p=new Uint32Array(a);for(let e=0;e<a;e++){let t=Math.imul(c(i,e*3),2654435761)^Math.imul(c(i,e*3+1),2246822519)^Math.imul(c(i,e*3+2),3266489917);for(t=(t^t>>>15)&d;f[t]!==-1&&!l(f[t],e);)t=t+1&d;f[t]===-1&&(f[t]=e),p[e]=f[t]}for(let e=0;e<o;e++)t[e]=p[t[e]]}let c=new Float32Array(s*3),l=new Float32Array(s);for(let n=0;n<s;n++){let r=t[n*3]*3,i=t[n*3+1]*3,a=t[n*3+2]*3,o=e[i]-e[r],s=e[i+1]-e[r+1],u=e[i+2]-e[r+2],d=e[a]-e[r],f=e[a+1]-e[r+1],p=e[a+2]-e[r+2],m=s*p-u*f,h=u*d-o*p,g=o*f-s*d,_=Math.sqrt(m*m+h*h+g*g);_!==0&&(c[n*3]=m/_,c[n*3+1]=h/_,c[n*3+2]=g/_,l[n]=_)}let u=new Uint32Array(a+1);for(let e=0;e<o;e++)u[t[e]+1]+=1;for(let e=0;e<a;e++)u[e+1]+=u[e];let d=new Uint32Array(o),f=u.slice(0,a);for(let e=0;e<o;e++){let n=t[e];d[f[n]]=e,f[n]+=1}let p=0;for(let e=0;e<a;e++)p=Math.max(p,u[e+1]-u[e]);let m=new Uint32Array(o),h=new Uint32Array(a),g=new Float32Array(Math.max(1,p)*3);for(let e=0;e<a;e++){let t=0;for(let n=u[e];n<u[e+1];n++){let e=d[n],r=Math.floor(e/3)*3,a=c[r],o=c[r+1],s=c[r+2],l=-1;if(a===0&&o===0&&s===0)l=0;else for(let e=0;e<t;e++)if(g[e*3]*a+g[e*3+1]*o+g[e*3+2]*s>=i){l=e;break}l===-1&&(l=t,g[t*3]=a,g[t*3+1]=o,g[t*3+2]=s,t++),m[e]=l}h[e]=Math.max(1,t)}let _=new Uint32Array(a+1);for(let e=0;e<a;e++)_[e+1]=_[e]+h[e]-1;let v=_[a],y=a+v,b=e,x=n,S=r;if(v>0){b=new Float32Array(y*3),b.set(e),x=n?new Float32Array(y*2):null,x&&n&&x.set(n),S=r?new Uint8Array(y*3):null,S&&r&&S.set(r);for(let t=0;t<a;t++)for(let i=1;i<h[t];i++){let o=a+_[t]+i-1;b[o*3]=e[t*3],b[o*3+1]=e[t*3+1],b[o*3+2]=e[t*3+2],x&&n&&(x[o*2]=n[t*2],x[o*2+1]=n[t*2+1]),S&&r&&(S[o*3]=r[t*3],S[o*3+1]=r[t*3+1],S[o*3+2]=r[t*3+2])}}let C=new Float32Array(y*3);for(let e=0;e<o;e++){let n=t[e],r=m[e],i=r===0?n:a+_[n]+r-1;t[e]=i;let o=Math.floor(e/3)*3,s=l[o/3];C[i*3]+=c[o]*s,C[i*3+1]+=c[o+1]*s,C[i*3+2]+=c[o+2]*s}for(let e=0;e<C.length;e+=3){let t=C[e],n=C[e+1],r=C[e+2],i=Math.sqrt(t*t+n*n+r*r)||1;C[e]=t/i,C[e+1]=n/i,C[e+2]=r/i}return{positions:b,normals:C,indices:t,uvs:x,colors:S}}function H(e,t,n,r){let i=e.length/3,a=new Float32Array(i*3),o=new Float32Array(i*3);for(let t=0;t<n.length;t+=3){let i=n[t],s=n[t+1],c=n[t+2],l=e[s*3]-e[i*3],u=e[s*3+1]-e[i*3+1],d=e[s*3+2]-e[i*3+2],f=e[c*3]-e[i*3],p=e[c*3+1]-e[i*3+1],m=e[c*3+2]-e[i*3+2],h=u*m-d*p,g=d*f-l*m,_=l*p-u*f,v=Math.sqrt(h*h+g*g+_*_);if(v===0)continue;let y=(p*_-m*g)/v,b=(m*h-f*_)/v,x=(f*g-p*h)/v,S=(g*d-_*u)/v,C=(_*l-h*d)/v,w=(h*u-g*l)/v,T=r[s*2]-r[i*2],E=r[c*2]-r[i*2],D=r[s*2+1]-r[i*2+1],O=r[c*2+1]-r[i*2+1],k=T*y+E*S,A=T*b+E*C,j=T*x+E*w,M=D*y+O*S,N=D*b+O*C,P=D*x+O*w;for(let e=0;e<3;e++){let r=n[t+e];a[r*3]+=k,a[r*3+1]+=A,a[r*3+2]+=j,o[r*3]+=M,o[r*3+1]+=N,o[r*3+2]+=P}}let s=new Float32Array(i*4);for(let e=0;e<i;e++){let n=t[e*3],r=t[e*3+1],i=t[e*3+2],c=a[e*3]*n+a[e*3+1]*r+a[e*3+2]*i,l=a[e*3]-c*n,u=a[e*3+1]-c*r,d=a[e*3+2]-c*i,f=Math.sqrt(l*l+u*u+d*d);if(!(f>1e-12)){let e=+(Math.abs(n)<.9),t=1-e;l=t*i,u=-e*i,d=e*r-t*n,f=Math.sqrt(l*l+u*u+d*d)||1}l/=f,u/=f,d/=f;let p=r*d-i*u,m=i*l-n*d,h=n*u-r*l,g=p*o[e*3]+m*o[e*3+1]+h*o[e*3+2];s[e*4]=l,s[e*4+1]=u,s[e*4+2]=d,s[e*4+3]=g<0?-1:1}return s}function U(e,t){let n=se(e.positions,e.indices,t),r=ce(e.positions,e.indices,e.uvs,e.colors),i=r.uvs?H(r.positions,r.normals,r.indices,r.uvs):null;return{...r,closed:n,tangents:i}}function le(e){let{isFloat32:t,deltaEncoded:n,planarByteSplit:r,uint16Indices:i,origin:a,scale:o,uvs:s,colors:c,jobs:l}=e,u=e=>e>>>1^-(e&1),d;if(t)d=e.vertexData;else{let t;if(r){let n=e.vertexData,r=n.length/6;t=new Int16Array(r*3);let i=0,a=0,o=0;for(let e=0;e<r;e++)i=i+u(n[e]|n[r*3+e]<<8)<<16>>16,a=a+u(n[r+e]|n[r*4+e]<<8)<<16>>16,o=o+u(n[r*2+e]|n[r*5+e]<<8)<<16>>16,t[e*3]=i,t[e*3+1]=a,t[e*3+2]=o}else if(n){let n=e.vertexData;t=new Int16Array(n.length);let r=0,i=0,a=0;for(let e=0;e<n.length;e+=3)r=r+u(n[e])<<16>>16,i=i+u(n[e+1])<<16>>16,a=a+u(n[e+2])<<16>>16,t[e]=r,t[e+1]=i,t[e+2]=a}else t=e.vertexData;d=new Float32Array(t.length);let i=a[0],s=a[1],c=a[2],l=o[0],f=o[1],p=o[2];for(let e=0;e<t.length;e+=3)d[e]=i+(t[e]+32767)*l,d[e+1]=s+(t[e+1]+32767)*f,d[e+2]=c+(t[e+2]+32767)*p}let f;if(r){let t=e.indexData;if(i){let e=t.length/2,n=new Uint16Array(e),r=0;for(let i=0;i<e;i++)r=r+u(t[i]|t[e+i]<<8)&65535,n[i]=r;f=n}else{let e=t.length/4,n=new Uint32Array(e),r=0;for(let i=0;i<e;i++){let a=(t[i]|t[e+i]<<8|t[e*2+i]<<16|t[e*3+i]<<24)>>>0;r=r+u(a)>>>0,n[i]=r}f=n}}else if(n){let t=e.indexData;if(t instanceof Uint16Array){let e=new Uint16Array(t.length),n=0;for(let r=0;r<t.length;r++)n=n+u(t[r])&65535,e[r]=n;f=e}else{let e=new Uint32Array(t.length),n=0;for(let r=0;r<t.length;r++)n=n+u(t[r])>>>0,e[r]=n;f=e}}else f=e.indexData;let p=d.length/3;for(let e=0;e<f.length;e++)if(f[e]>=p)throw Error(`Index ${f[e]} out of range of vertexCount ${p}`);let m=[];for(let e of l){let t=0,n=0;for(let r of e.windows)t+=r.vertexCount,n+=r.indexCount;let r=new Float32Array(t*3),i=new Uint32Array(n),a=s?new Float32Array(t*2):null,o=c?new Uint8Array(t*3):null,l=0,u=0;for(let t of e.windows){let e=t.vertexStart*3;r.set(d.subarray(e,e+t.vertexCount*3),l*3),a&&s&&a.set(s.subarray(t.vertexStart*2,(t.vertexStart+t.vertexCount)*2),l*2),o&&c&&o.set(c.subarray(e,e+t.vertexCount*3),l*3);let n=t.vertexStart,p=t.vertexStart+t.vertexCount,m=l-t.vertexStart;for(let e=0;e<t.indexCount;e++){let r=f[t.indexStart+e];if(r<n||r>=p)throw Error(`Index ${r} outside vertex window [${n}, ${p})`);i[u+e]=r+m}l+=t.vertexCount,u+=t.indexCount}m.push({positions:r,indices:i,uvs:a,colors:o})}return m}function ue(){return[`const assemble = ${le.toString()};`,`const isClosedSolid = ${se.toString()};`,`const splitCreases = ${ce.toString()};`,`const grainTangents = ${H.toString()};`,`self.onmessage = (event) => {`,`  const { id, input } = event.data;`,`  try {`,`    const geometries = assemble(input).map((g, i) => {`,`      const counts = input.jobs[i].windows.map((w) => w.indexCount);`,`      const closed = isClosedSolid(g.positions, g.indices, counts);`,`      const c = splitCreases(g.positions, g.indices, g.uvs, g.colors);`,`      const tangents = c.uvs ? grainTangents(c.positions, c.normals, c.indices, c.uvs) : null;`,`      return { ...c, closed, tangents };`,`    });`,`    const transfer = [];`,`    for (const g of geometries) {`,`      transfer.push(g.positions.buffer, g.normals.buffer, g.indices.buffer);`,`      if (g.uvs) transfer.push(g.uvs.buffer);`,`      if (g.tangents) transfer.push(g.tangents.buffer);`,`      if (g.colors) transfer.push(g.colors.buffer);`,`    }`,`    self.postMessage({ id, geometries }, transfer);`,`  } catch (error) {`,`    self.postMessage({ id, error: String((error && error.message) || error) });`,`  }`,`};`].join(`
-`)}let W;const G=new Map;let de=1;function fe(){if(W!==void 0)return W;if(typeof Worker>`u`||typeof Blob>`u`||typeof URL>`u`||typeof URL.createObjectURL!=`function`)return W=null,null;try{let e=URL.createObjectURL(new Blob([ue()],{type:`text/javascript`})),t=new Worker(e);t.onmessage=e=>{let{id:t,geometries:n,error:r}=e.data,i=G.get(t);i&&(G.delete(t),n?i.resolve(n):i.reject(Error(r??`mesh assembly failed in worker`)))},t.onerror=()=>{for(let e of G.values())e.reject(Error(`mesh assembly worker crashed`));G.clear(),t.terminate(),W=null},W=t}catch{W=null}return W}function pe(e,t,n){return new Promise((r,i)=>{let a=de++;G.set(a,{resolve:r,reject:i}),e.postMessage({id:a,input:t},n)})}let K=1;function q(e){K=Math.max(1,e)}t.n(q);function J(e,r,i,a){typeof document>`u`||new n.TextureLoader().load(r,t=>{if(t.colorSpace=i===`map`?n.SRGBColorSpace:n.NoColorSpace,t.anisotropy=K,a){let e=t.image,r=e?.width&&e.height?e.height/e.width:1;t.wrapS=n.RepeatWrapping,t.wrapT=n.RepeatWrapping,t.repeat.set(1/a,1/(a*r))}e[i]=t,e.needsUpdate=!0},void 0,e=>{t.p().warn(`Failed to load material ${i} ${r}:`,e)})}const me={brushed:{fibres:[{pitch:.04,length:[2,12],depth:.3},{pitch:.25,length:[5,40],depth:.18}],bands:[]},rolled:{fibres:[{pitch:.3,length:[80,600],depth:.07}],bands:[{width:20,length:1500,depth:.05}]}},he=.35,Y=e=>e.toFixed(4);function ge(e,t){let n=me[e];if(!n||!(t>0))return null;let r=n.fibres.map((e,t)=>`selvaFibres( vUv, footprint, ${Y(e.pitch)}, vec2( ${Y(e.length[0])}, ${Y(e.length[1])} ), ${Y(e.depth)}, ${Y(t*31+3)} )`).join(` + `)||`0.0`,i=n.bands.map(e=>`selvaBand( vUv, footprint, vec2( ${Y(e.length)}, ${Y(e.width)} ), ${Y(e.depth)} )`).join(` + `)||`0.0`;return{key:`finish:${e}:${Y(t)}`,patch:e=>{e.fragmentShader=e.fragmentShader.replace(`#include <common>`,`#include <common>
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_gpu_ownership = require("./gpu-ownership-ADRZBxxs.cjs");
+const require_gpu_dispose = require("./gpu-dispose-Cxu3dFmA.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 fflate = require("fflate");
+// src/shared/encoding.ts
+function getNodeBuffer() {
+	const buf = globalThis.Buffer;
+	return typeof buf === "function" ? buf : void 0;
+}
+/**
+* WHATWG forgiving-base64 normalization without the alphabet check: strip ASCII whitespace, then
+* drop trailing padding where the spec allows it (total length a multiple of 4). `null` when the
+* length can't be base64. The decoders check the alphabet themselves, faster than a regex.
+*/
+function stripBase64(str) {
+	let data = str.replace(/[\t\n\f\r ]/g, "");
+	if (data.length % 4 === 0) data = data.replace(/={1,2}$/, "");
+	return data.length % 4 === 1 ? null : data;
+}
+/**
+* @throws {VisualizationError} `ENCODING_ERROR` if invalid, or `INVALID_STATE` if no decoder is
+*   available in this environment.
+*/
+function decodeBase64ToBinary(base64File) {
+	const data = stripBase64(base64File);
+	const bytes = data === null ? null : decodeStripped(data);
+	if (bytes === null) throw new require_gpu_dispose.VisualizationError("Invalid base64 input.", require_gpu_dispose.ErrorCodes.ENCODING_ERROR, { context: { inputLength: base64File.length } });
+	return bytes;
+}
+/** Decode {@link stripBase64} output; `null` when a character is outside the alphabet. */
+function decodeStripped(data) {
+	const Buffer = getNodeBuffer();
+	if (Buffer) {
+		if (Buffer.byteLength(data, "utf8") !== data.length) return null;
+		if (data.includes("-") || data.includes("_")) return null;
+		const decoded = Buffer.from(data, "base64");
+		if (decoded.length !== Math.floor(data.length * 3 / 4)) return null;
+		return decoded.byteOffset === 0 && decoded.buffer.byteLength === decoded.length ? new Uint8Array(decoded.buffer, 0, decoded.length) : new Uint8Array(decoded);
+	}
+	if (typeof globalThis.atob === "function") {
+		let binary;
+		try {
+			binary = globalThis.atob(data);
+		} catch {
+			return null;
+		}
+		const bytes = new Uint8Array(binary.length);
+		for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i) & 255;
+		return bytes;
+	}
+	throw new require_gpu_dispose.VisualizationError("Base64 decoding not supported in this environment.", require_gpu_dispose.ErrorCodes.INVALID_STATE, { context: { environmentInfo: "atob or Buffer not available" } });
+}
+// src/parse/mesh-policy.ts
+function cloneSceneObjects(meshes) {
+	return meshes.map((root) => {
+		const copy = root.clone(true);
+		const sources = [];
+		root.traverse((child) => sources.push(child));
+		let i = 0;
+		copy.traverse((child) => {
+			const source = sources[i++];
+			const target = child;
+			if (!source.geometry) return;
+			target.geometry = source.geometry.clone();
+		});
+		return copy;
+	});
+}
+/** Skips materials — the memo never owns those; see the file header. */
+function releaseSceneObjects(meshes) {
+	meshes.forEach((root) => require_gpu_dispose.disposeObjectTree(root, { materials: false }));
+}
+/** Structurally, not nominally, typed as `@selvajs/solve/client`'s `MeshPolicy<THREE.Object3D>` — avoids a dependency on solve. */
+const meshPolicy = {
+	clone: cloneSceneObjects,
+	release: releaseSceneObjects
+};
+/** Opacity < 1 flips `transparent` on. */
+function materialParams(color, opacity) {
+	const resolved = opacity ?? 1;
+	return {
+		color: new three.Color(color ?? "#ffffff"),
+		transparent: resolved < 1,
+		opacity: resolved
+	};
+}
+// src/parse/display-items/items/curves.ts
+const DEFAULT_LINE_WIDTH = 2;
+/** Two vertices — the shortest renderable polyline. */
+const MIN_POSITIONS = 6;
+/**
+* Curves arrive tessellated: the backend sends `points`, this builds the line. Nothing decodes
+* geometry in the browser.
+*
+* Uses `Line2`/`LineMaterial` instead of `THREE.Line`: plain `THREE.Line` is hard-capped at 1px on
+* every major GPU backend, so `item.width` would go unhonoured. `Line2.onBeforeRender` sets
+* `LineMaterial`'s required `resolution`, so no renderer reference is needed here.
+*
+* @throws VisualizationError when the item has no `points` — see {@link curvePositions}.
+*/
+function buildCurveLine(item) {
+	const positions = curvePositions(item);
+	if (!positions) return null;
+	const geometry = new three_addons_lines_LineGeometry_js.LineGeometry();
+	geometry.setPositions(positions);
+	const params = materialParams(item.color, item.opacity);
+	const material = new three_addons_lines_LineMaterial_js.LineMaterial({ color: params.color });
+	const styled = material;
+	styled.linewidth = item.width ?? DEFAULT_LINE_WIDTH;
+	styled.transparent = params.transparent;
+	styled.opacity = params.opacity;
+	const line = new three_addons_lines_Line2_js.Line2(geometry, material);
+	line.computeLineDistances();
+	line.name = item.name;
+	line.userData = {
+		source: "compute",
+		id: item.id,
+		layer: item.layer,
+		kind: "curve",
+		metadata: item.metadata
+	};
+	return line;
+}
+/**
+* Flat `[x,y,z, …]`, or null for a degenerate curve — one of those can't abort the batch.
+*
+* A curve with no `points` **throws** instead. It means the definition was solved by a Display
+* component predating backend tessellation, which is a stale definition rather than one bad curve:
+* skipping would render a scene silently missing geometry, indistinguishable from a definition that
+* has no curves, with the fix nowhere in sight.
+*/
+function curvePositions(item) {
+	if (!item.points) throw new require_gpu_dispose.VisualizationError(`Curve display item '${item.id}' has no tessellated points. It was produced by an outdated Display component — upgrade it in Grasshopper (Solution → Upgrade obsolete components) and re-save the definition.`, require_gpu_dispose.ErrorCodes.INVALID_CONFIG, { context: {
+		itemId: item.id,
+		kind: item.kind
+	} });
+	return item.points.length >= MIN_POSITIONS ? item.points : null;
+}
+// src/parse/display-items/items/points.ts
+function buildPoint(item) {
+	const { position } = item;
+	if (!position || typeof position.X !== "number" || !Number.isFinite(position.X) || typeof position.Y !== "number" || !Number.isFinite(position.Y) || typeof position.Z !== "number" || !Number.isFinite(position.Z)) {
+		require_gpu_dispose.getLogger().warn(`Skipping point display item with missing or non-finite position (id: ${String(item.id)}).`);
+		return null;
+	}
+	const geometry = new three.BufferGeometry();
+	geometry.setAttribute("position", new three.Float32BufferAttribute([
+		position.X,
+		position.Y,
+		position.Z
+	], 3));
+	const material = new three.PointsMaterial({
+		...materialParams(item.color, item.opacity),
+		size: 6,
+		sizeAttenuation: false
+	});
+	const points = new three.Points(geometry, material);
+	points.name = item.name;
+	points.userData = {
+		source: "compute",
+		id: item.id,
+		layer: item.layer,
+		kind: "point",
+		metadata: item.metadata
+	};
+	return points;
+}
+// src/parse/display-items/display-items-parser.ts
+/**
+* Builds THREE objects for the batch's non-mesh items.
+*
+* @throws VisualizationError when a curve predates backend tessellation, so a stale definition
+* surfaces as an actionable error instead of a scene quietly missing its curves. Every other
+* unrenderable item is logged and skipped.
+*/
+function parseDisplayItems(items) {
+	if (!items || items.length === 0) return [];
+	const objects = [];
+	for (const item of items) switch (item.kind) {
+		case "curve": {
+			const line = buildCurveLine(item);
+			if (line) objects.push(line);
+			break;
+		}
+		case "point": {
+			const point = buildPoint(item);
+			if (point) objects.push(point);
+			break;
+		}
+		default: {
+			const unknown = item;
+			require_gpu_dispose.getLogger().warn(`Skipping unknown display item kind: ${String(unknown.kind)}`);
+			break;
+		}
+	}
+	return objects;
+}
+// src/parse/webdisplay/binary/header.ts
+/** "SLVA" little-endian — an uncompressed mesh blob. */
+const BINARY_MESH_MAGIC = 1096174675;
+/**
+* Header fields use explicit-LE `DataView` reads, but the zero-copy geometry readers build
+* typed-array views in *host* byte order (every mainstream JS target is little-endian, and
+* per-element DataView reads would be far costlier on the hot geometry paths). This check makes
+* the assumption explicit: on a big-endian host the parser refuses to decode rather than return
+* byte-swapped garbage.
+*/
+const HOST_IS_LITTLE_ENDIAN = new Uint16Array(new Uint8Array([1, 0]).buffer)[0] === 1;
+// src/parse/webdisplay/binary/geometry.ts
+function toUint8Array(input) {
+	if (typeof input === "string") return decodeBase64ToBinary(input);
+	if (input instanceof Uint8Array) return input;
+	return new Uint8Array(input);
+}
+function isSlvz(bytes) {
+	return bytes.byteLength >= 8 && new DataView(bytes.buffer, bytes.byteOffset, 8).getUint32(0, true) === 1515605075;
+}
+/** Size a SLVZ blob inflates to, as its header declares; 0 for anything else. Unvalidated. */
+function slvzInflatedBytes(bytes) {
+	return isSlvz(bytes) ? new DataView(bytes.buffer, bytes.byteOffset, 8).getUint32(4, true) : 0;
+}
+function slvzPayload(bytes) {
+	const uncompressedLen = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getUint32(4, true);
+	const deflated = bytes.subarray(8);
+	const maxPlausibleLen = Math.max(deflated.byteLength * 1032 + 1024, 1 << 20);
+	if (uncompressedLen > maxPlausibleLen) throw fail("SLVZ header declares an implausible uncompressed length", {
+		uncompressedLen,
+		deflatedBytes: deflated.byteLength,
+		maxPlausibleLen
+	});
+	return {
+		deflated,
+		uncompressedLen
+	};
+}
+function inflateFailure(error, payload) {
+	return fail(`Failed to inflate SLVZ blob: ${error instanceof Error ? error.message : String(error)}`, {
+		uncompressedLen: payload.uncompressedLen,
+		deflatedBytes: payload.deflated.byteLength
+	});
+}
+function checkInflatedLength(out, payload) {
+	if (out.byteLength !== payload.uncompressedLen) throw fail("SLVZ payload inflated to a different size than the header declares.", {
+		declaredLen: payload.uncompressedLen,
+		actualLen: out.byteLength,
+		deflatedBytes: payload.deflated.byteLength
+	});
+	return out;
+}
+/**
+* If the blob is a SLVZ compressed container, inflate it back to the raw SLVA bytes; otherwise
+* return the input untouched. Detection is by the leading 4-byte magic, so an uncompressed SLVA
+* blob (or any pre-v3 payload) flows through unchanged.
+*/
+function maybeDecompress(bytes) {
+	if (!isSlvz(bytes)) return bytes;
+	const payload = slvzPayload(bytes);
+	let out;
+	try {
+		out = (0, fflate.inflateSync)(payload.deflated, { out: new Uint8Array(payload.uncompressedLen + 1) });
+	} catch (error) {
+		throw inflateFailure(error, payload);
+	}
+	return checkInflatedLength(out, payload);
+}
+/**
+* {@link maybeDecompress} for a SLVZ blob, inflated in fflate's own worker so the calling thread
+* stays free. The result owns its buffer. Rejects on any failure, including a worker that could not
+* start: the caller falls back to {@link maybeDecompress}, which reports a corrupt blob properly.
+*/
+function inflateSlvzAsync(bytes) {
+	return new Promise((resolve, reject) => {
+		const payload = slvzPayload(bytes);
+		try {
+			(0, fflate.inflate)(payload.deflated, { size: payload.uncompressedLen + 1 }, (error, out) => {
+				if (error) {
+					reject(inflateFailure(error, payload));
+					return;
+				}
+				try {
+					resolve(checkInflatedLength(out, payload));
+				} catch (mismatch) {
+					reject(mismatch);
+				}
+			});
+		} catch (error) {
+			reject(inflateFailure(error, payload));
+		}
+	});
+}
+function decodeUtf8(bytes) {
+	if (typeof TextDecoder !== "undefined") return new TextDecoder("utf-8").decode(bytes);
+	if (typeof globalThis.Buffer !== "undefined") return globalThis.Buffer.from(bytes).toString("utf-8");
+	throw new require_gpu_dispose.VisualizationError("No UTF-8 decoder available in this environment.", require_gpu_dispose.ErrorCodes.INVALID_STATE);
+}
+function readInt16Vertices(buffer, byteOffset, count) {
+	if (count === 0) return /* @__PURE__ */ new Int16Array(0);
+	if (byteOffset % 2 === 0) return new Int16Array(buffer, byteOffset, count);
+	const copy = new Uint8Array(count * 2);
+	copy.set(new Uint8Array(buffer, byteOffset, count * 2));
+	return new Int16Array(copy.buffer);
+}
+function readFloat32Vertices(buffer, byteOffset, count) {
+	if (count === 0) return /* @__PURE__ */ new Float32Array(0);
+	if (byteOffset % 4 === 0) return new Float32Array(buffer, byteOffset, count);
+	const copy = new Uint8Array(count * 4);
+	copy.set(new Uint8Array(buffer, byteOffset, count * 4));
+	return new Float32Array(copy.buffer);
+}
+function readUint16Array(buffer, byteOffset, count) {
+	if (count === 0) return /* @__PURE__ */ new Uint16Array(0);
+	if (byteOffset % 2 === 0) return new Uint16Array(buffer, byteOffset, count);
+	const copy = new Uint8Array(count * 2);
+	copy.set(new Uint8Array(buffer, byteOffset, count * 2));
+	return new Uint16Array(copy.buffer);
+}
+function readUint32Array(buffer, byteOffset, count) {
+	if (count === 0) return /* @__PURE__ */ new Uint32Array(0);
+	if (byteOffset % 4 === 0) return new Uint32Array(buffer, byteOffset, count);
+	const copy = new Uint8Array(count * 4);
+	copy.set(new Uint8Array(buffer, byteOffset, count * 4));
+	return new Uint32Array(copy.buffer);
+}
+/**
+* Rejects blobs whose index stream references vertices past `vertexCount`. Downstream mesh
+* assembly trusts indices arithmetically (rebasing, `subarray` slicing), so an out-of-range index
+* would otherwise corrupt geometry silently instead of failing the parse. A uint16 index stream
+* can't exceed a vertex count above 65535, so that case skips the scan.
+*/
+function validateIndicesInRange(indices, vertexCount) {
+	if (indices.length === 0) return;
+	if (indices instanceof Uint16Array && vertexCount > 65535) return;
+	for (let i = 0; i < indices.length; i++) if (indices[i] >= vertexCount) throw fail("Index out of range of vertexCount.", {
+		indexPosition: i,
+		indexValue: indices[i],
+		vertexCount
+	});
+}
+/** Inverse of the writer's zigzag map: 0,1,2,3 → 0,-1,1,-2. */
+function unzigzag(zz) {
+	return zz >>> 1 ^ -(zz & 1);
+}
+/**
+* Undoes the v3 delta filter on the quantized vertex stream: each component is a zigzag-mapped,
+* wrapped 16-bit difference from the previous vertex's same component (independent x/y/z running
+* sums). `(x << 16) >> 16` reproduces the writer's int16 wrapping.
+*/
+function decodeDeltaVertices(zigzagged) {
+	const out = new Int16Array(zigzagged.length);
+	let px = 0;
+	let py = 0;
+	let pz = 0;
+	for (let i = 0; i < zigzagged.length; i += 3) {
+		px = px + unzigzag(zigzagged[i]) << 16 >> 16;
+		py = py + unzigzag(zigzagged[i + 1]) << 16 >> 16;
+		pz = pz + unzigzag(zigzagged[i + 2]) << 16 >> 16;
+		out[i] = px;
+		out[i + 1] = py;
+		out[i + 2] = pz;
+	}
+	return out;
+}
+/**
+* Undoes the v4 planar byte-split vertex layout: six byte planes
+* `[Xlo][Ylo][Zlo][Xhi][Yhi][Zhi]` (each `vertexCount` bytes) of the zigzag deltas — merge the
+* planes, unzigzag, prefix-sum per component. Same delta semantics as {@link decodeDeltaVertices}.
+*/
+function decodePlanarVertices(planes, vertexCount) {
+	const out = new Int16Array(vertexCount * 3);
+	const n = vertexCount;
+	let px = 0;
+	let py = 0;
+	let pz = 0;
+	for (let i = 0; i < n; i++) {
+		px = px + unzigzag(planes[i] | planes[n * 3 + i] << 8) << 16 >> 16;
+		py = py + unzigzag(planes[n + i] | planes[n * 4 + i] << 8) << 16 >> 16;
+		pz = pz + unzigzag(planes[n * 2 + i] | planes[n * 5 + i] << 8) << 16 >> 16;
+		out[i * 3] = px;
+		out[i * 3 + 1] = py;
+		out[i * 3 + 2] = pz;
+	}
+	return out;
+}
+/** Undoes the v4 planar byte-split uint16 index layout `[lo × N][hi × N]`. */
+function decodePlanarIndices16(planes, count) {
+	const out = new Uint16Array(count);
+	let prev = 0;
+	for (let i = 0; i < count; i++) {
+		prev = prev + unzigzag(planes[i] | planes[count + i] << 8) & 65535;
+		out[i] = prev;
+	}
+	return out;
+}
+/** Undoes the v4 planar byte-split uint32 index layout `[b0 × N][b1 × N][b2 × N][b3 × N]`. */
+function decodePlanarIndices32(planes, count) {
+	const out = new Uint32Array(count);
+	let prev = 0;
+	for (let i = 0; i < count; i++) {
+		const zz = (planes[i] | planes[count + i] << 8 | planes[count * 2 + i] << 16 | planes[count * 3 + i] << 24) >>> 0;
+		prev = prev + unzigzag(zz) >>> 0;
+		out[i] = prev;
+	}
+	return out;
+}
+function decodeDeltaIndices16(zigzagged) {
+	const out = new Uint16Array(zigzagged.length);
+	let prev = 0;
+	for (let i = 0; i < zigzagged.length; i++) {
+		prev = prev + unzigzag(zigzagged[i]) & 65535;
+		out[i] = prev;
+	}
+	return out;
+}
+function decodeDeltaIndices32(zigzagged) {
+	const out = new Uint32Array(zigzagged.length);
+	let prev = 0;
+	for (let i = 0; i < zigzagged.length; i++) {
+		prev = prev + unzigzag(zigzagged[i]) >>> 0;
+		out[i] = prev;
+	}
+	return out;
+}
+function fail(message, context) {
+	return new require_gpu_dispose.VisualizationError(message, require_gpu_dispose.ErrorCodes.VALIDATION_ERROR, { context });
+}
+// src/parse/webdisplay/binary/textures.ts
+/** Byte size of the UV chunk header: uvFormat(u32) + uvOrigin(2×f64) + uvScale(2×f64). */
+const UV_CHUNK_HEADER_BYTES = 36;
+/**
+* Parses the trailing UV chunk into absolute Float32 u,v pairs. Quantized UVs reconstruct as
+* `origin + q * scale` (unsigned q), undoing the per-component delta+zigzag filter when set;
+* float32 UVs are copied out as-is (never filtered).
+*/
+function parseUvChunk(bytes, view, offset, vertexCount, deltaEncoded, planarByteSplit = false) {
+	if (offset + UV_CHUNK_HEADER_BYTES > bytes.byteLength) throw fail("Insufficient data to read UV chunk header.", {
+		expectedBytes: UV_CHUNK_HEADER_BYTES,
+		availableBytes: bytes.byteLength - offset,
+		offset
+	});
+	const uvFormat = view.getUint32(offset, true);
+	offset += 4;
+	const originU = view.getFloat64(offset, true);
+	offset += 8;
+	const originV = view.getFloat64(offset, true);
+	offset += 8;
+	const scaleU = view.getFloat64(offset, true);
+	offset += 8;
+	const scaleV = view.getFloat64(offset, true);
+	offset += 8;
+	const componentCount = vertexCount * 2;
+	const useFloat32 = uvFormat === 1;
+	const dataByteLength = componentCount * (useFloat32 ? 4 : 2);
+	if (offset + dataByteLength > bytes.byteLength) throw fail("Insufficient data to read UV chunk.", {
+		expectedBytes: dataByteLength,
+		availableBytes: bytes.byteLength - offset,
+		offset,
+		uvFormat,
+		vertexCount
+	});
+	const absoluteOffset = bytes.byteOffset + offset;
+	let uvs;
+	if (useFloat32) uvs = readFloat32Vertices(bytes.buffer, absoluteOffset, componentCount).slice();
+	else if (planarByteSplit) {
+		const planes = bytes.subarray(offset, offset + dataByteLength);
+		const n = vertexCount;
+		uvs = new Float32Array(componentCount);
+		let qu = 0;
+		let qv = 0;
+		for (let i = 0; i < n; i++) {
+			qu = qu + unzigzag(planes[i] | planes[n * 2 + i] << 8) & 65535;
+			qv = qv + unzigzag(planes[n + i] | planes[n * 3 + i] << 8) & 65535;
+			uvs[i * 2] = originU + qu * scaleU;
+			uvs[i * 2 + 1] = originV + qv * scaleV;
+		}
+	} else {
+		const raw = readUint16Array(bytes.buffer, absoluteOffset, componentCount);
+		uvs = new Float32Array(componentCount);
+		let qu = 0;
+		let qv = 0;
+		for (let i = 0; i < componentCount; i += 2) {
+			if (deltaEncoded) {
+				qu = qu + unzigzag(raw[i]) & 65535;
+				qv = qv + unzigzag(raw[i + 1]) & 65535;
+			} else {
+				qu = raw[i];
+				qv = raw[i + 1];
+			}
+			uvs[i] = originU + qu * scaleU;
+			uvs[i + 1] = originV + qv * scaleV;
+		}
+	}
+	return {
+		uvs,
+		offset: offset + dataByteLength
+	};
+}
+/**
+* Parses the trailing vertex-color chunk into raw r,g,b bytes, undoing the per-channel wrapped
+* 8-bit delta+zigzag filter when the blob-wide delta flag is set.
+*/
+function parseColorChunk(bytes, offset, vertexCount, deltaEncoded) {
+	const byteLength = vertexCount * 3;
+	if (offset + byteLength > bytes.byteLength) throw fail("Insufficient data to read vertex-color chunk.", {
+		expectedBytes: byteLength,
+		availableBytes: bytes.byteLength - offset,
+		offset,
+		vertexCount
+	});
+	const raw = bytes.subarray(offset, offset + byteLength);
+	if (!deltaEncoded) return raw.slice();
+	const colors = new Uint8Array(byteLength);
+	let r = 0;
+	let g = 0;
+	let b = 0;
+	for (let i = 0; i < byteLength; i += 3) {
+		r = r + unzigzag(raw[i]) & 255;
+		g = g + unzigzag(raw[i + 1]) & 255;
+		b = b + unzigzag(raw[i + 2]) & 255;
+		colors[i] = r;
+		colors[i + 1] = g;
+		colors[i + 2] = b;
+	}
+	return colors;
+}
+const CHUNK_GEOM = 1297040711;
+const CHUNK_TABL = 1279410516;
+const CHUNK_MATL = 1280590157;
+const CHUNK_TEXR = 1381516628;
+/** One byte per mesh row: 0 = unknown, 1 = open, 2 = closed solid. */
+const CHUNK_CLSD = 1146309699;
+/** Reserved attr key carrying each object's identity — split out of the attr dict on read. */
+const ID_ATTR = "id";
+/** Material `map` prefix that references a TEXR chunk by index. */
+const TEX_REF_PREFIX = "slvm:tex:";
+const NAMES_NONE = 0;
+const NAMES_SEQUENTIAL = 1;
+const NAMES_POOL = 2;
+function isSlvmContainer(bytes) {
+	return bytes.byteLength >= 4 && new DataView(bytes.buffer, bytes.byteOffset, 4).getUint32(0, true) === 1297501267;
+}
+/**
+* Parses an SLVM v3 container down to its mesh geometry blob and the metadata the rest of the
+* pipeline expects. Group vertex/index windows are rebuilt as prefix sums over the table — the
+* format mandates geometry is concatenated in table order, so starts are never stored.
+*
+* @throws {VisualizationError} On bad magic, unknown version, or a truncated/malformed container.
+*/
+function parseSlvmContainer(bytes) {
+	const chunks = readChunks(bytes);
+	let geometryBlob = null;
+	let tableBytes = null;
+	let materialsJson = null;
+	let closedFlags = null;
+	const textures = [];
+	for (const { type, payload } of chunks) switch (type) {
+		case CHUNK_GEOM:
+			geometryBlob = payload;
+			break;
+		case CHUNK_TABL:
+			tableBytes = maybeDecompress(payload);
+			break;
+		case CHUNK_MATL:
+			materialsJson = decodeUtf8(payload);
+			break;
+		case CHUNK_TEXR:
+			textures.push(payload);
+			break;
+		case CHUNK_CLSD: closedFlags = maybeDecompress(payload);
+	}
+	if (geometryBlob === null) throw fail("SLVM container has no GEOM chunk.", { chunkCount: chunks.length });
+	if (tableBytes === null) throw fail("SLVM container has no TABL chunk.", { chunkCount: chunks.length });
+	const { groups } = parseTable(tableBytes, closedFlags);
+	const materials = parseMaterials(materialsJson, textures);
+	return {
+		geometryBlob,
+		metadata: {
+			materials,
+			groups
+		}
+	};
+}
+function readChunks(bytes) {
+	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	if (bytes.byteLength < 12 || view.getUint32(0, true) !== 1297501267) throw fail("Not an SLVM container (bad magic).", { byteLength: bytes.byteLength });
+	const version = view.getUint32(4, true);
+	if (version !== 3) throw fail(`Unsupported SLVM version: ${version}`, { expectedVersion: 3 });
+	const count = view.getUint32(8, true);
+	const chunks = [];
+	let offset = 12;
+	for (let i = 0; i < count; i++) {
+		if (offset + 8 > bytes.byteLength) throw fail("Truncated SLVM chunk header.", {
+			offset,
+			chunkIndex: i
+		});
+		const type = view.getUint32(offset, true);
+		const len = view.getUint32(offset + 4, true);
+		offset += 8;
+		if (offset + len > bytes.byteLength) throw fail("Truncated SLVM chunk payload.", {
+			offset,
+			chunkIndex: i,
+			byteLen: len
+		});
+		chunks.push({
+			type,
+			payload: bytes.subarray(offset, offset + len)
+		});
+		offset += len + (4 - len % 4) % 4;
+	}
+	return chunks;
+}
+function readVarint(r) {
+	let value = 0;
+	let shift = 0;
+	for (;;) {
+		if (r.pos >= r.bytes.byteLength || shift > 28) throw fail("Malformed varint in SLVM table.", { pos: r.pos });
+		const b = r.bytes[r.pos++];
+		value |= (b & 127) << shift;
+		if ((b & 128) === 0) return value >>> 0;
+		shift += 7;
+	}
+}
+function readStringColumn(r, objectCount, pool) {
+	const mode = r.bytes[r.pos++];
+	const result = new Array(objectCount);
+	switch (mode) {
+		case NAMES_NONE:
+			result.fill("");
+			break;
+		case NAMES_SEQUENTIAL:
+			for (let i = 0; i < objectCount; i++) result[i] = String(i + 1);
+			break;
+		case NAMES_POOL:
+			for (let i = 0; i < objectCount; i++) result[i] = pool[readVarint(r)] ?? "";
+			break;
+		default: throw fail(`Unknown SLVM string column mode: ${mode}`, { pos: r.pos });
+	}
+	return result;
+}
+function parseTable(bytes, closedFlags) {
+	const r = {
+		bytes,
+		pos: 0
+	};
+	const meshCount = readVarint(r);
+	const curveCount = readVarint(r);
+	const pointCount = readVarint(r);
+	const objectCount = meshCount + curveCount + pointCount;
+	const poolCount = readVarint(r);
+	const pool = new Array(poolCount);
+	for (let i = 0; i < poolCount; i++) {
+		const len = readVarint(r);
+		pool[i] = decodeUtf8(bytes.subarray(r.pos, r.pos + len));
+		r.pos += len;
+	}
+	const vertexCounts = new Array(meshCount);
+	const triCounts = new Array(meshCount);
+	for (let i = 0; i < meshCount; i++) {
+		vertexCounts[i] = readVarint(r);
+		triCounts[i] = readVarint(r);
+	}
+	for (let i = 0; i < curveCount; i++) readVarint(r);
+	const runCount = readVarint(r);
+	const runs = [];
+	for (let i = 0; i < runCount; i++) runs.push({
+		materialId: readVarint(r),
+		meshCount: readVarint(r)
+	});
+	const names = readStringColumn(r, objectCount, pool);
+	const layers = readStringColumn(r, objectCount, pool);
+	const attrs = new Array(objectCount);
+	const attrCount = readVarint(r);
+	for (let a = 0; a < attrCount; a++) {
+		const key = pool[readVarint(r)] ?? "";
+		const n = readVarint(r);
+		const indices = new Array(n);
+		let idx = 0;
+		for (let i = 0; i < n; i++) {
+			idx += readVarint(r);
+			indices[i] = idx;
+		}
+		for (let i = 0; i < n; i++) {
+			const value = pool[readVarint(r)] ?? "";
+			const objIndex = indices[i];
+			(attrs[objIndex] ??= {})[key] = value;
+		}
+	}
+	const effectiveRuns = runs.length > 0 || meshCount === 0 ? runs : [{
+		materialId: 0,
+		meshCount
+	}];
+	const groups = [];
+	let meshIndex = 0;
+	let vertexStart = 0;
+	let indexStart = 0;
+	for (const run of effectiveRuns) {
+		const meshes = [];
+		for (let i = 0; i < run.meshCount && meshIndex < meshCount; i++, meshIndex++) {
+			const meshAttrs = attrs[meshIndex];
+			const id = meshAttrs?.[ID_ATTR];
+			if (meshAttrs !== void 0) delete meshAttrs[ID_ATTR];
+			const mesh = {
+				id,
+				name: names[meshIndex],
+				layer: layers[meshIndex],
+				vertexCount: vertexCounts[meshIndex],
+				indexCount: triCounts[meshIndex] * 3,
+				vertexStart,
+				indexStart,
+				metadata: meshAttrs ?? {}
+			};
+			const verdict = closedFlags?.[meshIndex];
+			if (verdict === 1 || verdict === 2) mesh.closed = verdict === 2;
+			meshes.push(mesh);
+			vertexStart += vertexCounts[meshIndex];
+			indexStart += triCounts[meshIndex] * 3;
+		}
+		groups.push({
+			materialId: run.materialId,
+			meshes
+		});
+	}
+	return { groups };
+}
+function parseMaterials(json, textures) {
+	if (json === null) return [];
+	let materials;
+	try {
+		materials = JSON.parse(json).materials ?? [];
+	} catch (error) {
+		throw fail(`Failed to parse SLVM materials JSON: ${error instanceof Error ? error.message : String(error)}`, { byteLength: json.length });
+	}
+	for (const material of materials) for (const slot of TEXTURE_SLOTS) {
+		const reference = material[slot];
+		if (reference?.startsWith(TEX_REF_PREFIX)) {
+			const tex = textures[Number(reference.slice(9))];
+			if (tex !== void 0) material[slot] = textureToDataUri(tex);
+		}
+	}
+	return materials;
+}
+const TEXTURE_SLOTS = [
+	"map",
+	"roughnessMap",
+	"normalMap"
+];
+/** TEXR payload is [varint mimeLen][mime utf8][image bytes]; downstream wants a data URI. */
+function textureToDataUri(payload) {
+	const r = {
+		bytes: payload,
+		pos: 0
+	};
+	const mimeLen = readVarint(r);
+	const mime = decodeUtf8(payload.subarray(r.pos, r.pos + mimeLen));
+	const data = payload.subarray(r.pos + mimeLen);
+	let binary = "";
+	const step = 32768;
+	for (let i = 0; i < data.byteLength; i += step) binary += String.fromCharCode(...data.subarray(i, i + step));
+	return `data:${mime};base64,${btoa(binary)}`;
+}
+// src/parse/webdisplay/binary-parser.ts
+/** Second half of {@link parseBinaryMeshBatch}, for a caller that already holds the raw view. */
+function decodeRawMeshBatch(raw) {
+	let vertices;
+	if (raw.isFloat32) vertices = raw.vertexData;
+	else if (raw.planarByteSplit) vertices = decodePlanarVertices(raw.vertexData, raw.vertexCount);
+	else if (raw.deltaEncoded) vertices = decodeDeltaVertices(raw.vertexData);
+	else vertices = raw.vertexData;
+	let indices;
+	if (raw.planarByteSplit) {
+		const planes = raw.indexData;
+		indices = raw.uint16Indices ? decodePlanarIndices16(planes, planes.length / 2) : decodePlanarIndices32(planes, planes.length / 4);
+	} else if (raw.deltaEncoded) indices = raw.indexData instanceof Uint16Array ? decodeDeltaIndices16(raw.indexData) : decodeDeltaIndices32(raw.indexData);
+	else indices = raw.indexData;
+	validateIndicesInRange(indices, raw.vertexCount);
+	return {
+		metadata: raw.metadata,
+		flags: raw.flags,
+		vertices,
+		indices,
+		origin: raw.origin,
+		scale: raw.scale,
+		uvs: raw.uvs,
+		colors: raw.colors
+	};
+}
+/** See {@link RawBinaryMeshBatch}. Same validation/throw behavior as the decoding parser. */
+function parseBinaryMeshBatchRaw(input) {
+	if (!HOST_IS_LITTLE_ENDIAN) throw new require_gpu_dispose.VisualizationError("SLVA parsing requires a little-endian host: the zero-copy geometry readers view the wire bytes in host byte order.", require_gpu_dispose.ErrorCodes.ENVIRONMENT_ERROR);
+	const rawInput = toUint8Array(input);
+	if (isSlvmContainer(rawInput)) {
+		const container = parseSlvmContainer(rawInput);
+		const raw = parseBinaryMeshBatchRaw(container.geometryBlob);
+		raw.metadata = container.metadata;
+		return raw;
+	}
+	const bytes = maybeDecompress(rawInput);
+	const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	if (bytes.byteLength < 12) throw fail("Blob too small to contain SLVA header.", {
+		expectedBytes: 12,
+		availableBytes: bytes.byteLength
+	});
+	let offset = 0;
+	const magic = view.getUint32(offset, true);
+	offset += 4;
+	if (magic !== 1096174675) throw fail(`Invalid SLVA magic: 0x${magic.toString(16)}`, {
+		expectedMagic: `0x${BINARY_MESH_MAGIC.toString(16)}`,
+		actualMagic: `0x${magic.toString(16)}`
+	});
+	const version = view.getUint32(offset, true);
+	offset += 4;
+	if (version < 1 || version > 4) throw fail(`Unsupported SLVA version: ${version}`, {
+		minSupportedVersion: 1,
+		maxSupportedVersion: 4,
+		actualVersion: version
+	});
+	const metadataLen = view.getUint32(offset, true);
+	offset += 4;
+	if (offset + metadataLen > bytes.byteLength) throw fail("Insufficient data to read metadata JSON.", {
+		expectedBytes: metadataLen,
+		availableBytes: bytes.byteLength - offset,
+		offset
+	});
+	const metadataBytes = bytes.subarray(offset, offset + metadataLen);
+	offset += metadataLen;
+	let metadata;
+	try {
+		metadata = metadataLen === 0 ? {} : JSON.parse(decodeUtf8(metadataBytes));
+	} catch (error) {
+		throw fail(`Failed to parse metadata JSON: ${error instanceof Error ? error.message : String(error)}`, { metadataLen });
+	}
+	if (offset + 56 > bytes.byteLength) throw fail("Insufficient data to read geometry header.", {
+		expectedBytes: 56,
+		availableBytes: bytes.byteLength - offset,
+		offset
+	});
+	const flags = view.getUint32(offset, true);
+	offset += 4;
+	const originX = view.getFloat64(offset, true);
+	offset += 8;
+	const originY = view.getFloat64(offset, true);
+	offset += 8;
+	const originZ = view.getFloat64(offset, true);
+	offset += 8;
+	const scaleX = view.getFloat64(offset, true);
+	offset += 8;
+	const scaleY = view.getFloat64(offset, true);
+	offset += 8;
+	const scaleZ = view.getFloat64(offset, true);
+	offset += 8;
+	const vertexCount = view.getUint32(offset, true);
+	offset += 4;
+	const useFloat32 = (flags & 1) !== 0;
+	const deltaEncoded = (flags & 4) !== 0;
+	const planarByteSplit = (flags & 32) !== 0;
+	const componentCount = vertexCount * 3;
+	const verticesByteLength = componentCount * (useFloat32 ? 4 : 2);
+	if (offset + verticesByteLength > bytes.byteLength) throw fail("Insufficient data to read vertices.", {
+		expectedBytes: verticesByteLength,
+		availableBytes: bytes.byteLength - offset,
+		offset,
+		useFloat32,
+		vertexCount
+	});
+	const absoluteOffset = bytes.byteOffset + offset;
+	let vertexData;
+	if (useFloat32) vertexData = readFloat32Vertices(bytes.buffer, absoluteOffset, componentCount);
+	else if (planarByteSplit) vertexData = bytes.subarray(offset, offset + verticesByteLength);
+	else if (deltaEncoded) vertexData = readUint16Array(bytes.buffer, absoluteOffset, componentCount);
+	else vertexData = readInt16Vertices(bytes.buffer, absoluteOffset, componentCount);
+	offset += verticesByteLength;
+	if (offset + 4 > bytes.byteLength) throw fail("Insufficient data to read index count.", {
+		expectedBytes: 4,
+		availableBytes: bytes.byteLength - offset,
+		offset
+	});
+	const indexCount = view.getUint32(offset, true);
+	offset += 4;
+	const useUint16Indices = (flags & 2) !== 0;
+	const indicesByteLength = indexCount * (useUint16Indices ? 2 : 4);
+	if (offset + indicesByteLength > bytes.byteLength) throw fail("Insufficient data to read indices.", {
+		expectedBytes: indicesByteLength,
+		availableBytes: bytes.byteLength - offset,
+		offset,
+		indexCount,
+		useUint16Indices
+	});
+	const indexData = planarByteSplit ? bytes.subarray(offset, offset + indicesByteLength) : useUint16Indices ? readUint16Array(bytes.buffer, bytes.byteOffset + offset, indexCount) : readUint32Array(bytes.buffer, bytes.byteOffset + offset, indexCount);
+	offset += indicesByteLength;
+	let uvs = null;
+	if ((flags & 8) !== 0) {
+		const parsed = parseUvChunk(bytes, view, offset, vertexCount, deltaEncoded, planarByteSplit);
+		uvs = parsed.uvs;
+		offset = parsed.offset;
+	}
+	let colors = null;
+	if ((flags & 16) !== 0) colors = parseColorChunk(bytes, offset, vertexCount, deltaEncoded);
+	return {
+		metadata,
+		flags,
+		vertexData,
+		indexData,
+		isFloat32: useFloat32,
+		deltaEncoded,
+		planarByteSplit,
+		uint16Indices: useUint16Indices,
+		vertexCount,
+		origin: [
+			originX,
+			originY,
+			originZ
+		],
+		scale: [
+			scaleX,
+			scaleY,
+			scaleZ
+		],
+		uvs,
+		colors
+	};
+}
+// src/parse/webdisplay/closed-solid.ts
+/**
+* True when every member of a geometry is a closed, consistently wound, outward-facing triangle
+* surface, so its back faces can never be seen and the material can cull them.
+*
+* Drawing them anyway is not just overdraw. A thin closed part (a 0.5 mm sheet) puts its inside
+* faces within one depth-buffer step of its outside ones, and once precision drops below the
+* thickness they punch through as dark jagged triangles. Culled, they never compete.
+*
+* Members are tested apart, because two closed parts touching along an edge share it four ways and
+* would read as open together. Positions are welded first: Rhino meshes each Brep face separately,
+* so a solid's seams carry duplicate vertices that only position identifies. Any
+* doubt (an unwelded seam, a non-manifold edge, inward winding) answers false, which keeps the
+* double-sided default.
+*
+* Self-contained (no outer captures besides `Math`) so the mesh-assembly worker can embed it via
+* `Function.prototype.toString`.
+*
+* @param memberIndexCounts Index count of each member, in order; members are concatenated in
+*   `indices`.
+*/
+function isClosedSolid(positions, indices, memberIndexCounts) {
+	if (memberIndexCounts.length === 0) return false;
+	const tableSizeFor = (count) => {
+		let size = 16;
+		while (size < count * 2) size *= 2;
+		return size;
+	};
+	const vertexCount = positions.length / 3;
+	const tag = new Int32Array(vertexCount);
+	const canonicalOf = new Int32Array(vertexCount);
+	let weldVertex = /* @__PURE__ */ new Int32Array(0);
+	let cellX = /* @__PURE__ */ new Int32Array(0);
+	let cellY = /* @__PURE__ */ new Int32Array(0);
+	let cellZ = /* @__PURE__ */ new Int32Array(0);
+	let welded = /* @__PURE__ */ new Int32Array(0);
+	let vertexOf = /* @__PURE__ */ new Int32Array(0);
+	let outStart = /* @__PURE__ */ new Int32Array(0);
+	let outTo = /* @__PURE__ */ new Int32Array(0);
+	let cursor = /* @__PURE__ */ new Int32Array(0);
+	const grown = (array, length) => array.length >= length ? array : new Int32Array(length);
+	const memberIsClosed = (member, start, count) => {
+		if (count < 12 || count % 3 !== 0) return false;
+		const seen = 2 * member + 1;
+		const done = seen + 1;
+		let magnitude = 0;
+		let uniqueVertices = 0;
+		for (let i = 0; i < count; i++) {
+			const v = indices[start + i];
+			if (tag[v] === seen) continue;
+			tag[v] = seen;
+			uniqueVertices++;
+			magnitude = Math.max(magnitude, Math.abs(positions[v * 3]), Math.abs(positions[v * 3 + 1]), Math.abs(positions[v * 3 + 2]));
+		}
+		if (!(magnitude > 0) || !Number.isFinite(magnitude)) return false;
+		const inverseCell = 1 / (2 * Math.pow(2, Math.floor(Math.log2(magnitude)) - 23));
+		const weldSize = tableSizeFor(uniqueVertices);
+		const weldMask = weldSize - 1;
+		weldVertex = grown(weldVertex, weldSize);
+		weldVertex.fill(-1, 0, weldSize);
+		cellX = grown(cellX, weldSize);
+		cellY = grown(cellY, weldSize);
+		cellZ = grown(cellZ, weldSize);
+		const cellSlot = (x, y, z) => {
+			let h = Math.imul(x, 2654435761) ^ Math.imul(y, 2246822519) ^ Math.imul(z, 3266489917);
+			h = (h ^ h >>> 15) & weldMask;
+			while (weldVertex[h] !== -1 && (cellX[h] !== x || cellY[h] !== y || cellZ[h] !== z)) h = h + 1 & weldMask;
+			return h;
+		};
+		const neighbour = (scaled, cell) => {
+			const offset = scaled - cell;
+			return offset > .25 ? cell + 1 : offset < -.25 ? cell - 1 : cell;
+		};
+		welded = grown(welded, count);
+		vertexOf = grown(vertexOf, uniqueVertices);
+		let canonicals = 0;
+		for (let i = 0; i < count; i++) {
+			const v = indices[start + i];
+			if (tag[v] === done) {
+				welded[i] = canonicalOf[v];
+				continue;
+			}
+			const sx = positions[v * 3] * inverseCell;
+			const sy = positions[v * 3 + 1] * inverseCell;
+			const sz = positions[v * 3 + 2] * inverseCell;
+			const x = Math.round(sx);
+			const y = Math.round(sy);
+			const z = Math.round(sz);
+			const nx = neighbour(sx, x);
+			const ny = neighbour(sy, y);
+			const nz = neighbour(sz, z);
+			let canonical = -1;
+			let ownSlot = -1;
+			for (let combo = 0; combo < 8 && canonical === -1; combo++) {
+				if (combo & 1 && nx === x || combo & 2 && ny === y || combo & 4 && nz === z) continue;
+				const h = cellSlot(combo & 1 ? nx : x, combo & 2 ? ny : y, combo & 4 ? nz : z);
+				if (combo === 0) ownSlot = h;
+				if (weldVertex[h] !== -1) canonical = weldVertex[h];
+			}
+			if (canonical === -1) {
+				const h = ownSlot;
+				canonical = canonicals++;
+				weldVertex[h] = canonical;
+				cellX[h] = x;
+				cellY[h] = y;
+				cellZ[h] = z;
+				vertexOf[canonical] = v;
+			}
+			tag[v] = done;
+			canonicalOf[v] = canonical;
+			welded[i] = canonical;
+		}
+		outStart = grown(outStart, canonicals + 1);
+		outStart.fill(0, 0, canonicals + 1);
+		let triangles = 0;
+		for (let i = 0; i < count; i += 3) {
+			const a = welded[i];
+			const b = welded[i + 1];
+			const c = welded[i + 2];
+			if (a === b || b === c || c === a) continue;
+			outStart[a + 1] += 1;
+			outStart[b + 1] += 1;
+			outStart[c + 1] += 1;
+			triangles++;
+		}
+		if (triangles < 4) return false;
+		for (let k = 0; k < canonicals; k++) outStart[k + 1] += outStart[k];
+		outTo = grown(outTo, outStart[canonicals]);
+		cursor = grown(cursor, canonicals);
+		cursor.set(outStart.subarray(0, canonicals));
+		for (let i = 0; i < count; i += 3) {
+			const a = welded[i];
+			const b = welded[i + 1];
+			const c = welded[i + 2];
+			if (a === b || b === c || c === a) continue;
+			outTo[cursor[a]] = b;
+			cursor[a] += 1;
+			outTo[cursor[b]] = c;
+			cursor[b] += 1;
+			outTo[cursor[c]] = a;
+			cursor[c] += 1;
+		}
+		for (let a = 0; a < canonicals; a++) {
+			const first = outStart[a];
+			const end = outStart[a + 1];
+			for (let k = first; k < end; k++) {
+				const b = outTo[k];
+				for (let j = first; j < k; j++) if (outTo[j] === b) return false;
+				let reversed = false;
+				for (let j = outStart[b], bEnd = outStart[b + 1]; j < bEnd && !reversed; j++) reversed = outTo[j] === a;
+				if (!reversed) return false;
+			}
+		}
+		const o = vertexOf[welded[0]] * 3;
+		const ox = positions[o];
+		const oy = positions[o + 1];
+		const oz = positions[o + 2];
+		let volume = 0;
+		for (let i = 0; i < count; i += 3) {
+			const a = vertexOf[welded[i]] * 3;
+			const b = vertexOf[welded[i + 1]] * 3;
+			const c = vertexOf[welded[i + 2]] * 3;
+			const ax = positions[a] - ox;
+			const ay = positions[a + 1] - oy;
+			const az = positions[a + 2] - oz;
+			const bx = positions[b] - ox;
+			const by = positions[b + 1] - oy;
+			const bz = positions[b + 2] - oz;
+			const cx = positions[c] - ox;
+			const cy = positions[c + 1] - oy;
+			const cz = positions[c + 2] - oz;
+			volume += ax * (by * cz - bz * cy) + ay * (bz * cx - bx * cz) + az * (bx * cy - by * cx);
+		}
+		return volume > 0;
+	};
+	let start = 0;
+	for (let member = 0; member < memberIndexCounts.length; member++) {
+		const count = memberIndexCounts[member];
+		if (!memberIsClosed(member, start, count)) return false;
+		start += count;
+	}
+	return true;
+}
+// src/parse/webdisplay/crease-normals.ts
+/**
+* Vertex normals that stay smooth across gentle curvature and break at creases, splitting a vertex
+* wherever the faces sharing it disagree by more than the crease angle.
+*
+* The writer welds coincident vertices, and seams between Brep faces often come out welded
+* across a 90° fold. A plain average there tilts every normal along the fold halfway round it,
+* and the long thin triangles of a sheet-metal strip carry that tilt metres across a flat face:
+* streaks, an X around every hole, a whole strip shaded darker than its neighbour.
+*
+* Face normals are area-weighted: across a tangent bend the bend's facets are narrow, so they barely
+* tilt the wide flat face beside them. Weighting by corner angle instead let a bend facet's corner
+* tilt a flat band by up to 23°, enough to flip a metal's reflection from sky to ground.
+*
+* `indices` is rewritten in place to point split corners at their new vertices, which take the
+* slots of welded-away duplicates before any are appended; the index count never changes, so index
+* windows stay valid.
+*
+* Self-contained (no outer captures besides `Math`) so the mesh-assembly worker can embed it via
+* `Function.prototype.toString`.
+*/
+function splitCreases(positions, indices, uvs, colors) {
+	const CREASE_COS = Math.cos(30 * Math.PI / 180);
+	const vertexCount = positions.length / 3;
+	const cornerCount = indices.length;
+	const triangleCount = cornerCount / 3;
+	let orphans = /* @__PURE__ */ new Uint32Array(0);
+	{
+		const posBits = new Uint32Array(positions.buffer, positions.byteOffset, positions.length);
+		const uvBits = uvs ? new Uint32Array(uvs.buffer, uvs.byteOffset, uvs.length) : null;
+		const word = (bits, i) => bits[i] === 2147483648 ? 0 : bits[i];
+		let size = 16;
+		while (size < vertexCount * 2) size *= 2;
+		const mask = size - 1;
+		const slots = new Int32Array(size).fill(-1);
+		const canonical = new Uint32Array(vertexCount);
+		let merged = false;
+		for (let v = 0; v < vertexCount; v++) {
+			const x = word(posBits, v * 3);
+			const y = word(posBits, v * 3 + 1);
+			const z = word(posBits, v * 3 + 2);
+			let h = Math.imul(x, 2654435761) ^ Math.imul(y, 2246822519) ^ Math.imul(z, 3266489917);
+			h = (h ^ h >>> 15) & mask;
+			for (;;) {
+				const other = slots[h];
+				if (other === -1) {
+					slots[h] = v;
+					canonical[v] = v;
+					break;
+				}
+				if (word(posBits, other * 3) === x && word(posBits, other * 3 + 1) === y && word(posBits, other * 3 + 2) === z && (!colors || colors[other * 3] === colors[v * 3] && colors[other * 3 + 1] === colors[v * 3 + 1] && colors[other * 3 + 2] === colors[v * 3 + 2]) && (!uvBits || uvBits[other * 2] === uvBits[v * 2] && uvBits[other * 2 + 1] === uvBits[v * 2 + 1])) {
+					canonical[v] = other;
+					merged = true;
+					break;
+				}
+				h = h + 1 & mask;
+			}
+		}
+		if (merged) {
+			for (let i = 0; i < cornerCount; i++) indices[i] = canonical[indices[i]];
+			let orphanCount = 0;
+			for (let v = 0; v < vertexCount; v++) if (canonical[v] !== v) orphanCount++;
+			orphans = new Uint32Array(orphanCount);
+			for (let v = 0, k = 0; v < vertexCount; v++) if (canonical[v] !== v) orphans[k++] = v;
+		}
+	}
+	const faceNormals = new Float32Array(triangleCount * 3);
+	const faceAreas = new Float32Array(triangleCount);
+	for (let t = 0; t < triangleCount; t++) {
+		const a = indices[t * 3] * 3;
+		const b = indices[t * 3 + 1] * 3;
+		const c = indices[t * 3 + 2] * 3;
+		const abx = positions[b] - positions[a];
+		const aby = positions[b + 1] - positions[a + 1];
+		const abz = positions[b + 2] - positions[a + 2];
+		const acx = positions[c] - positions[a];
+		const acy = positions[c + 1] - positions[a + 1];
+		const acz = positions[c + 2] - positions[a + 2];
+		const nx = aby * acz - abz * acy;
+		const ny = abz * acx - abx * acz;
+		const nz = abx * acy - aby * acx;
+		const length = Math.sqrt(nx * nx + ny * ny + nz * nz);
+		if (length === 0) continue;
+		faceNormals[t * 3] = nx / length;
+		faceNormals[t * 3 + 1] = ny / length;
+		faceNormals[t * 3 + 2] = nz / length;
+		faceAreas[t] = length;
+	}
+	const cornerStart = new Uint32Array(vertexCount + 1);
+	for (let i = 0; i < cornerCount; i++) cornerStart[indices[i] + 1] += 1;
+	for (let v = 0; v < vertexCount; v++) cornerStart[v + 1] += cornerStart[v];
+	const cornersOf = new Uint32Array(cornerCount);
+	const fill = cornerStart.slice(0, vertexCount);
+	for (let i = 0; i < cornerCount; i++) {
+		const v = indices[i];
+		cornersOf[fill[v]] = i;
+		fill[v] += 1;
+	}
+	let maxDegree = 0;
+	for (let v = 0; v < vertexCount; v++) maxDegree = Math.max(maxDegree, cornerStart[v + 1] - cornerStart[v]);
+	const groupOf = new Uint32Array(cornerCount);
+	const groupCount = new Uint32Array(vertexCount);
+	const founders = new Float32Array(Math.max(1, maxDegree) * 3);
+	for (let v = 0; v < vertexCount; v++) {
+		let groups = 0;
+		for (let k = cornerStart[v]; k < cornerStart[v + 1]; k++) {
+			const corner = cornersOf[k];
+			const f = Math.floor(corner / 3) * 3;
+			const nx = faceNormals[f];
+			const ny = faceNormals[f + 1];
+			const nz = faceNormals[f + 2];
+			let group = -1;
+			if (nx === 0 && ny === 0 && nz === 0) group = 0;
+			else for (let g = 0; g < groups; g++) if (founders[g * 3] * nx + founders[g * 3 + 1] * ny + founders[g * 3 + 2] * nz >= CREASE_COS) {
+				group = g;
+				break;
+			}
+			if (group === -1) {
+				group = groups;
+				founders[groups * 3] = nx;
+				founders[groups * 3 + 1] = ny;
+				founders[groups * 3 + 2] = nz;
+				groups++;
+			}
+			groupOf[corner] = group;
+		}
+		groupCount[v] = Math.max(1, groups);
+	}
+	const extraStart = new Uint32Array(vertexCount + 1);
+	for (let v = 0; v < vertexCount; v++) extraStart[v + 1] = extraStart[v] + groupCount[v] - 1;
+	const extra = extraStart[vertexCount];
+	const total = vertexCount + Math.max(0, extra - orphans.length);
+	const copySlot = new Uint32Array(extra);
+	for (let k = 0; k < extra; k++) copySlot[k] = k < orphans.length ? orphans[k] : vertexCount + k - orphans.length;
+	let outPositions = positions;
+	let outUvs = uvs;
+	let outColors = colors;
+	if (extra > 0) {
+		outPositions = new Float32Array(total * 3);
+		outPositions.set(positions);
+		outUvs = uvs ? new Float32Array(total * 2) : null;
+		if (outUvs && uvs) outUvs.set(uvs);
+		outColors = colors ? new Uint8Array(total * 3) : null;
+		if (outColors && colors) outColors.set(colors);
+		for (let v = 0; v < vertexCount; v++) for (let g = 1; g < groupCount[v]; g++) {
+			const copy = copySlot[extraStart[v] + g - 1];
+			outPositions[copy * 3] = positions[v * 3];
+			outPositions[copy * 3 + 1] = positions[v * 3 + 1];
+			outPositions[copy * 3 + 2] = positions[v * 3 + 2];
+			if (outUvs && uvs) {
+				outUvs[copy * 2] = uvs[v * 2];
+				outUvs[copy * 2 + 1] = uvs[v * 2 + 1];
+			}
+			if (outColors && colors) {
+				outColors[copy * 3] = colors[v * 3];
+				outColors[copy * 3 + 1] = colors[v * 3 + 1];
+				outColors[copy * 3 + 2] = colors[v * 3 + 2];
+			}
+		}
+	}
+	const normals = new Float32Array(total * 3);
+	for (let t = 0; t < triangleCount; t++) {
+		const w = faceAreas[t];
+		const nx = faceNormals[t * 3] * w;
+		const ny = faceNormals[t * 3 + 1] * w;
+		const nz = faceNormals[t * 3 + 2] * w;
+		for (let corner = t * 3; corner < t * 3 + 3; corner++) {
+			let target = indices[corner];
+			const g = groupOf[corner];
+			if (g !== 0) {
+				target = copySlot[extraStart[target] + g - 1];
+				indices[corner] = target;
+			}
+			normals[target * 3] += nx;
+			normals[target * 3 + 1] += ny;
+			normals[target * 3 + 2] += nz;
+		}
+	}
+	for (let i = 0; i < normals.length; i += 3) {
+		const x = normals[i];
+		const y = normals[i + 1];
+		const z = normals[i + 2];
+		const length = Math.sqrt(x * x + y * y + z * z) || 1;
+		normals[i] = x / length;
+		normals[i + 1] = y / length;
+		normals[i + 2] = z / length;
+	}
+	return {
+		positions: outPositions,
+		normals,
+		indices,
+		uvs: outUvs,
+		colors: outColors
+	};
+}
+// src/parse/webdisplay/grain-tangents.ts
+/**
+* Per-vertex tangents for three's `tangent` attribute: xyz along increasing U, w the handedness that
+* points `cross(normal, tangent)` along increasing V.
+*
+* Without the attribute three rebuilds the frame per pixel from screen-space UV derivatives, which
+* is noisy on long thin triangles. three's own `computeTangents()` needs V to vary on every
+* triangle and leaves a zero tangent where it doesn't (a tube centred on its grain axis has constant
+* V), and a zero tangent renders NaN-black. Only U's gradient is needed here, so V can be anything.
+*
+* Self-contained (no outer captures besides `Math`) so the mesh-assembly worker can embed it via
+* `Function.prototype.toString`.
+*/
+function grainTangents(positions, normals, indices, uvs) {
+	const vertexCount = positions.length / 3;
+	const gradU = new Float32Array(vertexCount * 3);
+	const gradV = new Float32Array(vertexCount * 3);
+	for (let t = 0; t < indices.length; t += 3) {
+		const a = indices[t];
+		const b = indices[t + 1];
+		const c = indices[t + 2];
+		const e1x = positions[b * 3] - positions[a * 3];
+		const e1y = positions[b * 3 + 1] - positions[a * 3 + 1];
+		const e1z = positions[b * 3 + 2] - positions[a * 3 + 2];
+		const e2x = positions[c * 3] - positions[a * 3];
+		const e2y = positions[c * 3 + 1] - positions[a * 3 + 1];
+		const e2z = positions[c * 3 + 2] - positions[a * 3 + 2];
+		const nx = e1y * e2z - e1z * e2y;
+		const ny = e1z * e2x - e1x * e2z;
+		const nz = e1x * e2y - e1y * e2x;
+		const length = Math.sqrt(nx * nx + ny * ny + nz * nz);
+		if (length === 0) continue;
+		const px = (e2y * nz - e2z * ny) / length;
+		const py = (e2z * nx - e2x * nz) / length;
+		const pz = (e2x * ny - e2y * nx) / length;
+		const qx = (ny * e1z - nz * e1y) / length;
+		const qy = (nz * e1x - nx * e1z) / length;
+		const qz = (nx * e1y - ny * e1x) / length;
+		const du1 = uvs[b * 2] - uvs[a * 2];
+		const du2 = uvs[c * 2] - uvs[a * 2];
+		const dv1 = uvs[b * 2 + 1] - uvs[a * 2 + 1];
+		const dv2 = uvs[c * 2 + 1] - uvs[a * 2 + 1];
+		const ux = du1 * px + du2 * qx;
+		const uy = du1 * py + du2 * qy;
+		const uz = du1 * pz + du2 * qz;
+		const vx = dv1 * px + dv2 * qx;
+		const vy = dv1 * py + dv2 * qy;
+		const vz = dv1 * pz + dv2 * qz;
+		for (let k = 0; k < 3; k++) {
+			const v = indices[t + k];
+			gradU[v * 3] += ux;
+			gradU[v * 3 + 1] += uy;
+			gradU[v * 3 + 2] += uz;
+			gradV[v * 3] += vx;
+			gradV[v * 3 + 1] += vy;
+			gradV[v * 3 + 2] += vz;
+		}
+	}
+	const tangents = new Float32Array(vertexCount * 4);
+	for (let v = 0; v < vertexCount; v++) {
+		const nx = normals[v * 3];
+		const ny = normals[v * 3 + 1];
+		const nz = normals[v * 3 + 2];
+		const along = gradU[v * 3] * nx + gradU[v * 3 + 1] * ny + gradU[v * 3 + 2] * nz;
+		let tx = gradU[v * 3] - along * nx;
+		let ty = gradU[v * 3 + 1] - along * ny;
+		let tz = gradU[v * 3 + 2] - along * nz;
+		let length = Math.sqrt(tx * tx + ty * ty + tz * tz);
+		if (!(length > 1e-12)) {
+			const ax = Math.abs(nx) < .9 ? 1 : 0;
+			const ay = 1 - ax;
+			tx = ay * nz;
+			ty = -ax * nz;
+			tz = ax * ny - ay * nx;
+			length = Math.sqrt(tx * tx + ty * ty + tz * tz) || 1;
+		}
+		tx /= length;
+		ty /= length;
+		tz /= length;
+		const bx = ny * tz - nz * ty;
+		const by = nz * tx - nx * tz;
+		const bz = nx * ty - ny * tx;
+		const handedness = bx * gradV[v * 3] + by * gradV[v * 3 + 1] + bz * gradV[v * 3 + 2];
+		tangents[v * 4] = tx;
+		tangents[v * 4 + 1] = ty;
+		tangents[v * 4 + 2] = tz;
+		tangents[v * 4 + 3] = handedness < 0 ? -1 : 1;
+	}
+	return tangents;
+}
+// src/parse/webdisplay/mesh-assembly.ts
+/**
+* {@link assembleGeometries} is the hot, pure part of batch parsing: undoes the delta filter on
+* the raw wire arrays, dequantizes int16 positions to world floats, and slices/rebases per-geometry
+* windows. {@link finishGeometry} then adds normals and the closed-solid flag.
+* Everything it needs travels as typed arrays, so the whole stage runs in a Worker and the main
+* thread only wraps the returned buffers into `BufferGeometry` objects.
+*
+* Like `edge-extract.ts`, it's a single self-contained function with zero outer captures (only
+* `Math` and its arguments) so `Function.prototype.toString` yields code that runs unchanged
+* inside a blob-URL Worker ({@link meshAssemblyWorkerSource}) — bundler-agnostic by construction.
+* That forces duplicating small helpers from `binary-parser.ts` (unzigzag/delta decode);
+* equivalence with the synchronous path is pinned by tests.
+*/
+/**
+* The shared tail of both parse paths, so the worker and the main-thread fallback can't drift.
+* Closedness is judged before the crease split, which rewires corners to new vertex slots.
+* Tangents come after it, so each split copy takes only its own side's faces.
+*/
+function finishGeometry(geometry, members) {
+	const closed = members.every((m) => typeof m.closed === "boolean") ? members.length > 0 && members.every((m) => m.closed) : isClosedSolid(geometry.positions, geometry.indices, members.map((m) => m.indexCount));
+	const creased = splitCreases(geometry.positions, geometry.indices, geometry.uvs, geometry.colors);
+	const tangents = creased.uvs ? grainTangents(creased.positions, creased.normals, creased.indices, creased.uvs) : null;
+	return {
+		...creased,
+		closed,
+		tangents
+	};
+}
+function assembleGeometries(input) {
+	const { isFloat32, deltaEncoded, planarByteSplit, uint16Indices, origin, scale, uvs, colors, jobs } = input;
+	const unzigzag = (zz) => zz >>> 1 ^ -(zz & 1);
+	let worldVertices;
+	if (isFloat32) worldVertices = input.vertexData;
+	else {
+		let quantized;
+		if (planarByteSplit) {
+			const planes = input.vertexData;
+			const n = planes.length / 6;
+			quantized = new Int16Array(n * 3);
+			let px = 0;
+			let py = 0;
+			let pz = 0;
+			for (let i = 0; i < n; i++) {
+				px = px + unzigzag(planes[i] | planes[n * 3 + i] << 8) << 16 >> 16;
+				py = py + unzigzag(planes[n + i] | planes[n * 4 + i] << 8) << 16 >> 16;
+				pz = pz + unzigzag(planes[n * 2 + i] | planes[n * 5 + i] << 8) << 16 >> 16;
+				quantized[i * 3] = px;
+				quantized[i * 3 + 1] = py;
+				quantized[i * 3 + 2] = pz;
+			}
+		} else if (deltaEncoded) {
+			const zigzagged = input.vertexData;
+			quantized = new Int16Array(zigzagged.length);
+			let px = 0;
+			let py = 0;
+			let pz = 0;
+			for (let i = 0; i < zigzagged.length; i += 3) {
+				px = px + unzigzag(zigzagged[i]) << 16 >> 16;
+				py = py + unzigzag(zigzagged[i + 1]) << 16 >> 16;
+				pz = pz + unzigzag(zigzagged[i + 2]) << 16 >> 16;
+				quantized[i] = px;
+				quantized[i + 1] = py;
+				quantized[i + 2] = pz;
+			}
+		} else quantized = input.vertexData;
+		worldVertices = new Float32Array(quantized.length);
+		const ox = origin[0];
+		const oy = origin[1];
+		const oz = origin[2];
+		const sx = scale[0];
+		const sy = scale[1];
+		const sz = scale[2];
+		for (let i = 0; i < quantized.length; i += 3) {
+			worldVertices[i] = ox + (quantized[i] + 32767) * sx;
+			worldVertices[i + 1] = oy + (quantized[i + 1] + 32767) * sy;
+			worldVertices[i + 2] = oz + (quantized[i + 2] + 32767) * sz;
+		}
+	}
+	let indices;
+	if (planarByteSplit) {
+		const planes = input.indexData;
+		if (uint16Indices) {
+			const count = planes.length / 2;
+			const out = new Uint16Array(count);
+			let prev = 0;
+			for (let i = 0; i < count; i++) {
+				prev = prev + unzigzag(planes[i] | planes[count + i] << 8) & 65535;
+				out[i] = prev;
+			}
+			indices = out;
+		} else {
+			const count = planes.length / 4;
+			const out = new Uint32Array(count);
+			let prev = 0;
+			for (let i = 0; i < count; i++) {
+				const zz = (planes[i] | planes[count + i] << 8 | planes[count * 2 + i] << 16 | planes[count * 3 + i] << 24) >>> 0;
+				prev = prev + unzigzag(zz) >>> 0;
+				out[i] = prev;
+			}
+			indices = out;
+		}
+	} else if (deltaEncoded) {
+		const zigzagged = input.indexData;
+		if (zigzagged instanceof Uint16Array) {
+			const out = new Uint16Array(zigzagged.length);
+			let prev = 0;
+			for (let i = 0; i < zigzagged.length; i++) {
+				prev = prev + unzigzag(zigzagged[i]) & 65535;
+				out[i] = prev;
+			}
+			indices = out;
+		} else {
+			const out = new Uint32Array(zigzagged.length);
+			let prev = 0;
+			for (let i = 0; i < zigzagged.length; i++) {
+				prev = prev + unzigzag(zigzagged[i]) >>> 0;
+				out[i] = prev;
+			}
+			indices = out;
+		}
+	} else indices = input.indexData;
+	const totalVertexCount = worldVertices.length / 3;
+	for (let i = 0; i < indices.length; i++) if (indices[i] >= totalVertexCount) throw new Error(`Index ${indices[i]} out of range of vertexCount ${totalVertexCount}`);
+	const results = [];
+	for (const job of jobs) {
+		let vertexTotal = 0;
+		let indexTotal = 0;
+		for (const window of job.windows) {
+			vertexTotal += window.vertexCount;
+			indexTotal += window.indexCount;
+		}
+		const positions = new Float32Array(vertexTotal * 3);
+		const outIndices = new Uint32Array(indexTotal);
+		const outUvs = uvs ? new Float32Array(vertexTotal * 2) : null;
+		const outColors = colors ? new Uint8Array(vertexTotal * 3) : null;
+		let vertexCursor = 0;
+		let indexCursor = 0;
+		for (const window of job.windows) {
+			const componentStart = window.vertexStart * 3;
+			positions.set(worldVertices.subarray(componentStart, componentStart + window.vertexCount * 3), vertexCursor * 3);
+			if (outUvs && uvs) outUvs.set(uvs.subarray(window.vertexStart * 2, (window.vertexStart + window.vertexCount) * 2), vertexCursor * 2);
+			if (outColors && colors) outColors.set(colors.subarray(componentStart, componentStart + window.vertexCount * 3), vertexCursor * 3);
+			const windowStart = window.vertexStart;
+			const windowEnd = window.vertexStart + window.vertexCount;
+			const shift = vertexCursor - window.vertexStart;
+			for (let i = 0; i < window.indexCount; i++) {
+				const indexValue = indices[window.indexStart + i];
+				if (indexValue < windowStart || indexValue >= windowEnd) throw new Error(`Index ${indexValue} outside vertex window [${windowStart}, ${windowEnd})`);
+				outIndices[indexCursor + i] = indexValue + shift;
+			}
+			vertexCursor += window.vertexCount;
+			indexCursor += window.indexCount;
+		}
+		results.push({
+			positions,
+			indices: outIndices,
+			uvs: outUvs,
+			colors: outColors
+		});
+	}
+	return results;
+}
+/**
+* Worker script running {@link assembleGeometries} and {@link finishGeometry} off the main thread.
+* Protocol: receives `{id, input}`, replies `{id, geometries}` (each a {@link FinishedGeometry})
+* with every output buffer transferred, or `{id, error}`. Pinned by a test that evals this source
+* against a stub `self`.
+*/
+function meshAssemblyWorkerSource() {
+	return [
+		`const assemble = ${assembleGeometries.toString()};`,
+		`const isClosedSolid = ${isClosedSolid.toString()};`,
+		`const splitCreases = ${splitCreases.toString()};`,
+		`const grainTangents = ${grainTangents.toString()};`,
+		`self.onmessage = (event) => {`,
+		`  const { id, input } = event.data;`,
+		`  try {`,
+		`    const geometries = assemble(input).map((g, i) => {`,
+		`      const windows = input.jobs[i].windows;`,
+		`      const known = windows.every((w) => typeof w.closed === 'boolean');`,
+		`      const closed = known`,
+		`        ? windows.length > 0 && windows.every((w) => w.closed)`,
+		`        : isClosedSolid(g.positions, g.indices, windows.map((w) => w.indexCount));`,
+		`      const c = splitCreases(g.positions, g.indices, g.uvs, g.colors);`,
+		`      const tangents = c.uvs ? grainTangents(c.positions, c.normals, c.indices, c.uvs) : null;`,
+		`      return { ...c, closed, tangents };`,
+		`    });`,
+		`    const transfer = [];`,
+		`    for (const g of geometries) {`,
+		`      transfer.push(g.positions.buffer, g.normals.buffer, g.indices.buffer);`,
+		`      if (g.uvs) transfer.push(g.uvs.buffer);`,
+		`      if (g.tangents) transfer.push(g.tangents.buffer);`,
+		`      if (g.colors) transfer.push(g.colors.buffer);`,
+		`    }`,
+		`    self.postMessage({ id, geometries }, transfer);`,
+		`  } catch (error) {`,
+		`    self.postMessage({ id, error: String((error && error.message) || error) });`,
+		`  }`,
+		`};`
+	].join("\n");
+}
+let assemblyWorker;
+const pendingAssemblies = /* @__PURE__ */ new Map();
+let nextAssemblyRequestId = 1;
+function getAssemblyWorker() {
+	if (assemblyWorker !== void 0) return assemblyWorker;
+	if (typeof Worker === "undefined" || typeof Blob === "undefined" || typeof URL === "undefined" || typeof URL.createObjectURL !== "function") {
+		assemblyWorker = null;
+		return null;
+	}
+	try {
+		const url = URL.createObjectURL(new Blob([meshAssemblyWorkerSource()], { type: "text/javascript" }));
+		const worker = new Worker(url);
+		worker.onmessage = (event) => {
+			const { id, geometries, error } = event.data;
+			const pending = pendingAssemblies.get(id);
+			if (!pending) return;
+			pendingAssemblies.delete(id);
+			if (geometries) pending.resolve(geometries);
+			else pending.reject(new Error(error ?? "mesh assembly failed in worker"));
+		};
+		worker.onerror = () => {
+			for (const pending of pendingAssemblies.values()) pending.reject(/* @__PURE__ */ new Error("mesh assembly worker crashed"));
+			pendingAssemblies.clear();
+			worker.terminate();
+			assemblyWorker = null;
+		};
+		assemblyWorker = worker;
+	} catch {
+		assemblyWorker = null;
+	}
+	return assemblyWorker;
+}
+function requestAssembly(worker, input, transfer) {
+	return new Promise((resolve, reject) => {
+		const id = nextAssemblyRequestId++;
+		pendingAssemblies.set(id, {
+			resolve,
+			reject
+		});
+		worker.postMessage({
+			id,
+			input
+		}, transfer);
+	});
+}
+// src/parse/webdisplay/apply-texture.ts
+/**
+* Anisotropic-filtering samples applied to material textures, keeping them sharp at grazing angles
+* instead of blurring. Ceiling is hardware-defined (`renderer.capabilities.getMaxAnisotropy()`,
+* typically 16). Defaults to three's default (1 — no anisotropy) until a renderer reports in.
+*/
+let maxAnisotropy = 1;
+/**
+* Subscribed to the renderer's own report below, so no host wiring is needed; still exported for a
+* host embedding a foreign renderer that wants to set it directly. Applies to textures loaded from
+* here on — textures already decoded keep the value they were given.
+*/
+function setTextureAnisotropy(value) {
+	maxAnisotropy = Math.max(1, value);
+}
+require_gpu_dispose.observeMaxAnisotropy(setTextureAnisotropy);
+/**
+* Assigns a texture to `material[slot]` once fetched and decoded — the mesh renders without it for
+* the first frames. Load failures log a warning and leave the slot empty rather than breaking the
+* batch.
+*
+* Each call loads independently: no caching, no cross-material sharing. The texture is owned by the
+* material it is assigned to, so the scene's normal dispose walk frees it like any other resource.
+*/
+function applyTexture(material, url, slot, mapSize) {
+	if (typeof document === "undefined") return;
+	new three.TextureLoader().load(url, (texture) => {
+		texture.colorSpace = slot === "map" ? three.SRGBColorSpace : three.NoColorSpace;
+		texture.anisotropy = maxAnisotropy;
+		if (mapSize) {
+			const image = texture.image;
+			const aspect = image?.width && image.height ? image.height / image.width : 1;
+			texture.wrapS = three.RepeatWrapping;
+			texture.wrapT = three.RepeatWrapping;
+			texture.repeat.set(1 / mapSize, 1 / (mapSize * aspect));
+		}
+		material[slot] = texture;
+		material.needsUpdate = true;
+	}, void 0, (error) => {
+		require_gpu_dispose.getLogger().warn(`Failed to load material ${slot} ${url}:`, error);
+	});
+}
+// src/parse/webdisplay/batch/surface-finish.ts
+/**
+* Procedural surfaces, so a preset looks like its material with no texture files to ship or upload.
+* UVs are millimetres, so a brick is brick-sized at any model scale. Each recipe sets `tone` (albedo
+* multiplier), `gloss` (roughness multiplier) and `height` (relief in metres, to match the viewer).
+* Every pattern goes through `selvaDetail`, colour included: a noise cell or a brick under a pixel
+* samples to static, so a whole building has to settle to its flat colour.
+*/
+const RECIPES$1 = {
+	wood: `
+		float warp = selvaFbm( uv * vec2( 0.003, 0.02 ) );
+		float rings = 0.5 + 0.5 * sin( ( uv.y + warp * 90.0 ) * 0.28 );
+		float fibre = selvaNoise( uv * vec2( 0.03, 1.4 ) );
+		float grain = ( rings * 0.65 + fibre * 0.35 ) - 0.5;
+		grain *= selvaDetail( 4.0 );
+		tone = vec3( 1.0 + grain * 0.42 );
+		gloss = 1.0 + grain * 0.35;
+		height = fibre * 0.00012 * selvaDetail( 1.0 );`,
+	concrete: `
+		float blotch = ( selvaFbm( uv * 0.0035 ) - 0.5 ) * selvaDetail( 40.0 );
+		float holes = smoothstep( 0.8, 0.88, selvaNoise( uv * 0.22 ) ) * selvaDetail( 5.0 );
+		float speck = selvaNoise( uv * 0.9 ) - 0.5;
+		tone = vec3( 1.0 + blotch * 0.26 + speck * 0.05 * selvaDetail( 1.0 ) - holes * 0.2 );
+		gloss = 1.0 + blotch * 0.3;
+		height = -holes * 0.0005;`,
+	plaster: `
+		float trowel = 0.5 + ( selvaFbm( uv * 0.05 ) - 0.5 ) * selvaDetail( 6.0 );
+		tone = vec3( 1.0 + ( trowel - 0.5 ) * 0.07 );
+		gloss = 1.0 + ( trowel - 0.5 ) * 0.2;
+		height = trowel * 0.0007;`,
+	brick: `
+		vec2 course = vec2( 225.0, 75.0 );
+		float row = floor( uv.y / course.y );
+		vec2 laid = vec2( uv.x + mod( row, 2.0 ) * course.x * 0.5, uv.y );
+		vec2 id = floor( laid / course );
+		vec2 edge = abs( fract( laid / course ) - 0.5 ) * course;
+		float joint = 1.0 - smoothstep( 0.0, 1.5, min( course.x * 0.5 - 5.0 - edge.x, course.y * 0.5 - 5.0 - edge.y ) );
+		joint *= selvaDetail( 10.0 );
+		float face = 1.0 + ( ( selvaHash( id ) - 0.5 ) * 0.48 + ( selvaFbm( uv * 0.05 ) - 0.5 ) * 0.25 ) * selvaDetail( 65.0 );
+		tone = mix( vec3( face ), vec3( 1.5, 1.7, 1.8 ), joint );
+		gloss = 1.0 + joint * 0.15;
+		height = -joint * 0.005;`,
+	corten: `
+		float bloom = 0.5 + ( selvaFbm( uv * vec2( 0.006, 0.0025 ) ) - 0.5 ) * selvaDetail( 25.0 );
+		float scale = 0.5 + ( selvaFbm( uv * 0.06 ) - 0.5 ) * selvaDetail( 8.0 );
+		tone = mix( vec3( 0.62, 0.52, 0.46 ), vec3( 1.28, 1.08, 0.9 ), smoothstep( 0.32, 0.68, bloom ) );
+		tone *= 1.0 + ( scale - 0.5 ) * 0.3;
+		gloss = 1.0 + ( scale - 0.5 ) * 0.25;
+		height = scale * 0.0004;`
+};
+const f$1 = (n) => n.toFixed(4);
+/** Null for the finishes `finish.ts` draws itself. */
+function surfacePatch(finish, strength) {
+	const recipe = RECIPES$1[finish];
+	if (!recipe || !(strength > 0)) return null;
+	const patch = (shader) => {
+		shader.fragmentShader = shader.fragmentShader.replace("#include <common>", `#include <common>
+				float selvaFootprint;
+				// Hash without sine: sin() loses precision on the large arguments mm UVs produce.
+				float selvaHash( vec2 p ) {
+					vec3 p3 = fract( vec3( p.xyx ) * 0.1031 );
+					p3 += dot( p3, p3.yzx + 33.33 );
+					return fract( ( p3.x + p3.y ) * p3.z );
+				}
+				float selvaNoise( vec2 p ) {
+					vec2 i = floor( p );
+					vec2 f = fract( p );
+					vec2 s = f * f * ( 3.0 - 2.0 * f );
+					return mix(
+						mix( selvaHash( i ), selvaHash( i + vec2( 1.0, 0.0 ) ), s.x ),
+						mix( selvaHash( i + vec2( 0.0, 1.0 ) ), selvaHash( i + vec2( 1.0, 1.0 ) ), s.x ),
+						s.y
+					);
+				}
+				float selvaFbm( vec2 p ) {
+					float sum = 0.0;
+					float amplitude = 0.5;
+					for ( int i = 0; i < 4; i ++ ) {
+						sum += amplitude * selvaNoise( p );
+						p = p * 2.03 + vec2( 17.0, 9.0 );
+						amplitude *= 0.5;
+					}
+					return sum / 0.9375;
+				}
+				float selvaDetail( float featureMm ) {
+					return 1.0 - smoothstep( 0.5, 1.5, selvaFootprint / featureMm );
+				}`).replace("#include <color_fragment>", `#include <color_fragment>
+				selvaFootprint = max( max( fwidth( vUv.x ), fwidth( vUv.y ) ), 1e-6 );
+				vec2 uv = vUv;
+				vec3 tone = vec3( 1.0 );
+				float gloss = 1.0;
+				float height = 0.0;
+				${recipe}
+				diffuseColor.rgb *= mix( vec3( 1.0 ), tone, ${f$1(strength)} );`).replace("#include <roughnessmap_fragment>", `#include <roughnessmap_fragment>
+				roughnessFactor = clamp( roughnessFactor * mix( 1.0, gloss, ${f$1(strength)} ), 0.0, 1.0 );`).replace("#include <normal_fragment_maps>", `#include <normal_fragment_maps>
+				{
+					// Bump from screen derivatives, as three's perturbNormalArb.
+					vec3 dx = dFdx( - vViewPosition );
+					vec3 dy = dFdy( - vViewPosition );
+					vec3 r1 = cross( dy, normal );
+					vec3 r2 = cross( normal, dx );
+					float det = dot( dx, r1 ) * faceDirection;
+					vec3 grad = sign( det ) * ( dFdx( height ) * r1 + dFdy( height ) * r2 ) * ${f$1(strength)};
+					normal = normalize( abs( det ) * normal - grad );
+				}`);
+	};
+	return {
+		key: `surface:${finish}:${f$1(strength)}`,
+		patch
+	};
+}
+// src/parse/webdisplay/batch/finish.ts
+const RECIPES = {
+	brushed: {
+		fibres: [{
+			pitch: .04,
+			length: [2, 12],
+			depth: .3
+		}, {
+			pitch: .25,
+			length: [5, 40],
+			depth: .18
+		}],
+		bands: []
+	},
+	rolled: {
+		fibres: [{
+			pitch: .3,
+			length: [80, 600],
+			depth: .07
+		}],
+		bands: [{
+			width: 20,
+			length: 1500,
+			depth: .05
+		}]
+	}
+};
+const TILT = .6;
+const FIBRE_FADE = .35;
+const f = (n) => n.toFixed(4);
+/** The shader patch for a finish, or null when it would draw nothing. `key` extends the program cache key. */
+function finishPatch(finish, strength) {
+	const recipe = RECIPES[finish];
+	if (!recipe) return surfacePatch(finish, strength);
+	if (!(strength > 0)) return null;
+	const fibres = recipe.fibres.map((fb, i) => `selvaFibres( vUv, footprint, ${f(fb.pitch)}, vec2( ${f(fb.length[0])}, ${f(fb.length[1])} ), ${f(fb.depth)}, ${f(i * 31 + 3)} )`).join(" + ") || "0.0";
+	const bands = recipe.bands.map((b) => `selvaBand( vUv, footprint, vec2( ${f(b.length)}, ${f(b.width)} ), ${f(b.depth)} )`).join(" + ") || "0.0";
+	const patch = (shader) => {
+		shader.fragmentShader = shader.fragmentShader.replace("#include <common>", `#include <common>
 				// Hash without sine: sin() loses precision on the large arguments mm UVs produce.
 				float selvaHash( vec2 p ) {
 					vec3 p3 = fract( vec3( p.xyx ) * 0.1031 );
@@ -34,20 +1864,20 @@ Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=requi
 				float selvaFibres( vec2 uv, float footprint, float pitch, vec2 len, float depth, float seed ) {
 					float level = clamp( log2( footprint / pitch ) + 0.5, 0.0, 14.0 );
 					float l0 = floor( level );
-					float a = selvaFibreRow( uv, pitch * exp2( l0 ), len, seed + 7.0 * l0 ) * exp2( -${Y(he)} * l0 );
+					float a = selvaFibreRow( uv, pitch * exp2( l0 ), len, seed + 7.0 * l0 ) * exp2( -${f(FIBRE_FADE)} * l0 );
 					float b = selvaFibreRow( uv, pitch * exp2( l0 + 1.0 ), len, seed + 7.0 * l0 + 7.0 )
-						* exp2( -${Y(he)} * ( l0 + 1.0 ) );
+						* exp2( -${f(FIBRE_FADE)} * ( l0 + 1.0 ) );
 					return depth * mix( a, b, level - l0 );
 				}
 				float selvaBand( vec2 uv, float footprint, vec2 size, float depth ) {
 					float fade = 1.0 - smoothstep( 0.5, 1.0, footprint / size.y );
 					return depth * fade * ( selvaNoise( uv / size ) * 2.0 - 1.0 );
-				}`).replace(`#include <color_fragment>`,`#include <color_fragment>
+				}`).replace("#include <color_fragment>", `#include <color_fragment>
 				float footprint = max( fwidth( vUv.y ), 1e-6 );
-				float selvaFibre = ( ${r} ) * ${Y(t)};
-				float selvaStreak = selvaFibre + ( ${i} ) * ${Y(t)};
-				diffuseColor.rgb *= 1.0 + 0.5 * selvaStreak;`).replace(`#include <roughnessmap_fragment>`,`#include <roughnessmap_fragment>
-				roughnessFactor = clamp( roughnessFactor * ( 1.0 + selvaStreak ), 0.0, 1.0 );`).replace(`#include <normal_fragment_maps>`,`#include <normal_fragment_maps>
+				float selvaFibre = ( ${fibres} ) * ${f(strength)};
+				float selvaStreak = selvaFibre + ( ${bands} ) * ${f(strength)};
+				diffuseColor.rgb *= 1.0 + 0.5 * selvaStreak;`).replace("#include <roughnessmap_fragment>", `#include <roughnessmap_fragment>
+				roughnessFactor = clamp( roughnessFactor * ( 1.0 + selvaStreak ), 0.0, 1.0 );`).replace("#include <normal_fragment_maps>", `#include <normal_fragment_maps>
 				#ifdef USE_ANISOTROPY
 					vec3 selvaAcross = tbn[ 1 ];
 				#else
@@ -57,12 +1887,960 @@ Object.defineProperty(exports,Symbol.toStringTag,{value:`Module`});const e=requi
 					vec3 selvaAcross = cross( selvaQ1, normal ) * dFdx( vUv ).y + cross( normal, selvaQ0 ) * dFdy( vUv ).y;
 					selvaAcross *= inversesqrt( max( dot( selvaAcross, selvaAcross ), 1e-12 ) );
 				#endif
-				normal = normalize( normal + ${Y(.6)} * selvaFibre * selvaAcross );`)}}}function _e(e,t){return t?.appearance?.cullBackfaces?!0:(t?.closed??!1)&&!e.transparent&&e.opacity>=1}function ve(e,t){let n=new Map;return(r,i)=>{let a=e[r],o=_e(a,{...t,closed:i}),s=`${r}:${o}`,c=n.get(s);return c||(c=ye(a,{...t,closed:o}),n.set(s,c)),c}}function ye(e,r){let i=t.o(e.color),a=r?.vertexColors??!1,o=r?.appearance,s=new n.MeshPhysicalMaterial({color:i,metalness:e.metalness,roughness:e.roughness,opacity:e.opacity,transparent:e.transparent,vertexColors:a,side:_e(e,r)?n.FrontSide:n.DoubleSide,polygonOffset:!0,polygonOffsetFactor:.25,polygonOffsetUnits:0,depthWrite:!0,depthTest:!0});e.envMapIntensity==null?o?.envMapIntensity!=null&&(s.envMapIntensity=t.u(o.envMapIntensity,e.metalness)):(s.envMapIntensity=e.envMapIntensity,s.userData[t.l]=e.envMapIntensity),e.clearcoat!=null&&(s.clearcoat=e.clearcoat,s.clearcoatRoughness=e.clearcoatRoughness??0),e.anisotropy!=null&&e.anisotropy>0&&r?.hasUvs&&(s.anisotropy=e.anisotropy,s.anisotropyRotation=e.anisotropyRotation??0),e.transmission!=null&&(s.transmission=e.transmission,s.thickness=0),e.ior!=null&&(s.ior=e.ior),a&&xe(s);let c=e.finish&&r?.hasUvs?ge(e.finish,e.finishStrength??1):null;c&&(s.defines={...s.defines,USE_UV:``},be(s,c.key,c.patch));let{mapSize:l}=e;return e.map&&J(s,e.map,`map`,l),e.roughnessMap&&J(s,e.roughnessMap,`roughnessMap`,l),e.normalMap&&J(s,e.normalMap,`normalMap`,l),s}function be(e,t,n){let r=e.onBeforeCompile,i=e.customProgramCacheKey.bind(e);e.onBeforeCompile=(t,i)=>{r.call(e,t,i),n(t)},e.customProgramCacheKey=()=>`${i()}|${t}`}function xe(e){be(e,`srgb-vertex-colors`,e=>{e.vertexShader=e.vertexShader.replace(`#include <color_vertex>`,`#include <color_vertex>
+				normal = normalize( normal + ${f(TILT)} * selvaFibre * selvaAcross );`);
+	};
+	return {
+		key: `finish:${finish}:${f(strength)}`,
+		patch
+	};
+}
+// src/parse/webdisplay/batch/materials.ts
+const SURFACE_OFFSET_FACTOR = .25;
+function cullsBackFaces(matData, options) {
+	if (options?.appearance?.cullBackfaces) return true;
+	return (options?.closed ?? false) && !matData.transparent && matData.opacity >= 1;
+}
+function createMaterialPicker(materialsSrc, options) {
+	const built = /* @__PURE__ */ new Map();
+	return (materialId, closed) => {
+		const matData = materialsSrc[materialId];
+		const culled = cullsBackFaces(matData, {
+			...options,
+			closed
+		});
+		const key = `${materialId}:${culled}`;
+		let material = built.get(key);
+		if (!material) {
+			material = createMaterial(matData, {
+				...options,
+				closed: culled
+			});
+			built.set(key, material);
+		}
+		return material;
+	};
+}
+function createMaterial(matData, options) {
+	const color = require_gpu_dispose.parseColor(matData.color);
+	const vertexColors = options?.vertexColors ?? false;
+	const appearance = options?.appearance;
+	const material = new three.MeshPhysicalMaterial({
+		color,
+		metalness: matData.metalness,
+		roughness: matData.roughness,
+		opacity: matData.opacity,
+		transparent: matData.transparent,
+		vertexColors,
+		side: cullsBackFaces(matData, options) ? three.FrontSide : three.DoubleSide,
+		polygonOffset: true,
+		polygonOffsetFactor: SURFACE_OFFSET_FACTOR,
+		polygonOffsetUnits: 0,
+		depthWrite: true,
+		depthTest: true
+	});
+	if (matData.envMapIntensity != null) {
+		material.envMapIntensity = matData.envMapIntensity;
+		material.userData[require_gpu_dispose.OWN_ENV_MAP_INTENSITY] = matData.envMapIntensity;
+	} else if (appearance?.envMapIntensity != null) material.envMapIntensity = require_gpu_dispose.lookEnvMapIntensity(appearance.envMapIntensity, matData.metalness);
+	if (matData.emissive != null) {
+		material.emissive.set(matData.emissive);
+		material.emissiveIntensity = matData.emissiveIntensity ?? 1;
+		material.userData[require_gpu_dispose.OWN_EMISSIVE] = true;
+		if (matData.emissiveLight != null) material.userData[require_gpu_dispose.EMISSIVE_LIGHT] = matData.emissiveLight;
+	}
+	if (matData.clearcoat != null) {
+		material.clearcoat = matData.clearcoat;
+		material.clearcoatRoughness = matData.clearcoatRoughness ?? 0;
+	}
+	if (matData.anisotropy != null && matData.anisotropy > 0 && options?.hasUvs) {
+		material.anisotropy = matData.anisotropy;
+		material.anisotropyRotation = matData.anisotropyRotation ?? 0;
+	}
+	if (matData.transmission != null) {
+		material.transmission = matData.transmission;
+		material.thickness = 0;
+	}
+	if (matData.ior != null) material.ior = matData.ior;
+	if (vertexColors) applyVertexColorSRGBDecode(material);
+	const finish = matData.finish && options?.hasUvs ? finishPatch(matData.finish, matData.finishStrength ?? 1) : null;
+	if (finish) {
+		material.defines = {
+			...material.defines,
+			USE_UV: ""
+		};
+		addShaderPatch(material, finish.key, finish.patch);
+	}
+	const { mapSize } = matData;
+	if (matData.map) applyTexture(material, matData.map, "map", mapSize);
+	if (matData.roughnessMap) applyTexture(material, matData.roughnessMap, "roughnessMap", mapSize);
+	if (matData.normalMap) applyTexture(material, matData.normalMap, "normalMap", mapSize);
+	return material;
+}
+/**
+* Chains `patch` after any earlier one. three caches compiled programs by `customProgramCacheKey`,
+* which defaults to the `onBeforeCompile` source; a chained wrapper's source is the same whatever
+* it wraps, so every patch must extend the key or two materials would share one program.
+*/
+function addShaderPatch(material, key, patch) {
+	const previous = material.onBeforeCompile;
+	const previousKey = material.customProgramCacheKey.bind(material);
+	material.onBeforeCompile = (shader, renderer) => {
+		previous.call(material, shader, renderer);
+		patch(shader);
+	};
+	material.customProgramCacheKey = () => `${previousKey()}|${key}`;
+}
+/**
+* three.js uploads vertex colors verbatim and multiplies them straight into linear working space
+* (unlike textures, which carry a `colorSpace` and get decoded) — so sRGB-authored vertex colors
+* render too bright without this shader patch. Done on the GPU rather than a CPU pass over the
+* buffer, to keep the hot per-solve parse cheap.
+*/
+function applyVertexColorSRGBDecode(material) {
+	addShaderPatch(material, "srgb-vertex-colors", (shader) => {
+		shader.vertexShader = shader.vertexShader.replace("#include <color_vertex>", `#include <color_vertex>
 			#if defined( USE_COLOR ) || defined( USE_COLOR_ALPHA )
 				vColor.rgb = mix(
 					vColor.rgb / 12.92,
 					pow( ( vColor.rgb + 0.055 ) / 1.055, vec3( 2.4 ) ),
 					step( vec3( 0.04045 ), vColor.rgb )
 				);
-			#endif`)})}function X(e,n){return new t.g(e,t.h.VALIDATION_ERROR,{context:n})}function Se(e,t,n,r){for(let i of e){if(!Number.isInteger(i.materialId)||i.materialId<0||i.materialId>=t)throw X(`Group materialId out of range of the materials array.`,{materialId:i.materialId,materialCount:t});for(let e of i.meshes){let t={vertexStart:e.vertexStart,vertexCount:e.vertexCount,indexStart:e.indexStart,indexCount:e.indexCount};for(let[n,r]of Object.entries(t))if(!Number.isInteger(r)||r<0)throw X(`Mesh metadata field "${n}" must be a non-negative integer.`,{meshName:e.name,field:n,value:r});if(e.vertexStart+e.vertexCount>n)throw X(`Mesh vertex window exceeds the batch vertex buffer.`,{meshName:e.name,vertexStart:e.vertexStart,vertexCount:e.vertexCount,totalVertexCount:n});if(e.indexStart+e.indexCount>r)throw X(`Mesh index window exceeds the batch index buffer.`,{meshName:e.name,indexStart:e.indexStart,indexCount:e.indexCount,totalIndexCount:r})}}}function Ce(e,t){return X(`Index references a vertex outside its mesh's vertex window.`,{meshName:t.name,indexValue:e,vertexStart:t.vertexStart,vertexCount:t.vertexCount})}function we(e,t,n){let r=new Float32Array(e.length),i=t[0],a=t[1],o=t[2],s=n[0],c=n[1],l=n[2];for(let t=0;t<e.length;t+=3)r[t]=i+(e[t]+32767)*s,r[t+1]=a+(e[t+1]+32767)*c,r[t+2]=o+(e[t+2]+32767)*l;return r}function Te(e){let t=new Map;for(let n of e.meshes){let e=n.layer??``,r=t.get(e);r||(r=[],t.set(e,r)),r.push(n)}return[...t.values()].map(t=>({materialId:e.materialId,meshes:t}))}function Ee(e,t,n,r,i=null,a=null){let o=0,s=0;for(let t of e.meshes)o+=t.vertexCount,s+=t.indexCount;let c=new Float32Array(o*3),l=new Uint32Array(s),u=i?new Float32Array(o*2):null,d=a?new Uint8Array(o*3):null,f=0,p=0;for(let r of e.meshes){let e=r.vertexStart*3,o=r.vertexCount*3;if(c.set(t.subarray(e,e+o),f*3),u&&i){let e=r.vertexStart*2;u.set(i.subarray(e,e+r.vertexCount*2),f*2)}d&&a&&d.set(a.subarray(e,e+o),f*3);let s=n.subarray(r.indexStart,r.indexStart+r.indexCount),m=f-r.vertexStart,h=r.vertexStart,g=r.vertexStart+r.vertexCount;for(let e=0;e<s.length;e++){let t=s[e];if(t<h||t>=g)throw Ce(t,r);l[p+e]=t+m}f+=r.vertexCount,p+=r.indexCount}let m=U({positions:c,indices:l,uvs:u,colors:d},e.meshes.map(e=>e.indexCount));return Oe(Z(m),e,r(e.materialId,m.closed))}function Z(e){let t=new n.BufferGeometry;return t.setAttribute(`position`,new n.BufferAttribute(e.positions,3)),t.setAttribute(`normal`,new n.BufferAttribute(e.normals,3)),t.setIndex(new n.BufferAttribute(e.indices,1)),e.uvs&&t.setAttribute(`uv`,new n.BufferAttribute(e.uvs,2)),e.tangents&&t.setAttribute(`tangent`,new n.BufferAttribute(e.tangents,4)),e.colors&&t.setAttribute(`color`,new n.BufferAttribute(e.colors,3,!0)),t}function De(e){let t=[],n=0;for(let r of e.meshes)t.push({trackingKey:r.id,name:r.name,layer:r.layer,metadata:r.metadata??{},indexStart:n,indexCount:r.indexCount}),n+=r.indexCount;return t}function Oe(e,t,r){let i=new n.Mesh(e,r),a=t.meshes[0],o=t.meshes.map(e=>e.name).filter(e=>e&&e.length>0);return i.name=o.length>0?o[0]:`merged_material_${t.materialId}`,i.castShadow=!0,i.receiveShadow=!0,i.userData={source:`compute`,name:i.name,layer:a?.layer??``,metadata:a?.metadata??{},members:De(t)},i}function ke(e,t,n,r,i=null,a=null){let o=[];for(let s of e.meshes){let c=s.vertexStart*3,l=s.vertexCount*3,u=t.slice(c,c+l),d=n.subarray(s.indexStart,s.indexStart+s.indexCount),f=new Uint32Array(d.length),p=s.vertexStart,m=s.vertexStart+s.vertexCount;for(let e=0;e<d.length;e++){let t=d[e];if(t<p||t>=m)throw Ce(t,s);f[e]=t-p}let h=s.vertexStart*2,g=U({positions:u,indices:f,uvs:i?i.slice(h,h+s.vertexCount*2):null,colors:a?a.slice(c,c+l):null},[f.length]);o.push(Ae(Z(g),s,r(e.materialId,g.closed)))}return o}function Ae(e,t,r){let i=new n.Mesh(e,r);return i.name=t.name,i.userData={source:`compute`,name:t.name,layer:t.layer??``,trackingKey:t.id,metadata:t.metadata??{}},i.castShadow=!0,i.receiveShadow=!0,i}async function je(e,t,n){let{mergeByMaterial:r=!0,debug:i=!1,material:a}=t??{},{parseTime:o=0,perfStart:s=i?performance.now():0}=n??{};if(!e.compressedData)return[];let c=await Ie(e.compressedData,{mergeByMaterial:r,debug:i,material:a,fallback:{materials:e.materials,groups:e.groups}});if(c)return c;let l=performance.now();return Fe(oe(e.compressedData),{mergeByMaterial:r,debug:i,material:a,parseTime:o,decodeTime:performance.now()-l,perfStart:s,blobBytes:i?Le(e.compressedData):0,fallback:{materials:e.materials,groups:e.groups}})}async function Me(e,t){let{mergeByMaterial:n=!0,debug:r=!1,material:i}=t??{},a=r?performance.now():0,o=await Ie(e,{mergeByMaterial:n,debug:r,material:i});if(o)return o;let s=performance.now(),c=oe(e),l=performance.now()-s,u=e.byteLength;return Fe(c,{mergeByMaterial:n,debug:r,material:i,parseTime:0,decodeTime:l,perfStart:a,blobBytes:u})}let Ne=!1;function Pe(e,n){if(e||Ne)return;let r=0;for(let e of n)r+=e.meshes.length;r<1e3||(Ne=!0,t.p().warn(`Parsing ${r} meshes with mergeByMaterial: false — each becomes its own THREE object, and render cost scales with object count. Drop the option to merge by material (the default); per-object identity survives it via userData.members.`))}function Fe(e,n){let{mergeByMaterial:r,debug:i,material:a,parseTime:o,decodeTime:s,perfStart:c,blobBytes:l,fallback:u}=n,d=e.metadata.materials??u?.materials??[],f=e.metadata.groups??u?.groups??[],p=!!(e.flags&1);Se(f,d.length,e.vertices.length/3,e.indices.length);let m=p?e.vertices:we(e.vertices,e.origin,e.scale);if(i){let n=e.vertices.byteLength+e.indices.byteLength;t.p().debug(`Mesh Batch Stats:`),t.p().debug(`  Materials: ${d.length} | Groups: ${f.length}`),t.p().debug(`  Vertices: ${e.vertices.length/3} | Indices: ${e.indices.length}`),t.p().debug(`  Format: ${p?`float32`:`int16 quantized`}`),t.p().debug(`  Blob: ${(l/1024/1024).toFixed(2)} MB | Geometry on wire: ${(n/1024/1024).toFixed(2)} MB`)}Pe(r,f);let h=performance.now(),g=ve(d,{vertexColors:e.colors!=null,hasUvs:e.uvs!=null,appearance:a}),_=[],v=r?f.flatMap(Te):f;for(let t of v)if(r&&t.meshes.length>1){let n=Ee(t,m,e.indices,g,e.uvs,e.colors);_.push(n)}else{let n=ke(t,m,e.indices,g,e.uvs,e.colors);_.push(...n)}let y=performance.now()-h;if(i){let e=performance.now()-c;t.p().debug(`Performance:`),o>0&&t.p().debug(`  Parse JSON: ${o.toFixed(2)}ms`),t.p().debug(`  Decode binary: ${s.toFixed(2)}ms`),t.p().debug(`  Create Meshes: ${y.toFixed(2)}ms`),t.p().debug(`  Total: ${e.toFixed(2)}ms`)}return Promise.resolve(_)}async function Ie(e,n){if(typeof Worker>`u`)return null;let r=V(e),i=r.planarByteSplit?r.indexData.length/(r.uint16Indices?2:4):r.indexData.length;if(i/3<5e4)return null;let a=fe();if(!a)return null;let o=r.metadata.materials??n.fallback?.materials??[],s=r.metadata.groups??n.fallback?.groups??[];Se(s,o.length,r.vertexCount,i);let c=e=>({vertexStart:e.vertexStart,vertexCount:e.vertexCount,indexStart:e.indexStart,indexCount:e.indexCount}),l=[],u=[],d=n.mergeByMaterial?s.flatMap(Te):s;for(let e of d)if(n.mergeByMaterial&&e.meshes.length>1)l.push({kind:`merged`,windows:e.meshes.map(c)}),u.push({kind:`merged`,group:e});else for(let t of e.meshes)l.push({kind:`single`,windows:[c(t)]}),u.push({kind:`single`,group:e,meshMeta:t});let f=r.vertexData.slice(),p=r.indexData.slice(),m=[f.buffer,p.buffer];r.uvs&&m.push(r.uvs.buffer),r.colors&&m.push(r.colors.buffer);let h;try{h=await pe(a,{vertexData:f,isFloat32:r.isFloat32,deltaEncoded:r.deltaEncoded,planarByteSplit:r.planarByteSplit,uint16Indices:r.uint16Indices,origin:r.origin,scale:r.scale,indexData:p,uvs:r.uvs,colors:r.colors,jobs:l},m)}catch(e){return t.p().warn(`Mesh assembly worker failed; falling back to main-thread parse.`,e),null}if(h.length!==l.length)return null;let g=ve(o,{vertexColors:r.colors!=null,hasUvs:r.uvs!=null,appearance:n.material}),_=[];for(let e=0;e<h.length;e++){let t=h[e],n=u[e],r=Z(t),i=g(n.group.materialId,t.closed),a=n.kind===`merged`?Oe(r,n.group,i):Ae(r,n.meshMeta,i);_.push(a)}return n.debug&&t.p().debug(`Mesh batch assembled off-thread: ${_.length} meshes, ${i/3} triangles`),_}function Le(e){return Math.floor(e.length*3/4)}const Q={Angstroms:1e-10,Nanometers:1e-9,Microns:1e-6,Millimeters:.001,Centimeters:.01,Decimeters:.1,Meters:1,Dekameters:10,Hectometers:100,Kilometers:1e3,Megameters:1e6,Gigameters:1e9,Microinches:2.54e-8,Mils:254e-7,Inches:.0254,Feet:.3048,Yards:.9144,Miles:1609.344,NauticalMiles:1852};function Re(e){let t=e.split(`.`);return t.includes(`Display`)||t.includes(`DisplayBatch`)}const $=new Set;async function ze(e,t){let n=performance.now(),r=[],{allowScaling:i=!0,allowAutoPosition:a=!1,groundAxis:o=`z`,debug:s=!1,parsing:c={}}=t??{};try{return await Ve(e,r,i?Be(e.modelunits):1,c,s),a&&Ge(r,o),r}catch(e){throw Ke(e,r),e}finally{s&&Je(n)}}function Be(e){let n=Q[e];return n===void 0?($.has(e)||($.add(e),t.p().warn(`Unknown Rhino model unit "${e}" — geometry will not be scaled (factor 1). Known units: ${Object.keys(Q).join(`, `)}.`)),1):n}async function Ve(e,t,n,r,i){for(let a of e.values){let e=a.InnerTree;for(let a in e){let o=e[a];o&&await He(o,t,n,r,i)}}}async function He(e,n,r,i,a){for(let o of e){if(!Re(o.type))continue;let e={debug:!1,...i,mergeByMaterial:i.mergeByMaterial??!0},s=Ue(o.data);if(!s){t.p().error(`Error parsing display batch envelope: invalid JSON`);continue}let c=await je(s,e),l=v(s.items),u=[...c,...l];if(r!==1)for(let e of u)e.scale.set(r,r,r);n.push(...u),a&&t.p().debug(`Extracted ${c.length} meshes and ${l.length} items from batch`)}}function Ue(e){return typeof e==`string`?We(e):e}function We(e){try{return JSON.parse(e)}catch{return}}function Ge(e,n){if(e.length===0)return;let r=t.a(e);t.i(e,r.min[n],n)}function Ke(e,n){t.p().error(`An unexpected error occurred:`,e),qe(n)}function qe(e){for(let t of e){let e=t;e.geometry&&e.geometry.dispose(),e.material&&(Array.isArray(e.material)?e.material.forEach(e=>e.dispose()):e.material.dispose())}}function Je(e){let n=performance.now()-e;t.p().info(`Time to process meshes:`,`${n.toFixed(2)}ms`)}exports.SCALE_FACTORS=Q,exports.getThreeObjectsFromComputeResponse=ze,exports.meshPolicy=p,exports.parseDisplayItems=v,exports.parseMeshBatchBlob=Me,exports.parseMeshBatchObject=je,exports.setTextureAnisotropy=q;
+			#endif`);
+	});
+}
+// src/parse/webdisplay/batch/metadata.ts
+function metadataFail(message, context) {
+	return new require_gpu_dispose.VisualizationError(message, require_gpu_dispose.ErrorCodes.VALIDATION_ERROR, { context });
+}
+/**
+* Validates the batch's group/mesh metadata against the decoded geometry buffers before any of it
+* is used arithmetically. Throws on the first inconsistency — out-of-range `materialId`,
+* non-integer or negative offsets/counts, or a vertex/index window that overruns the buffers — so
+* malformed or version-skewed metadata fails the parse loudly instead of corrupting the render.
+*/
+function validateGroupMetadata(groups, materialCount, totalVertexCount, totalIndexCount) {
+	for (const group of groups) {
+		if (!Number.isInteger(group.materialId) || group.materialId < 0 || group.materialId >= materialCount) throw metadataFail("Group materialId out of range of the materials array.", {
+			materialId: group.materialId,
+			materialCount
+		});
+		for (const mesh of group.meshes) {
+			const fields = {
+				vertexStart: mesh.vertexStart,
+				vertexCount: mesh.vertexCount,
+				indexStart: mesh.indexStart,
+				indexCount: mesh.indexCount
+			};
+			for (const [field, value] of Object.entries(fields)) if (!Number.isInteger(value) || value < 0) throw metadataFail(`Mesh metadata field "${field}" must be a non-negative integer.`, {
+				meshName: mesh.name,
+				field,
+				value
+			});
+			if (mesh.vertexStart + mesh.vertexCount > totalVertexCount) throw metadataFail("Mesh vertex window exceeds the batch vertex buffer.", {
+				meshName: mesh.name,
+				vertexStart: mesh.vertexStart,
+				vertexCount: mesh.vertexCount,
+				totalVertexCount
+			});
+			if (mesh.indexStart + mesh.indexCount > totalIndexCount) throw metadataFail("Mesh index window exceeds the batch index buffer.", {
+				meshName: mesh.name,
+				indexStart: mesh.indexStart,
+				indexCount: mesh.indexCount,
+				totalIndexCount
+			});
+		}
+	}
+}
+/**
+* Error for an index outside its mesh's declared vertex window
+* `[vertexStart, vertexStart + vertexCount)`. Rebasing (`index - vertexStart`) writes into an
+* unsigned array, so an out-of-window index would otherwise wrap to ~4 billion and corrupt the
+* geometry. Range checks live inline in the copy loops (a function call per index measured
+* noticeably slower at millions of indices) — this only builds the failure.
+*/
+function indexOutOfWindow(indexValue, meshMeta) {
+	return metadataFail("Index references a vertex outside its mesh's vertex window.", {
+		meshName: meshMeta.name,
+		indexValue,
+		vertexStart: meshMeta.vertexStart,
+		vertexCount: meshMeta.vertexCount
+	});
+}
+/**
+* Reconstructs world-unit float32 positions from int16 quantized values:
+* `world = origin + (q + 32767) * scale`. No rotation — the Three scene uses Rhino's Z-up frame,
+* so vertices pass through as they arrived.
+*/
+function dequantizeInt16(q, origin, scale) {
+	const out = new Float32Array(q.length);
+	const ox = origin[0];
+	const oy = origin[1];
+	const oz = origin[2];
+	const sx = scale[0];
+	const sy = scale[1];
+	const sz = scale[2];
+	for (let i = 0; i < q.length; i += 3) {
+		out[i] = ox + (q[i] + 32767) * sx;
+		out[i + 1] = oy + (q[i + 1] + 32767) * sy;
+		out[i + 2] = oz + (q[i + 2] + 32767) * sz;
+	}
+	return out;
+}
+// src/parse/webdisplay/batch/merge.ts
+/**
+* Split a material group into one sub-group per layer, preserving mesh order.
+*
+* Merging is by material alone, but a merged mesh is one THREE object and so can sit on exactly
+* one layer in the outliner. Without this split, two layers sharing a material collapse into a
+* single object filed under the first one, and hiding either layer hides both.
+*/
+function splitGroupByLayer(group) {
+	const byLayer = /* @__PURE__ */ new Map();
+	for (const meshMeta of group.meshes) {
+		const layer = meshMeta.layer ?? "";
+		let bucket = byLayer.get(layer);
+		if (!bucket) {
+			bucket = [];
+			byLayer.set(layer, bucket);
+		}
+		bucket.push(meshMeta);
+	}
+	return [...byLayer.values()].map((meshes) => ({
+		materialId: group.materialId,
+		meshes
+	}));
+}
+/**
+* The groups a merge-by-material draws: every group of one material gathered into one, in order of
+* first appearance, then split by layer. The writer keeps meshes in input order, so one material
+* can head several groups.
+*/
+function mergeGroupsOf(groups) {
+	const byMaterial = /* @__PURE__ */ new Map();
+	for (const group of groups) {
+		const meshes = byMaterial.get(group.materialId);
+		if (meshes) for (const mesh of group.meshes) meshes.push(mesh);
+		else byMaterial.set(group.materialId, group.meshes.slice());
+	}
+	return [...byMaterial].flatMap(([materialId, meshes]) => splitGroupByLayer({
+		materialId,
+		meshes
+	}));
+}
+/**
+* Merges a material group's meshes into one BufferGeometry. Parser indices already address the
+* combined vertex array (rebased by the C# pipeline during batch assembly), so this copies each
+* mesh's vertex/index slices into a fresh contiguous buffer and shifts indices to match.
+*/
+function createMergedMesh(group, allVertices, allIndices, pickMaterial, allUvs = null, allColors = null) {
+	let totalVertexCount = 0;
+	let totalIndexCount = 0;
+	for (const meshMeta of group.meshes) {
+		totalVertexCount += meshMeta.vertexCount;
+		totalIndexCount += meshMeta.indexCount;
+	}
+	const mergedVertices = new Float32Array(totalVertexCount * 3);
+	const mergedIndices = new Uint32Array(totalIndexCount);
+	const mergedUvs = allUvs ? new Float32Array(totalVertexCount * 2) : null;
+	const mergedColors = allColors ? new Uint8Array(totalVertexCount * 3) : null;
+	let vertexWriteCursor = 0;
+	let indexWriteCursor = 0;
+	for (const meshMeta of group.meshes) {
+		const componentStart = meshMeta.vertexStart * 3;
+		const componentLen = meshMeta.vertexCount * 3;
+		mergedVertices.set(allVertices.subarray(componentStart, componentStart + componentLen), vertexWriteCursor * 3);
+		if (mergedUvs && allUvs) {
+			const uvStart = meshMeta.vertexStart * 2;
+			mergedUvs.set(allUvs.subarray(uvStart, uvStart + meshMeta.vertexCount * 2), vertexWriteCursor * 2);
+		}
+		if (mergedColors && allColors) mergedColors.set(allColors.subarray(componentStart, componentStart + componentLen), vertexWriteCursor * 3);
+		const indicesSlice = allIndices.subarray(meshMeta.indexStart, meshMeta.indexStart + meshMeta.indexCount);
+		const indexShift = vertexWriteCursor - meshMeta.vertexStart;
+		const windowStart = meshMeta.vertexStart;
+		const windowEnd = meshMeta.vertexStart + meshMeta.vertexCount;
+		for (let i = 0; i < indicesSlice.length; i++) {
+			const indexValue = indicesSlice[i];
+			if (indexValue < windowStart || indexValue >= windowEnd) throw indexOutOfWindow(indexValue, meshMeta);
+			mergedIndices[indexWriteCursor + i] = indexValue + indexShift;
+		}
+		vertexWriteCursor += meshMeta.vertexCount;
+		indexWriteCursor += meshMeta.indexCount;
+	}
+	const finished = finishGeometry({
+		positions: mergedVertices,
+		indices: mergedIndices,
+		uvs: mergedUvs,
+		colors: mergedColors
+	}, group.meshes);
+	return finalizeMergedMesh(geometryFrom(finished), group, pickMaterial(group.materialId, finished.closed));
+}
+function geometryFrom(finished) {
+	const geometry = new three.BufferGeometry();
+	geometry.setAttribute("position", new three.BufferAttribute(finished.positions, 3));
+	geometry.setAttribute("normal", new three.BufferAttribute(finished.normals, 3));
+	geometry.setIndex(new three.BufferAttribute(finished.indices, 1));
+	if (finished.uvs) geometry.setAttribute("uv", new three.BufferAttribute(finished.uvs, 2));
+	if (finished.tangents) geometry.setAttribute("tangent", new three.BufferAttribute(finished.tangents, 4));
+	if (finished.colors) geometry.setAttribute("color", new three.BufferAttribute(finished.colors, 3, true));
+	return geometry;
+}
+/**
+* Per-member records for a merged mesh, each carrying its window into the merged index buffer.
+* The windows are a prefix sum over `indexCount` because the merge concatenates members in this
+* order — see the copy loop in {@link createMergedMesh}.
+*/
+function mergedMembers(group) {
+	const members = [];
+	let indexStart = 0;
+	for (const mesh of group.meshes) {
+		members.push({
+			trackingKey: mesh.id,
+			name: mesh.name,
+			layer: mesh.layer,
+			metadata: mesh.metadata ?? {},
+			indexStart,
+			indexCount: mesh.indexCount
+		});
+		indexStart += mesh.indexCount;
+	}
+	return members;
+}
+function finalizeMergedMesh(geometry, group, material) {
+	const threeMesh = new three.Mesh(geometry, material);
+	const firstMesh = group.meshes[0];
+	const meshNames = group.meshes.map((m) => m.name).filter((name) => name && name.length > 0);
+	threeMesh.name = meshNames.length > 0 ? meshNames[0] : `merged_material_${group.materialId}`;
+	threeMesh.castShadow = true;
+	threeMesh.receiveShadow = true;
+	threeMesh.userData = {
+		source: "compute",
+		name: threeMesh.name,
+		layer: firstMesh?.layer ?? "",
+		metadata: firstMesh?.metadata ?? {},
+		members: mergedMembers(group)
+	};
+	return threeMesh;
+}
+/**
+* Creates individual meshes from a material group. Each mesh's indices are rebased so they
+* address its own local vertex slice starting from 0.
+*/
+function createIndividualMeshes(group, allVertices, allIndices, pickMaterial, allUvs = null, allColors = null) {
+	const meshes = [];
+	for (const meshMeta of group.meshes) {
+		const componentStart = meshMeta.vertexStart * 3;
+		const componentLen = meshMeta.vertexCount * 3;
+		const vertices = allVertices.slice(componentStart, componentStart + componentLen);
+		const indicesSlice = allIndices.subarray(meshMeta.indexStart, meshMeta.indexStart + meshMeta.indexCount);
+		const rebasedIndices = new Uint32Array(indicesSlice.length);
+		const baseIndex = meshMeta.vertexStart;
+		const windowEnd = meshMeta.vertexStart + meshMeta.vertexCount;
+		for (let i = 0; i < indicesSlice.length; i++) {
+			const indexValue = indicesSlice[i];
+			if (indexValue < baseIndex || indexValue >= windowEnd) throw indexOutOfWindow(indexValue, meshMeta);
+			rebasedIndices[i] = indexValue - baseIndex;
+		}
+		const uvStart = meshMeta.vertexStart * 2;
+		const finished = finishGeometry({
+			positions: vertices,
+			indices: rebasedIndices,
+			uvs: allUvs ? allUvs.slice(uvStart, uvStart + meshMeta.vertexCount * 2) : null,
+			colors: allColors ? allColors.slice(componentStart, componentStart + componentLen) : null
+		}, [meshMeta]);
+		meshes.push(finalizeSingleMesh(geometryFrom(finished), meshMeta, pickMaterial(group.materialId, finished.closed)));
+	}
+	return meshes;
+}
+function finalizeSingleMesh(geometry, meshMeta, material) {
+	const mesh = new three.Mesh(geometry, material);
+	mesh.name = meshMeta.name;
+	mesh.userData = {
+		source: "compute",
+		name: meshMeta.name,
+		layer: meshMeta.layer ?? "",
+		trackingKey: meshMeta.id,
+		metadata: meshMeta.metadata ?? {}
+	};
+	mesh.castShadow = true;
+	mesh.receiveShadow = true;
+	return mesh;
+}
+// src/parse/webdisplay/batch/finished-cache.ts
+const MAX_BYTES = 268435456;
+const entries = /* @__PURE__ */ new Map();
+let totalBytes = 0;
+function getFinishedBatch(geometryBytes, jobs) {
+	const jobShape = shapeOf(jobs);
+	const key = cacheKey(geometryBytes, jobShape);
+	const entry = entries.get(key);
+	if (!entry || !sameInts(entry.jobShape, jobShape) || !sameBytes(entry.geometryBytes, geometryBytes)) return null;
+	entries.delete(key);
+	entries.set(key, entry);
+	return entry;
+}
+/** Wraps each finished geometry in a `BufferGeometry`, owned by the scene. */
+function buildBatch(batch) {
+	const { geometries, ...rest } = batch;
+	return {
+		...rest,
+		buffers: geometries.map(geometryFrom),
+		closed: geometries.map((g) => g.closed)
+	};
+}
+/** Same as {@link buildBatch}, but the cache keeps the geometries for the next identical payload. */
+function storeFinishedBatch(geometryBytes, jobs, batch) {
+	const built = buildBatch(batch);
+	let bytes = geometryBytes.byteLength;
+	for (const g of batch.geometries) {
+		bytes += g.positions.byteLength + g.normals.byteLength + g.indices.byteLength;
+		bytes += (g.uvs?.byteLength ?? 0) + (g.colors?.byteLength ?? 0) + (g.tangents?.byteLength ?? 0);
+	}
+	if (bytes > MAX_BYTES) return built;
+	const jobShape = shapeOf(jobs);
+	const key = cacheKey(geometryBytes, jobShape);
+	const existing = entries.get(key);
+	if (existing) {
+		entries.delete(key);
+		release(existing);
+	}
+	built.buffers.forEach(require_gpu_ownership.shareGeometry);
+	entries.set(key, {
+		...built,
+		geometryBytes: geometryBytes.slice(),
+		jobShape,
+		bytes
+	});
+	totalBytes += bytes;
+	for (const [oldest, entry] of entries) {
+		if (totalBytes <= MAX_BYTES) break;
+		entries.delete(oldest);
+		release(entry);
+	}
+	return built;
+}
+/**
+* Empties the cache and frees its geometries. The cache lives as long as the page, so a host calls
+* this when its viewer goes away; a mesh still drawing one of them uploads it again.
+*/
+function clearGeometryCache() {
+	entries.forEach(release);
+	entries.clear();
+}
+function release(entry) {
+	totalBytes -= entry.bytes;
+	for (const buffer of entry.buffers) {
+		require_gpu_ownership.unshareGeometry(buffer);
+		buffer.dispose();
+	}
+}
+function shapeOf(jobs) {
+	let length = 0;
+	for (const job of jobs) length += 2 + 4 * job.windows.length;
+	const shape = new Int32Array(length);
+	let i = 0;
+	for (const job of jobs) {
+		shape[i++] = job.kind === "merged" ? 1 : 0;
+		shape[i++] = job.windows.length;
+		for (const w of job.windows) {
+			shape[i++] = w.vertexStart;
+			shape[i++] = w.vertexCount;
+			shape[i++] = w.indexStart;
+			shape[i++] = w.indexCount;
+		}
+	}
+	return shape;
+}
+function cacheKey(geometryBytes, jobShape) {
+	const length = geometryBytes.length;
+	const stride = Math.max(1, Math.floor(length / 1024));
+	let hash = 2166136261;
+	for (let i = 0; i < length; i += stride) hash = Math.imul(hash ^ geometryBytes[i], 16777619);
+	let shapeHash = 2166136261;
+	for (let i = 0; i < jobShape.length; i++) shapeHash = Math.imul(shapeHash ^ jobShape[i], 16777619);
+	return `${length}:${hash >>> 0}:${jobShape.length}:${shapeHash >>> 0}`;
+}
+function sameInts(a, b) {
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+	return true;
+}
+function sameBytes(a, b) {
+	if (a.length !== b.length) return false;
+	let i = 0;
+	if (a.byteOffset % 4 === 0 && b.byteOffset % 4 === 0) {
+		const words = a.length >>> 2;
+		const wa = new Uint32Array(a.buffer, a.byteOffset, words);
+		const wb = new Uint32Array(b.buffer, b.byteOffset, words);
+		for (; i < words; i++) if (wa[i] !== wb[i]) return false;
+		i = words << 2;
+	}
+	for (; i < a.length; i++) if (a[i] !== b[i]) return false;
+	return true;
+}
+// src/parse/webdisplay/batch-parser.ts
+/**
+* Parses a DisplayBatch object and creates Three.js meshes from its mesh blob.
+*
+* Synchronous internally — `parseBinaryMeshBatch` does no IO, just typed-array views over the
+* blob. Stays `async` so callers don't need to change shape if parsing moves into a worker later.
+*
+* @throws {VisualizationError} On a corrupt/truncated/unsupported mesh blob or malformed group metadata.
+*/
+async function parseMeshBatchObject(batch, options, telemetry) {
+	const { mergeByMaterial = true, debug = false, material } = options ?? {};
+	const { parseTime = 0, perfStart = debug ? performance.now() : 0 } = telemetry ?? {};
+	if (!batch.compressedData) return [];
+	const decodeStart = performance.now();
+	const assemblyOptions = {
+		mergeByMaterial,
+		debug,
+		material,
+		fallback: {
+			materials: batch.materials,
+			groups: batch.groups
+		}
+	};
+	const opened = await openBatch(batch.compressedData, assemblyOptions);
+	if (opened.meshes) return opened.meshes;
+	const assembledMeshes = await tryBuildViaAssembly(opened, assemblyOptions);
+	if (assembledMeshes) return assembledMeshes;
+	return buildMeshesFromParsed(decodeRawMeshBatch(opened.raw), {
+		mergeByMaterial,
+		debug,
+		material,
+		parseTime,
+		decodeTime: performance.now() - decodeStart,
+		perfStart,
+		blobBytes: debug ? approximateBase64DecodedBytes(batch.compressedData) : 0,
+		fallback: {
+			materials: batch.materials,
+			groups: batch.groups
+		}
+	});
+}
+/**
+* Parses a raw binary mesh batch blob (SLVA wire format) and creates Three.js meshes.
+*
+* Use this entry point when the blob arrives as a binary WebSocket frame rather than inside a JSON
+* envelope — the blob is self-describing, with materials, groups, and per-object ids coming
+* from the container's table.
+*
+* @throws {VisualizationError} On a corrupt/truncated/unsupported mesh blob or malformed group metadata.
+*/
+async function parseMeshBatchBlob(blob, options) {
+	const { mergeByMaterial = true, debug = false, material } = options ?? {};
+	const perfStart = debug ? performance.now() : 0;
+	const decodeStart = performance.now();
+	const assemblyOptions = {
+		mergeByMaterial,
+		debug,
+		material
+	};
+	const opened = await openBatch(blob, assemblyOptions);
+	if (opened.meshes) return opened.meshes;
+	const assembledMeshes = await tryBuildViaAssembly(opened, assemblyOptions);
+	if (assembledMeshes) return assembledMeshes;
+	const parsed = decodeRawMeshBatch(opened.raw);
+	const decodeTime = performance.now() - decodeStart;
+	const blobBytes = blob.byteLength;
+	return buildMeshesFromParsed(parsed, {
+		mergeByMaterial,
+		debug,
+		material,
+		parseTime: 0,
+		decodeTime,
+		perfStart,
+		blobBytes
+	});
+}
+const UNMERGED_MESH_WARN_THRESHOLD = 1e3;
+let warnedUnmerged = false;
+/**
+* Warns once when a caller opts out of merging on a batch large enough for it to hurt.
+*
+* Opting out is legitimate — it is what gives every source object its own THREE object — so this
+* does not override the caller. It exists because the failure is silent: nothing errors, the model
+* renders correctly, and the only symptom is a frame rate nobody traces back to a parse option.
+*/
+function warnIfUnmergedAtScale(mergeByMaterial, groups) {
+	if (mergeByMaterial || warnedUnmerged) return;
+	let meshCount = 0;
+	for (const group of groups) meshCount += group.meshes.length;
+	if (meshCount < UNMERGED_MESH_WARN_THRESHOLD) return;
+	warnedUnmerged = true;
+	require_gpu_dispose.getLogger().warn(`Parsing ${meshCount} meshes with mergeByMaterial: false — each becomes its own THREE object, and render cost scales with object count. Drop the option to merge by material (the default); per-object identity survives it via userData.members.`);
+}
+function buildMeshesFromParsed(parsed, opts) {
+	const { mergeByMaterial, debug, material: materialAppearance, parseTime, decodeTime, perfStart, blobBytes, fallback } = opts;
+	const materialsSrc = parsed.metadata.materials ?? fallback?.materials ?? [];
+	const groups = parsed.metadata.groups ?? fallback?.groups ?? [];
+	const isFloat32 = (parsed.flags & 1) !== 0;
+	validateGroupMetadata(groups, materialsSrc.length, parsed.vertices.length / 3, parsed.indices.length);
+	const worldVertices = isFloat32 ? parsed.vertices : dequantizeInt16(parsed.vertices, parsed.origin, parsed.scale);
+	if (debug) {
+		const wireBytes = parsed.vertices.byteLength + parsed.indices.byteLength;
+		require_gpu_dispose.getLogger().debug("Mesh Batch Stats:");
+		require_gpu_dispose.getLogger().debug(`  Materials: ${materialsSrc.length} | Groups: ${groups.length}`);
+		require_gpu_dispose.getLogger().debug(`  Vertices: ${parsed.vertices.length / 3} | Indices: ${parsed.indices.length}`);
+		require_gpu_dispose.getLogger().debug(`  Format: ${isFloat32 ? "float32" : "int16 quantized"}`);
+		require_gpu_dispose.getLogger().debug(`  Blob: ${(blobBytes / 1024 / 1024).toFixed(2)} MB | Geometry on wire: ${(wireBytes / 1024 / 1024).toFixed(2)} MB`);
+	}
+	warnIfUnmergedAtScale(mergeByMaterial, groups);
+	const meshCreateStart = performance.now();
+	const pickMaterial = createMaterialPicker(materialsSrc, {
+		vertexColors: parsed.colors != null,
+		hasUvs: parsed.uvs != null,
+		appearance: materialAppearance
+	});
+	const meshes = [];
+	const mergeGroups = mergeByMaterial ? mergeGroupsOf(groups) : groups;
+	for (const group of mergeGroups) if (mergeByMaterial && group.meshes.length > 1) {
+		const mergedMesh = createMergedMesh(group, worldVertices, parsed.indices, pickMaterial, parsed.uvs, parsed.colors);
+		meshes.push(mergedMesh);
+	} else {
+		const individualMeshes = createIndividualMeshes(group, worldVertices, parsed.indices, pickMaterial, parsed.uvs, parsed.colors);
+		for (const mesh of individualMeshes) meshes.push(mesh);
+	}
+	const meshCreateTime = performance.now() - meshCreateStart;
+	if (debug) {
+		const totalTime = performance.now() - perfStart;
+		require_gpu_dispose.getLogger().debug("Performance:");
+		if (parseTime > 0) require_gpu_dispose.getLogger().debug(`  Parse JSON: ${parseTime.toFixed(2)}ms`);
+		require_gpu_dispose.getLogger().debug(`  Decode binary: ${decodeTime.toFixed(2)}ms`);
+		require_gpu_dispose.getLogger().debug(`  Create Meshes: ${meshCreateTime.toFixed(2)}ms`);
+		require_gpu_dispose.getLogger().debug(`  Total: ${totalTime.toFixed(2)}ms`);
+	}
+	return Promise.resolve(meshes);
+}
+/**
+* Unwraps an SLVM container only as far as its table and materials, and answers from the
+* finished-geometry cache before paying for the inflate. A bare SLVA/SLVZ blob (old `.gh` files)
+* keeps its metadata inside the compressed geometry, so it always decodes.
+*/
+async function openBatch(input, opts) {
+	const bytes = toUint8Array(input);
+	if (!isSlvmContainer(bytes)) return {
+		raw: parseBinaryMeshBatchRaw(bytes),
+		geometryBytes: null,
+		source: bytes,
+		reparse: () => parseBinaryMeshBatchRaw(bytes)
+	};
+	const container = parseSlvmContainer(bytes);
+	const cached = buildFromFinishedCache(container, opts);
+	if (cached) return { meshes: cached };
+	const geometryBlob = container.geometryBlob;
+	const reparse = () => {
+		const raw = parseBinaryMeshBatchRaw(geometryBlob);
+		raw.metadata = container.metadata;
+		return raw;
+	};
+	const inflated = await inflateInWorker(container);
+	const raw = inflated ? parseBinaryMeshBatchRaw(inflated) : reparse();
+	raw.metadata = container.metadata;
+	return {
+		raw,
+		geometryBytes: geometryBlob,
+		source: geometryBlob,
+		reparse
+	};
+}
+const INFLATE_IN_WORKER_MIN_BYTES = 4194304;
+/**
+* Inflates a large SLVZ geometry chunk off the calling thread. Null means inflate it here: a small
+* or uncompressed chunk, no worker support, or a worker that failed.
+*/
+async function inflateInWorker(container) {
+	if (slvzInflatedBytes(container.geometryBlob) < INFLATE_IN_WORKER_MIN_BYTES || !getAssemblyWorker()) return null;
+	try {
+		return await inflateSlvzAsync(container.geometryBlob);
+	} catch {
+		return null;
+	}
+}
+function buildFromFinishedCache(container, opts) {
+	const materialsSrc = container.metadata.materials ?? opts.fallback?.materials ?? [];
+	const groups = container.metadata.groups ?? opts.fallback?.groups ?? [];
+	const { jobs, jobRefs } = planJobs(groups, opts.mergeByMaterial);
+	const cached = getFinishedBatch(container.geometryBlob, jobs);
+	if (!cached) return null;
+	validateGroupMetadata(groups, materialsSrc.length, cached.vertexCount, cached.indexCount);
+	return meshesFromBuilt(cached, jobRefs, materialsSrc, opts.material);
+}
+/** One job per merged group or per unmerged mesh, with a parallel ref list to unwrap results by index. */
+function planJobs(groups, mergeByMaterial) {
+	const windowOf = (m) => ({
+		vertexStart: m.vertexStart,
+		vertexCount: m.vertexCount,
+		indexStart: m.indexStart,
+		indexCount: m.indexCount,
+		closed: m.closed
+	});
+	const jobs = [];
+	const jobRefs = [];
+	const mergeGroups = mergeByMaterial ? mergeGroupsOf(groups) : groups;
+	for (const group of mergeGroups) if (mergeByMaterial && group.meshes.length > 1) {
+		jobs.push({
+			kind: "merged",
+			windows: group.meshes.map(windowOf)
+		});
+		jobRefs.push({
+			kind: "merged",
+			group
+		});
+	} else for (const meshMeta of group.meshes) {
+		jobs.push({
+			kind: "single",
+			windows: [windowOf(meshMeta)]
+		});
+		jobRefs.push({
+			kind: "single",
+			group,
+			meshMeta
+		});
+	}
+	return {
+		jobs,
+		jobRefs
+	};
+}
+/**
+* Builds a heavy batch through the assembly functions, in the worker when there is one and inline
+* otherwise, and caches the result under `geometryBytes`. Returns `null` for a small batch or a
+* crashed worker, and the caller then runs the synchronous path. Malformed-blob/metadata errors
+* throw either way, matching the entry points' contract.
+*/
+async function tryBuildViaAssembly(opened, opts) {
+	const { raw, geometryBytes } = opened;
+	const indexCount = raw.planarByteSplit ? raw.indexData.length / (raw.uint16Indices ? 2 : 4) : raw.indexData.length;
+	if (indexCount / 3 < 5e4) return null;
+	const materialsSrc = raw.metadata.materials ?? opts.fallback?.materials ?? [];
+	const groups = raw.metadata.groups ?? opts.fallback?.groups ?? [];
+	validateGroupMetadata(groups, materialsSrc.length, raw.vertexCount, indexCount);
+	const { jobs, jobRefs } = planJobs(groups, opts.mergeByMaterial);
+	const assembled = await assemble(raw, jobs, opened.source);
+	if (!assembled) {
+		if (ownsBuffer(raw, opened.source)) opened.raw = opened.reparse();
+		return null;
+	}
+	const batch = {
+		geometries: assembled,
+		hasUvs: raw.uvs != null,
+		hasColors: raw.colors != null,
+		vertexCount: raw.vertexCount,
+		indexCount
+	};
+	const built = geometryBytes ? storeFinishedBatch(geometryBytes, jobs, batch) : buildBatch(batch);
+	if (opts.debug) require_gpu_dispose.getLogger().debug(`Mesh batch assembled: ${assembled.length} geometries, ${indexCount / 3} triangles`);
+	return meshesFromBuilt(built, jobRefs, materialsSrc, opts.material);
+}
+/**
+* True when `raw`'s geometry arrays live in a buffer nobody else reads: the buffer a SLVZ chunk
+* was inflated into, not the WebSocket frame an uncompressed chunk still points into.
+*/
+function ownsBuffer(raw, source) {
+	return raw.vertexData.buffer !== source.buffer && raw.indexData.buffer !== source.buffer;
+}
+async function assemble(raw, jobs, source) {
+	const worker = getAssemblyWorker();
+	const input = {
+		vertexData: raw.vertexData,
+		isFloat32: raw.isFloat32,
+		deltaEncoded: raw.deltaEncoded,
+		planarByteSplit: raw.planarByteSplit,
+		uint16Indices: raw.uint16Indices,
+		origin: raw.origin,
+		scale: raw.scale,
+		indexData: raw.indexData,
+		uvs: raw.uvs,
+		colors: raw.colors,
+		jobs
+	};
+	if (!worker) return assembleGeometries(input).map((geometry, i) => finishGeometry(geometry, jobs[i].windows));
+	if (!ownsBuffer(raw, source)) {
+		input.vertexData = raw.vertexData.slice();
+		input.indexData = raw.indexData.slice();
+		input.uvs = raw.uvs?.slice() ?? null;
+		input.colors = raw.colors?.slice() ?? null;
+	}
+	const transfer = /* @__PURE__ */ new Set([input.vertexData.buffer, input.indexData.buffer]);
+	if (input.uvs) transfer.add(input.uvs.buffer);
+	if (input.colors) transfer.add(input.colors.buffer);
+	try {
+		const assembled = await requestAssembly(worker, input, [...transfer]);
+		return assembled.length === jobs.length ? assembled : null;
+	} catch (error) {
+		require_gpu_dispose.getLogger().warn("Mesh assembly worker failed; falling back to main-thread parse.", error);
+		return null;
+	}
+}
+function meshesFromBuilt(built, jobRefs, materialsSrc, appearance) {
+	const pickMaterial = createMaterialPicker(materialsSrc, {
+		vertexColors: built.hasColors,
+		hasUvs: built.hasUvs,
+		appearance
+	});
+	const meshes = [];
+	for (let i = 0; i < built.buffers.length; i++) {
+		const geometry = built.buffers[i];
+		const ref = jobRefs[i];
+		const material = pickMaterial(ref.group.materialId, built.closed[i]);
+		const mesh = ref.kind === "merged" ? finalizeMergedMesh(geometry, ref.group, material) : finalizeSingleMesh(geometry, ref.meshMeta, material);
+		meshes.push(mesh);
+	}
+	return meshes;
+}
+function approximateBase64DecodedBytes(base64) {
+	return Math.floor(base64.length * 3 / 4);
+}
+// src/parse/webdisplay/webdisplay-parser.ts
+/**
+* Metres per model unit, keyed by Rhino `UnitSystem` name (the `modelunits` string on the compute
+* response). Imperial factors are the exact international definitions. Units missing from this
+* table scale by 1 and log a one-time warning — see {@link getScaleFactor}.
+*/
+const SCALE_FACTORS = {
+	Angstroms: 1e-10,
+	Nanometers: 1e-9,
+	Microns: 1e-6,
+	Millimeters: .001,
+	Centimeters: .01,
+	Decimeters: .1,
+	Meters: 1,
+	Dekameters: 10,
+	Hectometers: 100,
+	Kilometers: 1e3,
+	Megameters: 1e6,
+	Gigameters: 1e9,
+	Microinches: 2.54e-8,
+	Mils: 254e-7,
+	Inches: .0254,
+	Feet: .3048,
+	Yards: .9144,
+	Miles: 1609.344,
+	NauticalMiles: 1852
+};
+const DISPLAY_COMPONENT_TYPE = "Display";
+const DISPLAY_BATCH_TYPE = "DisplayBatch";
+/**
+* True when a wire `type` denotes a Display payload: one of its dot-separated tokens is exactly
+* `Display` or `DisplayBatch`. Matches the bare `Display` used by older servers and the namespaced
+* `Selva.GH.Features.Display.Services.DisplayBatch`, but not e.g. `System.DisplayText` — matching
+* on tokens rather than substring avoids misrouting an unrelated type that merely contains "Display".
+*/
+function isDisplayItemType(type) {
+	const tokens = type.split(".");
+	return tokens.includes(DISPLAY_COMPONENT_TYPE) || tokens.includes(DISPLAY_BATCH_TYPE);
+}
+/** Unknown-unit names already warned about, so a per-solve parse doesn't spam the log. */
+const warnedUnknownUnits = /* @__PURE__ */ new Set();
+/**
+* Extracts display meshes and items from a Grasshopper WebDisplay compute response: decompresses,
+* scales to meters, and optionally grounds them. Requires the VektorNode Rhino.Compute fork.
+*
+* Synchronous internally (large batches block the UI for their duration); `async` only so the
+* shape can stay stable if parsing moves off-thread later.
+*
+* @throws Rethrows unexpected errors after attempting to dispose any created meshes.
+*/
+async function getThreeObjectsFromComputeResponse(data, options) {
+	const startTime = performance.now();
+	const objects = [];
+	const { allowScaling = true, allowAutoPosition = false, groundAxis = "z", debug = false, parsing: parsingOptions = {} } = options ?? {};
+	try {
+		await extractDisplayFromData(data, objects, allowScaling ? getScaleFactor(data.modelunits) : 1, parsingOptions, debug);
+		if (allowAutoPosition) applyGroundOffset(objects, groundAxis);
+		return objects;
+	} catch (error) {
+		handleError(error, objects);
+		throw error;
+	} finally {
+		if (debug) logProcessingTime(startTime);
+	}
+}
+/**
+* Gets the metres-per-unit scale factor for a Rhino unit name. Unknown units fall back to 1 (no
+* scaling) with a one-time warning — a kilometers model rendering 1000x off should at least say why.
+*/
+function getScaleFactor(modelUnits) {
+	const factor = SCALE_FACTORS[modelUnits];
+	if (factor !== void 0) return factor;
+	if (!warnedUnknownUnits.has(modelUnits)) {
+		warnedUnknownUnits.add(modelUnits);
+		require_gpu_dispose.getLogger().warn(`Unknown Rhino model unit "${modelUnits}" — geometry will not be scaled (factor 1). Known units: ${Object.keys(SCALE_FACTORS).join(", ")}.`);
+	}
+	return 1;
+}
+async function extractDisplayFromData(data, objects, scaleFactor, parsingOptions, debug) {
+	for (const value of data.values) {
+		const innerTree = value.InnerTree;
+		for (const path in innerTree) {
+			const branch = innerTree[path];
+			if (!branch) continue;
+			await processDataBranch(branch, objects, scaleFactor, parsingOptions, debug);
+		}
+	}
+}
+/** Extracts a DisplayBatch's meshes (binary blob) and items (curves/points JSON) from one data branch. */
+async function processDataBranch(branch, objects, scaleFactor, parsingOptions, debug) {
+	for (const item of branch) {
+		if (!isDisplayItemType(item.type)) continue;
+		const mergedParsingOptions = {
+			debug: false,
+			...parsingOptions,
+			mergeByMaterial: parsingOptions.mergeByMaterial ?? true
+		};
+		const batch = extractBatch(item.data);
+		if (!batch) {
+			require_gpu_dispose.getLogger().error("Error parsing display batch envelope: invalid JSON");
+			continue;
+		}
+		const batchMeshes = await parseMeshBatchObject(batch, mergedParsingOptions);
+		const batchItems = parseDisplayItems(batch.items);
+		const batchObjects = [...batchMeshes, ...batchItems];
+		if (scaleFactor !== 1) for (const obj of batchObjects) obj.scale.set(scaleFactor, scaleFactor, scaleFactor);
+		for (const object of batchObjects) objects.push(object);
+		if (debug) require_gpu_dispose.getLogger().debug(`Extracted ${batchMeshes.length} meshes and ${batchItems.length} items from batch`);
+	}
+}
+/** Resolves `item.data` to a parsed DisplayBatch, tolerating either an already-parsed object or a JSON string. */
+function extractBatch(data) {
+	return typeof data === "string" ? safeParse(data) : data;
+}
+function safeParse(s) {
+	try {
+		return JSON.parse(s);
+	} catch {
+		return;
+	}
+}
+/**
+* Drops objects so their lowest point sits on the ground plane. `axis` isn't hardcoded to `z`
+* because subtracting `min.z` on a host with a non-default `sceneUp` would shove content sideways
+* instead of down.
+*/
+function applyGroundOffset(meshes, axis) {
+	if (meshes.length === 0) return;
+	const combinedBoundingBox = require_gpu_dispose.computeCombinedBoundingBox(meshes);
+	require_gpu_dispose.applyOffset(meshes, combinedBoundingBox.min[axis], axis);
+}
+function handleError(error, meshes) {
+	require_gpu_dispose.getLogger().error("An unexpected error occurred:", error);
+	disposeMeshes(meshes);
+}
+function disposeMeshes(meshes) {
+	for (const mesh of meshes) require_gpu_dispose.disposeObjectTree(mesh);
+}
+function logProcessingTime(startTime) {
+	const elapsed = performance.now() - startTime;
+	require_gpu_dispose.getLogger().info("Time to process meshes:", `${elapsed.toFixed(2)}ms`);
+}
+exports.SCALE_FACTORS = SCALE_FACTORS;
+exports.clearGeometryCache = clearGeometryCache;
+exports.getThreeObjectsFromComputeResponse = getThreeObjectsFromComputeResponse;
+exports.meshPolicy = meshPolicy;
+exports.parseDisplayItems = parseDisplayItems;
+exports.parseMeshBatchBlob = parseMeshBatchBlob;
+exports.parseMeshBatchObject = parseMeshBatchObject;
+exports.setTextureAnisotropy = setTextureAnisotropy;
+
 //# sourceMappingURL=parse.cjs.map