@selvajs/selva 4.17.1 → 4.18.1

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

@@ -0,0 +1,2640 @@
+//#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` }, e);
+			return {
+				online: n.ok,
+				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.14.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, se$1 as c, isNumberWidget as d, e, isCheckboxWidget as f, isTextWidget as g, h, isDynamicValueListWidget as i, isDropdownWidget as j, isFileWidget as k, isColorWidget as l, nt as n, pe as p, s, tt as t, v$1 as v };
+//# sourceMappingURL=schema.js-YChb_4u9.js.map