@selvajs/selva 4.8.0-beta.4 → 4.8.0-beta.7

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

@@ -0,0 +1,1768 @@
+import { b as b$1, f, u, y, a as be$1, O as Oe$1, E as E$1, w as we$1, c as Ee$1, p as pe$1, d as ue$1, D as De$1, L as Le$1, N, h as he$1 } from './chunk-AYH5O3VG.js-YiX3ZqeT.js';
+
+//#region ../compute/dist/grasshopper.js
+var b = class b {
+	constructor(e, r) {
+		b$1(this, "serverUrl");
+		b$1(this, "apiKey");
+		b$1(this, "disposed", false);
+		b$1(this, "activeMonitors", /* @__PURE__ */ new Set());
+		b$1(this, "activeTimeouts", /* @__PURE__ */ new Set());
+		this.serverUrl = be$1(e), this.apiKey = r;
+	}
+	buildHeaders() {
+		let e = { "Content-Type": "application/json" };
+		return this.apiKey && (e.RhinoComputeKey = this.apiKey), e;
+	}
+	fetchWithTimeout(e, r = {}, n = b.DEFAULT_TIMEOUT_MS) {
+		let s = new Headers(this.buildHeaders());
+		r.headers && new Headers(r.headers).forEach((a, u) => {
+			s.set(u, a);
+		});
+		let o = {};
+		s.forEach((a, u) => {
+			o[u] = a;
+		});
+		let i = {
+			...r,
+			headers: o
+		};
+		return n > 0 && !i.signal && (i.signal = AbortSignal.timeout(n)), fetch(e, i);
+	}
+	async isServerOnline(e = 5e3) {
+		this.ensureNotDisposed();
+		let r = `${this.serverUrl}/`;
+		try {
+			return (await this.fetchWithTimeout(r, { method: "GET" }, e)).ok;
+		} catch (n) {
+			return y().debug("[ComputeServerStats] Fetch error:", n), false;
+		}
+	}
+	async getActiveChildren(e = {}) {
+		this.ensureNotDisposed();
+		let { initialize: r = true } = e, n = r ? `${this.serverUrl}/activechildren` : `${this.serverUrl}/activechildren?initialize=false`, s = r ? b.LIFECYCLE_TIMEOUT_MS : b.DEFAULT_TIMEOUT_MS;
+		try {
+			let o = await this.fetchWithTimeout(n, {}, s);
+			if (!o.ok) return y().warn("[ComputeServerStats] Failed to fetch active children:", o.status), null;
+			let i = (await o.text()).trim();
+			return /^\d+$/.test(i) ? parseInt(i, 10) : (y().warn("[ComputeServerStats] Invalid active children response:", i), null);
+		} catch (o) {
+			return y().warn("[ComputeServerStats] Error fetching active children:", o), null;
+		}
+	}
+	async getVersion() {
+		this.ensureNotDisposed();
+		try {
+			let e = await this.fetchWithTimeout(`${this.serverUrl}/version`);
+			if (!e.ok) return y().warn("[ComputeServerStats] Failed to fetch version:", e.status), null;
+			let r = await e.text();
+			try {
+				let n = JSON.parse(r);
+				return {
+					rhino: n.rhino ?? "",
+					compute: n.compute ?? "",
+					git_sha: n.git_sha ?? null
+				};
+			} catch {
+				return {
+					rhino: r,
+					compute: "",
+					git_sha: null
+				};
+			}
+		} catch (e) {
+			return y().warn("[ComputeServerStats] Error fetching version:", e), null;
+		}
+	}
+	async getInstalledPlugins(e = "gh") {
+		this.ensureNotDisposed();
+		try {
+			let r = await this.fetchWithTimeout(`${this.serverUrl}/plugins/${e}/installed`);
+			if (!r.ok) return y().warn(`[ComputeServerStats] Failed to fetch ${e} plugins:`, r.status), null;
+			let n = await r.text();
+			try {
+				let s = JSON.parse(n);
+				return s && typeof s == "object" ? s : null;
+			} catch {
+				return null;
+			}
+		} catch (r) {
+			return y().warn(`[ComputeServerStats] Error fetching ${e} plugins:`, r), null;
+		}
+	}
+	async getServerStats() {
+		if (this.ensureNotDisposed(), !await this.isServerOnline()) return { isOnline: false };
+		let [r, n] = await Promise.all([this.getVersion(), this.getActiveChildren({ initialize: false })]);
+		return {
+			isOnline: true,
+			...r && { version: r },
+			...n !== null && { activeChildren: n }
+		};
+	}
+	async purgeCache() {
+		this.ensureNotDisposed();
+		try {
+			let e = await this.fetchWithTimeout(`${this.serverUrl}/cache/purge`, { method: "POST" });
+			if (!e.ok) return y().warn("[ComputeServerStats] Failed to purge cache:", e.status), null;
+			let r = await e.text();
+			try {
+				let n = JSON.parse(r);
+				return typeof n.purged == "number" ? n.purged : null;
+			} catch {
+				return null;
+			}
+		} catch (e) {
+			return y().warn("[ComputeServerStats] Error purging cache:", e), null;
+		}
+	}
+	async purgeAllChildren() {
+		this.ensureNotDisposed();
+		let e = await this.getActiveChildren({ initialize: false });
+		if (e === null) return y().warn("[ComputeServerStats] purgeAllChildren: could not read child count"), null;
+		if (e === 0) return {
+			totalPurged: 0,
+			calls: 0,
+			children: 0,
+			confident: true
+		};
+		let r = e * 2, n = 0;
+		for (let s = 0; s < r; s++) {
+			let o = await this.purgeCache();
+			o !== null && (n += o);
+		}
+		return {
+			totalPurged: n,
+			calls: r,
+			children: e,
+			confident: e === 1
+		};
+	}
+	async getServerTime() {
+		this.ensureNotDisposed();
+		try {
+			let e = await this.fetchWithTimeout(`${this.serverUrl}/servertime`);
+			if (!e.ok) return y().warn("[ComputeServerStats] Failed to fetch server time:", e.status), null;
+			let r = (await e.text()).trim().replace(/^"|"$/g, ""), n = new Date(r);
+			return isNaN(n.getTime()) ? null : n;
+		} catch (e) {
+			return y().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 y().warn("[ComputeServerStats] Failed to fetch idle span:", e.status), null;
+			let r = parseFloat((await e.text()).trim());
+			return isNaN(r) ? null : r;
+		} catch (e) {
+			return y().warn("[ComputeServerStats] Error fetching idle span:", e), null;
+		}
+	}
+	async launchChildren() {
+		return this.postJson("/launch-children");
+	}
+	async launchChild(e) {
+		let r = e === void 0 ? "/launch-child" : `/launch-child?port=${e}`;
+		return this.postJson(r);
+	}
+	async shutdownChildren(e) {
+		let r = e === void 0 ? "/shutdown-children" : `/shutdown-children?port=${e}`;
+		return this.postJson(r);
+	}
+	async recycleChildren(e) {
+		let r = e === void 0 ? "/recycle-children" : `/recycle-children?port=${e}`;
+		return this.postJson(r);
+	}
+	async postJson(e) {
+		this.ensureNotDisposed();
+		try {
+			let r = await this.fetchWithTimeout(`${this.serverUrl}${e}`, { method: "POST" }, b.LIFECYCLE_TIMEOUT_MS);
+			if (!r.ok) return y().warn(`[ComputeServerStats] POST ${e} failed:`, r.status), null;
+			let n = await r.text();
+			try {
+				return JSON.parse(n);
+			} catch {
+				return null;
+			}
+		} catch (r) {
+			return y().warn(`[ComputeServerStats] Error on POST ${e}:`, r), null;
+		}
+	}
+	monitor(e, r = 5e3) {
+		if (this.ensureNotDisposed(), !Number.isFinite(r) || r < b.MIN_MONITOR_INTERVAL_MS) throw new RangeError(`monitor() intervalMs must be a finite number >= ${b.MIN_MONITOR_INTERVAL_MS}ms, got ${r}. Sub-${b.MIN_MONITOR_INTERVAL_MS}ms polling would hot-loop the server.`);
+		let n = true, s = null;
+		y().info(`\u{1F504} Starting server stats monitoring every ${r}ms`);
+		let o = async () => {
+			if (s !== null && (this.activeTimeouts.delete(s), s = null), !(!n || this.disposed)) {
+				try {
+					let a = await this.getServerStats();
+					if (!n || this.disposed) return;
+					try {
+						e(a);
+					} catch (u) {
+						y().error("[ComputeServerStats] Monitor callback threw:", u);
+					}
+				} catch (a) {
+					!n || this.disposed ? y().debug("[ComputeServerStats] Monitor poll cancelled during shutdown:", a) : y().error("[ComputeServerStats] Failed to fetch stats during monitor:", a);
+				}
+				n && !this.disposed && (s = setTimeout(() => {
+					o();
+				}, r), this.activeTimeouts.add(s));
+			}
+		}, i = () => {
+			n = false, s !== null && (clearTimeout(s), this.activeTimeouts.delete(s), s = null), this.activeMonitors.delete(i);
+		};
+		return this.activeMonitors.add(i), o(), i;
+	}
+	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 f("ComputeServerStats has been disposed and cannot be used", u.INVALID_STATE, { context: { disposed: this.disposed } });
+	}
+};
+b$1(b, "DEFAULT_TIMEOUT_MS", 5e3), b$1(b, "LIFECYCLE_TIMEOUT_MS", 6e4), b$1(b, "MIN_MONITOR_INTERVAL_MS", 100);
+var I = b;
+var ue = /* @__PURE__ */ new Set();
+function $e() {
+	if (typeof window > "u" || globalThis.process?.versions?.node != null) return false;
+	let e = globalThis.navigator, r = typeof e?.userAgent == "string" ? e.userAgent : "";
+	return !/jsdom/i.test(r);
+}
+function D(t, e) {
+	e || $e() && !ue.has(t) && (ue.add(t), y().warn(`Warning: ${t} is running on the client side. For better performance and security, consider running this on the server side.`));
+}
+var _e = "Unable to load grasshopper definition";
+var je = { definition_not_cached: u.DEFINITION_NOT_CACHED };
+function B(t) {
+	return {
+		...t,
+		serverErrorCodes: {
+			...je,
+			...t.serverErrorCodes
+		}
+	};
+}
+function Be(t) {
+	return t instanceof f ? t.code === u.DEFINITION_NOT_CACHED || t.message.includes(_e) : false;
+}
+function Ue(t, e) {
+	if (!e) return;
+	let r = E$1(t, "values");
+	if (!Array.isArray(r) || r.length === 0) return;
+	let n = [];
+	for (let o of r) {
+		let i = E$1(o, "innerTree");
+		(!i || Object.keys(i).length === 0) && n.push(E$1(o, "paramName") ?? "<unnamed>");
+	}
+	if (n.length === 0) return;
+	let s = n.length === r.length ? "all" : `${n.length}/${r.length}`;
+	y().warn(`Solve returned empty output(s) (${s}): ${n.join(", ")}. These parameters produced no data \u2014 check the definition's inputs and the branch feeding each.`);
+}
+async function k(t, e, r) {
+	D("solveGrasshopperDefinition", r.suppressBrowserWarning);
+	let { response: s } = await M(E(await U(e), t), r);
+	return s;
+}
+async function le(t, e, r) {
+	D("solveGrasshopperDefinitionWithCacheKey", r.suppressBrowserWarning);
+	return M(E(await U(e), t), r);
+}
+async function pe(t, e, r, n) {
+	D("solveByCacheKey", n.suppressBrowserWarning);
+	let s = {
+		algo: null,
+		pointer: e,
+		values: t
+	};
+	try {
+		return {
+			...await M(s, n),
+			missed: !1
+		};
+	} catch (o) {
+		if (!Be(o)) throw o;
+		return {
+			...await M(E(await U(r), t), n),
+			missed: true
+		};
+	}
+}
+async function U(t) {
+	if (!we$1(t)) return t;
+	try {
+		return await t.load();
+	} catch (e) {
+		throw new f(`Failed to load definition bytes for ref '${t.key}'`, u.INVALID_INPUT, {
+			context: { definitionKey: t.key },
+			originalError: e instanceof Error ? e : new Error(String(e))
+		});
+	}
+}
+async function M(t, e) {
+	ze(t, e);
+	let r = await Ee$1("grasshopper", t, B(e)), { pointer: n, algo: s, ...o } = r, i = o, a = pe$1(r);
+	if (a !== void 0) {
+		let u = typeof s == "string" ? s.length : 0;
+		N(i, Math.max(0, a - u));
+	}
+	return Ue(i, e.debug), {
+		response: i,
+		cacheKey: typeof n == "string" ? n : null
+	};
+}
+function E(t, e) {
+	let r = {
+		algo: null,
+		pointer: null,
+		values: e
+	};
+	return t instanceof Uint8Array ? r.algo = ue$1(t) : /^https?:\/\//i.test(t) ? r.pointer = t : r.algo = De$1(t) ?? Le$1(t), r;
+}
+function ze(t, e) {
+	e.cachesolve != null && (t.cachesolve = e.cachesolve), e.cacheerroredsolves != null && (t.cacheerroredsolves = e.cacheerroredsolves), e.modelunits != null && (t.modelunits = e.modelunits), e.angletolerance != null && (t.angletolerance = e.angletolerance), e.absolutetolerance != null && (t.absolutetolerance = e.absolutetolerance), e.dataversion != null && (t.dataversion = e.dataversion);
+}
+function ce(t) {
+	let e = /* @__PURE__ */ new WeakSet(), r = (n) => {
+		if (n === void 0) return "undefined";
+		if (n === null) return "null";
+		if (typeof n == "number") return Number.isFinite(n) ? String(n) : "null";
+		if (typeof n == "string" || typeof n == "boolean") return JSON.stringify(n);
+		if (typeof n == "bigint") return `${n}n`;
+		if (n instanceof Uint8Array) return `{"__u8":${n.length},"hash":"${me(n)}"}`;
+		if (Array.isArray(n)) {
+			if (e.has(n)) return "\"[Circular]\"";
+			e.add(n);
+			let s = [];
+			for (let o = 0; o < n.length; o++) s.push(r(n[o]));
+			return e.delete(n), `[${s.join(",")}]`;
+		}
+		if (typeof n == "object") {
+			if (e.has(n)) return "\"[Circular]\"";
+			e.add(n);
+			let s;
+			return typeof n.toJSON == "function" ? s = r(n.toJSON()) : n instanceof Map ? s = `{"__map":[${[...n.entries()].map(([i, a]) => `[${r(i)},${r(a)}]`).sort().join(",")}]}` : n instanceof Set ? s = `{"__set":[${[...n.values()].map(r).sort().join(",")}]}` : s = `{${Object.keys(n).sort().map((a) => `${JSON.stringify(a)}:${r(n[a])}`).join(",")}}`, e.delete(n), s;
+		}
+		return "null";
+	};
+	return r(t);
+}
+function fe(t, e) {
+	let r = 2166136261;
+	for (let n = 0; n < t; n++) r ^= e(n), r = r + ((r << 1) + (r << 4) + (r << 7) + (r << 8) + (r << 24)) >>> 0;
+	return r.toString(16).padStart(8, "0");
+}
+function de(t) {
+	return fe(t.length, (e) => t.charCodeAt(e));
+}
+function me(t) {
+	return fe(t.length, (e) => t[e]);
+}
+function z(t, e) {
+	let r = ce(e);
+	return `${t}|t:${r.length}:${de(r)}`;
+}
+function F(t) {
+	return we$1(t) ? `r:${t.key}` : typeof t == "string" ? `s:${t.length}:${de(t)}` : `u8:${t.length}:${me(t)}`;
+}
+var Ke = 100;
+function He(t) {
+	return typeof t != "string" ? true : !/^https?:\/\//i.test(t);
+}
+function Qe(t) {
+	try {
+		return JSON.stringify(t)?.length ?? 0;
+	} catch {
+		return 0;
+	}
+}
+var A = class {
+	constructor(e, r, n = {}, s) {
+		b$1(this, "executor");
+		b$1(this, "baseConfig");
+		b$1(this, "mode");
+		b$1(this, "maxConcurrent");
+		b$1(this, "maxQueueDepth");
+		b$1(this, "queueWaitMs");
+		b$1(this, "timeoutMs");
+		b$1(this, "retry");
+		b$1(this, "cacheEnabled");
+		b$1(this, "cacheMaxBytes");
+		b$1(this, "cacheTtl");
+		b$1(this, "cacheErroredSolves");
+		b$1(this, "cache", /* @__PURE__ */ new Map());
+		b$1(this, "cacheBytes", 0);
+		b$1(this, "cacheHits", 0);
+		b$1(this, "cacheMisses", 0);
+		b$1(this, "cacheEvictions", 0);
+		b$1(this, "cacheKeyExecutor");
+		b$1(this, "reuseServerDefinitionCache");
+		b$1(this, "serverCacheKeys", /* @__PURE__ */ new Map());
+		b$1(this, "onStart");
+		b$1(this, "onSettle");
+		b$1(this, "onSuperseded");
+		b$1(this, "subscribers", /* @__PURE__ */ new Set());
+		b$1(this, "inFlight", /* @__PURE__ */ new Set());
+		b$1(this, "pendingForLatestWins", null);
+		b$1(this, "fifoQueue", []);
+		b$1(this, "_lastResult", null);
+		b$1(this, "_lastError", null);
+		b$1(this, "_lastDurationMs", null);
+		b$1(this, "solveSeq", 0);
+		b$1(this, "lastStateSeq", 0);
+		b$1(this, "disposed", false);
+		this.executor = e, this.cacheKeyExecutor = s, this.baseConfig = r, 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 o = n.cache, i = typeof o == "object" ? o : null;
+		this.cacheMaxBytes = Math.max(0, i?.maxBytes ?? 0), this.cacheEnabled = this.cacheMaxBytes > 0, this.cacheTtl = i?.ttlMs ?? 0, this.cacheErroredSolves = i?.cacheErroredSolves ?? true, this.reuseServerDefinitionCache = !!s && (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 ? 1 : 0);
+	}
+	get lastResult() {
+		return this._lastResult;
+	}
+	get lastError() {
+		return this._lastError;
+	}
+	get lastDurationMs() {
+		return this._lastDurationMs;
+	}
+	setMaxConcurrent(e) {
+		let r = Math.max(1, Math.floor(e));
+		if (r === this.maxConcurrent) return;
+		let n = r > this.maxConcurrent;
+		this.maxConcurrent = r, 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 (r) {
+			y().error("[SolveScheduler] subscriber threw:", r);
+		}
+	}
+	solve(e, r, n) {
+		if (this.disposed) return Promise.reject(new f("SolveScheduler has been disposed and cannot be used", u.INVALID_STATE));
+		let s = F(e), o = z(s, r), i = ++this.solveSeq, a = {
+			key: o,
+			enqueuedAt: Date.now(),
+			startedAt: null
+		};
+		if (n?.signal?.aborted) return Promise.reject(this.makeAbortError(a));
+		if (this.cacheEnabled) {
+			let u = this.readCache(o);
+			if (u) {
+				this.mode === "latest-wins" && this.supersedeCurrent();
+				let m = {
+					status: "success",
+					response: u,
+					durationMs: 0,
+					fromCache: true
+				};
+				return this.writeLastState(i, {
+					result: u,
+					durationMs: 0
+				}), this.runHook(this.onStart, a), this.runHook(this.onSettle, a, m), this.notify(), Promise.resolve(u);
+			}
+		}
+		return new Promise((u, m) => {
+			let f = {
+				definition: e,
+				dataTree: r,
+				definitionHash: s,
+				ctx: a,
+				seq: i,
+				resolve: u,
+				reject: m,
+				externalSignal: n?.signal
+			};
+			f.externalSignal && (f.queuedAbortHandler = () => this.abortQueuedItem(f), f.externalSignal.addEventListener("abort", f.queuedAbortHandler, { once: true })), this.enqueue(f);
+		});
+	}
+	writeLastState(e, r) {
+		return e < this.lastStateSeq ? false : (this.lastStateSeq = e, "result" in r ? (this._lastResult = r.result, this._lastError = null) : this._lastError = r.error, this._lastDurationMs = r.durationMs, true);
+	}
+	supersedeCurrent() {
+		this.pendingForLatestWins && (this.supersede(this.pendingForLatestWins), this.pendingForLatestWins = null);
+		for (let e of this.inFlight) this.supersede(e), e.controller.abort();
+	}
+	abortQueuedItem(e) {
+		this.pendingForLatestWins === e && (this.pendingForLatestWins = null);
+		let r = this.fifoQueue.indexOf(e);
+		r >= 0 && this.fifoQueue.splice(r, 1), this.rejectAsAborted(e), this.notify();
+	}
+	shedAsQueueFull(e) {
+		let r = new f("Solve queue is full; request rejected (backpressure)", u.QUEUE_FULL, {
+			statusCode: 503,
+			context: {
+				key: e.ctx.key,
+				queueDepth: this.fifoQueue.length,
+				maxQueueDepth: this.maxQueueDepth
+			}
+		});
+		this.settleError(e, r) && this.runHook(this.onSettle, e.ctx, {
+			status: "error",
+			error: r,
+			durationMs: 0
+		}), this.notify();
+	}
+	armQueueWaitTimer(e) {
+		if (this.queueWaitMs === void 0) return;
+		let r = this.queueWaitMs;
+		e.queueWaitTimer = setTimeout(() => {
+			if (e.settled) return;
+			let n = this.fifoQueue.indexOf(e);
+			n >= 0 && this.fifoQueue.splice(n, 1);
+			let s = new f(`Solve waited longer than ${r}ms in queue; rejected (backpressure)`, u.QUEUE_TIMEOUT, {
+				statusCode: 503,
+				context: {
+					key: e.ctx.key,
+					waitedMs: Date.now() - e.ctx.enqueuedAt,
+					queueWaitMs: r
+				}
+			});
+			this.settleError(e, s) && this.runHook(this.onSettle, e.ctx, {
+				status: "error",
+				error: s,
+				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 r = new AbortController(), n = e;
+		n.controller = r, this.inFlight.add(n), e.ctx.startedAt = Date.now(), this.clearQueueWaitTimer(e), this.removeQueuedAbortHandler(e);
+		let s = () => r.abort();
+		e.externalSignal?.addEventListener("abort", s, { once: true }), this.runHook(this.onStart, e.ctx), this.notify();
+		let o = performance.now();
+		try {
+			let i = {
+				...this.baseConfig,
+				signal: r.signal,
+				...this.timeoutMs !== void 0 && { timeoutMs: this.timeoutMs },
+				...this.retry !== void 0 && { retry: this.retry }
+			}, { response: a, definitionReuploaded: u } = await this.runExecutor(e.definition, e.dataTree, e.definitionHash, i), m = performance.now() - o;
+			if (this.cacheEnabled && this.writeCache(e.ctx.key, a), !this.settleSuccess(e, a)) return;
+			this.writeLastState(e.seq, {
+				result: a,
+				durationMs: m
+			}), this.runHook(this.onSettle, e.ctx, {
+				status: "success",
+				response: a,
+				durationMs: m,
+				fromCache: !1,
+				definitionReuploaded: u
+			});
+		} catch (i) {
+			let a = performance.now() - o, u = this.normalizeExecutionError(i, n);
+			this.writeLastState(e.seq, {
+				error: u,
+				durationMs: a
+			}), this.settleError(e, u) && this.runHook(this.onSettle, e.ctx, {
+				status: "error",
+				error: u,
+				durationMs: a
+			});
+		} finally {
+			e.externalSignal?.removeEventListener("abort", s), this.inFlight.delete(n), this.drainNext(), this.notify();
+		}
+	}
+	async runExecutor(e, r, n, s) {
+		if (!this.cacheKeyExecutor || !this.reuseServerDefinitionCache || !He(e)) return { response: await this.executor(e, r, s) };
+		let o = n, i = this.serverCacheKeys.get(o) ?? null, a = await this.cacheKeyExecutor(e, r, i, s);
+		if (a.cacheKey) for (this.serverCacheKeys.delete(o), this.serverCacheKeys.set(o, a.cacheKey); this.serverCacheKeys.size > Ke;) {
+			let u = this.serverCacheKeys.keys().next().value;
+			if (u === void 0) break;
+			this.serverCacheKeys.delete(u);
+		}
+		else this.serverCacheKeys.delete(o);
+		return {
+			response: a.response,
+			definitionReuploaded: a.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) {
+		let r = new f("Superseded by newer solve", u.SUPERSEDED, { context: {
+			key: e.ctx.key,
+			enqueuedAt: e.ctx.enqueuedAt
+		} });
+		this.settleError(e, r) && this.runHook(this.onSuperseded, e.ctx);
+	}
+	makeAbortError(e) {
+		return new f("Request aborted by caller", u.ABORTED, { context: {
+			key: e.key,
+			enqueuedAt: e.enqueuedAt
+		} });
+	}
+	settleError(e, r) {
+		return e.settled ? false : (e.settled = { error: r }, this.clearQueueWaitTimer(e), this.removeQueuedAbortHandler(e), e.reject(r), true);
+	}
+	settleSuccess(e, r) {
+		return e.settled ? false : (e.settled = { ok: true }, this.clearQueueWaitTimer(e), this.removeQueuedAbortHandler(e), e.resolve(r), 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(e, r) {
+		return r.settled && "error" in r.settled ? r.settled.error : e instanceof f ? e : this.isAbortLikeError(e) ? this.makeAbortError(r.ctx) : new f(e instanceof Error ? e.message : String(e), u.UNKNOWN_ERROR, { originalError: e instanceof Error ? e : new Error(String(e)) });
+	}
+	cancelAll() {
+		for (this.pendingForLatestWins && (this.rejectAsAborted(this.pendingForLatestWins), this.pendingForLatestWins = null); this.fifoQueue.length > 0;) {
+			let e = this.fifoQueue.shift();
+			this.rejectAsAborted(e);
+		}
+		for (let e of this.inFlight) {
+			let r = this.makeAbortError(e.ctx);
+			this.settleError(e, r) && this.runHook(this.onSettle, e.ctx, {
+				status: "error",
+				error: r,
+				durationMs: e.ctx.startedAt ? Date.now() - e.ctx.startedAt : 0
+			}), e.controller.abort();
+		}
+		this.notify();
+	}
+	rejectAsAborted(e) {
+		let r = this.makeAbortError(e.ctx);
+		this.settleError(e, r) && this.runHook(this.onSettle, e.ctx, {
+			status: "error",
+			error: r,
+			durationMs: 0
+		});
+	}
+	readCache(e) {
+		if (!this.cacheEnabled) return null;
+		let r = this.cache.get(e);
+		return r ? this.cacheTtl > 0 && Date.now() - r.insertedAt > this.cacheTtl ? (this.dropCacheEntry(e), this.cacheMisses += 1, null) : (this.cache.delete(e), this.cache.set(e, r), this.cacheHits += 1, r.response) : (this.cacheMisses += 1, null);
+	}
+	writeCache(e, r) {
+		if (!this.cacheEnabled || !this.cacheErroredSolves && r.errors && r.errors.length > 0) return;
+		let n = pe$1(r) ?? Qe(r);
+		if (!(n > this.cacheMaxBytes)) for (this.dropCacheEntry(e), this.cache.set(e, {
+			response: r,
+			insertedAt: Date.now(),
+			sizeBytes: n
+		}), this.cacheBytes += n; this.cacheBytes > this.cacheMaxBytes && this.cache.size > 0;) {
+			let s = this.cache.keys().next().value;
+			if (s === void 0) break;
+			this.dropCacheEntry(s), this.cacheEvictions += 1;
+		}
+	}
+	dropCacheEntry(e) {
+		let r = this.cache.get(e);
+		r && (this.cache.delete(e), this.cacheBytes -= r.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, ...r) {
+		if (e) try {
+			e(...r);
+		} catch (n) {
+			y().error("[SolveScheduler] hook threw:", n);
+		}
+	}
+};
+function he(t) {
+	return we$1(t) ? `ref:${t.key}` : typeof t == "string" && t.length < 200 ? t : "...content...";
+}
+function ye(t) {
+	return Array.isArray(t) ? t.map((e) => {
+		let r = 0, n = 0, s = E$1(e, "innerTree");
+		if (s && typeof s == "object") {
+			for (let o of Object.values(s)) if (Array.isArray(o)) {
+				r += o.length;
+				for (let i of o) {
+					let a = i?.data;
+					typeof a == "string" && (n += a.length);
+				}
+			}
+		}
+		return {
+			param: E$1(e, "paramName") ?? "<unnamed>",
+			items: r,
+			bytes: n
+		};
+	}) : [];
+}
+var L = class t {
+	constructor(e) {
+		b$1(this, "config");
+		b$1(this, "serverStats");
+		b$1(this, "disposed", false);
+		this.config = this.normalizeComputeConfig(e), this.serverStats = new I(this.config.serverUrl, this.config.apiKey);
+	}
+	static async create(e) {
+		let r = new t(e), n = Math.max(1, (e.retry?.attempts ?? 2) + 1), s = e.retry?.baseDelayMs ?? 250, o = e.retry?.maxDelayMs ?? 1e3;
+		for (let i = 0; i < n; i++) {
+			if (await r.serverStats.isServerOnline()) return r;
+			if (i < n - 1) {
+				let a = Math.min(s * 2 ** i, o);
+				await new Promise((u) => setTimeout(u, a));
+			}
+		}
+		throw await r.dispose(), new f("Rhino Compute server is not online", u.NETWORK_ERROR, { context: {
+			serverUrl: r.config.serverUrl,
+			attempts: n
+		} });
+	}
+	getConfig() {
+		return this.ensureNotDisposed(), { ...this.config };
+	}
+	async getIO(e) {
+		return this.ensureNotDisposed(), q(e, this.config);
+	}
+	async getRawIO(e) {
+		return this.ensureNotDisposed(), V(e, this.config);
+	}
+	async solve(e, r, n) {
+		this.ensureNotDisposed();
+		try {
+			if (typeof e == "string" && !e?.trim()) throw new f("Definition URL/content is required", u.INVALID_INPUT, { context: { receivedUrl: e } });
+			if (e instanceof Uint8Array && e.length === 0) throw new f("Definition content is empty", u.INVALID_INPUT);
+			if (we$1(e) && !e.key.trim()) throw new f("DefinitionRef key is empty", u.INVALID_INPUT);
+			let o = await k(r, e, {
+				...this.config,
+				...n?.signal !== void 0 && { signal: n.signal },
+				...n?.timeoutMs !== void 0 && { timeoutMs: n.timeoutMs },
+				...n?.retry !== void 0 && { retry: n.retry }
+			});
+			if (o?.errors && o.errors.length > 0) throw new f(o.errors.join("; ") || "Computation failed", u.COMPUTATION_ERROR, { context: {
+				definition: he(e),
+				inputSummary: ye(r),
+				errors: o.errors,
+				warnings: o.warnings,
+				values: o.values
+			} });
+			return o;
+		} catch (s) {
+			throw this.config.debug && y().error("Compute failed:", s), s instanceof f ? s : new f(s instanceof Error ? s.message : String(s), u.COMPUTATION_ERROR, {
+				context: {
+					definition: he(e),
+					inputSummary: ye(r)
+				},
+				originalError: s instanceof Error ? s : new Error(String(s))
+			});
+		}
+	}
+	createScheduler(e) {
+		this.ensureNotDisposed();
+		let r = (s, o, i) => k(o, s, i), n = (s, o, i, a) => i === null ? le(o, s, a).then((u) => ({
+			...u,
+			missed: false
+		})) : pe(o, i, s, a);
+		return new A(r, this.config, e, n);
+	}
+	async dispose() {
+		this.disposed || (this.disposed = true, await this.serverStats.dispose());
+	}
+	ensureNotDisposed() {
+		if (this.disposed) throw new f("GrasshopperClient has been disposed and cannot be used", u.INVALID_STATE);
+	}
+	normalizeComputeConfig(e) {
+		return {
+			...e,
+			serverUrl: be$1(e.serverUrl),
+			apiKey: e.apiKey,
+			authToken: e.authToken,
+			debug: e.debug ?? false,
+			suppressBrowserWarning: e.suppressBrowserWarning
+		};
+	}
+};
+var G = /* @__PURE__ */ new Map();
+function be(t, e) {
+	G.set(t, e);
+}
+be("Rhino.Geometry.Point3d", (t, e) => {
+	let r = e;
+	return !r || typeof r.X != "number" ? null : new t.Point([
+		r.X,
+		r.Y,
+		r.Z
+	]);
+});
+be("Rhino.Geometry.Line", (t, e) => {
+	let r = e;
+	return !r || !r.From || !r.To ? null : new t.Line([
+		r.From.X,
+		r.From.Y,
+		r.From.Z
+	], [
+		r.To.X,
+		r.To.Y,
+		r.To.Z
+	]);
+});
+function Je(t) {
+	if (G.has(t)) return G.get(t);
+	for (let [e, r] of G) if (t.startsWith(e)) return r;
+}
+function Ye(t) {
+	return !!(t && typeof t == "object" && typeof t.data == "string");
+}
+function ge(t, e) {
+	return {
+		__decodeError: true,
+		type: t,
+		raw: e
+	};
+}
+function Te(t, e, r) {
+	let n = Je(e), s = false;
+	if (n) try {
+		let o = n(r, t);
+		if (o != null) return o;
+	} catch (o) {
+		y().warn(`Failed to decode Rhino type ${e}:`, o), s = true;
+	}
+	try {
+		if (Ye(t)) return r.CommonObject.decode(t);
+	} catch (o) {
+		return y().warn(`Failed to decode ${e} with CommonObject:`, o), ge(e, t);
+	}
+	return s ? ge(e, t) : t;
+}
+function Se(t) {
+	let e = /* @__PURE__ */ new WeakSet(), r = (n) => {
+		if (!n || typeof n != "object" || e.has(n)) return;
+		e.add(n);
+		let s = n.delete;
+		if (typeof s == "function") {
+			let i = n.isDeleted;
+			(typeof i != "function" || !i.call(n)) && s.call(n);
+			return;
+		}
+		if (Array.isArray(n)) {
+			for (let i of n) r(i);
+			return;
+		}
+		let o = Object.getPrototypeOf(n);
+		if (o === Object.prototype || o === null) for (let i of Object.values(n)) r(i);
+	};
+	r(t);
+}
+var x = {
+	STRING: "System.String",
+	INT: "System.Int32",
+	DOUBLE: "System.Double",
+	BOOL: "System.Boolean"
+};
+var Xe = "Rhino.Geometry.";
+var Ze = ["WebDisplay"];
+var et = "FileData";
+function Ce(t) {
+	return Ze.some((e) => t.includes(e));
+}
+function tt(t) {
+	if (typeof t != "string") return t;
+	let e = t.trim();
+	if (!(e.startsWith("{") || e.startsWith("[") || e.startsWith("\""))) return t;
+	try {
+		let n = JSON.parse(e);
+		if (typeof n == "string") try {
+			return JSON.parse(n);
+		} catch {
+			return n;
+		}
+		return n;
+	} catch {
+		return t;
+	}
+}
+function rt(t, e, r) {
+	switch (e) {
+		case x.STRING: return typeof t != "string" ? t : t.replace(/^"(.*)"$/, "$1");
+		case x.INT: return Number.parseInt(t, 10);
+		case x.DOUBLE: return Number.parseFloat(t);
+		case x.BOOL: return String(t).toLowerCase() === "true";
+		default: return r && e.startsWith(Xe) ? Te(t, e, r) : t;
+	}
+}
+var K = /* @__PURE__ */ new WeakMap();
+function ve(t) {
+	if (K.has(t)) return K.get(t);
+	let e = tt(t.data);
+	return K.set(t, e), e;
+}
+function Ie(t, e, r, n) {
+	if (typeof t.data != "string") return t.data;
+	return rt(r ? ve(t) : t.data, e, n);
+}
+function nt(t) {
+	if (!t || typeof t != "object") return false;
+	let e = t;
+	return typeof e.fileName == "string" && typeof e.fileType == "string" && "data" in e && typeof e.isBase64Encoded == "boolean" && typeof e.subFolder == "string";
+}
+function H(t) {
+	let e = E$1(t, "values");
+	return Array.isArray(e) ? e : [];
+}
+function Q(t) {
+	return typeof t.type == "string" ? t.type : "";
+}
+function J(t, e) {
+	if (!(!t || typeof t != "object")) {
+		for (let r of Object.values(t)) if (Array.isArray(r)) for (let n of r) n && typeof n == "object" && e(n);
+	}
+}
+function De(t, e = false, r = {}) {
+	let { parseValues: n = true, rhino: s, stringOnly: o = false } = r, i = {}, a = /* @__PURE__ */ new Set();
+	for (let u of H(t)) {
+		let m = E$1(u, "paramName");
+		J(E$1(u, "innerTree"), (f) => {
+			let h = Q(f);
+			if (Ce(h) || o && h !== x.STRING) return;
+			let g = e ? f.id : m;
+			if (!g) return;
+			let T = Ie(f, h, n, s);
+			g in i ? a.has(g) ? i[g].push(T) : (i[g] = [i[g], T], a.add(g)) : i[g] = T;
+		});
+	}
+	return {
+		values: i,
+		dispose: () => Se(i)
+	};
+}
+function xe(t) {
+	let e = [];
+	for (let r of H(t)) J(E$1(r, "innerTree"), (n) => {
+		if (!Q(n).includes(et)) return;
+		let s = ve(n);
+		nt(s) && e.push(s);
+	});
+	return e;
+}
+function we(t, e, r = {}) {
+	let { parseValues: n = true, rhino: s, stringOnly: o = false } = r;
+	for (let i of H(t)) {
+		let a = E$1(i, "innerTree"), u = false;
+		if ("byName" in e) {
+			if (E$1(i, "paramName") !== e.byName) continue;
+			u = true;
+		}
+		let m = [];
+		if (J(a, (f) => {
+			if ("byId" in e) {
+				if (f.id !== e.byId) return;
+				u = true;
+			}
+			let h = Q(f);
+			Ce(h) || o && h !== x.STRING || m.push(Ie(f, h, n, s));
+		}), u) return m.length === 0 ? void 0 : m.length === 1 ? m[0] : m;
+	}
+}
+var W = class {
+	constructor(e, r = false) {
+		b$1(this, "response", e);
+		b$1(this, "debug", r);
+	}
+	getValues(e = false, r = {}) {
+		return De(this.response, e, r);
+	}
+	getValue(e, r) {
+		return we(this.response, e, r);
+	}
+	getFileData() {
+		return xe(this.response);
+	}
+	async getAndDownloadFiles(e, r) {
+		let n = this.getFileData();
+		await Oe$1(n, e, r);
+	}
+};
+var Y = /^\{(-?\d+(?:;-?\d+)*)?\}$/;
+function w(t) {
+	if (typeof t != "object" || t === null || Array.isArray(t)) return false;
+	let e = Object.entries(t);
+	return e.length > 0 && e.every(([r, n]) => Y.test(r) && Array.isArray(n));
+}
+function X(t, e, r) {
+	let n = Number(t.toFixed(e));
+	return Math.abs(t - n) < r ? n : t;
+}
+function Ee(t, e) {
+	if (!Number.isFinite(t) || t === 0) return .1;
+	let r = Math.abs(t);
+	if (r >= 1) {
+		let g = String(t).split(".")[1];
+		if (g && g.length > 0) {
+			let T = Math.min(g.length, 12), v = Math.pow(10, -T), ne = Number(v.toFixed(T));
+			return Math.abs(ne - v) < e ? ne : v;
+		}
+		return 1;
+	}
+	let n = String(t), s = n.toLowerCase().match(/e(-?\d+)/);
+	if (s) {
+		let h = Number(s[1]);
+		if (h < 0 || n.toLowerCase().includes("e-")) {
+			let g = Math.abs(h), T = Math.pow(10, -g), v = Number(T.toFixed(g));
+			return Math.abs(v - T) < e ? v : T;
+		}
+		return .1;
+	}
+	let o = 12, a = r.toFixed(o).replace(/0+$/, ""), u = Math.min((a.split(".")[1] || "").length, o);
+	if (u === 0) return .1;
+	let m = Math.pow(10, -u), f = Number(m.toFixed(u));
+	return Math.abs(f - m) < e ? f : m;
+}
+function Z(t) {
+	return typeof t.stepSize == "number" && Number.isFinite(t.stepSize) && t.stepSize > 0 ? t.stepSize : void 0;
+}
+function C(t, e, r) {
+	if (t == null) return t;
+	if (Array.isArray(t)) {
+		let s = t.map(e).filter((o) => o !== null);
+		return s.length > 0 ? s : void 0;
+	}
+	let n = e(t);
+	return n !== null ? n : r ? void 0 : t;
+}
+var R = (t) => {
+	if (typeof t == "number") return Number.isFinite(t) ? t : null;
+	if (typeof t == "string") {
+		let e = t.trim();
+		if (e === "" || /^[+-]?0[xbo]/i.test(e)) return null;
+		let r = Number(e);
+		return Number.isFinite(r) ? r : null;
+	}
+	return null;
+};
+var $ = (t) => {
+	if (typeof t == "boolean") return t;
+	if (typeof t == "string") {
+		let e = t.trim().toLowerCase();
+		if (e === "true") return true;
+		if (e === "false") return false;
+	}
+	return null;
+};
+var Ae = (t) => typeof t == "string" ? t.length >= 2 && t.startsWith("\"") && t.endsWith("\"") ? t.slice(1, -1) : t.startsWith("\"") ? t.slice(1) : t : null;
+var Re = (t) => {
+	if (typeof t == "string") {
+		let e = t.trim();
+		return e.startsWith("\"") && e.endsWith("\"") && (e = e.slice(1, -1).trim()), e;
+	}
+	return null;
+};
+function ee(t) {
+	return (e) => {
+		if (typeof e == "object" && e !== null) return e;
+		if (typeof e == "string" && e.trim() !== "") try {
+			let r = JSON.parse(e);
+			return typeof r == "object" && r !== null ? r : (y().warn(`Parsed value for input ${t} is not an object`), null);
+		} catch (r) {
+			return y().warn(`Failed to parse object value "${e}" for input ${t}`, r), null;
+		}
+		return null;
+	};
+}
+function st(t, e = 1e-8) {
+	let r = t.paramType === "Integer", n = Z(t);
+	if (w(t.default)) return {
+		default: t.default,
+		stepSize: n ?? (r ? 1 : .1)
+	};
+	if (typeof t.default == "string" && t.default.trim() !== "" && R(t.default) === null) throw new f(`Invalid numeric default "${t.default}" for input "${t.name || "unknown"}"`, u.VALIDATION_ERROR, { context: {
+		inputName: t.name,
+		default: t.default
+	} });
+	let s = C(t.default, R, true);
+	if (r) return Array.isArray(s) ? s = s.map((h) => typeof h == "number" ? Math.round(h) : h) : typeof s == "number" && (s = Math.round(s)), {
+		default: s,
+		stepSize: n ?? 1
+	};
+	let o = Array.isArray(s) ? s[0] : s, i;
+	typeof o == "number" && Number.isFinite(o) && o !== 0 ? i = o : typeof t.minimum == "number" && Number.isFinite(t.minimum) && t.minimum !== 0 ? i = t.minimum : typeof t.maximum == "number" && Number.isFinite(t.maximum) && t.maximum !== 0 && (i = t.maximum);
+	let a = n ?? (i !== void 0 ? Ee(i, e) : .1), u$1 = 0, m = String(a), f$1 = m.toLowerCase().match(/e(-?\d+)/);
+	if (f$1 ? u$1 = Math.abs(Number(f$1[1])) : u$1 = m.split(".")[1]?.length ?? 0, u$1 === 0 && typeof o == "number" && o !== 0 && Math.abs(o) < 1) {
+		let h = Math.ceil(-Math.log10(Math.abs(o)));
+		Number.isFinite(h) && h > 0 && (u$1 = h);
+	}
+	return u$1 = Math.min(Math.max(u$1, 0), 12), Array.isArray(s) ? s = s.map((h) => typeof h == "number" ? X(h, u$1, e) : h) : typeof s == "number" && (s = X(s, u$1, e)), {
+		default: s,
+		stepSize: a
+	};
+}
+var ot = {
+	types: ["Number", "Integer"],
+	parse(t, e) {
+		let { default: r, stepSize: n } = st(t);
+		return {
+			...e,
+			paramType: t.paramType,
+			minimum: t.minimum,
+			maximum: t.maximum,
+			atLeast: t.atLeast,
+			atMost: t.atMost,
+			stepSize: n,
+			default: r
+		};
+	},
+	fallback(t, e) {
+		let r = (t.atMost ?? 1) > 1, n = typeof t.minimum == "number" && Number.isFinite(t.minimum) && t.minimum > 0 ? t.minimum : 0;
+		return {
+			...e,
+			paramType: t.paramType,
+			minimum: t.minimum,
+			maximum: t.maximum,
+			atLeast: t.atLeast,
+			atMost: t.atMost,
+			stepSize: Z(t) ?? (t.paramType === "Integer" ? 1 : .1),
+			default: r ? [n] : n
+		};
+	}
+};
+var it = {
+	types: ["Boolean"],
+	parse(t, e) {
+		if (w(t.default)) return {
+			...e,
+			paramType: "Boolean",
+			default: t.default
+		};
+		let r = C(t.default, $, false);
+		if (r != null && typeof r != "boolean" && !Array.isArray(r)) throw new f(`Invalid boolean default "${String(r)}" for input "${t.name || "unknown"}"`, u.VALIDATION_ERROR, { context: {
+			inputName: t.name,
+			default: t.default
+		} });
+		return {
+			...e,
+			paramType: "Boolean",
+			default: r
+		};
+	},
+	fallback(t, e) {
+		let r = (t.atMost ?? 1) > 1;
+		return {
+			...e,
+			paramType: "Boolean",
+			default: r ? [false] : false
+		};
+	}
+};
+var at = {
+	types: ["Text"],
+	parse(t, e) {
+		let r = C(t.default, Ae, false);
+		return {
+			...e,
+			paramType: "Text",
+			default: r
+		};
+	},
+	fallback(t, e) {
+		let r = (t.atMost ?? 1) > 1;
+		return {
+			...e,
+			paramType: "Text",
+			default: r ? [""] : ""
+		};
+	}
+};
+var ut = {
+	types: ["ValueList"],
+	parse(t, e) {
+		if (!t.values || typeof t.values != "object" || Object.keys(t.values).length === 0) throw f.missingValues(t.nickname || "unnamed", "ValueList");
+		let r = t.default;
+		if (t.default !== void 0 && t.default !== null) {
+			if (typeof t.default == "object") throw new f(`ValueList input "${t.nickname || "unnamed"}" default is not a string-able value`, u.VALIDATION_ERROR, { context: {
+				inputName: t.name,
+				default: t.default
+			} });
+			let n = String(t.default).toLowerCase(), s = Object.keys(t.values).find((o) => o.toLowerCase() === n);
+			s !== void 0 ? r = s : y().warn(`ValueList input "${t.nickname || "unnamed"}" default value "${t.default}" is not in available values`);
+		}
+		return {
+			...e,
+			paramType: "ValueList",
+			values: t.values,
+			default: r
+		};
+	},
+	fallback(t, e) {
+		return {
+			...e,
+			paramType: "ValueList",
+			values: t.values && typeof t.values == "object" ? t.values : {},
+			default: void 0
+		};
+	}
+};
+var Pe = {
+	types: ["Geometry"],
+	parse(t, e) {
+		let r = C(t.default, ee(t.nickname || "unnamed"), true);
+		return {
+			...e,
+			paramType: "Geometry",
+			default: r
+		};
+	},
+	fallback(t, e) {
+		let r = (t.atMost ?? 1) > 1;
+		return {
+			...e,
+			paramType: "Geometry",
+			default: r ? [null] : null
+		};
+	}
+};
+var te = new Map([
+	ot,
+	it,
+	at,
+	ut,
+	Pe,
+	{
+		types: ["File"],
+		parse(t, e) {
+			let r = C(t.default, ee(t.nickname || "unnamed"), true);
+			return {
+				...e,
+				paramType: "File",
+				acceptedFormats: t.acceptedFormats,
+				default: r
+			};
+		},
+		fallback(t, e) {
+			let r = (t.atMost ?? 1) > 1;
+			return {
+				...e,
+				paramType: "File",
+				default: r ? [null] : null
+			};
+		}
+	},
+	{
+		types: ["Color"],
+		parse(t, e) {
+			let r = C(t.default, Re, false);
+			return {
+				...e,
+				paramType: "Color",
+				default: r
+			};
+		},
+		fallback(t, e) {
+			let r = (t.atMost ?? 1) > 1;
+			return {
+				...e,
+				paramType: "Color",
+				default: r ? ["0, 0, 0"] : "0, 0, 0"
+			};
+		}
+	}
+].flatMap((t) => t.types.map((e) => [e, t])));
+var Ne = Pe;
+function Oe(t) {
+	return E$1(t, "data");
+}
+function ft(t) {
+	return E$1(t, "type");
+}
+var dt = /* @__PURE__ */ new Set([
+	"System.Double",
+	"System.Single",
+	"System.Decimal",
+	"System.Int32",
+	"System.Int64"
+]);
+var mt = /* @__PURE__ */ new Set(["System.Int32", "System.Int64"]);
+function Me(t) {
+	if (typeof t.default != "object" || t.default === null) return { schema: t };
+	if (Array.isArray(t.default)) return { schema: t };
+	if (!he$1(t.default, "innerTree")) {
+		let n = `Input "${t.name ?? "unknown"}" default had an unrecognized shape (no innerTree key); the default was dropped.`;
+		return y().warn("Unexpected structure in input.default:", t.default), {
+			schema: {
+				...t,
+				default: null
+			},
+			warning: {
+				code: "MALFORMED_DEFAULT",
+				message: n
+			}
+		};
+	}
+	let e = E$1(t.default, "innerTree") ?? {};
+	if (Object.keys(e).length === 0) return { schema: {
+		...t,
+		default: void 0
+	} };
+	if (t.treeAccess || t.atMost && t.atMost > 1) {
+		let n = {}, s = [];
+		for (let [i, a] of Object.entries(e)) {
+			if (!Array.isArray(a)) {
+				let m = `Input "${t.name ?? "unknown"}" default had a non-array innerTree branch ("${i}"); the default was dropped.`;
+				return y().warn("Unexpected structure in input.default innerTree:", t.default), {
+					schema: {
+						...t,
+						default: null
+					},
+					warning: {
+						code: "MALFORMED_DEFAULT",
+						message: m
+					}
+				};
+			}
+			let u = [];
+			for (let m of a) {
+				let f = Oe(m), h = ft(m);
+				if (h && dt.has(h)) {
+					if (typeof f == "string" && f.trim() === "") continue;
+					let g = R(f);
+					if (g === null) {
+						s.push(`"${String(f)}" (${h})`);
+						continue;
+					}
+					u.push(mt.has(h) ? Math.round(g) : g);
+					continue;
+				}
+				if (h === "System.Boolean") {
+					let g = $(f);
+					if (g === null) {
+						s.push(`"${String(f)}" (${h})`);
+						continue;
+					}
+					u.push(g);
+					continue;
+				}
+				if (typeof f == "string" && h?.startsWith("Rhino.Geometry")) {
+					try {
+						u.push(JSON.parse(f));
+					} catch {
+						u.push(f);
+					}
+					continue;
+				}
+				u.push(f);
+			}
+			n[i] = u;
+		}
+		let o;
+		if (s.length > 0) {
+			let i = `Input "${t.name ?? "unknown"}" default contained ${s.length} tree value(s) that could not be parsed and were dropped: ${s.join(", ")}.`;
+			y().warn(i), o = {
+				code: "MALFORMED_DEFAULT",
+				message: i
+			};
+		}
+		return {
+			schema: {
+				...t,
+				default: n
+			},
+			...o && { warning: o }
+		};
+	}
+	let r = [];
+	for (let n of Object.values(e)) Array.isArray(n) && n.forEach((s) => {
+		s && typeof s == "object" && he$1(s, "data") && r.push(Oe(s));
+	});
+	return r.length === 0 ? { schema: {
+		...t,
+		default: void 0
+	} } : r.length === 1 ? { schema: {
+		...t,
+		default: r[0]
+	} } : { schema: {
+		...t,
+		default: r
+	} };
+}
+var ht = new Map([...te.keys()].map((t) => [t.toLowerCase(), t]));
+function yt(t) {
+	return ht.get(t?.toLowerCase()) ?? t;
+}
+function gt(t) {
+	return ke(t).input;
+}
+function ke(t) {
+	let e = {
+		description: t.description,
+		name: t.name,
+		nickname: t.nickname,
+		treeAccess: t.treeAccess,
+		groupName: t.groupName ?? void 0,
+		id: t.id
+	}, r = yt(t.paramType), n = {
+		...t,
+		paramType: r
+	}, s;
+	try {
+		let { schema: i, warning: a } = Me(n);
+		n = i, s = a && {
+			inputName: t.name || "unknown",
+			paramType: t.paramType,
+			message: a.message,
+			code: a.code
+		};
+	} catch (i) {
+		n = {
+			...n,
+			default: null
+		}, s = {
+			inputName: t.name || "unknown",
+			paramType: t.paramType,
+			message: `Input "${t.name ?? "unknown"}" default could not be normalized and was dropped: ${i instanceof Error ? i.message : String(i)}`,
+			code: "MALFORMED_DEFAULT"
+		};
+	}
+	let o = te.get(r);
+	try {
+		if (!o) throw f.unknownParamType(r, t.name);
+		return {
+			input: o.parse(n, e),
+			error: s,
+			...s && { errors: [s] }
+		};
+	} catch (i) {
+		if (i instanceof f) {
+			y().error(`Validation error for input ${t.name || "unknown"}:`, i.message);
+			let a = {
+				inputName: t.name || "unknown",
+				paramType: t.paramType,
+				message: i.message,
+				code: i.code
+			};
+			return {
+				input: (o ?? Ne).fallback(n, e),
+				error: a,
+				errors: s ? [s, a] : [a]
+			};
+		}
+		throw new f(i instanceof Error ? i.message : String(i), "VALIDATION_ERROR", {
+			context: {
+				paramName: t.name,
+				paramType: r
+			},
+			originalError: i instanceof Error ? i : new Error(String(i))
+		});
+	}
+}
+function Fe(t) {
+	let e = [], r = [];
+	for (let n of t) {
+		let { input: s, errors: o } = ke(n);
+		e.push(s), o && r.push(...o);
+	}
+	return {
+		inputs: e,
+		parseErrors: r
+	};
+}
+function Le(t) {
+	let e = E$1(t, "stepSize");
+	return {
+		id: E$1(t, "id") ?? "",
+		name: E$1(t, "name") ?? "",
+		nickname: E$1(t, "nickname") ?? null,
+		description: E$1(t, "description") ?? "",
+		paramType: E$1(t, "paramType") ?? "",
+		treeAccess: E$1(t, "treeAccess") ?? false,
+		minimum: E$1(t, "minimum") ?? null,
+		maximum: E$1(t, "maximum") ?? null,
+		atLeast: E$1(t, "atLeast") ?? 1,
+		atMost: E$1(t, "atMost") ?? 1,
+		stepSize: typeof e == "number" && Number.isFinite(e) ? e : void 0,
+		default: E$1(t, "default"),
+		values: E$1(t, "values"),
+		acceptedFormats: E$1(t, "acceptedFormats"),
+		groupName: E$1(t, "groupName") ?? null
+	};
+}
+function Ve(t) {
+	return {
+		name: E$1(t, "name") ?? "",
+		nickname: E$1(t, "nickname") ?? null,
+		paramType: E$1(t, "paramType") ?? "",
+		id: E$1(t, "id") ?? ""
+	};
+}
+async function V(t, e) {
+	let r = E(t, []), n = {};
+	if (r.algo && (n.algo = r.algo), r.pointer && (n.pointer = r.pointer), !n.algo && !n.pointer) throw new f("Definition must resolve to either a URL pointer or base64 algo", u.INVALID_INPUT, { context: { definition: t } });
+	let s = await Ee$1("io", n, B(e));
+	if (!s || typeof s != "object") throw new f("Invalid IO response structure", u.INVALID_INPUT, { context: {
+		response: s,
+		definition: t
+	} });
+	let o = Ge(E$1(s, "warnings")), i = Ge(E$1(s, "errors")), a = E$1(s, "inputs"), u$2 = E$1(s, "outputs");
+	return {
+		inputs: Array.isArray(a) ? a.map(Le) : [],
+		outputs: Array.isArray(u$2) ? u$2.map(Ve) : [],
+		...o && { loadWarnings: o },
+		...i && { loadErrors: i }
+	};
+}
+function Ge(t) {
+	if (!Array.isArray(t)) return;
+	let e = t.map(bt).filter((r) => r !== void 0);
+	return e.length > 0 ? e : void 0;
+}
+function bt(t) {
+	if (t == null) return;
+	let e;
+	if (typeof t == "string") e = t;
+	else if (typeof t == "object") {
+		let r = E$1(t, "message");
+		if (typeof r == "string" && r.trim().length > 0) e = r;
+		else try {
+			e = JSON.stringify(t) ?? String(t);
+		} catch {
+			e = String(t);
+		}
+	} else e = String(t);
+	return e.trim().length > 0 ? e : void 0;
+}
+async function q(t, e) {
+	D("fetchParsedDefinitionIO", e.suppressBrowserWarning);
+	let { inputs: r, outputs: n, loadWarnings: s, loadErrors: o } = await V(t, e), { inputs: i, parseErrors: a } = Fe(r);
+	return {
+		inputs: i,
+		outputs: n,
+		...a.length > 0 && { parseErrors: a },
+		...s && { loadWarnings: s },
+		...o && { loadErrors: o }
+	};
+}
+function Tt(t) {
+	return (Array.isArray(t) ? t : [t]).map((r) => ({
+		schemas: E$1(r, "schemas"),
+		error: E$1(r, "error")
+	}));
+}
+var re = class t {
+	constructor(e) {
+		b$1(this, "innerTree");
+		b$1(this, "paramName");
+		this.paramName = e, this.innerTree = {};
+	}
+	append(e, r) {
+		let n = t.formatPathString(e);
+		this.innerTree[n] || (this.innerTree[n] = []);
+		let s = r.map((o) => ({ data: t.serializeValue(o) }));
+		return this.innerTree[n].push(...s), this;
+	}
+	appendSingle(e, r) {
+		return this.append(e, [r]);
+	}
+	fromDataTreeDefault(e) {
+		this.innerTree = {};
+		for (let [r, n] of Object.entries(e)) {
+			if (!Array.isArray(n)) continue;
+			let s = t.parsePathString(r);
+			this.append(s, n);
+		}
+		return this;
+	}
+	appendFlat(e) {
+		let r = Array.isArray(e) ? e : [e];
+		return this.append([0], r);
+	}
+	flatten() {
+		let e = [];
+		for (let r of Object.values(this.innerTree)) if (Array.isArray(r)) for (let n of r) e.push(t.deserializeValue(n.data));
+		return e;
+	}
+	getPaths() {
+		return Object.keys(this.innerTree);
+	}
+	getPath(e) {
+		let r = t.formatPathString(e), n = this.innerTree[r];
+		if (n) return n.map((s) => t.deserializeValue(s.data));
+	}
+	toComputeFormat() {
+		return {
+			ParamName: this.paramName,
+			InnerTree: this.innerTree
+		};
+	}
+	getInnerTree() {
+		return this.innerTree;
+	}
+	getParamName() {
+		return this.paramName;
+	}
+	static fromInputParams(e) {
+		return e.filter((r) => t.hasValidValue(r.default)).map((r) => {
+			let n = new t(r.nickname || "unnamed"), s = r.default;
+			if (r.treeAccess && w(s)) n.fromDataTreeDefault(s), t.isNumericInput(r) && n.applyNumericConstraints(r.minimum, r.maximum, r.nickname || "unnamed");
+			else {
+				let o = Array.isArray(s) ? s : [s], i = t.processValues(o, r);
+				n.appendFlat(i);
+			}
+			return n.toComputeFormat();
+		});
+	}
+	static fromInputParam(e) {
+		return t.hasValidValue(e.default) ? t.fromInputParams([e])[0] : void 0;
+	}
+	static replaceTreeValue(e, r, n) {
+		let s = e.length > 0 && e[0] instanceof t, o = t.buildFromValue(r, n);
+		if (s) {
+			let m = e.slice(), f = m.findIndex((h) => h.getParamName() === r);
+			return f !== -1 ? m[f] = o : m.push(o), m;
+		}
+		let i = e.slice(), a = o.toComputeFormat(), u = i.findIndex((m) => m.ParamName === r);
+		return u !== -1 ? i[u] = a : i.push(a), i;
+	}
+	static buildFromValue(e, r) {
+		let n = new t(e);
+		return w(r) ? n.fromDataTreeDefault(r) : n.appendFlat(r), n;
+	}
+	static getTreeValue(e, r) {
+		let s = e.length > 0 && e[0] instanceof t ? t.readFromBuilders(e, r) : t.readFromDataTrees(e, r);
+		return s === null || s.length === 0 ? null : s.length === 1 ? s[0] : s;
+	}
+	static readFromBuilders(e, r) {
+		let n = e.find((s) => s.getParamName() === r);
+		return n ? n.flatten() : null;
+	}
+	static readFromDataTrees(e, r) {
+		let n = e.find((i) => i.ParamName === r);
+		if (!n?.InnerTree) return null;
+		let s = Object.keys(n.InnerTree)[0];
+		if (!s) return null;
+		let o = n.InnerTree[s];
+		return Array.isArray(o) ? o.map((i) => i?.data !== void 0 ? t.deserializeValue(i.data) : null) : o?.data !== void 0 ? [t.deserializeValue(o.data)] : o !== void 0 ? [o] : null;
+	}
+	static parsePathString(e) {
+		let r = e.match(Y);
+		if (!r) throw new Error(`Invalid Grasshopper tree path: "${e}". Expected "{}", "{0}", or "{0;1;2}" (negative indices allowed, no empty segments).`);
+		return r[1] ? r[1].split(";").map(Number) : [];
+	}
+	static formatPathString(e) {
+		return `{${e.join(";")}}`;
+	}
+	applyNumericConstraints(e, r, n) {
+		for (let s of Object.values(this.innerTree)) if (Array.isArray(s)) for (let o of s) {
+			let i = t.deserializeValue(o.data);
+			if (typeof i == "number") {
+				let a = t.clampValue(i, e, r, n);
+				o.data = t.serializeValue(a);
+			}
+		}
+	}
+	static serializeValue(e) {
+		return typeof e == "boolean" || typeof e == "number" || typeof e == "string" ? e : typeof e == "object" && e !== null ? 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 r = Number(e);
+		return Number.isFinite(r) && String(r) === e ? r : e === "true" ? true : e === "false" ? false : e;
+	}
+	static hasValidValue(e) {
+		return e == null ? false : typeof e == "string" ? true : !(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, r) {
+		return e.map((n) => t.isNumericInput(r) && typeof n == "number" ? t.clampValue(n, r.minimum, r.maximum, r.nickname || "unnamed") : n).filter((n) => n != null);
+	}
+	static clampValue(e, r, n, s) {
+		let o = e;
+		return r != null && o < r && (y().warn(`${s}: ${e} below min ${r}, clamping`), o = r), n != null && o > n && (y().warn(`${s}: ${e} above max ${n}, clamping`), o = n), o;
+	}
+};
+//#endregion
+//#region ../schemas/src/generated/schema.ts
+/** Current UISchema format version (from ui-schema.json's schemaVersion default). */
+var UI_SCHEMA_VERSION = "2.13.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 { I, L, Tt as T, UI_SCHEMA_VERSION as U, W, isNumberWidget as a, isCheckboxWidget as b, ce as c, isTextWidget as d, isDropdownWidget as e, isFileWidget as f, gt as g, isColorWidget as h, isDynamicValueListWidget as i, re as r };
+//# sourceMappingURL=schema.js-o6B8HHvu.js.map