@selvajs/selva 4.7.2 → 4.7.4-beta.0

package/build/server/chunks/chunks/chunk-RFFCVRKM.js-Bw_Hh4Hk.js

@@ -0,0 +1,1496 @@
+import { y, m, p, A, l, Q as Q$1, a as yt, w as w$1, E as Ee$1, g as ge$1, d as de$1, M as Me$1, D as De$1, N as N$1, S as Se$1 } from './chunk-XT3XWDDV.js-CgVdm1U0.js';
+
+//#region ../compute/dist/chunk-RFFCVRKM.js
+var ie = /* @__PURE__ */ new Set();
+function Ve() {
+	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 x(t, e) {
+	e || Ve() && !ie.has(t) && (ie.add(t), m().warn(`Warning: ${t} is running on the client side. For better performance and security, consider running this on the server side.`));
+}
+function T(t) {
+	return typeof t == "object" && !(t instanceof Uint8Array) && typeof t.key == "string" && typeof t.load == "function";
+}
+var Ge = "Unable to load grasshopper definition";
+function We(t) {
+	return t instanceof p ? t.code === l.DEFINITION_NOT_CACHED || t.message.includes(Ge) : false;
+}
+function je(t, e) {
+	if (!e) return;
+	let r = w$1(t, "values");
+	if (!Array.isArray(r) || r.length === 0) return;
+	let n = [];
+	for (let o of r) {
+		let i = w$1(o, "innerTree");
+		(!i || Object.keys(i).length === 0) && n.push(w$1(o, "paramName") ?? "<unnamed>");
+	}
+	if (n.length === 0) return;
+	let s = n.length === r.length ? "all" : `${n.length}/${r.length}`;
+	m().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) {
+	x("solveGrasshopperDefinition", r.suppressBrowserWarning ?? r.suppressClientSideWarning);
+	let { response: s } = await P(w(await j(e), t), r);
+	return s;
+}
+async function ae(t, e, r) {
+	x("solveGrasshopperDefinitionWithCacheKey", r.suppressBrowserWarning ?? r.suppressClientSideWarning);
+	return P(w(await j(e), t), r);
+}
+async function ue(t, e, r, n) {
+	x("solveByCacheKey", n.suppressBrowserWarning ?? n.suppressClientSideWarning);
+	let s = {
+		algo: null,
+		pointer: e,
+		values: t
+	};
+	try {
+		return {
+			...await P(s, n),
+			missed: !1
+		};
+	} catch (o) {
+		if (!We(o)) throw o;
+		return {
+			...await P(w(await j(r), t), n),
+			missed: true
+		};
+	}
+}
+async function j(t) {
+	if (!T(t)) return t;
+	try {
+		return await t.load();
+	} catch (e) {
+		throw new p(`Failed to load definition bytes for ref '${t.key}'`, l.INVALID_INPUT, {
+			context: { definitionKey: t.key },
+			originalError: e instanceof Error ? e : new Error(String(e))
+		});
+	}
+}
+async function P(t, e) {
+	Be(t, e);
+	let r = await Ee$1("grasshopper", t, e), { pointer: n, algo: s, ...o } = r, i = o, a = ge$1(r);
+	if (a !== void 0) {
+		let u = typeof s == "string" ? s.length : 0;
+		N$1(i, Math.max(0, a - u));
+	}
+	return je(i, e.debug), {
+		response: i,
+		cacheKey: typeof n == "string" ? n : null
+	};
+}
+function w(t, e) {
+	let r = {
+		algo: null,
+		pointer: null,
+		values: e
+	};
+	return t instanceof Uint8Array ? r.algo = de$1(t) : /^https?:\/\//i.test(t) ? r.pointer = t : r.algo = Me$1(t) ?? De$1(t), r;
+}
+function Be(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 le(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":"${fe(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 pe(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 ce(t) {
+	return pe(t.length, (e) => t.charCodeAt(e));
+}
+function fe(t) {
+	return pe(t.length, (e) => t[e]);
+}
+function B(t, e) {
+	let r = le(e);
+	return `${t}|t:${r.length}:${ce(r)}`;
+}
+function N(t) {
+	return T(t) ? `r:${t.key}` : typeof t == "string" ? `s:${t.length}:${ce(t)}` : `u8:${t.length}:${fe(t)}`;
+}
+var ze = 100;
+function Ue(t) {
+	return typeof t != "string" ? true : !/^https?:\/\//i.test(t);
+}
+function _e(t) {
+	try {
+		return JSON.stringify(t)?.length ?? 0;
+	} catch {
+		return 0;
+	}
+}
+var E = class {
+	constructor(e, r, n = {}, s) {
+		y(this, "executor");
+		y(this, "baseConfig");
+		y(this, "mode");
+		y(this, "maxConcurrent");
+		y(this, "maxQueueDepth");
+		y(this, "queueWaitMs");
+		y(this, "timeoutMs");
+		y(this, "retry");
+		y(this, "cacheEnabled");
+		y(this, "cacheMax");
+		y(this, "cacheMaxBytes");
+		y(this, "cacheTtl");
+		y(this, "cacheErroredSolves");
+		y(this, "cache", /* @__PURE__ */ new Map());
+		y(this, "cacheBytes", 0);
+		y(this, "cacheHits", 0);
+		y(this, "cacheMisses", 0);
+		y(this, "cacheEvictions", 0);
+		y(this, "cacheKeyExecutor");
+		y(this, "reuseServerDefinitionCache");
+		y(this, "serverCacheKeys", /* @__PURE__ */ new Map());
+		y(this, "onStart");
+		y(this, "onSettle");
+		y(this, "onSuperseded");
+		y(this, "subscribers", /* @__PURE__ */ new Set());
+		y(this, "inFlight", /* @__PURE__ */ new Set());
+		y(this, "pendingForLatestWins", null);
+		y(this, "fifoQueue", []);
+		y(this, "_lastResult", null);
+		y(this, "_lastError", null);
+		y(this, "_lastDurationMs", null);
+		y(this, "solveSeq", 0);
+		y(this, "lastStateSeq", 0);
+		y(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;
+		this.cacheEnabled = o !== void 0 && o !== false;
+		let i = typeof o == "object" ? o : {};
+		this.cacheMax = i.maxEntries ?? 50, this.cacheMaxBytes = Math.max(0, i.maxBytes ?? 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;
+	}
+	subscribe(e) {
+		return this.subscribers.add(e), () => this.subscribers.delete(e);
+	}
+	notify() {
+		for (let e of this.subscribers) try {
+			e();
+		} catch (r) {
+			m().error("[SolveScheduler] subscriber threw:", r);
+		}
+	}
+	solve(e, r, n) {
+		if (this.disposed) return Promise.reject(new p("SolveScheduler has been disposed and cannot be used", l.INVALID_STATE));
+		let s = N(e), o = B(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 f = {
+					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, f), this.notify(), Promise.resolve(u);
+			}
+		}
+		return new Promise((u, f) => {
+			let c = {
+				definition: e,
+				dataTree: r,
+				definitionHash: s,
+				ctx: a,
+				seq: i,
+				resolve: u,
+				reject: f,
+				externalSignal: n?.signal
+			};
+			c.externalSignal && (c.queuedAbortHandler = () => this.abortQueuedItem(c), c.externalSignal.addEventListener("abort", c.queuedAbortHandler, { once: true })), this.enqueue(c);
+		});
+	}
+	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 p("Solve queue is full; request shed (backpressure)", l.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 p(`Solve waited longer than ${r}ms in queue; shed (backpressure)`, l.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));
+				break;
+		}
+		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), f = performance.now() - o;
+			if (this.cacheEnabled && this.writeCache(e.ctx.key, a), !this.settleSuccess(e, a)) return;
+			this.writeLastState(e.seq, {
+				result: a,
+				durationMs: f
+			}), this.runHook(this.onSettle, e.ctx, {
+				status: "success",
+				response: a,
+				durationMs: f,
+				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 || !Ue(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 > ze;) {
+			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 p("Superseded by newer solve", l.SUPERSEDED, { context: {
+			key: e.ctx.key,
+			enqueuedAt: e.ctx.enqueuedAt
+		} });
+		this.settleError(e, r) && this.runHook(this.onSuperseded, e.ctx);
+	}
+	makeAbortError(e) {
+		return new p("Request aborted by caller", l.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 p ? e : this.isAbortLikeError(e) ? this.makeAbortError(r.ctx) : new p(e instanceof Error ? e.message : String(e), l.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 = ge$1(r) ?? _e(r);
+		if (!(this.cacheMaxBytes > 0 && n > this.cacheMaxBytes)) for (this.dropCacheEntry(e), this.cache.set(e, {
+			response: r,
+			insertedAt: Date.now(),
+			sizeBytes: n
+		}), this.cacheBytes += n; (this.cache.size > this.cacheMax || this.cacheMaxBytes > 0 && 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) {
+			m().error("[SolveScheduler] hook threw:", n);
+		}
+	}
+};
+function de(t) {
+	return T(t) ? `ref:${t.key}` : typeof t == "string" && t.length < 200 ? t : "...content...";
+}
+function me(t) {
+	return Array.isArray(t) ? t.map((e) => {
+		let r = 0, n = 0, s = w$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: w$1(e, "paramName") ?? "<unnamed>",
+			items: r,
+			bytes: n
+		};
+	}) : [];
+}
+var O = class t {
+	constructor(e) {
+		y(this, "config");
+		y(this, "serverStats");
+		y(this, "disposed", false);
+		this.config = this.normalizeComputeConfig(e), this.serverStats = new A(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 p("Rhino Compute server is not online", l.NETWORK_ERROR, { context: {
+			serverUrl: r.config.serverUrl,
+			attempts: n
+		} });
+	}
+	getConfig() {
+		return this.ensureNotDisposed(), { ...this.config };
+	}
+	async getIO(e) {
+		return this.ensureNotDisposed(), $(e, this.config);
+	}
+	async getRawIO(e) {
+		return this.ensureNotDisposed(), M(e, this.config);
+	}
+	async solve(e, r, n) {
+		this.ensureNotDisposed();
+		try {
+			if (typeof e == "string" && !e?.trim()) throw new p("Definition URL/content is required", l.INVALID_INPUT, { context: { receivedUrl: e } });
+			if (e instanceof Uint8Array && e.length === 0) throw new p("Definition content is empty", l.INVALID_INPUT);
+			if (T(e) && !e.key.trim()) throw new p("DefinitionRef key is empty", l.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 p(o.errors.join("; ") || "Computation failed", l.COMPUTATION_ERROR, { context: {
+				definition: de(e),
+				inputSummary: me(r),
+				errors: o.errors,
+				warnings: o.warnings,
+				values: o.values
+			} });
+			return o;
+		} catch (s) {
+			throw this.config.debug && m().error("Compute failed:", s), s instanceof p ? s : new p(s instanceof Error ? s.message : String(s), l.COMPUTATION_ERROR, {
+				context: {
+					definition: de(e),
+					inputSummary: me(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 ? ae(o, s, a).then((u) => ({
+			...u,
+			missed: false
+		})) : ue(o, i, s, a);
+		return new E(r, this.config, e, n);
+	}
+	async dispose() {
+		this.disposed || (this.disposed = true, await this.serverStats.dispose());
+	}
+	ensureNotDisposed() {
+		if (this.disposed) throw new p("GrasshopperClient has been disposed and cannot be used", l.INVALID_STATE);
+	}
+	normalizeComputeConfig(e) {
+		return {
+			...e,
+			serverUrl: Q$1(e.serverUrl),
+			apiKey: e.apiKey,
+			authToken: e.authToken,
+			debug: e.debug ?? false,
+			suppressBrowserWarning: e.suppressBrowserWarning ?? e.suppressClientSideWarning
+		};
+	}
+};
+var F = /* @__PURE__ */ new Map();
+function ye(t, e) {
+	F.set(t, e);
+}
+ye("Rhino.Geometry.Point3d", (t, e) => {
+	let r = e;
+	return !r || typeof r.X != "number" ? null : new t.Point([
+		r.X,
+		r.Y,
+		r.Z
+	]);
+});
+ye("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 qe(t) {
+	if (F.has(t)) return F.get(t);
+	for (let [e, r] of F) if (t.startsWith(e)) return r;
+}
+function Ke(t) {
+	return !!(t && typeof t == "object" && typeof t.data == "string");
+}
+function he(t, e) {
+	return {
+		__decodeError: true,
+		type: t,
+		raw: e
+	};
+}
+function ge(t, e, r) {
+	let n = qe(e), s = false;
+	if (n) try {
+		let o = n(r, t);
+		if (o != null) return o;
+	} catch (o) {
+		m().warn(`Failed to decode Rhino type ${e}:`, o), s = true;
+	}
+	try {
+		if (Ke(t)) return r.CommonObject.decode(t);
+	} catch (o) {
+		return m().warn(`Failed to decode ${e} with CommonObject:`, o), he(e, t);
+	}
+	return s ? he(e, t) : t;
+}
+function be(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 I = {
+	STRING: "System.String",
+	INT: "System.Int32",
+	DOUBLE: "System.Double",
+	BOOL: "System.Boolean"
+};
+var Qe = "Rhino.Geometry.";
+var He = ["WebDisplay"];
+var Je = "FileData";
+function Te(t) {
+	return He.some((e) => t.includes(e));
+}
+function Ye(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 Xe(t, e, r) {
+	switch (e) {
+		case I.STRING: return typeof t != "string" ? t : t.replace(/^"(.*)"$/, "$1");
+		case I.INT: return Number.parseInt(t, 10);
+		case I.DOUBLE: return Number.parseFloat(t);
+		case I.BOOL: return String(t).toLowerCase() === "true";
+		default: return r && e.startsWith(Qe) ? ge(t, e, r) : t;
+	}
+}
+var z = /* @__PURE__ */ new WeakMap();
+function Se(t) {
+	if (z.has(t)) return z.get(t);
+	let e = Ye(t.data);
+	return z.set(t, e), e;
+}
+function De(t, e, r, n) {
+	if (typeof t.data != "string") return t.data;
+	return Xe(r ? Se(t) : t.data, e, n);
+}
+function Ze(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 U(t) {
+	let e = w$1(t, "values");
+	return Array.isArray(e) ? e : [];
+}
+function _(t) {
+	return typeof t.type == "string" ? t.type : "";
+}
+function q(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 xe(t, e = false, r = {}) {
+	let { parseValues: n = true, rhino: s, stringOnly: o = false } = r, i = {}, a = /* @__PURE__ */ new Set();
+	for (let u of U(t)) {
+		let f = w$1(u, "paramName");
+		q(w$1(u, "innerTree"), (c) => {
+			let d = _(c);
+			if (Te(d) || o && d !== I.STRING) return;
+			let g = e ? c.id : f;
+			if (!g) return;
+			let b = De(c, d, n, s);
+			g in i ? a.has(g) ? i[g].push(b) : (i[g] = [i[g], b], a.add(g)) : i[g] = b;
+		});
+	}
+	return {
+		values: i,
+		dispose: () => be(i)
+	};
+}
+function Ie(t) {
+	let e = [];
+	for (let r of U(t)) q(w$1(r, "innerTree"), (n) => {
+		if (!_(n).includes(Je)) return;
+		let s = Se(n);
+		Ze(s) && e.push(s);
+	});
+	return e;
+}
+function Ce(t, e, r = {}) {
+	let { parseValues: n = true, rhino: s, stringOnly: o = false } = r;
+	for (let i of U(t)) {
+		let a = w$1(i, "innerTree"), u = false;
+		if ("byName" in e) {
+			if (w$1(i, "paramName") !== e.byName) continue;
+			u = true;
+		}
+		let f = [];
+		if (q(a, (c) => {
+			if ("byId" in e) {
+				if (c.id !== e.byId) return;
+				u = true;
+			}
+			let d = _(c);
+			Te(d) || o && d !== I.STRING || f.push(De(c, d, n, s));
+		}), u) return f.length === 0 ? void 0 : f.length === 1 ? f[0] : f;
+	}
+}
+var L = class {
+	constructor(e, r = false) {
+		y(this, "response", e);
+		y(this, "debug", r);
+	}
+	getValues(e = false, r = {}) {
+		return xe(this.response, e, r);
+	}
+	getValue(e, r) {
+		return Ce(this.response, e, r);
+	}
+	getFileData() {
+		return Ie(this.response);
+	}
+	async getAndDownloadFiles(e, r) {
+		await Se$1(this.getFileData(), e, r);
+	}
+};
+var K = /^\{(-?\d+(?:;-?\d+)*)?\}$/;
+function C(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]) => K.test(r) && Array.isArray(n));
+}
+function Q(t, e, r) {
+	let n = Number(t.toFixed(e));
+	return Math.abs(t - n) < r ? n : t;
+}
+function we(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 b = Math.min(g.length, 12), D = Math.pow(10, -b), Z = Number(D.toFixed(b));
+			return Math.abs(Z - D) < e ? Z : D;
+		}
+		return 1;
+	}
+	let n = String(t), s = n.toLowerCase().match(/e(-?\d+)/);
+	if (s) {
+		let d = Number(s[1]);
+		if (d < 0 || n.toLowerCase().includes("e-")) {
+			let g = Math.abs(d), b = Math.pow(10, -g), D = Number(b.toFixed(g));
+			return Math.abs(D - b) < e ? D : b;
+		}
+		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 f = Math.pow(10, -u), c = Number(f.toFixed(u));
+	return Math.abs(c - f) < e ? c : f;
+}
+function H(t) {
+	return typeof t.stepSize == "number" && Number.isFinite(t.stepSize) && t.stepSize > 0 ? t.stepSize : void 0;
+}
+function S(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 v = (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 V = (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 Ee = (t) => typeof t == "string" ? t.length >= 2 && t.startsWith("\"") && t.endsWith("\"") ? t.slice(1, -1) : t.startsWith("\"") ? t.slice(1) : t : null;
+var ve = (t) => {
+	if (typeof t == "string") {
+		let e = t.trim();
+		return e.startsWith("\"") && e.endsWith("\"") && (e = e.slice(1, -1).trim()), e;
+	}
+	return null;
+};
+function J(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 : (m().warn(`Parsed value for input ${t} is not an object`), null);
+		} catch (r) {
+			return m().warn(`Failed to parse object value "${e}" for input ${t}`, r), null;
+		}
+		return null;
+	};
+}
+function et(t, e = 1e-8) {
+	let r = t.paramType === "Integer", n = H(t);
+	if (C(t.default)) return {
+		default: t.default,
+		stepSize: n ?? (r ? 1 : .1)
+	};
+	if (typeof t.default == "string" && t.default.trim() !== "" && v(t.default) === null) throw new p(`Invalid numeric default "${t.default}" for input "${t.name || "unknown"}"`, l.VALIDATION_ERROR, { context: {
+		inputName: t.name,
+		default: t.default
+	} });
+	let s = S(t.default, v, true);
+	if (r) return Array.isArray(s) ? s = s.map((d) => typeof d == "number" ? Math.round(d) : d) : 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 ? we(i, e) : .1), u = 0, f = String(a), c = f.toLowerCase().match(/e(-?\d+)/);
+	if (c ? u = Math.abs(Number(c[1])) : u = f.split(".")[1]?.length ?? 0, u === 0 && typeof o == "number" && o !== 0 && Math.abs(o) < 1) {
+		let d = Math.ceil(-Math.log10(Math.abs(o)));
+		Number.isFinite(d) && d > 0 && (u = d);
+	}
+	return u = Math.min(Math.max(u, 0), 12), Array.isArray(s) ? s = s.map((d) => typeof d == "number" ? Q(d, u, e) : d) : typeof s == "number" && (s = Q(s, u, e)), {
+		default: s,
+		stepSize: a
+	};
+}
+var tt = {
+	types: ["Number", "Integer"],
+	parse(t, e) {
+		let { default: r, stepSize: n } = et(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: H(t) ?? (t.paramType === "Integer" ? 1 : .1),
+			default: r ? [n] : n
+		};
+	}
+};
+var rt = {
+	types: ["Boolean"],
+	parse(t, e) {
+		if (C(t.default)) return {
+			...e,
+			paramType: "Boolean",
+			default: t.default
+		};
+		let r = S(t.default, V, false);
+		if (r != null && typeof r != "boolean" && !Array.isArray(r)) throw new p(`Invalid boolean default "${String(r)}" for input "${t.name || "unknown"}"`, l.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 nt = {
+	types: ["Text"],
+	parse(t, e) {
+		let r = S(t.default, Ee, false);
+		return {
+			...e,
+			paramType: "Text",
+			default: r
+		};
+	},
+	fallback(t, e) {
+		let r = (t.atMost ?? 1) > 1;
+		return {
+			...e,
+			paramType: "Text",
+			default: r ? [""] : ""
+		};
+	}
+};
+var st = {
+	types: ["ValueList"],
+	parse(t, e) {
+		if (!t.values || typeof t.values != "object" || Object.keys(t.values).length === 0) throw p.missingValues(t.nickname || "unnamed", "ValueList");
+		let r = t.default;
+		if (t.default !== void 0 && t.default !== null) {
+			if (typeof t.default == "object") throw new p(`ValueList input "${t.nickname || "unnamed"}" default is not a string-able value`, l.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 : m().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 Ae = {
+	types: ["Geometry"],
+	parse(t, e) {
+		let r = S(t.default, J(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 Y = new Map([
+	tt,
+	rt,
+	nt,
+	st,
+	Ae,
+	{
+		types: ["File"],
+		parse(t, e) {
+			let r = S(t.default, J(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 = S(t.default, ve, 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 Re = Ae;
+function Pe(t) {
+	return w$1(t, "data");
+}
+function ut(t) {
+	return w$1(t, "type");
+}
+var lt = /* @__PURE__ */ new Set([
+	"System.Double",
+	"System.Single",
+	"System.Decimal",
+	"System.Int32",
+	"System.Int64"
+]);
+var pt = /* @__PURE__ */ new Set(["System.Int32", "System.Int64"]);
+function ke(t) {
+	if (typeof t.default != "object" || t.default === null) return { schema: t };
+	if (Array.isArray(t.default)) return { schema: t };
+	if (!yt(t.default, "innerTree")) {
+		let n = `Input "${t.name ?? "unknown"}" default had an unrecognized shape (no innerTree key); the default was dropped.`;
+		return m().warn("Unexpected structure in input.default:", t.default), {
+			schema: {
+				...t,
+				default: null
+			},
+			warning: {
+				code: "MALFORMED_DEFAULT",
+				message: n
+			}
+		};
+	}
+	let e = w$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 f = `Input "${t.name ?? "unknown"}" default had a non-array innerTree branch ("${i}"); the default was dropped.`;
+				return m().warn("Unexpected structure in input.default innerTree:", t.default), {
+					schema: {
+						...t,
+						default: null
+					},
+					warning: {
+						code: "MALFORMED_DEFAULT",
+						message: f
+					}
+				};
+			}
+			let u = [];
+			for (let f of a) {
+				let c = Pe(f), d = ut(f);
+				if (d && lt.has(d)) {
+					if (typeof c == "string" && c.trim() === "") continue;
+					let g = v(c);
+					if (g === null) {
+						s.push(`"${String(c)}" (${d})`);
+						continue;
+					}
+					u.push(pt.has(d) ? Math.round(g) : g);
+					continue;
+				}
+				if (d === "System.Boolean") {
+					let g = V(c);
+					if (g === null) {
+						s.push(`"${String(c)}" (${d})`);
+						continue;
+					}
+					u.push(g);
+					continue;
+				}
+				if (typeof c == "string" && d?.startsWith("Rhino.Geometry")) {
+					try {
+						u.push(JSON.parse(c));
+					} catch {
+						u.push(c);
+					}
+					continue;
+				}
+				u.push(c);
+			}
+			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(", ")}.`;
+			m().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" && yt(s, "data") && r.push(Pe(s));
+	});
+	return r.length === 0 ? { schema: {
+		...t,
+		default: void 0
+	} } : r.length === 1 ? { schema: {
+		...t,
+		default: r[0]
+	} } : { schema: {
+		...t,
+		default: r
+	} };
+}
+var ct = new Map([...Y.keys()].map((t) => [t.toLowerCase(), t]));
+function ft(t) {
+	return ct.get(t?.toLowerCase()) ?? t;
+}
+function dt(t) {
+	return Ne(t).input;
+}
+function Ne(t) {
+	let e = {
+		description: t.description,
+		name: t.name,
+		nickname: t.nickname,
+		treeAccess: t.treeAccess,
+		groupName: t.groupName ?? void 0,
+		id: t.id
+	}, r = ft(t.paramType), n = {
+		...t,
+		paramType: r
+	}, s;
+	try {
+		let { schema: i, warning: a } = ke(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 = Y.get(r);
+	try {
+		if (!o) throw p.unknownParamType(r, t.name);
+		return {
+			input: o.parse(n, e),
+			error: s,
+			...s && { errors: [s] }
+		};
+	} catch (i) {
+		if (i instanceof p) {
+			m().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 ?? Re).fallback(n, e),
+				error: a,
+				errors: s ? [s, a] : [a]
+			};
+		}
+		throw new p(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 Oe(t) {
+	let e = [], r = [];
+	for (let n of t) {
+		let { input: s, errors: o } = Ne(n);
+		e.push(s), o && r.push(...o);
+	}
+	return {
+		inputs: e,
+		parseErrors: r
+	};
+}
+function Me(t) {
+	let e = w$1(t, "stepSize");
+	return {
+		id: w$1(t, "id") ?? "",
+		name: w$1(t, "name") ?? "",
+		nickname: w$1(t, "nickname") ?? null,
+		description: w$1(t, "description") ?? "",
+		paramType: w$1(t, "paramType") ?? "",
+		treeAccess: w$1(t, "treeAccess") ?? false,
+		minimum: w$1(t, "minimum") ?? null,
+		maximum: w$1(t, "maximum") ?? null,
+		atLeast: w$1(t, "atLeast") ?? 1,
+		atMost: w$1(t, "atMost") ?? 1,
+		stepSize: typeof e == "number" && Number.isFinite(e) ? e : void 0,
+		default: w$1(t, "default"),
+		values: w$1(t, "values"),
+		acceptedFormats: w$1(t, "acceptedFormats"),
+		groupName: w$1(t, "groupName") ?? null
+	};
+}
+function Fe(t) {
+	return {
+		name: w$1(t, "name") ?? "",
+		nickname: w$1(t, "nickname") ?? null,
+		paramType: w$1(t, "paramType") ?? "",
+		id: w$1(t, "id") ?? ""
+	};
+}
+async function M(t, e) {
+	let r = w(t, []), n = {};
+	if (r.algo && (n.algo = r.algo), r.pointer && (n.pointer = r.pointer), !n.algo && !n.pointer) throw new p("Definition must resolve to either a URL pointer or base64 algo", l.INVALID_INPUT, { context: { definition: t } });
+	let s = await Ee$1("io", n, e);
+	if (!s || typeof s != "object") throw new p("Invalid IO response structure", l.INVALID_INPUT, { context: {
+		response: s,
+		definition: t
+	} });
+	let o = Le(w$1(s, "warnings")), i = Le(w$1(s, "errors")), a = w$1(s, "inputs"), u = w$1(s, "outputs");
+	return {
+		inputs: Array.isArray(a) ? a.map(Me) : [],
+		outputs: Array.isArray(u) ? u.map(Fe) : [],
+		...o && { loadWarnings: o },
+		...i && { loadErrors: i }
+	};
+}
+function Le(t) {
+	if (!Array.isArray(t)) return;
+	let e = t.map(mt).filter((r) => r !== void 0);
+	return e.length > 0 ? e : void 0;
+}
+function mt(t) {
+	if (t == null) return;
+	let e;
+	if (typeof t == "string") e = t;
+	else if (typeof t == "object") {
+		let r = w$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 $(t, e) {
+	x("fetchParsedDefinitionIO", e.suppressBrowserWarning ?? e.suppressClientSideWarning);
+	let { inputs: r, outputs: n, loadWarnings: s, loadErrors: o } = await M(t, e), { inputs: i, parseErrors: a } = Oe(r);
+	return {
+		inputs: i,
+		outputs: n,
+		...a.length > 0 && { parseErrors: a },
+		...s && { loadWarnings: s },
+		...o && { loadErrors: o }
+	};
+}
+var X = class t {
+	constructor(e) {
+		y(this, "innerTree");
+		y(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 && C(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 f = e.slice(), c = f.findIndex((d) => d.getParamName() === r);
+			return c !== -1 ? f[c] = o : f.push(o), f;
+		}
+		let i = e.slice(), a = o.toComputeFormat(), u = i.findIndex((f) => f.ParamName === r);
+		return u !== -1 ? i[u] = a : i.push(a), i;
+	}
+	static buildFromValue(e, r) {
+		let n = new t(e);
+		return C(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(K);
+		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 && (m().warn(`${s}: ${e} below min ${r}, clamping`), o = r), n != null && o > n && (m().warn(`${s}: ${e} above max ${n}, clamping`), o = n), o;
+	}
+};
+
+export { L, O, X, dt as d, le as l };
+//# sourceMappingURL=chunk-RFFCVRKM.js-Bw_Hh4Hk.js.map