@selvajs/selva 4.7.2 → 4.7.4-beta.0

package/build/server/chunks/chunks/chunk-XT3XWDDV.js-CgVdm1U0.js

@@ -0,0 +1,976 @@
+//#region ../compute/dist/chunk-XT3XWDDV.js
+var ae = Object.defineProperty;
+var ue = (t, e, r) => e in t ? ae(t, e, {
+	enumerable: true,
+	configurable: true,
+	writable: true,
+	value: r
+}) : t[e] = r;
+var y = (t, e, r) => ue(t, typeof e != "symbol" ? e + "" : e, r);
+var l = {
+	NETWORK_ERROR: "NETWORK_ERROR",
+	AUTH_ERROR: "AUTH_ERROR",
+	VALIDATION_ERROR: "VALIDATION_ERROR",
+	COMPUTATION_ERROR: "COMPUTATION_ERROR",
+	TIMEOUT_ERROR: "TIMEOUT_ERROR",
+	CORS_ERROR: "CORS_ERROR",
+	NOT_FOUND: "NOT_FOUND",
+	RATE_LIMIT: "RATE_LIMIT",
+	INVALID_RESPONSE: "INVALID_RESPONSE",
+	UNKNOWN_ERROR: "UNKNOWN_ERROR",
+	INVALID_STATE: "INVALID_STATE",
+	INVALID_INPUT: "INVALID_INPUT",
+	INVALID_CONFIG: "INVALID_CONFIG",
+	BROWSER_ONLY: "BROWSER_ONLY",
+	ENVIRONMENT_ERROR: "ENVIRONMENT_ERROR",
+	ENCODING_ERROR: "ENCODING_ERROR",
+	MALFORMED_DEFAULT: "MALFORMED_DEFAULT",
+	SUPERSEDED: "SUPERSEDED",
+	ABORTED: "ABORTED",
+	QUEUE_FULL: "QUEUE_FULL",
+	QUEUE_TIMEOUT: "QUEUE_TIMEOUT",
+	DEFINITION_NOT_CACHED: "DEFINITION_NOT_CACHED"
+};
+var p = class t extends Error {
+	constructor(r, n = l.UNKNOWN_ERROR, o) {
+		super(r);
+		y(this, "code");
+		y(this, "statusCode");
+		y(this, "context");
+		y(this, "originalError");
+		this.name = "RhinoComputeError", this.code = n, this.statusCode = o?.statusCode, this.context = o?.context, this.originalError = o?.originalError, o?.originalError && (this.cause = o.originalError);
+	}
+	static missingValues(r, n, o) {
+		return new t(`Input "${r}" has no values defined${n ? ` (expected ${n})` : ""}`, l.INVALID_INPUT, { context: {
+			inputName: r,
+			expectedType: n,
+			...o
+		} });
+	}
+	static unknownParamType(r, n, o) {
+		return new t(`Unknown paramType: ${r}`, l.VALIDATION_ERROR, { context: {
+			receivedParamType: r,
+			paramName: n,
+			...o
+		} });
+	}
+};
+function C() {
+	let t = globalThis.Buffer;
+	return typeof t == "function" ? t : void 0;
+}
+function De(t) {
+	let e = C();
+	return e ? e.from(t, "utf-8").toString("base64") : de(new TextEncoder().encode(t));
+}
+var le = 64;
+var ce = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function Me(t) {
+	if (!t) return null;
+	let e = t.replace(/[\t\n\f\r ]/g, "");
+	e.length % 4 === 0 && (e = e.replace(/={1,2}$/, ""));
+	let r = e.length % 4;
+	if (r === 1 || e.length < le || !/^[A-Za-z0-9+/]*$/.test(e)) return null;
+	let n = ce.indexOf(e.charAt(e.length - 1));
+	return r === 2 && (n & 15) !== 0 || r === 3 && (n & 3) !== 0 ? null : r === 0 ? e : e + "==".slice(0, 4 - r);
+}
+function _(t) {
+	let e = t.replace(/[\t\n\f\r ]/g, "");
+	if (e.length % 4 === 0 && (e = e.replace(/={1,2}$/, "")), e.length % 4 === 1 || !/^[A-Za-z0-9+/]*$/.test(e)) throw new p("Invalid base64 input.", l.ENCODING_ERROR, { context: { inputLength: t.length } });
+	let r = C();
+	if (r) return new Uint8Array(r.from(e, "base64"));
+	if (typeof globalThis.atob == "function") {
+		let n = globalThis.atob(e), o = new Uint8Array(n.length);
+		for (let s = 0; s < n.length; s++) o[s] = n.charCodeAt(s) & 255;
+		return o;
+	}
+	throw new p("Base64 decoding not supported in this environment.", l.INVALID_STATE, { context: { environmentInfo: "atob or Buffer not available" } });
+}
+function P(t) {
+	let e = C();
+	if (e) return e.byteLength(t, "utf-8");
+	let r = 0;
+	for (let n = 0; n < t.length; n++) {
+		let o = t.charCodeAt(n);
+		o < 128 ? r += 1 : o < 2048 ? r += 2 : o >= 55296 && o <= 56319 && n + 1 < t.length && (t.charCodeAt(n + 1) & 64512) === 56320 ? (r += 4, n++) : r += 3;
+	}
+	return r;
+}
+function de(t) {
+	let e = C();
+	if (e) return e.from(t).toString("base64");
+	if (typeof globalThis.btoa == "function") {
+		let n = [];
+		for (let o = 0; o < t.length; o += 32766) n.push(globalThis.btoa(String.fromCharCode.apply(null, t.subarray(o, o + 32766))));
+		return n.join("");
+	}
+	throw new p("Base64 encoding not supported in this environment.", l.INVALID_STATE, { context: { environmentInfo: "btoa or Buffer not available" } });
+}
+var I = class {
+	debug() {}
+	info() {}
+	warn() {}
+	error() {}
+};
+var U = class {
+	debug(e, ...r) {
+		console.debug(e, ...r);
+	}
+	info(e, ...r) {
+		console.info(e, ...r);
+	}
+	warn(e, ...r) {
+		console.warn(e, ...r);
+	}
+	error(e, ...r) {
+		console.error(e, ...r);
+	}
+};
+var L = new I();
+function m() {
+	return L;
+}
+function B(t) {
+	if (t === null) {
+		L = new I();
+		return;
+	}
+	let e = [
+		"debug",
+		"info",
+		"warn",
+		"error"
+	].filter((r) => typeof t[r] != "function");
+	if (e.length > 0) throw new p(`Logger is missing required method(s): ${e.join(", ")}. A logger must implement debug, info, warn and error.`, l.INVALID_CONFIG, { context: { missingMethods: e } });
+	L = t;
+}
+function fe() {
+	B(new U());
+}
+function h(t, e) {
+	e && m().debug(t);
+}
+function W(t, e) {
+	return `${e.replace(/\/+$/, "")}/${t.replace(/^\/+/, "")}`;
+}
+function pe(t) {
+	try {
+		let e = new URL(t).hostname.toLowerCase();
+		return e === "localhost" || e === "127.0.0.1" || e === "[::1]";
+	} catch {
+		return /(localhost|127\.0\.0\.1|\[::1\])/i.test(t);
+	}
+}
+var q = /* @__PURE__ */ new Set();
+function z(t, e) {
+	let r = {
+		...e.headers,
+		"X-Request-ID": t,
+		"Content-Type": "application/json",
+		...e.authToken && { Authorization: e.authToken },
+		...e.apiKey && { RhinoComputeKey: e.apiKey }
+	};
+	return !e.apiKey && !e.authToken && !q.has(e.serverUrl) && !pe(e.serverUrl) && (q.add(e.serverUrl), m().warn(`\u26A0\uFE0F [Rhino Compute] Request [${t}] targets remote server (${e.serverUrl}) but no API key or auth token is configured. Requests may fail or be rate-limited. (warned once per server)`)), r;
+}
+function K() {
+	return `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+}
+function me(t) {
+	if (!t) return null;
+	let e = { raw: t }, r = false;
+	for (let n of t.split(",")) {
+		let [o, ...s] = n.trim().split(";"), c = s.find((d) => d.trim().toLowerCase().startsWith("dur"));
+		if (!c) continue;
+		let i = Number(c.split("=")[1]);
+		if (!Number.isFinite(i)) continue;
+		let a = o.trim().toLowerCase();
+		(a === "decode" || a === "solve" || a === "encode") && (e[a] = i, r = true);
+	}
+	return r ? e : null;
+}
+function x(t, e, r, n) {
+	if (!r) return;
+	let o = me(t.headers.get("Server-Timing"));
+	if (o) try {
+		r(o, e);
+	} catch (s) {
+		n && h(`   onServerTiming callback threw: ${s}`, true);
+	}
+}
+var V = /* @__PURE__ */ new WeakMap();
+function N(t, e) {
+	typeof t != "object" || t === null || V.set(t, e);
+}
+function ge(t) {
+	if (!(typeof t != "object" || t === null)) return V.get(t);
+}
+var D = 4096;
+function he(t) {
+	return t.length <= D ? t : `${t.slice(0, D)}\u2026 [truncated ${t.length - D} chars]`;
+}
+function ye(t, e, r, n, o, s, c, i) {
+	let { status: a, statusText: d } = t, u = {};
+	t.headers.forEach((se, ie) => {
+		u[ie] = se;
+	});
+	let g = s.trim(), f = g ? ` \u2014 ${g.slice(0, 200)}${g.length > 200 ? "…" : ""}` : "", E = i ?? s, S = {
+		url: e,
+		requestId: r,
+		method: "POST",
+		requestSize: n,
+		serverUrl: o,
+		responseBody: E ? he(E) : void 0,
+		responseHeaders: u
+	}, b = {
+		401: {
+			message: `HTTP ${a}: ${d}${f}`,
+			code: l.AUTH_ERROR
+		},
+		403: {
+			message: `HTTP ${a}: ${d}${f}`,
+			code: l.AUTH_ERROR
+		},
+		404: {
+			message: `Endpoint not found: ${e}`,
+			code: l.NOT_FOUND
+		},
+		413: {
+			message: `Request too large: ${(n / 1024).toFixed(2)}KB`,
+			code: l.VALIDATION_ERROR
+		},
+		429: {
+			message: `Rate limit exceeded${f}`,
+			code: l.RATE_LIMIT
+		},
+		500: {
+			message: `Server error: ${d}${f}`,
+			code: l.COMPUTATION_ERROR
+		},
+		502: {
+			message: `Service unavailable: ${d}${f}`,
+			code: l.NETWORK_ERROR
+		},
+		503: {
+			message: `Service unavailable: ${d}${f}`,
+			code: l.NETWORK_ERROR
+		},
+		504: {
+			message: `Service unavailable: ${d}${f}`,
+			code: l.NETWORK_ERROR
+		}
+	}[a] || {
+		message: `HTTP ${a}: ${d}${f}`,
+		code: l.UNKNOWN_ERROR
+	}, k = Re(c) ?? b.code;
+	throw new p(b.message, k, {
+		statusCode: a,
+		context: S
+	});
+}
+function Re(t) {
+	if (t === "definition_not_cached") return l.DEFINITION_NOT_CACHED;
+}
+async function H(t, e, r, n, o, s, c, i) {
+	let a = Math.round(performance.now() - s);
+	if (!t.ok) {
+		let d = await t.text(), u = d;
+		c && (h(`\u274C Request [${r}] failed with HTTP ${t.status} in ${a}ms`, true), h(`   URL: ${e}`, true), h(`   Status: ${t.status} ${t.statusText}`, true), u && h(`   Response body: ${u.substring(0, 500)}${u.length > 500 ? "..." : ""}`, true));
+		let g;
+		try {
+			let f = JSON.parse(u);
+			typeof f?.code == "string" && (g = f.code);
+		} catch {}
+		if (t.status === 500) try {
+			let f = JSON.parse(u);
+			if (f?.values && (f.errors || f.warnings)) return N(f, u.length), c && (h(`\u26A0\uFE0F Request [${r}] completed with Grasshopper errors in ${a}ms`, !0), f.errors?.length > 0 && h(`   Errors: ${JSON.stringify(f.errors, null, 2)}`, !0), f.warnings?.length > 0 && h(`   Warnings: ${JSON.stringify(f.warnings, null, 2)}`, !0)), x(t, r, i, c), f;
+			let E = typeof f?.message == "string" && f.message || typeof f?.Message == "string" && f.Message || "", S = typeof f?.ExceptionType == "string" && f.ExceptionType || "", O = f?.stackTrace ?? f?.StackTrace, b = Array.isArray(O) ? O.join(`
+`) : O || "";
+			E ? u = `${S ? `${S}: ` : ""}${E}${b ? `
+${b}` : ""}` : f?.error && (u = typeof f.error == "string" ? f.error : JSON.stringify(f.error, null, 2));
+		} catch (f) {
+			c && h(`   Failed to parse error body as JSON: ${f}`, true);
+		}
+		ye(t, e, r, n, o, u, g, d);
+	}
+	h(`\u2705 Request [${r}] completed in ${a}ms`, c), x(t, r, i, c);
+	try {
+		let d = await t.text(), u = JSON.parse(d);
+		return N(u, d.length), u;
+	} catch (d) {
+		let u = (t.headers.get("Content-Type") ?? "").toLowerCase();
+		throw u !== "" && !u.includes("json") ? new p(`Server returned a non-JSON response (Content-Type: ${u}) \u2014 check the server URL / proxy configuration`, l.INVALID_RESPONSE, {
+			statusCode: t.status,
+			context: {
+				url: e,
+				requestId: r,
+				contentType: u
+			},
+			originalError: d instanceof Error ? d : new Error(String(d))
+		}) : new p("Failed to parse JSON response", l.NETWORK_ERROR, {
+			statusCode: t.status,
+			context: {
+				url: e,
+				requestId: r
+			},
+			originalError: d instanceof Error ? d : new Error(String(d))
+		});
+	}
+}
+var T = {
+	attempts: 0,
+	baseDelayMs: 500,
+	maxDelayMs: 3e4,
+	retryOn429: true
+};
+var M = /* @__PURE__ */ new Set([
+	502,
+	503,
+	504
+]);
+var J = 6e4;
+function j(t) {
+	return t ? {
+		attempts: t.attempts ?? T.attempts,
+		baseDelayMs: t.baseDelayMs ?? T.baseDelayMs,
+		maxDelayMs: t.maxDelayMs ?? T.maxDelayMs,
+		retryOn429: t.retryOn429 ?? T.retryOn429
+	} : T;
+}
+function G(t) {
+	if (!t) return null;
+	let e = Number(t);
+	if (Number.isFinite(e) && e >= 0) return e * 1e3;
+	let r = Date.parse(t);
+	if (Number.isFinite(r)) {
+		let n = r - Date.now();
+		return n > 0 ? n : 0;
+	}
+	return null;
+}
+function v(t, e) {
+	let r = e.baseDelayMs * Math.pow(2, t), n = Math.random() * e.baseDelayMs;
+	return Math.min(r + n, e.maxDelayMs);
+}
+function Y(t, e) {
+	return new Promise((r, n) => {
+		if (e?.aborted) {
+			n(new DOMException("Aborted", "AbortError"));
+			return;
+		}
+		let o = setTimeout(() => {
+			e?.removeEventListener("abort", s), r();
+		}, t), s = () => {
+			clearTimeout(o), n(new DOMException("Aborted", "AbortError"));
+		};
+		e?.addEventListener("abort", s, { once: true });
+	});
+}
+function Z(t, e) {
+	let r = () => {}, n = typeof e == "number" && e > 0;
+	if (!t && !n) return {
+		signal: void 0,
+		cleanup: r
+	};
+	if (t && !n) return {
+		signal: t,
+		cleanup: r
+	};
+	let o = typeof AbortSignal < "u" && typeof AbortSignal.timeout == "function";
+	if (!t) {
+		if (o) return {
+			signal: AbortSignal.timeout(e),
+			cleanup: r
+		};
+		let u = new AbortController(), g = setTimeout(() => u.abort(), e);
+		return {
+			signal: u.signal,
+			cleanup: () => clearTimeout(g)
+		};
+	}
+	let s = new AbortController(), c, i;
+	if (o) c = AbortSignal.timeout(e);
+	else {
+		let u = new AbortController();
+		i = setTimeout(() => u.abort(), e), c = u.signal;
+	}
+	let a = [t, c], d = function() {
+		s.abort(this.reason);
+	};
+	for (let u of a) {
+		if (u.aborted) {
+			s.abort(u.reason);
+			break;
+		}
+		u.addEventListener("abort", d, { once: true });
+	}
+	return {
+		signal: s.signal,
+		cleanup: () => {
+			i !== void 0 && clearTimeout(i);
+			for (let u of a) u.removeEventListener("abort", d);
+		}
+	};
+}
+async function we(t, e, r, n) {
+	let { signal: o, cleanup: s } = Z(t.config.signal, t.config.timeoutMs), c = performance.now();
+	try {
+		let i = await fetch(t.fullUrl, {
+			method: "POST",
+			body: t.body,
+			headers: t.headers,
+			signal: o
+		});
+		if ((M.has(i.status) || e.retryOn429 && i.status === 429) && r < n - 1) {
+			let u = G(i.headers.get("Retry-After")), g = u !== null ? Math.min(u, Math.max(e.maxDelayMs, J)) : v(r, e);
+			return await i.text().catch(() => {}), {
+				ok: !1,
+				retry: !0,
+				delayMs: g,
+				cause: new p(`HTTP ${i.status} ${i.statusText} (will retry)`, i.status === 429 ? l.RATE_LIMIT : l.NETWORK_ERROR, {
+					statusCode: i.status,
+					context: { requestId: t.requestId }
+				})
+			};
+		}
+		return {
+			ok: !0,
+			value: await H(i, t.fullUrl, t.requestId, t.requestSize, t.config.serverUrl, c, t.config.debug, t.config.onServerTiming)
+		};
+	} catch (i) {
+		if (i instanceof Error && (i.name === "AbortError" || i.name === "TimeoutError")) {
+			if (t.config.signal?.aborted === true) return {
+				ok: false,
+				retry: false,
+				cause: new p("Request aborted by caller", l.ABORTED, {
+					context: {
+						endpoint: t.endpoint,
+						requestId: t.requestId,
+						requestSize: t.requestSize
+					},
+					originalError: i
+				})
+			};
+			let u = typeof t.config.timeoutMs == "number" && t.config.timeoutMs > 0 ? new p(`Request timed out after ${t.config.timeoutMs}ms`, l.TIMEOUT_ERROR, {
+				context: {
+					serverUrl: t.config.serverUrl,
+					timeoutMs: t.config.timeoutMs,
+					url: t.fullUrl,
+					requestId: t.requestId,
+					endpoint: t.endpoint,
+					requestSize: t.requestSize
+				},
+				originalError: i
+			}) : new p(`Request aborted by the runtime (${i.name}): ${i.message}`, l.NETWORK_ERROR, {
+				context: {
+					serverUrl: t.config.serverUrl,
+					url: t.fullUrl,
+					requestId: t.requestId,
+					endpoint: t.endpoint,
+					requestSize: t.requestSize
+				},
+				originalError: i
+			});
+			return r < n - 1 ? {
+				ok: false,
+				retry: true,
+				delayMs: v(r, e),
+				cause: u
+			} : {
+				ok: false,
+				retry: false,
+				cause: u
+			};
+		}
+		if (i instanceof TypeError) {
+			let a = typeof window < "u" && typeof window.document < "u", d = {
+				serverUrl: t.config.serverUrl,
+				url: t.fullUrl,
+				requestId: t.requestId,
+				endpoint: t.endpoint,
+				requestSize: t.requestSize
+			}, u = a ? new p(`Request failed: ${i.message} \u2014 in a browser this usually means a CORS misconfiguration on the server (or a network failure; the browser does not distinguish them)`, l.CORS_ERROR, {
+				context: d,
+				originalError: i
+			}) : new p(`Network error: ${i.message}`, l.NETWORK_ERROR, {
+				context: d,
+				originalError: i
+			});
+			return r < n - 1 ? {
+				ok: false,
+				retry: true,
+				delayMs: v(r, e),
+				cause: u
+			} : {
+				ok: false,
+				retry: false,
+				cause: u
+			};
+		}
+		if (i instanceof p) {
+			let a = i.statusCode;
+			return (i.code === l.NETWORK_ERROR && a !== void 0 && a >= 200 && a < 300 || a !== void 0 && (M.has(a) || e.retryOn429 && a === 429)) && r < n - 1 ? {
+				ok: false,
+				retry: true,
+				delayMs: v(r, e),
+				cause: i
+			} : {
+				ok: false,
+				retry: false,
+				cause: i
+			};
+		}
+		return {
+			ok: false,
+			retry: false,
+			cause: new p(i instanceof Error ? i.message : String(i), l.UNKNOWN_ERROR, {
+				context: {
+					endpoint: t.endpoint,
+					requestId: t.requestId
+				},
+				originalError: i instanceof Error ? i : new Error(String(i))
+			})
+		};
+	} finally {
+		s();
+	}
+}
+async function Ee(t, e, r) {
+	let n = K(), o = JSON.stringify(e), s = P(o), c = W(t, r.serverUrl), i = z(n, r), a = j(r.retry), d = a.attempts + 1;
+	if (r.debug) {
+		let g = (s / 1024).toFixed(2);
+		h(`${s > 1e5 ? "⚠️" : "🚀"} Starting compute request [${n}]: ${t} (${g}KB)`, true);
+	}
+	let u = {
+		endpoint: t,
+		body: o,
+		requestSize: s,
+		fullUrl: c,
+		requestId: n,
+		headers: i,
+		config: r
+	};
+	for (let g = 0;; g++) {
+		let f = await we(u, a, g, d);
+		if (f.ok) return f.value;
+		if (!f.retry) throw f.cause;
+		r.debug && h(`\u{1F501} Request [${n}] retrying after ${f.delayMs}ms (attempt ${g + 2}/${d}): ${f.cause.message}`, true);
+		try {
+			await Y(f.delayMs, r.signal);
+		} catch {
+			throw new p("Request aborted by caller", l.ABORTED, {
+				context: {
+					endpoint: t,
+					requestId: n,
+					requestSize: s
+				},
+				originalError: f.cause
+			});
+		}
+	}
+}
+var be = "compute.rhino3d.com";
+function Q(t) {
+	let e = t?.trim() ?? "";
+	if (!e) throw new p("serverUrl is required", l.INVALID_CONFIG, { context: { receivedServerUrl: t } });
+	if (!/^https?:\/\//i.test(e)) throw new p(`Invalid serverUrl: "${e}". Must start with "http://" or "https://". For example: "http://localhost:5000" or "https://example.com"`, l.INVALID_CONFIG, { context: { receivedServerUrl: t } });
+	let r;
+	try {
+		r = new URL(e);
+	} catch (o) {
+		throw new p(`Invalid serverUrl: "${e}". Must be a valid URL. Received error: ${o instanceof Error ? o.message : String(o)}`, l.INVALID_CONFIG, {
+			context: { receivedServerUrl: t },
+			originalError: o instanceof Error ? o : void 0
+		});
+	}
+	if (r.username !== "" || r.password !== "") throw new p(`Invalid serverUrl: "${e}". Must not embed credentials (user:pass@host) \u2014 fetch rejects credentialed URLs at request time. Pass the API key separately.`, l.INVALID_CONFIG, { context: { receivedServerUrl: t } });
+	if (e.includes("?") || e.includes("#")) throw new p(`Invalid serverUrl: "${e}". Must not contain a query string or fragment \u2014 endpoint paths are appended to this URL (e.g. "\${serverUrl}/version"), and a "?" or "#" suffix would corrupt every request path.`, l.INVALID_CONFIG, { context: { receivedServerUrl: t } });
+	if (r.hostname.toLowerCase().replace(/\.+$/, "") === be) throw new p("serverUrl must be set to your Compute server URL. The default public endpoint is not allowed.", l.INVALID_CONFIG, { context: { receivedServerUrl: t } });
+	return e.replace(/\/+$/, "");
+}
+var R = class R {
+	constructor(e, r) {
+		y(this, "serverUrl");
+		y(this, "apiKey");
+		y(this, "disposed", false);
+		y(this, "activeMonitors", /* @__PURE__ */ new Set());
+		y(this, "activeTimeouts", /* @__PURE__ */ new Set());
+		this.serverUrl = Q(e), this.apiKey = r;
+	}
+	buildHeaders() {
+		let e = { "Content-Type": "application/json" };
+		return this.apiKey && (e.RhinoComputeKey = this.apiKey), e;
+	}
+	fetchWithTimeout(e, r = {}, n = R.DEFAULT_TIMEOUT_MS) {
+		let o = new Headers(this.buildHeaders());
+		r.headers && new Headers(r.headers).forEach((i, a) => {
+			o.set(a, i);
+		});
+		let s = {};
+		o.forEach((i, a) => {
+			s[a] = i;
+		});
+		let c = {
+			...r,
+			headers: s
+		};
+		return n > 0 && !c.signal && (c.signal = AbortSignal.timeout(n)), fetch(e, c);
+	}
+	async isServerOnline(e = 5e3) {
+		this.ensureNotDisposed();
+		let r = `${this.serverUrl}/`;
+		try {
+			return (await this.fetchWithTimeout(r, { method: "GET" }, e)).ok;
+		} catch (n) {
+			return m().debug("[ComputeServerStats] Fetch error:", n), false;
+		}
+	}
+	async getActiveChildren(e = {}) {
+		this.ensureNotDisposed();
+		let { initialize: r = true } = e, n = r ? `${this.serverUrl}/activechildren` : `${this.serverUrl}/activechildren?initialize=false`, o = r ? R.LIFECYCLE_TIMEOUT_MS : R.DEFAULT_TIMEOUT_MS;
+		try {
+			let s = await this.fetchWithTimeout(n, {}, o);
+			if (!s.ok) return m().warn("[ComputeServerStats] Failed to fetch active children:", s.status), null;
+			let c = (await s.text()).trim();
+			return /^\d+$/.test(c) ? parseInt(c, 10) : (m().warn("[ComputeServerStats] Invalid active children response:", c), null);
+		} catch (s) {
+			return m().warn("[ComputeServerStats] Error fetching active children:", s), null;
+		}
+	}
+	async getVersion() {
+		this.ensureNotDisposed();
+		try {
+			let e = await this.fetchWithTimeout(`${this.serverUrl}/version`);
+			if (!e.ok) return m().warn("[ComputeServerStats] Failed to fetch version:", e.status), null;
+			let r = await e.text();
+			try {
+				let n = JSON.parse(r);
+				return {
+					rhino: n.rhino ?? "",
+					compute: n.compute ?? "",
+					git_sha: n.git_sha ?? null
+				};
+			} catch {
+				return {
+					rhino: r,
+					compute: "",
+					git_sha: null
+				};
+			}
+		} catch (e) {
+			return m().warn("[ComputeServerStats] Error fetching version:", e), null;
+		}
+	}
+	async getInstalledPlugins(e = "gh") {
+		this.ensureNotDisposed();
+		try {
+			let r = await this.fetchWithTimeout(`${this.serverUrl}/plugins/${e}/installed`);
+			if (!r.ok) return m().warn(`[ComputeServerStats] Failed to fetch ${e} plugins:`, r.status), null;
+			let n = await r.text();
+			try {
+				let o = JSON.parse(n);
+				return o && typeof o == "object" ? o : null;
+			} catch {
+				return null;
+			}
+		} catch (r) {
+			return m().warn(`[ComputeServerStats] Error fetching ${e} plugins:`, r), null;
+		}
+	}
+	async getServerStats() {
+		if (this.ensureNotDisposed(), !await this.isServerOnline()) return { isOnline: false };
+		let [r, n] = await Promise.all([this.getVersion(), this.getActiveChildren({ initialize: false })]);
+		return {
+			isOnline: true,
+			...r && { version: r },
+			...n !== null && { activeChildren: n }
+		};
+	}
+	async purgeCache() {
+		this.ensureNotDisposed();
+		try {
+			let e = await this.fetchWithTimeout(`${this.serverUrl}/cache/purge`, { method: "POST" });
+			if (!e.ok) return m().warn("[ComputeServerStats] Failed to purge cache:", e.status), null;
+			let r = await e.text();
+			try {
+				let n = JSON.parse(r);
+				return typeof n.purged == "number" ? n.purged : null;
+			} catch {
+				return null;
+			}
+		} catch (e) {
+			return m().warn("[ComputeServerStats] Error purging cache:", e), null;
+		}
+	}
+	async purgeAllChildren() {
+		this.ensureNotDisposed();
+		let e = await this.getActiveChildren({ initialize: false });
+		if (e === null) return m().warn("[ComputeServerStats] purgeAllChildren: could not read child count"), null;
+		if (e === 0) return {
+			totalPurged: 0,
+			calls: 0,
+			children: 0,
+			confident: true
+		};
+		let r = e * 2, n = 0;
+		for (let o = 0; o < r; o++) {
+			let s = await this.purgeCache();
+			s !== null && (n += s);
+		}
+		return {
+			totalPurged: n,
+			calls: r,
+			children: e,
+			confident: e === 1
+		};
+	}
+	async getServerTime() {
+		this.ensureNotDisposed();
+		try {
+			let e = await this.fetchWithTimeout(`${this.serverUrl}/servertime`);
+			if (!e.ok) return m().warn("[ComputeServerStats] Failed to fetch server time:", e.status), null;
+			let r = (await e.text()).trim().replace(/^"|"$/g, ""), n = new Date(r);
+			return isNaN(n.getTime()) ? null : n;
+		} catch (e) {
+			return m().warn("[ComputeServerStats] Error fetching server time:", e), null;
+		}
+	}
+	async getIdleSpan() {
+		this.ensureNotDisposed();
+		try {
+			let e = await this.fetchWithTimeout(`${this.serverUrl}/idlespan`);
+			if (!e.ok) return m().warn("[ComputeServerStats] Failed to fetch idle span:", e.status), null;
+			let r = parseFloat((await e.text()).trim());
+			return isNaN(r) ? null : r;
+		} catch (e) {
+			return m().warn("[ComputeServerStats] Error fetching idle span:", e), null;
+		}
+	}
+	async launchChildren() {
+		return this.postJson("/launch-children");
+	}
+	async launchChild(e) {
+		let r = e === void 0 ? "/launch-child" : `/launch-child?port=${e}`;
+		return this.postJson(r);
+	}
+	async shutdownChildren(e) {
+		let r = e === void 0 ? "/shutdown-children" : `/shutdown-children?port=${e}`;
+		return this.postJson(r);
+	}
+	async recycleChildren(e) {
+		let r = e === void 0 ? "/recycle-children" : `/recycle-children?port=${e}`;
+		return this.postJson(r);
+	}
+	async postJson(e) {
+		this.ensureNotDisposed();
+		try {
+			let r = await this.fetchWithTimeout(`${this.serverUrl}${e}`, { method: "POST" }, R.LIFECYCLE_TIMEOUT_MS);
+			if (!r.ok) return m().warn(`[ComputeServerStats] POST ${e} failed:`, r.status), null;
+			let n = await r.text();
+			try {
+				return JSON.parse(n);
+			} catch {
+				return null;
+			}
+		} catch (r) {
+			return m().warn(`[ComputeServerStats] Error on POST ${e}:`, r), null;
+		}
+	}
+	monitor(e, r = 5e3) {
+		if (this.ensureNotDisposed(), !Number.isFinite(r) || r < R.MIN_MONITOR_INTERVAL_MS) throw new RangeError(`monitor() intervalMs must be a finite number >= ${R.MIN_MONITOR_INTERVAL_MS}ms, got ${r}. Sub-${R.MIN_MONITOR_INTERVAL_MS}ms polling would hot-loop the server.`);
+		let n = true, o = null;
+		m().info(`\u{1F504} Starting server stats monitoring every ${r}ms`);
+		let s = async () => {
+			if (o !== null && (this.activeTimeouts.delete(o), o = null), !(!n || this.disposed)) {
+				try {
+					let i = await this.getServerStats();
+					if (!n || this.disposed) return;
+					try {
+						e(i);
+					} catch (a) {
+						m().error("[ComputeServerStats] Monitor callback threw:", a);
+					}
+				} catch (i) {
+					!n || this.disposed ? m().debug("[ComputeServerStats] Monitor poll cancelled during shutdown:", i) : m().error("[ComputeServerStats] Failed to fetch stats during monitor:", i);
+				}
+				n && !this.disposed && (o = setTimeout(() => {
+					s();
+				}, r), this.activeTimeouts.add(o));
+			}
+		}, c = () => {
+			n = false, o !== null && (clearTimeout(o), this.activeTimeouts.delete(o), o = null), this.activeMonitors.delete(c);
+		};
+		return this.activeMonitors.add(c), s(), c;
+	}
+	async dispose() {
+		if (!this.disposed) {
+			this.disposed = true;
+			for (let e of this.activeMonitors) e();
+			this.activeMonitors.clear();
+			for (let e of this.activeTimeouts) clearTimeout(e);
+			this.activeTimeouts.clear();
+		}
+	}
+	ensureNotDisposed() {
+		if (this.disposed) throw new p("ComputeServerStats has been disposed and cannot be used", l.INVALID_STATE, { context: { disposed: this.disposed } });
+	}
+};
+y(R, "DEFAULT_TIMEOUT_MS", 5e3), y(R, "LIFECYCLE_TIMEOUT_MS", 6e4), y(R, "MIN_MONITOR_INTERVAL_MS", 100);
+var A = R;
+function X(t, e = {}) {
+	let { preserveSpaces: r = false } = e, n = r ? /[-_]+(.)?/g : /[\s\-_]+(.)?/g, o = t.trim().replace(n, (s, c) => c ? c.toUpperCase() : "");
+	return o = o.replace(/^[A-Z]+(?=[A-Z][a-z]|[^A-Za-z]|$)/, (s) => s.toLowerCase()), o.charAt(0).toLowerCase() + o.slice(1);
+}
+function Te(t) {
+	if (t === null || typeof t != "object") return false;
+	let e = Object.getPrototypeOf(t);
+	return e === Object.prototype || e === null;
+}
+function F(t, e = {}) {
+	if (!t || typeof t != "object") return t;
+	if (Array.isArray(t)) return e.deep ? t.map((n) => F(n, e)) : t;
+	if (!Te(t)) return t;
+	let r = {};
+	for (let n of Object.keys(t)) {
+		let o = X(n, { preserveSpaces: e.preserveSpaces });
+		Object.prototype.hasOwnProperty.call(r, o) && m().warn(`camelcaseKeys: key '${n}' collides with an earlier key on '${o}' \u2014 the earlier value is overwritten (last key wins).`);
+		let s = t[n];
+		r[o] = e.deep ? F(s, e) : s;
+	}
+	return r;
+}
+function w(t, e) {
+	if (!t || typeof t != "object") return;
+	let r = t;
+	if (te(r, e)) return r[e];
+	let n = re(r).get(e.toLowerCase());
+	return n === void 0 ? void 0 : r[n];
+}
+var te = (t, e) => Object.prototype.hasOwnProperty.call(t, e);
+function yt(t, e) {
+	if (!t || typeof t != "object") return false;
+	let r = t;
+	return te(r, e) ? true : re(r).has(e.toLowerCase());
+}
+var ee = /* @__PURE__ */ new WeakMap();
+function re(t) {
+	let e = Object.keys(t), r = ee.get(t);
+	if (r && r.keyCount === e.length) return r.map;
+	let n = /* @__PURE__ */ new Map();
+	for (let o of e) {
+		let s = o.toLowerCase();
+		n.has(s) || n.set(s, o);
+	}
+	return ee.set(t, {
+		keyCount: e.length,
+		map: n
+	}), n;
+}
+var Se = async (t, e, r = null) => {
+	if (typeof document > "u" || typeof Blob > "u") throw new p("File download functionality is only available in browser environments. This function requires the DOM API (document, Blob).", l.BROWSER_ONLY, { context: {
+		environment: typeof window < "u" ? "browser (SSR)" : "Node.js",
+		documentAvailable: typeof document < "u",
+		blobAvailable: typeof Blob < "u"
+	} });
+	try {
+		await Ae(await ne(t, r), e);
+	} catch (n) {
+		throw n instanceof p ? n : new p("Failed to download files from compute response", l.INVALID_STATE, {
+			context: { originalError: n instanceof Error ? n.message : String(n) },
+			originalError: n instanceof Error ? n : void 0
+		});
+	}
+};
+var $ = (t) => t.replace(/\\/g, "/").split("/").map((e) => e.trim()).filter((e) => e !== "" && e !== "." && e !== ".." && !/^[a-zA-Z]:$/.test(e)).join("/");
+var Oe = (t) => t === true || typeof t == "string" && t.trim().toLowerCase() === "true";
+var Ce = (t) => {
+	let e = [];
+	return t.forEach((r) => {
+		let n = w(r, "fileName") ?? "", o = w(r, "fileType") ?? "", s = $(`${n}${o}`);
+		if (s === "") {
+			m().warn(`Skipping file with unusable name "${n}${o}": no safe archive path remains after sanitization.`);
+			return;
+		}
+		let c = w(r, "subFolder"), i = c ? $(c) : "", a = i !== "" ? `${i}/${s}` : s, d = w(r, "data");
+		if (typeof d != "string" || d === "") {
+			m().warn(`Skipping file "${a}": item carries no usable data.`);
+			return;
+		}
+		if (Oe(w(r, "isBase64Encoded"))) try {
+			e.push({
+				fileName: s,
+				content: _(d),
+				path: a
+			});
+		} catch (u) {
+			m().warn(`Skipping file "${a}": base64 decode failed.`, u);
+		}
+		else e.push({
+			fileName: s,
+			content: d,
+			path: a
+		});
+	}), e;
+};
+var Ie = 3e4;
+var Ne = async (t) => (await Promise.all(t.map(async (r) => {
+	try {
+		let n = typeof AbortSignal < "u" && typeof AbortSignal.timeout == "function" ? AbortSignal.timeout(Ie) : void 0, o = await fetch(r.filePath, { signal: n });
+		if (!o.ok) return m().warn(`Failed to fetch additional file from URL: ${r.filePath}`), null;
+		let s = await o.arrayBuffer(), c = $(r.fileName);
+		if (c === "") return m().warn(`Skipping fetched file with unusable name: ${r.fileName}`), null;
+		let i = r.subFolder ? $(r.subFolder) : "";
+		return {
+			fileName: c,
+			content: new Uint8Array(s),
+			path: i !== "" ? `${i}/${c}` : c
+		};
+	} catch (n) {
+		return m().error(`Error fetching additional file from URL: ${r.filePath}`, n), null;
+	}
+}))).filter((r) => r !== null);
+var ne = async (t, e) => {
+	let r = Ce(t);
+	if (e) {
+		let o = Array.isArray(e) ? e : [e];
+		r.push(...await Ne(o));
+	}
+	let n = /* @__PURE__ */ new Set();
+	return r.map((o) => {
+		let s = oe(o.path, n);
+		return n.add(s), s === o.path ? o : (m().warn(`Duplicate archive path "${o.path}" \u2014 storing as "${s}".`), {
+			...o,
+			path: s,
+			fileName: s.slice(s.lastIndexOf("/") + 1)
+		});
+	});
+};
+async function Ae(t, e) {
+	let { zip: r, strToU8: n } = await import('./esm.js-5PXzLulY.js'), o = {}, s = /* @__PURE__ */ new Set();
+	t.forEach((a) => {
+		let d = oe(a.path, s);
+		s.add(d), d !== a.path && m().warn(`Duplicate archive path "${a.path}" \u2014 storing as "${d}".`), o[d] = typeof a.content == "string" ? n(a.content) : a.content;
+	});
+	let c = await new Promise((a, d) => {
+		r(o, { level: 6 }, (u, g) => u ? d(u) : a(g));
+	});
+	$e(new Blob([c], { type: "application/zip" }), `${e}.zip`);
+}
+function oe(t, e) {
+	if (!e.has(t)) return t;
+	let r = t.lastIndexOf("/"), n = t.lastIndexOf("."), o = n > r ? n : t.length, s = t.slice(0, o), c = t.slice(o);
+	for (let i = 2;; i++) {
+		let a = `${s}-${i}${c}`;
+		if (!e.has(a)) return a;
+	}
+}
+function $e(t, e) {
+	if (typeof document > "u") throw new p("saveFile requires a browser environment with DOM API access.", l.BROWSER_ONLY, { context: {
+		function: "saveFile",
+		requiredAPI: "document"
+	} });
+	let r = URL.createObjectURL(t), n = document.createElement("a");
+	n.href = r, n.download = e, document.body.appendChild(n), n.click(), n.remove(), setTimeout(() => URL.revokeObjectURL(r), 1e4);
+}
+
+export { A, De as D, Ee as E, F, Me as M, N, Q, Se as S, yt as a, de as d, fe as f, ge as g, l, m, p, w, y };
+//# sourceMappingURL=chunk-XT3XWDDV.js-CgVdm1U0.js.map