@selvajs/selva 4.20.0-beta.1 → 4.20.0-beta.11

package/build/server/chunks/chunks/grasshopper.js-julMp0aw.js

@@ -0,0 +1,2652 @@
+//#region ../compute/dist/core-CFlbOj2M.js
+var e = {
+	NETWORK_ERROR: `NETWORK_ERROR`,
+	AUTH_ERROR: `AUTH_ERROR`,
+	VALIDATION_ERROR: `VALIDATION_ERROR`,
+	COMPUTATION_ERROR: `COMPUTATION_ERROR`,
+	TIMEOUT_ERROR: `TIMEOUT_ERROR`,
+	CORS_ERROR: `CORS_ERROR`,
+	NOT_FOUND: `NOT_FOUND`,
+	RATE_LIMIT: `RATE_LIMIT`,
+	INVALID_RESPONSE: `INVALID_RESPONSE`,
+	RESPONSE_TOO_LARGE: `RESPONSE_TOO_LARGE`,
+	UNKNOWN_ERROR: `UNKNOWN_ERROR`,
+	INVALID_STATE: `INVALID_STATE`,
+	INVALID_INPUT: `INVALID_INPUT`,
+	INVALID_CONFIG: `INVALID_CONFIG`,
+	BROWSER_ONLY: `BROWSER_ONLY`,
+	ENVIRONMENT_ERROR: `ENVIRONMENT_ERROR`,
+	ENCODING_ERROR: `ENCODING_ERROR`,
+	MALFORMED_DEFAULT: `MALFORMED_DEFAULT`,
+	SUPERSEDED: `SUPERSEDED`,
+	ABORTED: `ABORTED`,
+	QUEUE_FULL: `QUEUE_FULL`,
+	QUEUE_TIMEOUT: `QUEUE_TIMEOUT`,
+	DEFINITION_NOT_CACHED: `DEFINITION_NOT_CACHED`
+};
+var t = class extends Error {
+	code;
+	statusCode;
+	context;
+	originalError;
+	constructor(t, n = e.UNKNOWN_ERROR, r) {
+		if (super(t), this.name = `ComputeError`, this.code = n, this.statusCode = r?.statusCode, this.context = r?.context, r?.originalError !== void 0) {
+			let e = r.originalError;
+			this.originalError = e instanceof Error ? e : Error(String(e)), this.cause = this.originalError;
+		}
+	}
+};
+var n = {
+	debug() {},
+	info() {},
+	warn() {},
+	error() {}
+};
+var r = n;
+function i() {
+	return r;
+}
+function a(i) {
+	if (i === null) {
+		r = n;
+		return;
+	}
+	let a = [
+		`debug`,
+		`info`,
+		`warn`,
+		`error`
+	].filter((e) => typeof i[e] != `function`);
+	if (a.length > 0) throw new t(`Logger is missing required method(s): ${a.join(`, `)}. A logger must implement debug, info, warn and error.`, e.INVALID_CONFIG, { context: { missingMethods: a } });
+	r = i;
+}
+function o() {
+	a(console);
+}
+function s(e, t) {
+	if (!e || typeof e != `object`) return;
+	if (Object.prototype.hasOwnProperty.call(e, t)) return t;
+	let n = t.toLowerCase();
+	return Object.keys(e).find((e) => e.toLowerCase() === n);
+}
+function c(e, t) {
+	let n = s(e, t);
+	return n === void 0 ? void 0 : e[n];
+}
+function l(e, t) {
+	return s(e, t) !== void 0;
+}
+function d(n, r) {
+	let i = n?.trim() ?? ``;
+	if (!i) throw new t(`serverUrl is required`, e.INVALID_CONFIG, { context: { receivedServerUrl: n } });
+	let a = (r, a) => new t(`Invalid serverUrl: "${i}". ${r}`, e.INVALID_CONFIG, {
+		context: { receivedServerUrl: n },
+		originalError: a
+	});
+	if (!/^https?:\/\//i.test(i)) throw a(`Must start with "http://" or "https://". For example: "http://localhost:6500" or "https://example.com"`);
+	let o;
+	try {
+		o = new URL(i);
+	} catch (e) {
+		throw a(`Must be a valid URL. Received error: ${e instanceof Error ? e.message : String(e)}`, e);
+	}
+	if (o.username !== `` || o.password !== ``) throw a(`Must not embed credentials (user:pass@host) — fetch rejects credentialed URLs at request time. Pass the API key separately.`);
+	if (i.includes(`?`) || i.includes(`#`)) throw a("Must not contain a query string or fragment — endpoint paths are appended to this URL (e.g. \"${serverUrl}/version\"), and a \"?\" or \"#\" suffix would corrupt every request path.");
+	let s = f(o.hostname.toLowerCase(), `.`);
+	if ((r?.blockedHosts ?? [`compute.rhino3d.com`]).map((e) => f(e.toLowerCase(), `.`)).includes(s)) throw new t(`serverUrl must be set to your Compute server URL. The shared public endpoint is not allowed.`, e.INVALID_CONFIG, { context: { receivedServerUrl: n } });
+	return f(i, `/`);
+}
+function f(e, t) {
+	let n = e.length;
+	for (; n > 0 && e[n - 1] === t;) n--;
+	return e.slice(0, n);
+}
+function p(e, t) {
+	return `${t}/${e.replace(/^\/+/, ``)}`;
+}
+function m(e) {
+	try {
+		let t = new URL(e).hostname.toLowerCase();
+		return t === `localhost` || t === `127.0.0.1` || t === `[::1]`;
+	} catch {
+		return /(localhost|127\.0\.0\.1|\[::1\])/i.test(e);
+	}
+}
+var h = /* @__PURE__ */ new Set();
+function g$1(e) {
+	return y$1(e.headers, v$1(e));
+}
+function _$1(e, t) {
+	let n = y$1(t.headers, {
+		...v$1(t),
+		"X-Request-ID": e,
+		"Content-Type": `application/json`
+	});
+	return !t.apiKey && !t.authToken && !h.has(t.serverUrl) && !m(t.serverUrl) && (h.add(t.serverUrl), i().warn(`⚠️ [Compute] Request [${e}] targets remote server (${t.serverUrl}) but no API key or auth token is configured. Requests may fail or be rate-limited. (warned once per server)`)), n;
+}
+function v$1(e) {
+	return {
+		...e.authToken && { Authorization: e.authToken },
+		...e.apiKey && { [e.apiKeyHeader ?? `RhinoComputeKey`]: e.apiKey }
+	};
+}
+function y$1(e, t) {
+	let n = new Set(Object.keys(t).map((e) => e.toLowerCase())), r = Object.entries(e ?? {}).filter(([e]) => !n.has(e.toLowerCase()));
+	return {
+		...Object.fromEntries(r),
+		...t
+	};
+}
+function b$1() {
+	return `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+}
+function x$1() {
+	let e = globalThis.Buffer;
+	return typeof e == `function` ? e : void 0;
+}
+function ee(e) {
+	let t = x$1();
+	return t ? t.from(e, `utf-8`).toString(`base64`) : T$1(new TextEncoder().encode(e));
+}
+function te(e) {
+	let t = S$1(e);
+	return t === null || /[^A-Za-z0-9+/]/.test(t) ? null : t;
+}
+function S$1(e) {
+	let t = e.replace(/[\t\n\f\r ]/g, ``);
+	return t.length % 4 == 0 && (t = t.replace(/={1,2}$/, ``)), t.length % 4 == 1 ? null : t;
+}
+function ne(e) {
+	let t = te(e);
+	if (t === null || t.length < 64) return null;
+	let n = t.length % 4, r = `ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/`.indexOf(t.charAt(t.length - 1));
+	return n === 2 && r & 15 || n === 3 && r & 3 ? null : n === 0 ? t : t + `==`.slice(0, 4 - n);
+}
+function C$1(n) {
+	let r = S$1(n), i = r === null ? null : re(r);
+	if (i === null) throw new t(`Invalid base64 input.`, e.ENCODING_ERROR, { context: { inputLength: n.length } });
+	return i;
+}
+function re(n) {
+	let r = x$1();
+	if (r) {
+		if (r.byteLength(n, `utf8`) !== n.length || n.includes(`-`) || n.includes(`_`)) return null;
+		let e = r.from(n, `base64`);
+		return e.length === Math.floor(n.length * 3 / 4) ? e.byteOffset === 0 && e.buffer.byteLength === e.length ? new Uint8Array(e.buffer, 0, e.length) : new Uint8Array(e) : null;
+	}
+	if (typeof globalThis.atob == `function`) {
+		let e;
+		try {
+			e = globalThis.atob(n);
+		} catch {
+			return null;
+		}
+		let t = new Uint8Array(e.length);
+		for (let n = 0; n < e.length; n++) t[n] = e.charCodeAt(n) & 255;
+		return t;
+	}
+	throw new t(`Base64 decoding not supported in this environment.`, e.ENVIRONMENT_ERROR, { context: { environmentInfo: `atob or Buffer not available` } });
+}
+function w$1(e) {
+	let t = x$1();
+	if (t) return t.byteLength(e, `utf-8`);
+	let n = 0;
+	for (let t = 0; t < e.length; t++) {
+		let r = e.charCodeAt(t);
+		r < 128 ? n += 1 : r < 2048 ? n += 2 : r >= 55296 && r <= 56319 && t + 1 < e.length && (e.charCodeAt(t + 1) & 64512) == 56320 ? (n += 4, t++) : n += 3;
+	}
+	return n;
+}
+function T$1(n) {
+	let r = x$1();
+	if (r) return r.from(n).toString(`base64`);
+	if (typeof globalThis.btoa == `function`) {
+		let e = 32766, t = [];
+		for (let r = 0; r < n.length; r += e) t.push(globalThis.btoa(String.fromCharCode.apply(null, n.subarray(r, r + e))));
+		return t.join(``);
+	}
+	throw new t(`Base64 encoding not supported in this environment.`, e.ENVIRONMENT_ERROR, { context: { environmentInfo: `btoa or Buffer not available` } });
+}
+var E$1 = 1 << 20;
+async function D$1(e, t = 1 / 0) {
+	if (t === 1 / 0) return {
+		text: await e.text(),
+		truncated: false
+	};
+	if (!e.body) {
+		let n = await e.text();
+		return {
+			text: n,
+			truncated: w$1(n) > t
+		};
+	}
+	let n = Number(e.headers.get(`Content-Length`));
+	if (!e.headers.has(`Content-Encoding`) && n > t) return await e.body.cancel().catch(() => {}), {
+		text: ``,
+		truncated: true
+	};
+	let r = e.body.getReader(), i = new TextDecoder(), a = [], o = 0;
+	for (;;) {
+		let { done: e, value: n } = await r.read();
+		if (e) break;
+		if (o += n.byteLength, a.push(i.decode(n, { stream: true })), o > t) return await r.cancel().catch(() => {}), {
+			text: a.join(``),
+			truncated: true
+		};
+	}
+	return a.push(i.decode()), {
+		text: a.join(``),
+		truncated: false
+	};
+}
+function ie$1(e) {
+	if (!e) return null;
+	let t = { raw: e }, n = false;
+	for (let r of e.split(`,`)) {
+		let [e, ...i] = r.trim().split(`;`), a = i.find((e) => e.trim().toLowerCase().startsWith(`dur`));
+		if (!a) continue;
+		let o = Number(a.split(`=`)[1]);
+		if (!Number.isFinite(o)) continue;
+		let s = e.trim().toLowerCase();
+		(s === `decode` || s === `solve` || s === `encode`) && (t[s] = o, n = true);
+	}
+	return n ? t : null;
+}
+function O$1(e, t, n, r) {
+	if (!n) return;
+	let a = ie$1(e.headers.get(`Server-Timing`));
+	if (a) try {
+		n(a, t);
+	} catch (e) {
+		r && i().debug(`   onServerTiming callback threw: ${e}`);
+	}
+}
+function k$1(e) {
+	return e instanceof Error && (e.name === `AbortError` || e.name === `TimeoutError`);
+}
+function ae$1(e, t) {
+	let n = () => {};
+	if (typeof t != `number` || t <= 0) return {
+		signal: e,
+		cleanup: n
+	};
+	let r = AbortSignal.timeout(t);
+	if (!e) return {
+		signal: r,
+		cleanup: n
+	};
+	let i = new AbortController(), a = [e, r], o = function() {
+		i.abort(this.reason);
+	};
+	for (let e of a) {
+		if (e.aborted) {
+			i.abort(e.reason);
+			break;
+		}
+		e.addEventListener(`abort`, o, { once: true });
+	}
+	return {
+		signal: i.signal,
+		cleanup: () => {
+			for (let e of a) e.removeEventListener(`abort`, o);
+		}
+	};
+}
+var A$1 = /* @__PURE__ */ new WeakMap();
+function j$1(e, t) {
+	typeof e == `object` && e && A$1.set(e, t);
+}
+function oe$1(e) {
+	if (typeof e == `object` && e) return A$1.get(e);
+}
+var M$1 = 4096;
+function se$1(e) {
+	return e.length <= M$1 ? e : `${e.slice(0, M$1)}… [truncated ${e.length - M$1} chars]`;
+}
+function ce$1(n, r, i, a, o) {
+	let { status: s, statusText: c } = n, { fullUrl: l, requestId: u, requestSize: d, config: f } = r, p = Object.fromEntries(n.headers.entries()), m = a.trim(), h = m ? ` — ${m.slice(0, 200)}${m.length > 200 ? `…` : ``}` : ``, g = {
+		url: l,
+		requestId: u,
+		method: `POST`,
+		requestSize: d,
+		serverUrl: f.serverUrl,
+		responseBody: i ? se$1(i) : void 0,
+		responseHeaders: p
+	}, _ = {
+		400: {
+			message: `Bad request: ${c}${h}`,
+			code: e.VALIDATION_ERROR
+		},
+		401: {
+			message: `HTTP ${s}: ${c}${h}`,
+			code: e.AUTH_ERROR
+		},
+		403: {
+			message: `HTTP ${s}: ${c}${h}`,
+			code: e.AUTH_ERROR
+		},
+		404: {
+			message: `Endpoint not found: ${l}`,
+			code: e.NOT_FOUND
+		},
+		413: {
+			message: `Request too large: ${(d / 1024).toFixed(2)}KB`,
+			code: e.VALIDATION_ERROR
+		},
+		429: {
+			message: `Rate limit exceeded${h}`,
+			code: e.RATE_LIMIT
+		},
+		500: {
+			message: `Server error: ${c}${h}`,
+			code: e.COMPUTATION_ERROR
+		},
+		502: {
+			message: `Bad gateway: ${c}${h}`,
+			code: e.NETWORK_ERROR
+		},
+		503: {
+			message: `Service unavailable: ${c}${h}`,
+			code: e.NETWORK_ERROR
+		},
+		504: {
+			message: `Gateway timeout: ${c}${h}`,
+			code: e.NETWORK_ERROR
+		}
+	}[s] || {
+		message: `HTTP ${s}: ${c}${h}`,
+		code: e.UNKNOWN_ERROR
+	}, v = f.serverErrorCodes, y = o && v && Object.prototype.hasOwnProperty.call(v, o) ? v[o] : void 0;
+	throw new t(_.message, y ?? _.code, {
+		statusCode: s,
+		context: g
+	});
+}
+function N$1(e) {
+	return e.type === `opaqueredirect` || e.status >= 300 && e.status < 400;
+}
+function le$1(n, r) {
+	let i = n.headers.get(`Location`) ?? void 0;
+	return new t(`Server redirected the request${i ? ` to ${i}` : ``}. Redirects are not followed, so credentials never leave serverUrl: set serverUrl to the address it redirects to.`, e.INVALID_CONFIG, {
+		...n.status > 0 && { statusCode: n.status },
+		context: {
+			url: r.fullUrl,
+			requestId: r.requestId,
+			location: i
+		}
+	});
+}
+function P$1(n, r) {
+	let { maxResponseBytes: i } = r.config;
+	return new t(`Response body exceeded maxResponseBytes (${i} bytes)`, e.RESPONSE_TOO_LARGE, {
+		statusCode: n.status,
+		context: {
+			url: r.fullUrl,
+			requestId: r.requestId,
+			maxResponseBytes: i
+		}
+	});
+}
+async function ue$1(n, r, a) {
+	let { requestId: o, config: s } = r, { debug: l, onServerTiming: u, maxResponseBytes: d = 1 / 0 } = s, f = Math.round(performance.now() - a);
+	if (N$1(n)) throw await n.body?.cancel().catch(() => {}), le$1(n, r);
+	if (!n.ok) {
+		let e = n.status === 500, { text: t, truncated: a } = await D$1(n, e ? d : Math.min(E$1, d));
+		if (a && e) throw P$1(n, r);
+		if (l) {
+			let e = i();
+			e.debug(`❌ Request [${o}] failed with HTTP ${n.status} in ${f}ms`), e.debug(`   URL: ${r.fullUrl}`), e.debug(`   Status: ${n.status} ${n.statusText}`), t && e.debug(`   Response body: ${t.substring(0, 500)}${t.length > 500 ? `...` : ``}`);
+		}
+		let s, p = !a;
+		if (p) try {
+			s = JSON.parse(t);
+		} catch (t) {
+			p = false, l && e && i().debug(`   Failed to parse error body as JSON: ${t}`);
+		}
+		let m = typeof s?.code == `string` ? s.code : void 0, h = t;
+		if (e && p) {
+			let e = c(s, `values`), r = c(s, `errors`), a = c(s, `warnings`);
+			if (e && (r || a)) {
+				if (j$1(s, t.length), l) {
+					let e = i();
+					e.debug(`⚠️ Request [${o}] completed with solver errors in ${f}ms`), r && r.length > 0 && e.debug(`   Errors: ${JSON.stringify(r, null, 2)}`), a && a.length > 0 && e.debug(`   Warnings: ${JSON.stringify(a, null, 2)}`);
+				}
+				return O$1(n, o, u, l), s;
+			}
+			let d = typeof s?.message == `string` && s.message || typeof s?.Message == `string` && s.Message || ``, p = typeof s?.ExceptionType == `string` && s.ExceptionType || ``, m = s?.stackTrace ?? s?.StackTrace, g = Array.isArray(m) ? m.join(`
+`) : m || ``;
+			d ? h = `${p ? `${p}: ` : ``}${d}${g ? `\n${g}` : ``}` : s?.error && (h = typeof s.error == `string` ? s.error : JSON.stringify(s.error, null, 2));
+		}
+		ce$1(n, r, t, h, m);
+	}
+	l && i().debug(`✅ Request [${o}] completed in ${f}ms`), O$1(n, o, u, l);
+	try {
+		let { text: e, truncated: t } = await D$1(n, d);
+		if (t) throw P$1(n, r);
+		let i = JSON.parse(e);
+		return j$1(i, e.length), i;
+	} catch (i) {
+		if (k$1(i) || i instanceof t) throw i;
+		let a = (n.headers.get(`Content-Type`) ?? ``).toLowerCase();
+		throw a !== `` && !a.includes(`json`) ? new t(`Server returned a non-JSON response (Content-Type: ${a}) — check the server URL / proxy configuration`, e.INVALID_RESPONSE, {
+			statusCode: n.status,
+			context: {
+				url: r.fullUrl,
+				requestId: o,
+				contentType: a
+			},
+			originalError: i
+		}) : new t(`Failed to parse JSON response`, e.NETWORK_ERROR, {
+			statusCode: n.status,
+			context: {
+				url: r.fullUrl,
+				requestId: o
+			},
+			originalError: i
+		});
+	}
+}
+var F$1 = /ECONNREFUSED|ERR_CONNECTION_REFUSED|connection refused/i;
+var I$1 = /ENOTFOUND|EAI_AGAIN|getaddrinfo|ERR_NAME_NOT_RESOLVED|dns/i;
+var L$1 = /TimeoutError|ETIMEDOUT|ECONNRESET|EHOSTUNREACH|ENETUNREACH|abort|timed? ?out/i;
+function R$1(e) {
+	if (e.online) return null;
+	if (e.status !== void 0) {
+		if (e.status === 401 || e.status === 403) return {
+			verdict: `unauthorized`,
+			retryable: false,
+			summary: `The server rejected the liveness probe with HTTP ${e.status} — check the API key.`
+		};
+		let t = e.status >= 500;
+		return {
+			verdict: `http_error`,
+			retryable: t,
+			summary: t ? `The server answered HTTP ${e.status} — it may still be starting up.` : `The server answered HTTP ${e.status}, which will not change on retry.`
+		};
+	}
+	let t = e.error ?? ``;
+	return F$1.test(t) ? {
+		verdict: `refused`,
+		retryable: false,
+		summary: `Connection refused — the host is reachable but nothing is listening on that port. Rhino.Compute is not running, or the URL names the wrong port.`
+	} : I$1.test(t) ? {
+		verdict: `dns`,
+		retryable: true,
+		summary: `The server hostname could not be resolved — check the URL and DNS.`
+	} : L$1.test(t) ? {
+		verdict: `timeout`,
+		retryable: true,
+		summary: `No response before the timeout — the machine may be powered off, blocked by a firewall, or still booting.`
+	} : {
+		verdict: `unknown`,
+		retryable: true,
+		summary: t ? `The connection failed: ${t}` : `The connection failed.`
+	};
+}
+var z$1 = {
+	attempts: 0,
+	baseDelayMs: 500,
+	maxDelayMs: 3e4,
+	retryOn429: true
+};
+var B$1 = /* @__PURE__ */ new Set([
+	502,
+	503,
+	504
+]);
+function V$1(e) {
+	return e ? {
+		attempts: e.attempts ?? z$1.attempts,
+		baseDelayMs: e.baseDelayMs ?? z$1.baseDelayMs,
+		maxDelayMs: e.maxDelayMs ?? z$1.maxDelayMs,
+		retryOn429: e.retryOn429 ?? z$1.retryOn429
+	} : z$1;
+}
+function H$1(e, t) {
+	return B$1.has(e) || t.retryOn429 && e === 429;
+}
+function U$1(e, t, n) {
+	let r = de$1(e);
+	return r === null ? W$1(t, n) : Math.min(r, Math.max(n.maxDelayMs, 6e4));
+}
+function de$1(e) {
+	if (!e) return null;
+	let t = Number(e);
+	if (Number.isFinite(t) && t >= 0) return t * 1e3;
+	let n = Date.parse(e);
+	if (Number.isFinite(n)) {
+		let e = n - Date.now();
+		return e > 0 ? e : 0;
+	}
+	return null;
+}
+function W$1(e, t) {
+	let n = t.baseDelayMs * 2 ** e, r = Math.random() * t.baseDelayMs;
+	return Math.min(n + r, t.maxDelayMs);
+}
+function fe$1(e, t) {
+	return new Promise((n, r) => {
+		if (t?.aborted) {
+			r(new DOMException(`Aborted`, `AbortError`));
+			return;
+		}
+		let i = setTimeout(() => {
+			t?.removeEventListener(`abort`, a), n();
+		}, e), a = () => {
+			clearTimeout(i), r(new DOMException(`Aborted`, `AbortError`));
+		};
+		t?.addEventListener(`abort`, a, { once: true });
+	});
+}
+function G$1(n, r) {
+	return new t(`Request aborted by caller`, e.ABORTED, {
+		context: n.errorContext,
+		originalError: r
+	});
+}
+async function pe$1(n, r, i, a) {
+	let { signal: o, cleanup: s } = ae$1(n.config.signal, n.config.timeoutMs), c = performance.now();
+	try {
+		let s = await fetch(n.fullUrl, {
+			method: `POST`,
+			body: n.body,
+			headers: n.headers,
+			signal: o,
+			redirect: `manual`
+		});
+		return !a && H$1(s.status, r) ? (await D$1(s, E$1).catch(() => {}), {
+			ok: !1,
+			retryable: !0,
+			delayMs: U$1(s.headers.get(`Retry-After`), i, r),
+			cause: new t(`HTTP ${s.status} ${s.statusText} (will retry)`, s.status === 429 ? e.RATE_LIMIT : e.NETWORK_ERROR, {
+				statusCode: s.status,
+				context: n.errorContext
+			})
+		}) : {
+			ok: !0,
+			value: await ue$1(s, n, c)
+		};
+	} catch (e) {
+		return me$1(e, n);
+	} finally {
+		s();
+	}
+}
+function me$1(n, r) {
+	if (k$1(n)) {
+		if (r.config.signal?.aborted) return {
+			ok: false,
+			retryable: false,
+			cause: G$1(r, n)
+		};
+		let { timeoutMs: i } = r.config;
+		return {
+			ok: false,
+			retryable: true,
+			cause: typeof i == `number` && i > 0 ? new t(`Request timed out after ${i}ms`, e.TIMEOUT_ERROR, {
+				context: {
+					...r.errorContext,
+					timeoutMs: i
+				},
+				originalError: n
+			}) : new t(`Request aborted by the runtime (${n.name}): ${n.message}`, e.NETWORK_ERROR, {
+				context: r.errorContext,
+				originalError: n
+			})
+		};
+	}
+	if (n instanceof TypeError) return {
+		ok: false,
+		retryable: true,
+		cause: typeof window < `u` && window.document !== void 0 ? new t(`Request failed: ${n.message} — in a browser this usually means a CORS misconfiguration on the server (or a network failure; the browser does not distinguish them)`, e.CORS_ERROR, {
+			context: r.errorContext,
+			originalError: n
+		}) : new t(`Network error: ${n.message}`, e.NETWORK_ERROR, {
+			context: r.errorContext,
+			originalError: n
+		})
+	};
+	if (n instanceof t) {
+		let t = n.statusCode;
+		return {
+			ok: false,
+			retryable: n.code === e.NETWORK_ERROR && t !== void 0 && t >= 200 && t < 300,
+			cause: n
+		};
+	}
+	return {
+		ok: false,
+		retryable: false,
+		cause: new t(n instanceof Error ? n.message : String(n), e.UNKNOWN_ERROR, {
+			context: r.errorContext,
+			originalError: n
+		})
+	};
+}
+async function he$1(n, r, a) {
+	let o = b$1(), s;
+	try {
+		s = JSON.stringify(r);
+	} catch (r) {
+		throw new t(`Request body is not JSON-serializable: ${r instanceof Error ? r.message : String(r)}`, e.INVALID_INPUT, {
+			context: {
+				endpoint: n,
+				requestId: o
+			},
+			originalError: r
+		});
+	}
+	let c = w$1(s), l = d(a.serverUrl, { blockedHosts: [] }), { maxResponseBytes: u } = a;
+	if (u !== void 0 && !(u >= 0)) throw new t(`maxResponseBytes must be a number of bytes, got ${u}`, e.INVALID_CONFIG, { context: { maxResponseBytes: u } });
+	let f = p(n, l), m = _$1(o, a), h = V$1(a.retry), g = h.attempts + 1;
+	if (a.debug) {
+		let e = (c / 1024).toFixed(2), t = c > 1e5 ? `⚠️` : `🚀`;
+		i().debug(`${t} Starting compute request [${o}]: ${n} (${e}KB)`);
+	}
+	let v = {
+		endpoint: n,
+		body: s,
+		requestSize: c,
+		fullUrl: f,
+		requestId: o,
+		headers: m,
+		config: a,
+		errorContext: {
+			serverUrl: l,
+			url: f,
+			endpoint: n,
+			requestId: o,
+			requestSize: c
+		}
+	};
+	for (let e = 0;; e++) {
+		let t = e >= h.attempts, n = await pe$1(v, h, e, t);
+		if (n.ok) return n.value;
+		if (t || !n.retryable) throw n.cause;
+		let r = n.delayMs ?? W$1(e, h);
+		a.debug && i().debug(`🔁 Request [${o}] retrying after ${r}ms (attempt ${e + 2}/${g}): ${n.cause.message}`);
+		try {
+			await fe$1(r, a.signal);
+		} catch {
+			throw G$1(v, n.cause);
+		}
+	}
+}
+function ge$1(e) {
+	return typeof e == `object` && !(e instanceof Uint8Array) && typeof e.key == `string` && typeof e.load == `function`;
+}
+function _e$1(e) {
+	return typeof e == `string` && /^https?:\/\//i.test(e);
+}
+var K$1 = (e) => (e ?? ``).replace(/::/g, `/`).replace(/\\/g, `/`).split(`/`).map((e) => e.trim()).filter((e) => e !== ``);
+var ve$1 = (e) => K$1(e.subFolder)[0] ?? ``;
+var ye$1 = (e) => K$1(e.subFolder).slice(1).join(`/`);
+var q$1 = (e) => {
+	let t = /* @__PURE__ */ new Map();
+	for (let n of e) {
+		let e = ve$1(n), r = t.get(e);
+		r ? r.push(n) : t.set(e, [n]);
+	}
+	return Array.from(t, ([e, t]) => ({
+		root: e,
+		files: t
+	}));
+};
+var be$1 = (e) => {
+	let t = e.replace(/[/\\:*?"<>|]/g, `_`).replace(/\s+/g, ` `).trim().replace(/^\.+/, ``);
+	return t === `` ? `files` : t;
+};
+var J$1 = async (e, t = null) => {
+	let n = xe$1(e);
+	if (t) {
+		let e = Array.isArray(t) ? t : [t];
+		n.push(...await Se$1(e));
+	}
+	let r = /* @__PURE__ */ new Set();
+	return n.map((e) => {
+		let t = $$1(e.path, r);
+		return r.add(t), t === e.path ? e : (i().warn(`Duplicate archive path "${e.path}" — storing as "${t}".`), {
+			...e,
+			path: t,
+			fileName: t.slice(t.lastIndexOf(`/`) + 1)
+		});
+	});
+};
+var Y$1 = async (n, r, i = null, a = {}) => {
+	if (typeof document > `u` || typeof Blob > `u`) throw new t(`File download functionality is only available in browser environments. This function requires the DOM API (document, Blob).`, e.BROWSER_ONLY, { context: {
+		environment: typeof window < `u` ? `browser (SSR)` : `Node.js`,
+		documentAvailable: typeof document < `u`,
+		blobAvailable: typeof Blob < `u`
+	} });
+	try {
+		await Ce$1(await J$1(n, i), r, a.saveBlob ?? we$1);
+	} catch (n) {
+		throw n instanceof t ? n : new t(`Failed to download files from compute response`, e.INVALID_STATE, {
+			context: { originalError: n instanceof Error ? n.message : String(n) },
+			originalError: n
+		});
+	}
+};
+var X$1 = async (e, t, n = null, r = {}) => {
+	let i = q$1(e);
+	if (i.length === 0) {
+		await Y$1([], t, n, r);
+		return;
+	}
+	let a = (i.find((e) => e.root === ``) ?? i[0]).root;
+	for (let { root: e, files: o } of i) await Y$1(e === `` ? o : o.map((e) => ({
+		...e,
+		subFolder: ye$1(e)
+	})), e === `` ? t : be$1(e), e === a ? n : null, r);
+};
+var Z$1 = (e) => K$1(e).filter((e) => e !== `.` && e !== `..` && !/^[a-zA-Z]:$/.test(e)).join(`/`);
+var Q$1 = (e) => e === true || typeof e == `string` && e.trim().toLowerCase() === `true`;
+var xe$1 = (e) => {
+	let t = [];
+	return e.forEach((e) => {
+		let n = c(e, `fileName`) ?? ``, r = c(e, `fileType`) ?? ``, a = Z$1(`${n}${r}`);
+		if (a === ``) {
+			i().warn(`Skipping file with unusable name "${n}${r}": no safe archive path remains after sanitization.`);
+			return;
+		}
+		let o = c(e, `subFolder`), s = o ? Z$1(o) : ``, l = s === `` ? a : `${s}/${a}`, u = c(e, `data`);
+		if (typeof u != `string` || u === ``) {
+			i().warn(`Skipping file "${l}": item carries no usable data.`);
+			return;
+		}
+		let d = c(e, `metadata`);
+		if (Q$1(c(e, `isBase64Encoded`))) try {
+			t.push({
+				fileName: a,
+				content: C$1(u),
+				path: l,
+				subFolder: s,
+				...d ? { metadata: d } : {}
+			});
+		} catch (e) {
+			i().warn(`Skipping file "${l}": base64 decode failed.`, e);
+		}
+		else t.push({
+			fileName: a,
+			content: u,
+			path: l,
+			subFolder: s,
+			...d ? { metadata: d } : {}
+		});
+	}), t;
+};
+var Se$1 = async (e) => (await Promise.all(e.map(async (e) => {
+	try {
+		let t = await fetch(e.filePath, { signal: AbortSignal.timeout(3e4) });
+		if (!t.ok) return i().warn(`Failed to fetch additional file from URL: ${e.filePath}`), null;
+		let n = await t.arrayBuffer(), r = Z$1(e.fileName);
+		if (r === ``) return i().warn(`Skipping fetched file with unusable name: ${e.fileName}`), null;
+		let a = e.subFolder ? Z$1(e.subFolder) : ``;
+		return {
+			fileName: r,
+			content: new Uint8Array(n),
+			path: a === `` ? r : `${a}/${r}`,
+			subFolder: a
+		};
+	} catch (t) {
+		return i().error(`Error fetching additional file from URL: ${e.filePath}`, t), null;
+	}
+}))).filter((e) => e !== null);
+async function Ce$1(e, t, n) {
+	let { zip: r, strToU8: i } = await import('./esm.js-Dzxc7OGH.js'), a = new Set(e.map((e) => e.path)), o = {};
+	for (let t of e) {
+		let e = t.path === `__proto__` ? $$1(t.path, a) : t.path;
+		a.add(e), o[e] = typeof t.content == `string` ? i(t.content) : t.content;
+	}
+	let s = await new Promise((e, t) => {
+		r(o, { level: 6 }, (n, r) => n ? t(n) : e(r));
+	});
+	await n(new Blob([s], { type: `application/zip` }), `${t}.zip`);
+}
+function $$1(e, t) {
+	if (!t.has(e)) return e;
+	let n = e.lastIndexOf(`/`), r = e.lastIndexOf(`.`), i = r > n ? r : e.length, a = e.slice(0, i), o = e.slice(i);
+	for (let e = 2;; e++) {
+		let n = `${a}-${e}${o}`;
+		if (!t.has(n)) return n;
+	}
+}
+function we$1(e, t) {
+	let n = URL.createObjectURL(e), r = document.createElement(`a`);
+	r.href = n, r.download = t, document.body.appendChild(r), r.click(), r.remove(), setTimeout(() => URL.revokeObjectURL(n), 1e4);
+}
+//#endregion
+//#region ../compute/dist/grasshopper.js
+var g = class e$1 {
+	serverUrl;
+	headers;
+	disposed = false;
+	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 = d(e), this.headers = {
+			...g$1(typeof t == `string` ? { apiKey: t } : t ?? {}),
+			"Content-Type": `application/json`
+		};
+	}
+	fetchWithTimeout(t, n = {}, r = e$1.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$1.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 D$1(o, e$1.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$1.DEFAULT_TIMEOUT_MS) {
+		return (await this.probeServer(t)).online;
+	}
+	async probeServer(t = e$1.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 || N$1(e),
+				status: e.status
+			};
+		} catch (e) {
+			return i().debug(`[ComputeServerStats] Fetch error:`, e), {
+				online: false,
+				error: e instanceof Error ? `${e.name}: ${e.message}` : String(e)
+			};
+		}
+	}
+	async getActiveChildren(t = {}) {
+		let { initialize: n = true } = t, r = n ? await this.getText(`/activechildren`, {}, e$1.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: false };
+		let [e, t] = await Promise.all([this.getVersion(), this.getActiveChildren({ initialize: false })]);
+		return {
+			isOnline: true,
+			...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: false });
+		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: true
+		};
+		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$1.LIFECYCLE_TIMEOUT_MS);
+		return n === null ? null : _(n) ?? null;
+	}
+	monitor(r, a = 5e3) {
+		if (this.ensureNotDisposed(), !Number.isFinite(a) || a < e$1.MIN_MONITOR_INTERVAL_MS) throw new t(`monitor() intervalMs must be a finite number >= ${e$1.MIN_MONITOR_INTERVAL_MS}ms, got ${a}. Sub-${e$1.MIN_MONITOR_INTERVAL_MS}ms polling would hot-loop the server.`, e.INVALID_CONFIG, { context: { intervalMs: a } });
+		let o = true, 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 = false, s !== null && (clearTimeout(s), s = null), this.activeMonitors.delete(l);
+		};
+		return this.activeMonitors.add(l), c(), l;
+	}
+	async dispose() {
+		if (!this.disposed) {
+			this.disposed = true;
+			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`, e.INVALID_STATE);
+	}
+};
+function _(e) {
+	try {
+		return JSON.parse(e);
+	} catch {
+		return;
+	}
+}
+var v = /* @__PURE__ */ new Set();
+function ie() {
+	if (typeof window > `u` || globalThis.process?.versions?.node != null) return false;
+	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.`));
+}
+var ae = { definition_not_cached: e.DEFINITION_NOT_CACHED };
+function oe(e) {
+	return {
+		...e,
+		serverErrorCodes: {
+			...ae,
+			...e.serverErrorCodes
+		}
+	};
+}
+function se(e$2) {
+	return e$2 instanceof t ? e$2.code === e.DEFINITION_NOT_CACHED || e$2.message.includes(`Unable to load grasshopper definition`) : false;
+}
+function ce(t, n) {
+	if (!n) return;
+	let r = c(t, `values`);
+	if (!Array.isArray(r) || r.length === 0) return;
+	let a = [];
+	for (let t of r) {
+		let n = c(t, `innerTree`);
+		(!n || Object.keys(n).length === 0) && a.push(c(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: true
+	};
+}
+async function de(e, t, n) {
+	return pe(b(await fe(t), e), n);
+}
+async function fe(e$3) {
+	if (!ge$1(e$3)) return e$3;
+	try {
+		return await e$3.load();
+	} catch (r) {
+		throw new t(`Failed to load definition bytes for ref '${e$3.key}'`, e.INVALID_INPUT, {
+			context: { definitionKey: e$3.key },
+			originalError: r
+		});
+	}
+}
+async function pe(e, t) {
+	d(t.serverUrl), me(e, t);
+	let { maxResponseBytes: n } = t, r = await he$1(`grasshopper`, e, oe({
+		...t,
+		maxResponseBytes: n !== void 0 && e.algo ? n + e.algo.length : n
+	})), { pointer: i, algo: a, ...o } = r, s = o, l = oe$1(r);
+	if (l !== void 0) {
+		let e = typeof a == `string` ? a.length : 0;
+		j$1(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 = T$1(e) : _e$1(e) ? n.pointer = e : n.algo = ne(e) ?? ee(e), n;
+}
+function me(e, t) {
+	t.cachesolve != null && (e.cachesolve = t.cachesolve), t.cacheerroredsolves != null && (e.cacheerroredsolves = t.cacheerroredsolves), 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: true,
+		enumerable: true,
+		configurable: true
+	}) : e[t] = n;
+}
+var S = /^\{(-?\d+(?:;-?\d+)*)?\}$/;
+function C(e) {
+	if (typeof e != `object` || !e || Array.isArray(e)) return false;
+	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;
+}
+var 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;
+};
+var E = (e) => {
+	if (typeof e == `boolean`) return e;
+	if (typeof e == `string`) {
+		let t = e.trim().toLowerCase();
+		if (t === `true`) return true;
+		if (t === `false`) return false;
+	}
+	return null;
+};
+var he = (e) => typeof e == `string` ? e.length >= 2 && e.startsWith(`"`) && e.endsWith(`"`) ? e.slice(1, -1) : e.startsWith(`"`) ? e.slice(1) : e : null;
+var 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;
+	};
+}
+var _e = /* @__PURE__ */ new Set([
+	`System.Double`,
+	`System.Single`,
+	`System.Decimal`,
+	`System.Int32`,
+	`System.Int64`
+]);
+var ve = /* @__PURE__ */ new Set([`System.Int32`, `System.Int64`]);
+function O(e$4, t) {
+	return i().warn(t), {
+		schema: {
+			...e$4,
+			default: null
+		},
+		warning: {
+			code: e.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 (!l(t.default, `innerTree`)) return O(t, `Input "${a}" default had an unrecognized shape (no innerTree key); the default was dropped.`);
+	let o = c(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 = c(t, `data`), r = c(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);
+					continue;
+				}
+				if (r === `System.Boolean`) {
+					let e = E(n);
+					if (e === null) {
+						s.push(`"${String(n)}" (${r})`);
+						continue;
+					}
+					o.push(e);
+					continue;
+				}
+				if (typeof n == `string` && r?.startsWith(`Rhino.Geometry`)) {
+					try {
+						o.push(JSON.parse(n));
+					} catch {
+						o.push(n);
+					}
+					continue;
+				}
+				o.push(n);
+			}
+			x(r, n, o);
+		}
+		if (s.length > 0) {
+			let e$5 = `Input "${a}" default contained ${s.length} tree value(s) that could not be parsed and were dropped: ${s.join(`, `)}.`;
+			return i().warn(e$5), {
+				schema: {
+					...t,
+					default: r
+				},
+				warning: {
+					code: e.MALFORMED_DEFAULT,
+					message: e$5
+				}
+			};
+		}
+		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` && l(n, `data`) && s.push(c(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, n] = String(Math.abs(e)).split(`e`), r = n === void 0 ? Math.abs(e).toFixed(12).replace(/0+$/, ``).split(`.`)[1]?.length ?? 0 : (t.split(`.`)[1]?.length ?? 0) - Number(n);
+	return Math.min(Math.max(r, 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;
+}
+var j = (e, t) => (e.atMost ?? 1) > 1 ? [t] : t;
+var M = (e) => A(e) ?? (e.paramType === `Integer` ? 1 : .1);
+var N = (e, t) => Array.isArray(e) ? e.map((e) => typeof e == `number` ? t(e) : e) : typeof e == `number` ? t(e) : e;
+function Se(e$6) {
+	if (C(e$6.default)) return {
+		default: e$6.default,
+		stepSize: M(e$6)
+	};
+	if (typeof e$6.default == `string` && e$6.default.trim() !== `` && T(e$6.default) === null) throw new t(`Invalid numeric default "${e$6.default}" for input "${e$6.name || `unknown`}"`, e.VALIDATION_ERROR, { context: {
+		inputName: e$6.name,
+		default: e$6.default
+	} });
+	let r = w(e$6.default, T, true);
+	if (e$6.paramType === `Integer`) return {
+		default: N(r, Math.round),
+		stepSize: M(e$6)
+	};
+	let i = Array.isArray(r) ? r[0] : r, a = [
+		i,
+		e$6.minimum,
+		e$6.maximum
+	].find((e) => typeof e == `number` && Number.isFinite(e) && e !== 0), o = A(e$6) ?? (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
+	};
+}
+var 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)
+		};
+	}
+};
+var Ce = {
+	parse(e$7, r) {
+		if (C(e$7.default)) return {
+			...r,
+			paramType: `Boolean`,
+			default: e$7.default
+		};
+		let i = w(e$7.default, E, false);
+		if (i != null && typeof i != `boolean` && !Array.isArray(i)) throw new t(`Invalid boolean default "${String(i)}" for input "${e$7.name || `unknown`}"`, e.VALIDATION_ERROR, { context: {
+			inputName: e$7.name,
+			default: e$7.default
+		} });
+		return {
+			...r,
+			paramType: `Boolean`,
+			default: i
+		};
+	},
+	fallback(e, t) {
+		return {
+			...t,
+			paramType: `Boolean`,
+			default: j(e, false)
+		};
+	}
+};
+var we = { parse(e, t) {
+	let n = w(e.default, he, false);
+	return {
+		...t,
+		paramType: `Text`,
+		default: n
+	};
+} };
+var Te = {
+	parse(e$8, r, a) {
+		if (!e$8.values || typeof e$8.values != `object` || Object.keys(e$8.values).length === 0) {
+			let r = e$8.nickname || `unnamed`;
+			throw new t(`Input "${r}" has no values defined (expected ValueList)`, e.INVALID_INPUT, { context: {
+				inputName: r,
+				expectedType: `ValueList`
+			} });
+		}
+		let o = e$8.default;
+		if (e$8.default !== void 0 && e$8.default !== null) {
+			if (typeof e$8.default == `object`) throw new t(`ValueList input "${e$8.nickname || `unnamed`}" default is not a string-able value`, e.VALIDATION_ERROR, { context: {
+				inputName: e$8.name,
+				default: e$8.default
+			} });
+			let r = String(e$8.default).toLowerCase(), s = Object.keys(e$8.values).find((e) => e.toLowerCase() === r);
+			if (s !== void 0) o = s;
+			else {
+				let t = `ValueList input "${e$8.nickname || `unnamed`}" default value "${e$8.default}" is not in available values`;
+				i().warn(t), a?.({
+					code: e.VALIDATION_ERROR,
+					message: t
+				});
+			}
+		}
+		return {
+			...r,
+			paramType: `ValueList`,
+			values: e$8.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)
+	};
+}
+var 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`), true);
+			return {
+				...t,
+				paramType: `Geometry`,
+				default: n
+			};
+		},
+		fallback: F
+	}],
+	[`File`, { parse(e, t) {
+		let n = w(e.default, D(e.nickname || `unnamed`), true);
+		return {
+			...t,
+			paramType: `File`,
+			acceptedFormats: e.acceptedFormats,
+			default: n
+		};
+	} }],
+	[`Color`, { parse(e, t) {
+		let n = w(e.default, ge, false);
+		return {
+			...t,
+			paramType: `Color`,
+			default: n
+		};
+	} }]
+]);
+var Ee = F;
+var De = new Map([...I.keys()].map((e) => [e.toLowerCase(), e]));
+function Oe(e) {
+	return De.get(e?.toLowerCase()) ?? e;
+}
+function L(e$10) {
+	let r = e$10.name || `unknown`, a = [], o = ({ code: t, message: n }) => {
+		a.push({
+			inputName: r,
+			paramType: e$10.paramType,
+			message: n,
+			code: t
+		});
+	}, s = {
+		description: e$10.description,
+		name: e$10.name,
+		nickname: e$10.nickname,
+		treeAccess: e$10.treeAccess,
+		groupName: e$10.groupName ?? void 0,
+		id: e$10.id
+	}, c = Oe(e$10.paramType), l = {
+		...e$10,
+		paramType: c
+	};
+	try {
+		let { schema: e, warning: t } = ye(l, r);
+		l = e, t && o(t);
+	} catch (e$9) {
+		l = {
+			...l,
+			default: null
+		}, o({
+			code: e.MALFORMED_DEFAULT,
+			message: `Input "${r}" default could not be normalized and was dropped: ${e$9 instanceof Error ? e$9.message : String(e$9)}`
+		});
+	}
+	let u = I.get(c);
+	try {
+		if (!u) throw new t(`Unknown paramType: ${c}`, e.VALIDATION_ERROR, { context: {
+			receivedParamType: c,
+			paramName: e$10.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), e.VALIDATION_ERROR, {
+			context: {
+				paramName: e$10.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 = c(t, `stepSize`);
+	return {
+		id: c(t, `id`) ?? ``,
+		name: c(t, `name`) ?? ``,
+		nickname: c(t, `nickname`) ?? null,
+		description: c(t, `description`) ?? ``,
+		paramType: c(t, `paramType`) ?? ``,
+		treeAccess: c(t, `treeAccess`) ?? false,
+		minimum: c(t, `minimum`) ?? null,
+		maximum: c(t, `maximum`) ?? null,
+		atLeast: c(t, `atLeast`) ?? 1,
+		atMost: c(t, `atMost`) ?? 1,
+		stepSize: typeof n == `number` && Number.isFinite(n) ? n : void 0,
+		default: c(t, `default`),
+		values: c(t, `values`),
+		acceptedFormats: c(t, `acceptedFormats`),
+		groupName: c(t, `groupName`) ?? null
+	};
+}
+function Me(t) {
+	return {
+		name: c(t, `name`) ?? ``,
+		nickname: c(t, `nickname`) ?? null,
+		paramType: c(t, `paramType`) ?? ``,
+		id: c(t, `id`) ?? ``
+	};
+}
+async function R(r, i) {
+	y(`fetchDefinitionIO`, i.suppressBrowserWarning), d(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`, e.INVALID_INPUT);
+	let s = await he$1(`io`, a ? { algo: a } : { pointer: o }, oe(i));
+	if (!s || typeof s != `object`) throw new t(`Invalid IO response structure`, e.INVALID_INPUT, { context: { response: s } });
+	let c$1 = z(c(s, `warnings`)), l = z(c(s, `errors`)), u = c(s, `inputs`), f = c(s, `outputs`);
+	return {
+		inputs: Array.isArray(u) ? u.map(je) : [],
+		outputs: Array.isArray(f) ? f.map(Me) : [],
+		...c$1 && { loadWarnings: c$1 },
+		...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 = c(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 }
+	};
+}
+var 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);
+}
+var 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 W(e, t) {
+	return `${e}|t:${H(U(t))}`;
+}
+function G(e) {
+	return ge$1(e) ? `r:${e.key}` : typeof e == `string` ? `s:${H(e)}` : `u8:${H(e)}`;
+}
+var 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);
+	}
+};
+var 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 = false;
+	constructor(e$11, r, i = {}) {
+		if (this.executor = e$11, 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 }.`, e.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 ?? true, this.reuseServerDefinitionCache = i.reuseServerDefinitionCache ?? true, 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$12, r, i) {
+		if (this.disposed) return Promise.reject(new t(`SolveScheduler has been disposed and cannot be used`, e.INVALID_STATE));
+		let a = new ze(() => this.hashDefinitionMemo(e$12), r), o = ``;
+		if (this.cacheEnabled || this.onStart || this.onSettle || this.onSuperseded) try {
+			o = a.key;
+		} catch (e$13) {
+			return Promise.reject(new t(`Solve input could not be hashed`, e.INVALID_INPUT, { originalError: e$13 }));
+		}
+		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: true
+			};
+			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: true,
+				durationMs: 0
+			});
+		}
+		return new Promise((t, n) => {
+			let o = {
+				definition: e$12,
+				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: true })), 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$14) {
+		let r = new t(`Solve queue is full; request rejected (backpressure)`, e.QUEUE_FULL, {
+			statusCode: 503,
+			context: {
+				queueDepth: this.fifo.size,
+				maxQueueDepth: this.maxQueueDepth
+			}
+		});
+		this.fail(e$14, r), this.notify();
+	}
+	armQueueWaitTimer(e$15) {
+		if (this.queueWaitMs === void 0) return;
+		let r = this.queueWaitMs;
+		e$15.queueWaitTimer = setTimeout(() => {
+			if (e$15.settled) return;
+			this.dequeue(e$15);
+			let i = new t(`Solve waited longer than ${r}ms in queue; rejected (backpressure)`, e.QUEUE_TIMEOUT, {
+				statusCode: 503,
+				context: {
+					waitedMs: Date.now() - e$15.ctx.enqueuedAt,
+					queueWaitMs: r
+				}
+			});
+			this.fail(e$15, 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: true }), 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 || _e$1(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);
+				}
+				return;
+			}
+			for (; this.fifo.size > 0 && this.inFlight.size < this.maxConcurrent;) this.execute(this.fifo.shift());
+		}
+	}
+	supersede(e$16) {
+		let r = new t(`Superseded by newer solve`, e.SUPERSEDED, { context: { enqueuedAt: e$16.ctx.enqueuedAt } });
+		this.settleError(e$16, r) && this.runHook(this.onSuperseded, e$16.ctx);
+	}
+	makeAbortError(e$17) {
+		return new t(`Request aborted by caller`, e.ABORTED, { context: { enqueuedAt: e$17.enqueuedAt } });
+	}
+	settleError(e, t) {
+		return !e.settled && (e.settled = { error: t }, this.clearQueueWaitTimer(e), this.removeQueuedAbortHandler(e), e.reject(t), true);
+	}
+	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: true }, this.clearQueueWaitTimer(e), this.removeQueuedAbortHandler(e), e.resolve(t), true);
+	}
+	removeQueuedAbortHandler(e) {
+		e.queuedAbortHandler && e.externalSignal && e.externalSignal.removeEventListener(`abort`, e.queuedAbortHandler), e.queuedAbortHandler = void 0;
+	}
+	normalizeExecutionError(e$18, r) {
+		return r.settled && `error` in r.settled ? r.settled.error : e$18 instanceof t ? e$18 : e$18 instanceof Error && e$18.name === `AbortError` ? this.makeAbortError(r.ctx) : new t(e$18 instanceof Error ? e$18.message : String(e$18), e.UNKNOWN_ERROR, { originalError: e$18 });
+	}
+	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 = c(n, `errors`);
+		if (!this.cacheErroredSolves && Array.isArray(r) && r.length > 0) return;
+		let i = oe$1(n) ?? Ve(n);
+		if (!(i > this.cacheMaxBytes)) for (this.dropCacheEntry(t), this.cache.set(t, {
+			response: n,
+			insertedAt: Date.now(),
+			sizeBytes: i
+		}), this.cacheBytes += i; 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 = true, 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 ge$1(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 = c(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: c(t, `paramName`) ?? `<unnamed>`,
+			items: n,
+			bytes: r
+		};
+	}) : [];
+}
+var Ge = class r {
+	config;
+	serverStats;
+	disposed = false;
+	static CREATE_PROBE_TIMEOUT_MS = 2e3;
+	constructor(e) {
+		this.config = {
+			...e,
+			serverUrl: d(e.serverUrl),
+			debug: e.debug ?? false
+		}, this.serverStats = new g(this.config.serverUrl, this.config);
+	}
+	static async create(e$19, i = {}) {
+		let a = new r(e$19), 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 = R$1(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;
+		throw new t(u ? `Rhino Compute server is not available. ${u.summary}` : `Rhino Compute server is not online`, e.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`, e.INVALID_INPUT, { context: { receivedUrl: r } });
+			if (r instanceof Uint8Array && r.length === 0) throw new t(`Definition content is empty`, e.INVALID_INPUT);
+			if (ge$1(r) && !r.key.trim()) throw new t(`DefinitionRef key is empty`, e.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 = c(i, `errors`);
+			if (Array.isArray(s) && s.length > 0) throw new t(s.map(String).join(`; `) || `Computation failed`, e.COMPUTATION_ERROR, { context: {
+				definition: Ue(r),
+				inputSummary: We(a),
+				errors: s,
+				warnings: c(i, `warnings`),
+				values: i.values
+			} });
+			return i;
+		} catch (e$20) {
+			throw this.config.debug && i().error(`Compute failed:`, e$20), e$20 instanceof t ? e$20 : new t(e$20 instanceof Error ? e$20.message : String(e$20), e.COMPUTATION_ERROR, {
+				context: {
+					definition: Ue(r),
+					inputSummary: We(a)
+				},
+				originalError: e$20
+			});
+		}
+	}
+	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 = true, await this.serverStats.dispose());
+	}
+	ensureNotDisposed() {
+		if (this.disposed) throw new t(`GrasshopperClient has been disposed and cannot be used`, e.INVALID_STATE);
+	}
+};
+function qe(e, t) {
+	return {
+		__decodeError: true,
+		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);
+}
+var 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 = false;
+	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 = true;
+	}
+	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;
+}
+var J = {
+	STRING: `System.String`,
+	INT: `System.Int32`,
+	DOUBLE: `System.Double`,
+	BOOL: `System.Boolean`
+};
+var 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 = c(t, `fileName`), i = c(t, `fileType`), a = c(t, `subFolder`), o = c(t, `isBase64Encoded`);
+	if (typeof n != `string` || typeof i != `string` || typeof a != `string` || !l(t, `data`) || typeof o != `boolean` && typeof o != `string`) return null;
+	let s = c(t, `metadata`);
+	return {
+		fileName: n,
+		fileType: i,
+		data: c(t, `data`),
+		isBase64Encoded: Q$1(o),
+		subFolder: a,
+		...s ? { metadata: s } : {}
+	};
+}
+function X(t) {
+	let n = c(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 = false, r = {}) {
+	let { parseValues: i = true, rhino: a, stringOnly: o = false } = r, s = {}, c$2 = /* @__PURE__ */ new Set();
+	for (let r of X(t)) {
+		let t = c(r, `paramName`);
+		Q(c(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$2.has(l) ? s[l].push(u) : (s[l] = [s[l], u], c$2.add(l)) : x(s, l, u);
+		});
+	}
+	return {
+		values: s,
+		dispose: () => Je(s)
+	};
+}
+function it(t) {
+	let n = [];
+	for (let r of X(t)) Q(c(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 = true, rhino: a, stringOnly: o = false } = r;
+	for (let r of X(t)) {
+		let t = c(r, `innerTree`), s = false;
+		if (`byName` in n) {
+			if (c(r, `paramName`) !== n.byName) continue;
+			s = true;
+		}
+		let c$3 = [];
+		if (Q(t, (e) => {
+			if (`byId` in n) {
+				if (e.id !== n.byId) return;
+				s = true;
+			}
+			let t = Z(e);
+			$e(t, o) || c$3.push(Y(e, t, i, a));
+		}), s) return c$3.length === 0 ? void 0 : c$3.length === 1 ? c$3[0] : c$3;
+	}
+}
+var ot = class {
+	response;
+	constructor(e) {
+		this.response = e;
+	}
+	getValues(e = false, t = {}) {
+		return rt(this.response, e, t);
+	}
+	getValue(e, t) {
+		return at(this.response, e, t);
+	}
+	async getAndDownloadFiles(e, t) {
+		await Y$1(it(this.response), e, t);
+	}
+};
+function st(t) {
+	return (Array.isArray(t) ? t : [t]).map((t) => ({
+		schemas: c(t, `schemas`),
+		error: c(t, `error`)
+	}));
+}
+var ct = /* @__PURE__ */ new Set([
+	`options`,
+	`defaultOptions`,
+	`values`
+]);
+var lt = /* @__PURE__ */ new Set([`optionMedia`, `assets`]);
+var 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 = c(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$21, i) {
+		let a = r.getTree(e$21, 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`, e.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 c(t, `ParamName`);
+	}
+	static parsePathString(e$22) {
+		let r = e$22.match(S);
+		if (!r) throw new t(`Invalid Grasshopper tree path: "${e$22}". Expected "{}", "{0}", or "{0;1;2}" (negative indices allowed, no empty segments).`, e.INVALID_INPUT, { context: { pathStr: e$22 } });
+		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 ? false : 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 { C$1 as C, Ge as G, K$1 as K, R$1 as R, U, X$1 as X, g as a, ot as b, e, ft as f, ge$1 as g, mt as m, o, st as s, t };
+//# sourceMappingURL=grasshopper.js-julMp0aw.js.map