@selvajs/selva 4.20.0-beta.7 → 4.20.0-beta.9

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

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