@selvajs/selva 4.20.0-beta.4 → 4.20.0-beta.5

package/build/server/chunks/chunks/schema.js-CCefMgzX.js

@@ -0,0 +1,2643 @@
+//#region ../compute/dist/core-BSKhoCtA.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`,
+	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 t extends Error {
+	code;
+	statusCode;
+	context;
+	originalError;
+	constructor(t, n = e.UNKNOWN_ERROR, r) {
+		super(t), this.name = `ComputeError`, this.code = n, this.statusCode = r?.statusCode, this.context = r?.context, this.originalError = r?.originalError, r?.originalError && (this.cause = r.originalError);
+	}
+	static missingValues(n, r, i) {
+		return new t(`Input "${n}" has no values defined${r ? ` (expected ${r})` : ``}`, e.INVALID_INPUT, { context: {
+			inputName: n,
+			expectedType: r,
+			...i
+		} });
+	}
+	static unknownParamType(n, r, i) {
+		return new t(`Unknown paramType: ${n}`, e.VALIDATION_ERROR, { context: {
+			receivedParamType: n,
+			paramName: r,
+			...i
+		} });
+	}
+};
+var n = class {
+	debug() {}
+	info() {}
+	warn() {}
+	error() {}
+};
+var r = class {
+	debug(e, ...t) {
+		console.debug(e, ...t);
+	}
+	info(e, ...t) {
+		console.info(e, ...t);
+	}
+	warn(e, ...t) {
+		console.warn(e, ...t);
+	}
+	error(e, ...t) {
+		console.error(e, ...t);
+	}
+};
+var i = new n();
+function a() {
+	return i;
+}
+function o(r) {
+	if (r === null) {
+		i = new n();
+		return;
+	}
+	let a = [
+		`debug`,
+		`info`,
+		`warn`,
+		`error`
+	].filter((e) => typeof r[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 } });
+	i = r;
+}
+function s() {
+	o(new r());
+}
+function c(e, t) {
+	if (!e || typeof e != `object`) return;
+	let n = e;
+	if (l(n, t)) return n[t];
+	let r = f(n).get(t.toLowerCase());
+	return r === void 0 ? void 0 : n[r];
+}
+var l = (e, t) => Object.prototype.hasOwnProperty.call(e, t);
+function u(e, t) {
+	if (!e || typeof e != `object`) return false;
+	let n = e;
+	return l(n, t) ? true : f(n).has(t.toLowerCase());
+}
+var d = /* @__PURE__ */ new WeakMap();
+function f(e) {
+	let t = Object.keys(e), n = d.get(e);
+	if (n && n.keyCount === t.length) return n.map;
+	let r = /* @__PURE__ */ new Map();
+	for (let e of t) {
+		let t = e.toLowerCase();
+		r.has(t) || r.set(t, e);
+	}
+	return d.set(e, {
+		keyCount: t.length,
+		map: r
+	}), r;
+}
+function m(n, r) {
+	let i = n?.trim() ?? ``;
+	if (!i) throw new t(`serverUrl is required`, e.INVALID_CONFIG, { context: { receivedServerUrl: n } });
+	if (!/^https?:\/\//i.test(i)) throw new t(`Invalid serverUrl: "${i}". Must start with "http://" or "https://". For example: "http://localhost:5000" or "https://example.com"`, e.INVALID_CONFIG, { context: { receivedServerUrl: n } });
+	let a;
+	try {
+		a = new URL(i);
+	} catch (r) {
+		throw new t(`Invalid serverUrl: "${i}". Must be a valid URL. Received error: ${r instanceof Error ? r.message : String(r)}`, e.INVALID_CONFIG, {
+			context: { receivedServerUrl: n },
+			originalError: r instanceof Error ? r : void 0
+		});
+	}
+	if (a.username !== `` || a.password !== ``) throw new t(`Invalid serverUrl: "${i}". Must not embed credentials (user:pass@host) — fetch rejects credentialed URLs at request time. Pass the API key separately.`, e.INVALID_CONFIG, { context: { receivedServerUrl: n } });
+	if (i.includes(`?`) || i.includes(`#`)) throw new t(`Invalid serverUrl: "${i}". 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.`, e.INVALID_CONFIG, { context: { receivedServerUrl: n } });
+	let o = a.hostname.toLowerCase().replace(/\.+$/, ``);
+	if (([`compute.rhino3d.com`]).map((e) => e.toLowerCase().replace(/\.+$/, ``)).includes(o)) 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 i.replace(/\/+$/, ``);
+}
+var h$1 = /ECONNREFUSED|ERR_CONNECTION_REFUSED|connection refused/i;
+var g$1 = /ENOTFOUND|EAI_AGAIN|getaddrinfo|ERR_NAME_NOT_RESOLVED|dns/i;
+var _$1 = /TimeoutError|ETIMEDOUT|ECONNRESET|EHOSTUNREACH|ENETUNREACH|abort|timed? ?out/i;
+function v$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 h$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.`
+	} : g$1.test(t) ? {
+		verdict: `dns`,
+		retryable: true,
+		summary: `The server hostname could not be resolved — check the URL and DNS.`
+	} : _$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.`
+	};
+}
+function y$1() {
+	let e = globalThis.Buffer;
+	return typeof e == `function` ? e : void 0;
+}
+function b$1(e) {
+	let t = y$1();
+	return t ? t.from(e, `utf-8`).toString(`base64`) : w$1(new TextEncoder().encode(e));
+}
+function x$1(e) {
+	if (!e) return null;
+	let t = e.replace(/[\t\n\f\r ]/g, ``);
+	t.length % 4 == 0 && (t = t.replace(/={1,2}$/, ``));
+	let n = t.length % 4;
+	if (n === 1 || t.length < 64 || !/^[A-Za-z0-9+/]*$/.test(t)) return null;
+	let 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 S$1(n) {
+	let r = n.replace(/[\t\n\f\r ]/g, ``);
+	if (r.length % 4 == 0 && (r = r.replace(/={1,2}$/, ``)), r.length % 4 == 1 || !/^[A-Za-z0-9+/]*$/.test(r)) throw new t(`Invalid base64 input.`, e.ENCODING_ERROR, { context: { inputLength: n.length } });
+	let i = y$1();
+	if (i) return new Uint8Array(i.from(r, `base64`));
+	if (typeof globalThis.atob == `function`) {
+		let e = globalThis.atob(r), 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 C$1(e) {
+	let t = y$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 w$1(n) {
+	let r = y$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` } });
+}
+function T$1(e, t) {
+	t && a().debug(e);
+}
+function ee(e, t) {
+	return `${t.replace(/\/+$/, ``)}/${e.replace(/^\/+/, ``)}`;
+}
+function te$1(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 E$1 = /* @__PURE__ */ new Set();
+function D$1(e, t) {
+	let n = {
+		...t.headers,
+		"X-Request-ID": e,
+		"Content-Type": `application/json`,
+		...t.authToken && { Authorization: t.authToken },
+		...t.apiKey && { [t.apiKeyHeader ?? `RhinoComputeKey`]: t.apiKey }
+	};
+	return !t.apiKey && !t.authToken && !E$1.has(t.serverUrl) && !te$1(t.serverUrl) && (E$1.add(t.serverUrl), a().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 O$1() {
+	return `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+}
+function ne$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 k$1(e, t, n, r) {
+	if (!n) return;
+	let i = ne$1(e.headers.get(`Server-Timing`));
+	if (i) try {
+		n(i, t);
+	} catch (e) {
+		r && T$1(`   onServerTiming callback threw: ${e}`, true);
+	}
+}
+var A$1 = /* @__PURE__ */ new WeakMap();
+function j$1(e, t) {
+	typeof e == `object` && e && A$1.set(e, t);
+}
+function re$1(e) {
+	if (typeof e == `object` && e) return A$1.get(e);
+}
+var M$1 = 4096;
+function ie$1(e) {
+	return e.length <= M$1 ? e : `${e.slice(0, M$1)}… [truncated ${e.length - M$1} chars]`;
+}
+function ae$1(n, r, i, a, o, s, c, l, u) {
+	let { status: d, statusText: f } = n, p = {};
+	n.headers.forEach((e, t) => {
+		p[t] = e;
+	});
+	let m = s.trim(), h = m ? ` — ${m.slice(0, 200)}${m.length > 200 ? `…` : ``}` : ``, g = l ?? s, _ = {
+		url: r,
+		requestId: i,
+		method: `POST`,
+		requestSize: a,
+		serverUrl: o,
+		responseBody: g ? ie$1(g) : void 0,
+		responseHeaders: p
+	}, v = {
+		400: {
+			message: `Bad request: ${f}${h}`,
+			code: e.VALIDATION_ERROR
+		},
+		401: {
+			message: `HTTP ${d}: ${f}${h}`,
+			code: e.AUTH_ERROR
+		},
+		403: {
+			message: `HTTP ${d}: ${f}${h}`,
+			code: e.AUTH_ERROR
+		},
+		404: {
+			message: `Endpoint not found: ${r}`,
+			code: e.NOT_FOUND
+		},
+		413: {
+			message: `Request too large: ${(a / 1024).toFixed(2)}KB`,
+			code: e.VALIDATION_ERROR
+		},
+		429: {
+			message: `Rate limit exceeded${h}`,
+			code: e.RATE_LIMIT
+		},
+		500: {
+			message: `Server error: ${f}${h}`,
+			code: e.COMPUTATION_ERROR
+		},
+		502: {
+			message: `Bad gateway: ${f}${h}`,
+			code: e.NETWORK_ERROR
+		},
+		503: {
+			message: `Service unavailable: ${f}${h}`,
+			code: e.NETWORK_ERROR
+		},
+		504: {
+			message: `Service unavailable: ${f}${h}`,
+			code: e.NETWORK_ERROR
+		}
+	}[d] || {
+		message: `HTTP ${d}: ${f}${h}`,
+		code: e.UNKNOWN_ERROR
+	}, y = N$1(c, u) ?? v.code;
+	throw new t(v.message, y, {
+		statusCode: d,
+		context: _
+	});
+}
+function N$1(e, t) {
+	if (e && t) return t[e];
+}
+async function P$1(n, r, i, a, o, s, l, u, d) {
+	let f = Math.round(performance.now() - s);
+	if (!n.ok) {
+		let e = await n.text(), t = e;
+		l && (T$1(`❌ Request [${i}] failed with HTTP ${n.status} in ${f}ms`, true), T$1(`   URL: ${r}`, true), T$1(`   Status: ${n.status} ${n.statusText}`, true), t && T$1(`   Response body: ${t.substring(0, 500)}${t.length > 500 ? `...` : ``}`, true));
+		let s;
+		try {
+			let e = JSON.parse(t);
+			typeof e?.code == `string` && (s = e.code);
+		} catch {}
+		if (n.status === 500) try {
+			let e = JSON.parse(t), r = c(e, `values`), a = c(e, `errors`), o = c(e, `warnings`);
+			if (r && (a || o)) return j$1(e, t.length), l && (T$1(`⚠️ Request [${i}] completed with solver errors in ${f}ms`, !0), a && a.length > 0 && T$1(`   Errors: ${JSON.stringify(a, null, 2)}`, !0), o && o.length > 0 && T$1(`   Warnings: ${JSON.stringify(o, null, 2)}`, !0)), k$1(n, i, u, l), e;
+			let s = typeof e?.message == `string` && e.message || typeof e?.Message == `string` && e.Message || ``, d = typeof e?.ExceptionType == `string` && e.ExceptionType || ``, p = e?.stackTrace ?? e?.StackTrace, m = Array.isArray(p) ? p.join(`
+`) : p || ``;
+			s ? t = `${d ? `${d}: ` : ``}${s}${m ? `\n${m}` : ``}` : e?.error && (t = typeof e.error == `string` ? e.error : JSON.stringify(e.error, null, 2));
+		} catch (e) {
+			l && T$1(`   Failed to parse error body as JSON: ${e}`, true);
+		}
+		ae$1(n, r, i, a, o, t, s, e, d);
+	}
+	T$1(`✅ Request [${i}] completed in ${f}ms`, l), k$1(n, i, u, l);
+	try {
+		let e = await n.text(), t = JSON.parse(e);
+		return j$1(t, e.length), t;
+	} catch (a) {
+		let o = (n.headers.get(`Content-Type`) ?? ``).toLowerCase();
+		throw o !== `` && !o.includes(`json`) ? new t(`Server returned a non-JSON response (Content-Type: ${o}) — check the server URL / proxy configuration`, e.INVALID_RESPONSE, {
+			statusCode: n.status,
+			context: {
+				url: r,
+				requestId: i,
+				contentType: o
+			},
+			originalError: a instanceof Error ? a : Error(String(a))
+		}) : new t(`Failed to parse JSON response`, e.NETWORK_ERROR, {
+			statusCode: n.status,
+			context: {
+				url: r,
+				requestId: i
+			},
+			originalError: a instanceof Error ? a : Error(String(a))
+		});
+	}
+}
+var F$1 = {
+	attempts: 0,
+	baseDelayMs: 500,
+	maxDelayMs: 3e4,
+	retryOn429: true
+};
+var I$1 = /* @__PURE__ */ new Set([
+	502,
+	503,
+	504
+]);
+function L$1(e) {
+	return e ? {
+		attempts: e.attempts ?? F$1.attempts,
+		baseDelayMs: e.baseDelayMs ?? F$1.baseDelayMs,
+		maxDelayMs: e.maxDelayMs ?? F$1.maxDelayMs,
+		retryOn429: e.retryOn429 ?? F$1.retryOn429
+	} : F$1;
+}
+function R$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 z$1(e, t) {
+	let n = t.baseDelayMs * 2 ** e, r = Math.random() * t.baseDelayMs;
+	return Math.min(n + r, t.maxDelayMs);
+}
+function B$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 V$1(e, t) {
+	let n = () => {}, r = typeof t == `number` && t > 0;
+	if (!e && !r) return {
+		signal: void 0,
+		cleanup: n
+	};
+	if (e && !r) return {
+		signal: e,
+		cleanup: n
+	};
+	let i = typeof AbortSignal < `u` && typeof AbortSignal.timeout == `function`;
+	if (!e) {
+		if (i) return {
+			signal: AbortSignal.timeout(t),
+			cleanup: n
+		};
+		let e = new AbortController(), r = setTimeout(() => e.abort(), t);
+		return {
+			signal: e.signal,
+			cleanup: () => clearTimeout(r)
+		};
+	}
+	let a = new AbortController(), o, s;
+	if (i) o = AbortSignal.timeout(t);
+	else {
+		let e = new AbortController();
+		s = setTimeout(() => e.abort(), t), o = e.signal;
+	}
+	let c = [e, o], l = function() {
+		a.abort(this.reason);
+	};
+	for (let e of c) {
+		if (e.aborted) {
+			a.abort(e.reason);
+			break;
+		}
+		e.addEventListener(`abort`, l, { once: true });
+	}
+	return {
+		signal: a.signal,
+		cleanup: () => {
+			s !== void 0 && clearTimeout(s);
+			for (let e of c) e.removeEventListener(`abort`, l);
+		}
+	};
+}
+async function H$1(n, r, i, a) {
+	let { signal: o, cleanup: s } = V$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
+		});
+		if ((I$1.has(s.status) || r.retryOn429 && s.status === 429) && i < a - 1) {
+			let a = R$1(s.headers.get(`Retry-After`)), o = a === null ? z$1(i, r) : Math.min(a, Math.max(r.maxDelayMs, 6e4));
+			return await s.text().catch(() => {}), {
+				ok: !1,
+				retry: !0,
+				delayMs: o,
+				cause: new t(`HTTP ${s.status} ${s.statusText} (will retry)`, s.status === 429 ? e.RATE_LIMIT : e.NETWORK_ERROR, {
+					statusCode: s.status,
+					context: { requestId: n.requestId }
+				})
+			};
+		}
+		return {
+			ok: !0,
+			value: await P$1(s, n.fullUrl, n.requestId, n.requestSize, n.config.serverUrl, c, n.config.debug, n.config.onServerTiming, n.config.serverErrorCodes)
+		};
+	} catch (o) {
+		if (o instanceof Error && (o.name === `AbortError` || o.name === `TimeoutError`)) {
+			if (n.config.signal?.aborted === true) return {
+				ok: false,
+				retry: false,
+				cause: new t(`Request aborted by caller`, e.ABORTED, {
+					context: {
+						endpoint: n.endpoint,
+						requestId: n.requestId,
+						requestSize: n.requestSize
+					},
+					originalError: o
+				})
+			};
+			let s = typeof n.config.timeoutMs == `number` && n.config.timeoutMs > 0 ? new t(`Request timed out after ${n.config.timeoutMs}ms`, e.TIMEOUT_ERROR, {
+				context: {
+					serverUrl: n.config.serverUrl,
+					timeoutMs: n.config.timeoutMs,
+					url: n.fullUrl,
+					requestId: n.requestId,
+					endpoint: n.endpoint,
+					requestSize: n.requestSize
+				},
+				originalError: o
+			}) : new t(`Request aborted by the runtime (${o.name}): ${o.message}`, e.NETWORK_ERROR, {
+				context: {
+					serverUrl: n.config.serverUrl,
+					url: n.fullUrl,
+					requestId: n.requestId,
+					endpoint: n.endpoint,
+					requestSize: n.requestSize
+				},
+				originalError: o
+			});
+			return i < a - 1 ? {
+				ok: false,
+				retry: true,
+				delayMs: z$1(i, r),
+				cause: s
+			} : {
+				ok: false,
+				retry: false,
+				cause: s
+			};
+		}
+		if (o instanceof TypeError) {
+			let s = typeof window < `u` && window.document !== void 0, c = {
+				serverUrl: n.config.serverUrl,
+				url: n.fullUrl,
+				requestId: n.requestId,
+				endpoint: n.endpoint,
+				requestSize: n.requestSize
+			}, l = s ? new t(`Request failed: ${o.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: c,
+				originalError: o
+			}) : new t(`Network error: ${o.message}`, e.NETWORK_ERROR, {
+				context: c,
+				originalError: o
+			});
+			return i < a - 1 ? {
+				ok: false,
+				retry: true,
+				delayMs: z$1(i, r),
+				cause: l
+			} : {
+				ok: false,
+				retry: false,
+				cause: l
+			};
+		}
+		if (o instanceof t) {
+			let t = o.statusCode;
+			return (o.code === e.NETWORK_ERROR && t !== void 0 && t >= 200 && t < 300 || t !== void 0 && (I$1.has(t) || r.retryOn429 && t === 429)) && i < a - 1 ? {
+				ok: false,
+				retry: true,
+				delayMs: z$1(i, r),
+				cause: o
+			} : {
+				ok: false,
+				retry: false,
+				cause: o
+			};
+		}
+		return {
+			ok: false,
+			retry: false,
+			cause: new t(o instanceof Error ? o.message : String(o), e.UNKNOWN_ERROR, {
+				context: {
+					endpoint: n.endpoint,
+					requestId: n.requestId
+				},
+				originalError: o instanceof Error ? o : Error(String(o))
+			})
+		};
+	} finally {
+		s();
+	}
+}
+async function U$1(n, r, i) {
+	let a = O$1(), o;
+	try {
+		o = 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: a
+			},
+			originalError: r instanceof Error ? r : Error(String(r))
+		});
+	}
+	let s = C$1(o), c = ee(n, i.serverUrl), l = D$1(a, i), u = L$1(i.retry), d = u.attempts + 1;
+	if (i.debug) {
+		let e = (s / 1024).toFixed(2);
+		T$1(`${s > 1e5 ? `⚠️` : `🚀`} Starting compute request [${a}]: ${n} (${e}KB)`, true);
+	}
+	let f = {
+		endpoint: n,
+		body: o,
+		requestSize: s,
+		fullUrl: c,
+		requestId: a,
+		headers: l,
+		config: i
+	};
+	for (let r = 0;; r++) {
+		let o = await H$1(f, u, r, d);
+		if (o.ok) return o.value;
+		if (!o.retry) throw o.cause;
+		i.debug && T$1(`🔁 Request [${a}] retrying after ${o.delayMs}ms (attempt ${r + 2}/${d}): ${o.cause.message}`, true);
+		try {
+			await B$1(o.delayMs, i.signal);
+		} catch {
+			throw new t(`Request aborted by caller`, e.ABORTED, {
+				context: {
+					endpoint: n,
+					requestId: a,
+					requestSize: s
+				},
+				originalError: o.cause
+			});
+		}
+	}
+}
+function W$1(e) {
+	return typeof e == `object` && !(e instanceof Uint8Array) && typeof e.key == `string` && typeof e.load == `function`;
+}
+var G$1 = (e) => (e ?? ``).replace(/::/g, `/`).replace(/\\/g, `/`).split(`/`).map((e) => e.trim()).filter((e) => e !== ``);
+var K$1 = (e) => G$1(e.subFolder)[0] ?? ``;
+var q$1 = (e) => G$1(e.subFolder).slice(1).join(`/`);
+var J$1 = (e) => {
+	let t = /* @__PURE__ */ new Map();
+	for (let n of e) {
+		let e = K$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 oe$1 = (e) => {
+	let t = e.replace(/[/\\:*?"<>|]/g, `_`).replace(/\s+/g, ` `).trim().replace(/^\.+/, ``);
+	return t === `` ? `files` : t;
+};
+var X$1 = async (n, r, i = null) => {
+	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 de$1(await Q$1(n, i), r);
+	} 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 instanceof Error ? n : void 0
+		});
+	}
+};
+var se$1 = async (e, t, n = null) => {
+	let r = J$1(e);
+	if (r.length === 0) {
+		await X$1([], t, n);
+		return;
+	}
+	let i = (r.find((e) => e.root === ``) ?? r[0]).root;
+	for (let { root: e, files: a } of r) await X$1(e === `` ? a : a.map((e) => ({
+		...e,
+		subFolder: q$1(e)
+	})), e === `` ? t : oe$1(e), e === i ? n : null);
+};
+var Z$1 = (e) => e.replace(/::/g, `/`).replace(/\\/g, `/`).split(`/`).map((e) => e.trim()).filter((e) => e !== `` && e !== `.` && e !== `..` && !/^[a-zA-Z]:$/.test(e)).join(`/`);
+var ce$1 = (e) => e === true || typeof e == `string` && e.trim().toLowerCase() === `true`;
+var le$1 = (e) => {
+	let t = [];
+	return e.forEach((e) => {
+		let n = c(e, `fileName`) ?? ``, r = c(e, `fileType`) ?? ``, i = Z$1(`${n}${r}`);
+		if (i === ``) {
+			a().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 === `` ? i : `${s}/${i}`, u = c(e, `data`);
+		if (typeof u != `string` || u === ``) {
+			a().warn(`Skipping file "${l}": item carries no usable data.`);
+			return;
+		}
+		let d = c(e, `metadata`);
+		if (ce$1(c(e, `isBase64Encoded`))) try {
+			t.push({
+				fileName: i,
+				content: S$1(u),
+				path: l,
+				subFolder: s,
+				...d ? { metadata: d } : {}
+			});
+		} catch (e) {
+			a().warn(`Skipping file "${l}": base64 decode failed.`, e);
+		}
+		else t.push({
+			fileName: i,
+			content: u,
+			path: l,
+			subFolder: s,
+			...d ? { metadata: d } : {}
+		});
+	}), t;
+};
+var ue = async (e) => (await Promise.all(e.map(async (e) => {
+	try {
+		let t = typeof AbortSignal < `u` && typeof AbortSignal.timeout == `function` ? AbortSignal.timeout(3e4) : void 0, n = await fetch(e.filePath, { signal: t });
+		if (!n.ok) return a().warn(`Failed to fetch additional file from URL: ${e.filePath}`), null;
+		let r = await n.arrayBuffer(), i = Z$1(e.fileName);
+		if (i === ``) return a().warn(`Skipping fetched file with unusable name: ${e.fileName}`), null;
+		let o = e.subFolder ? Z$1(e.subFolder) : ``;
+		return {
+			fileName: i,
+			content: new Uint8Array(r),
+			path: o === `` ? i : `${o}/${i}`,
+			subFolder: o
+		};
+	} catch (t) {
+		return a().error(`Error fetching additional file from URL: ${e.filePath}`, t), null;
+	}
+}))).filter((e) => e !== null);
+var Q$1 = async (e, t) => {
+	let n = le$1(e);
+	if (t) {
+		let e = Array.isArray(t) ? t : [t];
+		n.push(...await ue(e));
+	}
+	let r = /* @__PURE__ */ new Set();
+	return n.map((e) => {
+		let t = $$1(e.path, r);
+		return r.add(t), t === e.path ? e : (a().warn(`Duplicate archive path "${e.path}" — storing as "${t}".`), {
+			...e,
+			path: t,
+			fileName: t.slice(t.lastIndexOf(`/`) + 1)
+		});
+	});
+};
+async function de$1(e, t) {
+	let { zip: n, strToU8: r } = await import('./esm.js-Dzxc7OGH.js'), i = {}, o = /* @__PURE__ */ new Set();
+	e.forEach((e) => {
+		let t = $$1(e.path, o);
+		o.add(t), t !== e.path && a().warn(`Duplicate archive path "${e.path}" — storing as "${t}".`), i[t] = typeof e.content == `string` ? r(e.content) : e.content;
+	});
+	let s = await new Promise((e, t) => {
+		n(i, { level: 6 }, (n, r) => n ? t(n) : e(r));
+	});
+	fe$1(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 fe$1(n, r) {
+	if (typeof document > `u`) throw new t(`saveFile requires a browser environment with DOM API access.`, e.BROWSER_ONLY, { context: {
+		function: `saveFile`,
+		requiredAPI: `document`
+	} });
+	let i = URL.createObjectURL(n), a = document.createElement(`a`);
+	a.href = i, a.download = r, document.body.appendChild(a), a.click(), a.remove(), setTimeout(() => URL.revokeObjectURL(i), 1e4);
+}
+//#endregion
+//#region ../compute/dist/grasshopper.js
+var h = class n {
+	serverUrl;
+	apiKey;
+	disposed = false;
+	activeMonitors = /* @__PURE__ */ new Set();
+	activeTimeouts = /* @__PURE__ */ new Set();
+	static DEFAULT_TIMEOUT_MS = 5e3;
+	static LIFECYCLE_TIMEOUT_MS = 6e4;
+	static MIN_MONITOR_INTERVAL_MS = 100;
+	constructor(e, t) {
+		this.serverUrl = m(e), this.apiKey = t;
+	}
+	buildHeaders() {
+		let e = { "Content-Type": `application/json` };
+		return this.apiKey && (e.RhinoComputeKey = this.apiKey), e;
+	}
+	fetchWithTimeout(e, t = {}, r = n.DEFAULT_TIMEOUT_MS) {
+		let i = new Headers(this.buildHeaders());
+		t.headers && new Headers(t.headers).forEach((e, t) => {
+			i.set(t, e);
+		});
+		let a = {};
+		i.forEach((e, t) => {
+			a[t] = e;
+		});
+		let o = {
+			...t,
+			headers: a
+		};
+		return r > 0 && !o.signal && (o.signal = AbortSignal.timeout(r)), fetch(e, o);
+	}
+	async isServerOnline(e = 5e3) {
+		return (await this.probeServer(e)).online;
+	}
+	async probeServer(e = 5e3) {
+		this.ensureNotDisposed();
+		let t = `${this.serverUrl}/`;
+		try {
+			let n = await this.fetchWithTimeout(t, {
+				method: `GET`,
+				redirect: `manual`
+			}, e), r = n.type === `opaqueredirect` || n.status >= 300 && n.status < 400;
+			return {
+				online: n.ok || r,
+				status: n.status
+			};
+		} catch (e) {
+			return a().debug(`[ComputeServerStats] Fetch error:`, e), {
+				online: false,
+				error: e instanceof Error ? `${e.name}: ${e.message}` : String(e)
+			};
+		}
+	}
+	async getActiveChildren(e = {}) {
+		this.ensureNotDisposed();
+		let { initialize: t = true } = e, i = t ? `${this.serverUrl}/activechildren` : `${this.serverUrl}/activechildren?initialize=false`, a$1 = t ? n.LIFECYCLE_TIMEOUT_MS : n.DEFAULT_TIMEOUT_MS;
+		try {
+			let e = await this.fetchWithTimeout(i, {}, a$1);
+			if (!e.ok) return a().warn(`[ComputeServerStats] Failed to fetch active children:`, e.status), null;
+			let t = (await e.text()).trim();
+			return /^\d+$/.test(t) ? parseInt(t, 10) : (a().warn(`[ComputeServerStats] Invalid active children response:`, t), null);
+		} catch (e) {
+			return a().warn(`[ComputeServerStats] Error fetching active children:`, e), null;
+		}
+	}
+	async getVersion() {
+		this.ensureNotDisposed();
+		try {
+			let e = await this.fetchWithTimeout(`${this.serverUrl}/version`);
+			if (!e.ok) return a().warn(`[ComputeServerStats] Failed to fetch version:`, e.status), null;
+			let t = await e.text();
+			try {
+				let e = JSON.parse(t);
+				return {
+					rhino: e.rhino ?? ``,
+					compute: e.compute ?? ``,
+					git_sha: e.git_sha ?? null
+				};
+			} catch {
+				return {
+					rhino: t,
+					compute: ``,
+					git_sha: null
+				};
+			}
+		} catch (e) {
+			return a().warn(`[ComputeServerStats] Error fetching version:`, e), null;
+		}
+	}
+	async getInstalledPlugins(e = `gh`) {
+		this.ensureNotDisposed();
+		try {
+			let t = await this.fetchWithTimeout(`${this.serverUrl}/plugins/${e}/installed`);
+			if (!t.ok) return a().warn(`[ComputeServerStats] Failed to fetch ${e} plugins:`, t.status), null;
+			let n = await t.text();
+			try {
+				let e = JSON.parse(n);
+				return e && typeof e == `object` ? e : null;
+			} catch {
+				return null;
+			}
+		} catch (t) {
+			return a().warn(`[ComputeServerStats] Error fetching ${e} plugins:`, t), 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() {
+		this.ensureNotDisposed();
+		try {
+			let e = await this.fetchWithTimeout(`${this.serverUrl}/cache/purge`, { method: `POST` });
+			if (!e.ok) return a().warn(`[ComputeServerStats] Failed to purge cache:`, e.status), null;
+			let t = await e.text();
+			try {
+				let e = JSON.parse(t);
+				return typeof e.purged == `number` ? e.purged : null;
+			} catch {
+				return null;
+			}
+		} catch (e) {
+			return a().warn(`[ComputeServerStats] Error purging cache:`, e), null;
+		}
+	}
+	async purgeAllChildren() {
+		this.ensureNotDisposed();
+		let e = await this.getActiveChildren({ initialize: false });
+		if (e === null) return a().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() {
+		this.ensureNotDisposed();
+		try {
+			let e = await this.fetchWithTimeout(`${this.serverUrl}/servertime`);
+			if (!e.ok) return a().warn(`[ComputeServerStats] Failed to fetch server time:`, e.status), null;
+			let t = (await e.text()).trim().replace(/^"|"$/g, ``), n = new Date(t);
+			return isNaN(n.getTime()) ? null : n;
+		} catch (e) {
+			return a().warn(`[ComputeServerStats] Error fetching server time:`, e), null;
+		}
+	}
+	async getIdleSpan() {
+		this.ensureNotDisposed();
+		try {
+			let e = await this.fetchWithTimeout(`${this.serverUrl}/idlespan`);
+			if (!e.ok) return a().warn(`[ComputeServerStats] Failed to fetch idle span:`, e.status), null;
+			let t = parseFloat((await e.text()).trim());
+			return isNaN(t) ? null : t;
+		} catch (e) {
+			return a().warn(`[ComputeServerStats] Error fetching idle span:`, e), null;
+		}
+	}
+	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(e) {
+		this.ensureNotDisposed();
+		try {
+			let t = await this.fetchWithTimeout(`${this.serverUrl}${e}`, { method: `POST` }, n.LIFECYCLE_TIMEOUT_MS);
+			if (!t.ok) return a().warn(`[ComputeServerStats] POST ${e} failed:`, t.status), null;
+			let i = await t.text();
+			try {
+				return JSON.parse(i);
+			} catch {
+				return null;
+			}
+		} catch (t) {
+			return a().warn(`[ComputeServerStats] Error on POST ${e}:`, t), null;
+		}
+	}
+	monitor(i, a$2 = 5e3) {
+		if (this.ensureNotDisposed(), !Number.isFinite(a$2) || a$2 < n.MIN_MONITOR_INTERVAL_MS) throw new t(`monitor() intervalMs must be a finite number >= ${n.MIN_MONITOR_INTERVAL_MS}ms, got ${a$2}. Sub-${n.MIN_MONITOR_INTERVAL_MS}ms polling would hot-loop the server.`, e.INVALID_CONFIG, { context: { intervalMs: a$2 } });
+		let o = true, s = null;
+		a().info(`🔄 Starting server stats monitoring every ${a$2}ms`);
+		let c = async () => {
+			if (s !== null && (this.activeTimeouts.delete(s), s = null), o && !this.disposed) {
+				try {
+					let e = await this.getServerStats();
+					if (!o || this.disposed) return;
+					try {
+						i(e);
+					} catch (e) {
+						a().error(`[ComputeServerStats] Monitor callback threw:`, e);
+					}
+				} catch (e) {
+					!o || this.disposed ? a().debug(`[ComputeServerStats] Monitor poll cancelled during shutdown:`, e) : a().error(`[ComputeServerStats] Failed to fetch stats during monitor:`, e);
+				}
+				o && !this.disposed && (s = setTimeout(() => void c(), a$2), this.activeTimeouts.add(s));
+			}
+		}, l = () => {
+			o = false, s !== null && (clearTimeout(s), this.activeTimeouts.delete(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();
+			for (let e of this.activeTimeouts) clearTimeout(e);
+			this.activeTimeouts.clear();
+		}
+	}
+	ensureNotDisposed() {
+		if (this.disposed) throw new t(`ComputeServerStats has been disposed and cannot be used`, e.INVALID_STATE, { context: { disposed: this.disposed } });
+	}
+};
+var te = /* @__PURE__ */ new Set();
+function ne() {
+	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 g(e, t) {
+	t || ne() && !te.has(e) && (te.add(e), a().warn(`Warning: ${e} is running on the client side. For better performance and security, consider running this on the server side.`));
+}
+var re = { definition_not_cached: e.DEFINITION_NOT_CACHED };
+function _(e) {
+	return {
+		...e,
+		serverErrorCodes: {
+			...re,
+			...e.serverErrorCodes
+		}
+	};
+}
+function ie(n) {
+	return n instanceof t ? n.code === e.DEFINITION_NOT_CACHED || n.message.includes(`Unable to load grasshopper definition`) : false;
+}
+function ae(e, t) {
+	if (!t) return;
+	let n = c(e, `values`);
+	if (!Array.isArray(n) || n.length === 0) return;
+	let i = [];
+	for (let e of n) {
+		let t = c(e, `innerTree`);
+		(!t || Object.keys(t).length === 0) && i.push(c(e, `paramName`) ?? `<unnamed>`);
+	}
+	if (i.length === 0) return;
+	let a$3 = i.length === n.length ? `all` : `${i.length}/${n.length}`;
+	a().warn(`Solve returned empty output(s) (${a$3}): ${i.join(`, `)}. These parameters produced no data — check the definition's inputs and the branch feeding each.`);
+}
+async function v(e, t, n) {
+	g(`solveGrasshopperDefinition`, n.suppressBrowserWarning);
+	let { response: r } = await b(x(await y(t), e), n);
+	return r;
+}
+async function oe(e, t, n) {
+	return g(`solveGrasshopperDefinitionWithCacheKey`, n.suppressBrowserWarning), b(x(await y(t), e), n);
+}
+async function se(e, t, n, r) {
+	g(`solveByCacheKey`, r.suppressBrowserWarning);
+	let i = {
+		algo: null,
+		pointer: t,
+		values: e
+	};
+	try {
+		return {
+			...await b(i, r),
+			missed: !1
+		};
+	} catch (t) {
+		if (!ie(t)) throw t;
+		return {
+			...await b(x(await y(n), e), r),
+			missed: true
+		};
+	}
+}
+async function y(n) {
+	if (!W$1(n)) return n;
+	try {
+		return await n.load();
+	} catch (r) {
+		throw new t(`Failed to load definition bytes for ref '${n.key}'`, e.INVALID_INPUT, {
+			context: { definitionKey: n.key },
+			originalError: r instanceof Error ? r : Error(String(r))
+		});
+	}
+}
+async function b(e, t) {
+	ce(e, t);
+	let n = await U$1(`grasshopper`, e, _(t)), { pointer: r, algo: a, ...o } = n, c = o, l = re$1(n);
+	if (l !== void 0) {
+		let e = typeof a == `string` ? a.length : 0;
+		j$1(c, Math.max(0, l - e));
+	}
+	return ae(c, t.debug), {
+		response: c,
+		cacheKey: typeof r == `string` ? r : null
+	};
+}
+function x(e, t) {
+	let n = {
+		algo: null,
+		pointer: null,
+		values: t
+	};
+	return e instanceof Uint8Array ? n.algo = w$1(e) : /^https?:\/\//i.test(e) ? n.pointer = e : n.algo = x$1(e) ?? b$1(e), n;
+}
+function ce(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 S(e) {
+	let t = /* @__PURE__ */ new WeakSet(), n = (e) => {
+		if (e === void 0) return `undefined`;
+		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 (e instanceof Uint8Array) return `{"__u8":${e.length},"hash":"${le(e)}"}`;
+		if (Array.isArray(e)) {
+			if (t.has(e)) return `"[Circular]"`;
+			t.add(e);
+			let r = [];
+			for (let t = 0; t < e.length; t++) r.push(n(e[t]));
+			return t.delete(e), `[${r.join(`,`)}]`;
+		}
+		if (typeof e == `object`) {
+			if (t.has(e)) return `"[Circular]"`;
+			t.add(e);
+			let r;
+			return 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(`,`)}}`, t.delete(e), r;
+		}
+		return `null`;
+	};
+	return n(e);
+}
+function C(e, t) {
+	let n = 2166136261;
+	for (let r = 0; r < e; r++) n ^= t(r), n = n + ((n << 1) + (n << 4) + (n << 7) + (n << 8) + (n << 24)) >>> 0;
+	return n.toString(16).padStart(8, `0`);
+}
+function w(e) {
+	return C(e.length, (t) => e.charCodeAt(t));
+}
+function le(e) {
+	return C(e.length, (t) => e[t]);
+}
+function T(e, t) {
+	let n = S(t);
+	return `${e}|t:${n.length}:${w(n)}`;
+}
+function E(e) {
+	return W$1(e) ? `r:${e.key}` : typeof e == `string` ? `s:${e.length}:${w(e)}` : `u8:${e.length}:${le(e)}`;
+}
+function de(e) {
+	return typeof e != `string` || !/^https?:\/\//i.test(e);
+}
+function fe(e) {
+	try {
+		return JSON.stringify(e)?.length ?? 0;
+	} catch {
+		return 0;
+	}
+}
+var D = 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;
+	cacheKeyExecutor;
+	reuseServerDefinitionCache;
+	serverCacheKeys = /* @__PURE__ */ new Map();
+	onStart;
+	onSettle;
+	onSuperseded;
+	subscribers = /* @__PURE__ */ new Set();
+	inFlight = /* @__PURE__ */ new Set();
+	pendingForLatestWins = null;
+	fifoQueue = [];
+	_lastResult = null;
+	_lastError = null;
+	_lastDurationMs = null;
+	solveSeq = 0;
+	lastStateSeq = 0;
+	disposed = false;
+	constructor(e, t, n = {}, r) {
+		this.executor = e, this.cacheKeyExecutor = r, this.baseConfig = t, this.mode = n.mode ?? `latest-wins`, this.maxConcurrent = Math.max(1, n.maxConcurrent ?? (this.mode === `parallel` ? 4 : 1)), this.maxQueueDepth = n.maxQueueDepth !== void 0 && n.maxQueueDepth > 0 ? Math.floor(n.maxQueueDepth) : void 0, this.queueWaitMs = n.queueWaitMs !== void 0 && n.queueWaitMs > 0 ? n.queueWaitMs : void 0, this.timeoutMs = n.timeoutMs, this.retry = n.retry;
+		let i = n.cache, a = typeof i == `object` ? i : null;
+		this.cacheMaxBytes = Math.max(0, a?.maxBytes ?? 0), this.cacheEnabled = this.cacheMaxBytes > 0, this.cacheTtl = a?.ttlMs ?? 0, this.cacheErroredSolves = a?.cacheErroredSolves ?? true, this.reuseServerDefinitionCache = !!r && (n.reuseServerDefinitionCache ?? true), this.onStart = n.onStart, this.onSettle = n.onSettle, this.onSuperseded = n.onSuperseded;
+	}
+	get isSolving() {
+		return this.inFlight.size > 0;
+	}
+	get hasPending() {
+		return this.pendingForLatestWins !== null || this.fifoQueue.length > 0;
+	}
+	get inFlightCount() {
+		return this.inFlight.size;
+	}
+	get queueDepth() {
+		return this.fifoQueue.length + +!!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) {
+			a().error(`[SolveScheduler] subscriber threw:`, e);
+		}
+	}
+	solve(n, r, i) {
+		if (this.disposed) return Promise.reject(new t(`SolveScheduler has been disposed and cannot be used`, e.INVALID_STATE));
+		let a = E(n), o = T(a, r), s = ++this.solveSeq, c = {
+			key: o,
+			enqueuedAt: Date.now(),
+			startedAt: null
+		};
+		if (i?.signal?.aborted) return Promise.reject(this.makeAbortError(c));
+		if (this.cacheEnabled) {
+			let e = this.readCache(o);
+			if (e) {
+				this.mode === `latest-wins` && this.supersedeCurrent();
+				let t = {
+					status: `success`,
+					response: e,
+					durationMs: 0,
+					fromCache: true
+				};
+				return this.writeLastState(s, {
+					result: e,
+					durationMs: 0
+				}), this.runHook(this.onStart, c), this.runHook(this.onSettle, c, t), this.notify(), Promise.resolve(e);
+			}
+		}
+		return new Promise((e, t) => {
+			let o = {
+				definition: n,
+				dataTree: r,
+				definitionHash: a,
+				ctx: c,
+				seq: s,
+				resolve: e,
+				reject: t,
+				externalSignal: i?.signal,
+				selvaevents: i?.selvaevents
+			};
+			o.externalSignal && (o.queuedAbortHandler = () => this.abortQueuedItem(o), o.externalSignal.addEventListener(`abort`, o.queuedAbortHandler, { once: true })), this.enqueue(o);
+		});
+	}
+	writeLastState(e, t) {
+		return e < this.lastStateSeq ? false : (this.lastStateSeq = e, `result` in t ? (this._lastResult = t.result, this._lastError = null) : this._lastError = t.error, this._lastDurationMs = t.durationMs, true);
+	}
+	supersedeCurrent() {
+		this.pendingForLatestWins &&= (this.supersede(this.pendingForLatestWins), null);
+		for (let e of this.inFlight) this.supersede(e), e.controller.abort();
+	}
+	abortQueuedItem(e) {
+		this.pendingForLatestWins === e && (this.pendingForLatestWins = null);
+		let t = this.fifoQueue.indexOf(e);
+		t >= 0 && this.fifoQueue.splice(t, 1), this.rejectAsAborted(e), this.notify();
+	}
+	shedAsQueueFull(n) {
+		let r = new t(`Solve queue is full; request rejected (backpressure)`, e.QUEUE_FULL, {
+			statusCode: 503,
+			context: {
+				key: n.ctx.key,
+				queueDepth: this.fifoQueue.length,
+				maxQueueDepth: this.maxQueueDepth
+			}
+		});
+		this.settleError(n, r) && this.runHook(this.onSettle, n.ctx, {
+			status: `error`,
+			error: r,
+			durationMs: 0
+		}), this.notify();
+	}
+	armQueueWaitTimer(n) {
+		if (this.queueWaitMs === void 0) return;
+		let r = this.queueWaitMs;
+		n.queueWaitTimer = setTimeout(() => {
+			if (n.settled) return;
+			let i = this.fifoQueue.indexOf(n);
+			i >= 0 && this.fifoQueue.splice(i, 1);
+			let a = new t(`Solve waited longer than ${r}ms in queue; rejected (backpressure)`, e.QUEUE_TIMEOUT, {
+				statusCode: 503,
+				context: {
+					key: n.ctx.key,
+					waitedMs: Date.now() - n.ctx.enqueuedAt,
+					queueWaitMs: r
+				}
+			});
+			this.settleError(n, a) && this.runHook(this.onSettle, n.ctx, {
+				status: `error`,
+				error: a,
+				durationMs: 0
+			}), 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`:
+			case `parallel`: this.inFlight.size < this.maxConcurrent ? this.execute(e) : this.maxQueueDepth !== void 0 && this.fifoQueue.length >= this.maxQueueDepth ? this.shedAsQueueFull(e) : (this.armQueueWaitTimer(e), this.fifoQueue.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 }
+			}, { response: r, definitionReuploaded: a } = await this.runExecutor(e.definition, e.dataTree, e.definitionHash, n), o = performance.now() - i;
+			if (this.cacheEnabled && this.writeCache(e.ctx.key, r), !this.settleSuccess(e, r)) return;
+			this.writeLastState(e.seq, {
+				result: r,
+				durationMs: o
+			}), this.runHook(this.onSettle, e.ctx, {
+				status: `success`,
+				response: r,
+				durationMs: o,
+				fromCache: !1,
+				definitionReuploaded: a
+			});
+		} catch (t) {
+			let r = performance.now() - i, a = this.normalizeExecutionError(t, n);
+			this.writeLastState(e.seq, {
+				error: a,
+				durationMs: r
+			}), this.settleError(e, a) && this.runHook(this.onSettle, e.ctx, {
+				status: `error`,
+				error: a,
+				durationMs: r
+			});
+		} finally {
+			e.externalSignal?.removeEventListener(`abort`, r), this.inFlight.delete(n), this.drainNext(), this.notify();
+		}
+	}
+	async runExecutor(e, t, n, r) {
+		if (!this.cacheKeyExecutor || !this.reuseServerDefinitionCache || !de(e)) return { response: await this.executor(e, t, r) };
+		let i = n, a = this.serverCacheKeys.get(i) ?? null, o = await this.cacheKeyExecutor(e, t, a, r);
+		if (o.cacheKey) for (this.serverCacheKeys.delete(i), this.serverCacheKeys.set(i, o.cacheKey); this.serverCacheKeys.size > 100;) {
+			let e = this.serverCacheKeys.keys().next().value;
+			if (e === void 0) break;
+			this.serverCacheKeys.delete(e);
+		}
+		else this.serverCacheKeys.delete(i);
+		return {
+			response: o.response,
+			definitionReuploaded: o.missed
+		};
+	}
+	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.fifoQueue.length > 0 && this.inFlight.size < this.maxConcurrent;) {
+				let e = this.fifoQueue.shift();
+				this.execute(e);
+			}
+		}
+	}
+	supersede(n) {
+		let r = new t(`Superseded by newer solve`, e.SUPERSEDED, { context: {
+			key: n.ctx.key,
+			enqueuedAt: n.ctx.enqueuedAt
+		} });
+		this.settleError(n, r) && this.runHook(this.onSuperseded, n.ctx);
+	}
+	makeAbortError(n) {
+		return new t(`Request aborted by caller`, e.ABORTED, { context: {
+			key: n.key,
+			enqueuedAt: n.enqueuedAt
+		} });
+	}
+	settleError(e, t) {
+		return !e.settled && (e.settled = { error: t }, this.clearQueueWaitTimer(e), this.removeQueuedAbortHandler(e), e.reject(t), true);
+	}
+	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;
+	}
+	isAbortLikeError(e) {
+		if (e instanceof Error) {
+			if (e.name === `AbortError`) return true;
+			if (typeof DOMException < `u` && e instanceof DOMException) return e.name === `AbortError`;
+		}
+		return false;
+	}
+	normalizeExecutionError(n, r) {
+		return r.settled && `error` in r.settled ? r.settled.error : n instanceof t ? n : this.isAbortLikeError(n) ? this.makeAbortError(r.ctx) : new t(n instanceof Error ? n.message : String(n), e.UNKNOWN_ERROR, { originalError: n instanceof Error ? n : Error(String(n)) });
+	}
+	cancelAll() {
+		for (this.pendingForLatestWins &&= (this.rejectAsAborted(this.pendingForLatestWins), null); this.fifoQueue.length > 0;) {
+			let e = this.fifoQueue.shift();
+			this.rejectAsAborted(e);
+		}
+		for (let e of this.inFlight) {
+			let t = this.makeAbortError(e.ctx);
+			this.settleError(e, t) && this.runHook(this.onSettle, e.ctx, {
+				status: `error`,
+				error: t,
+				durationMs: e.ctx.startedAt ? Date.now() - e.ctx.startedAt : 0
+			}), e.controller.abort();
+		}
+		this.notify();
+	}
+	rejectAsAborted(e) {
+		let t = this.makeAbortError(e.ctx);
+		this.settleError(e, t) && this.runHook(this.onSettle, e.ctx, {
+			status: `error`,
+			error: t,
+			durationMs: 0
+		});
+	}
+	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(e, t) {
+		if (!this.cacheEnabled) return;
+		let n = c(t, `errors`);
+		if (!this.cacheErroredSolves && Array.isArray(n) && n.length > 0) return;
+		let r = re$1(t) ?? fe(t);
+		if (!(r > this.cacheMaxBytes)) for (this.dropCacheEntry(e), this.cache.set(e, {
+			response: t,
+			insertedAt: Date.now(),
+			sizeBytes: r
+		}), this.cacheBytes += r; 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) {
+			a().error(`[SolveScheduler] hook threw:`, e);
+		}
+	}
+};
+function O(e) {
+	return W$1(e) ? `ref:${e.key}` : typeof e == `string` && e.length < 200 ? e : `...content...`;
+}
+function k(e) {
+	return Array.isArray(e) ? e.map((e) => {
+		let t = 0, n = 0, r = c(e, `innerTree`);
+		if (r && typeof r == `object`) {
+			for (let e of Object.values(r)) if (Array.isArray(e)) {
+				t += e.length;
+				for (let t of e) {
+					let e = t?.data;
+					typeof e == `string` && (n += e.length);
+				}
+			}
+		}
+		return {
+			param: c(e, `paramName`) ?? `<unnamed>`,
+			items: t,
+			bytes: n
+		};
+	}) : [];
+}
+var pe = class n {
+	config;
+	serverStats;
+	disposed = false;
+	static CREATE_PROBE_TIMEOUT_MS = 2e3;
+	constructor(e) {
+		this.config = this.normalizeComputeConfig(e), this.serverStats = new h(this.config.serverUrl, this.config.apiKey);
+	}
+	static async create(r) {
+		let i = new n(r), a = Math.max(1, (r.retry?.attempts ?? 2) + 1), o = r.retry?.baseDelayMs ?? 250, s = r.retry?.maxDelayMs ?? 1e3, l, u = null, d = 0;
+		for (let e = 0; e < a; e++) {
+			if (d = e + 1, l = await i.serverStats.probeServer(n.CREATE_PROBE_TIMEOUT_MS), l.online) return i;
+			if (u = v$1(l), u && !u.retryable) break;
+			if (e < a - 1) {
+				let t = Math.min(o * 2 ** e, s);
+				await new Promise((e) => setTimeout(e, t));
+			}
+		}
+		await i.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: i.config.serverUrl,
+				attempts: d,
+				maxAttempts: a,
+				...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(), Xe(e, this.config);
+	}
+	async getRawIO(e) {
+		return this.ensureNotDisposed(), Q(e, this.config);
+	}
+	async solve(n, i, a$5) {
+		this.ensureNotDisposed();
+		try {
+			if (typeof n == `string` && !n?.trim()) throw new t(`Definition URL/content is required`, e.INVALID_INPUT, { context: { receivedUrl: n } });
+			if (n instanceof Uint8Array && n.length === 0) throw new t(`Definition content is empty`, e.INVALID_INPUT);
+			if (W$1(n) && !n.key.trim()) throw new t(`DefinitionRef key is empty`, e.INVALID_INPUT);
+			let r = await v(i, n, {
+				...this.config,
+				...a$5?.signal !== void 0 && { signal: a$5.signal },
+				...a$5?.timeoutMs !== void 0 && { timeoutMs: a$5.timeoutMs },
+				...a$5?.retry !== void 0 && { retry: a$5.retry },
+				...a$5?.selvaevents !== void 0 && { selvaevents: a$5.selvaevents }
+			}), o = c(r, `errors`);
+			if (Array.isArray(o) && o.length > 0) throw new t(o.map(String).join(`; `) || `Computation failed`, e.COMPUTATION_ERROR, { context: {
+				definition: O(n),
+				inputSummary: k(i),
+				errors: o,
+				warnings: c(r, `warnings`),
+				values: r.values
+			} });
+			return r;
+		} catch (a$4) {
+			throw this.config.debug && a().error(`Compute failed:`, a$4), a$4 instanceof t ? a$4 : new t(a$4 instanceof Error ? a$4.message : String(a$4), e.COMPUTATION_ERROR, {
+				context: {
+					definition: O(n),
+					inputSummary: k(i)
+				},
+				originalError: a$4 instanceof Error ? a$4 : Error(String(a$4))
+			});
+		}
+	}
+	createScheduler(e) {
+		return this.ensureNotDisposed(), new D((e, t, n) => v(t, e, n), this.config, e, (e, t, n, r) => n === null ? oe(t, e, r).then((e) => ({
+			...e,
+			missed: false
+		})) : se(t, n, e, r));
+	}
+	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);
+	}
+	normalizeComputeConfig(e) {
+		return {
+			...e,
+			serverUrl: m(e.serverUrl),
+			apiKey: e.apiKey,
+			authToken: e.authToken,
+			debug: e.debug ?? false,
+			suppressBrowserWarning: e.suppressBrowserWarning
+		};
+	}
+};
+var A = /* @__PURE__ */ new Map();
+function me(e, t) {
+	A.set(e, t);
+}
+me(`Rhino.Geometry.Point3d`, (e, t) => {
+	let n = t;
+	return !n || typeof n.X != `number` ? null : new e.Point([
+		n.X,
+		n.Y,
+		n.Z
+	]);
+}), me(`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 he(e) {
+	if (A.has(e)) return A.get(e);
+	for (let [t, n] of A) if (e.startsWith(t)) return n;
+}
+function ge(e) {
+	return !!(e && typeof e == `object` && typeof e.data == `string`);
+}
+function j(e, t) {
+	return {
+		__decodeError: true,
+		type: e,
+		raw: t
+	};
+}
+function _e(e, t, n) {
+	let i = he(t), a$6 = false;
+	if (i) try {
+		let t = i(n, e);
+		if (t != null) return t;
+	} catch (e) {
+		a().warn(`Failed to decode Rhino type ${t}:`, e), a$6 = true;
+	}
+	try {
+		if (ge(e)) return n.CommonObject.decode(e);
+	} catch (n) {
+		return a().warn(`Failed to decode ${t} with CommonObject:`, n), j(t, e);
+	}
+	return a$6 ? j(t, e) : e;
+}
+function ve(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 M = {
+	STRING: `System.String`,
+	INT: `System.Int32`,
+	DOUBLE: `System.Double`,
+	BOOL: `System.Boolean`
+};
+var ye = [`WebDisplay`];
+var N = `FileData`;
+function P(e) {
+	return ye.some((t) => e.includes(t));
+}
+function be(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 xe(e, t, n) {
+	switch (t) {
+		case M.STRING: return typeof e == `string` ? e.replace(/^"(.*)"$/, `$1`) : e;
+		case M.INT: return Number.parseInt(e, 10);
+		case M.DOUBLE: return Number.parseFloat(e);
+		case M.BOOL: return String(e).toLowerCase() === `true`;
+		default: return n && t.startsWith(`Rhino.Geometry.`) ? _e(e, t, n) : e;
+	}
+}
+var F = /* @__PURE__ */ new WeakMap();
+function I(e) {
+	if (F.has(e)) return F.get(e);
+	let t = be(e.data);
+	return F.set(e, t), t;
+}
+function L(e, t, n, r) {
+	if (typeof e.data != `string`) return e.data;
+	let i = n ? I(e) : e.data;
+	return n && t.includes(N) ? R(i) ?? i : xe(i, t, r);
+}
+var Se = (e) => e === true || typeof e == `string` && e.trim().toLowerCase() === `true`;
+function R(e) {
+	if (!e || typeof e != `object`) return null;
+	let t = c(e, `fileName`), r = c(e, `fileType`), i = c(e, `subFolder`), a = c(e, `isBase64Encoded`);
+	if (typeof t != `string` || typeof r != `string` || typeof i != `string` || !u(e, `data`) || typeof a != `boolean` && typeof a != `string`) return null;
+	let o = c(e, `metadata`);
+	return {
+		fileName: t,
+		fileType: r,
+		data: c(e, `data`),
+		isBase64Encoded: Se(a),
+		subFolder: i,
+		...o ? { metadata: o } : {}
+	};
+}
+function z(e) {
+	let t = c(e, `values`);
+	return Array.isArray(t) ? t : [];
+}
+function B(e) {
+	return typeof e.type == `string` ? e.type : ``;
+}
+function V(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 Ce(e, t = false, n = {}) {
+	let { parseValues: r = true, rhino: i, stringOnly: a = false } = n, o = {}, s = /* @__PURE__ */ new Set();
+	for (let n of z(e)) {
+		let e = c(n, `paramName`);
+		V(c(n, `innerTree`), (n) => {
+			let c = B(n);
+			if (P(c) || a && c !== M.STRING) return;
+			let l = t ? n.id : e;
+			if (!l) return;
+			let u = L(n, c, r, i);
+			l in o ? s.has(l) ? o[l].push(u) : (o[l] = [o[l], u], s.add(l)) : o[l] = u;
+		});
+	}
+	return {
+		values: o,
+		dispose: () => ve(o)
+	};
+}
+function we(e) {
+	let t = [];
+	for (let n of z(e)) V(c(n, `innerTree`), (e) => {
+		if (!B(e).includes(N)) return;
+		let n = R(I(e));
+		n && t.push(n);
+	});
+	return t;
+}
+function Te(e, t, n = {}) {
+	let { parseValues: r = true, rhino: i, stringOnly: a = false } = n;
+	for (let n of z(e)) {
+		let e = c(n, `innerTree`), o = false;
+		if (`byName` in t) {
+			if (c(n, `paramName`) !== t.byName) continue;
+			o = true;
+		}
+		let s = [];
+		if (V(e, (e) => {
+			if (`byId` in t) {
+				if (e.id !== t.byId) return;
+				o = true;
+			}
+			let n = B(e);
+			P(n) || a && n !== M.STRING || s.push(L(e, n, r, i));
+		}), o) return s.length === 0 ? void 0 : s.length === 1 ? s[0] : s;
+	}
+}
+var Ee = class {
+	response;
+	debug;
+	constructor(e, t = false) {
+		this.response = e, this.debug = t;
+	}
+	getValues(e = false, t = {}) {
+		return Ce(this.response, e, t);
+	}
+	getValue(e, t) {
+		return Te(this.response, e, t);
+	}
+	getFileData() {
+		return we(this.response);
+	}
+	async getAndDownloadFiles(e, t) {
+		await X$1(this.getFileData(), e, t);
+	}
+};
+var H = /^\{(-?\d+(?:;-?\d+)*)?\}$/;
+function U(e) {
+	if (typeof e != `object` || !e || Array.isArray(e)) return false;
+	let t = Object.entries(e);
+	return t.length > 0 && t.every(([e, t]) => H.test(e) && Array.isArray(t));
+}
+function W(e, t, n) {
+	let r = Number(e.toFixed(t));
+	return Math.abs(e - r) < n ? r : e;
+}
+function De(e, t) {
+	if (!Number.isFinite(e) || e === 0) return .1;
+	let n = Math.abs(e);
+	if (n >= 1) {
+		let n = String(e).split(`.`)[1];
+		if (n && n.length > 0) {
+			let e = Math.min(n.length, 12), r = 10 ** -e, i = Number(r.toFixed(e));
+			return Math.abs(i - r) < t ? i : r;
+		}
+		return 1;
+	}
+	let r = String(e), i = r.toLowerCase().match(/e(-?\d+)/);
+	if (i) {
+		let e = Number(i[1]);
+		if (e < 0 || r.toLowerCase().includes(`e-`)) {
+			let n = Math.abs(e), r = 10 ** -n, i = Number(r.toFixed(n));
+			return Math.abs(i - r) < t ? i : r;
+		}
+		return .1;
+	}
+	let a = n.toFixed(12).replace(/0+$/, ``), o = Math.min((a.split(`.`)[1] || ``).length, 12);
+	if (o === 0) return .1;
+	let s = 10 ** -o, c = Number(s.toFixed(o));
+	return Math.abs(c - s) < t ? c : s;
+}
+function G(e) {
+	return typeof e.stepSize == `number` && Number.isFinite(e.stepSize) && e.stepSize > 0 ? e.stepSize : void 0;
+}
+function K(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 q = (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 J = (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 Oe = (e) => typeof e == `string` ? e.length >= 2 && e.startsWith(`"`) && e.endsWith(`"`) ? e.slice(1, -1) : e.startsWith(`"`) ? e.slice(1) : e : null;
+var ke = (e) => {
+	if (typeof e == `string`) {
+		let t = e.trim();
+		return t.startsWith(`"`) && t.endsWith(`"`) && (t = t.slice(1, -1).trim()), t;
+	}
+	return null;
+};
+function Y(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 : (a().warn(`Parsed value for input ${e} is not an object`), null);
+		} catch (n) {
+			return a().warn(`Failed to parse object value "${t}" for input ${e}`, n), null;
+		}
+		return null;
+	};
+}
+function Ae(n, r = 1e-8) {
+	let i = n.paramType === `Integer`, a = G(n);
+	if (U(n.default)) return {
+		default: n.default,
+		stepSize: a ?? (i ? 1 : .1)
+	};
+	if (typeof n.default == `string` && n.default.trim() !== `` && q(n.default) === null) throw new t(`Invalid numeric default "${n.default}" for input "${n.name || `unknown`}"`, e.VALIDATION_ERROR, { context: {
+		inputName: n.name,
+		default: n.default
+	} });
+	let o = K(n.default, q, true);
+	if (i) return Array.isArray(o) ? o = o.map((e) => typeof e == `number` ? Math.round(e) : e) : typeof o == `number` && (o = Math.round(o)), {
+		default: o,
+		stepSize: a ?? 1
+	};
+	let s = Array.isArray(o) ? o[0] : o, c;
+	typeof s == `number` && Number.isFinite(s) && s !== 0 ? c = s : typeof n.minimum == `number` && Number.isFinite(n.minimum) && n.minimum !== 0 ? c = n.minimum : typeof n.maximum == `number` && Number.isFinite(n.maximum) && n.maximum !== 0 && (c = n.maximum);
+	let l = a ?? (c === void 0 ? .1 : De(c, r)), u = 0, d = String(l), f = d.toLowerCase().match(/e(-?\d+)/);
+	if (u = f ? Math.abs(Number(f[1])) : d.split(`.`)[1]?.length ?? 0, u === 0 && typeof s == `number` && s !== 0 && Math.abs(s) < 1) {
+		let e = Math.ceil(-Math.log10(Math.abs(s)));
+		Number.isFinite(e) && e > 0 && (u = e);
+	}
+	return u = Math.min(Math.max(u, 0), 12), Array.isArray(o) ? o = o.map((e) => typeof e == `number` ? W(e, u, r) : e) : typeof o == `number` && (o = W(o, u, r)), {
+		default: o,
+		stepSize: l
+	};
+}
+var je = {
+	types: [`Number`, `Integer`],
+	parse(e, t) {
+		let { default: n, stepSize: r } = Ae(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 = (e.atMost ?? 1) > 1, r = 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: G(e) ?? (e.paramType === `Integer` ? 1 : .1),
+			default: n ? [r] : r
+		};
+	}
+};
+var Me = {
+	types: [`Boolean`],
+	parse(n, r) {
+		if (U(n.default)) return {
+			...r,
+			paramType: `Boolean`,
+			default: n.default
+		};
+		let i = K(n.default, J, false);
+		if (i != null && typeof i != `boolean` && !Array.isArray(i)) throw new t(`Invalid boolean default "${String(i)}" for input "${n.name || `unknown`}"`, e.VALIDATION_ERROR, { context: {
+			inputName: n.name,
+			default: n.default
+		} });
+		return {
+			...r,
+			paramType: `Boolean`,
+			default: i
+		};
+	},
+	fallback(e, t) {
+		let n = (e.atMost ?? 1) > 1;
+		return {
+			...t,
+			paramType: `Boolean`,
+			default: n ? [false] : false
+		};
+	}
+};
+var Ne = {
+	types: [`Text`],
+	parse(e, t) {
+		let n = K(e.default, Oe, false);
+		return {
+			...t,
+			paramType: `Text`,
+			default: n
+		};
+	},
+	fallback(e, t) {
+		let n = (e.atMost ?? 1) > 1;
+		return {
+			...t,
+			paramType: `Text`,
+			default: n ? [``] : ``
+		};
+	}
+};
+var Pe = {
+	types: [`ValueList`],
+	parse(n, i, a$7) {
+		if (!n.values || typeof n.values != `object` || Object.keys(n.values).length === 0) throw t.missingValues(n.nickname || `unnamed`, `ValueList`);
+		let o = n.default;
+		if (n.default !== void 0 && n.default !== null) {
+			if (typeof n.default == `object`) throw new t(`ValueList input "${n.nickname || `unnamed`}" default is not a string-able value`, e.VALIDATION_ERROR, { context: {
+				inputName: n.name,
+				default: n.default
+			} });
+			let i = String(n.default).toLowerCase(), s = Object.keys(n.values).find((e) => e.toLowerCase() === i);
+			if (s !== void 0) o = s;
+			else {
+				let t = `ValueList input "${n.nickname || `unnamed`}" default value "${n.default}" is not in available values`;
+				a().warn(t), a$7?.({
+					code: e.VALIDATION_ERROR,
+					message: t
+				});
+			}
+		}
+		return {
+			...i,
+			paramType: `ValueList`,
+			values: n.values,
+			default: o
+		};
+	},
+	fallback(e, t) {
+		return {
+			...t,
+			paramType: `ValueList`,
+			values: e.values && typeof e.values == `object` ? e.values : {},
+			default: void 0
+		};
+	}
+};
+var X = {
+	types: [`Geometry`],
+	parse(e, t) {
+		let n = K(e.default, Y(e.nickname || `unnamed`), true);
+		return {
+			...t,
+			paramType: `Geometry`,
+			default: n
+		};
+	},
+	fallback(e, t) {
+		let n = (e.atMost ?? 1) > 1;
+		return {
+			...t,
+			paramType: `Geometry`,
+			default: n ? [null] : null
+		};
+	}
+};
+var Z = new Map([
+	je,
+	Me,
+	Ne,
+	Pe,
+	X,
+	{
+		types: [`File`],
+		parse(e, t) {
+			let n = K(e.default, Y(e.nickname || `unnamed`), true);
+			return {
+				...t,
+				paramType: `File`,
+				acceptedFormats: e.acceptedFormats,
+				default: n
+			};
+		},
+		fallback(e, t) {
+			let n = (e.atMost ?? 1) > 1;
+			return {
+				...t,
+				paramType: `File`,
+				default: n ? [null] : null
+			};
+		}
+	},
+	{
+		types: [`Color`],
+		parse(e, t) {
+			let n = K(e.default, ke, false);
+			return {
+				...t,
+				paramType: `Color`,
+				default: n
+			};
+		},
+		fallback(e, t) {
+			let n = (e.atMost ?? 1) > 1;
+			return {
+				...t,
+				paramType: `Color`,
+				default: n ? [`0, 0, 0`] : `0, 0, 0`
+			};
+		}
+	}
+].flatMap((e) => e.types.map((t) => [t, e])));
+var Fe = X;
+function Ie(e) {
+	return c(e, `data`);
+}
+function Le(e) {
+	return c(e, `type`);
+}
+var Re = /* @__PURE__ */ new Set([
+	`System.Double`,
+	`System.Single`,
+	`System.Decimal`,
+	`System.Int32`,
+	`System.Int64`
+]);
+var ze = /* @__PURE__ */ new Set([`System.Int32`, `System.Int64`]);
+function Be(e) {
+	if (typeof e.default != `object` || e.default === null || Array.isArray(e.default)) return { schema: e };
+	if (!u(e.default, `innerTree`)) {
+		let t = `Input "${e.name ?? `unknown`}" default had an unrecognized shape (no innerTree key); the default was dropped.`;
+		return a().warn(`Unexpected structure in input.default:`, e.default), {
+			schema: {
+				...e,
+				default: null
+			},
+			warning: {
+				code: `MALFORMED_DEFAULT`,
+				message: t
+			}
+		};
+	}
+	let t = c(e.default, `innerTree`) ?? {};
+	if (Object.keys(t).length === 0) return { schema: {
+		...e,
+		default: void 0
+	} };
+	if (e.treeAccess || e.atMost && e.atMost > 1) {
+		let n = {}, i = [];
+		for (let [a$8, o] of Object.entries(t)) {
+			if (!Array.isArray(o)) {
+				let t = `Input "${e.name ?? `unknown`}" default had a non-array innerTree branch ("${a$8}"); the default was dropped.`;
+				return a().warn(`Unexpected structure in input.default innerTree:`, e.default), {
+					schema: {
+						...e,
+						default: null
+					},
+					warning: {
+						code: `MALFORMED_DEFAULT`,
+						message: t
+					}
+				};
+			}
+			let t = [];
+			for (let e of o) {
+				let n = Ie(e), r = Le(e);
+				if (r && Re.has(r)) {
+					if (typeof n == `string` && n.trim() === ``) continue;
+					let e = q(n);
+					if (e === null) {
+						i.push(`"${String(n)}" (${r})`);
+						continue;
+					}
+					t.push(ze.has(r) ? Math.round(e) : e);
+					continue;
+				}
+				if (r === `System.Boolean`) {
+					let e = J(n);
+					if (e === null) {
+						i.push(`"${String(n)}" (${r})`);
+						continue;
+					}
+					t.push(e);
+					continue;
+				}
+				if (typeof n == `string` && r?.startsWith(`Rhino.Geometry`)) {
+					try {
+						t.push(JSON.parse(n));
+					} catch {
+						t.push(n);
+					}
+					continue;
+				}
+				t.push(n);
+			}
+			n[a$8] = t;
+		}
+		let a$9;
+		if (i.length > 0) {
+			let t = `Input "${e.name ?? `unknown`}" default contained ${i.length} tree value(s) that could not be parsed and were dropped: ${i.join(`, `)}.`;
+			a().warn(t), a$9 = {
+				code: `MALFORMED_DEFAULT`,
+				message: t
+			};
+		}
+		return {
+			schema: {
+				...e,
+				default: n
+			},
+			...a$9 && { warning: a$9 }
+		};
+	}
+	let i = [];
+	for (let e of Object.values(t)) Array.isArray(e) && e.forEach((e) => {
+		e && typeof e == `object` && u(e, `data`) && i.push(Ie(e));
+	});
+	return i.length === 0 ? { schema: {
+		...e,
+		default: void 0
+	} } : i.length === 1 ? { schema: {
+		...e,
+		default: i[0]
+	} } : { schema: {
+		...e,
+		default: i
+	} };
+}
+var Ve = new Map([...Z.keys()].map((e) => [e.toLowerCase(), e]));
+function He(e) {
+	return Ve.get(e?.toLowerCase()) ?? e;
+}
+function Ue(e) {
+	return We(e).input;
+}
+function We(e) {
+	let n = {
+		description: e.description,
+		name: e.name,
+		nickname: e.nickname,
+		treeAccess: e.treeAccess,
+		groupName: e.groupName ?? void 0,
+		id: e.id
+	}, i = He(e.paramType), a$10 = {
+		...e,
+		paramType: i
+	}, o;
+	try {
+		let { schema: t, warning: n } = Be(a$10);
+		a$10 = t, o = n && {
+			inputName: e.name || `unknown`,
+			paramType: e.paramType,
+			message: n.message,
+			code: n.code
+		};
+	} catch (t) {
+		a$10 = {
+			...a$10,
+			default: null
+		}, o = {
+			inputName: e.name || `unknown`,
+			paramType: e.paramType,
+			message: `Input "${e.name ?? `unknown`}" default could not be normalized and was dropped: ${t instanceof Error ? t.message : String(t)}`,
+			code: `MALFORMED_DEFAULT`
+		};
+	}
+	let s = Z.get(i), c = [], l = (t) => c.push({
+		inputName: e.name || `unknown`,
+		paramType: e.paramType,
+		message: t.message,
+		code: t.code
+	});
+	try {
+		if (!s) throw t.unknownParamType(i, e.name);
+		let r = s.parse(a$10, n, l), u = o ? [o, ...c] : c;
+		return {
+			input: r,
+			error: o,
+			...u.length > 0 && { errors: u }
+		};
+	} catch (l) {
+		if (l instanceof t) {
+			a().error(`Validation error for input ${e.name || `unknown`}:`, l.message);
+			let t = {
+				inputName: e.name || `unknown`,
+				paramType: e.paramType,
+				message: l.message,
+				code: l.code
+			};
+			return {
+				input: (s ?? Fe).fallback(a$10, n),
+				error: t,
+				errors: [
+					...o ? [o] : [],
+					...c,
+					t
+				]
+			};
+		}
+		throw new t(l instanceof Error ? l.message : String(l), `VALIDATION_ERROR`, {
+			context: {
+				paramName: e.name,
+				paramType: i
+			},
+			originalError: l instanceof Error ? l : Error(String(l))
+		});
+	}
+}
+function Ge(e) {
+	let t = [], n = [];
+	for (let r of e) {
+		let { input: e, errors: i } = We(r);
+		t.push(e), i && n.push(...i);
+	}
+	return {
+		inputs: t,
+		parseErrors: n
+	};
+}
+function Ke(e) {
+	let t = c(e, `stepSize`);
+	return {
+		id: c(e, `id`) ?? ``,
+		name: c(e, `name`) ?? ``,
+		nickname: c(e, `nickname`) ?? null,
+		description: c(e, `description`) ?? ``,
+		paramType: c(e, `paramType`) ?? ``,
+		treeAccess: c(e, `treeAccess`) ?? false,
+		minimum: c(e, `minimum`) ?? null,
+		maximum: c(e, `maximum`) ?? null,
+		atLeast: c(e, `atLeast`) ?? 1,
+		atMost: c(e, `atMost`) ?? 1,
+		stepSize: typeof t == `number` && Number.isFinite(t) ? t : void 0,
+		default: c(e, `default`),
+		values: c(e, `values`),
+		acceptedFormats: c(e, `acceptedFormats`),
+		groupName: c(e, `groupName`) ?? null
+	};
+}
+function qe(e) {
+	return {
+		name: c(e, `name`) ?? ``,
+		nickname: c(e, `nickname`) ?? null,
+		paramType: c(e, `paramType`) ?? ``,
+		id: c(e, `id`) ?? ``
+	};
+}
+async function Q(n, r) {
+	let i = x(n, []), a = {};
+	if (i.algo && (a.algo = i.algo), i.pointer && (a.pointer = i.pointer), !a.algo && !a.pointer) throw new t(`Definition must resolve to either a URL pointer or base64 algo`, e.INVALID_INPUT, { context: { definition: n } });
+	let o = await U$1(`io`, a, _(r));
+	if (!o || typeof o != `object`) throw new t(`Invalid IO response structure`, e.INVALID_INPUT, { context: {
+		response: o,
+		definition: n
+	} });
+	let s = Je(c(o, `warnings`)), c$1 = Je(c(o, `errors`)), l = c(o, `inputs`), u = c(o, `outputs`);
+	return {
+		inputs: Array.isArray(l) ? l.map(Ke) : [],
+		outputs: Array.isArray(u) ? u.map(qe) : [],
+		...s && { loadWarnings: s },
+		...c$1 && { loadErrors: c$1 }
+	};
+}
+function Je(e) {
+	if (!Array.isArray(e)) return;
+	let t = e.map(Ye).filter((e) => e !== void 0);
+	return t.length > 0 ? t : void 0;
+}
+function Ye(e) {
+	if (e == null) return;
+	let t;
+	if (typeof e == `string`) t = e;
+	else if (typeof e == `object`) {
+		let n = c(e, `message`);
+		if (typeof n == `string` && n.trim().length > 0) t = n;
+		else try {
+			t = JSON.stringify(e) ?? String(e);
+		} catch {
+			t = String(e);
+		}
+	} else t = String(e);
+	return t.trim().length > 0 ? t : void 0;
+}
+async function Xe(e, t) {
+	g(`fetchParsedDefinitionIO`, t.suppressBrowserWarning);
+	let { inputs: n, outputs: r, loadWarnings: i, loadErrors: a } = await Q(e, t), { inputs: o, parseErrors: s } = Ge(n);
+	return {
+		inputs: o,
+		outputs: r,
+		...s.length > 0 && { parseErrors: s },
+		...i && { loadWarnings: i },
+		...a && { loadErrors: a }
+	};
+}
+function Ze(e) {
+	return (Array.isArray(e) ? e : [e]).map((e) => ({
+		schemas: c(e, `schemas`),
+		error: c(e, `error`)
+	}));
+}
+var Qe = /* @__PURE__ */ new Set([
+	`options`,
+	`defaultOptions`,
+	`values`
+]);
+var $e = (e) => e >= `A` && e <= `Z`;
+function et(e) {
+	if (e.length === 0 || !$e(e[0])) return e;
+	let t = 0;
+	for (; t < e.length && $e(e[t]);) t++;
+	return t > 1 && t < e.length && t--, e.slice(0, t).toLowerCase() + e.slice(t);
+}
+function tt(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 = et(n);
+		t[e] = Qe.has(e) ? r : $(r);
+	}
+	return t;
+}
+var nt = class n {
+	innerTree;
+	paramName;
+	constructor(e) {
+		this.paramName = e, this.innerTree = {};
+	}
+	append(e, t) {
+		let r = n.formatPathString(e);
+		this.innerTree[r] || (this.innerTree[r] = []);
+		let i = t.map((e) => ({ data: n.serializeValue(e) }));
+		return this.innerTree[r].push(...i), this;
+	}
+	appendSingle(e, t) {
+		return this.append(e, [t]);
+	}
+	fromDataTreeDefault(e) {
+		this.innerTree = {};
+		for (let [t, r] of Object.entries(e)) {
+			if (!Array.isArray(r)) continue;
+			let e = n.parsePathString(t);
+			this.append(e, r);
+		}
+		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 r of t) e.push(n.deserializeValue(r.data));
+		return e;
+	}
+	getPaths() {
+		return Object.keys(this.innerTree);
+	}
+	getPath(e) {
+		let t = n.formatPathString(e), r = this.innerTree[t];
+		if (r) return r.map((e) => n.deserializeValue(e.data));
+	}
+	toComputeFormat() {
+		return {
+			ParamName: this.paramName,
+			InnerTree: this.innerTree
+		};
+	}
+	getInnerTree() {
+		return this.innerTree;
+	}
+	getParamName() {
+		return this.paramName;
+	}
+	static fromInputParams(e) {
+		return e.filter((e) => n.hasValidValue(e.default)).map((e) => {
+			let t = new n(e.nickname || `unnamed`), r = e.default;
+			if (e.treeAccess && U(r)) t.fromDataTreeDefault(r), n.isNumericInput(e) && t.applyNumericConstraints(e.minimum, e.maximum, e.nickname || `unnamed`);
+			else {
+				let i = Array.isArray(r) ? r : [r], a = n.processValues(i, e);
+				t.appendFlat(a);
+			}
+			return t.toComputeFormat();
+		});
+	}
+	static fromInputParam(e) {
+		if (n.hasValidValue(e.default)) return n.fromInputParams([e])[0];
+	}
+	static replaceTreeValue(e, t, r) {
+		let i = e.length > 0 && e[0] instanceof n, a = n.buildFromValue(t, r);
+		if (i) {
+			let n = e.slice(), r = n.findIndex((e) => e.getParamName() === t);
+			return r === -1 ? n.push(a) : n[r] = a, n;
+		}
+		let o = e.slice(), s = a.toComputeFormat(), c = o.findIndex((e) => e.ParamName === t);
+		return c === -1 ? o.push(s) : o[c] = s, o;
+	}
+	static buildFromValue(e, t) {
+		let r = new n(e);
+		return U(t) ? r.fromDataTreeDefault(t) : r.appendFlat(t), r;
+	}
+	static getTreeValue(e, t) {
+		let r = e.length > 0 && e[0] instanceof n ? n.readFromBuilders(e, t) : n.readFromDataTrees(e, t);
+		return r === null || r.length === 0 ? null : r.length === 1 ? r[0] : r;
+	}
+	static readFromBuilders(e, t) {
+		let n = e.find((e) => e.getParamName() === t);
+		return n ? n.flatten() : null;
+	}
+	static readFromDataTrees(e, t) {
+		let r = e.find((e) => e.ParamName === t);
+		if (!r?.InnerTree) return null;
+		let i = Object.keys(r.InnerTree)[0];
+		if (!i) return null;
+		let a = r.InnerTree[i];
+		return Array.isArray(a) ? a.map((e) => e?.data === void 0 ? null : n.deserializeValue(e.data)) : a?.data === void 0 ? a === void 0 ? null : [a] : [n.deserializeValue(a.data)];
+	}
+	static parsePathString(n) {
+		let r = n.match(H);
+		if (!r) throw new t(`Invalid Grasshopper tree path: "${n}". Expected "{}", "{0}", or "{0;1;2}" (negative indices allowed, no empty segments).`, e.INVALID_INPUT, { context: { pathStr: n } });
+		return r[1] ? r[1].split(`;`).map(Number) : [];
+	}
+	static formatPathString(e) {
+		return `{${e.join(`;`)}}`;
+	}
+	applyNumericConstraints(e, t, r) {
+		for (let i of Object.values(this.innerTree)) if (Array.isArray(i)) for (let a of i) {
+			let i = n.deserializeValue(a.data);
+			if (typeof i == `number`) {
+				let o = n.clampValue(i, e, t, r);
+				a.data = n.serializeValue(o);
+			}
+		}
+	}
+	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 == `boolean` || typeof e == `number` || 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 isNumericInput(e) {
+		return e.paramType === `Number` || e.paramType === `Integer`;
+	}
+	static processValues(e, t) {
+		return e.map((e) => n.isNumericInput(t) && typeof e == `number` ? n.clampValue(e, t.minimum, t.maximum, t.nickname || `unnamed`) : e).filter((e) => e != null);
+	}
+	static clampValue(e, t, n, i) {
+		let a$11 = e;
+		return t != null && a$11 < t && (a().warn(`${i}: ${e} below min ${t}, clamping`), a$11 = t), n != null && a$11 > n && (a().warn(`${i}: ${e} above max ${n}, clamping`), a$11 = n), a$11;
+	}
+};
+//#endregion
+//#region ../schemas/src/generated/schema.ts
+/** Current UISchema format version (from ui-schema.json's schemaVersion default). */
+var UI_SCHEMA_VERSION = "2.15.0";
+function isNumberWidget(item) {
+	return item.type === "input" && item.widgetType === "number";
+}
+function isTextWidget(item) {
+	return item.type === "input" && item.widgetType === "text";
+}
+function isDropdownWidget(item) {
+	return item.type === "input" && item.widgetType === "dropdown";
+}
+function isDynamicValueListWidget(item) {
+	return item.type === "input" && item.widgetType === "dynamicValueList";
+}
+function isCheckboxWidget(item) {
+	return item.type === "input" && item.widgetType === "checkbox";
+}
+function isFileWidget(item) {
+	return item.type === "input" && item.widgetType === "file";
+}
+function isColorWidget(item) {
+	return item.type === "input" && item.widgetType === "color";
+}
+
+export { Ee as E, G$1 as G, S, UI_SCHEMA_VERSION as U, W$1 as W, Ze as Z, t as a, Ue as b, isNumberWidget as c, isTextWidget as d, e, isDropdownWidget as f, isDynamicValueListWidget as g, h, isCheckboxWidget as i, isFileWidget as j, isColorWidget as k, se$1 as l, nt as n, pe as p, s, tt as t, v$1 as v };
+//# sourceMappingURL=schema.js-CCefMgzX.js.map