@selvajs/compute 5.0.0-beta.8 → 5.0.0-beta.9

package/dist/grasshopper.js

@@ -1,2 +1,3052 @@
-import{C as e,D as t,O as n,S as r,T as i,_ as a,c as o,d as s,f as c,h as l,i as u,l as d,m as f,p,s as m,t as ee,u as te,v as ne,x as h,y as re}from"./core-BPYXUtfq.js";var g=class e{serverUrl;headers;disposed=!1;activeMonitors=/* @__PURE__ */ new Set;static DEFAULT_TIMEOUT_MS=5e3;static LIFECYCLE_TIMEOUT_MS=6e4;static MIN_MONITOR_INTERVAL_MS=100;static MAX_BODY_BYTES=1<<20;constructor(e,t){this.serverUrl=h(e),this.headers={...re(typeof t==`string`?{apiKey:t}:t??{}),"Content-Type":`application/json`}}fetchWithTimeout(t,n={},r=e.DEFAULT_TIMEOUT_MS){let i={...n,headers:this.headers,redirect:`manual`};return r>0&&!i.signal&&(i.signal=AbortSignal.timeout(r)),fetch(t,i)}async getText(t,n={},r=e.DEFAULT_TIMEOUT_MS){this.ensureNotDisposed();let a=`${n.method??`GET`} ${t}`;try{let o=await this.fetchWithTimeout(`${this.serverUrl}${t}`,n,r);if(!o.ok)return i().warn(`[ComputeServerStats] ${a} failed:`,o.status),await o.body?.cancel().catch(()=>{}),null;let{text:s,truncated:c}=await f(o,e.MAX_BODY_BYTES);return c?(i().warn(`[ComputeServerStats] ${a} answered with an oversized body`),null):s}catch(e){return i().warn(`[ComputeServerStats] ${a} errored:`,e),null}}async isServerOnline(t=e.DEFAULT_TIMEOUT_MS){return(await this.probeServer(t)).online}async probeServer(t=e.DEFAULT_TIMEOUT_MS){this.ensureNotDisposed();let n=`${this.serverUrl}/`;try{let e=await this.fetchWithTimeout(n,{method:`GET`},t);return await e.body?.cancel().catch(()=>{}),{online:e.ok||s(e),status:e.status}}catch(e){return i().debug(`[ComputeServerStats] Fetch error:`,e),{online:!1,error:e instanceof Error?`${e.name}: ${e.message}`:String(e)}}}async getActiveChildren(t={}){let{initialize:n=!0}=t,r=n?await this.getText(`/activechildren`,{},e.LIFECYCLE_TIMEOUT_MS):await this.getText(`/activechildren?initialize=false`);if(r===null)return null;let a=r.trim();return/^\d+$/.test(a)?parseInt(a,10):(i().warn(`[ComputeServerStats] /activechildren answered with a non-numeric body`),null)}async getVersion(){let e=await this.getText(`/version`);if(e===null)return null;let t=_(e);return t==null?{rhino:e,compute:``,git_sha:null}:{rhino:t.rhino??``,compute:t.compute??``,git_sha:t.git_sha??null}}async getInstalledPlugins(e=`gh`){let t=await this.getText(`/plugins/${e}/installed`),n=t===null?void 0:_(t);return n&&typeof n==`object`?n:null}async getServerStats(){if(this.ensureNotDisposed(),!await this.isServerOnline())return{isOnline:!1};let[e,t]=await Promise.all([this.getVersion(),this.getActiveChildren({initialize:!1})]);return{isOnline:!0,...e&&{version:e},...t!==null&&{activeChildren:t}}}async purgeCache(){let e=await this.getText(`/cache/purge`,{method:`POST`}),t=(e===null?void 0:_(e))?.purged;return typeof t==`number`?t:null}async purgeAllChildren(){this.ensureNotDisposed();let e=await this.getActiveChildren({initialize:!1});if(e===null)return i().warn(`[ComputeServerStats] purgeAllChildren: could not read child count`),null;if(e===0)return{totalPurged:0,calls:0,children:0,confident:!0};let t=e*2,n=0;for(let e=0;e<t;e++){let e=await this.purgeCache();e!==null&&(n+=e)}return{totalPurged:n,calls:t,children:e,confident:e===1}}async getServerTime(){let e=await this.getText(`/servertime`);if(e===null)return null;let t=new Date(e.trim().replace(/^"|"$/g,``));return isNaN(t.getTime())?null:t}async getIdleSpan(){let e=await this.getText(`/idlespan`);if(e===null)return null;let t=parseFloat(e.trim());return isNaN(t)?null:t}async launchChildren(){return this.postJson(`/launch-children`)}async launchChild(e){let t=e===void 0?`/launch-child`:`/launch-child?port=${e}`;return this.postJson(t)}async shutdownChildren(e){let t=e===void 0?`/shutdown-children`:`/shutdown-children?port=${e}`;return this.postJson(t)}async recycleChildren(e){let t=e===void 0?`/recycle-children`:`/recycle-children?port=${e}`;return this.postJson(t)}async postJson(t){let n=await this.getText(t,{method:`POST`},e.LIFECYCLE_TIMEOUT_MS);return n===null?null:_(n)??null}monitor(r,a=5e3){if(this.ensureNotDisposed(),!Number.isFinite(a)||a<e.MIN_MONITOR_INTERVAL_MS)throw new t(`monitor() intervalMs must be a finite number >= ${e.MIN_MONITOR_INTERVAL_MS}ms, got ${a}. Sub-${e.MIN_MONITOR_INTERVAL_MS}ms polling would hot-loop the server.`,n.INVALID_CONFIG,{context:{intervalMs:a}});let o=!0,s=null;i().info(`🔄 Starting server stats monitoring every ${a}ms`);let c=async()=>{if(s=null,o&&!this.disposed){try{let e=await this.getServerStats();if(!o||this.disposed)return;try{r(e)}catch(e){i().error(`[ComputeServerStats] Monitor callback threw:`,e)}}catch(e){!o||this.disposed?i().debug(`[ComputeServerStats] Monitor poll cancelled during shutdown:`,e):i().error(`[ComputeServerStats] Failed to fetch stats during monitor:`,e)}o&&!this.disposed&&(s=setTimeout(()=>void c(),a))}},l=()=>{o=!1,s!==null&&(clearTimeout(s),s=null),this.activeMonitors.delete(l)};return this.activeMonitors.add(l),c(),l}async dispose(){if(!this.disposed){this.disposed=!0;for(let e of this.activeMonitors)e();this.activeMonitors.clear()}}ensureNotDisposed(){if(this.disposed)throw new t(`ComputeServerStats has been disposed and cannot be used`,n.INVALID_STATE)}};function _(e){try{return JSON.parse(e)}catch{return}}const v=/* @__PURE__ */ new Set;function ie(){if(typeof window>`u`||globalThis.process?.versions?.node!=null)return!1;let e=globalThis.navigator,t=typeof e?.userAgent==`string`?e.userAgent:``;return!/jsdom/i.test(t)}function y(e,t){t||ie()&&!v.has(e)&&(v.add(e),i().warn(`Warning: ${e} is running on the client side. For better performance and security, consider running this on the server side.`))}const ae={definition_not_cached:n.DEFINITION_NOT_CACHED};function oe(e){return{...e,serverErrorCodes:{...ae,...e.serverErrorCodes}}}function se(e){return e instanceof t?e.code===n.DEFINITION_NOT_CACHED||e.message.includes(`Unable to load grasshopper definition`):!1}function ce(t,n){if(!n)return;let r=e(t,`values`);if(!Array.isArray(r)||r.length===0)return;let a=[];for(let t of r){let n=e(t,`innerTree`);n&&Object.keys(n).length!==0||a.push(e(t,`paramName`)??`<unnamed>`)}if(a.length===0)return;let o=a.length===r.length?`all`:`${a.length}/${r.length}`;i().warn(`Solve returned empty output(s) (${o}): ${a.join(`, `)}. These parameters produced no data — check the definition's inputs and the branch feeding each.`)}async function le(e,t,n){return y(`solveGrasshopperDefinition`,n.suppressBrowserWarning),(await de(e,t,n)).response}async function ue(e,t,n,r){if(y(`solveWithServerCacheKey`,r.suppressBrowserWarning),t!==null)try{return{...await pe({algo:null,pointer:t,values:e},r),missed:!1}}catch(e){if(!se(e))throw e}return{...await de(e,n,r),missed:!0}}async function de(e,t,n){return pe(b(await fe(t),e),n)}async function fe(e){if(!m(e))return e;try{return await e.load()}catch(r){throw new t(`Failed to load definition bytes for ref '${e.key}'`,n.INVALID_INPUT,{context:{definitionKey:e.key},originalError:r})}}async function pe(e,t){h(t.serverUrl),me(e,t);let{maxResponseBytes:n}=t,r=await d(`grasshopper`,e,oe({...t,maxResponseBytes:n!==void 0&&e.algo?n+e.algo.length:n})),{pointer:i,algo:a,...o}=r,s=o,l=c(r);if(l!==void 0){let e=typeof a==`string`?a.length:0;p(s,Math.max(0,l-e))}return ce(s,t.debug),{response:s,cacheKey:typeof i==`string`?i:null}}function b(e,t){let n={algo:null,pointer:null,values:t};return e instanceof Uint8Array?n.algo=l(e):o(e)?n.pointer=e:n.algo=a(e)??ne(e),n}function me(e,t){t.cachesolve!=null&&(e.cachesolve=t.cachesolve),t.modelunits!=null&&(e.modelunits=t.modelunits),t.angletolerance!=null&&(e.angletolerance=t.angletolerance),t.absolutetolerance!=null&&(e.absolutetolerance=t.absolutetolerance),t.dataversion!=null&&(e.dataversion=t.dataversion),t.selvaevents!=null&&(e.selvaevents=t.selvaevents)}function x(e,t,n){t===`__proto__`?Object.defineProperty(e,t,{value:n,writable:!0,enumerable:!0,configurable:!0}):e[t]=n}const S=/^\{(-?\d+(?:;-?\d+)*)?\}$/;function C(e){if(typeof e!=`object`||!e||Array.isArray(e))return!1;let t=Object.entries(e);return t.length>0&&t.every(([e,t])=>S.test(e)&&Array.isArray(t))}function w(e,t,n){if(e==null)return e;if(Array.isArray(e)){let n=e.map(t).filter(e=>e!==null);return n.length>0?n:void 0}let r=t(e);return r===null?n?void 0:e:r}const T=e=>{if(typeof e==`number`)return Number.isFinite(e)?e:null;if(typeof e==`string`){let t=e.trim();if(t===``||/^[+-]?0[xbo]/i.test(t))return null;let n=Number(t);return Number.isFinite(n)?n:null}return null},E=e=>{if(typeof e==`boolean`)return e;if(typeof e==`string`){let t=e.trim().toLowerCase();if(t===`true`)return!0;if(t===`false`)return!1}return null},he=e=>typeof e==`string`?e.length>=2&&e.startsWith(`"`)&&e.endsWith(`"`)?e.slice(1,-1):e.startsWith(`"`)?e.slice(1):e:null,ge=e=>{if(typeof e==`string`){let t=e.trim();return t.startsWith(`"`)&&t.endsWith(`"`)&&(t=t.slice(1,-1).trim()),t}return null};function D(e){return t=>{if(typeof t==`object`&&t)return t;if(typeof t==`string`&&t.trim()!==``)try{let n=JSON.parse(t);return typeof n==`object`&&n?n:(i().warn(`Parsed value for input ${e} is not an object`),null)}catch(n){return i().warn(`Failed to parse object value "${t}" for input ${e}`,n),null}return null}}const _e=/* @__PURE__ */ new Set([`System.Double`,`System.Single`,`System.Decimal`,`System.Int32`,`System.Int64`]),ve=/* @__PURE__ */ new Set([`System.Int32`,`System.Int64`]);function O(e,t){return i().warn(t),{schema:{...e,default:null},warning:{code:n.MALFORMED_DEFAULT,message:t}}}function ye(t,a){if(typeof t.default!=`object`||t.default===null||Array.isArray(t.default)||C(t.default))return{schema:t};if(!r(t.default,`innerTree`))return O(t,`Input "${a}" default had an unrecognized shape (no innerTree key); the default was dropped.`);let o=e(t.default,`innerTree`)??{};if(Object.keys(o).length===0)return{schema:{...t,default:void 0}};if(t.treeAccess||t.atMost&&t.atMost>1){let r={},s=[];for(let[n,i]of Object.entries(o)){if(!Array.isArray(i))return O(t,`Input "${a}" default had a non-array innerTree branch ("${n}"); the default was dropped.`);let o=[];for(let t of i){let n=e(t,`data`),r=e(t,`type`);if(r&&_e.has(r)){if(typeof n==`string`&&n.trim()===``)continue;let e=T(n);if(e===null){s.push(`"${String(n)}" (${r})`);continue}o.push(ve.has(r)?Math.round(e):e)}else if(r===`System.Boolean`){let e=E(n);if(e===null){s.push(`"${String(n)}" (${r})`);continue}o.push(e)}else if(typeof n==`string`&&r?.startsWith(`Rhino.Geometry`))try{o.push(JSON.parse(n))}catch{o.push(n)}else o.push(n)}x(r,n,o)}if(s.length>0){let e=`Input "${a}" default contained ${s.length} tree value(s) that could not be parsed and were dropped: ${s.join(`, `)}.`;return i().warn(e),{schema:{...t,default:r},warning:{code:n.MALFORMED_DEFAULT,message:e}}}return{schema:{...t,default:r}}}let s=[];for(let t of Object.values(o))if(Array.isArray(t))for(let n of t)n&&typeof n==`object`&&r(n,`data`)&&s.push(e(n,`data`));return{schema:{...t,default:s.length>1?s:s[0]}}}function be(e,t){let n=Number(e.toFixed(t));return Math.abs(e-n)<1e-8?n:e}function k(e){if(!Number.isFinite(e))return 0;let t=Number(Math.abs(e).toPrecision(15)),[n,r=`0`]=String(t).split(`e`),i=(n.split(`.`)[1]?.length??0)-Number(r);return Math.min(Math.max(i,0),12)}function xe(e){if(!Number.isFinite(e)||e===0)return .1;let t=k(e);return t===0?Math.abs(e)>=1?1:.1:Number((10**-t).toFixed(t))}function A(e){return typeof e.stepSize==`number`&&Number.isFinite(e.stepSize)&&e.stepSize>0?e.stepSize:void 0}const j=(e,t)=>(e.atMost??1)>1?[t]:t,M=e=>A(e)??(e.paramType===`Integer`?1:.1),N=(e,t)=>Array.isArray(e)?e.map(e=>typeof e==`number`?t(e):e):typeof e==`number`?t(e):e;function Se(e){if(C(e.default))return{default:e.default,stepSize:M(e)};if(typeof e.default==`string`&&e.default.trim()!==``&&T(e.default)===null)throw new t(`Invalid numeric default "${e.default}" for input "${e.name||`unknown`}"`,n.VALIDATION_ERROR,{context:{inputName:e.name,default:e.default}});let r=w(e.default,T,!0);if(e.paramType===`Integer`)return{default:N(r,Math.round),stepSize:M(e)};let i=Array.isArray(r)?r[0]:r,a=[i,e.minimum,e.maximum].find(e=>typeof e==`number`&&Number.isFinite(e)&&e!==0),o=A(e)??(a===void 0?.1:xe(a)),s=k(o);if(s===0&&typeof i==`number`&&i!==0&&Math.abs(i)<1){let e=Math.ceil(-Math.log10(Math.abs(i)));Number.isFinite(e)&&e>0&&(s=e)}return s=Math.min(Math.max(s,0),12),{default:N(r,e=>be(e,s)),stepSize:o}}const P={parse(e,t){let{default:n,stepSize:r}=Se(e);return{...t,paramType:e.paramType,minimum:e.minimum,maximum:e.maximum,atLeast:e.atLeast,atMost:e.atMost,stepSize:r,default:n}},fallback(e,t){let n=typeof e.minimum==`number`&&Number.isFinite(e.minimum)&&e.minimum>0?e.minimum:0;return{...t,paramType:e.paramType,minimum:e.minimum,maximum:e.maximum,atLeast:e.atLeast,atMost:e.atMost,stepSize:M(e),default:j(e,n)}}},Ce={parse(e,r){if(C(e.default))return{...r,paramType:`Boolean`,default:e.default};let i=w(e.default,E,!1);if(i!=null&&typeof i!=`boolean`&&!Array.isArray(i))throw new t(`Invalid boolean default "${String(i)}" for input "${e.name||`unknown`}"`,n.VALIDATION_ERROR,{context:{inputName:e.name,default:e.default}});return{...r,paramType:`Boolean`,default:i}},fallback(e,t){return{...t,paramType:`Boolean`,default:j(e,!1)}}},we={parse(e,t){let n=w(e.default,he,!1);return{...t,paramType:`Text`,default:n}}},Te={parse(e,r,a){if(!e.values||typeof e.values!=`object`||Object.keys(e.values).length===0){let r=e.nickname||`unnamed`;throw new t(`Input "${r}" has no values defined (expected ValueList)`,n.INVALID_INPUT,{context:{inputName:r,expectedType:`ValueList`}})}let o=e.default;if(e.default!==void 0&&e.default!==null){if(typeof e.default==`object`)throw new t(`ValueList input "${e.nickname||`unnamed`}" default is not a string-able value`,n.VALIDATION_ERROR,{context:{inputName:e.name,default:e.default}});let r=String(e.default).toLowerCase(),s=Object.keys(e.values).find(e=>e.toLowerCase()===r);if(s!==void 0)o=s;else{let t=`ValueList input "${e.nickname||`unnamed`}" default value "${e.default}" is not in available values`;i().warn(t),a?.({code:n.VALIDATION_ERROR,message:t})}}return{...r,paramType:`ValueList`,values:e.values,default:o}},fallback(e,t){return{...t,paramType:`ValueList`,values:e.values&&typeof e.values==`object`?e.values:{},default:void 0}}};function F(e,t){return{...t,paramType:`Geometry`,default:j(e,null)}}const I=/* @__PURE__ */ new Map([[`Number`,P],[`Integer`,P],[`Boolean`,Ce],[`Text`,we],[`ValueList`,Te],[`Geometry`,{parse(e,t){let n=w(e.default,D(e.nickname||`unnamed`),!0);return{...t,paramType:`Geometry`,default:n}},fallback:F}],[`File`,{parse(e,t){let n=w(e.default,D(e.nickname||`unnamed`),!0);return{...t,paramType:`File`,acceptedFormats:e.acceptedFormats,default:n}}}],[`Color`,{parse(e,t){let n=w(e.default,ge,!1);return{...t,paramType:`Color`,default:n}}}]]),Ee=F,De=new Map([...I.keys()].map(e=>[e.toLowerCase(),e]));function Oe(e){return De.get(e?.toLowerCase())??e}function ke(e){return L(e).input}function L(e){let r=e.name||`unknown`,a=[],o=({code:t,message:n})=>{a.push({inputName:r,paramType:e.paramType,message:n,code:t})},s={description:e.description,name:e.name,nickname:e.nickname,treeAccess:e.treeAccess,groupName:e.groupName??void 0,id:e.id},c=Oe(e.paramType),l={...e,paramType:c};try{let{schema:e,warning:t}=ye(l,r);l=e,t&&o(t)}catch(e){l={...l,default:null},o({code:n.MALFORMED_DEFAULT,message:`Input "${r}" default could not be normalized and was dropped: ${e instanceof Error?e.message:String(e)}`})}let u=I.get(c);try{if(!u)throw new t(`Unknown paramType: ${c}`,n.VALIDATION_ERROR,{context:{receivedParamType:c,paramName:e.name}});return{input:u.parse(l,s,o),errors:a}}catch(d){if(!(d instanceof t))throw new t(d instanceof Error?d.message:String(d),n.VALIDATION_ERROR,{context:{paramName:e.name,paramType:c},originalError:d});return i().error(`Validation error for input ${r}:`,d.message),o(d),{input:(u?.fallback??Ee)(l,s),errors:a}}}function Ae(e){let t=[],n=[];for(let r of e){let{input:e,errors:i}=L(r);t.push(e),n.push(...i)}return{inputs:t,parseErrors:n}}function je(t){let n=e(t,`stepSize`);return{id:e(t,`id`)??``,name:e(t,`name`)??``,nickname:e(t,`nickname`)??null,description:e(t,`description`)??``,paramType:e(t,`paramType`)??``,treeAccess:e(t,`treeAccess`)??!1,minimum:e(t,`minimum`)??null,maximum:e(t,`maximum`)??null,atLeast:e(t,`atLeast`)??1,atMost:e(t,`atMost`)??1,stepSize:typeof n==`number`&&Number.isFinite(n)?n:void 0,default:e(t,`default`),values:e(t,`values`),acceptedFormats:e(t,`acceptedFormats`),groupName:e(t,`groupName`)??null}}function Me(t){return{name:e(t,`name`)??``,nickname:e(t,`nickname`)??null,paramType:e(t,`paramType`)??``,id:e(t,`id`)??``}}async function R(r,i){y(`fetchDefinitionIO`,i.suppressBrowserWarning),h(i.serverUrl);let{algo:a,pointer:o}=b(r,[]);if(!a&&!o)throw new t(`Definition must resolve to either a URL pointer or base64 algo`,n.INVALID_INPUT);let s=await d(`io`,a?{algo:a}:{pointer:o},oe(i));if(!s||typeof s!=`object`)throw new t(`Invalid IO response structure`,n.INVALID_INPUT,{context:{response:s}});let c=z(e(s,`warnings`)),l=z(e(s,`errors`)),u=e(s,`inputs`),f=e(s,`outputs`);return{inputs:Array.isArray(u)?u.map(je):[],outputs:Array.isArray(f)?f.map(Me):[],...c&&{loadWarnings:c},...l&&{loadErrors:l}}}function z(e){if(!Array.isArray(e))return;let t=e.map(Ne).filter(e=>e!==void 0);return t.length>0?t:void 0}function Ne(t){if(t==null)return;let n;if(typeof t==`string`)n=t;else if(typeof t==`object`){let r=e(t,`message`);if(typeof r==`string`&&r.trim().length>0)n=r;else try{n=JSON.stringify(t)??String(t)}catch{n=String(t)}}else n=String(t);return n.trim().length>0?n:void 0}async function B(e,t){let{inputs:n,outputs:r,loadWarnings:i,loadErrors:a}=await R(e,t),{inputs:o,parseErrors:s}=Ae(n);return{inputs:o,outputs:r,...s.length>0&&{parseErrors:s},...i&&{loadWarnings:i},...a&&{loadErrors:a}}}const V=globalThis.process?.getBuiltinModule?.(`node:crypto`);function H(e){if(V){let t=V.createHash(`sha256`);return typeof e==`string`?t.update(e,`utf16le`):t.update(e),t.digest(`hex`)}return Fe(e)}const Pe=new Int32Array([1116352408,1899447441,3049323471,3921009573,961987163,1508970993,2453635748,2870763221,3624381080,310598401,607225278,1426881987,1925078388,2162078206,2614888103,3248222580,3835390401,4022224774,264347078,604807628,770255983,1249150122,1555081692,1996064986,2554220882,2821834349,2952996808,3210313671,3336571891,3584528711,113926993,338241895,666307205,773529912,1294757372,1396182291,1695183700,1986661051,2177026350,2456956037,2730485921,2820302411,3259730800,3345764771,3516065817,3600352804,4094571909,275423344,430227734,506948616,659060556,883997877,958139571,1322822218,1537002063,1747873779,1955562222,2024104815,2227730452,2361852424,2428436474,2756734187,3204031479,3329325298]);function Fe(e){let t=new Ie;return typeof e==`string`?t.updateString(e):t.update(e),t.digestHex()}var Ie=class{h=new Int32Array([1779033703,3144134277,1013904242,2773480762,1359893119,2600822924,528734635,1541459225]);w=/* @__PURE__ */ new Int32Array(64);pending=/* @__PURE__ */ new Uint8Array(64);pendingLength=0;totalBytes=0;update(e){this.totalBytes+=e.length;let t=0;if(this.pendingLength>0){let n=Math.min(64-this.pendingLength,e.length);if(this.pending.set(e.subarray(0,n),this.pendingLength),this.pendingLength+=n,t=n,this.pendingLength<64)return;this.compressBytes(this.pending,0),this.pendingLength=0}for(;t+64<=e.length;t+=64)this.compressBytes(e,t);this.pending.set(e.subarray(t),0),this.pendingLength=e.length-t}updateString(e){let t=this.w,n=e.length-e.length%32;for(let r=0;r<n;r+=32){for(let n=0;n<16;n++){let i=e.charCodeAt(r+2*n),a=e.charCodeAt(r+2*n+1);t[n]=(i&255)<<24|i>>>8<<16|(a&255)<<8|a>>>8}this.compress()}this.totalBytes+=n*2;let r=new Uint8Array((e.length-n)*2);for(let t=n,i=0;t<e.length;t++){let n=e.charCodeAt(t);r[i++]=n&255,r[i++]=n>>>8}this.update(r)}digestHex(){let e=this.totalBytes*8,t=new Uint8Array(this.pendingLength<56?64:128);t.set(this.pending.subarray(0,this.pendingLength)),t[this.pendingLength]=128;let n=new DataView(t.buffer);n.setUint32(t.length-8,Math.floor(e/4294967296)),n.setUint32(t.length-4,e>>>0);for(let e=0;e<t.length;e+=64)this.compressBytes(t,e);let r=``;for(let e of this.h)r+=(e>>>0).toString(16).padStart(8,`0`);return r}compressBytes(e,t){let n=this.w;for(let r=0;r<16;r++){let i=t+r*4;n[r]=e[i]<<24|e[i+1]<<16|e[i+2]<<8|e[i+3]}this.compress()}compress(){let e=this.w;for(let t=16;t<64;t++){let n=e[t-15],r=e[t-2],i=(n>>>7|n<<25)^(n>>>18|n<<14)^n>>>3,a=(r>>>17|r<<15)^(r>>>19|r<<13)^r>>>10;e[t]=e[t-16]+i+e[t-7]+a|0}let t=this.h,n=t[0],r=t[1],i=t[2],a=t[3],o=t[4],s=t[5],c=t[6],l=t[7];for(let t=0;t<64;t++){let u=(o>>>6|o<<26)^(o>>>11|o<<21)^(o>>>25|o<<7),d=o&s^~o&c,f=l+u+d+Pe[t]+e[t]|0,p=((n>>>2|n<<30)^(n>>>13|n<<19)^(n>>>22|n<<10))+(n&r^n&i^r&i)|0;l=c,c=s,s=o,o=a+f|0,a=i,i=r,r=n,n=f+p|0}t[0]=t[0]+n|0,t[1]=t[1]+r|0,t[2]=t[2]+i|0,t[3]=t[3]+a|0,t[4]=t[4]+o|0,t[5]=t[5]+s|0,t[6]=t[6]+c|0,t[7]=t[7]+l|0}};function U(e){let t=/* @__PURE__ */ new WeakSet,n=e=>{if(e===null)return`null`;if(typeof e==`number`)return Number.isFinite(e)?String(e):`null`;if(typeof e==`string`||typeof e==`boolean`)return JSON.stringify(e);if(typeof e==`bigint`)return`${e}n`;if(typeof e!=`object`)return`undefined`;if(e instanceof Uint8Array)return`{u8:${H(e)}}`;if(t.has(e))return`[Circular]`;t.add(e);let r;if(Array.isArray(e)){let t=[];for(let r=0;r<e.length;r++)t.push(n(e[r]));r=`[${t.join(`,`)}]`}else r=typeof e.toJSON==`function`?n(e.toJSON()):e instanceof Map?`{map:[${[...e.entries()].map(([e,t])=>`[${n(e)},${n(t)}]`).sort().join(`,`)}]}`:e instanceof Set?`{set:[${[...e.values()].map(n).sort().join(`,`)}]}`:`{${Object.keys(e).sort().map(t=>`${JSON.stringify(t)}:${n(e[t])}`).join(`,`)}}`;return t.delete(e),r};return n(e)}function Le(e,t){return W(G(e),t)}function W(e,t){return`${e}|t:${H(U(t))}`}function G(e){return m(e)?`r:${e.key}`:typeof e==`string`?`s:${H(e)}`:`u8:${H(e)}`}const K=/* @__PURE__ */ new WeakMap;function Re(e){if(!(e instanceof Uint8Array))return G(e);let t=K.get(e);return t===void 0&&(t=G(e),K.set(e,t)),t}var ze=class{hashDefinition;dataTree;definitionMemo;keyMemo;constructor(e,t){this.hashDefinition=e,this.dataTree=t}get definitionHash(){return this.definitionMemo??=this.hashDefinition()}get key(){return this.keyMemo??=W(this.definitionHash,this.dataTree)}},Be=class{items=[];head=0;live=/* @__PURE__ */ new Set;get size(){return this.live.size}push(e){this.items.push(e),this.live.add(e)}remove(e){this.live.delete(e)&&this.compact()}shift(){for(;this.head<this.items.length;){let e=this.items[this.head];if(this.items[this.head++]=void 0,e&&this.live.delete(e))return this.compact(),e}}compact(){if(this.live.size===0){this.items=[],this.head=0;return}let e=this.items.length-this.live.size;e<=64||e<=this.live.size||(this.items=this.items.filter(e=>e!==void 0&&this.live.has(e)),this.head=0)}};function Ve(e){try{return JSON.stringify(e)?.length??0}catch{return 0}}var He=class{executor;baseConfig;mode;maxConcurrent;maxQueueDepth;queueWaitMs;timeoutMs;retry;cacheEnabled;cacheMaxBytes;cacheTtl;cacheErroredSolves;cache=/* @__PURE__ */ new Map;cacheBytes=0;cacheHits=0;cacheMisses=0;cacheEvictions=0;reuseServerDefinitionCache;serverCacheKeys=/* @__PURE__ */ new Map;lastStringDefinition=null;onStart;onSettle;onSuperseded;subscribers=/* @__PURE__ */ new Set;inFlight=/* @__PURE__ */ new Set;pendingForLatestWins=null;fifo=new Be;_lastResult=null;_lastError=null;_lastDurationMs=null;solveSeq=0;lastStateSeq=0;disposed=!1;constructor(e,r,i={}){if(this.executor=e,this.baseConfig=r,this.mode=i.mode??`latest-wins`,this.mode!==`latest-wins`&&this.mode!==`queue`)throw new t(`Unknown scheduler mode '${String(this.mode)}'. For concurrent solves use { mode: 'queue', maxConcurrent: 4 }.`,n.INVALID_CONFIG,{context:{mode:this.mode}});this.maxConcurrent=Math.max(1,i.maxConcurrent??1),this.maxQueueDepth=i.maxQueueDepth!==void 0&&i.maxQueueDepth>0?Math.floor(i.maxQueueDepth):void 0,this.queueWaitMs=i.queueWaitMs!==void 0&&i.queueWaitMs>0?i.queueWaitMs:void 0,this.timeoutMs=i.timeoutMs,this.retry=i.retry;let a=i.cache,o=typeof a==`object`?a:null;this.cacheMaxBytes=Math.max(0,o?.maxBytes??0),this.cacheEnabled=this.cacheMaxBytes>0,this.cacheTtl=o?.ttlMs??0,this.cacheErroredSolves=o?.cacheErroredSolves??!0,this.reuseServerDefinitionCache=i.reuseServerDefinitionCache??!0,this.onStart=i.onStart,this.onSettle=i.onSettle,this.onSuperseded=i.onSuperseded}get isSolving(){return this.inFlight.size>0}get hasPending(){return this.pendingForLatestWins!==null||this.fifo.size>0}get inFlightCount(){return this.inFlight.size}get queueDepth(){return this.fifo.size+ +!!this.pendingForLatestWins}get lastResult(){return this._lastResult}get lastError(){return this._lastError}get lastDurationMs(){return this._lastDurationMs}setMaxConcurrent(e){let t=Math.max(1,Math.floor(e));if(t===this.maxConcurrent)return;let n=t>this.maxConcurrent;this.maxConcurrent=t,n&&this.drainNext()}getMaxConcurrent(){return this.maxConcurrent}subscribe(e){return this.subscribers.add(e),()=>this.subscribers.delete(e)}notify(){for(let e of this.subscribers)try{e()}catch(e){i().error(`[SolveScheduler] subscriber threw:`,e)}}solve(e,t,n){return this.solveDetailed(e,t,n).then(e=>e.response)}solveDetailed(e,r,i){if(this.disposed)return Promise.reject(new t(`SolveScheduler has been disposed and cannot be used`,n.INVALID_STATE));let a=new ze(()=>this.hashDefinitionMemo(e),r),o=``;if(this.cacheEnabled||this.onStart||this.onSettle||this.onSuperseded)try{o=a.key}catch(e){return Promise.reject(new t(`Solve input could not be hashed`,n.INVALID_INPUT,{originalError:e}))}let s=++this.solveSeq,c={key:o,enqueuedAt:Date.now(),startedAt:null};if(i?.signal?.aborted)return Promise.reject(this.makeAbortError(c));let l=this.readCache(o);if(l){this.mode===`latest-wins`&&this.supersedeCurrent();let e={status:`success`,response:l,durationMs:0,fromCache:!0};return this.writeLastState(s,{result:l,durationMs:0}),this.runHook(this.onStart,c),this.runHook(this.onSettle,c,e),this.notify(),Promise.resolve({response:l,fromCache:!0,durationMs:0})}return new Promise((t,n)=>{let o={definition:e,dataTree:r,hashes:a,ctx:c,seq:s,resolve:t,reject:n,externalSignal:i?.signal,selvaevents:i?.selvaevents,onServerTiming:i?.onServerTiming};o.externalSignal&&(o.queuedAbortHandler=()=>this.abortQueuedItem(o),o.externalSignal.addEventListener(`abort`,o.queuedAbortHandler,{once:!0})),this.enqueue(o)})}writeLastState(e,t){e<this.lastStateSeq||(this.lastStateSeq=e,`result`in t?(this._lastResult=t.result,this._lastError=null):this._lastError=t.error,this._lastDurationMs=t.durationMs)}supersedeCurrent(){this.pendingForLatestWins&&=(this.supersede(this.pendingForLatestWins),null);for(let e of this.inFlight)this.supersede(e),e.controller.abort()}dequeue(e){this.pendingForLatestWins===e&&(this.pendingForLatestWins=null),this.fifo.remove(e)}abortQueuedItem(e){this.dequeue(e),this.fail(e,this.makeAbortError(e.ctx)),this.notify()}shedAsQueueFull(e){let r=new t(`Solve queue is full; request rejected (backpressure)`,n.QUEUE_FULL,{statusCode:503,context:{queueDepth:this.fifo.size,maxQueueDepth:this.maxQueueDepth}});this.fail(e,r),this.notify()}armQueueWaitTimer(e){if(this.queueWaitMs===void 0)return;let r=this.queueWaitMs;e.queueWaitTimer=setTimeout(()=>{if(e.settled)return;this.dequeue(e);let i=new t(`Solve waited longer than ${r}ms in queue; rejected (backpressure)`,n.QUEUE_TIMEOUT,{statusCode:503,context:{waitedMs:Date.now()-e.ctx.enqueuedAt,queueWaitMs:r}});this.fail(e,i),this.notify()},r)}clearQueueWaitTimer(e){e.queueWaitTimer!==void 0&&(clearTimeout(e.queueWaitTimer),e.queueWaitTimer=void 0)}enqueue(e){switch(this.mode){case`latest-wins`:this.supersedeCurrent(),this.inFlight.size===0?this.execute(e):this.pendingForLatestWins=e;break;case`queue`:this.inFlight.size<this.maxConcurrent?this.execute(e):this.maxQueueDepth!==void 0&&this.fifo.size>=this.maxQueueDepth?this.shedAsQueueFull(e):(this.armQueueWaitTimer(e),this.fifo.push(e))}this.notify()}async execute(e){let t=new AbortController,n=e;n.controller=t,this.inFlight.add(n),e.ctx.startedAt=Date.now(),this.clearQueueWaitTimer(e),this.removeQueuedAbortHandler(e);let r=()=>t.abort();e.externalSignal?.addEventListener(`abort`,r,{once:!0}),this.runHook(this.onStart,e.ctx),this.notify();let i=performance.now();try{let n={...this.baseConfig,signal:t.signal,...this.timeoutMs!==void 0&&{timeoutMs:this.timeoutMs},...this.retry!==void 0&&{retry:this.retry},...e.selvaevents!==void 0&&{selvaevents:e.selvaevents}},r=e.onServerTiming;if(r){let e=this.baseConfig.onServerTiming;n.onServerTiming=(t,n)=>{try{e?.(t,n)}finally{r(t,n)}}}let{response:a,definitionReuploaded:o}=await this.runExecutor(e,n),s=performance.now()-i;if(this.writeCache(e.ctx.key,a),!this.settleSuccess(e,{response:a,fromCache:!1,definitionReuploaded:o,durationMs:s}))return;this.writeLastState(e.seq,{result:a,durationMs:s}),this.runHook(this.onSettle,e.ctx,{status:`success`,response:a,durationMs:s,fromCache:!1,definitionReuploaded:o})}catch(t){let r=performance.now()-i,a=this.normalizeExecutionError(t,n);this.writeLastState(e.seq,{error:a,durationMs:r}),this.fail(e,a,r)}finally{e.externalSignal?.removeEventListener(`abort`,r),this.inFlight.delete(n),this.drainNext(),this.notify()}}async runExecutor(e,t){let{definition:n,dataTree:r}=e;if(!this.reuseServerDefinitionCache||o(n)){let{response:e}=await this.executor(n,r,null,t);return{response:e}}let i=e.hashes.definitionHash,a=this.serverCacheKeys.get(i)??null,s=await this.executor(n,r,a,t);return this.serverCacheKeys.delete(i),s.cacheKey&&(this.serverCacheKeys.set(i,s.cacheKey),this.serverCacheKeys.size>100&&this.serverCacheKeys.delete(this.serverCacheKeys.keys().next().value)),{response:s.response,definitionReuploaded:s.missed}}hashDefinitionMemo(e){return typeof e==`string`?(this.lastStringDefinition?.value!==e&&(this.lastStringDefinition={value:e,hash:G(e)}),this.lastStringDefinition.hash):Re(e)}drainNext(){if(!this.disposed){if(this.mode===`latest-wins`){if(this.pendingForLatestWins&&this.inFlight.size===0){let e=this.pendingForLatestWins;this.pendingForLatestWins=null,this.execute(e)}}else for(;this.fifo.size>0&&this.inFlight.size<this.maxConcurrent;)this.execute(this.fifo.shift())}}supersede(e){let r=new t(`Superseded by newer solve`,n.SUPERSEDED,{context:{enqueuedAt:e.ctx.enqueuedAt}});this.settleError(e,r)&&this.runHook(this.onSuperseded,e.ctx)}makeAbortError(e){return new t(`Request aborted by caller`,n.ABORTED,{context:{enqueuedAt:e.enqueuedAt}})}settleError(e,t){return!e.settled&&(e.settled={error:t},this.clearQueueWaitTimer(e),this.removeQueuedAbortHandler(e),e.reject(t),!0)}fail(e,t,n=0){this.settleError(e,t)&&this.runHook(this.onSettle,e.ctx,{status:`error`,error:t,durationMs:n})}settleSuccess(e,t){return!e.settled&&(e.settled={ok:!0},this.clearQueueWaitTimer(e),this.removeQueuedAbortHandler(e),e.resolve(t),!0)}removeQueuedAbortHandler(e){e.queuedAbortHandler&&e.externalSignal&&e.externalSignal.removeEventListener(`abort`,e.queuedAbortHandler),e.queuedAbortHandler=void 0}normalizeExecutionError(e,r){return r.settled&&`error`in r.settled?r.settled.error:e instanceof t?e:e instanceof Error&&e.name===`AbortError`?this.makeAbortError(r.ctx):new t(e instanceof Error?e.message:String(e),n.UNKNOWN_ERROR,{originalError:e})}cancelAll(){this.pendingForLatestWins&&=(this.fail(this.pendingForLatestWins,this.makeAbortError(this.pendingForLatestWins.ctx)),null);for(let e=this.fifo.shift();e;e=this.fifo.shift())this.fail(e,this.makeAbortError(e.ctx));for(let e of this.inFlight){let t=e.ctx.startedAt?Date.now()-e.ctx.startedAt:0;this.fail(e,this.makeAbortError(e.ctx),t),e.controller.abort()}this.notify()}readCache(e){if(!this.cacheEnabled)return null;let t=this.cache.get(e);return t?this.cacheTtl>0&&Date.now()-t.insertedAt>this.cacheTtl?(this.dropCacheEntry(e),this.cacheMisses+=1,null):(this.cache.delete(e),this.cache.set(e,t),this.cacheHits+=1,t.response):(this.cacheMisses+=1,null)}writeCache(t,n){if(!this.cacheEnabled)return;let r=e(n,`errors`);if(!this.cacheErroredSolves&&Array.isArray(r)&&r.length>0)return;let i=e(e(n,`selva`),`outcome`);if(e(i,`aborted`)===!0)return;let a=c(n)??Ve(n);if(!(a>this.cacheMaxBytes))for(this.dropCacheEntry(t),this.cache.set(t,{response:n,insertedAt:Date.now(),sizeBytes:a}),this.cacheBytes+=a;this.cacheBytes>this.cacheMaxBytes&&this.cache.size>0;){let e=this.cache.keys().next().value;if(e===void 0)break;this.dropCacheEntry(e),this.cacheEvictions+=1}}dropCacheEntry(e){let t=this.cache.get(e);t&&(this.cache.delete(e),this.cacheBytes-=t.sizeBytes)}clearCache(){this.cache.clear(),this.cacheBytes=0}cacheStats(){return{entries:this.cache.size,bytes:this.cacheBytes,hits:this.cacheHits,misses:this.cacheMisses,evictions:this.cacheEvictions}}dispose(){this.disposed||(this.disposed=!0,this.cancelAll(),this.subscribers.clear(),this.clearCache())}runHook(e,...t){if(e)try{e(...t)}catch(e){i().error(`[SolveScheduler] hook threw:`,e)}}};function Ue(e){return m(e)?`ref:${e.key}`:typeof e==`string`&&e.length<200?e:`...content...`}function We(t){return Array.isArray(t)?t.map(t=>{let n=0,r=0,i=e(t,`innerTree`);if(i&&typeof i==`object`){for(let e of Object.values(i))if(Array.isArray(e)){n+=e.length;for(let t of e){let e=t?.data;typeof e==`string`&&(r+=e.length)}}}return{param:e(t,`paramName`)??`<unnamed>`,items:n,bytes:r}}):[]}var Ge=class r{config;serverStats;disposed=!1;static CREATE_PROBE_TIMEOUT_MS=2e3;constructor(e){this.config={...e,serverUrl:h(e.serverUrl),debug:e.debug??!1},this.serverStats=new g(this.config.serverUrl,this.config)}static async create(e,i={}){let a=new r(e),o=Math.max(1,(i.probe?.attempts??2)+1),s=i.probe?.baseDelayMs??250,c=i.probe?.maxDelayMs??1e3,l,u=null,d=0;for(let e=0;e<o;e++){if(d=e+1,l=await a.serverStats.probeServer(r.CREATE_PROBE_TIMEOUT_MS),l.online)return a;if(u=te(l),u&&!u.retryable)break;if(e<o-1){let t=Math.min(s*2**e,c);await new Promise(e=>setTimeout(e,t))}}await a.dispose();let f=l?.status,p=u?`Rhino Compute server is not available. ${u.summary}`:`Rhino Compute server is not online`;throw new t(p,n.NETWORK_ERROR,{...f!==void 0&&{statusCode:f},context:{serverUrl:a.config.serverUrl,attempts:d,maxAttempts:o,...u&&{probeVerdict:u.verdict,probeRetryable:u.retryable},...f!==void 0&&{lastProbeStatus:f},...l?.error!==void 0&&{lastProbeError:l.error}}})}getConfig(){return this.ensureNotDisposed(),{...this.config}}async getIO(e){return this.ensureNotDisposed(),B(e,this.config)}async getRawIO(e){return this.ensureNotDisposed(),R(e,this.config)}async solve(r,a,o){this.ensureNotDisposed();try{if(typeof r==`string`&&!r.trim())throw new t(`Definition URL/content is required`,n.INVALID_INPUT,{context:{receivedUrl:r}});if(r instanceof Uint8Array&&r.length===0)throw new t(`Definition content is empty`,n.INVALID_INPUT);if(m(r)&&!r.key.trim())throw new t(`DefinitionRef key is empty`,n.INVALID_INPUT);let i=await le(a,r,{...this.config,...o?.signal!==void 0&&{signal:o.signal},...o?.timeoutMs!==void 0&&{timeoutMs:o.timeoutMs},...o?.retry!==void 0&&{retry:o.retry},...o?.selvaevents!==void 0&&{selvaevents:o.selvaevents}}),s=e(i,`errors`);if(Array.isArray(s)&&s.length>0)throw new t(s.map(String).join(`; `)||`Computation failed`,n.COMPUTATION_ERROR,{context:{definition:Ue(r),inputSummary:We(a),errors:s,warnings:e(i,`warnings`),values:i.values}});return i}catch(e){throw this.config.debug&&i().error(`Compute failed:`,e),e instanceof t?e:new t(e instanceof Error?e.message:String(e),n.COMPUTATION_ERROR,{context:{definition:Ue(r),inputSummary:We(a)},originalError:e})}}createScheduler(e){return this.ensureNotDisposed(),new He((e,t,n,r)=>ue(t,n,e,r),this.config,e)}async dispose(){this.disposed||(this.disposed=!0,await this.serverStats.dispose())}ensureNotDisposed(){if(this.disposed)throw new t(`GrasshopperClient has been disposed and cannot be used`,n.INVALID_STATE)}};function Ke(e){return typeof e==`object`&&!!e&&e.__decodeError===!0}function qe(e,t){return{__decodeError:!0,type:e,raw:t}}function Je(e){let t=/* @__PURE__ */ new WeakSet,n=e=>{if(!e||typeof e!=`object`||t.has(e))return;t.add(e);let r=e.delete;if(typeof r==`function`){let t=e.isDeleted;typeof t==`function`&&t.call(e)||r.call(e);return}if(Array.isArray(e)){for(let t of e)n(t);return}let i=Object.getPrototypeOf(e);if(i===Object.prototype||i===null)for(let t of Object.values(e))n(t)};n(e)}const q=/* @__PURE__ */ new Map([[`Rhino.Geometry.Point3d`,(e,t)=>{let n=t;return!n||typeof n.X!=`number`?null:new e.Point([n.X,n.Y,n.Z])}],[`Rhino.Geometry.Line`,(e,t)=>{let n=t;return!n||!n.From||!n.To?null:new e.Line([n.From.X,n.From.Y,n.From.Z],[n.To.X,n.To.Y,n.To.Z])}]]);function Ye(e){if(q.has(e))return q.get(e);for(let[t,n]of q)if(e.startsWith(t))return n}function Xe(e){return!!(e&&typeof e==`object`&&typeof e.data==`string`)}function Ze(e,t,n){let r=Ye(t),a=!1;if(r)try{let t=r(n,e);if(t!=null)return t}catch(e){i().warn(`Failed to decode Rhino type ${t}:`,e),a=!0}try{if(Xe(e))return n.CommonObject.decode(e)}catch(n){return i().warn(`Failed to decode ${t} with CommonObject:`,n),qe(t,e)}return a?qe(t,e):e}const J={STRING:`System.String`,INT:`System.Int32`,DOUBLE:`System.Double`,BOOL:`System.Boolean`},Qe=`FileData`;function $e(e,t){return e.includes(`WebDisplay`)||t&&e!==J.STRING}function et(e){if(typeof e!=`string`)return e;let t=e.trim();if(!(t.startsWith(`{`)||t.startsWith(`[`)||t.startsWith(`"`)))return e;try{let e=JSON.parse(t);if(typeof e==`string`)try{return JSON.parse(e)}catch{return e}return e}catch{return e}}function tt(e,t,n){switch(t){case J.STRING:return typeof e==`string`?e.replace(/^"(.*)"$/,`$1`):e;case J.INT:return Number.parseInt(String(e),10);case J.DOUBLE:return Number.parseFloat(String(e));case J.BOOL:return String(e).toLowerCase()===`true`;default:return n&&t.startsWith(`Rhino.Geometry.`)?Ze(e,t,n):e}}function Y(e,t,n,r){if(typeof e.data!=`string`)return e.data;let i=n?et(e.data):e.data;return n&&t.includes(Qe)?nt(i)??i:tt(i,t,r)}function nt(t){if(!t||typeof t!=`object`)return null;let n=e(t,`fileName`),i=e(t,`fileType`),a=e(t,`subFolder`),o=e(t,`isBase64Encoded`);if(typeof n!=`string`||typeof i!=`string`||typeof a!=`string`||!r(t,`data`)||typeof o!=`boolean`&&typeof o!=`string`)return null;let s=e(t,`metadata`);return{fileName:n,fileType:i,data:e(t,`data`),isBase64Encoded:u(o),subFolder:a,...s?{metadata:s}:{}}}function X(t){let n=e(t,`values`);return Array.isArray(n)?n:[]}function Z(e){return typeof e.type==`string`?e.type:``}function Q(e,t){if(e&&typeof e==`object`){for(let n of Object.values(e))if(Array.isArray(n))for(let e of n)e&&typeof e==`object`&&t(e)}}function rt(t,n=!1,r={}){let{parseValues:i=!0,rhino:a,stringOnly:o=!1}=r,s={},c=/* @__PURE__ */ new Set;for(let r of X(t)){let t=e(r,`paramName`);Q(e(r,`innerTree`),e=>{let r=Z(e);if($e(r,o))return;let l=n?e.id:t;if(!l)return;let u=Y(e,r,i,a);Object.prototype.hasOwnProperty.call(s,l)?c.has(l)?s[l].push(u):(s[l]=[s[l],u],c.add(l)):x(s,l,u)})}return{values:s,dispose:()=>Je(s)}}function it(t){let n=[];for(let r of X(t))Q(e(r,`innerTree`),e=>{if(!Z(e).includes(Qe))return;let t=nt(et(e.data));t&&n.push(t)});return n}function at(t,n,r={}){let{parseValues:i=!0,rhino:a,stringOnly:o=!1}=r;for(let r of X(t)){let t=e(r,`innerTree`),s=!1;if(`byName`in n){if(e(r,`paramName`)!==n.byName)continue;s=!0}let c=[];if(Q(t,e=>{if(`byId`in n){if(e.id!==n.byId)return;s=!0}let t=Z(e);$e(t,o)||c.push(Y(e,t,i,a))}),s)return c.length===0?void 0:c.length===1?c[0]:c}}var ot=class{response;constructor(e){this.response=e}getValues(e=!1,t={}){return rt(this.response,e,t)}getValue(e,t){return at(this.response,e,t)}async getAndDownloadFiles(e,t){await ee(it(this.response),e,t)}};function st(t){return(Array.isArray(t)?t:[t]).map(t=>({schemas:e(t,`schemas`),error:e(t,`error`)}))}const ct=/* @__PURE__ */ new Set([`options`,`defaultOptions`,`values`]),lt=/* @__PURE__ */ new Set([`optionMedia`,`assets`]),ut=e=>e>=`A`&&e<=`Z`;function dt(e){if(e.length===0||!ut(e[0]))return e;let t=0;for(;t<e.length&&ut(e[t]);)t++;return t>1&&t<e.length&&t--,e.slice(0,t).toLowerCase()+e.slice(t)}function ft(e){return $(e)}function $(e){if(Array.isArray(e))return e.map($);if(typeof e!=`object`||!e)return e;let t={};for(let[n,r]of Object.entries(e)){let e=dt(n);x(t,e,ct.has(e)?r:lt.has(e)?pt(r):$(r))}return t}function pt(e){if(typeof e!=`object`||!e||Array.isArray(e))return e;let t={};for(let[n,r]of Object.entries(e))x(t,n,$(r));return t}var mt=class r{innerTree;paramName;constructor(e){this.paramName=e,this.innerTree={}}append(e,t){let n=this.innerTree[r.formatPathString(e)]??=[];for(let e of t)n.push({data:r.serializeValue(e)});return this}fromDataTreeDefault(e){this.innerTree={};for(let[t,n]of Object.entries(e)){if(!Array.isArray(n))continue;let e=r.parsePathString(t);this.append(e,n)}return this}appendFlat(e){let t=Array.isArray(e)?e:[e];return this.append([0],t)}flatten(){let e=[];for(let t of Object.values(this.innerTree))if(Array.isArray(t))for(let n of t)e.push(r.deserializeValue(n.data));return e}toComputeFormat(){return{ParamName:this.paramName,InnerTree:this.innerTree}}getParamName(){return this.paramName}static fromInputParams(e){return r.fromValues(e.map(e=>({paramName:e.nickname||`unnamed`,paramType:e.paramType,value:e.default,...`minimum`in e&&{minimum:e.minimum,maximum:e.maximum}})))}static fromValues(e){let t=[];for(let n of e){let e=new r(n.paramName),a=r.itemCoercer(n);for(let[t,o]of r.branchesOf(n.value)){let r=[];for(let e of o){if(e==null)continue;let t=a(e);t===null?i().warn(`${n.paramName}: dropped an item that is not a valid ${n.paramType}`):r.push(t)}r.length>0&&e.append(t,r)}Object.keys(e.innerTree).length>0&&t.push(e.toComputeFormat())}return t}static branchesOf(e){return r.hasValidValue(e)?C(e)?Object.entries(e).map(([e,t])=>[r.parsePathString(e),t]):[[[0],Array.isArray(e)?e:[e]]]:[]}static itemCoercer(e){let{paramName:t,minimum:n,maximum:i}=e,a=e.paramType.toLowerCase();return a===`number`||a===`integer`?e=>{let o=T(e);if(o===null)return null;let s=a===`integer`?Math.round(o):o;return r.clampValue(s,n,i,t)}:a===`boolean`?E:e=>e}static replaceTreeValue(e,t,n){let i=r.buildFromValue(t,n).toComputeFormat(),a=e.slice(),o=a.findIndex(e=>r.paramNameOf(e)===t);return o===-1?a.push(i):a[o]=i,a}static buildFromValue(e,t){let n=new r(e);return C(t)?n.fromDataTreeDefault(t):n.appendFlat(t),n}static getTree(t,n){let i=t.find(e=>r.paramNameOf(e)===n);if(!i)return null;let a=/* @__PURE__ */ new Map,o=e(i,`InnerTree`);if(!o||typeof o!=`object`)return a;for(let[e,t]of Object.entries(o))Array.isArray(t)&&a.set(e,t.map(e=>e?.data===void 0?null:r.deserializeValue(e.data)));return a}static getTreeValue(e,i){let a=r.getTree(e,i);if(!a||a.size===0)return null;if(a.size>1)throw new t(`"${i}" has ${a.size} branches; read it with TreeBuilder.getTree`,n.INVALID_INPUT,{context:{paramName:i,branchCount:a.size}});let[o]=a.values();return o.length===0?null:o.length===1?o[0]:o}static paramNameOf(t){return e(t,`ParamName`)}static parsePathString(e){let r=e.match(S);if(!r)throw new t(`Invalid Grasshopper tree path: "${e}". Expected "{}", "{0}", or "{0;1;2}" (negative indices allowed, no empty segments).`,n.INVALID_INPUT,{context:{pathStr:e}});return r[1]?r[1].split(`;`).map(Number):[]}static formatPathString(e){return`{${e.join(`;`)}}`}static serializeValue(e){return typeof e==`boolean`||typeof e==`number`||typeof e==`string`?e:typeof e==`object`&&e?JSON.stringify(e):String(e)}static deserializeValue(e){if(typeof e!=`string`)return e;if(e.startsWith(`{`)||e.startsWith(`[`))try{return JSON.parse(e)}catch{return e}let t=Number(e);return Number.isFinite(t)&&String(t)===e?t:e===`true`||e!==`false`&&e}static hasValidValue(e){return e==null?!1:typeof e==`string`||!(Array.isArray(e)&&e.length===0||typeof e==`object`&&!Array.isArray(e)&&Object.keys(e).length===0)}static clampValue(e,t,n,r){let a=e;return t!=null&&a<t&&(i().warn(`${r}: ${e} below min ${t}, clamping`),a=t),n!=null&&a>n&&(i().warn(`${r}: ${e} above max ${n}, clamping`),a=n),a}};export{g as ComputeServerStats,Ge as GrasshopperClient,ot as GrasshopperResponseProcessor,He as SolveScheduler,mt as TreeBuilder,Je as disposeRhinoObjects,R as fetchDefinitionIO,B as fetchParsedDefinitionIO,G as hashDefinition,Le as hashSolveInput,Ke as isRhinoDecodeError,ft as normalizeUISchemaCasing,ke as processInput,st as readSchemaResults,le as solveGrasshopperDefinition,U as stableStringify};
+import { A as readField, C as withJsonContentType, D as tryParseJson, E as validateServerUrl, F as ErrorCodes, I as abortedByCaller, L as sleep, M as getLogger, O as redactUrl, P as ComputeError, S as buildAuthHeaders, _ as readBodyText, b as detectBase64Payload, c as isDefinitionUrl, d as classifyProbeFailure, f as isRedirect, g as raceSignal, h as composeSignal, i as isBase64Flag, k as hasField, l as fetchCompute, m as setResponseWireSize, p as getResponseWireSize, s as isDefinitionRef, t as downloadFileData, u as validateNumbers, v as base64ByteArray, w as warnIfClientSide, x as encodeStringToBase64 } from "./handle-files-fKtSlWT2.js";
+// src/grasshopper/server/compute-server-stats.ts
+/**
+* Server health and control: liveness, version, child processes, cache purges.
+*
+* @example
+* ```typescript
+* const stats = new ComputeServerStats('http://localhost:6500', 'your-api-key');
+*
+* try {
+*   const isOnline = await stats.isServerOnline();
+*   const children = await stats.getActiveChildren();
+*   const version = await stats.getVersion();
+*
+*   // Or get everything at once
+*   const allStats = await stats.getServerStats();
+* } finally {
+*   await stats.dispose(); // Clean up resources
+* }
+* ```
+*/
+var ComputeServerStats = class ComputeServerStats {
+	serverUrl;
+	headers;
+	disposed = false;
+	activeMonitors = /* @__PURE__ */ new Set();
+	/** Timeout (ms) for the fast read/monitoring endpoints. */
+	static DEFAULT_TIMEOUT_MS = 5e3;
+	/** Timeout (ms) for child-lifecycle POSTs — a cold Windows child can take ~30s to spawn. */
+	static LIFECYCLE_TIMEOUT_MS = 6e4;
+	/** Floor for `monitor()`'s `intervalMs` — anything lower hot-loops the server. */
+	static MIN_MONITOR_INTERVAL_MS = 100;
+	/** Every control-plane answer is a count, a version or a short map. */
+	static MAX_BODY_BYTES = 1 << 20;
+	/**
+	* @param serverUrl - Base URL of the Rhino Compute server with http:// or https:// scheme (e.g., 'http://localhost:6500')
+	* @param auth - An API key, or the same auth fields a solve's `ComputeConfig` carries
+	*   (`apiKey`, `apiKeyHeader`, `authToken`, `headers`).
+	*/
+	constructor(serverUrl, auth) {
+		this.serverUrl = validateServerUrl(serverUrl);
+		this.headers = buildAuthHeaders(typeof auth === "string" ? { apiKey: auth } : auth ?? {});
+	}
+	/**
+	* Aborts after `timeoutMs` so a hung connection can't stall a probe or `monitor()`; `0` disables
+	* it. Redirects are not followed: fetch would carry the API key header to the target.
+	*/
+	async fetchWithTimeout(url, init = {}, timeoutMs = ComputeServerStats.DEFAULT_TIMEOUT_MS) {
+		const { signal, cleanup } = composeSignal(init.signal ?? void 0, timeoutMs);
+		try {
+			return await fetch(url, {
+				...init,
+				headers: init.method === "POST" ? withJsonContentType(this.headers) : this.headers,
+				redirect: "manual",
+				signal
+			});
+		} finally {
+			cleanup();
+		}
+	}
+	/**
+	* The response body of `path`, or `null` (logged) on a non-2xx or a network
+	* failure. Throws only when disposed.
+	*/
+	async getText(path, init = {}, timeoutMs = ComputeServerStats.DEFAULT_TIMEOUT_MS) {
+		this.ensureNotDisposed();
+		const label = `${init.method ?? "GET"} ${path}`;
+		try {
+			const response = await this.fetchWithTimeout(`${this.serverUrl}${path}`, init, timeoutMs);
+			if (!response.ok) {
+				getLogger().warn(`[ComputeServerStats] ${label} failed:`, response.status);
+				await response.body?.cancel().catch(() => {});
+				return null;
+			}
+			const { text, truncated } = await readBodyText(response, ComputeServerStats.MAX_BODY_BYTES);
+			if (truncated) {
+				getLogger().warn(`[ComputeServerStats] ${label} answered with an oversized body`);
+				return null;
+			}
+			return text;
+		} catch (err) {
+			getLogger().warn(`[ComputeServerStats] ${label} errored:`, err);
+			return null;
+		}
+	}
+	/**
+	* Check if the server is online.
+	*
+	* This is a single-sample probe: it returns `true` only on a 2xx or a redirect
+	* from the proxy liveness root `/`, and `false` for every other outcome (4xx/5xx,
+	* network error, or timeout). A cold or briefly-busy-but-up server can therefore
+	* read as offline — callers that gate on this (e.g. client construction)
+	* should retry rather than treat a single `false` as authoritative.
+	*
+	* @param timeoutMs - Abort the probe after this many ms (default: 5000).
+	*   Pass `0` to disable the timeout. Prevents a hung connection from
+	*   stalling the caller indefinitely.
+	*/
+	async isServerOnline(timeoutMs = ComputeServerStats.DEFAULT_TIMEOUT_MS) {
+		return (await this.probeServer(timeoutMs)).online;
+	}
+	/**
+	* Detailed liveness probe backing {@link isServerOnline}.
+	*
+	* Reports what the probe actually saw so callers can distinguish "connection
+	* failed" (`error` set) from "server answered non-2xx" (`status` set) — e.g.
+	* a 401 from a proxy that requires an API key is a misconfiguration, not an
+	* offline server. Same single-sample caveat as {@link isServerOnline}.
+	*
+	* @param timeoutMs - Abort the probe after this many ms (default: 5000).
+	*   Pass `0` to disable the timeout.
+	* @param signal - Cancels the probe, which then reports the abort as its `error`.
+	* @returns `online` plus either the HTTP `status` the server answered with,
+	*   or the `error` the connection attempt failed with.
+	*/
+	async probeServer(timeoutMs = ComputeServerStats.DEFAULT_TIMEOUT_MS, signal) {
+		this.ensureNotDisposed();
+		const url = `${this.serverUrl}/`;
+		try {
+			const response = await this.fetchWithTimeout(url, {
+				method: "GET",
+				signal
+			}, timeoutMs);
+			await response.body?.cancel().catch(() => {});
+			return {
+				online: response.ok || isRedirect(response),
+				status: response.status
+			};
+		} catch (err) {
+			const error = describeProbeError(err);
+			getLogger().debug(`[ComputeServerStats] Fetch error: ${error}`);
+			return {
+				online: false,
+				error
+			};
+		}
+	}
+	/**
+	* Get the number of active child processes on the server.
+	*
+	* By default the proxy's `/activechildren` endpoint will *spawn* children up
+	* to the configured count if none are running, then report the count — which
+	* wakes (and bills) an idle server. Pass `{ initialize: false }` for a passive
+	* read that reports the current count without spawning; use this for
+	* monitoring or before a purge/probe where you must not wake the server.
+	*
+	* @param options.initialize - When `false`, append `?initialize=false` so the
+	*   server reports without spawning. Defaults to `true` (the server's default).
+	* @returns Number of active children, or null if unavailable
+	*/
+	async getActiveChildren(options = {}) {
+		const { initialize = true } = options;
+		const body = initialize ? await this.getText("/activechildren", {}, ComputeServerStats.LIFECYCLE_TIMEOUT_MS) : await this.getText("/activechildren?initialize=false");
+		if (body === null) return null;
+		const text = body.trim();
+		if (!/^\d+$/.test(text)) {
+			getLogger().warn("[ComputeServerStats] /activechildren answered with a non-numeric body");
+			return null;
+		}
+		return parseInt(text, 10);
+	}
+	/**
+	* Get the server version information.
+	*
+	* @returns Version object with rhino, compute, and git_sha, or null if unavailable
+	*/
+	async getVersion() {
+		const text = await this.getText("/version");
+		if (text === null) return null;
+		const json = tryParseJson(text);
+		if (json == null) return {
+			rhino: text,
+			compute: "",
+			git_sha: null
+		};
+		return {
+			rhino: json.rhino ?? "",
+			compute: json.compute ?? "",
+			git_sha: json.git_sha ?? null
+		};
+	}
+	/**
+	* Get the plugins installed on the server.
+	*
+	* Returns a `name → version` map of non-core plugins the server has loaded,
+	* or `null` if the request failed. Pass `kind` to choose which inventory:
+	* `'gh'` (default) lists Grasshopper add-on assemblies via
+	* `/plugins/gh/installed`; `'rhino'` lists Rhino plugins via
+	* `/plugins/rhino/installed`. Plugins that ship with Rhino / are core
+	* libraries are excluded by the server.
+	*
+	* @param kind - `'gh'` for Grasshopper add-ons (default) or `'rhino'` for Rhino plugins.
+	* @returns Map of plugin name to version, or `null` on failure.
+	*
+	* @example
+	* ```ts
+	* const gh = await stats.getInstalledPlugins();        // Grasshopper add-ons
+	* const selvaVersion = gh?.['Selva'] ?? null;
+	* ```
+	*/
+	async getInstalledPlugins(kind = "gh") {
+		const text = await this.getText(`/plugins/${kind}/installed`);
+		const json = text === null ? void 0 : tryParseJson(text);
+		return json && typeof json === "object" ? json : null;
+	}
+	/**
+	* Get comprehensive server statistics.
+	* Fetches all available server information in parallel.
+	*
+	* @returns Object containing server status and available stats
+	*/
+	async getServerStats() {
+		this.ensureNotDisposed();
+		if (!await this.isServerOnline()) return { isOnline: false };
+		const [version, activeChildren] = await Promise.all([this.getVersion(), this.getActiveChildren({ initialize: false })]);
+		return {
+			isOnline: true,
+			...version && { version },
+			...activeChildren !== null && { activeChildren }
+		};
+	}
+	/**
+	* Purge the server's solve-results / URL-data cache.
+	*
+	* POSTs to `cache/purge` and returns the number of entries removed, or `null`
+	* if the request failed. This clears cached solve responses and fetched
+	* definition-URL data; it does NOT evict the definition cache (active
+	* `pointer` references stay valid).
+	*
+	* **Caveat:** `cache/purge` is forwarded by the rhino.compute proxy to a
+	* single round-robin-selected child, so in a multi-child deployment one call
+	* purges one child's cache. Call repeatedly (or size the pool to 1) if you
+	* need a fleet-wide purge.
+	*
+	* @returns Number of entries removed, or `null` on failure.
+	*
+	* @example
+	* ```ts
+	* const removed = await stats.purgeCache();
+	* if (removed !== null) console.log(`Purged ${removed} cached solves`);
+	* ```
+	*/
+	async purgeCache() {
+		const text = await this.getText("/cache/purge", { method: "POST" });
+		const purged = (text === null ? void 0 : tryParseJson(text))?.purged;
+		return typeof purged === "number" ? purged : null;
+	}
+	/**
+	* Best-effort fleet-wide cache purge across a multi-child deployment.
+	*
+	* A single {@link purgeCache} POST is forwarded by the rhino.compute proxy to
+	* just ONE round-robin-selected child, so the other children keep serving
+	* stale cached solves. There is no proxy endpoint that addresses children
+	* individually, so this method reads the active child count (passively, never
+	* spawning) and fires `2 × count` sequential purges, relying on the proxy's
+	* round-robin to spread the hits across the pool.
+	*
+	* **This is best-effort, not a guarantee.** Round-robin can revisit one child
+	* and skip another; under concurrent traffic the rotation drifts. The result's
+	* `confident` flag is `true` only when the server reports a single child (where
+	* one purge is exact) — surface it so callers don't over-promise. For a hard
+	* fleet-wide guarantee, run the deployment at `--childcount 1` or add a
+	* server-side fan-out endpoint.
+	*
+	* @returns `{ totalPurged, calls, children, confident }`, or `null` if the
+	*   child count couldn't be read (server unreachable). `totalPurged` sums the
+	*   per-call counts; `calls` is how many purges were issued; `children` is the
+	*   reported pool size; `confident` is `true` only at a single-child pool.
+	*
+	* @example
+	* ```ts
+	* const r = await stats.purgeAllChildren();
+	* if (r && !r.confident) {
+	*   console.warn(`Purged ~${r.totalPurged} across ${r.children} children (best-effort)`);
+	* }
+	* ```
+	*/
+	async purgeAllChildren() {
+		this.ensureNotDisposed();
+		const children = await this.getActiveChildren({ initialize: false });
+		if (children === null) {
+			getLogger().warn("[ComputeServerStats] purgeAllChildren: could not read child count");
+			return null;
+		}
+		if (children === 0) return {
+			totalPurged: 0,
+			calls: 0,
+			children: 0,
+			confident: true
+		};
+		const calls = children * 2;
+		let totalPurged = 0;
+		for (let i = 0; i < calls; i++) {
+			const purged = await this.purgeCache();
+			if (purged !== null) totalPurged += purged;
+		}
+		return {
+			totalPurged,
+			calls,
+			children,
+			confident: children === 1
+		};
+	}
+	/**
+	* Get the server's current UTC clock.
+	*
+	* GETs `/servertime`, which the server emits as a JSON-encoded ISO-8601
+	* timestamp (e.g. `"2026-06-18T08:30:00Z"`). Useful for detecting clock skew
+	* between caller and server. Returns `null` if the request failed or the body
+	* isn't a parseable date.
+	*
+	* @returns A `Date` for the server's UTC time, or `null` on failure.
+	*/
+	async getServerTime() {
+		const text = await this.getText("/servertime");
+		if (text === null) return null;
+		const date = new Date(text.trim().replace(/^"|"$/g, ""));
+		return isNaN(date.getTime()) ? null : date;
+	}
+	/**
+	* Get how long the rhino.compute proxy has been idle.
+	*
+	* GETs `/idlespan` on the proxy, which returns the seconds elapsed since the
+	* last request was forwarded to a compute child. This is a proxy-level metric
+	* (not proxied to a child) used by autoscalers to decide when a node can be
+	* drained. Returns `null` if unavailable.
+	*
+	* @returns Idle time in seconds, or `null` on failure.
+	*/
+	async getIdleSpan() {
+		const text = await this.getText("/idlespan");
+		if (text === null) return null;
+		const seconds = parseFloat(text.trim());
+		return isNaN(seconds) ? null : seconds;
+	}
+	/**
+	* Fill the compute child pool up to the server's configured baseline.
+	*
+	* POSTs `/launch-children`. No-op when the pool is already at or above the
+	* configured `--childcount`. Returns `{ spawned, active }` — how many children
+	* were started and the resulting child count — or `null` on failure.
+	*
+	* To raise capacity above the baseline use {@link launchChild}; the baseline
+	* itself can only be changed by restarting rhino.compute.
+	*
+	* @returns `{ spawned, active }`, or `null` on failure.
+	*/
+	async launchChildren() {
+		return this.postJson("/launch-children");
+	}
+	/**
+	* Add a single compute child to the pool, optionally on a specific port.
+	*
+	* POSTs `/launch-child` (with `?port=N` when `port` is given). Unlike
+	* {@link launchChildren}, this can push the pool above the baseline, up to the
+	* server's `MaxChildren` cap. Returns `{ spawned: [port] }` on success, or
+	* `null` on failure (server replies 400 for a bad port, 409 if the port is in
+	* use, 503 at the max-children cap).
+	*
+	* @param port - Optional specific port to launch on; otherwise the next free one.
+	* @returns `{ spawned }` listing the launched port, or `null` on failure.
+	*/
+	async launchChild(port) {
+		const path = port === void 0 ? "/launch-child" : `/launch-child?port=${port}`;
+		return this.postJson(path);
+	}
+	/**
+	* Gracefully shut down compute children without respawning them.
+	*
+	* POSTs `/shutdown-children`. With no `port` it shuts down every child; with
+	* `port` it targets just that one. Children do not respawn, but the next
+	* `/grasshopper` request auto-spawns the pool back to the baseline. Returns
+	* `{ shutdown, active }` — how many were stopped and the remaining count — or
+	* `null` on failure.
+	*
+	* @param port - Optional port to target; omit to shut down all children.
+	* @returns `{ shutdown, active }`, or `null` on failure.
+	*/
+	async shutdownChildren(port) {
+		const path = port === void 0 ? "/shutdown-children" : `/shutdown-children?port=${port}`;
+		return this.postJson(path);
+	}
+	/**
+	* Shut down compute children and respawn replacements (rolling restart).
+	*
+	* POSTs `/recycle-children`. With no `port` it recycles every child; with
+	* `port` it recycles just that one. The server recycles sequentially (each
+	* replacement is serving before the next child is stopped) so the pool never
+	* drops to zero mid-recycle. Returns `{ shutdown, spawned, active }`, or
+	* `null` on failure.
+	*
+	* @param port - Optional port to target; omit to recycle all children.
+	* @returns `{ shutdown, spawned, active }`, or `null` on failure.
+	*/
+	async recycleChildren(port) {
+		const path = port === void 0 ? "/recycle-children" : `/recycle-children?port=${port}`;
+		return this.postJson(path);
+	}
+	/** A child-lifecycle POST: a spawn or recycle can take ~30 s. */
+	async postJson(path) {
+		const text = await this.getText(path, { method: "POST" }, ComputeServerStats.LIFECYCLE_TIMEOUT_MS);
+		return text === null ? null : tryParseJson(text) ?? null;
+	}
+	/**
+	* Continuously monitor server stats at specified interval.
+	*
+	* @param callback - Function called with stats on each interval
+	* @param intervalMs - Milliseconds between checks (default: 5000). Must be a
+	*   finite number of at least 100 ms — lower values would hot-loop the server.
+	* @returns Function to stop monitoring
+	* @throws {ComputeError} `INVALID_CONFIG` if `intervalMs` is not a finite number >= 100.
+	*
+	* @example
+	* ```typescript
+	* const stopMonitoring = stats.monitor((data) => {
+	*   console.log('Server stats:', data);
+	* }, 3000);
+	*
+	* // Later...
+	* stopMonitoring();
+	* ```
+	*/
+	monitor(callback, intervalMs = 5e3) {
+		this.ensureNotDisposed();
+		if (!Number.isFinite(intervalMs) || intervalMs < ComputeServerStats.MIN_MONITOR_INTERVAL_MS) throw new ComputeError(`monitor() intervalMs must be a finite number >= ${ComputeServerStats.MIN_MONITOR_INTERVAL_MS}ms, got ${intervalMs}. Sub-${ComputeServerStats.MIN_MONITOR_INTERVAL_MS}ms polling would hot-loop the server.`, ErrorCodes.INVALID_CONFIG, { context: { intervalMs } });
+		let active = true;
+		let currentTimeoutId = null;
+		getLogger().info(`🔄 Starting server stats monitoring every ${intervalMs}ms`);
+		const check = async () => {
+			currentTimeoutId = null;
+			if (!active || this.disposed) return;
+			try {
+				const _stats = await this.getServerStats();
+				if (!active || this.disposed) return;
+				try {
+					callback(_stats);
+				} catch (err) {
+					getLogger().error("[ComputeServerStats] Monitor callback threw:", err);
+				}
+			} catch (err) {
+				if (!active || this.disposed) getLogger().debug("[ComputeServerStats] Monitor poll cancelled during shutdown:", err);
+				else getLogger().error("[ComputeServerStats] Failed to fetch stats during monitor:", err);
+			}
+			if (active && !this.disposed) currentTimeoutId = setTimeout(() => void check(), intervalMs);
+		};
+		const stopMonitoring = () => {
+			active = false;
+			if (currentTimeoutId !== null) {
+				clearTimeout(currentTimeoutId);
+				currentTimeoutId = null;
+			}
+			this.activeMonitors.delete(stopMonitoring);
+		};
+		this.activeMonitors.add(stopMonitoring);
+		check();
+		return stopMonitoring;
+	}
+	/**
+	* Disposes of all resources and stops all active monitors.
+	* Call this when you're done using the stats instance.
+	*/
+	async dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		for (const stopMonitor of this.activeMonitors) stopMonitor();
+		this.activeMonitors.clear();
+	}
+	ensureNotDisposed() {
+		if (this.disposed) throw new ComputeError("ComputeServerStats has been disposed and cannot be used", ErrorCodes.INVALID_STATE);
+	}
+};
+/**
+* undici reports every connection failure as `TypeError: fetch failed` and keeps what happened on
+* `cause`, whose message is empty when several addresses failed: its `code` is the one sure field.
+*/
+function describeProbeError(err) {
+	if (!(err instanceof Error)) return String(err);
+	const summary = `${err.name}: ${err.message}`;
+	if (!(err.cause instanceof Error)) return summary;
+	const { code } = err.cause;
+	return `${summary}: ${typeof code === "string" ? `${code} ` : ""}${err.cause.message}`.trim();
+}
+// src/grasshopper/solve.ts
+/**
+* Server message for a `pointer` it can't resolve (evicted, or a different child in the pool).
+* Production servers scrub it, so the `definition_not_cached` code is the reliable signal; this
+* substring covers debug-mode servers and forks that emit no code.
+*/
+const DEFINITION_LOAD_FAILED = "Unable to load grasshopper definition";
+/** `core/` knows no backend's wire codes, so every Grasshopper request passes these in. */
+const GRASSHOPPER_SERVER_ERROR_CODES = { definition_not_cached: ErrorCodes.DEFINITION_NOT_CACHED };
+/** Attach the Grasshopper wire-code table without clobbering a caller's own entries. */
+function withGrasshopperErrorCodes(config) {
+	return {
+		...config,
+		serverErrorCodes: {
+			...GRASSHOPPER_SERVER_ERROR_CODES,
+			...config.serverErrorCodes
+		}
+	};
+}
+function isDefinitionLoadMiss(error) {
+	if (!(error instanceof ComputeError)) return false;
+	return error.code === ErrorCodes.DEFINITION_NOT_CACHED || error.message.includes(DEFINITION_LOAD_FAILED);
+}
+/**
+* Debug-only: names the outputs that produced nothing, usually a definition that didn't compute
+* (missing inputs, a guarded branch). An empty output can be legitimate, so this only warns.
+*/
+function warnOnEmptyInnerTrees(response, debug) {
+	if (!debug) return;
+	const values = readField(response, "values");
+	if (!Array.isArray(values) || values.length === 0) return;
+	const empty = [];
+	for (const param of values) {
+		const innerTree = readField(param, "innerTree");
+		if (!innerTree || Object.keys(innerTree).length === 0) empty.push(readField(param, "paramName") ?? "<unnamed>");
+	}
+	if (empty.length === 0) return;
+	const scope = empty.length === values.length ? "all" : `${empty.length}/${values.length}`;
+	getLogger().warn(`Solve returned empty output(s) (${scope}): ${empty.join(", ")}. These parameters produced no data — check the definition's inputs and the branch feeding each.`);
+}
+/**
+* Run one solve. `GrasshopperClient.solve()` adds input validation and throws on solver errors.
+*
+* @param definition - A URL (sent as a pointer), base64 `.gh` content, raw `.gh` bytes, or a
+*   `DefinitionRef` (loaded for the upload). Any other string is encoded as the definition text.
+* @returns The compute response, without the server's `pointer` and echoed `algo`.
+*
+* @example
+* await solveGrasshopperDefinition(trees, 'https://example.com/definition.gh', config);
+* await solveGrasshopperDefinition(trees, new Uint8Array(await readFile('model.gh')), config);
+*/
+async function solveGrasshopperDefinition(dataTree, definition, config) {
+	warnIfClientSide("solveGrasshopperDefinition", config.suppressBrowserWarning);
+	validateServerUrl(config.serverUrl);
+	return (await uploadAndSolve(dataTree, definition, config)).response;
+}
+/**
+* Solve by `pointer: cacheKey` when a key is known, skipping the upload. With no key, or when the
+* server has evicted it, upload the full definition and report `missed: true`. A `DefinitionRef`
+* is loaded only on that upload path.
+*/
+async function solveWithServerCacheKey(dataTree, cacheKey, definition, config) {
+	warnIfClientSide("solveWithServerCacheKey", config.suppressBrowserWarning);
+	if (cacheKey !== null) try {
+		return {
+			...await runSolve({
+				algo: null,
+				pointer: cacheKey,
+				values: dataTree
+			}, config),
+			missed: false
+		};
+	} catch (error) {
+		if (!isDefinitionLoadMiss(error)) throw error;
+	}
+	return {
+		...await uploadAndSolve(dataTree, definition, config),
+		missed: true
+	};
+}
+async function uploadAndSolve(dataTree, definition, config) {
+	return runSolve(prepareGrasshopperArgs(await materializeDefinition(definition, config), dataTree), config);
+}
+async function materializeDefinition(definition, config) {
+	if (!isDefinitionRef(definition)) return definition;
+	validateNumbers(config);
+	const { signal, cleanup } = composeSignal(config.signal, config.timeoutMs);
+	try {
+		return await raceSignal(definition.load(signal), signal);
+	} catch (error) {
+		if (config.signal?.aborted) throw abortedByCaller({ definitionKey: definition.key }, error);
+		if (signal?.aborted) throw new ComputeError(`Loading definition '${definition.key}' timed out after ${config.timeoutMs}ms`, ErrorCodes.TIMEOUT_ERROR, { context: {
+			definitionKey: definition.key,
+			timeoutMs: config.timeoutMs
+		} });
+		throw new ComputeError(`Failed to load definition bytes for ref '${definition.key}'`, ErrorCodes.INVALID_INPUT, {
+			context: { definitionKey: definition.key },
+			originalError: error
+		});
+	} finally {
+		cleanup();
+	}
+}
+/**
+* POST a solve and split the server's `pointer` off the response. The server echoes the request's
+* base64 definition back as `algo`; it is dropped so a cached response doesn't pin a multi-MB copy
+* of the definition against the scheduler's byte budget.
+*/
+async function runSolve(args, config) {
+	applyOptionalComputeSettings(args, config);
+	const { maxResponseBytes } = config;
+	const result = await fetchCompute("grasshopper", args, withGrasshopperErrorCodes({
+		...config,
+		maxResponseBytes: maxResponseBytes !== void 0 && args.algo ? maxResponseBytes + args.algo.length : maxResponseBytes
+	}));
+	assertResponseObject(result);
+	const { pointer, algo: _algo, ...rest } = result;
+	const response = readField(rest, "values") ? rest : {
+		...rest,
+		values: []
+	};
+	const wireSize = getResponseWireSize(result);
+	if (wireSize !== void 0) {
+		const algoLength = typeof _algo === "string" ? _algo.length : 0;
+		setResponseWireSize(response, Math.max(0, wireSize - algoLength));
+	}
+	warnOnEmptyInnerTrees(response, config.debug);
+	return {
+		response,
+		cacheKey: typeof pointer === "string" ? pointer : null
+	};
+}
+/** A 200 can carry valid JSON that isn't an object: `null` from a proxy, or a bare string. */
+function assertResponseObject(response) {
+	if (!response || typeof response !== "object") throw new ComputeError("Invalid response structure", ErrorCodes.INVALID_RESPONSE, { context: { responseType: response === null ? "null" : typeof response } });
+}
+function prepareGrasshopperArgs(definition, dataTree) {
+	const args = {
+		algo: null,
+		pointer: null,
+		values: dataTree
+	};
+	if (definition instanceof Uint8Array) args.algo = base64ByteArray(definition);
+	else if (isDefinitionUrl(definition)) args.pointer = definition;
+	else args.algo = detectBase64Payload(definition) ?? encodeStringToBase64(definition);
+	return args;
+}
+function applyOptionalComputeSettings(arglist, options) {
+	if (options.cachesolve != null) arglist.cachesolve = options.cachesolve;
+	if (options.modelunits != null) arglist.modelunits = options.modelunits;
+	if (options.angletolerance != null) arglist.angletolerance = options.angletolerance;
+	if (options.absolutetolerance != null) arglist.absolutetolerance = options.absolutetolerance;
+	if (options.dataversion != null) arglist.dataversion = options.dataversion;
+	if (options.selvaevents != null) arglist.selvaevents = options.selvaevents;
+}
+// src/core/utils/set-own-field.ts
+/**
+* `obj[key] = value` for a key taken from a wire payload. Assigning `__proto__` would call the
+* prototype setter and swap the object's prototype instead of storing the value.
+*/
+function setOwnField(obj, key, value) {
+	if (key === "__proto__") Object.defineProperty(obj, key, {
+		value,
+		writable: true,
+		enumerable: true,
+		configurable: true
+	});
+	else obj[key] = value;
+}
+// src/grasshopper/data-tree/tree-path.ts
+/**
+* Canonical matcher for a Grasshopper branch path key like `{0}`, `{0;1}`, or
+* the root path `{}`. This is the single source of truth for the branch-path
+* shape (`DataTreePath`); anything testing "does this string name a branch?"
+* should use this rather than re-inlining the regex.
+*
+* Matches `{}`, `{0}`, `{0;1;2}`, and negative indices like `{-1;2}` (GH_Path
+* allows them) — but NOT empty segments like `{0;}` / `{;}` / `{0;;1}`, which
+* would otherwise split to phantom 0s (`Number('') === 0`).
+*/
+const TREE_PATH_RE = /^\{(-?\d+(?:;-?\d+)*)?\}$/;
+/**
+* Membership test for a {@link DataTreeDefault}: an object keyed entirely by
+* branch paths, each mapping to an array of values. This is the one predicate
+* both the input-type parsers (to pass a tree-access default through untouched)
+* and `TreeBuilder` (to dispatch it to `fromDataTreeDefault`) ask — so the two
+* agree by construction on exactly which values are trees.
+*/
+function isDataTreeDefault(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const entries = Object.entries(value);
+	return entries.length > 0 && entries.every(([key, val]) => TREE_PATH_RE.test(key) && Array.isArray(val));
+}
+/** Every numeric CLR type Grasshopper serializes, so no numeric item stays a string. */
+const NUMERIC_ITEM_TYPES = /* @__PURE__ */ new Set([
+	"System.Double",
+	"System.Single",
+	"System.Decimal",
+	"System.Int32",
+	"System.Int64"
+]);
+/** Integral wire item types: rounded like the scalar Integer path. */
+const INTEGER_ITEM_TYPES = /* @__PURE__ */ new Set(["System.Int32", "System.Int64"]);
+// src/grasshopper/io/input/transformers.ts
+/**
+* Coerce a schema's `default`: array items are transformed and the rejected ones
+* filtered (none left → `undefined`); a rejected scalar becomes `undefined` when
+* `dropInvalidScalar`, else is kept verbatim for the parser to report.
+*/
+function coerceDefault(value, transform, dropInvalidScalar) {
+	if (value === void 0 || value === null) return value;
+	if (Array.isArray(value)) {
+		const processed = value.map(transform).filter((v) => v !== null);
+		return processed.length > 0 ? processed : void 0;
+	}
+	const transformed = transform(value);
+	if (transformed !== null) return transformed;
+	return dropInvalidScalar ? void 0 : value;
+}
+const numericTransformer = (value) => {
+	if (typeof value === "number") return Number.isFinite(value) ? value : null;
+	if (typeof value === "string") {
+		const trimmed = value.trim();
+		if (trimmed === "") return null;
+		if (/^[+-]?0[xbo]/i.test(trimmed)) return null;
+		const parsed = Number(trimmed);
+		return Number.isFinite(parsed) ? parsed : null;
+	}
+	return null;
+};
+const booleanTransformer = (value) => {
+	if (typeof value === "boolean") return value;
+	if (typeof value === "string") {
+		const lower = value.trim().toLowerCase();
+		if (lower === "true") return true;
+		if (lower === "false") return false;
+	}
+	return null;
+};
+const textTransformer = (value) => {
+	if (typeof value === "string") {
+		if (value.length >= 2 && value.startsWith("\"") && value.endsWith("\"")) return value.slice(1, -1);
+		if (value.startsWith("\"")) return value.slice(1);
+		return value;
+	}
+	return null;
+};
+const colorTransformer = (value) => {
+	if (typeof value === "string") {
+		let cleaned = value.trim();
+		if (cleaned.startsWith("\"") && cleaned.endsWith("\"")) cleaned = cleaned.slice(1, -1).trim();
+		return cleaned;
+	}
+	return null;
+};
+function objectTransformer(inputName) {
+	return (value) => {
+		if (typeof value === "object" && value !== null) return value;
+		if (typeof value === "string" && value.trim() !== "") try {
+			const parsed = JSON.parse(value);
+			if (typeof parsed === "object" && parsed !== null) return parsed;
+			getLogger().warn(`Parsed value for input ${inputName} is not an object`);
+			return null;
+		} catch {
+			getLogger().warn(`Failed to parse the object value for input ${inputName}`);
+			return null;
+		}
+		return null;
+	};
+}
+// src/grasshopper/io/input/normalize-default.ts
+function dropDefault(input, message) {
+	getLogger().warn(message);
+	return {
+		schema: {
+			...input,
+			default: null
+		},
+		warning: {
+			code: ErrorCodes.MALFORMED_DEFAULT,
+			message
+		}
+	};
+}
+/**
+* Flatten a raw input's `default` DataTree into the shape the type parsers take.
+* Never mutates `input`. A default it can't interpret is dropped with a `warning`.
+*/
+function normalizeDefault(input, label) {
+	if (typeof input.default !== "object" || input.default === null) return { schema: input };
+	if (Array.isArray(input.default) || isDataTreeDefault(input.default)) return { schema: input };
+	if (!hasField(input.default, "innerTree")) return dropDefault(input, `Input "${label}" default had an unrecognized shape (no innerTree key); the default was dropped.`);
+	const innerTree = readField(input.default, "innerTree") ?? {};
+	if (Object.keys(innerTree).length === 0) return { schema: {
+		...input,
+		default: void 0
+	} };
+	if (input.treeAccess || input.atMost && input.atMost > 1) {
+		const tree = {};
+		const invalidItems = [];
+		for (const [branch, items] of Object.entries(innerTree)) {
+			if (!Array.isArray(items)) return dropDefault(input, `Input "${label}" default had a non-array innerTree branch ("${branch}"); the default was dropped.`);
+			const parsed = [];
+			for (const item of items) {
+				const data = readField(item, "data");
+				const type = readField(item, "type");
+				if (type && NUMERIC_ITEM_TYPES.has(type)) {
+					if (typeof data === "string" && data.trim() === "") continue;
+					const num = numericTransformer(data);
+					if (num === null) {
+						invalidItems.push(`"${String(data)}" (${type})`);
+						continue;
+					}
+					parsed.push(INTEGER_ITEM_TYPES.has(type) ? Math.round(num) : num);
+					continue;
+				}
+				if (type === "System.Boolean") {
+					const bool = booleanTransformer(data);
+					if (bool === null) {
+						invalidItems.push(`"${String(data)}" (${type})`);
+						continue;
+					}
+					parsed.push(bool);
+					continue;
+				}
+				if (type === "System.String" && typeof data === "string") {
+					parsed.push(textTransformer(data));
+					continue;
+				}
+				if (typeof data === "string" && type?.startsWith("Rhino.Geometry")) {
+					try {
+						parsed.push(JSON.parse(data));
+					} catch {
+						parsed.push(data);
+					}
+					continue;
+				}
+				parsed.push(data);
+			}
+			setOwnField(tree, branch, parsed);
+		}
+		if (invalidItems.length > 0) {
+			const message = `Input "${label}" default contained ${invalidItems.length} tree value(s) that could not be parsed and were dropped: ${invalidItems.join(", ")}.`;
+			getLogger().warn(`Input "${label}" default: dropped ${invalidItems.length} tree value(s)`);
+			return {
+				schema: {
+					...input,
+					default: tree
+				},
+				warning: {
+					code: ErrorCodes.MALFORMED_DEFAULT,
+					message
+				}
+			};
+		}
+		return { schema: {
+			...input,
+			default: tree
+		} };
+	}
+	const allValues = [];
+	for (const items of Object.values(innerTree)) {
+		if (!Array.isArray(items)) continue;
+		for (const item of items) if (item && typeof item === "object" && hasField(item, "data")) allValues.push(readField(item, "data"));
+	}
+	return { schema: {
+		...input,
+		default: allValues.length > 1 ? allValues : allValues[0]
+	} };
+}
+// src/grasshopper/io/input/numeric-rounding.ts
+/** Snap float noise (`0.30000000000000004`) to `decimalPlaces`; a real difference is kept. */
+function applyRounding(value, decimalPlaces) {
+	const rounded = Number(value.toFixed(decimalPlaces));
+	return Math.abs(value - rounded) < 1e-8 ? rounded : value;
+}
+const MAX_DECIMALS = 12;
+const SIGNIFICANT_DIGITS = 15;
+/**
+* Decimal places `x` is written with, ignoring float noise, at most 12:
+* `0.30000000000000004` → 1, `16384.2` → 1, `1e-7` → 7, `1.5e21` → 0.
+*/
+function decimalsOf(x) {
+	if (!Number.isFinite(x)) return 0;
+	const clean = Number(Math.abs(x).toPrecision(SIGNIFICANT_DIGITS));
+	const [mantissa, exponent = "0"] = String(clean).split("e");
+	const decimals = (mantissa.split(".")[1]?.length ?? 0) - Number(exponent);
+	return Math.min(Math.max(decimals, 0), MAX_DECIMALS);
+}
+function getInputStepSize(value) {
+	if (!Number.isFinite(value) || value === 0) return .1;
+	const decimals = decimalsOf(value);
+	if (decimals === 0) return Math.abs(value) >= 1 ? 1 : .1;
+	return Number((10 ** -decimals).toFixed(decimals));
+}
+/** A server-authored `stepSize`, or `undefined` when absent or unusable. */
+function serverStepSize(schema) {
+	return typeof schema.stepSize === "number" && Number.isFinite(schema.stepSize) && schema.stepSize > 0 ? schema.stepSize : void 0;
+}
+// src/grasshopper/io/input/input-type-parsers.ts
+const labelOf = (schema) => schema.nickname || "unnamed";
+const listOr = (schema, value) => (schema.atMost ?? 1) > 1 ? [value] : value;
+const defaultStep = (schema) => serverStepSize(schema) ?? (schema.paramType === "Integer" ? 1 : .1);
+const mapNumbers = (value, fn) => Array.isArray(value) ? value.map((v) => typeof v === "number" ? fn(v) : v) : typeof value === "number" ? fn(value) : value;
+function computeNumeric(schema) {
+	if (isDataTreeDefault(schema.default)) return {
+		default: schema.default,
+		stepSize: defaultStep(schema)
+	};
+	if (typeof schema.default === "string" && schema.default.trim() !== "" && numericTransformer(schema.default) === null) throw new ComputeError(`Invalid numeric default "${schema.default}" for input "${schema.name || "unknown"}"`, ErrorCodes.VALIDATION_ERROR, { context: {
+		inputName: schema.name,
+		default: schema.default
+	} });
+	const value = coerceDefault(schema.default, numericTransformer, true);
+	if (schema.paramType === "Integer") return {
+		default: mapNumbers(value, Math.round),
+		stepSize: defaultStep(schema)
+	};
+	const firstValue = Array.isArray(value) ? value[0] : value;
+	const stepSource = [
+		firstValue,
+		schema.minimum,
+		schema.maximum
+	].find((v) => typeof v === "number" && Number.isFinite(v) && v !== 0);
+	const stepSize = serverStepSize(schema) ?? (stepSource !== void 0 ? getInputStepSize(stepSource) : .1);
+	let decimalPlaces = decimalsOf(stepSize);
+	if (decimalPlaces === 0 && typeof firstValue === "number" && firstValue !== 0 && Math.abs(firstValue) < 1) {
+		const inferred = Math.ceil(-Math.log10(Math.abs(firstValue)));
+		if (Number.isFinite(inferred) && inferred > 0) decimalPlaces = inferred;
+	}
+	decimalPlaces = Math.min(Math.max(decimalPlaces, 0), 12);
+	return {
+		default: mapNumbers(value, (n) => applyRounding(n, decimalPlaces)),
+		stepSize
+	};
+}
+const numericParam = (schema, base, computed) => ({
+	...base,
+	paramType: schema.paramType,
+	minimum: schema.minimum,
+	maximum: schema.maximum,
+	atLeast: schema.atLeast,
+	atMost: schema.atMost,
+	...computed
+});
+const numericParser = {
+	parse(schema, base) {
+		return numericParam(schema, base, computeNumeric(schema));
+	},
+	fallback(schema, base) {
+		const safeValue = typeof schema.minimum === "number" && Number.isFinite(schema.minimum) && schema.minimum > 0 ? schema.minimum : 0;
+		return numericParam(schema, base, {
+			stepSize: defaultStep(schema),
+			default: listOr(schema, safeValue)
+		});
+	}
+};
+const booleanParser = {
+	parse(schema, base) {
+		if (isDataTreeDefault(schema.default)) return {
+			...base,
+			paramType: "Boolean",
+			default: schema.default
+		};
+		const value = coerceDefault(schema.default, booleanTransformer, false);
+		if (value !== void 0 && value !== null && typeof value !== "boolean" && !Array.isArray(value)) throw new ComputeError(`Invalid boolean default "${String(value)}" for input "${schema.name || "unknown"}"`, ErrorCodes.VALIDATION_ERROR, { context: {
+			inputName: schema.name,
+			default: schema.default
+		} });
+		return {
+			...base,
+			paramType: "Boolean",
+			default: value
+		};
+	},
+	fallback(schema, base) {
+		return {
+			...base,
+			paramType: "Boolean",
+			default: listOr(schema, false)
+		};
+	}
+};
+const textParser = { parse(schema, base) {
+	const value = coerceDefault(schema.default, textTransformer, false);
+	return {
+		...base,
+		paramType: "Text",
+		default: value
+	};
+} };
+const valueListParser = {
+	parse(schema, base, warn) {
+		if (!schema.values || typeof schema.values !== "object" || Object.keys(schema.values).length === 0) {
+			const inputName = labelOf(schema);
+			throw new ComputeError(`Input "${inputName}" has no values defined (expected ValueList)`, ErrorCodes.INVALID_INPUT, { context: {
+				inputName,
+				expectedType: "ValueList"
+			} });
+		}
+		let defaultValue;
+		if (schema.default !== void 0 && schema.default !== null) {
+			if (typeof schema.default === "object") throw new ComputeError(`ValueList input "${labelOf(schema)}" default is not a string-able value`, ErrorCodes.VALIDATION_ERROR, { context: {
+				inputName: schema.name,
+				default: schema.default
+			} });
+			const defaultLower = String(schema.default).toLowerCase();
+			const match = Object.keys(schema.values).find((key) => key.toLowerCase() === defaultLower);
+			defaultValue = match ?? String(schema.default);
+			if (match === void 0) {
+				const inputName = labelOf(schema);
+				getLogger().warn(`ValueList input "${inputName}" default is not in available values`);
+				warn?.({
+					code: ErrorCodes.VALIDATION_ERROR,
+					message: `ValueList input "${inputName}" default value "${schema.default}" is not in available values`
+				});
+			}
+		}
+		return {
+			...base,
+			paramType: "ValueList",
+			values: schema.values,
+			default: defaultValue
+		};
+	},
+	fallback(schema, base) {
+		return {
+			...base,
+			paramType: "ValueList",
+			values: schema.values && typeof schema.values === "object" ? schema.values : {},
+			default: void 0
+		};
+	}
+};
+const objectDefault = (schema) => coerceDefault(schema.default, objectTransformer(labelOf(schema)), true);
+function geometryFallback(schema, base) {
+	return {
+		...base,
+		paramType: "Geometry",
+		default: listOr(schema, null)
+	};
+}
+/** Keyed by canonical paramType. */
+const INPUT_TYPE_PARSERS = /* @__PURE__ */ new Map([
+	["Number", numericParser],
+	["Integer", numericParser],
+	["Boolean", booleanParser],
+	["Text", textParser],
+	["ValueList", valueListParser],
+	["Geometry", {
+		parse(schema, base) {
+			return {
+				...base,
+				paramType: "Geometry",
+				default: objectDefault(schema)
+			};
+		},
+		fallback: geometryFallback
+	}],
+	["File", { parse(schema, base) {
+		return {
+			...base,
+			paramType: "File",
+			acceptedFormats: schema.acceptedFormats,
+			default: objectDefault(schema)
+		};
+	} }],
+	["Color", { parse(schema, base) {
+		const value = coerceDefault(schema.default, colorTransformer, false);
+		return {
+			...base,
+			paramType: "Color",
+			default: value
+		};
+	} }]
+]);
+const unknownTypeFallback = geometryFallback;
+// src/grasshopper/io/input/input-processors.ts
+const CANONICAL_PARAM_TYPES = new Map([...INPUT_TYPE_PARSERS.keys()].map((key) => [key.toLowerCase(), key]));
+/** An unknown paramType comes back unchanged, so its unknown-type error still surfaces. */
+function canonicalizeParamType(paramType) {
+	return CANONICAL_PARAM_TYPES.get(paramType?.toLowerCase()) ?? paramType;
+}
+/**
+* Parse one raw Grasshopper input schema into a typed {@link InputParam}.
+* A validation failure is swallowed and replaced with a safe default.
+*/
+function processInput(rawInput) {
+	return processInputWithError(rawInput).input;
+}
+/**
+* Like {@link processInput}, but also returns every problem found on the way, in
+* order: a dropped default, warnings the parser recovered from, and the parser
+* error that forced the safe default. Entries carry the RAW declared `paramType`
+* so clients match on the casing they sent.
+*
+* A non-`ComputeError` failure still throws: it is a bug, not bad input.
+*/
+function processInputWithError(rawInput) {
+	const label = rawInput.name || "unknown";
+	const errors = [];
+	const report = ({ code, message }) => {
+		errors.push({
+			inputName: label,
+			paramType: rawInput.paramType,
+			message,
+			code
+		});
+	};
+	const baseInput = {
+		description: rawInput.description,
+		name: rawInput.name,
+		nickname: rawInput.nickname,
+		treeAccess: rawInput.treeAccess,
+		groupName: rawInput.groupName ?? void 0,
+		id: rawInput.id
+	};
+	const paramType = canonicalizeParamType(rawInput.paramType);
+	let schema = {
+		...rawInput,
+		paramType
+	};
+	try {
+		const { schema: normalized, warning } = normalizeDefault(schema, label);
+		schema = normalized;
+		if (warning) report(warning);
+	} catch (error) {
+		schema = {
+			...schema,
+			default: null
+		};
+		report({
+			code: ErrorCodes.MALFORMED_DEFAULT,
+			message: `Input "${label}" default could not be normalized and was dropped: ${error instanceof Error ? error.message : String(error)}`
+		});
+	}
+	const parser = INPUT_TYPE_PARSERS.get(paramType);
+	try {
+		if (!parser) throw new ComputeError(`Unknown paramType: ${paramType}`, ErrorCodes.VALIDATION_ERROR, { context: {
+			receivedParamType: paramType,
+			paramName: rawInput.name
+		} });
+		return {
+			input: parser.parse(schema, baseInput, report),
+			errors
+		};
+	} catch (error) {
+		if (!(error instanceof ComputeError)) throw new ComputeError(error instanceof Error ? error.message : String(error), ErrorCodes.VALIDATION_ERROR, {
+			context: {
+				paramName: rawInput.name,
+				paramType
+			},
+			originalError: error
+		});
+		getLogger().error(`Validation error for input ${label}: ${error.code}`);
+		report(error);
+		return {
+			input: (parser?.fallback ?? unknownTypeFallback)(schema, baseInput),
+			errors
+		};
+	}
+}
+/** {@link processInputWithError} over a list, with every input's errors collected. */
+function processInputsWithErrors(rawInputs) {
+	const inputs = [];
+	const parseErrors = [];
+	for (const raw of rawInputs) {
+		const { input, errors } = processInputWithError(raw);
+		inputs.push(input);
+		parseErrors.push(...errors);
+	}
+	return {
+		inputs,
+		parseErrors
+	};
+}
+// src/grasshopper/io/normalize-schema.ts
+/**
+* Canonicalize a raw `/io` param record's field keys to camelCase, so the
+* parsers can read `schema.paramType` whichever casing the server sent. Values,
+* including `default` and the user-authored `values` map, pass through verbatim.
+*
+* A missing required field gets a fallback that keeps the type true: `paramType`
+* `''` surfaces as an unknown-type parse error, and `groupName` stays `null`
+* (not `''`) so "no group" differs from an empty group name.
+*/
+function normalizeInputSchema(raw) {
+	const stepSize = readField(raw, "stepSize");
+	return {
+		id: readField(raw, "id") ?? "",
+		name: readField(raw, "name") ?? "",
+		nickname: readField(raw, "nickname") ?? null,
+		description: readField(raw, "description") ?? "",
+		paramType: readField(raw, "paramType") ?? "",
+		treeAccess: readField(raw, "treeAccess") ?? false,
+		minimum: readField(raw, "minimum") ?? null,
+		maximum: readField(raw, "maximum") ?? null,
+		atLeast: readField(raw, "atLeast") ?? 1,
+		atMost: readField(raw, "atMost") ?? 1,
+		stepSize: typeof stepSize === "number" && Number.isFinite(stepSize) ? stepSize : void 0,
+		default: readField(raw, "default"),
+		values: readField(raw, "values"),
+		acceptedFormats: readField(raw, "acceptedFormats"),
+		groupName: readField(raw, "groupName") ?? null
+	};
+}
+function normalizeOutputSchema(raw) {
+	return {
+		name: readField(raw, "name") ?? "",
+		nickname: readField(raw, "nickname") ?? null,
+		paramType: readField(raw, "paramType") ?? "",
+		id: readField(raw, "id") ?? ""
+	};
+}
+// src/grasshopper/io/definition-io.ts
+/**
+* Fetches a definition's input/output schemas without per-type parsing.
+*
+* Field KEYS are canonicalized to camelCase and missing required fields get a fallback; a missing
+* or non-array `inputs` / `outputs` becomes `[]`. Field VALUES, notably `default` and the `values`
+* label map, pass through verbatim.
+*
+* @throws {ComputeError} If fetch fails or response is invalid
+*/
+async function fetchDefinitionIO(definition, config) {
+	warnIfClientSide("fetchDefinitionIO", config.suppressBrowserWarning);
+	validateServerUrl(config.serverUrl);
+	const { algo, pointer } = prepareGrasshopperArgs(definition, []);
+	if (!algo && !pointer) throw new ComputeError("Definition must resolve to either a URL pointer or base64 algo", ErrorCodes.INVALID_INPUT);
+	const response = await fetchCompute("io", algo ? { algo } : { pointer }, withGrasshopperErrorCodes(config));
+	assertResponseObject(response);
+	const loadWarnings = nonEmptyStrings(readField(response, "warnings"));
+	const loadErrors = nonEmptyStrings(readField(response, "errors"));
+	const rawInputs = readField(response, "inputs");
+	const rawOutputs = readField(response, "outputs");
+	return {
+		inputs: Array.isArray(rawInputs) ? rawInputs.map(normalizeInputSchema) : [],
+		outputs: Array.isArray(rawOutputs) ? rawOutputs.map(normalizeOutputSchema) : [],
+		...loadWarnings && { loadWarnings },
+		...loadErrors && { loadErrors }
+	};
+}
+/**
+* Server diagnostics as non-blank strings, or `undefined` when there are none.
+* Non-string entries are kept, not dropped: a fork reporting `{ message }`
+* objects must not yield an empty input list with no explanation.
+*/
+function nonEmptyStrings(value) {
+	if (!Array.isArray(value)) return void 0;
+	const cleaned = value.map(coerceDiagnostic).filter((v) => v !== void 0);
+	return cleaned.length > 0 ? cleaned : void 0;
+}
+function coerceDiagnostic(value) {
+	if (value === null || value === void 0) return void 0;
+	let text;
+	if (typeof value === "string") text = value;
+	else if (typeof value === "object") {
+		const message = readField(value, "message");
+		if (typeof message === "string" && message.trim().length > 0) text = message;
+		else try {
+			text = JSON.stringify(value) ?? String(value);
+		} catch {
+			text = String(value);
+		}
+	} else text = String(value);
+	return text.trim().length > 0 ? text : void 0;
+}
+/**
+* Fetches a definition's input/output schemas and parses each input into its
+* typed `InputParam`. An input that fails to parse gets a safe default
+* and an entry in `parseErrors`.
+*
+* @throws {ComputeError} If fetch fails or response is invalid
+*
+* @example
+* ```typescript
+* const { inputs, outputs } = await fetchParsedDefinitionIO(
+*   'https://example.com/definition.gh',
+*   { serverUrl: 'http://localhost:6500', apiKey: 'YOUR_KEY' }
+* );
+*
+* // Inputs are now strongly typed
+* inputs.forEach(input => {
+*   if (input.paramType === 'Number') {
+*     console.log(input.minimum, input.maximum); // TypeScript knows these exist
+*   }
+* });
+* ```
+*/
+async function fetchParsedDefinitionIO(definition, config) {
+	const { inputs: rawInputs, outputs, loadWarnings, loadErrors } = await fetchDefinitionIO(definition, config);
+	const { inputs, parseErrors } = processInputsWithErrors(rawInputs);
+	return {
+		inputs,
+		outputs,
+		...parseErrors.length > 0 && { parseErrors },
+		...loadWarnings && { loadWarnings },
+		...loadErrors && { loadErrors }
+	};
+}
+// src/grasshopper/scheduler/response-cache.ts
+/**
+* For a response that never crossed the fetch boundary (custom executor), so carries no
+* wire-size hint. An unserializable response is sized 0 rather than failing the solve.
+*/
+function estimateResponseSize(response) {
+	try {
+		return JSON.stringify(response)?.length ?? 0;
+	} catch {
+		return 0;
+	}
+}
+/** The scheduler's response cache: LRU by bytes, with an optional TTL. */
+var ResponseCache = class {
+	maxBytes;
+	ttlMs;
+	cacheErroredSolves;
+	entries = /* @__PURE__ */ new Map();
+	bytes = 0;
+	hits = 0;
+	misses = 0;
+	evictions = 0;
+	constructor(options) {
+		const config = options || null;
+		this.maxBytes = Math.max(0, config?.maxBytes ?? 0);
+		this.ttlMs = config?.ttlMs ?? 0;
+		this.cacheErroredSolves = config?.cacheErroredSolves ?? true;
+	}
+	/** A zero budget retains nothing, so it is off rather than a cache that can only ever miss. */
+	get enabled() {
+		return this.maxBytes > 0;
+	}
+	get(key) {
+		if (!this.enabled) return null;
+		const entry = this.entries.get(key);
+		if (!entry) {
+			this.misses += 1;
+			return null;
+		}
+		if (this.ttlMs > 0 && Date.now() - entry.insertedAt > this.ttlMs) {
+			this.drop(key);
+			this.misses += 1;
+			return null;
+		}
+		this.entries.delete(key);
+		this.entries.set(key, entry);
+		this.hits += 1;
+		return entry.response;
+	}
+	set(key, response) {
+		if (!this.enabled) return;
+		const solveErrors = readField(response, "errors");
+		if (!this.cacheErroredSolves && Array.isArray(solveErrors) && solveErrors.length > 0) return;
+		const outcome = readField(readField(response, "selva"), "outcome");
+		if (readField(outcome, "aborted") === true) return;
+		const sizeBytes = getResponseWireSize(response) ?? estimateResponseSize(response);
+		if (sizeBytes > this.maxBytes) return;
+		this.drop(key);
+		this.entries.set(key, {
+			response,
+			insertedAt: Date.now(),
+			sizeBytes
+		});
+		this.bytes += sizeBytes;
+		while (this.bytes > this.maxBytes && this.entries.size > 0) {
+			const oldest = this.entries.keys().next().value;
+			if (oldest === void 0) break;
+			this.drop(oldest);
+			this.evictions += 1;
+		}
+	}
+	clear() {
+		this.entries.clear();
+		this.bytes = 0;
+	}
+	stats() {
+		return {
+			entries: this.entries.size,
+			bytes: this.bytes,
+			hits: this.hits,
+			misses: this.misses,
+			evictions: this.evictions
+		};
+	}
+	drop(key) {
+		const entry = this.entries.get(key);
+		if (!entry) return;
+		this.entries.delete(key);
+		this.bytes -= entry.sizeBytes;
+	}
+};
+// src/core/utils/sha256.ts
+const nodeCrypto = globalThis.process?.getBuiltinModule?.("node:crypto");
+/** Lowercase hex SHA-256 of `input`. */
+function sha256Hex(input) {
+	if (nodeCrypto) {
+		const hash = nodeCrypto.createHash("sha256");
+		if (typeof input === "string") hash.update(input, "utf16le");
+		else hash.update(input);
+		return hash.digest("hex");
+	}
+	return sha256HexPortable(input);
+}
+const K = new Int32Array([
+	1116352408,
+	1899447441,
+	3049323471,
+	3921009573,
+	961987163,
+	1508970993,
+	2453635748,
+	2870763221,
+	3624381080,
+	310598401,
+	607225278,
+	1426881987,
+	1925078388,
+	2162078206,
+	2614888103,
+	3248222580,
+	3835390401,
+	4022224774,
+	264347078,
+	604807628,
+	770255983,
+	1249150122,
+	1555081692,
+	1996064986,
+	2554220882,
+	2821834349,
+	2952996808,
+	3210313671,
+	3336571891,
+	3584528711,
+	113926993,
+	338241895,
+	666307205,
+	773529912,
+	1294757372,
+	1396182291,
+	1695183700,
+	1986661051,
+	2177026350,
+	2456956037,
+	2730485921,
+	2820302411,
+	3259730800,
+	3345764771,
+	3516065817,
+	3600352804,
+	4094571909,
+	275423344,
+	430227734,
+	506948616,
+	659060556,
+	883997877,
+	958139571,
+	1322822218,
+	1537002063,
+	1747873779,
+	1955562222,
+	2024104815,
+	2227730452,
+	2361852424,
+	2428436474,
+	2756734187,
+	3204031479,
+	3329325298
+]);
+/** Exported so tests can check it against Node's native hash. */
+function sha256HexPortable(input) {
+	const state = new Sha256();
+	if (typeof input === "string") state.updateString(input);
+	else state.update(input);
+	return state.digestHex();
+}
+var Sha256 = class {
+	h = new Int32Array([
+		1779033703,
+		3144134277,
+		1013904242,
+		2773480762,
+		1359893119,
+		2600822924,
+		528734635,
+		1541459225
+	]);
+	w = /* @__PURE__ */ new Int32Array(64);
+	pending = /* @__PURE__ */ new Uint8Array(64);
+	pendingLength = 0;
+	totalBytes = 0;
+	update(bytes) {
+		this.totalBytes += bytes.length;
+		let offset = 0;
+		if (this.pendingLength > 0) {
+			const take = Math.min(64 - this.pendingLength, bytes.length);
+			this.pending.set(bytes.subarray(0, take), this.pendingLength);
+			this.pendingLength += take;
+			offset = take;
+			if (this.pendingLength < 64) return;
+			this.compressBytes(this.pending, 0);
+			this.pendingLength = 0;
+		}
+		for (; offset + 64 <= bytes.length; offset += 64) this.compressBytes(bytes, offset);
+		this.pending.set(bytes.subarray(offset), 0);
+		this.pendingLength = bytes.length - offset;
+	}
+	/**
+	* Feed a string's UTF-16LE bytes straight into the message words, skipping a byte buffer.
+	* Only on a fresh state: 32 code units fill a block exactly, so nothing may be pending.
+	*/
+	updateString(s) {
+		const w = this.w;
+		const whole = s.length - s.length % 32;
+		for (let offset = 0; offset < whole; offset += 32) {
+			for (let i = 0; i < 16; i++) {
+				const c0 = s.charCodeAt(offset + 2 * i);
+				const c1 = s.charCodeAt(offset + 2 * i + 1);
+				w[i] = (c0 & 255) << 24 | c0 >>> 8 << 16 | (c1 & 255) << 8 | c1 >>> 8;
+			}
+			this.compress();
+		}
+		this.totalBytes += whole * 2;
+		const rest = new Uint8Array((s.length - whole) * 2);
+		for (let i = whole, j = 0; i < s.length; i++) {
+			const code = s.charCodeAt(i);
+			rest[j++] = code & 255;
+			rest[j++] = code >>> 8;
+		}
+		this.update(rest);
+	}
+	digestHex() {
+		const bitLength = this.totalBytes * 8;
+		const tail = new Uint8Array(this.pendingLength < 56 ? 64 : 128);
+		tail.set(this.pending.subarray(0, this.pendingLength));
+		tail[this.pendingLength] = 128;
+		const view = new DataView(tail.buffer);
+		view.setUint32(tail.length - 8, Math.floor(bitLength / 4294967296));
+		view.setUint32(tail.length - 4, bitLength >>> 0);
+		for (let offset = 0; offset < tail.length; offset += 64) this.compressBytes(tail, offset);
+		let hex = "";
+		for (const word of this.h) hex += (word >>> 0).toString(16).padStart(8, "0");
+		return hex;
+	}
+	compressBytes(bytes, offset) {
+		const w = this.w;
+		for (let i = 0; i < 16; i++) {
+			const j = offset + i * 4;
+			w[i] = bytes[j] << 24 | bytes[j + 1] << 16 | bytes[j + 2] << 8 | bytes[j + 3];
+		}
+		this.compress();
+	}
+	/** One block, from the 16 message words already in `w`. */
+	compress() {
+		const w = this.w;
+		for (let i = 16; i < 64; i++) {
+			const x = w[i - 15];
+			const y = w[i - 2];
+			const s0 = (x >>> 7 | x << 25) ^ (x >>> 18 | x << 14) ^ x >>> 3;
+			const s1 = (y >>> 17 | y << 15) ^ (y >>> 19 | y << 13) ^ y >>> 10;
+			w[i] = w[i - 16] + s0 + w[i - 7] + s1 | 0;
+		}
+		const h = this.h;
+		let a = h[0];
+		let b = h[1];
+		let c = h[2];
+		let d = h[3];
+		let e = h[4];
+		let f = h[5];
+		let g = h[6];
+		let k = h[7];
+		for (let i = 0; i < 64; i++) {
+			const S1 = (e >>> 6 | e << 26) ^ (e >>> 11 | e << 21) ^ (e >>> 25 | e << 7);
+			const ch = e & f ^ ~e & g;
+			const t1 = k + S1 + ch + K[i] + w[i] | 0;
+			const t2 = ((a >>> 2 | a << 30) ^ (a >>> 13 | a << 19) ^ (a >>> 22 | a << 10)) + (a & b ^ a & c ^ b & c) | 0;
+			k = g;
+			g = f;
+			f = e;
+			e = d + t1 | 0;
+			d = c;
+			c = b;
+			b = a;
+			a = t1 + t2 | 0;
+		}
+		h[0] = h[0] + a | 0;
+		h[1] = h[1] + b | 0;
+		h[2] = h[2] + c | 0;
+		h[3] = h[3] + d | 0;
+		h[4] = h[4] + e | 0;
+		h[5] = h[5] + f | 0;
+		h[6] = h[6] + g | 0;
+		h[7] = h[7] + k | 0;
+	}
+};
+// src/grasshopper/scheduler/stable-hash.ts
+/**
+* Solve-key hashing, public so an app-layer durable cache or a pre-solved bundle viewer can
+* reproduce the scheduler's exact key. A key that canonicalizes even slightly differently
+* misses every entry the scheduler wrote, or worse, collides differently.
+*
+* Keys are SHA-256: one scheduler's cache serves every user of a server, so a key a user can
+* collide on purpose lets them choose what another user's solve returns.
+*/
+/**
+* Deterministic stringify with sorted keys. {a:1,b:2} and {b:2,a:1} produce
+* the same string. Safely handles circular references and non-finite numbers.
+*
+* The output is a cache key, so the invariant that matters is: two payloads
+* that serialize differently on the wire must stringify differently here
+* (false misses are harmless; false hits serve the wrong cached solve).
+* Non-JSON values get unquoted markers (`{u8:…}`, `[Circular]`) that no JSON
+* value stringifies to, so a plain object can't pose as one.
+*/
+function stableStringify(value) {
+	const path = /* @__PURE__ */ new WeakSet();
+	const stringify = (v) => {
+		if (v === null) return "null";
+		if (typeof v === "number") return Number.isFinite(v) ? String(v) : "null";
+		if (typeof v === "string" || typeof v === "boolean") return JSON.stringify(v);
+		if (typeof v === "bigint") return `${v}n`;
+		if (typeof v !== "object") return "undefined";
+		if (v instanceof Uint8Array) return `{u8:${sha256Hex(v)}}`;
+		if (path.has(v)) return "[Circular]";
+		path.add(v);
+		let out;
+		if (Array.isArray(v)) {
+			const parts = [];
+			for (let i = 0; i < v.length; i++) parts.push(stringify(v[i]));
+			out = `[${parts.join(",")}]`;
+		} else if (typeof v.toJSON === "function") out = stringify(v.toJSON());
+		else if (v instanceof Map) out = `{map:[${[...v.entries()].map(([k, val]) => `[${stringify(k)},${stringify(val)}]`).sort().join(",")}]}`;
+		else if (v instanceof Set) out = `{set:[${[...v.values()].map(stringify).sort().join(",")}]}`;
+		else out = `{${Object.keys(v).sort().map((k) => `${JSON.stringify(k)}:${stringify(v[k])}`).join(",")}}`;
+		path.delete(v);
+		return out;
+	};
+	return stringify(value);
+}
+/** The scheduler's solve-cache key for a definition and its input tree. */
+function hashSolveInput(definition, dataTree) {
+	return hashSolveInputForDefinition(hashDefinition(definition), dataTree);
+}
+/**
+* `hashSolveInput` from a precomputed {@link hashDefinition}, so the scheduler, which also keys its
+* server-cache-key map by that hash, passes over a multi-MB definition once per solve.
+*/
+function hashSolveInputForDefinition(definitionHash, dataTree) {
+	return `${definitionHash}|t:${sha256Hex(stableStringify(dataTree))}`;
+}
+/**
+* A definition's identity, without its inputs. Strings and bytes are hashed over their full
+* content; a `DefinitionRef` uses its `key`.
+*/
+function hashDefinition(definition) {
+	if (isDefinitionRef(definition)) return `r:${definition.key}`;
+	return typeof definition === "string" ? `s:${sha256Hex(definition)}` : `u8:${sha256Hex(definition)}`;
+}
+// src/grasshopper/scheduler/solve-scheduler.ts
+const SERVER_CACHE_KEYS_MAX = 100;
+/** `NaN` passes `Math.max` and fails every `inFlight < limit`, so nothing would ever dispatch. */
+function concurrencyLimit(value) {
+	if (Number.isNaN(value)) throw new ComputeError("maxConcurrent must be a number", ErrorCodes.INVALID_CONFIG, { context: { maxConcurrent: value } });
+	return Math.max(1, Math.floor(value));
+}
+const u8DefinitionHashes = /* @__PURE__ */ new WeakMap();
+/**
+* Remembers a buffer's hash by identity: a buffer mutated after its first solve keeps its old
+* hash and is served the old content's cached solves.
+*/
+function hashDefinitionOnce(definition) {
+	if (!(definition instanceof Uint8Array)) return hashDefinition(definition);
+	let hash = u8DefinitionHashes.get(definition);
+	if (hash === void 0) {
+		hash = hashDefinition(definition);
+		u8DefinitionHashes.set(definition, hash);
+	}
+	return hash;
+}
+/** One solve's input hashes, each taken on first use. */
+var SolveInputHashes = class {
+	hashDefinition;
+	dataTree;
+	definitionMemo;
+	keyMemo;
+	constructor(hashDefinition, dataTree) {
+		this.hashDefinition = hashDefinition;
+		this.dataTree = dataTree;
+	}
+	get definitionHash() {
+		return this.definitionMemo ??= this.hashDefinition();
+	}
+	get key() {
+		return this.keyMemo ??= hashSolveInputForDefinition(this.definitionHash, this.dataTree);
+	}
+};
+/**
+* The FIFO behind `queue` mode. Removing an item only drops it from `live`; the array is swept once
+* the dead entries outnumber the live ones, so aborting n queued solves costs O(n), not O(n²).
+*/
+var SolveQueue = class {
+	items = [];
+	head = 0;
+	live = /* @__PURE__ */ new Set();
+	get size() {
+		return this.live.size;
+	}
+	push(item) {
+		this.items.push(item);
+		this.live.add(item);
+	}
+	remove(item) {
+		if (this.live.delete(item)) this.compact();
+	}
+	shift() {
+		while (this.head < this.items.length) {
+			const item = this.items[this.head];
+			this.items[this.head++] = void 0;
+			if (item && this.live.delete(item)) {
+				this.compact();
+				return item;
+			}
+		}
+	}
+	compact() {
+		if (this.live.size === 0) {
+			this.items = [];
+			this.head = 0;
+			return;
+		}
+		const dead = this.items.length - this.live.size;
+		if (dead <= 64 || dead <= this.live.size) return;
+		this.items = this.items.filter((item) => item !== void 0 && this.live.has(item));
+		this.head = 0;
+	}
+};
+/**
+* Adds to a plain solve call:
+* - Scheduling (latest-wins for sliders, queue for jobs)
+* - Backpressure (bounded queue depth + queue-wait deadline)
+* - Cancellation (per-call signal + cancelAll)
+* - Optional response caching for repeated inputs
+* - Lifecycle hooks (start / settle / superseded) and state via subscribe()
+*
+* @example
+* ```ts
+* const scheduler = client.createScheduler({ mode: 'latest-wins', timeoutMs: 30_000 });
+*
+* // From a slider handler:
+* scheduler.solve(definition, tree).then((result) => {
+*   updateMeshes(result);
+* }).catch((err) => {
+*   if (err.code !== 'SUPERSEDED') showError(err);
+* });
+*
+* // From a UI binding:
+* scheduler.subscribe(() => {
+*   showSpinner = scheduler.isSolving;
+* });
+* ```
+*/
+var SolveScheduler = class {
+	executor;
+	baseConfig;
+	mode;
+	maxConcurrent;
+	maxQueueDepth;
+	queueWaitMs;
+	timeoutMs;
+	retry;
+	cache;
+	reuseServerDefinitionCache;
+	/** Definition hash → the server's cache key (`pointer`) for it. */
+	serverCacheKeys = /* @__PURE__ */ new Map();
+	/** A string definition re-sent unchanged is compared with this, far cheaper than hashing it. */
+	lastStringDefinition = null;
+	onStart;
+	onSettle;
+	onSuperseded;
+	subscribers = /* @__PURE__ */ new Set();
+	inFlight = /* @__PURE__ */ new Set();
+	pendingForLatestWins = null;
+	fifo = new SolveQueue();
+	_lastResult = null;
+	_lastError = null;
+	_lastDurationMs = null;
+	solveSeq = 0;
+	/** seq of the solve that last wrote `_lastResult`/`_lastError`. */
+	lastStateSeq = 0;
+	disposed = false;
+	constructor(executor, baseConfig, options = {}) {
+		this.executor = executor;
+		this.baseConfig = baseConfig;
+		this.mode = options.mode ?? "latest-wins";
+		if (this.mode !== "latest-wins" && this.mode !== "queue") throw new ComputeError(`Unknown scheduler mode '${String(this.mode)}'. For concurrent solves use { mode: 'queue', maxConcurrent: 4 }.`, ErrorCodes.INVALID_CONFIG, { context: { mode: this.mode } });
+		this.maxConcurrent = concurrencyLimit(options.maxConcurrent ?? 1);
+		this.maxQueueDepth = options.maxQueueDepth !== void 0 && options.maxQueueDepth > 0 ? Math.floor(options.maxQueueDepth) : void 0;
+		this.queueWaitMs = options.queueWaitMs !== void 0 && options.queueWaitMs > 0 ? options.queueWaitMs : void 0;
+		this.timeoutMs = options.timeoutMs;
+		this.retry = options.retry;
+		this.cache = new ResponseCache(options.cache);
+		this.reuseServerDefinitionCache = options.reuseServerDefinitionCache ?? true;
+		this.onStart = options.onStart;
+		this.onSettle = options.onSettle;
+		this.onSuperseded = options.onSuperseded;
+	}
+	get isSolving() {
+		return this.inFlight.size > 0;
+	}
+	get hasPending() {
+		return this.pendingForLatestWins !== null || this.fifo.size > 0;
+	}
+	get inFlightCount() {
+		return this.inFlight.size;
+	}
+	get queueDepth() {
+		return this.fifo.size + (this.pendingForLatestWins ? 1 : 0);
+	}
+	get lastResult() {
+		return this._lastResult;
+	}
+	get lastError() {
+		return this._lastError;
+	}
+	get lastDurationMs() {
+		return this._lastDurationMs;
+	}
+	/**
+	* Adjust how many solves may run at once, for when the compute server's worker
+	* pool changes size after this scheduler was built.
+	*
+	* Raising it drains queued work immediately. Lowering it never interrupts work
+	* already in flight — those finish above the new limit, and the cap applies from
+	* the next dispatch. Values below 1 are clamped, since 0 would wedge the queue.
+	*
+	* @throws {ComputeError} `INVALID_CONFIG` for `NaN`, which would wedge it too.
+	*/
+	setMaxConcurrent(value) {
+		const next = concurrencyLimit(value);
+		if (next === this.maxConcurrent) return;
+		const raised = next > this.maxConcurrent;
+		this.maxConcurrent = next;
+		if (raised) this.drainNext();
+	}
+	/** Subscribe to state changes. */
+	subscribe(listener) {
+		this.subscribers.add(listener);
+		return () => this.subscribers.delete(listener);
+	}
+	notify() {
+		for (const listener of this.subscribers) try {
+			listener();
+		} catch (err) {
+			getLogger().error("[SolveScheduler] subscriber threw:", err);
+		}
+	}
+	/**
+	* Schedule a solve. Returns a promise that:
+	* - Resolves with the compute response on success.
+	* - Rejects with `ComputeError` on failure.
+	* - Rejects with `code: ErrorCodes.SUPERSEDED` when the call was canceled because
+	*   newer values arrived (latest-wins mode).
+	* - Rejects with `code: ErrorCodes.ABORTED` when the call was canceled via
+	*   its own `signal` (queued or running) or `cancelAll()`.
+	* - Rejects with `code: ErrorCodes.QUEUE_FULL` when `maxQueueDepth` is set and
+	*   the queue was already full (backpressure; `statusCode: 503`).
+	* - Rejects with `code: ErrorCodes.QUEUE_TIMEOUT` when `queueWaitMs` is set and
+	*   the call sat queued longer than that before starting (`statusCode: 503`).
+	*
+	* Don't mutate a `Uint8Array` definition after solving it. Responses served
+	* from the cache (and via `lastResult`) are shared objects, not copies —
+	* treat them as immutable. Mutating one poisons every later cache hit for
+	* that key.
+	*
+	* Partial-success contract: unlike `GrasshopperClient.solve()`, which throws
+	* `COMPUTATION_ERROR` when the response carries solver errors, this RESOLVES
+	* with the response as-is — check `response.errors` yourself if a partial
+	* success must not be treated as a result (see `cacheErroredSolves` for the
+	* caching side of the same distinction).
+	*/
+	solve(definition, dataTree, options) {
+		return this.solveDetailed(definition, dataTree, options).then((detail) => detail.response);
+	}
+	/** {@link solve}, also resolving with whether this call hit the cache and how long it took. */
+	solveDetailed(definition, dataTree, options) {
+		if (this.disposed) return Promise.reject(new ComputeError("SolveScheduler has been disposed and cannot be used", ErrorCodes.INVALID_STATE));
+		const hashes = new SolveInputHashes(() => this.hashDefinitionMemo(definition), dataTree);
+		let key = "";
+		if (this.cache.enabled || this.onStart || this.onSettle || this.onSuperseded) try {
+			key = hashes.key;
+		} catch (error) {
+			return Promise.reject(new ComputeError("Solve input could not be hashed", ErrorCodes.INVALID_INPUT, { originalError: error }));
+		}
+		const seq = ++this.solveSeq;
+		const ctx = {
+			key,
+			enqueuedAt: Date.now(),
+			startedAt: null
+		};
+		if (options?.signal?.aborted) return Promise.reject(this.makeAbortError(ctx));
+		const cached = this.cache.get(key);
+		if (cached) {
+			if (this.mode === "latest-wins") this.supersedeCurrent();
+			const result = {
+				status: "success",
+				response: cached,
+				durationMs: 0,
+				fromCache: true
+			};
+			this.writeLastState(seq, {
+				result: cached,
+				durationMs: 0
+			});
+			this.runHook(this.onStart, ctx);
+			this.runHook(this.onSettle, ctx, result);
+			this.notify();
+			return Promise.resolve({
+				response: cached,
+				fromCache: true,
+				durationMs: 0
+			});
+		}
+		return new Promise((resolve, reject) => {
+			const item = {
+				definition,
+				dataTree,
+				hashes,
+				ctx,
+				seq,
+				resolve,
+				reject,
+				externalSignal: options?.signal,
+				selvaevents: options?.selvaevents,
+				onServerTiming: options?.onServerTiming
+			};
+			if (item.externalSignal) {
+				item.onExternalAbort = () => {
+					if (item.controller) item.controller.abort();
+					else this.abortQueuedItem(item);
+				};
+				item.externalSignal.addEventListener("abort", item.onExternalAbort, { once: true });
+			}
+			this.enqueue(item);
+		});
+	}
+	/** A slow solve settling late must not overwrite state a newer solve or cache hit published. */
+	writeLastState(seq, state) {
+		if (seq < this.lastStateSeq) return;
+		this.lastStateSeq = seq;
+		if ("result" in state) {
+			this._lastResult = state.result;
+			this._lastError = null;
+		} else this._lastError = state.error;
+		this._lastDurationMs = state.durationMs;
+	}
+	/** latest-wins: supersede the pending item and abort everything in flight. */
+	supersedeCurrent() {
+		if (this.pendingForLatestWins) {
+			this.supersede(this.pendingForLatestWins);
+			this.pendingForLatestWins = null;
+		}
+		for (const inflight of this.inFlight) {
+			this.supersede(inflight);
+			inflight.controller.abort();
+		}
+	}
+	dequeue(item) {
+		if (this.pendingForLatestWins === item) this.pendingForLatestWins = null;
+		this.fifo.remove(item);
+	}
+	abortQueuedItem(item) {
+		this.dequeue(item);
+		this.fail(item, this.makeAbortError(item.ctx));
+		this.notify();
+	}
+	/** The structured context lets an HTTP layer map QUEUE_FULL to 503 + Retry-After. */
+	shedAsQueueFull(item) {
+		const err = new ComputeError("Solve queue is full; request rejected (backpressure)", ErrorCodes.QUEUE_FULL, {
+			statusCode: 503,
+			context: {
+				queueDepth: this.fifo.size,
+				maxQueueDepth: this.maxQueueDepth
+			}
+		});
+		this.fail(item, err);
+		this.notify();
+	}
+	armQueueWaitTimer(item) {
+		if (this.queueWaitMs === void 0) return;
+		const waitMs = this.queueWaitMs;
+		item.queueWaitTimer = setTimeout(() => {
+			if (item.settled) return;
+			this.dequeue(item);
+			const err = new ComputeError(`Solve waited longer than ${waitMs}ms in queue; rejected (backpressure)`, ErrorCodes.QUEUE_TIMEOUT, {
+				statusCode: 503,
+				context: {
+					waitedMs: Date.now() - item.ctx.enqueuedAt,
+					queueWaitMs: waitMs
+				}
+			});
+			this.fail(item, err);
+			this.notify();
+		}, waitMs);
+	}
+	clearQueueWaitTimer(item) {
+		if (item.queueWaitTimer !== void 0) {
+			clearTimeout(item.queueWaitTimer);
+			item.queueWaitTimer = void 0;
+		}
+	}
+	enqueue(item) {
+		switch (this.mode) {
+			case "latest-wins":
+				this.supersedeCurrent();
+				if (this.inFlight.size === 0) this.execute(item);
+				else this.pendingForLatestWins = item;
+				break;
+			case "queue": if (this.inFlight.size < this.maxConcurrent) this.execute(item);
+			else if (this.maxQueueDepth !== void 0 && this.fifo.size >= this.maxQueueDepth) this.shedAsQueueFull(item);
+			else {
+				this.armQueueWaitTimer(item);
+				this.fifo.push(item);
+			}
+		}
+		this.notify();
+	}
+	async execute(item) {
+		const controller = new AbortController();
+		const inflight = item;
+		inflight.controller = controller;
+		this.inFlight.add(inflight);
+		item.ctx.startedAt = Date.now();
+		this.clearQueueWaitTimer(item);
+		this.runHook(this.onStart, item.ctx);
+		this.notify();
+		const startTime = performance.now();
+		try {
+			const config = {
+				...this.baseConfig,
+				signal: controller.signal,
+				...this.timeoutMs !== void 0 && { timeoutMs: this.timeoutMs },
+				...this.retry !== void 0 && { retry: this.retry },
+				...item.selvaevents !== void 0 && { selvaevents: item.selvaevents }
+			};
+			const callTiming = item.onServerTiming;
+			if (callTiming) {
+				const baseTiming = this.baseConfig.onServerTiming;
+				config.onServerTiming = (timing, requestId) => {
+					try {
+						baseTiming?.(timing, requestId);
+					} finally {
+						callTiming(timing, requestId);
+					}
+				};
+			}
+			const { response, definitionReuploaded } = await this.runExecutor(item, config);
+			const durationMs = performance.now() - startTime;
+			if (!this.disposed) this.cache.set(item.ctx.key, response);
+			if (!this.settleSuccess(item, {
+				response,
+				fromCache: false,
+				definitionReuploaded,
+				durationMs
+			})) return;
+			this.writeLastState(item.seq, {
+				result: response,
+				durationMs
+			});
+			this.runHook(this.onSettle, item.ctx, {
+				status: "success",
+				response,
+				durationMs,
+				fromCache: false,
+				definitionReuploaded
+			});
+		} catch (error) {
+			const durationMs = performance.now() - startTime;
+			const err = this.normalizeExecutionError(error, inflight);
+			this.writeLastState(item.seq, {
+				error: err,
+				durationMs
+			});
+			this.fail(item, err, durationMs);
+		} finally {
+			this.inFlight.delete(inflight);
+			this.drainNext();
+			this.notify();
+		}
+	}
+	async runExecutor(item, config) {
+		const { definition, dataTree } = item;
+		if (!this.reuseServerDefinitionCache || isDefinitionUrl(definition)) {
+			const { response } = await this.executor(definition, dataTree, null, config);
+			return { response };
+		}
+		const definitionHash = item.hashes.definitionHash;
+		const knownKey = this.serverCacheKeys.get(definitionHash) ?? null;
+		const result = await this.executor(definition, dataTree, knownKey, config);
+		this.serverCacheKeys.delete(definitionHash);
+		if (result.cacheKey) {
+			this.serverCacheKeys.set(definitionHash, result.cacheKey);
+			if (this.serverCacheKeys.size > SERVER_CACHE_KEYS_MAX) this.serverCacheKeys.delete(this.serverCacheKeys.keys().next().value);
+		}
+		return {
+			response: result.response,
+			definitionReuploaded: result.missed
+		};
+	}
+	hashDefinitionMemo(definition) {
+		if (typeof definition !== "string") return hashDefinitionOnce(definition);
+		if (this.lastStringDefinition?.value !== definition) this.lastStringDefinition = {
+			value: definition,
+			hash: hashDefinition(definition)
+		};
+		return this.lastStringDefinition.hash;
+	}
+	drainNext() {
+		if (this.disposed) return;
+		if (this.mode === "latest-wins") {
+			if (this.pendingForLatestWins && this.inFlight.size === 0) {
+				const next = this.pendingForLatestWins;
+				this.pendingForLatestWins = null;
+				this.execute(next);
+			}
+			return;
+		}
+		while (this.fifo.size > 0 && this.inFlight.size < this.maxConcurrent) this.execute(this.fifo.shift());
+	}
+	supersede(item) {
+		const err = new ComputeError("Superseded by newer solve", ErrorCodes.SUPERSEDED, { context: { enqueuedAt: item.ctx.enqueuedAt } });
+		if (this.settleError(item, err)) this.runHook(this.onSuperseded, item.ctx);
+	}
+	makeAbortError(ctx) {
+		return abortedByCaller({ enqueuedAt: ctx.enqueuedAt });
+	}
+	/**
+	* The executor, `supersede`, `cancelAll`, abort and the queue limits can all race to settle one
+	* item, and a promise ignores a second settle silently. The first settle wins; the return value
+	* says whether this call won, so only the winner fires its hook. Every settle path goes through
+	* here or {@link settleSuccess}.
+	*/
+	settleError(item, err) {
+		if (!this.claimSettle(item, { error: err })) return false;
+		item.reject(err);
+		return true;
+	}
+	/**
+	* Fires `onSettle` for queued items too, so a consumer counting solves in progress doesn't
+	* leak one. A supersede settles through {@link settleError} and fires `onSuperseded` instead.
+	*/
+	fail(item, err, durationMs = 0) {
+		if (this.settleError(item, err)) this.runHook(this.onSettle, item.ctx, {
+			status: "error",
+			error: err,
+			durationMs
+		});
+	}
+	settleSuccess(item, detail) {
+		if (!this.claimSettle(item, { ok: true })) return false;
+		item.resolve(detail);
+		return true;
+	}
+	claimSettle(item, settled) {
+		if (item.settled) return false;
+		item.settled = settled;
+		this.clearQueueWaitTimer(item);
+		if (item.onExternalAbort) item.externalSignal?.removeEventListener("abort", item.onExternalAbort);
+		return true;
+	}
+	normalizeExecutionError(error, item) {
+		if (item.settled && "error" in item.settled) return item.settled.error;
+		if (error instanceof ComputeError) return error;
+		if (error instanceof Error && error.name === "AbortError") return this.makeAbortError(item.ctx);
+		return new ComputeError(error instanceof Error ? error.message : String(error), ErrorCodes.UNKNOWN_ERROR, { originalError: error });
+	}
+	/** Cancel everything — in-flight and pending. */
+	cancelAll() {
+		if (this.pendingForLatestWins) {
+			this.fail(this.pendingForLatestWins, this.makeAbortError(this.pendingForLatestWins.ctx));
+			this.pendingForLatestWins = null;
+		}
+		for (let item = this.fifo.shift(); item; item = this.fifo.shift()) this.fail(item, this.makeAbortError(item.ctx));
+		for (const inflight of this.inFlight) {
+			const durationMs = inflight.ctx.startedAt ? Date.now() - inflight.ctx.startedAt : 0;
+			this.fail(inflight, this.makeAbortError(inflight.ctx), durationMs);
+			inflight.controller.abort();
+		}
+		this.notify();
+	}
+	clearCache() {
+		this.cache.clear();
+	}
+	/**
+	* Observability snapshot of the solve cache: current size plus lifetime
+	* hit/miss/eviction counters.
+	*
+	* `hits`/`misses` count cache CONSULTATIONS, so `hits / (hits + misses)` is the
+	* hit rate. A TTL-expired entry counts as a miss (the solve runs either way).
+	* `evictions` counts only entries dropped under size/byte pressure — not
+	* replace-in-place writes or TTL expiry, which are not capacity signals.
+	* Counters are cumulative and survive `clearCache()`.
+	*/
+	cacheStats() {
+		return this.cache.stats();
+	}
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.cancelAll();
+		this.subscribers.clear();
+		this.clearCache();
+	}
+	runHook(hook, ...args) {
+		if (!hook) return;
+		try {
+			hook(...args);
+		} catch (err) {
+			getLogger().error("[SolveScheduler] hook threw:", err);
+		}
+	}
+};
+// src/grasshopper/client/grasshopper-client.ts
+function describeDefinition(definition) {
+	if (isDefinitionRef(definition)) return `ref:${definition.key}`;
+	if (typeof definition !== "string" || definition.length >= 200) return "...content...";
+	return isDefinitionUrl(definition) ? redactUrl(definition) : definition;
+}
+/** Identifiers only: the error's `context` holds outputs and its message the server's words. */
+function describeFailure(error) {
+	if (!(error instanceof ComputeError)) return `Compute failed: ${error instanceof Error ? error.name : typeof error}`;
+	const status = error.statusCode === void 0 ? "" : ` HTTP ${error.statusCode}`;
+	const requestId = error.context?.requestId;
+	return `Compute failed: ${error.code}${status}${requestId ? ` [${requestId}]` : ""}`;
+}
+/**
+* Stands in for the input tree on errors: the tree can hold multi-MB geometry, and every logger
+* or telemetry sink that keeps the error would pin it. Never throws on a malformed tree.
+*/
+function summarizeDataTree(dataTree) {
+	if (!Array.isArray(dataTree)) return [];
+	return dataTree.map((tree) => {
+		let items = 0;
+		let bytes = 0;
+		const innerTree = readField(tree, "innerTree");
+		if (innerTree && typeof innerTree === "object") for (const branch of Object.values(innerTree)) {
+			if (!Array.isArray(branch)) continue;
+			items += branch.length;
+			for (const item of branch) {
+				const data = item?.data;
+				if (typeof data === "string") bytes += data.length;
+			}
+		}
+		return {
+			param: readField(tree, "paramName") ?? "<unnamed>",
+			items,
+			bytes
+		};
+	});
+}
+/**
+* The high-level API for solving Grasshopper definitions on a Rhino Compute server.
+*
+* In a browser, the server URL and API key are exposed to users: run it server-side, or proxy
+* requests through your own backend.
+*
+* @example
+* ```typescript
+* const client = await GrasshopperClient.create({
+*   serverUrl: 'http://localhost:6500',
+*   apiKey: 'your-api-key'
+* });
+*
+* try {
+*   const io = await client.getIO(definitionUrl);
+*   const result = await client.solve(definitionUrl, TreeBuilder.fromInputParams(io.inputs));
+* } finally {
+*   await client.dispose(); // Clean up resources
+* }
+* ```
+*/
+var GrasshopperClient = class GrasshopperClient {
+	config;
+	serverStats;
+	schedulers = /* @__PURE__ */ new Set();
+	disposed = false;
+	/**
+	* Per-probe timeout for the `create()` liveness gate: a healthy `GET /` answers in milliseconds,
+	* so this only bounds a silent server, and every extra second is paid once per retry.
+	*/
+	static CREATE_PROBE_TIMEOUT_MS = 2e3;
+	constructor(config) {
+		this.config = {
+			...config,
+			serverUrl: validateServerUrl(config.serverUrl),
+			debug: config.debug ?? false
+		};
+		this.serverStats = new ComputeServerStats(this.config.serverUrl, this.config);
+	}
+	/**
+	* Creates a client once a liveness probe (`GET /`) says the server is up. A cold server can read
+	* as offline, so the probe retries with a short backoff, stopping early when
+	* {@link classifyProbeFailure} says waiting can't change the answer. `config.signal` cancels the
+	* ladder.
+	*
+	* @throws {ComputeError} `NETWORK_ERROR` if the server stays unreachable across all attempts.
+	*   `context.probeVerdict` carries the verdict, so a caller can render a specific cause.
+	* @throws {ComputeError} `ABORTED` if `config.signal` fires first.
+	* @throws {ComputeError} `INVALID_CONFIG` if the configuration is invalid.
+	*/
+	static async create(config, options = {}) {
+		const client = new GrasshopperClient(config);
+		const { signal } = config;
+		const attempts = Math.max(1, (options.probe?.attempts ?? 2) + 1);
+		const baseDelayMs = options.probe?.baseDelayMs ?? 250;
+		const maxDelayMs = options.probe?.maxDelayMs ?? 1e3;
+		let lastProbe;
+		let failure = null;
+		let used = 0;
+		for (let attempt = 0; attempt < attempts && !signal?.aborted; attempt++) {
+			used = attempt + 1;
+			lastProbe = await client.serverStats.probeServer(GrasshopperClient.CREATE_PROBE_TIMEOUT_MS, signal);
+			if (lastProbe.online) return client;
+			failure = classifyProbeFailure(lastProbe);
+			if (failure && !failure.retryable) break;
+			if (attempt < attempts - 1) {
+				const delay = Math.min(baseDelayMs * 2 ** attempt, maxDelayMs);
+				await sleep(delay, signal).catch(() => {});
+			}
+		}
+		await client.dispose();
+		if (signal?.aborted) throw abortedByCaller({
+			serverUrl: client.config.serverUrl,
+			attempts: used
+		});
+		const status = lastProbe?.status;
+		const message = failure ? `Rhino Compute server is not available. ${failure.summary}` : "Rhino Compute server is not online";
+		throw new ComputeError(message, ErrorCodes.NETWORK_ERROR, {
+			...status !== void 0 && { statusCode: status },
+			context: {
+				serverUrl: client.config.serverUrl,
+				attempts: used,
+				maxAttempts: attempts,
+				...failure && {
+					probeVerdict: failure.verdict,
+					probeRetryable: failure.retryable
+				},
+				...status !== void 0 && { lastProbeStatus: status },
+				...lastProbe?.error !== void 0 && { lastProbeError: lastProbe.error }
+			}
+		});
+	}
+	/**
+	* Get input/output parameters of a Grasshopper definition.
+	*/
+	async getIO(definition) {
+		this.ensureNotDisposed();
+		return fetchParsedDefinitionIO(definition, this.config);
+	}
+	async getRawIO(definition) {
+		this.ensureNotDisposed();
+		return fetchDefinitionIO(definition, this.config);
+	}
+	/**
+	* Run a compute job with a Grasshopper definition.
+	*
+	* @throws {ComputeError} with code INVALID_INPUT if definition is empty
+	* @throws {ComputeError} with code NETWORK_ERROR if server is offline
+	* @throws {ComputeError} with code COMPUTATION_ERROR if computation fails.
+	*   On a partial-success response (some outputs computed, some errored) the
+	*   error's `context.values` carries the outputs that did compute — pass
+	*   `{ values } as GrasshopperComputeResponse` to the response processors to
+	*   render them. `context.inputSummary` describes the inputs (param names,
+	*   item counts, byte sizes) without pinning the full data tree.
+	*/
+	async solve(definition, dataTree, options) {
+		this.ensureNotDisposed();
+		const describeCall = () => ({
+			definition: describeDefinition(definition),
+			inputSummary: summarizeDataTree(dataTree)
+		});
+		try {
+			if (typeof definition === "string" && !definition.trim()) throw new ComputeError("Definition URL/content is required", ErrorCodes.INVALID_INPUT, { context: { receivedUrl: definition } });
+			else if (definition instanceof Uint8Array && definition.length === 0) throw new ComputeError("Definition content is empty", ErrorCodes.INVALID_INPUT);
+			else if (isDefinitionRef(definition) && !definition.key.trim()) throw new ComputeError("DefinitionRef key is empty", ErrorCodes.INVALID_INPUT);
+			const result = await solveGrasshopperDefinition(dataTree, definition, {
+				...this.config,
+				...options?.signal !== void 0 && { signal: options.signal },
+				...options?.timeoutMs !== void 0 && { timeoutMs: options.timeoutMs },
+				...options?.retry !== void 0 && { retry: options.retry },
+				...options?.selvaevents !== void 0 && { selvaevents: options.selvaevents }
+			});
+			const solveErrors = readField(result, "errors");
+			if (Array.isArray(solveErrors) && solveErrors.length > 0) throw new ComputeError(solveErrors.map(String).join("; ") || "Computation failed", ErrorCodes.COMPUTATION_ERROR, { context: {
+				...describeCall(),
+				errors: solveErrors,
+				warnings: readField(result, "warnings"),
+				values: result.values
+			} });
+			return result;
+		} catch (error) {
+			if (this.config.debug) getLogger().error(describeFailure(error));
+			if (error instanceof ComputeError) throw error;
+			throw new ComputeError(error instanceof Error ? error.message : String(error), ErrorCodes.COMPUTATION_ERROR, {
+				context: describeCall(),
+				originalError: error
+			});
+		}
+	}
+	/**
+	* Create a scheduler bound to this client. Use a scheduler for any UI surface
+	* that fires solves frequently (sliders, live editors) or that needs cancel
+	* semantics, response caching, or state observability.
+	*
+	* Multiple schedulers can be created from a single client — typically one per
+	* UI surface so their queues stay independent.
+	*
+	* @example
+	* ```ts
+	* const sliderScheduler = client.createScheduler({ mode: 'latest-wins' });
+	* const submitScheduler = client.createScheduler({ mode: 'queue', timeoutMs: 0 });
+	* ```
+	*/
+	createScheduler(options) {
+		this.ensureNotDisposed();
+		const scheduler = new SolveScheduler((definition, dataTree, cacheKey, config) => solveWithServerCacheKey(dataTree, cacheKey, definition, config), this.config, options);
+		this.schedulers.add(scheduler);
+		return scheduler;
+	}
+	/** Disposes of client resources, including every scheduler it created. */
+	async dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		for (const scheduler of this.schedulers) scheduler.dispose();
+		this.schedulers.clear();
+		await this.serverStats.dispose();
+	}
+	ensureNotDisposed() {
+		if (this.disposed) throw new ComputeError("GrasshopperClient has been disposed and cannot be used", ErrorCodes.INVALID_STATE);
+	}
+};
+// src/grasshopper/io/output/rhino-objects.ts
+/** Type guard for the {@link RhinoDecodeError} sentinel. */
+function isRhinoDecodeError(value) {
+	return typeof value === "object" && value !== null && value.__decodeError === true;
+}
+function makeDecodeError(rhinoType, raw) {
+	return {
+		__decodeError: true,
+		type: rhinoType,
+		raw
+	};
+}
+/**
+* Free every rhino3dm WASM object reachable from `value`.
+*
+* rhino3dm objects are emscripten bindings — JS GC never reclaims their WASM
+* heap allocation, so everything decoded from a solve response (`getValues`,
+* `getValue`) must be deleted explicitly or the heap
+* grows monotonically across solves (e.g. a UI decoding per slider tick).
+*
+* Walks arrays and plain objects recursively; anything exposing a `delete()`
+* method is treated as a WASM binding and freed (skipped if already deleted).
+* Safe to call more than once and on values containing no WASM objects.
+*/
+function disposeRhinoObjects(value) {
+	const seen = /* @__PURE__ */ new WeakSet();
+	const walk = (v) => {
+		if (!v || typeof v !== "object") return;
+		if (seen.has(v)) return;
+		seen.add(v);
+		const del = v.delete;
+		if (typeof del === "function") {
+			const isDeleted = v.isDeleted;
+			if (typeof isDeleted !== "function" || !isDeleted.call(v)) del.call(v);
+			return;
+		}
+		if (Array.isArray(v)) {
+			for (const item of v) walk(item);
+			return;
+		}
+		const proto = Object.getPrototypeOf(v);
+		if (proto === Object.prototype || proto === null) for (const item of Object.values(v)) walk(item);
+	};
+	walk(value);
+}
+// src/grasshopper/io/output/rhino-decoder.ts
+const decoders = /* @__PURE__ */ new Map([["Rhino.Geometry.Point3d", (rhino, data) => {
+	const d = data;
+	if (!d || typeof d.X !== "number") return null;
+	return new rhino.Point([
+		d.X,
+		d.Y,
+		d.Z
+	]);
+}], ["Rhino.Geometry.Line", (rhino, data) => {
+	const d = data;
+	if (!d || !d.From || !d.To) return null;
+	return new rhino.Line([
+		d.From.X,
+		d.From.Y,
+		d.From.Z
+	], [
+		d.To.X,
+		d.To.Y,
+		d.To.Z
+	]);
+}]]);
+/**
+* Whether the parsed item looks like a rhino3dm serialization envelope
+* (`{version, archive3dm, opennurbs, data: "<base64>"}`). `CommonObject.decode` expects the WHOLE
+* envelope — unwrapping `.data` first hands it the bare base64 string, which throws or decodes to
+* garbage.
+*/
+function isDecodableEnvelope(parsedData) {
+	return Boolean(parsedData && typeof parsedData === "object" && typeof parsedData.data === "string");
+}
+/**
+* Decode one typed payload from a solve response into a rhino3dm object.
+*
+* Every call yields exactly one of three outcomes:
+*
+* 1. **Decoded value** — a registered decoder recognized the shape, or the
+*    payload was a rhino3dm serialization envelope and `CommonObject.decode`
+*    succeeded.
+* 2. **Raw passthrough** (`=== parsedData`) — no decode path *applied*: no
+*    decoder matched the type (or the matched decoder returned `null`, meaning
+*    "not my shape") and the payload is not a decodable envelope. Not an error;
+*    the caller keeps the parsed JSON as-is.
+* 3. **{@link RhinoDecodeError} sentinel** — a decode was *attempted and threw*
+*    (a registered decoder threw and no envelope fallback could recover, or
+*    `CommonObject.decode` threw). Detect with {@link isRhinoDecodeError}.
+*
+* A decoder returning `null` is a soft miss, never an error: it falls through
+* to the envelope fallback.
+*/
+function decodeRhinoGeometry(parsedData, rhinoType, rhino) {
+	const decoder = decoders.get(rhinoType);
+	let decoderThrew = false;
+	if (decoder) try {
+		const decoded = decoder(rhino, parsedData);
+		if (decoded != null) return decoded;
+	} catch (error) {
+		getLogger().warn(`Failed to decode Rhino type ${rhinoType}:`, error);
+		decoderThrew = true;
+	}
+	try {
+		if (isDecodableEnvelope(parsedData)) return rhino.CommonObject.decode(parsedData);
+	} catch (error) {
+		getLogger().warn(`Failed to decode ${rhinoType} with CommonObject:`, error);
+		return makeDecodeError(rhinoType, parsedData);
+	}
+	return decoderThrew ? makeDecodeError(rhinoType, parsedData) : parsedData;
+}
+// src/grasshopper/io/output/response-processors.ts
+const RHINO_GEOMETRY_PREFIX = "Rhino.Geometry.";
+const FILE_DATA_TYPE = "FileData";
+/** WebDisplay items are skipped entirely: kept, they would write `null` into the result. */
+function skipItem(type, stringOnly) {
+	return type.includes("WebDisplay") || stringOnly && type !== "System.String";
+}
+const looksStructured = (text) => text.startsWith("{") || text.startsWith("[");
+function tryDecodeJSON(value) {
+	if (typeof value !== "string") return value;
+	const trimmed = value.trim();
+	if (!looksStructured(trimmed) && !trimmed.startsWith("\"")) return value;
+	const first = tryParseJson(trimmed) ?? value;
+	return typeof first === "string" && looksStructured(first.trim()) ? tryParseJson(first) ?? first : first;
+}
+function decodeBySystemType(raw, type, rhino) {
+	if (type === "System.String") return typeof raw === "string" ? raw.replace(/^"(.*)"$/, "$1") : raw;
+	if (INTEGER_ITEM_TYPES.has(type)) {
+		const value = Number.parseInt(String(raw), 10);
+		return Number.isNaN(value) || Number.isSafeInteger(value) ? value : raw;
+	}
+	if (NUMERIC_ITEM_TYPES.has(type)) return Number.parseFloat(String(raw));
+	if (type === "System.Boolean") return String(raw).toLowerCase() === "true";
+	if (rhino && type.startsWith(RHINO_GEOMETRY_PREFIX)) return decodeRhinoGeometry(raw, type, rhino);
+	return raw;
+}
+function extractItemValue(item, type, parseValues, rhino) {
+	if (typeof item.data !== "string") return item.data;
+	const raw = parseValues ? tryDecodeJSON(item.data) : item.data;
+	if (parseValues && type.includes(FILE_DATA_TYPE)) return asFileData(raw) ?? raw;
+	return decodeBySystemType(raw, type, rhino);
+}
+/**
+* A parsed `FileData` blob in the camelCase shape {@link FileData} documents, or
+* `null` when a required field is missing. Fields are read with `readField`,
+* since their casing varies by server branch.
+*/
+function asFileData(value) {
+	if (!value || typeof value !== "object") return null;
+	const fileName = readField(value, "fileName");
+	const fileType = readField(value, "fileType");
+	const subFolder = readField(value, "subFolder");
+	const flag = readField(value, "isBase64Encoded");
+	if (typeof fileName !== "string" || typeof fileType !== "string") return null;
+	if (typeof subFolder !== "string") return null;
+	if (!hasField(value, "data")) return null;
+	if (typeof flag !== "boolean" && typeof flag !== "string") return null;
+	const metadata = readField(value, "metadata");
+	return {
+		fileName,
+		fileType,
+		data: readField(value, "data"),
+		isBase64Encoded: isBase64Flag(flag),
+		subFolder,
+		...metadata ? { metadata } : {}
+	};
+}
+/** Partial-success and warnings-only responses can arrive with no `values` at all. */
+function getResponseParams(response) {
+	const values = readField(response, "values");
+	return Array.isArray(values) ? values : [];
+}
+/** A param's item type, tolerating items whose `type` is missing/non-string. */
+function itemType(item) {
+	return typeof item.type === "string" ? item.type : "";
+}
+/** Tolerates a missing tree (warnings-only partial successes) and skips non-object items. */
+function forEachTreeItem(tree, handler) {
+	if (!tree || typeof tree !== "object") return;
+	for (const list of Object.values(tree)) if (Array.isArray(list)) {
+		for (const item of list) if (item && typeof item === "object") handler(item);
+	}
+}
+/**
+* Read all output values from a Grasshopper Compute response, keyed by parameter
+* name (or ID when `byId`). Duplicate keys aggregate into an array.
+*
+* Geometry decoded via `rhino` lives on the WASM heap: free it with `dispose()`.
+*
+* @param options.parseValues - Parse complex data types into JS objects (default true).
+* @param options.rhino - Rhino3dm instance for geometry decoding.
+* @param options.stringOnly - Keep only string-typed items.
+*/
+function getValues(response, byId = false, options = {}) {
+	const { parseValues = true, rhino, stringOnly = false } = options;
+	const result = {};
+	const aggregated = /* @__PURE__ */ new Set();
+	for (const param of getResponseParams(response)) {
+		const paramName = readField(param, "paramName");
+		forEachTreeItem(readField(param, "innerTree"), (item) => {
+			const type = itemType(item);
+			if (skipItem(type, stringOnly)) return;
+			const key = byId ? item.id : paramName;
+			if (!key) return;
+			const value = extractItemValue(item, type, parseValues, rhino);
+			if (!Object.hasOwn(result, key)) setOwnField(result, key, value);
+			else if (aggregated.has(key)) result[key].push(value);
+			else {
+				result[key] = [result[key], value];
+				aggregated.add(key);
+			}
+		});
+	}
+	return {
+		values: result,
+		dispose: () => disposeRhinoObjects(result)
+	};
+}
+/** Decode every file-data item in a response into {@link FileData} objects. */
+function extractFileData(response) {
+	const output = [];
+	for (const param of getResponseParams(response)) forEachTreeItem(readField(param, "innerTree"), (item) => {
+		if (!itemType(item).includes(FILE_DATA_TYPE)) return;
+		const file = asFileData(tryDecodeJSON(item.data));
+		if (file) output.push(file);
+	});
+	return output;
+}
+/**
+* Read one parameter's value(s) from a response — `byName` matches a `ParamName`,
+* `byId` matches an item ID. Returns `undefined` if absent, a single value for one
+* match, or an array for several.
+*
+* Geometry decoded via `rhino` lives on the WASM heap: free it with
+* {@link disposeRhinoObjects} once consumed.
+*
+* @param parseOptions.parseValues - Parse raw data into formatted values (default true).
+* @param parseOptions.rhino - Rhino3dm instance for geometry decoding.
+* @param parseOptions.stringOnly - Keep only string-typed items.
+*/
+function getValue(response, options, parseOptions = {}) {
+	const { parseValues = true, rhino, stringOnly = false } = parseOptions;
+	for (const param of getResponseParams(response)) {
+		const tree = readField(param, "innerTree");
+		let matched = false;
+		if ("byName" in options) {
+			if (readField(param, "paramName") !== options.byName) continue;
+			matched = true;
+		}
+		const collected = [];
+		forEachTreeItem(tree, (item) => {
+			if ("byId" in options) {
+				if (item.id !== options.byId) return;
+				matched = true;
+			}
+			const type = itemType(item);
+			if (skipItem(type, stringOnly)) return;
+			collected.push(extractItemValue(item, type, parseValues, rhino));
+		});
+		if (matched) {
+			if (collected.length === 0) return void 0;
+			if (collected.length === 1) return collected[0];
+			return collected;
+		}
+	}
+}
+// src/grasshopper/client/grasshopper-response-processor.ts
+/** Reads parsed values and produced files out of one compute response. */
+var GrasshopperResponseProcessor = class {
+	response;
+	constructor(response) {
+		this.response = response;
+	}
+	/**
+	* Extract all values in the response.
+	*
+	* @typeParam T - Expected structure of the return value. Defaults to a simple key/value map. (later cast as needed)
+	* @param byId - Key by parameter ID instead of name. Requires the VektorNode rhino.compute branch.
+	* @param options - Controls parsing behavior such as Rhino geometry decoding.
+	* @returns Parsed Grasshopper output values.
+	*
+	* @example
+	* ```ts
+	* const processor = new GrasshopperResponseProcessor(response);
+	* const { values } = processor.getValues();
+	* ```
+	*
+	*/
+	getValues(byId = false, options = {}) {
+		return getValues(this.response, byId, options);
+	}
+	/**
+	* Retrieve a specific value by parameter name or ID.
+	*
+	* @param selector - `{ byName }` for the human-readable name, `{ byId }` for the parameter GUID.
+	* @param options - Parsing configuration (e.g. disable parsing or enable Rhino).
+	* @returns Single parsed value, array of values, or undefined if the parameter is absent.
+	*
+	* `byId` requires the VektorNode rhino.compute branch.
+	*
+	* @example
+	* ```ts
+	* const schema = processor.getValue({ byName: 'Schema' });
+	* const output = processor.getValue({ byId: 'a4be1c1e-23f9-4c27-b942-7f3bb2c45c6f' });
+	* ```
+	*/
+	getValue(selector, options) {
+		return getValue(this.response, selector, options);
+	}
+	/**
+	* Download all files generated by Grasshopper, optionally including
+	* additional user-provided files.
+	*
+	* @param folderName - Name of the zip archive, without the extension.
+	* @param additionalFiles - Extra files to package (single file, array, or null).
+	*
+	* @example
+	* ```ts
+	* await processor.getAndDownloadFiles('gh-output');
+	* ```
+	*
+	* @example
+	* ```ts
+	* const extra = { fileName: 'notes.txt', filePath: 'https://example.com/notes.txt' };
+	* await processor.getAndDownloadFiles('project', extra);
+	* ```
+	*/
+	async getAndDownloadFiles(folderName, additionalFiles) {
+		await downloadFileData(extractFileData(this.response), folderName, additionalFiles);
+	}
+};
+// src/grasshopper/io/schema-endpoint.ts
+/**
+* Read compute's `/grasshopper/schema` body: `[{ FileName, Schemas }]` per
+* uploaded file, or a bare object for a single file.
+*
+* Use this rather than unwrapping the body by hand: the wrapper keys' casing
+* varies by server branch, and a fixed-key read yields "no schemas" with a 200.
+* Only the two wrapper keys are read; schema contents pass through untouched.
+*
+* @typeParam TSchema - Your schema type (e.g. `UISchema`). Not inspected.
+*/
+function readSchemaResults(raw) {
+	return (Array.isArray(raw) ? raw : [raw]).map((entry) => ({
+		schemas: readField(entry, "schemas"),
+		error: readField(entry, "error")
+	}));
+}
+// src/grasshopper/io/normalize-ui-schema.ts
+/**
+* Canonicalize a `/grasshopper/schema` body's key casing.
+*
+* Compute serializes the plugin's `UISchema`, whose camelCase wire names live in
+* Newtonsoft `[JsonProperty]` attributes. `Selva.gha` ILRepack-merges Newtonsoft,
+* so those attributes are `Selva!Newtonsoft.Json.JsonPropertyAttribute`. When
+* compute's OWN Newtonsoft serializes, it doesn't recognize them, reads no
+* attributes, and emits raw CLR names (`Inputs`, `SchemaVersion`). Nothing throws:
+* `schema.inputs` reads `undefined`, and so does the `schemaVersion` gate.
+*
+* A casing rule, not a key allowlist: the wire names are the CLR names run
+* through Newtonsoft's camelCase strategy, so reproducing it covers every key
+* without drifting each time `UISchema` gains a field.
+*/
+/** Maps keyed by the definition's author (dropdown labels): copied verbatim. */
+const USER_AUTHORED_MAPS = /* @__PURE__ */ new Set([
+	"options",
+	"defaultOptions",
+	"values"
+]);
+/** Maps with author or hash keys whose entries are schema objects: keys verbatim, entries normalized. */
+const USER_KEYED_OBJECT_MAPS = /* @__PURE__ */ new Set(["optionMedia", "assets"]);
+const isUpper = (ch) => ch >= "A" && ch <= "Z";
+/**
+* Newtonsoft's `CamelCaseNamingStrategy`: a leading run of capitals is lowercased
+* whole, except the last one when a lowercase word follows. `UV` → `uv`,
+* `UVMapping` → `uvMapping` (a first-character rule gives `uVMapping`).
+*/
+function toCamelCase(key) {
+	if (key.length === 0 || !isUpper(key[0])) return key;
+	let run = 0;
+	while (run < key.length && isUpper(key[run])) run++;
+	if (run > 1 && run < key.length) run--;
+	return key.slice(0, run).toLowerCase() + key.slice(run);
+}
+/**
+* Returns a schema whose structural keys are camelCase, whichever Newtonsoft
+* serialized it. Always a fresh object the caller may mutate; non-objects are
+* returned as-is.
+*/
+function normalizeUISchemaCasing(raw) {
+	return normalizeValue(raw);
+}
+function normalizeValue(value) {
+	if (Array.isArray(value)) return value.map(normalizeValue);
+	if (value === null || typeof value !== "object") return value;
+	const out = {};
+	for (const [key, child] of Object.entries(value)) {
+		const canonical = toCamelCase(key);
+		setOwnField(out, canonical, USER_AUTHORED_MAPS.has(canonical) ? child : USER_KEYED_OBJECT_MAPS.has(canonical) ? normalizeEntries(child) : normalizeValue(child));
+	}
+	return out;
+}
+function normalizeEntries(value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return value;
+	const out = {};
+	for (const [key, child] of Object.entries(value)) setOwnField(out, key, normalizeValue(child));
+	return out;
+}
+// src/grasshopper/data-tree/data-tree.ts
+/**
+* Builds the Grasshopper data trees a solve takes as input.
+*
+* @example
+* ```ts
+* const tree = new TreeBuilder('MyParam')
+*   .append([0], [1, 2, 3])
+*   .append([1], [4, 5])
+*   .toComputeFormat();
+* ```
+*/
+var TreeBuilder = class TreeBuilder {
+	innerTree;
+	paramName;
+	constructor(paramName) {
+		this.paramName = paramName;
+		this.innerTree = {};
+	}
+	/** Append values to the branch at `path` (`[0, 1]` is `{0;1}`). A `null` item is skipped. */
+	append(path, items) {
+		const branch = this.innerTree[TreeBuilder.formatPathString(path)] ??= [];
+		for (const item of items) if (item !== null) branch.push({ data: TreeBuilder.serializeValue(item) });
+		return this;
+	}
+	/** Replace the tree with a branch-path map like `{ '{0;1}': [1, 2] }`. */
+	fromDataTreeDefault(treeData) {
+		this.innerTree = {};
+		for (const [pathStr, items] of Object.entries(treeData)) {
+			if (!Array.isArray(items)) continue;
+			const path = TreeBuilder.parsePathString(pathStr);
+			this.append(path, items);
+		}
+		return this;
+	}
+	/** Append a value, or each value of an array, to branch `{0}`. */
+	appendFlat(values) {
+		const items = Array.isArray(values) ? values : [values];
+		return this.append([0], items);
+	}
+	/** The tree in the shape a solve request sends. */
+	toComputeFormat() {
+		return {
+			ParamName: this.paramName,
+			InnerTree: this.innerTree
+		};
+	}
+	/**
+	* One tree per input that has a default, keyed by its nickname. Defaults are coerced and
+	* clamped by the same rules as {@link TreeBuilder.fromValues}.
+	*/
+	static fromInputParams(inputs) {
+		return TreeBuilder.fromValues(inputs.map((input) => ({
+			paramName: input.nickname || "unnamed",
+			paramType: input.paramType,
+			value: input.default,
+			..."minimum" in input && {
+				minimum: input.minimum,
+				maximum: input.maximum
+			}
+		})));
+	}
+	/**
+	* One tree per entry, coercing UI values the way Grasshopper reads them. Number and Integer
+	* items go through the numeric coercion (Integer rounds) and are clamped to
+	* `minimum`/`maximum`; Boolean items also accept `'true'`/`'false'`; every other type passes
+	* through. An item that fails coercion is dropped with a warning. An entry left with no items
+	* is omitted, so Grasshopper uses its own value; `''` is an item, not an empty value.
+	*/
+	static fromValues(entries) {
+		const trees = [];
+		for (const entry of entries) {
+			const tree = new TreeBuilder(entry.paramName);
+			const coerce = TreeBuilder.itemCoercer(entry);
+			for (const [path, items] of TreeBuilder.branchesOf(entry.value)) {
+				const kept = [];
+				for (const item of items) {
+					if (item === null || item === void 0) continue;
+					const coerced = coerce(item);
+					if (coerced === null) getLogger().warn(`${entry.paramName}: dropped an item that is not a valid ${entry.paramType}`);
+					else kept.push(coerced);
+				}
+				if (kept.length > 0) tree.append(path, kept);
+			}
+			if (Object.keys(tree.innerTree).length > 0) trees.push(tree.toComputeFormat());
+		}
+		return trees;
+	}
+	static branchesOf(value) {
+		if (!TreeBuilder.hasValidValue(value)) return [];
+		if (isDataTreeDefault(value)) return Object.entries(value).map(([path, items]) => [TreeBuilder.parsePathString(path), items]);
+		return [[[0], Array.isArray(value) ? value : [value]]];
+	}
+	/** `null` means the item was rejected. */
+	static itemCoercer(entry) {
+		const { paramName, minimum, maximum } = entry;
+		const paramType = entry.paramType.toLowerCase();
+		if (paramType === "number" || paramType === "integer") return (item) => {
+			const n = numericTransformer(item);
+			if (n === null) return null;
+			const value = paramType === "integer" ? Math.round(n) : n;
+			return TreeBuilder.clampValue(value, minimum, maximum, paramName);
+		};
+		if (paramType === "boolean") return booleanTransformer;
+		return (item) => item;
+	}
+	/**
+	* Set or add `paramName`'s tree to `newValue`: a scalar, an array (branch `{0}`), or a
+	* branch-path map. Copy-on-write: returns a new array and leaves the caller's untouched, so
+	* assign the result.
+	*/
+	static replaceTreeValue(trees, paramName, newValue) {
+		const compiled = TreeBuilder.buildFromValue(paramName, newValue).toComputeFormat();
+		const result = trees.slice();
+		const idx = result.findIndex((t) => TreeBuilder.paramNameOf(t) === paramName);
+		if (idx === -1) result.push(compiled);
+		else result[idx] = compiled;
+		return result;
+	}
+	static buildFromValue(paramName, value) {
+		const tree = new TreeBuilder(paramName);
+		if (isDataTreeDefault(value)) tree.fromDataTreeDefault(value);
+		else tree.appendFlat(value);
+		return tree;
+	}
+	/**
+	* `paramName`'s whole tree from a solve result's `values`, keyed by branch path (`'{0;1}'`).
+	* `null` when no tree has that param, an empty `Map` when it has no branches. An item without
+	* `data` reads as `null` in place, so indices don't shift.
+	*/
+	static getTree(trees, paramName) {
+		const tree = trees.find((t) => TreeBuilder.paramNameOf(t) === paramName);
+		if (!tree) return null;
+		const branches = /* @__PURE__ */ new Map();
+		const inner = readField(tree, "InnerTree");
+		if (!inner || typeof inner !== "object") return branches;
+		for (const [path, items] of Object.entries(inner)) {
+			if (!Array.isArray(items)) continue;
+			branches.set(path, items.map((item) => item?.data !== void 0 ? TreeBuilder.deserializeValue(item.data) : null));
+		}
+		return branches;
+	}
+	/**
+	* `paramName`'s value when its tree has a single branch: one item unwrapped (`5`, not `[5]`),
+	* several as an array. `null` for a missing param or an empty tree.
+	*
+	* @throws {ComputeError} `INVALID_INPUT` when the tree has more than one branch; read those
+	*   with {@link TreeBuilder.getTree}.
+	*/
+	static getTreeValue(trees, paramName) {
+		const tree = TreeBuilder.getTree(trees, paramName);
+		if (!tree || tree.size === 0) return null;
+		if (tree.size > 1) throw new ComputeError(`"${paramName}" has ${tree.size} branches; read it with TreeBuilder.getTree`, ErrorCodes.INVALID_INPUT, { context: {
+			paramName,
+			branchCount: tree.size
+		} });
+		const [items] = tree.values();
+		if (items.length === 0) return null;
+		return items.length === 1 ? items[0] : items;
+	}
+	static paramNameOf(tree) {
+		return readField(tree, "ParamName");
+	}
+	/**
+	* Parse a branch path like `"{0;1;2}"` into `[0, 1, 2]`.
+	*
+	* @throws {ComputeError} `INVALID_INPUT` for a malformed path, rather than
+	*   collapsing it to a default branch where two bad keys would merge.
+	*/
+	static parsePathString(pathStr) {
+		const match = pathStr.match(TREE_PATH_RE);
+		if (!match) throw new ComputeError(`Invalid Grasshopper tree path: "${pathStr}". Expected "{}", "{0}", or "{0;1;2}" (negative indices allowed, no empty segments).`, ErrorCodes.INVALID_INPUT, { context: { pathStr } });
+		if (!match[1]) return [];
+		return match[1].split(";").map(Number);
+	}
+	/** `[0, 1, 2]` → `"{0;1;2}"`. */
+	static formatPathString(path) {
+		return `{${path.join(";")}}`;
+	}
+	/** Booleans and numbers stay primitives: Grasshopper reads them typed. */
+	static serializeValue(value) {
+		return typeof value === "object" ? JSON.stringify(value) : value;
+	}
+	static deserializeValue(data) {
+		if (typeof data !== "string") return data;
+		if (data.startsWith("{") || data.startsWith("[")) try {
+			return JSON.parse(data);
+		} catch {
+			return data;
+		}
+		const num = Number(data);
+		if (Number.isFinite(num) && String(num) === data) return num;
+		if (data === "true") return true;
+		if (data === "false") return false;
+		return data;
+	}
+	static hasValidValue(value) {
+		if (value === void 0 || value === null) return false;
+		if (typeof value === "string") return true;
+		if (Array.isArray(value) && value.length === 0) return false;
+		if (typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 0) return false;
+		return true;
+	}
+	static clampValue(value, min, max, inputName) {
+		let result = value;
+		if (min !== null && min !== void 0 && result < min) {
+			getLogger().warn(`${inputName}: ${value} below min ${min}, clamping`);
+			result = min;
+		}
+		if (max !== null && max !== void 0 && result > max) {
+			getLogger().warn(`${inputName}: ${value} above max ${max}, clamping`);
+			result = max;
+		}
+		return result;
+	}
+};
+export { ComputeServerStats, GrasshopperClient, GrasshopperResponseProcessor, SolveScheduler, TreeBuilder, disposeRhinoObjects, fetchDefinitionIO, fetchParsedDefinitionIO, hashDefinition, hashSolveInput, isRhinoDecodeError, normalizeUISchemaCasing, processInput, readSchemaResults, solveGrasshopperDefinition, stableStringify };
+
 //# sourceMappingURL=grasshopper.js.map