@selvajs/selva 4.7.0-beta.2 → 4.7.0-beta.3

package/build/server/chunks/chunks/chunk-3SEQKFGD.js-hLBC6n0U.js

@@ -0,0 +1,1502 @@
+import { p, l, m, h, A as A$1, K as K$1, r as rt$1, w as w$1, E as Ee$1, o as oe, n as ne, P as Pe$1, x as xe$1, N as N$1, S as Se$1 } from './chunk-Y3M7P3BW.js-qwxSY5dh.js';
+
+//#region ../compute/dist/chunk-3SEQKFGD.js
+var se = /* @__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 D(t, e) {
+	e || Ve() && !se.has(t) && (se.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 Le = "Unable to load grasshopper definition";
+function We(t) {
+	return t instanceof p ? t.code === l.DEFINITION_NOT_CACHED || t.message.includes(Le) : false;
+}
+function Be(t, e) {
+	if (!e) return;
+	let r = w$1(t, "values");
+	if (!Array.isArray(r) || r.length === 0) return;
+	let n = [];
+	for (let s of r) {
+		let i = w$1(s, "innerTree");
+		(!i || Object.keys(i).length === 0) && n.push(w$1(s, "paramName") ?? "<unnamed>");
+	}
+	if (n.length === 0) return;
+	let o = n.length === r.length ? "all" : `${n.length}/${r.length}`;
+	m().warn(`Solve returned empty output(s) (${o}): ${n.join(", ")}. These parameters produced no data \u2014 check the definition's inputs and the branch feeding each.`);
+}
+async function E(t, e, r) {
+	D("solveGrasshopperDefinition", r.suppressBrowserWarning ?? r.suppressClientSideWarning);
+	let { response: o } = await N(v(await z(e), t), r);
+	return o;
+}
+async function ie(t, e, r) {
+	D("solveGrasshopperDefinitionWithCacheKey", r.suppressBrowserWarning ?? r.suppressClientSideWarning);
+	return N(v(await z(e), t), r);
+}
+async function ae(t, e, r, n) {
+	D("solveByCacheKey", n.suppressBrowserWarning ?? n.suppressClientSideWarning);
+	let o = {
+		algo: null,
+		pointer: e,
+		values: t
+	};
+	try {
+		return {
+			...await N(o, n),
+			missed: !1
+		};
+	} catch (s) {
+		if (!We(s)) throw s;
+		return {
+			...await N(v(await z(r), t), n),
+			missed: true
+		};
+	}
+}
+async function z(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 N(t, e) {
+	je(t, e);
+	let r = await Ee$1("grasshopper", t, e), { pointer: n, algo: o, ...s } = r, i = s, a = oe(r);
+	if (a !== void 0) {
+		let u = typeof o == "string" ? o.length : 0;
+		N$1(i, Math.max(0, a - u));
+	}
+	return Be(i, e.debug), {
+		response: i,
+		cacheKey: typeof n == "string" ? n : null
+	};
+}
+function v(t, e) {
+	let r = {
+		algo: null,
+		pointer: null,
+		values: e
+	};
+	return t instanceof Uint8Array ? r.algo = ne(t) : /^https?:\/\//i.test(t) ? r.pointer = t : r.algo = Pe$1(t) ?? xe$1(t), r;
+}
+function je(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 $(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":"${le(n)}"}`;
+		if (Array.isArray(n)) {
+			if (e.has(n)) return "\"[Circular]\"";
+			e.add(n);
+			let o = [];
+			for (let s = 0; s < n.length; s++) o.push(r(n[s]));
+			return e.delete(n), `[${o.join(",")}]`;
+		}
+		if (typeof n == "object") {
+			if (e.has(n)) return "\"[Circular]\"";
+			e.add(n);
+			let o;
+			return typeof n.toJSON == "function" ? o = r(n.toJSON()) : n instanceof Map ? o = `{"__map":[${[...n.entries()].map(([i, a]) => `[${r(i)},${r(a)}]`).sort().join(",")}]}` : n instanceof Set ? o = `{"__set":[${[...n.values()].map(r).sort().join(",")}]}` : o = `{${Object.keys(n).sort().map((a) => `${JSON.stringify(a)}:${r(n[a])}`).join(",")}}`, e.delete(n), o;
+		}
+		return "null";
+	};
+	return r(t);
+}
+function ue(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 pe(t) {
+	return ue(t.length, (e) => t.charCodeAt(e));
+}
+function le(t) {
+	return ue(t.length, (e) => t[e]);
+}
+function q(t, e) {
+	let r = $(e);
+	return `${t}|t:${r.length}:${pe(r)}`;
+}
+function R(t) {
+	return T(t) ? `r:${t.key}` : typeof t == "string" ? `s:${t.length}:${pe(t)}` : `u8:${t.length}:${le(t)}`;
+}
+var ze = 100;
+function $e(t) {
+	return typeof t != "string" ? true : !/^https?:\/\//i.test(t);
+}
+function qe(t) {
+	try {
+		return JSON.stringify(t)?.length ?? 0;
+	} catch {
+		return 0;
+	}
+}
+var x = class {
+	constructor(e, r, n = {}, o) {
+		h(this, "executor");
+		h(this, "baseConfig");
+		h(this, "mode");
+		h(this, "maxConcurrent");
+		h(this, "maxQueueDepth");
+		h(this, "queueWaitMs");
+		h(this, "timeoutMs");
+		h(this, "retry");
+		h(this, "cacheEnabled");
+		h(this, "cacheMax");
+		h(this, "cacheMaxBytes");
+		h(this, "cacheTtl");
+		h(this, "cacheErroredSolves");
+		h(this, "cache", /* @__PURE__ */ new Map());
+		h(this, "cacheBytes", 0);
+		h(this, "cacheKeyExecutor");
+		h(this, "reuseServerDefinitionCache");
+		h(this, "serverCacheKeys", /* @__PURE__ */ new Map());
+		h(this, "onStart");
+		h(this, "onSettle");
+		h(this, "onSuperseded");
+		h(this, "subscribers", /* @__PURE__ */ new Set());
+		h(this, "inFlight", /* @__PURE__ */ new Set());
+		h(this, "pendingForLatestWins", null);
+		h(this, "fifoQueue", []);
+		h(this, "_lastResult", null);
+		h(this, "_lastError", null);
+		h(this, "_lastDurationMs", null);
+		h(this, "solveSeq", 0);
+		h(this, "lastStateSeq", 0);
+		h(this, "disposed", false);
+		this.executor = e, this.cacheKeyExecutor = o, 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 s = n.cache;
+		this.cacheEnabled = s !== void 0 && s !== false;
+		let i = typeof s == "object" ? s : {};
+		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 = !!o && (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 o = R(e), s = q(o, r), i = ++this.solveSeq, a = {
+			key: s,
+			enqueuedAt: Date.now(),
+			startedAt: null
+		};
+		if (n?.signal?.aborted) return Promise.reject(this.makeAbortError(a));
+		if (this.cacheEnabled) {
+			let u = this.readCache(s);
+			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: o,
+				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 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 o = 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, o) && this.runHook(this.onSettle, e.ctx, {
+				status: "error",
+				error: o,
+				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 o = () => r.abort();
+		e.externalSignal?.addEventListener("abort", o, { once: true }), this.runHook(this.onStart, e.ctx), this.notify();
+		let s = 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() - s;
+			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() - s, 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", o), this.inFlight.delete(n), this.drainNext(), this.notify();
+		}
+	}
+	async runExecutor(e, r, n, o) {
+		if (!this.cacheKeyExecutor || !this.reuseServerDefinitionCache || !$e(e)) return { response: await this.executor(e, r, o) };
+		let s = n, i = this.serverCacheKeys.get(s) ?? null, a = await this.cacheKeyExecutor(e, r, i, o);
+		if (a.cacheKey) for (this.serverCacheKeys.delete(s), this.serverCacheKeys.set(s, 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(s);
+		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), null) : (this.cache.delete(e), this.cache.set(e, r), r.response) : null;
+	}
+	writeCache(e, r) {
+		if (!this.cacheEnabled || !this.cacheErroredSolves && r.errors && r.errors.length > 0) return;
+		let n = oe(r) ?? qe(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 o = this.cache.keys().next().value;
+			if (o === void 0) break;
+			this.dropCacheEntry(o);
+		}
+	}
+	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
+		};
+	}
+	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 fe(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, o = w$1(e, "innerTree");
+		if (o && typeof o == "object") {
+			for (let s of Object.values(o)) if (Array.isArray(s)) {
+				r += s.length;
+				for (let i of s) {
+					let a = i?.data;
+					typeof a == "string" && (n += a.length);
+				}
+			}
+		}
+		return {
+			param: w$1(e, "paramName") ?? "<unnamed>",
+			items: r,
+			bytes: n
+		};
+	}) : [];
+}
+var A = class t {
+	constructor(e) {
+		h(this, "config");
+		h(this, "serverStats");
+		h(this, "disposed", false);
+		this.config = this.normalizeComputeConfig(e), this.serverStats = new A$1(this.config.serverUrl, this.config.apiKey);
+	}
+	static async create(e) {
+		let r = new t(e), n = Math.max(1, (e.retry?.attempts ?? 2) + 1), o = e.retry?.baseDelayMs ?? 250, s = 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(o * 2 ** i, s);
+				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(), G(e, this.config);
+	}
+	async getRawIO(e) {
+		return this.ensureNotDisposed(), P(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 s = await E(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 (s?.errors && s.errors.length > 0) throw new p(s.errors.join("; ") || "Computation failed", l.COMPUTATION_ERROR, { context: {
+				definition: fe(e),
+				inputSummary: me(r),
+				errors: s.errors,
+				warnings: s.warnings,
+				values: s.values
+			} });
+			return s;
+		} catch (o) {
+			throw this.config.debug && m().error("Compute failed:", o), o instanceof p ? o : new p(o instanceof Error ? o.message : String(o), l.COMPUTATION_ERROR, {
+				context: {
+					definition: fe(e),
+					inputSummary: me(r)
+				},
+				originalError: o instanceof Error ? o : new Error(String(o))
+			});
+		}
+	}
+	createScheduler(e) {
+		this.ensureNotDisposed();
+		let r = (o, s, i) => E(s, o, i), n = (o, s, i, a) => i === null ? ie(s, o, a).then((u) => ({
+			...u,
+			missed: false
+		})) : ae(s, i, o, a);
+		return new x(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: K$1(e.serverUrl),
+			apiKey: e.apiKey,
+			authToken: e.authToken,
+			debug: e.debug ?? false,
+			suppressBrowserWarning: e.suppressBrowserWarning ?? e.suppressClientSideWarning
+		};
+	}
+};
+var V = /* @__PURE__ */ new Map();
+function he(t, e) {
+	V.set(t, e);
+}
+he("Rhino.Geometry.Point3d", (t, e) => {
+	let r = e;
+	return !r || typeof r.X != "number" ? null : new t.Point([
+		r.X,
+		r.Y,
+		r.Z
+	]);
+});
+he("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 Ue(t) {
+	if (V.has(t)) return V.get(t);
+	for (let [e, r] of V) if (t.startsWith(e)) return r;
+}
+function _e(t) {
+	return !!(t && typeof t == "object" && typeof t.data == "string");
+}
+function de(t, e) {
+	return {
+		__decodeError: true,
+		type: t,
+		raw: e
+	};
+}
+function ye(t, e, r) {
+	let n = Ue(e), o = false;
+	if (n) try {
+		let s = n(r, t);
+		if (s != null) return s;
+	} catch (s) {
+		m().warn(`Failed to decode Rhino type ${e}:`, s), o = true;
+	}
+	try {
+		if (_e(t)) return r.CommonObject.decode(t);
+	} catch (s) {
+		return m().warn(`Failed to decode ${e} with CommonObject:`, s), de(e, t);
+	}
+	return o ? de(e, t) : t;
+}
+function ge(t) {
+	let e = /* @__PURE__ */ new WeakSet(), r = (n) => {
+		if (!n || typeof n != "object" || e.has(n)) return;
+		e.add(n);
+		let o = n.delete;
+		if (typeof o == "function") {
+			let i = n.isDeleted;
+			(typeof i != "function" || !i.call(n)) && o.call(n);
+			return;
+		}
+		if (Array.isArray(n)) {
+			for (let i of n) r(i);
+			return;
+		}
+		let s = Object.getPrototypeOf(n);
+		if (s === Object.prototype || s === 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 Ke = "Rhino.Geometry.";
+var Qe = ["WebDisplay"];
+var He = "FileData";
+function be(t) {
+	return Qe.some((e) => t.includes(e));
+}
+function Je(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 Ye(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(Ke) ? ye(t, e, r) : t;
+	}
+}
+var U = /* @__PURE__ */ new WeakMap();
+function Te(t) {
+	if (U.has(t)) return U.get(t);
+	let e = Je(t.data);
+	return U.set(t, e), e;
+}
+function Se(t, e, r, n) {
+	if (typeof t.data != "string") return t.data;
+	return Ye(r ? Te(t) : t.data, e, n);
+}
+function Xe(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 _(t) {
+	let e = w$1(t, "values");
+	return Array.isArray(e) ? e : [];
+}
+function K(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 De(t, e = false, r = {}) {
+	let { parseValues: n = true, rhino: o, stringOnly: s = false } = r, i = {}, a = /* @__PURE__ */ new Set();
+	for (let u of _(t)) {
+		let m = w$1(u, "paramName");
+		Q(w$1(u, "innerTree"), (f) => {
+			let d = K(f);
+			if (be(d) || s && d !== I.STRING) return;
+			let g = e ? f.id : m;
+			if (!g) return;
+			let b = Se(f, d, n, o);
+			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: () => ge(i)
+	};
+}
+function xe(t) {
+	let e = [];
+	for (let r of _(t)) Q(w$1(r, "innerTree"), (n) => {
+		if (!K(n).includes(He)) return;
+		let o = Te(n);
+		Xe(o) && e.push(o);
+	});
+	return e;
+}
+function Ie(t, e, r = {}) {
+	let { parseValues: n = true, rhino: o, stringOnly: s = false } = r;
+	for (let i of _(t)) {
+		let a = w$1(i, "innerTree"), u = false;
+		if ("byName" in e) {
+			if (w$1(i, "paramName") !== e.byName) continue;
+			u = true;
+		}
+		let m = [];
+		if (Q(a, (f) => {
+			if ("byId" in e) {
+				if (f.id !== e.byId) return;
+				u = true;
+			}
+			let d = K(f);
+			be(d) || s && d !== I.STRING || m.push(Se(f, d, n, o));
+		}), u) return m.length === 0 ? void 0 : m.length === 1 ? m[0] : m;
+	}
+}
+var k = class {
+	constructor(e, r = false) {
+		h(this, "response", e);
+		h(this, "debug", r);
+	}
+	getValues(e = false, r = {}) {
+		return De(this.response, e, r);
+	}
+	getValue(e, r) {
+		return Ie(this.response, e, r);
+	}
+	async extractMeshesFromResponse(e) {
+		let r = {
+			debug: this.debug,
+			...e
+		}, n;
+		try {
+			({getThreeMeshesFromComputeResponse: n} = await import('./visualization-5RH6RSLV.js-DfUogATJ.js'));
+		} catch (o) {
+			throw new p("Failed to load three.js visualization module. Ensure three.js is installed as a peer dependency.", l.INVALID_STATE, { context: { originalError: o instanceof Error ? o.message : String(o) } });
+		}
+		return n(this.response, r);
+	}
+	getFileData() {
+		return xe(this.response);
+	}
+	async getAndDownloadFiles(e, r) {
+		await Se$1(this.getFileData(), e, r);
+	}
+};
+var H = /^\{(-?\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]) => H.test(r) && Array.isArray(n));
+}
+function w(t, e, r) {
+	if (t == null) return t;
+	if (Array.isArray(t)) {
+		let o = t.map(e).filter((s) => s !== null);
+		return o.length > 0 ? o : void 0;
+	}
+	let n = e(t);
+	return n !== null ? n : r ? void 0 : t;
+}
+var L = (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 J = (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 Ze = (t) => typeof t == "string" ? t.length >= 2 && t.startsWith("\"") && t.endsWith("\"") ? t.slice(1, -1) : t.startsWith("\"") ? t.slice(1) : t : null;
+var et = (t) => {
+	if (typeof t == "string") {
+		let e = t.trim();
+		return e.startsWith("\"") && e.endsWith("\"") && (e = e.slice(1, -1).trim()), e;
+	}
+	return null;
+};
+function we(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 Ce(t, e, r) {
+	let n = Number(t.toFixed(e));
+	return Math.abs(t - n) < r ? n : t;
+}
+function tt(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), S = Math.pow(10, -b), X = Number(S.toFixed(b));
+			return Math.abs(X - S) < e ? X : S;
+		}
+		return 1;
+	}
+	let n = String(t), o = n.toLowerCase().match(/e(-?\d+)/);
+	if (o) {
+		let d = Number(o[1]);
+		if (d < 0 || n.toLowerCase().includes("e-")) {
+			let g = Math.abs(d), b = Math.pow(10, -g), S = Number(b.toFixed(g));
+			return Math.abs(S - b) < e ? S : b;
+		}
+		return .1;
+	}
+	let s = 12, a = r.toFixed(s).replace(/0+$/, ""), u = Math.min((a.split(".")[1] || "").length, s);
+	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 Ee(t) {
+	return typeof t.stepSize == "number" && Number.isFinite(t.stepSize) && t.stepSize > 0 ? t.stepSize : void 0;
+}
+function rt(t, e = 1e-8) {
+	let r = t.paramType === "Integer", n = Ee(t);
+	if (C(t.default)) return {
+		default: t.default,
+		stepSize: n ?? (r ? 1 : .1)
+	};
+	if (typeof t.default == "string" && t.default.trim() !== "" && L(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 o = w(t.default, L, true);
+	if (r) return Array.isArray(o) ? o = o.map((d) => typeof d == "number" ? Math.round(d) : d) : typeof o == "number" && (o = Math.round(o)), {
+		default: o,
+		stepSize: n ?? 1
+	};
+	let s = Array.isArray(o) ? o[0] : o, i;
+	typeof s == "number" && Number.isFinite(s) && s !== 0 ? i = s : 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 ? tt(i, e) : .1), u = 0, m = String(a), f = m.toLowerCase().match(/e(-?\d+)/);
+	if (f ? u = Math.abs(Number(f[1])) : u = m.split(".")[1]?.length ?? 0, u === 0 && typeof s == "number" && s !== 0 && Math.abs(s) < 1) {
+		let d = Math.ceil(-Math.log10(Math.abs(s)));
+		Number.isFinite(d) && d > 0 && (u = d);
+	}
+	return u = Math.min(Math.max(u, 0), 12), Array.isArray(o) ? o = o.map((d) => typeof d == "number" ? Ce(d, u, e) : d) : typeof o == "number" && (o = Ce(o, u, e)), {
+		default: o,
+		stepSize: a
+	};
+}
+var nt = {
+	types: ["Number", "Integer"],
+	parse(t, e) {
+		let { default: r, stepSize: n } = rt(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: Ee(t) ?? (t.paramType === "Integer" ? 1 : .1),
+			default: r ? [n] : n
+		};
+	}
+};
+var ot = {
+	types: ["Boolean"],
+	parse(t, e) {
+		if (C(t.default)) return {
+			...e,
+			paramType: "Boolean",
+			default: t.default
+		};
+		let r = w(t.default, J, 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 st = {
+	types: ["Text"],
+	parse(t, e) {
+		let r = w(t.default, Ze, false);
+		return {
+			...e,
+			paramType: "Text",
+			default: r
+		};
+	},
+	fallback(t, e) {
+		let r = (t.atMost ?? 1) > 1;
+		return {
+			...e,
+			paramType: "Text",
+			default: r ? [""] : ""
+		};
+	}
+};
+var it = {
+	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(), o = Object.keys(t.values).find((s) => s.toLowerCase() === n);
+			o !== void 0 ? r = o : 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 ve = {
+	types: ["Geometry"],
+	parse(t, e) {
+		let r = w(t.default, we(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([
+	nt,
+	ot,
+	st,
+	it,
+	ve,
+	{
+		types: ["File"],
+		parse(t, e) {
+			let r = w(t.default, we(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 = w(t.default, et, 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 = ve;
+function Ae(t) {
+	return w$1(t, "data");
+}
+function lt(t) {
+	return w$1(t, "type");
+}
+var ct = /* @__PURE__ */ new Set([
+	"System.Double",
+	"System.Single",
+	"System.Decimal",
+	"System.Int32",
+	"System.Int64"
+]);
+var ft = /* @__PURE__ */ new Set(["System.Int32", "System.Int64"]);
+function Pe(t) {
+	if (typeof t.default != "object" || t.default === null) return { schema: t };
+	if (Array.isArray(t.default)) return { schema: t };
+	if (!rt$1(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 = {}, o = [];
+		for (let [i, a] of Object.entries(e)) {
+			if (!Array.isArray(a)) {
+				let m$1 = `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: m$1
+					}
+				};
+			}
+			let u = [];
+			for (let m of a) {
+				let f = Ae(m), d = lt(m);
+				if (d && ct.has(d)) {
+					if (typeof f == "string" && f.trim() === "") continue;
+					let g = L(f);
+					if (g === null) {
+						o.push(`"${String(f)}" (${d})`);
+						continue;
+					}
+					u.push(ft.has(d) ? Math.round(g) : g);
+					continue;
+				}
+				if (d === "System.Boolean") {
+					let g = J(f);
+					if (g === null) {
+						o.push(`"${String(f)}" (${d})`);
+						continue;
+					}
+					u.push(g);
+					continue;
+				}
+				if (typeof f == "string" && d?.startsWith("Rhino.Geometry")) {
+					try {
+						u.push(JSON.parse(f));
+					} catch {
+						u.push(f);
+					}
+					continue;
+				}
+				u.push(f);
+			}
+			n[i] = u;
+		}
+		let s;
+		if (o.length > 0) {
+			let i = `Input "${t.name ?? "unknown"}" default contained ${o.length} tree value(s) that could not be parsed and were dropped: ${o.join(", ")}.`;
+			m().warn(i), s = {
+				code: "MALFORMED_DEFAULT",
+				message: i
+			};
+		}
+		return {
+			schema: {
+				...t,
+				default: n
+			},
+			...s && { warning: s }
+		};
+	}
+	let r = [];
+	for (let n of Object.values(e)) Array.isArray(n) && n.forEach((o) => {
+		o && typeof o == "object" && rt$1(o, "data") && r.push(Ae(o));
+	});
+	return r.length === 0 ? { schema: {
+		...t,
+		default: void 0
+	} } : r.length === 1 ? { schema: {
+		...t,
+		default: r[0]
+	} } : { schema: {
+		...t,
+		default: r
+	} };
+}
+var mt = new Map([...Y.keys()].map((t) => [t.toLowerCase(), t]));
+function dt(t) {
+	return mt.get(t?.toLowerCase()) ?? t;
+}
+function ke(t) {
+	return Oe(t).input;
+}
+function Oe(t) {
+	let e = {
+		description: t.description,
+		name: t.name,
+		nickname: t.nickname,
+		treeAccess: t.treeAccess,
+		groupName: t.groupName ?? void 0,
+		id: t.id
+	}, r = dt(t.paramType), n = {
+		...t,
+		paramType: r
+	}, o;
+	try {
+		let { schema: i, warning: a } = Pe(n);
+		n = i, o = a && {
+			inputName: t.name || "unknown",
+			paramType: t.paramType,
+			message: a.message,
+			code: a.code
+		};
+	} catch (i) {
+		n = {
+			...n,
+			default: null
+		}, o = {
+			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 s = Y.get(r);
+	try {
+		if (!s) throw p.unknownParamType(r, t.name);
+		return {
+			input: s.parse(n, e),
+			error: o,
+			...o && { errors: [o] }
+		};
+	} 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: (s ?? Re).fallback(n, e),
+				error: a,
+				errors: o ? [o, 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 W(t) {
+	let e = [], r = [];
+	for (let n of t) {
+		let { input: o, errors: s } = Oe(n);
+		e.push(o), s && r.push(...s);
+	}
+	return {
+		inputs: e,
+		parseErrors: r
+	};
+}
+function Fe(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 Ne(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 P(t, e) {
+	let r = v(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 o = await Ee$1("io", n, e);
+	if (!o || typeof o != "object") throw new p("Invalid IO response structure", l.INVALID_INPUT, { context: {
+		response: o,
+		definition: t
+	} });
+	let s = Ge(w$1(o, "warnings")), i = Ge(w$1(o, "errors")), a = w$1(o, "inputs"), u = w$1(o, "outputs");
+	return {
+		inputs: Array.isArray(a) ? a.map(Fe) : [],
+		outputs: Array.isArray(u) ? u.map(Ne) : [],
+		...s && { loadWarnings: s },
+		...i && { loadErrors: i }
+	};
+}
+function Ge(t) {
+	if (!Array.isArray(t)) return;
+	let e = t.map(ht).filter((r) => r !== void 0);
+	return e.length > 0 ? e : void 0;
+}
+function ht(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 G(t, e) {
+	D("fetchParsedDefinitionIO", e.suppressBrowserWarning ?? e.suppressClientSideWarning);
+	let { inputs: r, outputs: n, loadWarnings: o, loadErrors: s } = await P(t, e), { inputs: i, parseErrors: a } = W(r);
+	return {
+		inputs: i,
+		outputs: n,
+		...a.length > 0 && { parseErrors: a },
+		...o && { loadWarnings: o },
+		...s && { loadErrors: s }
+	};
+}
+var B = class t {
+	constructor(e) {
+		h(this, "innerTree");
+		h(this, "paramName");
+		this.paramName = e, this.innerTree = {};
+	}
+	append(e, r) {
+		let n = t.formatPathString(e);
+		this.innerTree[n] || (this.innerTree[n] = []);
+		let o = r.map((s) => ({ data: t.serializeValue(s) }));
+		return this.innerTree[n].push(...o), 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 o = t.parsePathString(r);
+			this.append(o, 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((o) => t.deserializeValue(o.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"), o = r.default;
+			if (r.treeAccess && C(o)) n.fromDataTreeDefault(o), t.isNumericInput(r) && n.applyNumericConstraints(r.minimum, r.maximum, r.nickname || "unnamed");
+			else {
+				let s = Array.isArray(o) ? o : [o], i = t.processValues(s, 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 o = e.length > 0 && e[0] instanceof t, s = t.buildFromValue(r, n);
+		if (o) {
+			let m = e.slice(), f = m.findIndex((d) => d.getParamName() === r);
+			return f !== -1 ? m[f] = s : m.push(s), m;
+		}
+		let i = e.slice(), a = s.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 C(r) ? n.fromDataTreeDefault(r) : n.appendFlat(r), n;
+	}
+	static getTreeValue(e, r) {
+		let o = e.length > 0 && e[0] instanceof t ? t.readFromBuilders(e, r) : t.readFromDataTrees(e, r);
+		return o === null || o.length === 0 ? null : o.length === 1 ? o[0] : o;
+	}
+	static readFromBuilders(e, r) {
+		let n = e.find((o) => o.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 o = Object.keys(n.InnerTree)[0];
+		if (!o) return null;
+		let s = n.InnerTree[o];
+		return Array.isArray(s) ? s.map((i) => i?.data !== void 0 ? t.deserializeValue(i.data) : null) : s?.data !== void 0 ? [t.deserializeValue(s.data)] : s !== void 0 ? [s] : null;
+	}
+	static parsePathString(e) {
+		let r = e.match(H);
+		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 o of Object.values(this.innerTree)) if (Array.isArray(o)) for (let s of o) {
+			let i = t.deserializeValue(s.data);
+			if (typeof i == "number") {
+				let a = t.clampValue(i, e, r, n);
+				s.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, o) {
+		let s = e;
+		return r != null && s < r && (m().warn(`${o}: ${e} below min ${r}, clamping`), s = r), n != null && s > n && (m().warn(`${o}: ${e} above max ${n}, clamping`), s = n), s;
+	}
+};
+
+export { $, A, B, k as a, ke as k };
+//# sourceMappingURL=chunk-3SEQKFGD.js-hLBC6n0U.js.map