@selvajs/selva 4.20.0-beta.15 → 4.20.0-beta.16

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

@@ -0,0 +1,4332 @@
+// ../compute/dist/handle-files-DSwM21jz.js
+var DEFAULT_RETRY = {
+	attempts: 0,
+	baseDelayMs: 500,
+	maxDelayMs: 3e4,
+	retryOn429: true
+};
+var RETRYABLE_STATUS = /* @__PURE__ */ new Set([
+	502,
+	503,
+	504
+]);
+/**
+* Ceiling on a server-sent `Retry-After` wait. The server's window outranks
+* `RetryPolicy.maxDelayMs` (retrying sooner all but guarantees another 429), but a bad or hostile
+* header must not park the client for minutes. A `maxDelayMs` above this cap raises it.
+*/
+var RETRY_AFTER_CAP_MS = 6e4;
+function resolveRetryPolicy(policy) {
+	if (!policy) return DEFAULT_RETRY;
+	return {
+		attempts: policy.attempts ?? DEFAULT_RETRY.attempts,
+		baseDelayMs: policy.baseDelayMs ?? DEFAULT_RETRY.baseDelayMs,
+		maxDelayMs: policy.maxDelayMs ?? DEFAULT_RETRY.maxDelayMs,
+		retryOn429: policy.retryOn429 ?? DEFAULT_RETRY.retryOn429
+	};
+}
+function isRetryableStatus(status, policy) {
+	return RETRYABLE_STATUS.has(status) || policy.retryOn429 && status === 429;
+}
+/** Delay before the next attempt: the server's `Retry-After` when it sent one, else backoff. */
+function retryDelay(retryAfter, attempt, policy) {
+	const retryAfterMs = parseRetryAfter(retryAfter);
+	return retryAfterMs === null ? backoffDelay(attempt, policy) : Math.min(retryAfterMs, Math.max(policy.maxDelayMs, RETRY_AFTER_CAP_MS));
+}
+/** A `Retry-After` value (seconds or HTTP-date) in ms; null when missing or unparseable. */
+function parseRetryAfter(headerValue) {
+	if (!headerValue) return null;
+	const seconds = Number(headerValue);
+	if (Number.isFinite(seconds) && seconds >= 0) return seconds * 1e3;
+	const dateMs = Date.parse(headerValue);
+	if (Number.isFinite(dateMs)) {
+		const delta = dateMs - Date.now();
+		return delta > 0 ? delta : 0;
+	}
+	return null;
+}
+function backoffDelay(attempt, policy) {
+	const exponential = policy.baseDelayMs * Math.pow(2, attempt);
+	const jitter = Math.random() * policy.baseDelayMs;
+	return Math.min(exponential + jitter, policy.maxDelayMs);
+}
+function sleep(ms, signal) {
+	return new Promise((resolve, reject) => {
+		if (signal?.aborted) {
+			reject(new DOMException("Aborted", "AbortError"));
+			return;
+		}
+		const id = setTimeout(() => {
+			signal?.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		const onAbort = () => {
+			clearTimeout(id);
+			reject(new DOMException("Aborted", "AbortError"));
+		};
+		signal?.addEventListener("abort", onAbort, { once: true });
+	});
+}
+var ErrorCodes = {
+	/** Connection failure, a gateway status (502/503/504), or a 2xx body cut off mid-stream. */
+	NETWORK_ERROR: "NETWORK_ERROR",
+	/** HTTP 401 or 403: the server rejected the credentials. */
+	AUTH_ERROR: "AUTH_ERROR",
+	/** The server rejected the request (HTTP 400, 413), or an input failed a client-side check. */
+	VALIDATION_ERROR: "VALIDATION_ERROR",
+	/** The server failed the solve (HTTP 500), or the solve reported errors. */
+	COMPUTATION_ERROR: "COMPUTATION_ERROR",
+	/** No response within `ComputeConfig.timeoutMs`. */
+	TIMEOUT_ERROR: "TIMEOUT_ERROR",
+	/** A browser fetch failed with no response: most often CORS, which the browser hides. */
+	CORS_ERROR: "CORS_ERROR",
+	/** HTTP 404: the endpoint doesn't exist on this server. Never retried. */
+	NOT_FOUND: "NOT_FOUND",
+	/** HTTP 429. Retried, honouring `Retry-After`, when the policy allows (`RetryPolicy.retryOn429`). */
+	RATE_LIMIT: "RATE_LIMIT",
+	/**
+	* A 2xx with a body the client can't use: declared non-JSON (a captive portal, a proxy login page)
+	* or JSON that isn't an object. Never retried.
+	*/
+	INVALID_RESPONSE: "INVALID_RESPONSE",
+	/**
+	* The response body passed `ComputeConfig.maxResponseBytes`; the download was cancelled there.
+	* Never retried. `context` carries `{ maxResponseBytes }`.
+	*/
+	RESPONSE_TOO_LARGE: "RESPONSE_TOO_LARGE",
+	/** Any failure not classified by another code. */
+	UNKNOWN_ERROR: "UNKNOWN_ERROR",
+	/** An object was used after `dispose()`, or a file download failed part-way. */
+	INVALID_STATE: "INVALID_STATE",
+	/** A caller-supplied argument is unusable: an empty definition, an unserializable body. */
+	INVALID_INPUT: "INVALID_INPUT",
+	/**
+	* Bad configuration: an invalid `serverUrl`, an unsendable header, an unusable number, a server
+	* that answers with a redirect, an incomplete logger, an interval out of range.
+	*/
+	INVALID_CONFIG: "INVALID_CONFIG",
+	/** A browser-only API (file download) was called outside a browser. */
+	BROWSER_ONLY: "BROWSER_ONLY",
+	/** The runtime has no base64 codec: neither `Buffer` nor `atob`/`btoa`. */
+	ENVIRONMENT_ERROR: "ENVIRONMENT_ERROR",
+	/** A string that should be base64 isn't. */
+	ENCODING_ERROR: "ENCODING_ERROR",
+	/** An input's `default` had a shape the normalizer didn't recognize. */
+	MALFORMED_DEFAULT: "MALFORMED_DEFAULT",
+	/** Latest-wins scheduling: a newer call replaced this one. */
+	SUPERSEDED: "SUPERSEDED",
+	/** The scheduler or a caller-supplied `AbortSignal` aborted this call. */
+	ABORTED: "ABORTED",
+	/**
+	* The queue was at `maxQueueDepth`, so the call was rejected without queueing. Retryable after a
+	* back-off. `context` carries `{ queueDepth, maxQueueDepth }`.
+	*/
+	QUEUE_FULL: "QUEUE_FULL",
+	/**
+	* The call waited longer than `queueWaitMs` without starting, and was rejected rather than run
+	* stale. Retryable. `context` carries `{ waitedMs, queueWaitMs }`.
+	*/
+	QUEUE_TIMEOUT: "QUEUE_TIMEOUT",
+	/**
+	* The server no longer holds the definition a `pointer` named (evicted, restarted, another
+	* child). Retry with the full definition. Read from the error body's
+	* `code: "definition_not_cached"`.
+	*/
+	DEFINITION_NOT_CACHED: "DEFINITION_NOT_CACHED"
+};
+/** Error with a typed `code`: switch on it rather than on the message. */
+var ComputeError = class extends Error {
+	code;
+	statusCode;
+	context;
+	originalError;
+	constructor(message, code = ErrorCodes.UNKNOWN_ERROR, options) {
+		const original = options?.originalError;
+		const cause = original === void 0 || original instanceof Error ? original : new Error(String(original));
+		super(message, cause && { cause });
+		this.name = "ComputeError";
+		this.code = code;
+		this.statusCode = options?.statusCode;
+		this.context = options?.context;
+		this.originalError = cause;
+	}
+};
+/** A caller's signal cancelled the work. */
+function abortedByCaller(context, originalError) {
+	return new ComputeError("Request aborted by caller", ErrorCodes.ABORTED, {
+		context,
+		originalError
+	});
+}
+var silent = {
+	debug() {},
+	info() {},
+	warn() {},
+	error() {}
+};
+var internalLogger = silent;
+function getLogger() {
+	return internalLogger;
+}
+/**
+* Route the package's logs to `logger`; `null` silences them (the default).
+*
+* @throws {ComputeError} `INVALID_CONFIG` if the logger lacks one of the four methods, rather
+*   than a "debug is not a function" later at an unrelated call site.
+*
+* @example
+* ```typescript
+* import { setLogger } from '@selvajs/compute/core';
+*
+* setLogger(console);
+* setLogger({
+*   debug: (msg, ...args) => myLogger.debug(msg, ...args),
+*   info: (msg, ...args) => myLogger.info(msg, ...args),
+*   warn: (msg, ...args) => myLogger.warn(msg, ...args),
+*   error: (msg, ...args) => myLogger.error(msg, ...args)
+* });
+* setLogger(null);
+* ```
+*/
+function setLogger(logger) {
+	if (logger === null) {
+		internalLogger = silent;
+		return;
+	}
+	const missing = [
+		"debug",
+		"info",
+		"warn",
+		"error"
+	].filter((method) => typeof logger[method] !== "function");
+	if (missing.length > 0) throw new ComputeError(`Logger is missing required method(s): ${missing.join(", ")}. A logger must implement debug, info, warn and error.`, ErrorCodes.INVALID_CONFIG, { context: { missingMethods: missing } });
+	internalLogger = logger;
+}
+/** Shorthand for `setLogger(console)`. */
+function enableDebugLogging() {
+	setLogger(console);
+}
+/**
+* Case-insensitive field reads for wire payloads.
+*
+* Rhino Compute branches serialize the same field in different casings. mcneel 8.x/9.x send the IO
+* schema PascalCase (`ParamType`, `Default`, `InnerTree`): those C# classes carry no
+* `[JsonProperty]`. The VektorNode fork sends camelCase, except inside the `default` DataTree
+* (`ParamName`, `InnerTree`), an external type it can't attribute. So one response can mix casings.
+* Read the fields you need through here and leave the rest verbatim: rewriting every key corrupts
+* user-authored ones such as value-list labels.
+*/
+/** Own keys only: a payload probed for `constructor` must not find `Object.prototype`'s. */
+function findOwnKey(obj, name) {
+	if (!obj || typeof obj !== "object") return void 0;
+	if (Object.hasOwn(obj, name)) return name;
+	const lower = name.toLowerCase();
+	return Object.keys(obj).find((key) => key.toLowerCase() === lower);
+}
+/**
+* Read `name` in any casing, preferring an exact-case match. `undefined` when no own key matches or
+* `obj` isn't an object.
+*/
+function readField(obj, name) {
+	const key = findOwnKey(obj, name);
+	return key === void 0 ? void 0 : obj[key];
+}
+/** Whether `name` is present in any casing, even with a null or undefined value. */
+function hasField(obj, name) {
+	return findOwnKey(obj, name) !== void 0;
+}
+var UNREADABLE = "<unreadable URL>";
+/**
+* Only a URL with a real host can be cut safely. Anything else could hold a secret at any position:
+* `https://admin:p/ss@host` splits into a bad port and a path.
+*/
+function parseWithHost(url) {
+	try {
+		const parsed = new URL(url);
+		return parsed.host ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+/** `url` without credentials, query or fragment, for errors and logs. */
+function redactUrl(url) {
+	const parsed = parseWithHost(url);
+	if (!parsed) return UNREADABLE;
+	parsed.username = "";
+	parsed.password = "";
+	parsed.search = "";
+	parsed.hash = "";
+	return parsed.href;
+}
+/** Scheme and host alone. For a URL that was rejected, whose path can't be trusted either. */
+function redactToOrigin(url) {
+	const parsed = parseWithHost(url);
+	return parsed ? `${parsed.protocol}//${parsed.host}` : UNREADABLE;
+}
+/** The parsed value, or `undefined` when `text` isn't JSON. */
+function tryParseJson(text) {
+	try {
+		return JSON.parse(text);
+	} catch {
+		return;
+	}
+}
+/**
+* Validate a compute `serverUrl` and return it trimmed, without trailing slashes.
+*
+* @throws {ComputeError} `INVALID_CONFIG` when the URL is empty, isn't http(s), doesn't parse,
+*   embeds credentials, has a query or fragment, or names a blocked host.
+*/
+function validateServerUrl(raw, options) {
+	const trimmed = raw?.trim() ?? "";
+	if (!trimmed) throw new ComputeError("serverUrl is required", ErrorCodes.INVALID_CONFIG, { context: { receivedServerUrl: raw } });
+	const redacted = redactToOrigin(trimmed);
+	const invalid = (reason) => new ComputeError(`Invalid serverUrl: "${redacted}". ${reason}`, ErrorCodes.INVALID_CONFIG, { context: { receivedServerUrl: redacted } });
+	if (!/^https?:\/\//i.test(trimmed)) throw invalid("Must start with \"http://\" or \"https://\". For example: \"http://localhost:6500\" or \"https://example.com\"");
+	let parsed;
+	try {
+		parsed = new URL(trimmed);
+	} catch {
+		throw invalid("Must be a valid URL.");
+	}
+	if (parsed.username !== "" || parsed.password !== "") throw invalid("Must not embed credentials (user:pass@host) — fetch rejects credentialed URLs at request time. Pass the API key separately.");
+	if (trimmed.includes("?") || trimmed.includes("#")) throw invalid("Must not contain a query string or fragment — endpoint paths are appended to this URL (e.g. \"${serverUrl}/version\"), and a \"?\" or \"#\" suffix would corrupt every request path.");
+	const hostname = trimTrailing(parsed.hostname.toLowerCase(), ".");
+	if ((options?.blockedHosts ?? ["compute.rhino3d.com"]).map((h) => trimTrailing(h.toLowerCase(), ".")).includes(hostname)) throw new ComputeError("serverUrl must be set to your Compute server URL. The shared public endpoint is not allowed.", ErrorCodes.INVALID_CONFIG, { context: { receivedServerUrl: redacted } });
+	return trimTrailing(trimmed, "/");
+}
+/** A loop, not `/x+$/`: that regex retries from every position of a long run and goes quadratic. */
+function trimTrailing(value, char) {
+	let end = value.length;
+	while (end > 0 && value[end - 1] === char) end--;
+	return value.slice(0, end);
+}
+var warned = /* @__PURE__ */ new Set();
+/** Log `message` the first time `key` is seen: what it reports doesn't change per call. */
+function warnOnce(key, message) {
+	if (warned.has(key)) return;
+	warned.add(key);
+	getLogger().warn(message);
+}
+/**
+* True only in a real browser, where an API key in the config is exposed to users. jsdom defines
+* `window` too, so Node is ruled out by `process.versions.node`, and by jsdom's user-agent marker
+* for setups that hide `process`.
+*/
+function isRealBrowser() {
+	if (typeof window === "undefined") return false;
+	if (globalThis.process?.versions?.node != null) return false;
+	const nav = globalThis.navigator;
+	const userAgent = typeof nav?.userAgent === "string" ? nav.userAgent : "";
+	if (/jsdom/i.test(userAgent)) return false;
+	return true;
+}
+function warnIfClientSide(functionName, suppress) {
+	if (suppress || !isRealBrowser()) return;
+	warnOnce(`client-side:${functionName}`, `Warning: ${functionName} is running on the client side. For better performance and security, consider running this on the server side.`);
+}
+/** `serverUrl` as `validateServerUrl` returns it: no trailing slash. */
+function buildUrl(endpoint, serverUrl) {
+	return `${serverUrl}/${endpoint.replace(/^\/+/, "")}`;
+}
+function isLocalhost(serverUrl) {
+	const hostname = new URL(serverUrl).hostname.toLowerCase();
+	return hostname === "localhost" || hostname === "127.0.0.1" || hostname === "[::1]";
+}
+var DEFAULT_API_KEY_HEADER = "RhinoComputeKey";
+/**
+* Caller headers plus credentials. Every request to the server builds its headers here,
+* so a liveness probe authenticates exactly like the solve it gates.
+*/
+function buildAuthHeaders(auth) {
+	return assertSendable(mergeUnder(auth.headers, credentialHeaders(auth)));
+}
+function buildHeaders(requestId, config) {
+	const headers = assertSendable(mergeUnder(config.headers, {
+		...credentialHeaders(config),
+		"X-Request-ID": requestId,
+		"Content-Type": "application/json"
+	}));
+	if (!config.apiKey && !config.authToken && !isLocalhost(config.serverUrl)) warnOnce(`no-auth:${config.serverUrl}`, `[Compute] Request [${requestId}] targets remote server (${config.serverUrl}) but no API key or auth token is configured. Requests may fail or be rate-limited. (warned once per server)`);
+	return headers;
+}
+/** `headers` with a JSON `Content-Type` that replaces one of any casing already there. */
+function withJsonContentType(headers) {
+	return mergeUnder(headers, { "Content-Type": "application/json" });
+}
+function credentialHeaders(auth) {
+	return {
+		...auth.authToken && { Authorization: auth.authToken },
+		...auth.apiKey && { [auth.apiKeyHeader ?? DEFAULT_API_KEY_HEADER]: auth.apiKey }
+	};
+}
+/**
+* Header names are case-insensitive and fetch joins duplicates, so a caller key
+* matching a transport key in any case is dropped rather than sent alongside it.
+*/
+function mergeUnder(caller, transport) {
+	const taken = new Set(Object.keys(transport).map((name) => name.toLowerCase()));
+	const kept = Object.entries(caller ?? {}).filter(([name]) => !taken.has(name.toLowerCase()));
+	return {
+		...Object.fromEntries(kept),
+		...transport
+	};
+}
+/**
+* Left to fetch, a bad value becomes a retried TypeError that quotes it, and the value may be the
+* API key. `Headers` throws the same message, so its error is not kept as the cause.
+*/
+function assertSendable(headers) {
+	const check = new Headers();
+	for (const [name, value] of Object.entries(headers)) try {
+		check.set(name, value);
+	} catch {
+		throw new ComputeError(`Header "${name}" has an invalid name or value`, ErrorCodes.INVALID_CONFIG, { context: { header: name } });
+	}
+	return headers;
+}
+function generateRequestId() {
+	return `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+}
+function getNodeBuffer() {
+	const buf = globalThis.Buffer;
+	return typeof buf === "function" ? buf : void 0;
+}
+function encodeStringToBase64(str) {
+	const Buffer = getNodeBuffer();
+	if (Buffer) return Buffer.from(str, "utf-8").toString("base64");
+	return base64ByteArray(new TextEncoder().encode(str));
+}
+/**
+* WHATWG forgiving-base64 normalization: strip ASCII whitespace, then drop trailing padding where
+* the spec allows it (total length a multiple of 4). `null` when the length can't be base64. Leaves
+* the alphabet check to the decoders, which make it faster than a regex over a multi-MB payload.
+*/
+function stripBase64(str) {
+	let data = str.replace(/[\t\n\f\r ]/g, "");
+	if (data.length % 4 === 0) data = data.replace(/={1,2}$/, "");
+	return data.length % 4 === 1 ? null : data;
+}
+var B64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+/**
+* Whether an untyped string is base64 content: the canonical padded form when confident, else
+* `null` (treat it as plain text). A heuristic; pass a `Uint8Array` when it must be exact.
+*/
+function detectBase64Payload(str) {
+	const data = stripBase64(str);
+	if (data === null || data.length < 64) return null;
+	if (/[^A-Za-z0-9+/]/.test(data)) return null;
+	const rem = data.length % 4;
+	const lastValue = B64_ALPHABET.indexOf(data.charAt(data.length - 1));
+	if (rem === 2 && (lastValue & 15) !== 0) return null;
+	if (rem === 3 && (lastValue & 3) !== 0) return null;
+	return rem === 0 ? data : data + "==".slice(0, 4 - rem);
+}
+/**
+* Decode base64 to bytes, normalizing and validating the same way in Node and browsers.
+* `packages/visualization/src/shared/encoding.ts` keeps a copy that throws its own error class;
+* change both together.
+*
+* @throws {ComputeError} `ENCODING_ERROR` if invalid, or `ENVIRONMENT_ERROR` if the runtime has no decoder
+*/
+function decodeBase64ToBinary(base64File) {
+	const data = stripBase64(base64File);
+	const bytes = data === null ? null : decodeStripped(data);
+	if (bytes === null) throw new ComputeError("Invalid base64 input.", ErrorCodes.ENCODING_ERROR, { context: { inputLength: base64File.length } });
+	return bytes;
+}
+/** Decode {@link stripBase64} output; `null` when a character is outside the alphabet. */
+function decodeStripped(data) {
+	const Buffer = getNodeBuffer();
+	if (Buffer) {
+		if (Buffer.byteLength(data, "utf8") !== data.length) return null;
+		if (data.includes("-") || data.includes("_")) return null;
+		const decoded = Buffer.from(data, "base64");
+		if (decoded.length !== Math.floor(data.length * 3 / 4)) return null;
+		return decoded.byteOffset === 0 && decoded.buffer.byteLength === decoded.length ? new Uint8Array(decoded.buffer, 0, decoded.length) : new Uint8Array(decoded);
+	}
+	if (typeof globalThis.atob === "function") {
+		let binary;
+		try {
+			binary = globalThis.atob(data);
+		} catch {
+			return null;
+		}
+		const bytes = new Uint8Array(binary.length);
+		for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i) & 255;
+		return bytes;
+	}
+	throw new ComputeError("Base64 decoding not supported in this environment.", ErrorCodes.ENVIRONMENT_ERROR, { context: { environmentInfo: "atob or Buffer not available" } });
+}
+/** UTF-8 byte length. Sizes every request body: `Buffer` counts without allocating the copy. */
+function utf8ByteLength(str) {
+	const Buffer = getNodeBuffer();
+	return Buffer ? Buffer.byteLength(str, "utf-8") : new TextEncoder().encode(str).length;
+}
+function base64ByteArray(bytes) {
+	const Buffer = getNodeBuffer();
+	if (Buffer) return Buffer.from(bytes).toString("base64");
+	if (typeof globalThis.btoa === "function") {
+		const CHUNK = 32766;
+		const parts = [];
+		for (let i = 0; i < bytes.length; i += CHUNK) parts.push(globalThis.btoa(String.fromCharCode.apply(null, bytes.subarray(i, i + CHUNK))));
+		return parts.join("");
+	}
+	throw new ComputeError("Base64 encoding not supported in this environment.", ErrorCodes.ENVIRONMENT_ERROR, { context: { environmentInfo: "btoa or Buffer not available" } });
+}
+/**
+* Cap on an error body: it is read for its `code` and message only. A 500 is read in full instead,
+* since a partial success carries the computed values.
+*/
+var ERROR_BODY_MAX_BYTES = 1 << 20;
+/** Read a body as text, cancelling the download once it passes `limit` UTF-8 bytes. */
+async function readBodyText(response, limit = Infinity) {
+	if (limit === Infinity) return {
+		text: await response.text(),
+		truncated: false
+	};
+	if (!response.body) {
+		const text = await response.text();
+		return {
+			text,
+			truncated: utf8ByteLength(text) > limit
+		};
+	}
+	const declared = Number(response.headers.get("Content-Length"));
+	if (!response.headers.has("Content-Encoding") && declared > limit) {
+		await response.body.cancel().catch(() => {});
+		return {
+			text: "",
+			truncated: true
+		};
+	}
+	const reader = response.body.getReader();
+	const decoder = new TextDecoder();
+	const parts = [];
+	let received = 0;
+	for (;;) {
+		const { done, value } = await reader.read();
+		if (done) break;
+		received += value.byteLength;
+		parts.push(decoder.decode(value, { stream: true }));
+		if (received > limit) {
+			await reader.cancel().catch(() => {});
+			return {
+				text: parts.join(""),
+				truncated: true
+			};
+		}
+	}
+	parts.push(decoder.decode());
+	return {
+		text: parts.join(""),
+		truncated: false
+	};
+}
+/**
+* Parse a W3C Server Timing header, as the solve endpoint emits it:
+* `decode;dur=3, solve;dur=120, gh;dur=110, encode;dur=8, recomputed;desc="4/97"`, or
+* `cache;desc="hit"` when the server answered from its result cache. Null when it carries no
+* recognised metric.
+*/
+function parseServerTiming(headerValue) {
+	if (!headerValue) return null;
+	const timing = { raw: headerValue };
+	let sawMetric = false;
+	for (const part of headerValue.split(",")) {
+		const [rawName, ...params] = part.trim().split(";");
+		const name = rawName.trim().toLowerCase();
+		if (name === "decode" || name === "solve" || name === "encode" || name === "gh") {
+			const dur = Number(param(params, "dur"));
+			if (!Number.isFinite(dur)) continue;
+			timing[name] = dur;
+			sawMetric = true;
+		} else if (name === "recomputed") {
+			const [ran, total] = (param(params, "desc") ?? "").split("/").map(Number);
+			if (!Number.isInteger(ran) || !Number.isInteger(total)) continue;
+			timing.recomputed = {
+				ran,
+				total
+			};
+			sawMetric = true;
+		} else if (name === "cache" && param(params, "desc") === "hit") {
+			timing.cacheHit = true;
+			sawMetric = true;
+		}
+	}
+	return sawMetric ? timing : null;
+}
+function param(params, key) {
+	for (const p of params) {
+		const [k, ...v] = p.split("=");
+		if (k.trim().toLowerCase() !== key) continue;
+		return v.join("=").trim().replace(/^"(.*)"$/, "$1");
+	}
+}
+function fireServerTiming(response, requestId, onServerTiming) {
+	if (!onServerTiming) return;
+	const timing = parseServerTiming(response.headers.get("Server-Timing"));
+	if (!timing) return;
+	try {
+		onServerTiming(timing, requestId);
+	} catch (err) {
+		getLogger().debug(`onServerTiming callback threw ${err instanceof Error ? err.name : typeof err}`);
+	}
+}
+/** What fetch, or a body read, rejects with when its signal fires: a caller abort or a timeout. */
+function isAbortError(error) {
+	return error instanceof Error && (error.name === "AbortError" || error.name === "TimeoutError");
+}
+/** The most `AbortSignal.timeout` takes on Node, which wants a whole uint32. */
+var MAX_TIMEOUT_MS = 2 ** 32 - 1;
+/** `promise`'s outcome, or a rejection with `signal`'s reason if that fires first. */
+function raceSignal(promise, signal) {
+	if (!signal) return promise;
+	return new Promise((resolve, reject) => {
+		const onAbort = () => reject(signal.reason);
+		if (signal.aborted) onAbort();
+		signal.addEventListener("abort", onAbort, { once: true });
+		promise.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
+	});
+}
+/**
+* Compose a caller-supplied AbortSignal with an optional timeout; `undefined` when neither was
+* given. `AbortSignal.timeout` rather than `setTimeout`: its timer isn't throttled in a hidden tab.
+*/
+function composeSignal(callerSignal, timeoutMs) {
+	const noCleanup = () => {};
+	if (typeof timeoutMs !== "number" || timeoutMs <= 0) return {
+		signal: callerSignal,
+		cleanup: noCleanup
+	};
+	const timeoutSignal = AbortSignal.timeout(Math.floor(timeoutMs));
+	if (!callerSignal) return {
+		signal: timeoutSignal,
+		cleanup: noCleanup
+	};
+	const ctrl = new AbortController();
+	const sources = [callerSignal, timeoutSignal];
+	const onAbort = function() {
+		ctrl.abort(this.reason);
+	};
+	for (const s of sources) {
+		if (s.aborted) {
+			ctrl.abort(s.reason);
+			break;
+		}
+		s.addEventListener("abort", onAbort, { once: true });
+	}
+	return {
+		signal: ctrl.signal,
+		cleanup: () => {
+			for (const s of sources) s.removeEventListener("abort", onAbort);
+		}
+	};
+}
+/**
+* A response's JSON text length, so byte-budgeted caches never re-serialize a huge tree. A WeakMap
+* rather than a field keeps `JSON.stringify(response)` clean; it is keyed by identity, so a derived
+* copy must re-register. `.length` stands in for UTF-8 bytes: the JSON is near-pure ASCII.
+*/
+var wireSizes = /* @__PURE__ */ new WeakMap();
+/** Record `response`'s wire size. No-op for non-object/null values. */
+function setResponseWireSize(response, size) {
+	if (typeof response !== "object" || response === null) return;
+	wireSizes.set(response, size);
+}
+/** The wire size recorded for `response`, or undefined when never registered. */
+function getResponseWireSize(response) {
+	if (typeof response !== "object" || response === null) return void 0;
+	return wireSizes.get(response);
+}
+/** Upper bound for the raw server body stored on error `context.responseBody`. */
+var MAX_CONTEXT_BODY_CHARS = 4096;
+/** An allowlist: errors reach logs and telemetry, and `Set-Cookie` or a proxy's token must not. */
+var CONTEXT_HEADERS = [
+	"content-length",
+	"content-type",
+	"retry-after",
+	"server-timing",
+	"www-authenticate",
+	"x-request-id"
+];
+function truncateBody(body) {
+	if (body.length <= MAX_CONTEXT_BODY_CHARS) return body;
+	return `${body.slice(0, MAX_CONTEXT_BODY_CHARS)}… [truncated ${body.length - MAX_CONTEXT_BODY_CHARS} chars]`;
+}
+function contextHeaders(headers) {
+	const kept = {};
+	for (const name of CONTEXT_HEADERS) {
+		const value = headers.get(name);
+		if (value !== null) kept[name] = value;
+	}
+	return kept;
+}
+var plainMessage = ({ status, statusText, bodyHint }) => `HTTP ${status}: ${statusText}${bodyHint}`;
+var labelled = (label) => ({ statusText, bodyHint }) => `${label}: ${statusText}${bodyHint}`;
+var STATUS_RULES = {
+	400: {
+		code: ErrorCodes.VALIDATION_ERROR,
+		message: labelled("Bad request")
+	},
+	401: { code: ErrorCodes.AUTH_ERROR },
+	403: { code: ErrorCodes.AUTH_ERROR },
+	404: {
+		code: ErrorCodes.NOT_FOUND,
+		message: ({ fullUrl }) => `Endpoint not found: ${fullUrl}`
+	},
+	413: {
+		code: ErrorCodes.VALIDATION_ERROR,
+		message: ({ requestSize }) => `Request too large: ${(requestSize / 1024).toFixed(2)}KB`
+	},
+	429: {
+		code: ErrorCodes.RATE_LIMIT,
+		message: ({ bodyHint }) => `Rate limit exceeded${bodyHint}`
+	},
+	500: {
+		code: ErrorCodes.COMPUTATION_ERROR,
+		message: labelled("Server error")
+	},
+	502: {
+		code: ErrorCodes.NETWORK_ERROR,
+		message: labelled("Bad gateway")
+	},
+	503: {
+		code: ErrorCodes.NETWORK_ERROR,
+		message: labelled("Service unavailable")
+	},
+	504: {
+		code: ErrorCodes.NETWORK_ERROR,
+		message: labelled("Gateway timeout")
+	}
+};
+/**
+* `rawBody` is what came over the wire and goes on `context.responseBody`; `detail` may be a
+* message rewritten from it and only feeds the error message.
+*/
+function throwHttpError(response, ctx, rawBody, detail, serverCode) {
+	const { status, statusText } = response;
+	const { fullUrl, requestId, requestSize, config } = ctx;
+	const trimmed = detail.trim();
+	const bodyHint = trimmed ? ` — ${trimmed.slice(0, 200)}${trimmed.length > 200 ? "…" : ""}` : "";
+	const rule = STATUS_RULES[status] ?? { code: ErrorCodes.UNKNOWN_ERROR };
+	const message = (rule.message ?? plainMessage)({
+		status,
+		statusText,
+		bodyHint,
+		fullUrl,
+		requestSize
+	});
+	const codes = config.serverErrorCodes;
+	throw new ComputeError(message, (serverCode && codes && Object.hasOwn(codes, serverCode) ? codes[serverCode] : void 0) ?? rule.code, {
+		statusCode: status,
+		context: {
+			url: fullUrl,
+			requestId,
+			method: "POST",
+			requestSize,
+			serverUrl: config.serverUrl,
+			responseBody: rawBody ? truncateBody(rawBody) : void 0,
+			responseHeaders: contextHeaders(response.headers)
+		}
+	});
+}
+/** A 3xx, or a browser's `redirect: 'manual'` stand-in for one, which hides the status. */
+function isRedirect(response) {
+	return response.type === "opaqueredirect" || response.status >= 300 && response.status < 400;
+}
+/** Following a redirect would send the API key header, which fetch keeps cross-origin, to the target. */
+function redirectError(response, ctx) {
+	const location = response.headers.get("Location") ?? void 0;
+	return new ComputeError(`Server redirected the request${location ? ` to ${location}` : ""}. Redirects are not followed, so credentials never leave serverUrl: set serverUrl to the address it redirects to.`, ErrorCodes.INVALID_CONFIG, {
+		...response.status > 0 && { statusCode: response.status },
+		context: {
+			url: ctx.fullUrl,
+			requestId: ctx.requestId,
+			location
+		}
+	});
+}
+function tooLargeError(response, ctx) {
+	const { maxResponseBytes } = ctx.config;
+	return new ComputeError(`Response body exceeded maxResponseBytes (${maxResponseBytes} bytes)`, ErrorCodes.RESPONSE_TOO_LARGE, {
+		statusCode: response.status,
+		context: {
+			url: ctx.fullUrl,
+			requestId: ctx.requestId,
+			maxResponseBytes
+		}
+	});
+}
+/** Sizes and identifiers only: bodies and solver messages can hold user data. */
+function logDebug(ctx, message) {
+	if (ctx.config.debug) getLogger().debug(`Request [${ctx.requestId}] ${message}`);
+}
+/** Values plus errors or warnings: the solve ran, so this 500 is a partial success. */
+function partialSuccessCounts(parsed) {
+	const solveErrors = readField(parsed, "errors");
+	const solveWarnings = readField(parsed, "warnings");
+	if (!readField(parsed, "values") || !(solveErrors || solveWarnings)) return null;
+	return {
+		errors: solveErrors?.length ?? 0,
+		warnings: solveWarnings?.length ?? 0
+	};
+}
+/**
+* Compute8's exception handler sends `{ error, message: "<category>: <detail>", stackTrace? }`;
+* older servers sent PascalCase `Message`/`ExceptionType`/`StackTrace`.
+*/
+function serverErrorDetail(parsed) {
+	const serverMessage = typeof parsed?.message === "string" && parsed.message || typeof parsed?.Message === "string" && parsed.Message || "";
+	if (serverMessage) {
+		const exceptionType = typeof parsed?.ExceptionType === "string" && parsed.ExceptionType || "";
+		const prefix = exceptionType ? `${exceptionType}: ` : "";
+		const stack = parsed?.stackTrace ?? parsed?.StackTrace;
+		const stackStr = Array.isArray(stack) ? stack.join("\n") : stack || "";
+		return `${prefix}${serverMessage}${stackStr ? `\n${stackStr}` : ""}`;
+	}
+	if (parsed?.error) return typeof parsed.error === "string" ? parsed.error : JSON.stringify(parsed.error, null, 2);
+}
+async function handleErrorStatus(response, ctx, responseTime) {
+	const { maxResponseBytes = Infinity, onServerTiming } = ctx.config;
+	const isServerError = response.status === 500;
+	const { text: rawBody, truncated } = await readBodyText(response, isServerError ? maxResponseBytes : Math.min(ERROR_BODY_MAX_BYTES, maxResponseBytes));
+	if (truncated && isServerError) throw tooLargeError(response, ctx);
+	logDebug(ctx, `failed with HTTP ${response.status} in ${responseTime}ms (${rawBody.length} chars)`);
+	const parsed = truncated ? void 0 : tryParseJson(rawBody);
+	let detail = rawBody;
+	if (isServerError && parsed !== void 0) {
+		const partial = partialSuccessCounts(parsed);
+		if (partial) {
+			setResponseWireSize(parsed, rawBody.length);
+			logDebug(ctx, `completed in ${responseTime}ms with ${partial.errors} solver error(s), ${partial.warnings} warning(s)`);
+			fireServerTiming(response, ctx.requestId, onServerTiming);
+			return {
+				ok: true,
+				value: parsed
+			};
+		}
+		detail = serverErrorDetail(parsed) ?? rawBody;
+	}
+	const code = parsed?.code;
+	throwHttpError(response, ctx, rawBody, detail, typeof code === "string" ? code : void 0);
+}
+async function parseSuccessBody(response, ctx) {
+	const { maxResponseBytes = Infinity, signal } = ctx.config;
+	try {
+		const { text: rawBody, truncated } = await readBodyText(response, maxResponseBytes);
+		if (truncated) throw tooLargeError(response, ctx);
+		const parsed = JSON.parse(rawBody);
+		setResponseWireSize(parsed, rawBody.length);
+		return {
+			ok: true,
+			value: parsed
+		};
+	} catch (error) {
+		if (signal?.aborted || isAbortError(error) || error instanceof ComputeError) throw error;
+		const contentType = (response.headers.get("Content-Type") ?? "").toLowerCase();
+		if (contentType !== "" && !contentType.includes("json")) throw new ComputeError(`Server returned a non-JSON response (Content-Type: ${contentType}) — check the server URL / proxy configuration`, ErrorCodes.INVALID_RESPONSE, {
+			statusCode: response.status,
+			context: {
+				url: ctx.fullUrl,
+				requestId: ctx.requestId,
+				contentType
+			},
+			originalError: error
+		});
+		return {
+			ok: false,
+			retryable: true,
+			cause: new ComputeError("Failed to parse JSON response", ErrorCodes.NETWORK_ERROR, {
+				statusCode: response.status,
+				context: {
+					url: ctx.fullUrl,
+					requestId: ctx.requestId
+				},
+				originalError: error
+			})
+		};
+	}
+}
+/** Throws a {@link ComputeError} for anything a retry can't fix. */
+async function handleResponse(response, ctx, startTime) {
+	const responseTime = Math.round(performance.now() - startTime);
+	if (isRedirect(response)) {
+		await response.body?.cancel().catch(() => {});
+		throw redirectError(response, ctx);
+	}
+	if (!response.ok) return handleErrorStatus(response, ctx, responseTime);
+	logDebug(ctx, `completed in ${responseTime}ms`);
+	fireServerTiming(response, ctx.requestId, ctx.config.onServerTiming);
+	return parseSuccessBody(response, ctx);
+}
+/**
+* Matched against the probe's error string, which `probeServer` builds with undici's `cause` in
+* it. A browser collapses every failure into an opaque "Failed to fetch", which reads as unknown.
+*/
+var REFUSED_PATTERN = /ECONNREFUSED|ERR_CONNECTION_REFUSED|connection refused/i;
+var DNS_PATTERN = /ENOTFOUND|EAI_AGAIN|getaddrinfo|ERR_NAME_NOT_RESOLVED|dns/i;
+var TIMEOUT_PATTERN = /TimeoutError|ETIMEDOUT|ECONNRESET|EHOSTUNREACH|ENETUNREACH|abort|timed? ?out/i;
+/**
+* Classify a `ComputeServerStats.probeServer` result.
+*
+* A DNS failure is treated as retryable even though a missing record won't fix
+* itself: `EAI_AGAIN` is a *timeout* talking to the resolver, and the two are
+* not distinguishable from the error alone. Retrying a genuinely-wrong hostname
+* costs one window; giving up on a resolver hiccup breaks a server that is fine.
+*
+* @param probe - The `{ online, status?, error? }` a probe returned. An `online`
+*   probe is not a failure and yields `null`.
+*/
+function classifyProbeFailure(probe) {
+	if (probe.online) return null;
+	if (probe.status !== void 0) {
+		if (probe.status === 401 || probe.status === 403) return {
+			verdict: "unauthorized",
+			retryable: false,
+			summary: `The server rejected the liveness probe with HTTP ${probe.status} — check the API key.`
+		};
+		const retryable = probe.status >= 500;
+		return {
+			verdict: "http_error",
+			retryable,
+			summary: retryable ? `The server answered HTTP ${probe.status} — it may still be starting up.` : `The server answered HTTP ${probe.status}, which will not change on retry.`
+		};
+	}
+	const error = probe.error ?? "";
+	if (REFUSED_PATTERN.test(error)) return {
+		verdict: "refused",
+		retryable: false,
+		summary: "Connection refused — the host is reachable but nothing is listening on that port. Rhino.Compute is not running, or the URL names the wrong port."
+	};
+	if (DNS_PATTERN.test(error)) return {
+		verdict: "dns",
+		retryable: true,
+		summary: "The server hostname could not be resolved — check the URL and DNS."
+	};
+	if (TIMEOUT_PATTERN.test(error)) return {
+		verdict: "timeout",
+		retryable: true,
+		summary: "No response before the timeout — the machine may be powered off, blocked by a firewall, or still booting."
+	};
+	return {
+		verdict: "unknown",
+		retryable: true,
+		summary: error ? `The connection failed: ${error}` : "The connection failed."
+	};
+}
+async function attemptFetch(ctx, policy, attempt, isFinal) {
+	const { signal, cleanup } = composeSignal(ctx.config.signal, ctx.config.timeoutMs);
+	const startTime = performance.now();
+	const send = ctx.config.fetch ?? fetch;
+	try {
+		const response = await send(ctx.fullUrl, {
+			method: "POST",
+			body: ctx.body,
+			headers: ctx.headers,
+			signal,
+			redirect: "manual"
+		});
+		if (!isFinal && isRetryableStatus(response.status, policy)) {
+			await readBodyText(response, ERROR_BODY_MAX_BYTES).catch(() => {});
+			return {
+				ok: false,
+				retryable: true,
+				delayMs: retryDelay(response.headers.get("Retry-After"), attempt, policy),
+				cause: new ComputeError(`HTTP ${response.status} ${response.statusText} (will retry)`, response.status === 429 ? ErrorCodes.RATE_LIMIT : ErrorCodes.NETWORK_ERROR, {
+					statusCode: response.status,
+					context: ctx.errorContext
+				})
+			};
+		}
+		return await handleResponse(response, ctx, startTime);
+	} catch (error) {
+		return classifyFetchError(error, ctx);
+	} finally {
+		cleanup();
+	}
+}
+function classifyFetchError(error, ctx) {
+	if (error instanceof ComputeError) return {
+		ok: false,
+		retryable: false,
+		cause: error
+	};
+	if (ctx.config.signal?.aborted) return {
+		ok: false,
+		retryable: false,
+		cause: abortedByCaller(ctx.errorContext, error)
+	};
+	if (isAbortError(error)) {
+		const { timeoutMs } = ctx.config;
+		return {
+			ok: false,
+			retryable: true,
+			cause: typeof timeoutMs === "number" && timeoutMs > 0 ? new ComputeError(`Request timed out after ${timeoutMs}ms`, ErrorCodes.TIMEOUT_ERROR, {
+				context: {
+					...ctx.errorContext,
+					timeoutMs
+				},
+				originalError: error
+			}) : new ComputeError(`Request aborted by the runtime (${error.name}): ${error.message}`, ErrorCodes.NETWORK_ERROR, {
+				context: ctx.errorContext,
+				originalError: error
+			})
+		};
+	}
+	if (error instanceof TypeError) return {
+		ok: false,
+		retryable: true,
+		cause: typeof window !== "undefined" && typeof window.document !== "undefined" ? new ComputeError(`Request failed: ${error.message} — in a browser this usually means a CORS misconfiguration on the server (or a network failure; the browser does not distinguish them)`, ErrorCodes.CORS_ERROR, {
+			context: ctx.errorContext,
+			originalError: error
+		}) : new ComputeError(`Network error: ${error.message}`, ErrorCodes.NETWORK_ERROR, {
+			context: ctx.errorContext,
+			originalError: error
+		})
+	};
+	return {
+		ok: false,
+		retryable: false,
+		cause: new ComputeError(error instanceof Error ? error.message : String(error), ErrorCodes.UNKNOWN_ERROR, {
+			context: ctx.errorContext,
+			originalError: error
+		})
+	};
+}
+function requireNumber(name, value, isValid) {
+	if (value !== void 0 && !isValid(value)) throw new ComputeError(`${name} is not usable: ${value}`, ErrorCodes.INVALID_CONFIG, { context: { [name]: value } });
+}
+/** `NaN` fails every comparison, so unchecked it disables a loop's exit or a limit. */
+function validateNumbers({ timeoutMs, maxResponseBytes, retry }) {
+	const notNegative = (n) => n >= 0;
+	requireNumber("timeoutMs", timeoutMs, (n) => n <= MAX_TIMEOUT_MS);
+	requireNumber("maxResponseBytes", maxResponseBytes, notNegative);
+	requireNumber("retry.attempts", retry?.attempts, (n) => notNegative(n) && Number.isFinite(n));
+	requireNumber("retry.baseDelayMs", retry?.baseDelayMs, notNegative);
+	requireNumber("retry.maxDelayMs", retry?.maxDelayMs, notNegative);
+}
+/**
+* POST `args` as JSON to `<serverUrl>/<endpoint>` with retry, timeout and abort handling, and
+* return the parsed response. Most callers want a higher-level API.
+*
+* `R` names the expected response shape; nothing checks it, so the default `unknown` forces a
+* narrowing.
+*
+* @example
+* const response = await fetchCompute('grasshopper', args, {
+*   serverUrl: 'https://my-server.com',
+*   timeoutMs: 30_000,
+*   retry: { attempts: 2 },
+*   signal: controller.signal
+* });
+*/
+async function fetchCompute(endpoint, args, config) {
+	const requestId = generateRequestId();
+	let body;
+	try {
+		body = JSON.stringify(args);
+	} catch (error) {
+		throw new ComputeError(`Request body is not JSON-serializable: ${error instanceof Error ? error.message : String(error)}`, ErrorCodes.INVALID_INPUT, {
+			context: {
+				endpoint,
+				requestId
+			},
+			originalError: error
+		});
+	}
+	const requestSize = utf8ByteLength(body);
+	const serverUrl = validateServerUrl(config.serverUrl, { blockedHosts: [] });
+	validateNumbers(config);
+	const fullUrl = buildUrl(endpoint, serverUrl);
+	const headers = buildHeaders(requestId, config);
+	const retryPolicy = resolveRetryPolicy(config.retry);
+	const totalAttempts = retryPolicy.attempts + 1;
+	if (config.debug) {
+		const sizeKb = (requestSize / 1024).toFixed(2);
+		getLogger().debug(`Starting compute request [${requestId}]: ${endpoint} (${sizeKb}KB)`);
+	}
+	const ctx = {
+		endpoint,
+		body,
+		requestSize,
+		fullUrl,
+		requestId,
+		headers,
+		config,
+		errorContext: {
+			serverUrl,
+			url: fullUrl,
+			endpoint,
+			requestId,
+			requestSize
+		}
+	};
+	for (let attempt = 0;; attempt++) {
+		const isFinal = attempt >= retryPolicy.attempts;
+		const result = await attemptFetch(ctx, retryPolicy, attempt, isFinal);
+		if (result.ok) return result.value;
+		if (isFinal || !result.retryable) throw result.cause;
+		const delayMs = result.delayMs ?? backoffDelay(attempt, retryPolicy);
+		if (config.debug) getLogger().debug(`Request [${requestId}] retrying after ${delayMs}ms (attempt ${attempt + 2}/${totalAttempts}): ${result.cause.code}`);
+		try {
+			await sleep(delayMs, config.signal);
+		} catch {
+			throw abortedByCaller(ctx.errorContext, result.cause);
+		}
+	}
+}
+function isDefinitionRef(definition) {
+	return typeof definition === "object" && !(definition instanceof Uint8Array) && typeof definition.key === "string" && typeof definition.load === "function";
+}
+/** A URL is already a server-side reference: it is never uploaded or keyed by server cache key. */
+function isDefinitionUrl(definition) {
+	return typeof definition === "string" && /^https?:\/\//i.test(definition);
+}
+/**
+* The `Sub Folder` convention, as authored on Selva's Grasshopper file components.
+*
+* `::` nests, matching Rhino's layer separator (`ROOT::Panels`), and `/` and `\` are accepted
+* because people type them out of habit. The plugin normalizes to `/` before sending, so these
+* helpers also cover payloads from an older plugin that still emit `::`.
+*
+* The first segment is the **root**, which names the archive rather than becoming a folder inside
+* it: `ROOT::Panels` downloads as `ROOT.zip` containing `Panels/…`. Files sharing a root travel
+* together; distinct roots produce separate archives.
+*/
+/**
+* Split a `Sub Folder` value into folder segments; `/`, `\` and `::` all separate.
+*
+* Exported because anything rendering a folder tree has to agree with the archive on where the
+* boundaries are — splitting on `/` alone leaves `Main::Panels` as one literal segment and shows
+* a folder named after the separator.
+*/
+var subFolderSegments = (subFolder) => (subFolder ?? "").replace(/::/g, "/").replace(/\\/g, "/").split("/").map((segment) => segment.trim()).filter((segment) => segment !== "");
+/** First `Sub Folder` segment, or `''` when the file sits at the top level. */
+var rootOf = (file) => subFolderSegments(file.subFolder)[0] ?? "";
+/**
+* Everything below the root, as a `/`-joined path. The root names the archive, so repeating it
+* inside would nest it twice.
+*/
+var pathBelowRoot = (file) => subFolderSegments(file.subFolder).slice(1).join("/");
+/**
+* Group files by their `Sub Folder` root, preserving encounter order.
+*
+* Rootless files group under `''` — a caller naming archives supplies its own fallback for that
+* bucket. Useful beyond downloading: a consumer writing to disk gets the same grouping without
+* touching the DOM.
+*/
+var groupFilesByRoot = (files) => {
+	const groups = /* @__PURE__ */ new Map();
+	for (const file of files) {
+		const root = rootOf(file);
+		const bucket = groups.get(root);
+		if (bucket) bucket.push(file);
+		else groups.set(root, [file]);
+	}
+	return Array.from(groups, ([root, grouped]) => ({
+		root,
+		files: grouped
+	}));
+};
+/**
+* Make a root usable as a download filename: path separators and the characters Windows forbids
+* would otherwise reach the download attribute verbatim and produce a broken or misdirected save.
+*/
+var toArchiveName = (root) => {
+	const safe = root.replace(/[/\\:*?"<>|]/g, "_").replace(/\s+/g, " ").trim().replace(/^\.+/, "");
+	return safe === "" ? "files" : safe;
+};
+/**
+* Decode the files in a compute response, plus any external `additionalFiles`, without
+* downloading them. Never throws: an unnamed or undecodable item and a failed external fetch are
+* logged and dropped, the rest still resolve. Colliding archive paths are renamed
+* (`model.txt` → `model-2.txt`), so a consumer keying by `path` loses nothing.
+*/
+var extractFilesFromComputeResponse = async (downloadableFiles, additionalFiles = null) => {
+	const processedFiles = decodeResponseFiles(downloadableFiles);
+	if (additionalFiles) {
+		const filesArray = Array.isArray(additionalFiles) ? additionalFiles : [additionalFiles];
+		processedFiles.push(...await fetchRemoteFiles(filesArray));
+	}
+	const taken = /* @__PURE__ */ new Set();
+	return processedFiles.map((file) => {
+		const path = uniqueArchivePath(file.path, taken);
+		taken.add(path);
+		if (path === file.path) return file;
+		getLogger().warn(`Duplicate archive path "${file.path}" — storing as "${path}".`);
+		return {
+			...file,
+			path,
+			fileName: path.slice(path.lastIndexOf("/") + 1)
+		};
+	});
+};
+/** Downloads files from a compute response as a ZIP archive. */
+var downloadFileData = async (downloadableFiles, fileFoldername, additionalFiles = null, options = {}) => {
+	if (typeof document === "undefined" || typeof Blob === "undefined") throw new ComputeError("File download functionality is only available in browser environments. This function requires the DOM API (document, Blob).", ErrorCodes.BROWSER_ONLY, { context: {
+		environment: typeof window !== "undefined" ? "browser (SSR)" : "Node.js",
+		documentAvailable: typeof document !== "undefined",
+		blobAvailable: typeof Blob !== "undefined"
+	} });
+	try {
+		await createAndDownloadZip(await extractFilesFromComputeResponse(downloadableFiles, additionalFiles), fileFoldername, options.saveBlob ?? saveFile);
+	} catch (err) {
+		if (err instanceof ComputeError) throw err;
+		throw new ComputeError("Failed to download files from compute response", ErrorCodes.INVALID_STATE, {
+			context: {
+				fileCount: downloadableFiles.length,
+				zipName: fileFoldername
+			},
+			originalError: err
+		});
+	}
+};
+/**
+* Download one archive per `Sub Folder` root (see {@link groupFilesByRoot}). Files with no root go
+* into `fallbackName`, so a definition that never sets `Sub Folder` downloads as one archive.
+*
+* Archives are saved one at a time: browsers discard concurrent downloads issued in the same tick.
+* More than one save per gesture may prompt the user for permission.
+*
+* @param downloadableFiles - `FileData` items from the compute response.
+* @param fallbackName - Archive name for files with no `Sub Folder` root.
+* @param additionalFiles - Extra files to package; they carry no root and join the fallback archive.
+* @param options - `saveBlob` replaces the anchor download for every archive.
+*/
+var downloadFileDataByRoot = async (downloadableFiles, fallbackName, additionalFiles = null, options = {}) => {
+	const groups = groupFilesByRoot(downloadableFiles);
+	if (groups.length === 0) {
+		await downloadFileData([], fallbackName, additionalFiles, options);
+		return;
+	}
+	const extrasRoot = (groups.find((group) => group.root === "") ?? groups[0]).root;
+	for (const { root, files } of groups) await downloadFileData(root === "" ? files : files.map((file) => ({
+		...file,
+		subFolder: pathBelowRoot(file)
+	})), root === "" ? fallbackName : toArchiveName(root), root === extrasRoot ? additionalFiles : null, options);
+};
+/**
+* Zip-slip defense for a server-controlled path: drop `.`, `..` and drive-prefixed segments
+* (`C:`, and `C:evil`, which is relative to that drive's working directory) so no entry escapes
+* the extraction directory. `''` when nothing safe remains.
+*/
+var sanitizeArchivePath = (raw) => subFolderSegments(raw).filter((segment) => segment !== "." && segment !== ".." && !/^[a-zA-Z]:/.test(segment)).join("/");
+/** The `isBase64Encoded` wire flag. Some server branches send booleans as strings (`"True"`). */
+var isBase64Flag = (flag) => flag === true || typeof flag === "string" && flag.trim().toLowerCase() === "true";
+var joinArchivePath = (subFolder, name) => subFolder !== "" ? `${subFolder}/${name}` : name;
+var decodeResponseFiles = (dataItems) => {
+	const processedFiles = [];
+	dataItems.forEach((item) => {
+		const rawName = readField(item, "fileName") ?? "";
+		const rawType = readField(item, "fileType") ?? "";
+		const fileName = sanitizeArchivePath(`${rawName}${rawType}`);
+		if (fileName === "") {
+			getLogger().warn(`Skipping file with unusable name "${rawName}${rawType}": no safe archive path remains after sanitization.`);
+			return;
+		}
+		const rawSubFolder = readField(item, "subFolder");
+		const subFolder = rawSubFolder ? sanitizeArchivePath(rawSubFolder) : "";
+		const filePath = joinArchivePath(subFolder, fileName);
+		const data = readField(item, "data");
+		if (typeof data !== "string" || data === "") {
+			getLogger().warn(`Skipping file "${filePath}": item carries no usable data.`);
+			return;
+		}
+		let content = data;
+		if (isBase64Flag(readField(item, "isBase64Encoded"))) try {
+			content = decodeBase64ToBinary(data);
+		} catch (err) {
+			getLogger().warn(`Skipping file "${filePath}": base64 decode failed.`, err);
+			return;
+		}
+		const metadata = readField(item, "metadata");
+		processedFiles.push({
+			fileName,
+			content,
+			path: filePath,
+			subFolder,
+			...metadata ? { metadata } : {}
+		});
+	});
+	return processedFiles;
+};
+/** One dead URL must degrade the batch, not stall it forever. */
+var REMOTE_FILE_TIMEOUT_MS = 3e4;
+var fetchRemoteFiles = async (refs) => {
+	return (await Promise.all(refs.map(async (file) => {
+		try {
+			const response = await fetch(file.filePath, { signal: AbortSignal.timeout(REMOTE_FILE_TIMEOUT_MS) });
+			if (!response.ok) {
+				getLogger().warn(`Failed to fetch additional file: ${redactUrl(file.filePath)}`);
+				return null;
+			}
+			const arrayBuffer = await response.arrayBuffer();
+			const safeName = sanitizeArchivePath(file.fileName);
+			if (safeName === "") {
+				getLogger().warn(`Skipping fetched file with unusable name: ${file.fileName}`);
+				return null;
+			}
+			const subFolder = file.subFolder ? sanitizeArchivePath(file.subFolder) : "";
+			return {
+				fileName: safeName,
+				content: new Uint8Array(arrayBuffer),
+				path: joinArchivePath(subFolder, safeName),
+				subFolder
+			};
+		} catch (error) {
+			const reason = error instanceof Error ? error.name : "unknown error";
+			getLogger().error(`Error fetching additional file ${redactUrl(file.filePath)}: ${reason}`);
+			return null;
+		}
+	}))).filter((f) => f !== null);
+};
+async function createAndDownloadZip(files, zipName, save) {
+	const { zip, strToU8 } = await import('./esm.js-CRiT7ECX.js');
+	const taken = new Set(files.map((file) => file.path));
+	const zipData = {};
+	for (const file of files) {
+		const path = file.path === "__proto__" ? uniqueArchivePath(file.path, taken) : file.path;
+		taken.add(path);
+		zipData[path] = typeof file.content === "string" ? strToU8(file.content) : file.content;
+	}
+	const zipped = await new Promise((resolve, reject) => {
+		zip(zipData, { level: 6 }, (err, data) => err ? reject(err) : resolve(data));
+	});
+	await save(new Blob([zipped], { type: "application/zip" }), `${zipName}.zip`);
+}
+/**
+* First archive path not already taken in `taken`, disambiguating with a
+* numeric suffix before the extension: `dir/model.txt` → `dir/model-2.txt`.
+*/
+function uniqueArchivePath(path, taken) {
+	if (!taken.has(path)) return path;
+	const slash = path.lastIndexOf("/");
+	const dot = path.lastIndexOf(".");
+	const stemEnd = dot > slash ? dot : path.length;
+	const stem = path.slice(0, stemEnd);
+	const ext = path.slice(stemEnd);
+	for (let i = 2;; i++) {
+		const candidate = `${stem}-${i}${ext}`;
+		if (!taken.has(candidate)) return candidate;
+	}
+}
+function saveFile(blob, filename) {
+	const url = URL.createObjectURL(blob);
+	const a = document.createElement("a");
+	a.href = url;
+	a.download = filename;
+	document.body.appendChild(a);
+	a.click();
+	a.remove();
+	setTimeout(() => URL.revokeObjectURL(url), 1e4);
+}
+// ../compute/dist/grasshopper.js
+/**
+* Server health and control: liveness, version, child processes, cache purges.
+*
+* @example
+* ```typescript
+* const stats = new ComputeServerStats('http://localhost:6500', 'your-api-key');
+*
+* try {
+*   const isOnline = await stats.isServerOnline();
+*   const children = await stats.getActiveChildren();
+*   const version = await stats.getVersion();
+*
+*   // Or get everything at once
+*   const allStats = await stats.getServerStats();
+* } finally {
+*   await stats.dispose(); // Clean up resources
+* }
+* ```
+*/
+var ComputeServerStats = class ComputeServerStats {
+	serverUrl;
+	headers;
+	disposed = false;
+	activeMonitors = /* @__PURE__ */ new Set();
+	/** Timeout (ms) for the fast read/monitoring endpoints. */
+	static DEFAULT_TIMEOUT_MS = 5e3;
+	/** Timeout (ms) for child-lifecycle POSTs — a cold Windows child can take ~30s to spawn. */
+	static LIFECYCLE_TIMEOUT_MS = 6e4;
+	/** Floor for `monitor()`'s `intervalMs` — anything lower hot-loops the server. */
+	static MIN_MONITOR_INTERVAL_MS = 100;
+	/** Every control-plane answer is a count, a version or a short map. */
+	static MAX_BODY_BYTES = 1 << 20;
+	/**
+	* @param serverUrl - Base URL of the Rhino Compute server with http:// or https:// scheme (e.g., 'http://localhost:6500')
+	* @param auth - An API key, or the same auth fields a solve's `ComputeConfig` carries
+	*   (`apiKey`, `apiKeyHeader`, `authToken`, `headers`).
+	*/
+	constructor(serverUrl, auth) {
+		this.serverUrl = validateServerUrl(serverUrl);
+		this.headers = buildAuthHeaders(typeof auth === "string" ? { apiKey: auth } : auth ?? {});
+	}
+	/**
+	* Aborts after `timeoutMs` so a hung connection can't stall a probe or `monitor()`; `0` disables
+	* it. Redirects are not followed: fetch would carry the API key header to the target.
+	*/
+	async fetchWithTimeout(url, init = {}, timeoutMs = ComputeServerStats.DEFAULT_TIMEOUT_MS) {
+		const { signal, cleanup } = composeSignal(init.signal ?? void 0, timeoutMs);
+		try {
+			return await fetch(url, {
+				...init,
+				headers: init.method === "POST" ? withJsonContentType(this.headers) : this.headers,
+				redirect: "manual",
+				signal
+			});
+		} finally {
+			cleanup();
+		}
+	}
+	/**
+	* The response body of `path`, or `null` (logged) on a non-2xx or a network
+	* failure. Throws only when disposed.
+	*/
+	async getText(path, init = {}, timeoutMs = ComputeServerStats.DEFAULT_TIMEOUT_MS) {
+		this.ensureNotDisposed();
+		const label = `${init.method ?? "GET"} ${path}`;
+		try {
+			const response = await this.fetchWithTimeout(`${this.serverUrl}${path}`, init, timeoutMs);
+			if (!response.ok) {
+				getLogger().warn(`[ComputeServerStats] ${label} failed:`, response.status);
+				await response.body?.cancel().catch(() => {});
+				return null;
+			}
+			const { text, truncated } = await readBodyText(response, ComputeServerStats.MAX_BODY_BYTES);
+			if (truncated) {
+				getLogger().warn(`[ComputeServerStats] ${label} answered with an oversized body`);
+				return null;
+			}
+			return text;
+		} catch (err) {
+			getLogger().warn(`[ComputeServerStats] ${label} errored:`, err);
+			return null;
+		}
+	}
+	/**
+	* Check if the server is online.
+	*
+	* This is a single-sample probe: it returns `true` only on a 2xx or a redirect
+	* from the proxy liveness root `/`, and `false` for every other outcome (4xx/5xx,
+	* network error, or timeout). A cold or briefly-busy-but-up server can therefore
+	* read as offline — callers that gate on this (e.g. client construction)
+	* should retry rather than treat a single `false` as authoritative.
+	*
+	* @param timeoutMs - Abort the probe after this many ms (default: 5000).
+	*   Pass `0` to disable the timeout. Prevents a hung connection from
+	*   stalling the caller indefinitely.
+	*/
+	async isServerOnline(timeoutMs = ComputeServerStats.DEFAULT_TIMEOUT_MS) {
+		return (await this.probeServer(timeoutMs)).online;
+	}
+	/**
+	* Detailed liveness probe backing {@link isServerOnline}.
+	*
+	* Reports what the probe actually saw so callers can distinguish "connection
+	* failed" (`error` set) from "server answered non-2xx" (`status` set) — e.g.
+	* a 401 from a proxy that requires an API key is a misconfiguration, not an
+	* offline server. Same single-sample caveat as {@link isServerOnline}.
+	*
+	* @param timeoutMs - Abort the probe after this many ms (default: 5000).
+	*   Pass `0` to disable the timeout.
+	* @param signal - Cancels the probe, which then reports the abort as its `error`.
+	* @returns `online` plus either the HTTP `status` the server answered with,
+	*   or the `error` the connection attempt failed with.
+	*/
+	async probeServer(timeoutMs = ComputeServerStats.DEFAULT_TIMEOUT_MS, signal) {
+		this.ensureNotDisposed();
+		const url = `${this.serverUrl}/`;
+		try {
+			const response = await this.fetchWithTimeout(url, {
+				method: "GET",
+				signal
+			}, timeoutMs);
+			await response.body?.cancel().catch(() => {});
+			return {
+				online: response.ok || isRedirect(response),
+				status: response.status
+			};
+		} catch (err) {
+			const error = describeProbeError(err);
+			getLogger().debug(`[ComputeServerStats] Fetch error: ${error}`);
+			return {
+				online: false,
+				error
+			};
+		}
+	}
+	/**
+	* Get the number of active child processes on the server.
+	*
+	* By default the proxy's `/activechildren` endpoint will *spawn* children up
+	* to the configured count if none are running, then report the count — which
+	* wakes (and bills) an idle server. Pass `{ initialize: false }` for a passive
+	* read that reports the current count without spawning; use this for
+	* monitoring or before a purge/probe where you must not wake the server.
+	*
+	* @param options.initialize - When `false`, append `?initialize=false` so the
+	*   server reports without spawning. Defaults to `true` (the server's default).
+	* @returns Number of active children, or null if unavailable
+	*/
+	async getActiveChildren(options = {}) {
+		const { initialize = true } = options;
+		const body = initialize ? await this.getText("/activechildren", {}, ComputeServerStats.LIFECYCLE_TIMEOUT_MS) : await this.getText("/activechildren?initialize=false");
+		if (body === null) return null;
+		const text = body.trim();
+		if (!/^\d+$/.test(text)) {
+			getLogger().warn("[ComputeServerStats] /activechildren answered with a non-numeric body");
+			return null;
+		}
+		return parseInt(text, 10);
+	}
+	/**
+	* Get the server version information.
+	*
+	* @returns Version object with rhino, compute, and git_sha, or null if unavailable
+	*/
+	async getVersion() {
+		const text = await this.getText("/version");
+		if (text === null) return null;
+		const json = tryParseJson(text);
+		if (json == null) return {
+			rhino: text,
+			compute: "",
+			git_sha: null
+		};
+		return {
+			rhino: json.rhino ?? "",
+			compute: json.compute ?? "",
+			git_sha: json.git_sha ?? null
+		};
+	}
+	/**
+	* Get the plugins installed on the server.
+	*
+	* Returns a `name → version` map of non-core plugins the server has loaded,
+	* or `null` if the request failed. Pass `kind` to choose which inventory:
+	* `'gh'` (default) lists Grasshopper add-on assemblies via
+	* `/plugins/gh/installed`; `'rhino'` lists Rhino plugins via
+	* `/plugins/rhino/installed`. Plugins that ship with Rhino / are core
+	* libraries are excluded by the server.
+	*
+	* @param kind - `'gh'` for Grasshopper add-ons (default) or `'rhino'` for Rhino plugins.
+	* @returns Map of plugin name to version, or `null` on failure.
+	*
+	* @example
+	* ```ts
+	* const gh = await stats.getInstalledPlugins();        // Grasshopper add-ons
+	* const selvaVersion = gh?.['Selva'] ?? null;
+	* ```
+	*/
+	async getInstalledPlugins(kind = "gh") {
+		const text = await this.getText(`/plugins/${kind}/installed`);
+		const json = text === null ? void 0 : tryParseJson(text);
+		return json && typeof json === "object" ? json : null;
+	}
+	/**
+	* Get comprehensive server statistics.
+	* Fetches all available server information in parallel.
+	*
+	* @returns Object containing server status and available stats
+	*/
+	async getServerStats() {
+		this.ensureNotDisposed();
+		if (!await this.isServerOnline()) return { isOnline: false };
+		const [version, activeChildren] = await Promise.all([this.getVersion(), this.getActiveChildren({ initialize: false })]);
+		return {
+			isOnline: true,
+			...version && { version },
+			...activeChildren !== null && { activeChildren }
+		};
+	}
+	/**
+	* Purge the server's solve-results / URL-data cache.
+	*
+	* POSTs to `cache/purge` and returns the number of entries removed, or `null`
+	* if the request failed. This clears cached solve responses and fetched
+	* definition-URL data; it does NOT evict the definition cache (active
+	* `pointer` references stay valid).
+	*
+	* **Caveat:** `cache/purge` is forwarded by the rhino.compute proxy to a
+	* single round-robin-selected child, so in a multi-child deployment one call
+	* purges one child's cache. Call repeatedly (or size the pool to 1) if you
+	* need a fleet-wide purge.
+	*
+	* @returns Number of entries removed, or `null` on failure.
+	*
+	* @example
+	* ```ts
+	* const removed = await stats.purgeCache();
+	* if (removed !== null) console.log(`Purged ${removed} cached solves`);
+	* ```
+	*/
+	async purgeCache() {
+		const text = await this.getText("/cache/purge", { method: "POST" });
+		const purged = (text === null ? void 0 : tryParseJson(text))?.purged;
+		return typeof purged === "number" ? purged : null;
+	}
+	/**
+	* Best-effort fleet-wide cache purge across a multi-child deployment.
+	*
+	* A single {@link purgeCache} POST is forwarded by the rhino.compute proxy to
+	* just ONE round-robin-selected child, so the other children keep serving
+	* stale cached solves. There is no proxy endpoint that addresses children
+	* individually, so this method reads the active child count (passively, never
+	* spawning) and fires `2 × count` sequential purges, relying on the proxy's
+	* round-robin to spread the hits across the pool.
+	*
+	* **This is best-effort, not a guarantee.** Round-robin can revisit one child
+	* and skip another; under concurrent traffic the rotation drifts. The result's
+	* `confident` flag is `true` only when the server reports a single child (where
+	* one purge is exact) — surface it so callers don't over-promise. For a hard
+	* fleet-wide guarantee, run the deployment at `--childcount 1` or add a
+	* server-side fan-out endpoint.
+	*
+	* @returns `{ totalPurged, calls, children, confident }`, or `null` if the
+	*   child count couldn't be read (server unreachable). `totalPurged` sums the
+	*   per-call counts; `calls` is how many purges were issued; `children` is the
+	*   reported pool size; `confident` is `true` only at a single-child pool.
+	*
+	* @example
+	* ```ts
+	* const r = await stats.purgeAllChildren();
+	* if (r && !r.confident) {
+	*   console.warn(`Purged ~${r.totalPurged} across ${r.children} children (best-effort)`);
+	* }
+	* ```
+	*/
+	async purgeAllChildren() {
+		this.ensureNotDisposed();
+		const children = await this.getActiveChildren({ initialize: false });
+		if (children === null) {
+			getLogger().warn("[ComputeServerStats] purgeAllChildren: could not read child count");
+			return null;
+		}
+		if (children === 0) return {
+			totalPurged: 0,
+			calls: 0,
+			children: 0,
+			confident: true
+		};
+		const calls = children * 2;
+		let totalPurged = 0;
+		for (let i = 0; i < calls; i++) {
+			const purged = await this.purgeCache();
+			if (purged !== null) totalPurged += purged;
+		}
+		return {
+			totalPurged,
+			calls,
+			children,
+			confident: children === 1
+		};
+	}
+	/**
+	* Get the server's current UTC clock.
+	*
+	* GETs `/servertime`, which the server emits as a JSON-encoded ISO-8601
+	* timestamp (e.g. `"2026-06-18T08:30:00Z"`). Useful for detecting clock skew
+	* between caller and server. Returns `null` if the request failed or the body
+	* isn't a parseable date.
+	*
+	* @returns A `Date` for the server's UTC time, or `null` on failure.
+	*/
+	async getServerTime() {
+		const text = await this.getText("/servertime");
+		if (text === null) return null;
+		const date = new Date(text.trim().replace(/^"|"$/g, ""));
+		return isNaN(date.getTime()) ? null : date;
+	}
+	/**
+	* Get how long the rhino.compute proxy has been idle.
+	*
+	* GETs `/idlespan` on the proxy, which returns the seconds elapsed since the
+	* last request was forwarded to a compute child. This is a proxy-level metric
+	* (not proxied to a child) used by autoscalers to decide when a node can be
+	* drained. Returns `null` if unavailable.
+	*
+	* @returns Idle time in seconds, or `null` on failure.
+	*/
+	async getIdleSpan() {
+		const text = await this.getText("/idlespan");
+		if (text === null) return null;
+		const seconds = parseFloat(text.trim());
+		return isNaN(seconds) ? null : seconds;
+	}
+	/**
+	* Fill the compute child pool up to the server's configured baseline.
+	*
+	* POSTs `/launch-children`. No-op when the pool is already at or above the
+	* configured `--childcount`. Returns `{ spawned, active }` — how many children
+	* were started and the resulting child count — or `null` on failure.
+	*
+	* To raise capacity above the baseline use {@link launchChild}; the baseline
+	* itself can only be changed by restarting rhino.compute.
+	*
+	* @returns `{ spawned, active }`, or `null` on failure.
+	*/
+	async launchChildren() {
+		return this.postJson("/launch-children");
+	}
+	/**
+	* Add a single compute child to the pool, optionally on a specific port.
+	*
+	* POSTs `/launch-child` (with `?port=N` when `port` is given). Unlike
+	* {@link launchChildren}, this can push the pool above the baseline, up to the
+	* server's `MaxChildren` cap. Returns `{ spawned: [port] }` on success, or
+	* `null` on failure (server replies 400 for a bad port, 409 if the port is in
+	* use, 503 at the max-children cap).
+	*
+	* @param port - Optional specific port to launch on; otherwise the next free one.
+	* @returns `{ spawned }` listing the launched port, or `null` on failure.
+	*/
+	async launchChild(port) {
+		const path = port === void 0 ? "/launch-child" : `/launch-child?port=${port}`;
+		return this.postJson(path);
+	}
+	/**
+	* Gracefully shut down compute children without respawning them.
+	*
+	* POSTs `/shutdown-children`. With no `port` it shuts down every child; with
+	* `port` it targets just that one. Children do not respawn, but the next
+	* `/grasshopper` request auto-spawns the pool back to the baseline. Returns
+	* `{ shutdown, active }` — how many were stopped and the remaining count — or
+	* `null` on failure.
+	*
+	* @param port - Optional port to target; omit to shut down all children.
+	* @returns `{ shutdown, active }`, or `null` on failure.
+	*/
+	async shutdownChildren(port) {
+		const path = port === void 0 ? "/shutdown-children" : `/shutdown-children?port=${port}`;
+		return this.postJson(path);
+	}
+	/**
+	* Shut down compute children and respawn replacements (rolling restart).
+	*
+	* POSTs `/recycle-children`. With no `port` it recycles every child; with
+	* `port` it recycles just that one. The server recycles sequentially (each
+	* replacement is serving before the next child is stopped) so the pool never
+	* drops to zero mid-recycle. Returns `{ shutdown, spawned, active }`, or
+	* `null` on failure.
+	*
+	* @param port - Optional port to target; omit to recycle all children.
+	* @returns `{ shutdown, spawned, active }`, or `null` on failure.
+	*/
+	async recycleChildren(port) {
+		const path = port === void 0 ? "/recycle-children" : `/recycle-children?port=${port}`;
+		return this.postJson(path);
+	}
+	/** A child-lifecycle POST: a spawn or recycle can take ~30 s. */
+	async postJson(path) {
+		const text = await this.getText(path, { method: "POST" }, ComputeServerStats.LIFECYCLE_TIMEOUT_MS);
+		return text === null ? null : tryParseJson(text) ?? null;
+	}
+	/**
+	* Continuously monitor server stats at specified interval.
+	*
+	* @param callback - Function called with stats on each interval
+	* @param intervalMs - Milliseconds between checks (default: 5000). Must be a
+	*   finite number of at least 100 ms — lower values would hot-loop the server.
+	* @returns Function to stop monitoring
+	* @throws {ComputeError} `INVALID_CONFIG` if `intervalMs` is not a finite number >= 100.
+	*
+	* @example
+	* ```typescript
+	* const stopMonitoring = stats.monitor((data) => {
+	*   console.log('Server stats:', data);
+	* }, 3000);
+	*
+	* // Later...
+	* stopMonitoring();
+	* ```
+	*/
+	monitor(callback, intervalMs = 5e3) {
+		this.ensureNotDisposed();
+		if (!Number.isFinite(intervalMs) || intervalMs < ComputeServerStats.MIN_MONITOR_INTERVAL_MS) throw new ComputeError(`monitor() intervalMs must be a finite number >= ${ComputeServerStats.MIN_MONITOR_INTERVAL_MS}ms, got ${intervalMs}. Sub-${ComputeServerStats.MIN_MONITOR_INTERVAL_MS}ms polling would hot-loop the server.`, ErrorCodes.INVALID_CONFIG, { context: { intervalMs } });
+		let active = true;
+		let currentTimeoutId = null;
+		getLogger().info(`🔄 Starting server stats monitoring every ${intervalMs}ms`);
+		const check = async () => {
+			currentTimeoutId = null;
+			if (!active || this.disposed) return;
+			try {
+				const _stats = await this.getServerStats();
+				if (!active || this.disposed) return;
+				try {
+					callback(_stats);
+				} catch (err) {
+					getLogger().error("[ComputeServerStats] Monitor callback threw:", err);
+				}
+			} catch (err) {
+				if (!active || this.disposed) getLogger().debug("[ComputeServerStats] Monitor poll cancelled during shutdown:", err);
+				else getLogger().error("[ComputeServerStats] Failed to fetch stats during monitor:", err);
+			}
+			if (active && !this.disposed) currentTimeoutId = setTimeout(() => void check(), intervalMs);
+		};
+		const stopMonitoring = () => {
+			active = false;
+			if (currentTimeoutId !== null) {
+				clearTimeout(currentTimeoutId);
+				currentTimeoutId = null;
+			}
+			this.activeMonitors.delete(stopMonitoring);
+		};
+		this.activeMonitors.add(stopMonitoring);
+		check();
+		return stopMonitoring;
+	}
+	/**
+	* Disposes of all resources and stops all active monitors.
+	* Call this when you're done using the stats instance.
+	*/
+	async dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		for (const stopMonitor of this.activeMonitors) stopMonitor();
+		this.activeMonitors.clear();
+	}
+	ensureNotDisposed() {
+		if (this.disposed) throw new ComputeError("ComputeServerStats has been disposed and cannot be used", ErrorCodes.INVALID_STATE);
+	}
+};
+/**
+* undici reports every connection failure as `TypeError: fetch failed` and keeps what happened on
+* `cause`, whose message is empty when several addresses failed: its `code` is the one sure field.
+*/
+function describeProbeError(err) {
+	if (!(err instanceof Error)) return String(err);
+	const summary = `${err.name}: ${err.message}`;
+	if (!(err.cause instanceof Error)) return summary;
+	const { code } = err.cause;
+	return `${summary}: ${typeof code === "string" ? `${code} ` : ""}${err.cause.message}`.trim();
+}
+/**
+* Server message for a `pointer` it can't resolve (evicted, or a different child in the pool).
+* Production servers scrub it, so the `definition_not_cached` code is the reliable signal; this
+* substring covers debug-mode servers and forks that emit no code.
+*/
+var DEFINITION_LOAD_FAILED = "Unable to load grasshopper definition";
+/** `core/` knows no backend's wire codes, so every Grasshopper request passes these in. */
+var GRASSHOPPER_SERVER_ERROR_CODES = { definition_not_cached: ErrorCodes.DEFINITION_NOT_CACHED };
+/** Attach the Grasshopper wire-code table without clobbering a caller's own entries. */
+function withGrasshopperErrorCodes(config) {
+	return {
+		...config,
+		serverErrorCodes: {
+			...GRASSHOPPER_SERVER_ERROR_CODES,
+			...config.serverErrorCodes
+		}
+	};
+}
+function isDefinitionLoadMiss(error) {
+	if (!(error instanceof ComputeError)) return false;
+	return error.code === ErrorCodes.DEFINITION_NOT_CACHED || error.message.includes(DEFINITION_LOAD_FAILED);
+}
+/**
+* Debug-only: names the outputs that produced nothing, usually a definition that didn't compute
+* (missing inputs, a guarded branch). An empty output can be legitimate, so this only warns.
+*/
+function warnOnEmptyInnerTrees(response, debug) {
+	if (!debug) return;
+	const values = readField(response, "values");
+	if (!Array.isArray(values) || values.length === 0) return;
+	const empty = [];
+	for (const param of values) {
+		const innerTree = readField(param, "innerTree");
+		if (!innerTree || Object.keys(innerTree).length === 0) empty.push(readField(param, "paramName") ?? "<unnamed>");
+	}
+	if (empty.length === 0) return;
+	const scope = empty.length === values.length ? "all" : `${empty.length}/${values.length}`;
+	getLogger().warn(`Solve returned empty output(s) (${scope}): ${empty.join(", ")}. These parameters produced no data — check the definition's inputs and the branch feeding each.`);
+}
+/**
+* Run one solve. `GrasshopperClient.solve()` adds input validation and throws on solver errors.
+*
+* @param definition - A URL (sent as a pointer), base64 `.gh` content, raw `.gh` bytes, or a
+*   `DefinitionRef` (loaded for the upload). Any other string is encoded as the definition text.
+* @returns The compute response, without the server's `pointer` and echoed `algo`.
+*
+* @example
+* await solveGrasshopperDefinition(trees, 'https://example.com/definition.gh', config);
+* await solveGrasshopperDefinition(trees, new Uint8Array(await readFile('model.gh')), config);
+*/
+async function solveGrasshopperDefinition(dataTree, definition, config) {
+	warnIfClientSide("solveGrasshopperDefinition", config.suppressBrowserWarning);
+	validateServerUrl(config.serverUrl);
+	return (await uploadAndSolve(dataTree, definition, config)).response;
+}
+/**
+* Solve by `pointer: cacheKey` when a key is known, skipping the upload. With no key, or when the
+* server has evicted it, upload the full definition and report `missed: true`. A `DefinitionRef`
+* is loaded only on that upload path.
+*/
+async function solveWithServerCacheKey(dataTree, cacheKey, definition, config) {
+	warnIfClientSide("solveWithServerCacheKey", config.suppressBrowserWarning);
+	if (cacheKey !== null) try {
+		return {
+			...await runSolve({
+				algo: null,
+				pointer: cacheKey,
+				values: dataTree
+			}, config),
+			missed: false
+		};
+	} catch (error) {
+		if (!isDefinitionLoadMiss(error)) throw error;
+	}
+	return {
+		...await uploadAndSolve(dataTree, definition, config),
+		missed: true
+	};
+}
+async function uploadAndSolve(dataTree, definition, config) {
+	return runSolve(prepareGrasshopperArgs(await materializeDefinition(definition, config), dataTree), config);
+}
+async function materializeDefinition(definition, config) {
+	if (!isDefinitionRef(definition)) return definition;
+	validateNumbers(config);
+	const { signal, cleanup } = composeSignal(config.signal, config.timeoutMs);
+	try {
+		return await raceSignal(definition.load(signal), signal);
+	} catch (error) {
+		if (config.signal?.aborted) throw abortedByCaller({ definitionKey: definition.key }, error);
+		if (signal?.aborted) throw new ComputeError(`Loading definition '${definition.key}' timed out after ${config.timeoutMs}ms`, ErrorCodes.TIMEOUT_ERROR, { context: {
+			definitionKey: definition.key,
+			timeoutMs: config.timeoutMs
+		} });
+		throw new ComputeError(`Failed to load definition bytes for ref '${definition.key}'`, ErrorCodes.INVALID_INPUT, {
+			context: { definitionKey: definition.key },
+			originalError: error
+		});
+	} finally {
+		cleanup();
+	}
+}
+/**
+* POST a solve and split the server's `pointer` off the response. The server echoes the request's
+* base64 definition back as `algo`; it is dropped so a cached response doesn't pin a multi-MB copy
+* of the definition against the scheduler's byte budget.
+*/
+async function runSolve(args, config) {
+	applyOptionalComputeSettings(args, config);
+	const { maxResponseBytes } = config;
+	const result = await fetchCompute("grasshopper", args, withGrasshopperErrorCodes({
+		...config,
+		maxResponseBytes: maxResponseBytes !== void 0 && args.algo ? maxResponseBytes + args.algo.length : maxResponseBytes
+	}));
+	assertResponseObject(result);
+	const { pointer, algo: _algo, ...rest } = result;
+	const response = readField(rest, "values") ? rest : {
+		...rest,
+		values: []
+	};
+	const wireSize = getResponseWireSize(result);
+	if (wireSize !== void 0) {
+		const algoLength = typeof _algo === "string" ? _algo.length : 0;
+		setResponseWireSize(response, Math.max(0, wireSize - algoLength));
+	}
+	warnOnEmptyInnerTrees(response, config.debug);
+	return {
+		response,
+		cacheKey: typeof pointer === "string" ? pointer : null
+	};
+}
+/** A 200 can carry valid JSON that isn't an object: `null` from a proxy, or a bare string. */
+function assertResponseObject(response) {
+	if (!response || typeof response !== "object") throw new ComputeError("Invalid response structure", ErrorCodes.INVALID_RESPONSE, { context: { responseType: response === null ? "null" : typeof response } });
+}
+function prepareGrasshopperArgs(definition, dataTree) {
+	const args = {
+		algo: null,
+		pointer: null,
+		values: dataTree
+	};
+	if (definition instanceof Uint8Array) args.algo = base64ByteArray(definition);
+	else if (isDefinitionUrl(definition)) args.pointer = definition;
+	else args.algo = detectBase64Payload(definition) ?? encodeStringToBase64(definition);
+	return args;
+}
+function applyOptionalComputeSettings(arglist, options) {
+	if (options.cachesolve != null) arglist.cachesolve = options.cachesolve;
+	if (options.modelunits != null) arglist.modelunits = options.modelunits;
+	if (options.angletolerance != null) arglist.angletolerance = options.angletolerance;
+	if (options.absolutetolerance != null) arglist.absolutetolerance = options.absolutetolerance;
+	if (options.dataversion != null) arglist.dataversion = options.dataversion;
+	if (options.selvaevents != null) arglist.selvaevents = options.selvaevents;
+}
+/**
+* `obj[key] = value` for a key taken from a wire payload. Assigning `__proto__` would call the
+* prototype setter and swap the object's prototype instead of storing the value.
+*/
+function setOwnField(obj, key, value) {
+	if (key === "__proto__") Object.defineProperty(obj, key, {
+		value,
+		writable: true,
+		enumerable: true,
+		configurable: true
+	});
+	else obj[key] = value;
+}
+/**
+* Canonical matcher for a Grasshopper branch path key like `{0}`, `{0;1}`, or
+* the root path `{}`. This is the single source of truth for the branch-path
+* shape (`DataTreePath`); anything testing "does this string name a branch?"
+* should use this rather than re-inlining the regex.
+*
+* Matches `{}`, `{0}`, `{0;1;2}`, and negative indices like `{-1;2}` (GH_Path
+* allows them) — but NOT empty segments like `{0;}` / `{;}` / `{0;;1}`, which
+* would otherwise split to phantom 0s (`Number('') === 0`).
+*/
+var TREE_PATH_RE = /^\{(-?\d+(?:;-?\d+)*)?\}$/;
+/**
+* Membership test for a {@link DataTreeDefault}: an object keyed entirely by
+* branch paths, each mapping to an array of values. This is the one predicate
+* both the input-type parsers (to pass a tree-access default through untouched)
+* and `TreeBuilder` (to dispatch it to `fromDataTreeDefault`) ask — so the two
+* agree by construction on exactly which values are trees.
+*/
+function isDataTreeDefault(value) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+	const entries = Object.entries(value);
+	return entries.length > 0 && entries.every(([key, val]) => TREE_PATH_RE.test(key) && Array.isArray(val));
+}
+/** Every numeric CLR type Grasshopper serializes, so no numeric item stays a string. */
+var NUMERIC_ITEM_TYPES = /* @__PURE__ */ new Set([
+	"System.Double",
+	"System.Single",
+	"System.Decimal",
+	"System.Int32",
+	"System.Int64"
+]);
+/** Integral wire item types: rounded like the scalar Integer path. */
+var INTEGER_ITEM_TYPES = /* @__PURE__ */ new Set(["System.Int32", "System.Int64"]);
+/**
+* Coerce a schema's `default`: array items are transformed and the rejected ones
+* filtered (none left → `undefined`); a rejected scalar becomes `undefined` when
+* `dropInvalidScalar`, else is kept verbatim for the parser to report.
+*/
+function coerceDefault(value, transform, dropInvalidScalar) {
+	if (value === void 0 || value === null) return value;
+	if (Array.isArray(value)) {
+		const processed = value.map(transform).filter((v) => v !== null);
+		return processed.length > 0 ? processed : void 0;
+	}
+	const transformed = transform(value);
+	if (transformed !== null) return transformed;
+	return dropInvalidScalar ? void 0 : value;
+}
+var numericTransformer = (value) => {
+	if (typeof value === "number") return Number.isFinite(value) ? value : null;
+	if (typeof value === "string") {
+		const trimmed = value.trim();
+		if (trimmed === "") return null;
+		if (/^[+-]?0[xbo]/i.test(trimmed)) return null;
+		const parsed = Number(trimmed);
+		return Number.isFinite(parsed) ? parsed : null;
+	}
+	return null;
+};
+var booleanTransformer = (value) => {
+	if (typeof value === "boolean") return value;
+	if (typeof value === "string") {
+		const lower = value.trim().toLowerCase();
+		if (lower === "true") return true;
+		if (lower === "false") return false;
+	}
+	return null;
+};
+var textTransformer = (value) => {
+	if (typeof value === "string") {
+		if (value.length >= 2 && value.startsWith("\"") && value.endsWith("\"")) return value.slice(1, -1);
+		if (value.startsWith("\"")) return value.slice(1);
+		return value;
+	}
+	return null;
+};
+var colorTransformer = (value) => {
+	if (typeof value === "string") {
+		let cleaned = value.trim();
+		if (cleaned.startsWith("\"") && cleaned.endsWith("\"")) cleaned = cleaned.slice(1, -1).trim();
+		return cleaned;
+	}
+	return null;
+};
+function objectTransformer(inputName) {
+	return (value) => {
+		if (typeof value === "object" && value !== null) return value;
+		if (typeof value === "string" && value.trim() !== "") try {
+			const parsed = JSON.parse(value);
+			if (typeof parsed === "object" && parsed !== null) return parsed;
+			getLogger().warn(`Parsed value for input ${inputName} is not an object`);
+			return null;
+		} catch {
+			getLogger().warn(`Failed to parse the object value for input ${inputName}`);
+			return null;
+		}
+		return null;
+	};
+}
+function dropDefault(input, message) {
+	getLogger().warn(message);
+	return {
+		schema: {
+			...input,
+			default: null
+		},
+		warning: {
+			code: ErrorCodes.MALFORMED_DEFAULT,
+			message
+		}
+	};
+}
+/**
+* Flatten a raw input's `default` DataTree into the shape the type parsers take.
+* Never mutates `input`. A default it can't interpret is dropped with a `warning`.
+*/
+function normalizeDefault(input, label) {
+	if (typeof input.default !== "object" || input.default === null) return { schema: input };
+	if (Array.isArray(input.default) || isDataTreeDefault(input.default)) return { schema: input };
+	if (!hasField(input.default, "innerTree")) return dropDefault(input, `Input "${label}" default had an unrecognized shape (no innerTree key); the default was dropped.`);
+	const innerTree = readField(input.default, "innerTree") ?? {};
+	if (Object.keys(innerTree).length === 0) return { schema: {
+		...input,
+		default: void 0
+	} };
+	if (input.treeAccess || input.atMost && input.atMost > 1) {
+		const tree = {};
+		const invalidItems = [];
+		for (const [branch, items] of Object.entries(innerTree)) {
+			if (!Array.isArray(items)) return dropDefault(input, `Input "${label}" default had a non-array innerTree branch ("${branch}"); the default was dropped.`);
+			const parsed = [];
+			for (const item of items) {
+				const data = readField(item, "data");
+				const type = readField(item, "type");
+				if (type && NUMERIC_ITEM_TYPES.has(type)) {
+					if (typeof data === "string" && data.trim() === "") continue;
+					const num = numericTransformer(data);
+					if (num === null) {
+						invalidItems.push(`"${String(data)}" (${type})`);
+						continue;
+					}
+					parsed.push(INTEGER_ITEM_TYPES.has(type) ? Math.round(num) : num);
+					continue;
+				}
+				if (type === "System.Boolean") {
+					const bool = booleanTransformer(data);
+					if (bool === null) {
+						invalidItems.push(`"${String(data)}" (${type})`);
+						continue;
+					}
+					parsed.push(bool);
+					continue;
+				}
+				if (type === "System.String" && typeof data === "string") {
+					parsed.push(textTransformer(data));
+					continue;
+				}
+				if (typeof data === "string" && type?.startsWith("Rhino.Geometry")) {
+					try {
+						parsed.push(JSON.parse(data));
+					} catch {
+						parsed.push(data);
+					}
+					continue;
+				}
+				parsed.push(data);
+			}
+			setOwnField(tree, branch, parsed);
+		}
+		if (invalidItems.length > 0) {
+			const message = `Input "${label}" default contained ${invalidItems.length} tree value(s) that could not be parsed and were dropped: ${invalidItems.join(", ")}.`;
+			getLogger().warn(`Input "${label}" default: dropped ${invalidItems.length} tree value(s)`);
+			return {
+				schema: {
+					...input,
+					default: tree
+				},
+				warning: {
+					code: ErrorCodes.MALFORMED_DEFAULT,
+					message
+				}
+			};
+		}
+		return { schema: {
+			...input,
+			default: tree
+		} };
+	}
+	const allValues = [];
+	for (const items of Object.values(innerTree)) {
+		if (!Array.isArray(items)) continue;
+		for (const item of items) if (item && typeof item === "object" && hasField(item, "data")) allValues.push(readField(item, "data"));
+	}
+	return { schema: {
+		...input,
+		default: allValues.length > 1 ? allValues : allValues[0]
+	} };
+}
+/** Snap float noise (`0.30000000000000004`) to `decimalPlaces`; a real difference is kept. */
+function applyRounding(value, decimalPlaces) {
+	const rounded = Number(value.toFixed(decimalPlaces));
+	return Math.abs(value - rounded) < 1e-8 ? rounded : value;
+}
+var MAX_DECIMALS = 12;
+var SIGNIFICANT_DIGITS = 15;
+/**
+* Decimal places `x` is written with, ignoring float noise, at most 12:
+* `0.30000000000000004` → 1, `16384.2` → 1, `1e-7` → 7, `1.5e21` → 0.
+*/
+function decimalsOf(x) {
+	if (!Number.isFinite(x)) return 0;
+	const clean = Number(Math.abs(x).toPrecision(SIGNIFICANT_DIGITS));
+	const [mantissa, exponent = "0"] = String(clean).split("e");
+	const decimals = (mantissa.split(".")[1]?.length ?? 0) - Number(exponent);
+	return Math.min(Math.max(decimals, 0), MAX_DECIMALS);
+}
+function getInputStepSize(value) {
+	if (!Number.isFinite(value) || value === 0) return .1;
+	const decimals = decimalsOf(value);
+	if (decimals === 0) return Math.abs(value) >= 1 ? 1 : .1;
+	return Number((10 ** -decimals).toFixed(decimals));
+}
+/** A server-authored `stepSize`, or `undefined` when absent or unusable. */
+function serverStepSize(schema) {
+	return typeof schema.stepSize === "number" && Number.isFinite(schema.stepSize) && schema.stepSize > 0 ? schema.stepSize : void 0;
+}
+var labelOf = (schema) => schema.nickname || "unnamed";
+var listOr = (schema, value) => (schema.atMost ?? 1) > 1 ? [value] : value;
+var defaultStep = (schema) => serverStepSize(schema) ?? (schema.paramType === "Integer" ? 1 : .1);
+var mapNumbers = (value, fn) => Array.isArray(value) ? value.map((v) => typeof v === "number" ? fn(v) : v) : typeof value === "number" ? fn(value) : value;
+function computeNumeric(schema) {
+	if (isDataTreeDefault(schema.default)) return {
+		default: schema.default,
+		stepSize: defaultStep(schema)
+	};
+	if (typeof schema.default === "string" && schema.default.trim() !== "" && numericTransformer(schema.default) === null) throw new ComputeError(`Invalid numeric default "${schema.default}" for input "${schema.name || "unknown"}"`, ErrorCodes.VALIDATION_ERROR, { context: {
+		inputName: schema.name,
+		default: schema.default
+	} });
+	const value = coerceDefault(schema.default, numericTransformer, true);
+	if (schema.paramType === "Integer") return {
+		default: mapNumbers(value, Math.round),
+		stepSize: defaultStep(schema)
+	};
+	const firstValue = Array.isArray(value) ? value[0] : value;
+	const stepSource = [
+		firstValue,
+		schema.minimum,
+		schema.maximum
+	].find((v) => typeof v === "number" && Number.isFinite(v) && v !== 0);
+	const stepSize = serverStepSize(schema) ?? (stepSource !== void 0 ? getInputStepSize(stepSource) : .1);
+	let decimalPlaces = decimalsOf(stepSize);
+	if (decimalPlaces === 0 && typeof firstValue === "number" && firstValue !== 0 && Math.abs(firstValue) < 1) {
+		const inferred = Math.ceil(-Math.log10(Math.abs(firstValue)));
+		if (Number.isFinite(inferred) && inferred > 0) decimalPlaces = inferred;
+	}
+	decimalPlaces = Math.min(Math.max(decimalPlaces, 0), 12);
+	return {
+		default: mapNumbers(value, (n) => applyRounding(n, decimalPlaces)),
+		stepSize
+	};
+}
+var numericParam = (schema, base, computed) => ({
+	...base,
+	paramType: schema.paramType,
+	minimum: schema.minimum,
+	maximum: schema.maximum,
+	atLeast: schema.atLeast,
+	atMost: schema.atMost,
+	...computed
+});
+var numericParser = {
+	parse(schema, base) {
+		return numericParam(schema, base, computeNumeric(schema));
+	},
+	fallback(schema, base) {
+		const safeValue = typeof schema.minimum === "number" && Number.isFinite(schema.minimum) && schema.minimum > 0 ? schema.minimum : 0;
+		return numericParam(schema, base, {
+			stepSize: defaultStep(schema),
+			default: listOr(schema, safeValue)
+		});
+	}
+};
+var booleanParser = {
+	parse(schema, base) {
+		if (isDataTreeDefault(schema.default)) return {
+			...base,
+			paramType: "Boolean",
+			default: schema.default
+		};
+		const value = coerceDefault(schema.default, booleanTransformer, false);
+		if (value !== void 0 && value !== null && typeof value !== "boolean" && !Array.isArray(value)) throw new ComputeError(`Invalid boolean default "${String(value)}" for input "${schema.name || "unknown"}"`, ErrorCodes.VALIDATION_ERROR, { context: {
+			inputName: schema.name,
+			default: schema.default
+		} });
+		return {
+			...base,
+			paramType: "Boolean",
+			default: value
+		};
+	},
+	fallback(schema, base) {
+		return {
+			...base,
+			paramType: "Boolean",
+			default: listOr(schema, false)
+		};
+	}
+};
+var textParser = { parse(schema, base) {
+	const value = coerceDefault(schema.default, textTransformer, false);
+	return {
+		...base,
+		paramType: "Text",
+		default: value
+	};
+} };
+var valueListParser = {
+	parse(schema, base, warn) {
+		if (!schema.values || typeof schema.values !== "object" || Object.keys(schema.values).length === 0) {
+			const inputName = labelOf(schema);
+			throw new ComputeError(`Input "${inputName}" has no values defined (expected ValueList)`, ErrorCodes.INVALID_INPUT, { context: {
+				inputName,
+				expectedType: "ValueList"
+			} });
+		}
+		let defaultValue;
+		if (schema.default !== void 0 && schema.default !== null) {
+			if (typeof schema.default === "object") throw new ComputeError(`ValueList input "${labelOf(schema)}" default is not a string-able value`, ErrorCodes.VALIDATION_ERROR, { context: {
+				inputName: schema.name,
+				default: schema.default
+			} });
+			const defaultLower = String(schema.default).toLowerCase();
+			const match = Object.keys(schema.values).find((key) => key.toLowerCase() === defaultLower);
+			defaultValue = match ?? String(schema.default);
+			if (match === void 0) {
+				const inputName = labelOf(schema);
+				getLogger().warn(`ValueList input "${inputName}" default is not in available values`);
+				warn?.({
+					code: ErrorCodes.VALIDATION_ERROR,
+					message: `ValueList input "${inputName}" default value "${schema.default}" is not in available values`
+				});
+			}
+		}
+		return {
+			...base,
+			paramType: "ValueList",
+			values: schema.values,
+			default: defaultValue
+		};
+	},
+	fallback(schema, base) {
+		return {
+			...base,
+			paramType: "ValueList",
+			values: schema.values && typeof schema.values === "object" ? schema.values : {},
+			default: void 0
+		};
+	}
+};
+var objectDefault = (schema) => coerceDefault(schema.default, objectTransformer(labelOf(schema)), true);
+function geometryFallback(schema, base) {
+	return {
+		...base,
+		paramType: "Geometry",
+		default: listOr(schema, null)
+	};
+}
+/** Keyed by canonical paramType. */
+var INPUT_TYPE_PARSERS = /* @__PURE__ */ new Map([
+	["Number", numericParser],
+	["Integer", numericParser],
+	["Boolean", booleanParser],
+	["Text", textParser],
+	["ValueList", valueListParser],
+	["Geometry", {
+		parse(schema, base) {
+			return {
+				...base,
+				paramType: "Geometry",
+				default: objectDefault(schema)
+			};
+		},
+		fallback: geometryFallback
+	}],
+	["File", { parse(schema, base) {
+		return {
+			...base,
+			paramType: "File",
+			acceptedFormats: schema.acceptedFormats,
+			default: objectDefault(schema)
+		};
+	} }],
+	["Color", { parse(schema, base) {
+		const value = coerceDefault(schema.default, colorTransformer, false);
+		return {
+			...base,
+			paramType: "Color",
+			default: value
+		};
+	} }]
+]);
+var unknownTypeFallback = geometryFallback;
+var CANONICAL_PARAM_TYPES = new Map([...INPUT_TYPE_PARSERS.keys()].map((key) => [key.toLowerCase(), key]));
+/** An unknown paramType comes back unchanged, so its unknown-type error still surfaces. */
+function canonicalizeParamType(paramType) {
+	return CANONICAL_PARAM_TYPES.get(paramType?.toLowerCase()) ?? paramType;
+}
+/**
+* Like {@link processInput}, but also returns every problem found on the way, in
+* order: a dropped default, warnings the parser recovered from, and the parser
+* error that forced the safe default. Entries carry the RAW declared `paramType`
+* so clients match on the casing they sent.
+*
+* A non-`ComputeError` failure still throws: it is a bug, not bad input.
+*/
+function processInputWithError(rawInput) {
+	const label = rawInput.name || "unknown";
+	const errors = [];
+	const report = ({ code, message }) => {
+		errors.push({
+			inputName: label,
+			paramType: rawInput.paramType,
+			message,
+			code
+		});
+	};
+	const baseInput = {
+		description: rawInput.description,
+		name: rawInput.name,
+		nickname: rawInput.nickname,
+		treeAccess: rawInput.treeAccess,
+		groupName: rawInput.groupName ?? void 0,
+		id: rawInput.id
+	};
+	const paramType = canonicalizeParamType(rawInput.paramType);
+	let schema = {
+		...rawInput,
+		paramType
+	};
+	try {
+		const { schema: normalized, warning } = normalizeDefault(schema, label);
+		schema = normalized;
+		if (warning) report(warning);
+	} catch (error) {
+		schema = {
+			...schema,
+			default: null
+		};
+		report({
+			code: ErrorCodes.MALFORMED_DEFAULT,
+			message: `Input "${label}" default could not be normalized and was dropped: ${error instanceof Error ? error.message : String(error)}`
+		});
+	}
+	const parser = INPUT_TYPE_PARSERS.get(paramType);
+	try {
+		if (!parser) throw new ComputeError(`Unknown paramType: ${paramType}`, ErrorCodes.VALIDATION_ERROR, { context: {
+			receivedParamType: paramType,
+			paramName: rawInput.name
+		} });
+		return {
+			input: parser.parse(schema, baseInput, report),
+			errors
+		};
+	} catch (error) {
+		if (!(error instanceof ComputeError)) throw new ComputeError(error instanceof Error ? error.message : String(error), ErrorCodes.VALIDATION_ERROR, {
+			context: {
+				paramName: rawInput.name,
+				paramType
+			},
+			originalError: error
+		});
+		getLogger().error(`Validation error for input ${label}: ${error.code}`);
+		report(error);
+		return {
+			input: (parser?.fallback ?? unknownTypeFallback)(schema, baseInput),
+			errors
+		};
+	}
+}
+/** {@link processInputWithError} over a list, with every input's errors collected. */
+function processInputsWithErrors(rawInputs) {
+	const inputs = [];
+	const parseErrors = [];
+	for (const raw of rawInputs) {
+		const { input, errors } = processInputWithError(raw);
+		inputs.push(input);
+		parseErrors.push(...errors);
+	}
+	return {
+		inputs,
+		parseErrors
+	};
+}
+/**
+* Canonicalize a raw `/io` param record's field keys to camelCase, so the
+* parsers can read `schema.paramType` whichever casing the server sent. Values,
+* including `default` and the user-authored `values` map, pass through verbatim.
+*
+* A missing required field gets a fallback that keeps the type true: `paramType`
+* `''` surfaces as an unknown-type parse error, and `groupName` stays `null`
+* (not `''`) so "no group" differs from an empty group name.
+*/
+function normalizeInputSchema(raw) {
+	const stepSize = readField(raw, "stepSize");
+	return {
+		id: readField(raw, "id") ?? "",
+		name: readField(raw, "name") ?? "",
+		nickname: readField(raw, "nickname") ?? null,
+		description: readField(raw, "description") ?? "",
+		paramType: readField(raw, "paramType") ?? "",
+		treeAccess: readField(raw, "treeAccess") ?? false,
+		minimum: readField(raw, "minimum") ?? null,
+		maximum: readField(raw, "maximum") ?? null,
+		atLeast: readField(raw, "atLeast") ?? 1,
+		atMost: readField(raw, "atMost") ?? 1,
+		stepSize: typeof stepSize === "number" && Number.isFinite(stepSize) ? stepSize : void 0,
+		default: readField(raw, "default"),
+		values: readField(raw, "values"),
+		acceptedFormats: readField(raw, "acceptedFormats"),
+		groupName: readField(raw, "groupName") ?? null
+	};
+}
+function normalizeOutputSchema(raw) {
+	return {
+		name: readField(raw, "name") ?? "",
+		nickname: readField(raw, "nickname") ?? null,
+		paramType: readField(raw, "paramType") ?? "",
+		id: readField(raw, "id") ?? ""
+	};
+}
+/**
+* Fetches a definition's input/output schemas without per-type parsing.
+*
+* Field KEYS are canonicalized to camelCase and missing required fields get a fallback; a missing
+* or non-array `inputs` / `outputs` becomes `[]`. Field VALUES, notably `default` and the `values`
+* label map, pass through verbatim.
+*
+* @throws {ComputeError} If fetch fails or response is invalid
+*/
+async function fetchDefinitionIO(definition, config) {
+	warnIfClientSide("fetchDefinitionIO", config.suppressBrowserWarning);
+	validateServerUrl(config.serverUrl);
+	const { algo, pointer } = prepareGrasshopperArgs(definition, []);
+	if (!algo && !pointer) throw new ComputeError("Definition must resolve to either a URL pointer or base64 algo", ErrorCodes.INVALID_INPUT);
+	const response = await fetchCompute("io", algo ? { algo } : { pointer }, withGrasshopperErrorCodes(config));
+	assertResponseObject(response);
+	const loadWarnings = nonEmptyStrings(readField(response, "warnings"));
+	const loadErrors = nonEmptyStrings(readField(response, "errors"));
+	const rawInputs = readField(response, "inputs");
+	const rawOutputs = readField(response, "outputs");
+	return {
+		inputs: Array.isArray(rawInputs) ? rawInputs.map(normalizeInputSchema) : [],
+		outputs: Array.isArray(rawOutputs) ? rawOutputs.map(normalizeOutputSchema) : [],
+		...loadWarnings && { loadWarnings },
+		...loadErrors && { loadErrors }
+	};
+}
+/**
+* Server diagnostics as non-blank strings, or `undefined` when there are none.
+* Non-string entries are kept, not dropped: a fork reporting `{ message }`
+* objects must not yield an empty input list with no explanation.
+*/
+function nonEmptyStrings(value) {
+	if (!Array.isArray(value)) return void 0;
+	const cleaned = value.map(coerceDiagnostic).filter((v) => v !== void 0);
+	return cleaned.length > 0 ? cleaned : void 0;
+}
+function coerceDiagnostic(value) {
+	if (value === null || value === void 0) return void 0;
+	let text;
+	if (typeof value === "string") text = value;
+	else if (typeof value === "object") {
+		const message = readField(value, "message");
+		if (typeof message === "string" && message.trim().length > 0) text = message;
+		else try {
+			text = JSON.stringify(value) ?? String(value);
+		} catch {
+			text = String(value);
+		}
+	} else text = String(value);
+	return text.trim().length > 0 ? text : void 0;
+}
+/**
+* Fetches a definition's input/output schemas and parses each input into its
+* typed `InputParam`. An input that fails to parse gets a safe default
+* and an entry in `parseErrors`.
+*
+* @throws {ComputeError} If fetch fails or response is invalid
+*
+* @example
+* ```typescript
+* const { inputs, outputs } = await fetchParsedDefinitionIO(
+*   'https://example.com/definition.gh',
+*   { serverUrl: 'http://localhost:6500', apiKey: 'YOUR_KEY' }
+* );
+*
+* // Inputs are now strongly typed
+* inputs.forEach(input => {
+*   if (input.paramType === 'Number') {
+*     console.log(input.minimum, input.maximum); // TypeScript knows these exist
+*   }
+* });
+* ```
+*/
+async function fetchParsedDefinitionIO(definition, config) {
+	const { inputs: rawInputs, outputs, loadWarnings, loadErrors } = await fetchDefinitionIO(definition, config);
+	const { inputs, parseErrors } = processInputsWithErrors(rawInputs);
+	return {
+		inputs,
+		outputs,
+		...parseErrors.length > 0 && { parseErrors },
+		...loadWarnings && { loadWarnings },
+		...loadErrors && { loadErrors }
+	};
+}
+/**
+* For a response that never crossed the fetch boundary (custom executor), so carries no
+* wire-size hint. An unserializable response is sized 0 rather than failing the solve.
+*/
+function estimateResponseSize(response) {
+	try {
+		return JSON.stringify(response)?.length ?? 0;
+	} catch {
+		return 0;
+	}
+}
+/** The scheduler's response cache: LRU by bytes, with an optional TTL. */
+var ResponseCache = class {
+	maxBytes;
+	ttlMs;
+	cacheErroredSolves;
+	entries = /* @__PURE__ */ new Map();
+	bytes = 0;
+	hits = 0;
+	misses = 0;
+	evictions = 0;
+	constructor(options) {
+		const config = options || null;
+		this.maxBytes = Math.max(0, config?.maxBytes ?? 0);
+		this.ttlMs = config?.ttlMs ?? 0;
+		this.cacheErroredSolves = config?.cacheErroredSolves ?? true;
+	}
+	/** A zero budget retains nothing, so it is off rather than a cache that can only ever miss. */
+	get enabled() {
+		return this.maxBytes > 0;
+	}
+	get(key) {
+		if (!this.enabled) return null;
+		const entry = this.entries.get(key);
+		if (!entry) {
+			this.misses += 1;
+			return null;
+		}
+		if (this.ttlMs > 0 && Date.now() - entry.insertedAt > this.ttlMs) {
+			this.drop(key);
+			this.misses += 1;
+			return null;
+		}
+		this.entries.delete(key);
+		this.entries.set(key, entry);
+		this.hits += 1;
+		return entry.response;
+	}
+	set(key, response) {
+		if (!this.enabled) return;
+		const solveErrors = readField(response, "errors");
+		if (!this.cacheErroredSolves && Array.isArray(solveErrors) && solveErrors.length > 0) return;
+		if (readField(readField(readField(response, "selva"), "outcome"), "aborted") === true) return;
+		const sizeBytes = getResponseWireSize(response) ?? estimateResponseSize(response);
+		if (sizeBytes > this.maxBytes) return;
+		this.drop(key);
+		this.entries.set(key, {
+			response,
+			insertedAt: Date.now(),
+			sizeBytes
+		});
+		this.bytes += sizeBytes;
+		while (this.bytes > this.maxBytes && this.entries.size > 0) {
+			const oldest = this.entries.keys().next().value;
+			if (oldest === void 0) break;
+			this.drop(oldest);
+			this.evictions += 1;
+		}
+	}
+	clear() {
+		this.entries.clear();
+		this.bytes = 0;
+	}
+	stats() {
+		return {
+			entries: this.entries.size,
+			bytes: this.bytes,
+			hits: this.hits,
+			misses: this.misses,
+			evictions: this.evictions
+		};
+	}
+	drop(key) {
+		const entry = this.entries.get(key);
+		if (!entry) return;
+		this.entries.delete(key);
+		this.bytes -= entry.sizeBytes;
+	}
+};
+var nodeCrypto = globalThis.process?.getBuiltinModule?.("node:crypto");
+/** Lowercase hex SHA-256 of `input`. */
+function sha256Hex(input) {
+	if (nodeCrypto) {
+		const hash = nodeCrypto.createHash("sha256");
+		if (typeof input === "string") hash.update(input, "utf16le");
+		else hash.update(input);
+		return hash.digest("hex");
+	}
+	return sha256HexPortable(input);
+}
+var K = new Int32Array([
+	1116352408,
+	1899447441,
+	3049323471,
+	3921009573,
+	961987163,
+	1508970993,
+	2453635748,
+	2870763221,
+	3624381080,
+	310598401,
+	607225278,
+	1426881987,
+	1925078388,
+	2162078206,
+	2614888103,
+	3248222580,
+	3835390401,
+	4022224774,
+	264347078,
+	604807628,
+	770255983,
+	1249150122,
+	1555081692,
+	1996064986,
+	2554220882,
+	2821834349,
+	2952996808,
+	3210313671,
+	3336571891,
+	3584528711,
+	113926993,
+	338241895,
+	666307205,
+	773529912,
+	1294757372,
+	1396182291,
+	1695183700,
+	1986661051,
+	2177026350,
+	2456956037,
+	2730485921,
+	2820302411,
+	3259730800,
+	3345764771,
+	3516065817,
+	3600352804,
+	4094571909,
+	275423344,
+	430227734,
+	506948616,
+	659060556,
+	883997877,
+	958139571,
+	1322822218,
+	1537002063,
+	1747873779,
+	1955562222,
+	2024104815,
+	2227730452,
+	2361852424,
+	2428436474,
+	2756734187,
+	3204031479,
+	3329325298
+]);
+/** Exported so tests can check it against Node's native hash. */
+function sha256HexPortable(input) {
+	const state = new Sha256();
+	if (typeof input === "string") state.updateString(input);
+	else state.update(input);
+	return state.digestHex();
+}
+var Sha256 = class {
+	h = new Int32Array([
+		1779033703,
+		3144134277,
+		1013904242,
+		2773480762,
+		1359893119,
+		2600822924,
+		528734635,
+		1541459225
+	]);
+	w = /* @__PURE__ */ new Int32Array(64);
+	pending = /* @__PURE__ */ new Uint8Array(64);
+	pendingLength = 0;
+	totalBytes = 0;
+	update(bytes) {
+		this.totalBytes += bytes.length;
+		let offset = 0;
+		if (this.pendingLength > 0) {
+			const take = Math.min(64 - this.pendingLength, bytes.length);
+			this.pending.set(bytes.subarray(0, take), this.pendingLength);
+			this.pendingLength += take;
+			offset = take;
+			if (this.pendingLength < 64) return;
+			this.compressBytes(this.pending, 0);
+			this.pendingLength = 0;
+		}
+		for (; offset + 64 <= bytes.length; offset += 64) this.compressBytes(bytes, offset);
+		this.pending.set(bytes.subarray(offset), 0);
+		this.pendingLength = bytes.length - offset;
+	}
+	/**
+	* Feed a string's UTF-16LE bytes straight into the message words, skipping a byte buffer.
+	* Only on a fresh state: 32 code units fill a block exactly, so nothing may be pending.
+	*/
+	updateString(s) {
+		const w = this.w;
+		const whole = s.length - s.length % 32;
+		for (let offset = 0; offset < whole; offset += 32) {
+			for (let i = 0; i < 16; i++) {
+				const c0 = s.charCodeAt(offset + 2 * i);
+				const c1 = s.charCodeAt(offset + 2 * i + 1);
+				w[i] = (c0 & 255) << 24 | c0 >>> 8 << 16 | (c1 & 255) << 8 | c1 >>> 8;
+			}
+			this.compress();
+		}
+		this.totalBytes += whole * 2;
+		const rest = new Uint8Array((s.length - whole) * 2);
+		for (let i = whole, j = 0; i < s.length; i++) {
+			const code = s.charCodeAt(i);
+			rest[j++] = code & 255;
+			rest[j++] = code >>> 8;
+		}
+		this.update(rest);
+	}
+	digestHex() {
+		const bitLength = this.totalBytes * 8;
+		const tail = new Uint8Array(this.pendingLength < 56 ? 64 : 128);
+		tail.set(this.pending.subarray(0, this.pendingLength));
+		tail[this.pendingLength] = 128;
+		const view = new DataView(tail.buffer);
+		view.setUint32(tail.length - 8, Math.floor(bitLength / 4294967296));
+		view.setUint32(tail.length - 4, bitLength >>> 0);
+		for (let offset = 0; offset < tail.length; offset += 64) this.compressBytes(tail, offset);
+		let hex = "";
+		for (const word of this.h) hex += (word >>> 0).toString(16).padStart(8, "0");
+		return hex;
+	}
+	compressBytes(bytes, offset) {
+		const w = this.w;
+		for (let i = 0; i < 16; i++) {
+			const j = offset + i * 4;
+			w[i] = bytes[j] << 24 | bytes[j + 1] << 16 | bytes[j + 2] << 8 | bytes[j + 3];
+		}
+		this.compress();
+	}
+	/** One block, from the 16 message words already in `w`. */
+	compress() {
+		const w = this.w;
+		for (let i = 16; i < 64; i++) {
+			const x = w[i - 15];
+			const y = w[i - 2];
+			const s0 = (x >>> 7 | x << 25) ^ (x >>> 18 | x << 14) ^ x >>> 3;
+			const s1 = (y >>> 17 | y << 15) ^ (y >>> 19 | y << 13) ^ y >>> 10;
+			w[i] = w[i - 16] + s0 + w[i - 7] + s1 | 0;
+		}
+		const h = this.h;
+		let a = h[0];
+		let b = h[1];
+		let c = h[2];
+		let d = h[3];
+		let e = h[4];
+		let f = h[5];
+		let g = h[6];
+		let k = h[7];
+		for (let i = 0; i < 64; i++) {
+			const S1 = (e >>> 6 | e << 26) ^ (e >>> 11 | e << 21) ^ (e >>> 25 | e << 7);
+			const ch = e & f ^ ~e & g;
+			const t1 = k + S1 + ch + K[i] + w[i] | 0;
+			const t2 = ((a >>> 2 | a << 30) ^ (a >>> 13 | a << 19) ^ (a >>> 22 | a << 10)) + (a & b ^ a & c ^ b & c) | 0;
+			k = g;
+			g = f;
+			f = e;
+			e = d + t1 | 0;
+			d = c;
+			c = b;
+			b = a;
+			a = t1 + t2 | 0;
+		}
+		h[0] = h[0] + a | 0;
+		h[1] = h[1] + b | 0;
+		h[2] = h[2] + c | 0;
+		h[3] = h[3] + d | 0;
+		h[4] = h[4] + e | 0;
+		h[5] = h[5] + f | 0;
+		h[6] = h[6] + g | 0;
+		h[7] = h[7] + k | 0;
+	}
+};
+/**
+* Solve-key hashing, public so an app-layer durable cache or a pre-solved bundle viewer can
+* reproduce the scheduler's exact key. A key that canonicalizes even slightly differently
+* misses every entry the scheduler wrote, or worse, collides differently.
+*
+* Keys are SHA-256: one scheduler's cache serves every user of a server, so a key a user can
+* collide on purpose lets them choose what another user's solve returns.
+*/
+/**
+* Deterministic stringify with sorted keys. {a:1,b:2} and {b:2,a:1} produce
+* the same string. Safely handles circular references and non-finite numbers.
+*
+* The output is a cache key, so the invariant that matters is: two payloads
+* that serialize differently on the wire must stringify differently here
+* (false misses are harmless; false hits serve the wrong cached solve).
+* Non-JSON values get unquoted markers (`{u8:…}`, `[Circular]`) that no JSON
+* value stringifies to, so a plain object can't pose as one.
+*/
+function stableStringify(value) {
+	const path = /* @__PURE__ */ new WeakSet();
+	const stringify = (v) => {
+		if (v === null) return "null";
+		if (typeof v === "number") return Number.isFinite(v) ? String(v) : "null";
+		if (typeof v === "string" || typeof v === "boolean") return JSON.stringify(v);
+		if (typeof v === "bigint") return `${v}n`;
+		if (typeof v !== "object") return "undefined";
+		if (v instanceof Uint8Array) return `{u8:${sha256Hex(v)}}`;
+		if (path.has(v)) return "[Circular]";
+		path.add(v);
+		let out;
+		if (Array.isArray(v)) {
+			const parts = [];
+			for (let i = 0; i < v.length; i++) parts.push(stringify(v[i]));
+			out = `[${parts.join(",")}]`;
+		} else if (typeof v.toJSON === "function") out = stringify(v.toJSON());
+		else if (v instanceof Map) out = `{map:[${[...v.entries()].map(([k, val]) => `[${stringify(k)},${stringify(val)}]`).sort().join(",")}]}`;
+		else if (v instanceof Set) out = `{set:[${[...v.values()].map(stringify).sort().join(",")}]}`;
+		else out = `{${Object.keys(v).sort().map((k) => `${JSON.stringify(k)}:${stringify(v[k])}`).join(",")}}`;
+		path.delete(v);
+		return out;
+	};
+	return stringify(value);
+}
+/**
+* `hashSolveInput` from a precomputed {@link hashDefinition}, so the scheduler, which also keys its
+* server-cache-key map by that hash, passes over a multi-MB definition once per solve.
+*/
+function hashSolveInputForDefinition(definitionHash, dataTree) {
+	return `${definitionHash}|t:${sha256Hex(stableStringify(dataTree))}`;
+}
+/**
+* A definition's identity, without its inputs. Strings and bytes are hashed over their full
+* content; a `DefinitionRef` uses its `key`.
+*/
+function hashDefinition(definition) {
+	if (isDefinitionRef(definition)) return `r:${definition.key}`;
+	return typeof definition === "string" ? `s:${sha256Hex(definition)}` : `u8:${sha256Hex(definition)}`;
+}
+var SERVER_CACHE_KEYS_MAX = 100;
+/** `NaN` passes `Math.max` and fails every `inFlight < limit`, so nothing would ever dispatch. */
+function concurrencyLimit(value) {
+	if (Number.isNaN(value)) throw new ComputeError("maxConcurrent must be a number", ErrorCodes.INVALID_CONFIG, { context: { maxConcurrent: value } });
+	return Math.max(1, Math.floor(value));
+}
+var u8DefinitionHashes = /* @__PURE__ */ new WeakMap();
+/**
+* Remembers a buffer's hash by identity: a buffer mutated after its first solve keeps its old
+* hash and is served the old content's cached solves.
+*/
+function hashDefinitionOnce(definition) {
+	if (!(definition instanceof Uint8Array)) return hashDefinition(definition);
+	let hash = u8DefinitionHashes.get(definition);
+	if (hash === void 0) {
+		hash = hashDefinition(definition);
+		u8DefinitionHashes.set(definition, hash);
+	}
+	return hash;
+}
+/** One solve's input hashes, each taken on first use. */
+var SolveInputHashes = class {
+	hashDefinition;
+	dataTree;
+	definitionMemo;
+	keyMemo;
+	constructor(hashDefinition, dataTree) {
+		this.hashDefinition = hashDefinition;
+		this.dataTree = dataTree;
+	}
+	get definitionHash() {
+		return this.definitionMemo ??= this.hashDefinition();
+	}
+	get key() {
+		return this.keyMemo ??= hashSolveInputForDefinition(this.definitionHash, this.dataTree);
+	}
+};
+/**
+* The FIFO behind `queue` mode. Removing an item only drops it from `live`; the array is swept once
+* the dead entries outnumber the live ones, so aborting n queued solves costs O(n), not O(n²).
+*/
+var SolveQueue = class {
+	items = [];
+	head = 0;
+	live = /* @__PURE__ */ new Set();
+	get size() {
+		return this.live.size;
+	}
+	push(item) {
+		this.items.push(item);
+		this.live.add(item);
+	}
+	remove(item) {
+		if (this.live.delete(item)) this.compact();
+	}
+	shift() {
+		while (this.head < this.items.length) {
+			const item = this.items[this.head];
+			this.items[this.head++] = void 0;
+			if (item && this.live.delete(item)) {
+				this.compact();
+				return item;
+			}
+		}
+	}
+	compact() {
+		if (this.live.size === 0) {
+			this.items = [];
+			this.head = 0;
+			return;
+		}
+		const dead = this.items.length - this.live.size;
+		if (dead <= 64 || dead <= this.live.size) return;
+		this.items = this.items.filter((item) => item !== void 0 && this.live.has(item));
+		this.head = 0;
+	}
+};
+/**
+* Adds to a plain solve call:
+* - Scheduling (latest-wins for sliders, queue for jobs)
+* - Backpressure (bounded queue depth + queue-wait deadline)
+* - Cancellation (per-call signal + cancelAll)
+* - Optional response caching for repeated inputs
+* - Lifecycle hooks (start / settle / superseded) and state via subscribe()
+*
+* @example
+* ```ts
+* const scheduler = client.createScheduler({ mode: 'latest-wins', timeoutMs: 30_000 });
+*
+* // From a slider handler:
+* scheduler.solve(definition, tree).then((result) => {
+*   updateMeshes(result);
+* }).catch((err) => {
+*   if (err.code !== 'SUPERSEDED') showError(err);
+* });
+*
+* // From a UI binding:
+* scheduler.subscribe(() => {
+*   showSpinner = scheduler.isSolving;
+* });
+* ```
+*/
+var SolveScheduler = class {
+	executor;
+	baseConfig;
+	mode;
+	maxConcurrent;
+	maxQueueDepth;
+	queueWaitMs;
+	timeoutMs;
+	retry;
+	cache;
+	reuseServerDefinitionCache;
+	/** Definition hash → the server's cache key (`pointer`) for it. */
+	serverCacheKeys = /* @__PURE__ */ new Map();
+	/** A string definition re-sent unchanged is compared with this, far cheaper than hashing it. */
+	lastStringDefinition = null;
+	onStart;
+	onSettle;
+	onSuperseded;
+	subscribers = /* @__PURE__ */ new Set();
+	inFlight = /* @__PURE__ */ new Set();
+	pendingForLatestWins = null;
+	fifo = new SolveQueue();
+	_lastResult = null;
+	_lastError = null;
+	_lastDurationMs = null;
+	solveSeq = 0;
+	/** seq of the solve that last wrote `_lastResult`/`_lastError`. */
+	lastStateSeq = 0;
+	disposed = false;
+	constructor(executor, baseConfig, options = {}) {
+		this.executor = executor;
+		this.baseConfig = baseConfig;
+		this.mode = options.mode ?? "latest-wins";
+		if (this.mode !== "latest-wins" && this.mode !== "queue") throw new ComputeError(`Unknown scheduler mode '${String(this.mode)}'. For concurrent solves use { mode: 'queue', maxConcurrent: 4 }.`, ErrorCodes.INVALID_CONFIG, { context: { mode: this.mode } });
+		this.maxConcurrent = concurrencyLimit(options.maxConcurrent ?? 1);
+		this.maxQueueDepth = options.maxQueueDepth !== void 0 && options.maxQueueDepth > 0 ? Math.floor(options.maxQueueDepth) : void 0;
+		this.queueWaitMs = options.queueWaitMs !== void 0 && options.queueWaitMs > 0 ? options.queueWaitMs : void 0;
+		this.timeoutMs = options.timeoutMs;
+		this.retry = options.retry;
+		this.cache = new ResponseCache(options.cache);
+		this.reuseServerDefinitionCache = options.reuseServerDefinitionCache ?? true;
+		this.onStart = options.onStart;
+		this.onSettle = options.onSettle;
+		this.onSuperseded = options.onSuperseded;
+	}
+	get isSolving() {
+		return this.inFlight.size > 0;
+	}
+	get hasPending() {
+		return this.pendingForLatestWins !== null || this.fifo.size > 0;
+	}
+	get inFlightCount() {
+		return this.inFlight.size;
+	}
+	get queueDepth() {
+		return this.fifo.size + (this.pendingForLatestWins ? 1 : 0);
+	}
+	get lastResult() {
+		return this._lastResult;
+	}
+	get lastError() {
+		return this._lastError;
+	}
+	get lastDurationMs() {
+		return this._lastDurationMs;
+	}
+	/**
+	* Adjust how many solves may run at once, for when the compute server's worker
+	* pool changes size after this scheduler was built.
+	*
+	* Raising it drains queued work immediately. Lowering it never interrupts work
+	* already in flight — those finish above the new limit, and the cap applies from
+	* the next dispatch. Values below 1 are clamped, since 0 would wedge the queue.
+	*
+	* @throws {ComputeError} `INVALID_CONFIG` for `NaN`, which would wedge it too.
+	*/
+	setMaxConcurrent(value) {
+		const next = concurrencyLimit(value);
+		if (next === this.maxConcurrent) return;
+		const raised = next > this.maxConcurrent;
+		this.maxConcurrent = next;
+		if (raised) this.drainNext();
+	}
+	/** Subscribe to state changes. */
+	subscribe(listener) {
+		this.subscribers.add(listener);
+		return () => this.subscribers.delete(listener);
+	}
+	notify() {
+		for (const listener of this.subscribers) try {
+			listener();
+		} catch (err) {
+			getLogger().error("[SolveScheduler] subscriber threw:", err);
+		}
+	}
+	/**
+	* Schedule a solve. Returns a promise that:
+	* - Resolves with the compute response on success.
+	* - Rejects with `ComputeError` on failure.
+	* - Rejects with `code: ErrorCodes.SUPERSEDED` when the call was canceled because
+	*   newer values arrived (latest-wins mode).
+	* - Rejects with `code: ErrorCodes.ABORTED` when the call was canceled via
+	*   its own `signal` (queued or running) or `cancelAll()`.
+	* - Rejects with `code: ErrorCodes.QUEUE_FULL` when `maxQueueDepth` is set and
+	*   the queue was already full (backpressure; `statusCode: 503`).
+	* - Rejects with `code: ErrorCodes.QUEUE_TIMEOUT` when `queueWaitMs` is set and
+	*   the call sat queued longer than that before starting (`statusCode: 503`).
+	*
+	* Don't mutate a `Uint8Array` definition after solving it. Responses served
+	* from the cache (and via `lastResult`) are shared objects, not copies —
+	* treat them as immutable. Mutating one poisons every later cache hit for
+	* that key.
+	*
+	* Partial-success contract: unlike `GrasshopperClient.solve()`, which throws
+	* `COMPUTATION_ERROR` when the response carries solver errors, this RESOLVES
+	* with the response as-is — check `response.errors` yourself if a partial
+	* success must not be treated as a result (see `cacheErroredSolves` for the
+	* caching side of the same distinction).
+	*/
+	solve(definition, dataTree, options) {
+		return this.solveDetailed(definition, dataTree, options).then((detail) => detail.response);
+	}
+	/** {@link solve}, also resolving with whether this call hit the cache and how long it took. */
+	solveDetailed(definition, dataTree, options) {
+		if (this.disposed) return Promise.reject(new ComputeError("SolveScheduler has been disposed and cannot be used", ErrorCodes.INVALID_STATE));
+		const hashes = new SolveInputHashes(() => this.hashDefinitionMemo(definition), dataTree);
+		let key = "";
+		if (this.cache.enabled || this.onStart || this.onSettle || this.onSuperseded) try {
+			key = hashes.key;
+		} catch (error) {
+			return Promise.reject(new ComputeError("Solve input could not be hashed", ErrorCodes.INVALID_INPUT, { originalError: error }));
+		}
+		const seq = ++this.solveSeq;
+		const ctx = {
+			key,
+			enqueuedAt: Date.now(),
+			startedAt: null
+		};
+		if (options?.signal?.aborted) return Promise.reject(this.makeAbortError(ctx));
+		const cached = this.cache.get(key);
+		if (cached) {
+			if (this.mode === "latest-wins") this.supersedeCurrent();
+			const result = {
+				status: "success",
+				response: cached,
+				durationMs: 0,
+				fromCache: true
+			};
+			this.writeLastState(seq, {
+				result: cached,
+				durationMs: 0
+			});
+			this.runHook(this.onStart, ctx);
+			this.runHook(this.onSettle, ctx, result);
+			this.notify();
+			return Promise.resolve({
+				response: cached,
+				fromCache: true,
+				durationMs: 0
+			});
+		}
+		return new Promise((resolve, reject) => {
+			const item = {
+				definition,
+				dataTree,
+				hashes,
+				ctx,
+				seq,
+				resolve,
+				reject,
+				externalSignal: options?.signal,
+				selvaevents: options?.selvaevents,
+				onServerTiming: options?.onServerTiming
+			};
+			if (item.externalSignal) {
+				item.onExternalAbort = () => {
+					if (item.controller) item.controller.abort();
+					else this.abortQueuedItem(item);
+				};
+				item.externalSignal.addEventListener("abort", item.onExternalAbort, { once: true });
+			}
+			this.enqueue(item);
+		});
+	}
+	/** A slow solve settling late must not overwrite state a newer solve or cache hit published. */
+	writeLastState(seq, state) {
+		if (seq < this.lastStateSeq) return;
+		this.lastStateSeq = seq;
+		if ("result" in state) {
+			this._lastResult = state.result;
+			this._lastError = null;
+		} else this._lastError = state.error;
+		this._lastDurationMs = state.durationMs;
+	}
+	/** latest-wins: supersede the pending item and abort everything in flight. */
+	supersedeCurrent() {
+		if (this.pendingForLatestWins) {
+			this.supersede(this.pendingForLatestWins);
+			this.pendingForLatestWins = null;
+		}
+		for (const inflight of this.inFlight) {
+			this.supersede(inflight);
+			inflight.controller.abort();
+		}
+	}
+	dequeue(item) {
+		if (this.pendingForLatestWins === item) this.pendingForLatestWins = null;
+		this.fifo.remove(item);
+	}
+	abortQueuedItem(item) {
+		this.dequeue(item);
+		this.fail(item, this.makeAbortError(item.ctx));
+		this.notify();
+	}
+	/** The structured context lets an HTTP layer map QUEUE_FULL to 503 + Retry-After. */
+	shedAsQueueFull(item) {
+		const err = new ComputeError("Solve queue is full; request rejected (backpressure)", ErrorCodes.QUEUE_FULL, {
+			statusCode: 503,
+			context: {
+				queueDepth: this.fifo.size,
+				maxQueueDepth: this.maxQueueDepth
+			}
+		});
+		this.fail(item, err);
+		this.notify();
+	}
+	armQueueWaitTimer(item) {
+		if (this.queueWaitMs === void 0) return;
+		const waitMs = this.queueWaitMs;
+		item.queueWaitTimer = setTimeout(() => {
+			if (item.settled) return;
+			this.dequeue(item);
+			const err = new ComputeError(`Solve waited longer than ${waitMs}ms in queue; rejected (backpressure)`, ErrorCodes.QUEUE_TIMEOUT, {
+				statusCode: 503,
+				context: {
+					waitedMs: Date.now() - item.ctx.enqueuedAt,
+					queueWaitMs: waitMs
+				}
+			});
+			this.fail(item, err);
+			this.notify();
+		}, waitMs);
+	}
+	clearQueueWaitTimer(item) {
+		if (item.queueWaitTimer !== void 0) {
+			clearTimeout(item.queueWaitTimer);
+			item.queueWaitTimer = void 0;
+		}
+	}
+	enqueue(item) {
+		switch (this.mode) {
+			case "latest-wins":
+				this.supersedeCurrent();
+				if (this.inFlight.size === 0) this.execute(item);
+				else this.pendingForLatestWins = item;
+				break;
+			case "queue": if (this.inFlight.size < this.maxConcurrent) this.execute(item);
+			else if (this.maxQueueDepth !== void 0 && this.fifo.size >= this.maxQueueDepth) this.shedAsQueueFull(item);
+			else {
+				this.armQueueWaitTimer(item);
+				this.fifo.push(item);
+			}
+		}
+		this.notify();
+	}
+	async execute(item) {
+		const controller = new AbortController();
+		const inflight = item;
+		inflight.controller = controller;
+		this.inFlight.add(inflight);
+		item.ctx.startedAt = Date.now();
+		this.clearQueueWaitTimer(item);
+		this.runHook(this.onStart, item.ctx);
+		this.notify();
+		const startTime = performance.now();
+		try {
+			const config = {
+				...this.baseConfig,
+				signal: controller.signal,
+				...this.timeoutMs !== void 0 && { timeoutMs: this.timeoutMs },
+				...this.retry !== void 0 && { retry: this.retry },
+				...item.selvaevents !== void 0 && { selvaevents: item.selvaevents }
+			};
+			const callTiming = item.onServerTiming;
+			if (callTiming) {
+				const baseTiming = this.baseConfig.onServerTiming;
+				config.onServerTiming = (timing, requestId) => {
+					try {
+						baseTiming?.(timing, requestId);
+					} finally {
+						callTiming(timing, requestId);
+					}
+				};
+			}
+			const { response, definitionReuploaded } = await this.runExecutor(item, config);
+			const durationMs = performance.now() - startTime;
+			if (!this.disposed) this.cache.set(item.ctx.key, response);
+			if (!this.settleSuccess(item, {
+				response,
+				fromCache: false,
+				definitionReuploaded,
+				durationMs
+			})) return;
+			this.writeLastState(item.seq, {
+				result: response,
+				durationMs
+			});
+			this.runHook(this.onSettle, item.ctx, {
+				status: "success",
+				response,
+				durationMs,
+				fromCache: false,
+				definitionReuploaded
+			});
+		} catch (error) {
+			const durationMs = performance.now() - startTime;
+			const err = this.normalizeExecutionError(error, inflight);
+			this.writeLastState(item.seq, {
+				error: err,
+				durationMs
+			});
+			this.fail(item, err, durationMs);
+		} finally {
+			this.inFlight.delete(inflight);
+			this.drainNext();
+			this.notify();
+		}
+	}
+	async runExecutor(item, config) {
+		const { definition, dataTree } = item;
+		if (!this.reuseServerDefinitionCache || isDefinitionUrl(definition)) {
+			const { response } = await this.executor(definition, dataTree, null, config);
+			return { response };
+		}
+		const definitionHash = item.hashes.definitionHash;
+		const knownKey = this.serverCacheKeys.get(definitionHash) ?? null;
+		const result = await this.executor(definition, dataTree, knownKey, config);
+		this.serverCacheKeys.delete(definitionHash);
+		if (result.cacheKey) {
+			this.serverCacheKeys.set(definitionHash, result.cacheKey);
+			if (this.serverCacheKeys.size > SERVER_CACHE_KEYS_MAX) this.serverCacheKeys.delete(this.serverCacheKeys.keys().next().value);
+		}
+		return {
+			response: result.response,
+			definitionReuploaded: result.missed
+		};
+	}
+	hashDefinitionMemo(definition) {
+		if (typeof definition !== "string") return hashDefinitionOnce(definition);
+		if (this.lastStringDefinition?.value !== definition) this.lastStringDefinition = {
+			value: definition,
+			hash: hashDefinition(definition)
+		};
+		return this.lastStringDefinition.hash;
+	}
+	drainNext() {
+		if (this.disposed) return;
+		if (this.mode === "latest-wins") {
+			if (this.pendingForLatestWins && this.inFlight.size === 0) {
+				const next = this.pendingForLatestWins;
+				this.pendingForLatestWins = null;
+				this.execute(next);
+			}
+			return;
+		}
+		while (this.fifo.size > 0 && this.inFlight.size < this.maxConcurrent) this.execute(this.fifo.shift());
+	}
+	supersede(item) {
+		const err = new ComputeError("Superseded by newer solve", ErrorCodes.SUPERSEDED, { context: { enqueuedAt: item.ctx.enqueuedAt } });
+		if (this.settleError(item, err)) this.runHook(this.onSuperseded, item.ctx);
+	}
+	makeAbortError(ctx) {
+		return abortedByCaller({ enqueuedAt: ctx.enqueuedAt });
+	}
+	/**
+	* The executor, `supersede`, `cancelAll`, abort and the queue limits can all race to settle one
+	* item, and a promise ignores a second settle silently. The first settle wins; the return value
+	* says whether this call won, so only the winner fires its hook. Every settle path goes through
+	* here or {@link settleSuccess}.
+	*/
+	settleError(item, err) {
+		if (!this.claimSettle(item, { error: err })) return false;
+		item.reject(err);
+		return true;
+	}
+	/**
+	* Fires `onSettle` for queued items too, so a consumer counting solves in progress doesn't
+	* leak one. A supersede settles through {@link settleError} and fires `onSuperseded` instead.
+	*/
+	fail(item, err, durationMs = 0) {
+		if (this.settleError(item, err)) this.runHook(this.onSettle, item.ctx, {
+			status: "error",
+			error: err,
+			durationMs
+		});
+	}
+	settleSuccess(item, detail) {
+		if (!this.claimSettle(item, { ok: true })) return false;
+		item.resolve(detail);
+		return true;
+	}
+	claimSettle(item, settled) {
+		if (item.settled) return false;
+		item.settled = settled;
+		this.clearQueueWaitTimer(item);
+		if (item.onExternalAbort) item.externalSignal?.removeEventListener("abort", item.onExternalAbort);
+		return true;
+	}
+	normalizeExecutionError(error, item) {
+		if (item.settled && "error" in item.settled) return item.settled.error;
+		if (error instanceof ComputeError) return error;
+		if (error instanceof Error && error.name === "AbortError") return this.makeAbortError(item.ctx);
+		return new ComputeError(error instanceof Error ? error.message : String(error), ErrorCodes.UNKNOWN_ERROR, { originalError: error });
+	}
+	/** Cancel everything — in-flight and pending. */
+	cancelAll() {
+		if (this.pendingForLatestWins) {
+			this.fail(this.pendingForLatestWins, this.makeAbortError(this.pendingForLatestWins.ctx));
+			this.pendingForLatestWins = null;
+		}
+		for (let item = this.fifo.shift(); item; item = this.fifo.shift()) this.fail(item, this.makeAbortError(item.ctx));
+		for (const inflight of this.inFlight) {
+			const durationMs = inflight.ctx.startedAt ? Date.now() - inflight.ctx.startedAt : 0;
+			this.fail(inflight, this.makeAbortError(inflight.ctx), durationMs);
+			inflight.controller.abort();
+		}
+		this.notify();
+	}
+	clearCache() {
+		this.cache.clear();
+	}
+	/**
+	* Observability snapshot of the solve cache: current size plus lifetime
+	* hit/miss/eviction counters.
+	*
+	* `hits`/`misses` count cache CONSULTATIONS, so `hits / (hits + misses)` is the
+	* hit rate. A TTL-expired entry counts as a miss (the solve runs either way).
+	* `evictions` counts only entries dropped under size/byte pressure — not
+	* replace-in-place writes or TTL expiry, which are not capacity signals.
+	* Counters are cumulative and survive `clearCache()`.
+	*/
+	cacheStats() {
+		return this.cache.stats();
+	}
+	dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		this.cancelAll();
+		this.subscribers.clear();
+		this.clearCache();
+	}
+	runHook(hook, ...args) {
+		if (!hook) return;
+		try {
+			hook(...args);
+		} catch (err) {
+			getLogger().error("[SolveScheduler] hook threw:", err);
+		}
+	}
+};
+function describeDefinition(definition) {
+	if (isDefinitionRef(definition)) return `ref:${definition.key}`;
+	if (typeof definition !== "string" || definition.length >= 200) return "...content...";
+	return isDefinitionUrl(definition) ? redactUrl(definition) : definition;
+}
+/** Identifiers only: the error's `context` holds outputs and its message the server's words. */
+function describeFailure(error) {
+	if (!(error instanceof ComputeError)) return `Compute failed: ${error instanceof Error ? error.name : typeof error}`;
+	const status = error.statusCode === void 0 ? "" : ` HTTP ${error.statusCode}`;
+	const requestId = error.context?.requestId;
+	return `Compute failed: ${error.code}${status}${requestId ? ` [${requestId}]` : ""}`;
+}
+/**
+* Stands in for the input tree on errors: the tree can hold multi-MB geometry, and every logger
+* or telemetry sink that keeps the error would pin it. Never throws on a malformed tree.
+*/
+function summarizeDataTree(dataTree) {
+	if (!Array.isArray(dataTree)) return [];
+	return dataTree.map((tree) => {
+		let items = 0;
+		let bytes = 0;
+		const innerTree = readField(tree, "innerTree");
+		if (innerTree && typeof innerTree === "object") for (const branch of Object.values(innerTree)) {
+			if (!Array.isArray(branch)) continue;
+			items += branch.length;
+			for (const item of branch) {
+				const data = item?.data;
+				if (typeof data === "string") bytes += data.length;
+			}
+		}
+		return {
+			param: readField(tree, "paramName") ?? "<unnamed>",
+			items,
+			bytes
+		};
+	});
+}
+/**
+* The high-level API for solving Grasshopper definitions on a Rhino Compute server.
+*
+* In a browser, the server URL and API key are exposed to users: run it server-side, or proxy
+* requests through your own backend.
+*
+* @example
+* ```typescript
+* const client = await GrasshopperClient.create({
+*   serverUrl: 'http://localhost:6500',
+*   apiKey: 'your-api-key'
+* });
+*
+* try {
+*   const io = await client.getIO(definitionUrl);
+*   const result = await client.solve(definitionUrl, TreeBuilder.fromInputParams(io.inputs));
+* } finally {
+*   await client.dispose(); // Clean up resources
+* }
+* ```
+*/
+var GrasshopperClient = class GrasshopperClient {
+	config;
+	serverStats;
+	schedulers = /* @__PURE__ */ new Set();
+	disposed = false;
+	/**
+	* Per-probe timeout for the `create()` liveness gate: a healthy `GET /` answers in milliseconds,
+	* so this only bounds a silent server, and every extra second is paid once per retry.
+	*/
+	static CREATE_PROBE_TIMEOUT_MS = 2e3;
+	constructor(config) {
+		this.config = {
+			...config,
+			serverUrl: validateServerUrl(config.serverUrl),
+			debug: config.debug ?? false
+		};
+		this.serverStats = new ComputeServerStats(this.config.serverUrl, this.config);
+	}
+	/**
+	* Creates a client once a liveness probe (`GET /`) says the server is up. A cold server can read
+	* as offline, so the probe retries with a short backoff, stopping early when
+	* {@link classifyProbeFailure} says waiting can't change the answer. `config.signal` cancels the
+	* ladder.
+	*
+	* @throws {ComputeError} `NETWORK_ERROR` if the server stays unreachable across all attempts.
+	*   `context.probeVerdict` carries the verdict, so a caller can render a specific cause.
+	* @throws {ComputeError} `ABORTED` if `config.signal` fires first.
+	* @throws {ComputeError} `INVALID_CONFIG` if the configuration is invalid.
+	*/
+	static async create(config, options = {}) {
+		const client = new GrasshopperClient(config);
+		const { signal } = config;
+		const attempts = Math.max(1, (options.probe?.attempts ?? 2) + 1);
+		const baseDelayMs = options.probe?.baseDelayMs ?? 250;
+		const maxDelayMs = options.probe?.maxDelayMs ?? 1e3;
+		let lastProbe;
+		let failure = null;
+		let used = 0;
+		for (let attempt = 0; attempt < attempts && !signal?.aborted; attempt++) {
+			used = attempt + 1;
+			lastProbe = await client.serverStats.probeServer(GrasshopperClient.CREATE_PROBE_TIMEOUT_MS, signal);
+			if (lastProbe.online) return client;
+			failure = classifyProbeFailure(lastProbe);
+			if (failure && !failure.retryable) break;
+			if (attempt < attempts - 1) await sleep(Math.min(baseDelayMs * 2 ** attempt, maxDelayMs), signal).catch(() => {});
+		}
+		await client.dispose();
+		if (signal?.aborted) throw abortedByCaller({
+			serverUrl: client.config.serverUrl,
+			attempts: used
+		});
+		const status = lastProbe?.status;
+		throw new ComputeError(failure ? `Rhino Compute server is not available. ${failure.summary}` : "Rhino Compute server is not online", ErrorCodes.NETWORK_ERROR, {
+			...status !== void 0 && { statusCode: status },
+			context: {
+				serverUrl: client.config.serverUrl,
+				attempts: used,
+				maxAttempts: attempts,
+				...failure && {
+					probeVerdict: failure.verdict,
+					probeRetryable: failure.retryable
+				},
+				...status !== void 0 && { lastProbeStatus: status },
+				...lastProbe?.error !== void 0 && { lastProbeError: lastProbe.error }
+			}
+		});
+	}
+	/**
+	* Get input/output parameters of a Grasshopper definition.
+	*/
+	async getIO(definition) {
+		this.ensureNotDisposed();
+		return fetchParsedDefinitionIO(definition, this.config);
+	}
+	async getRawIO(definition) {
+		this.ensureNotDisposed();
+		return fetchDefinitionIO(definition, this.config);
+	}
+	/**
+	* Run a compute job with a Grasshopper definition.
+	*
+	* @throws {ComputeError} with code INVALID_INPUT if definition is empty
+	* @throws {ComputeError} with code NETWORK_ERROR if server is offline
+	* @throws {ComputeError} with code COMPUTATION_ERROR if computation fails.
+	*   On a partial-success response (some outputs computed, some errored) the
+	*   error's `context.values` carries the outputs that did compute — pass
+	*   `{ values } as GrasshopperComputeResponse` to the response processors to
+	*   render them. `context.inputSummary` describes the inputs (param names,
+	*   item counts, byte sizes) without pinning the full data tree.
+	*/
+	async solve(definition, dataTree, options) {
+		this.ensureNotDisposed();
+		const describeCall = () => ({
+			definition: describeDefinition(definition),
+			inputSummary: summarizeDataTree(dataTree)
+		});
+		try {
+			if (typeof definition === "string" && !definition.trim()) throw new ComputeError("Definition URL/content is required", ErrorCodes.INVALID_INPUT, { context: { receivedUrl: definition } });
+			else if (definition instanceof Uint8Array && definition.length === 0) throw new ComputeError("Definition content is empty", ErrorCodes.INVALID_INPUT);
+			else if (isDefinitionRef(definition) && !definition.key.trim()) throw new ComputeError("DefinitionRef key is empty", ErrorCodes.INVALID_INPUT);
+			const result = await solveGrasshopperDefinition(dataTree, definition, {
+				...this.config,
+				...options?.signal !== void 0 && { signal: options.signal },
+				...options?.timeoutMs !== void 0 && { timeoutMs: options.timeoutMs },
+				...options?.retry !== void 0 && { retry: options.retry },
+				...options?.selvaevents !== void 0 && { selvaevents: options.selvaevents }
+			});
+			const solveErrors = readField(result, "errors");
+			if (Array.isArray(solveErrors) && solveErrors.length > 0) throw new ComputeError(solveErrors.map(String).join("; ") || "Computation failed", ErrorCodes.COMPUTATION_ERROR, { context: {
+				...describeCall(),
+				errors: solveErrors,
+				warnings: readField(result, "warnings"),
+				values: result.values
+			} });
+			return result;
+		} catch (error) {
+			if (this.config.debug) getLogger().error(describeFailure(error));
+			if (error instanceof ComputeError) throw error;
+			throw new ComputeError(error instanceof Error ? error.message : String(error), ErrorCodes.COMPUTATION_ERROR, {
+				context: describeCall(),
+				originalError: error
+			});
+		}
+	}
+	/**
+	* Create a scheduler bound to this client. Use a scheduler for any UI surface
+	* that fires solves frequently (sliders, live editors) or that needs cancel
+	* semantics, response caching, or state observability.
+	*
+	* Multiple schedulers can be created from a single client — typically one per
+	* UI surface so their queues stay independent.
+	*
+	* @example
+	* ```ts
+	* const sliderScheduler = client.createScheduler({ mode: 'latest-wins' });
+	* const submitScheduler = client.createScheduler({ mode: 'queue', timeoutMs: 0 });
+	* ```
+	*/
+	createScheduler(options) {
+		this.ensureNotDisposed();
+		const scheduler = new SolveScheduler((definition, dataTree, cacheKey, config) => solveWithServerCacheKey(dataTree, cacheKey, definition, config), this.config, options);
+		this.schedulers.add(scheduler);
+		return scheduler;
+	}
+	/** Disposes of client resources, including every scheduler it created. */
+	async dispose() {
+		if (this.disposed) return;
+		this.disposed = true;
+		for (const scheduler of this.schedulers) scheduler.dispose();
+		this.schedulers.clear();
+		await this.serverStats.dispose();
+	}
+	ensureNotDisposed() {
+		if (this.disposed) throw new ComputeError("GrasshopperClient has been disposed and cannot be used", ErrorCodes.INVALID_STATE);
+	}
+};
+function makeDecodeError(rhinoType, raw) {
+	return {
+		__decodeError: true,
+		type: rhinoType,
+		raw
+	};
+}
+/**
+* Free every rhino3dm WASM object reachable from `value`.
+*
+* rhino3dm objects are emscripten bindings — JS GC never reclaims their WASM
+* heap allocation, so everything decoded from a solve response (`getValues`,
+* `getValue`) must be deleted explicitly or the heap
+* grows monotonically across solves (e.g. a UI decoding per slider tick).
+*
+* Walks arrays and plain objects recursively; anything exposing a `delete()`
+* method is treated as a WASM binding and freed (skipped if already deleted).
+* Safe to call more than once and on values containing no WASM objects.
+*/
+function disposeRhinoObjects(value) {
+	const seen = /* @__PURE__ */ new WeakSet();
+	const walk = (v) => {
+		if (!v || typeof v !== "object") return;
+		if (seen.has(v)) return;
+		seen.add(v);
+		const del = v.delete;
+		if (typeof del === "function") {
+			const isDeleted = v.isDeleted;
+			if (typeof isDeleted !== "function" || !isDeleted.call(v)) del.call(v);
+			return;
+		}
+		if (Array.isArray(v)) {
+			for (const item of v) walk(item);
+			return;
+		}
+		const proto = Object.getPrototypeOf(v);
+		if (proto === Object.prototype || proto === null) for (const item of Object.values(v)) walk(item);
+	};
+	walk(value);
+}
+var decoders = /* @__PURE__ */ new Map([["Rhino.Geometry.Point3d", (rhino, data) => {
+	const d = data;
+	if (!d || typeof d.X !== "number") return null;
+	return new rhino.Point([
+		d.X,
+		d.Y,
+		d.Z
+	]);
+}], ["Rhino.Geometry.Line", (rhino, data) => {
+	const d = data;
+	if (!d || !d.From || !d.To) return null;
+	return new rhino.Line([
+		d.From.X,
+		d.From.Y,
+		d.From.Z
+	], [
+		d.To.X,
+		d.To.Y,
+		d.To.Z
+	]);
+}]]);
+/**
+* Whether the parsed item looks like a rhino3dm serialization envelope
+* (`{version, archive3dm, opennurbs, data: "<base64>"}`). `CommonObject.decode` expects the WHOLE
+* envelope — unwrapping `.data` first hands it the bare base64 string, which throws or decodes to
+* garbage.
+*/
+function isDecodableEnvelope(parsedData) {
+	return Boolean(parsedData && typeof parsedData === "object" && typeof parsedData.data === "string");
+}
+/**
+* Decode one typed payload from a solve response into a rhino3dm object.
+*
+* Every call yields exactly one of three outcomes:
+*
+* 1. **Decoded value** — a registered decoder recognized the shape, or the
+*    payload was a rhino3dm serialization envelope and `CommonObject.decode`
+*    succeeded.
+* 2. **Raw passthrough** (`=== parsedData`) — no decode path *applied*: no
+*    decoder matched the type (or the matched decoder returned `null`, meaning
+*    "not my shape") and the payload is not a decodable envelope. Not an error;
+*    the caller keeps the parsed JSON as-is.
+* 3. **{@link RhinoDecodeError} sentinel** — a decode was *attempted and threw*
+*    (a registered decoder threw and no envelope fallback could recover, or
+*    `CommonObject.decode` threw). Detect with {@link isRhinoDecodeError}.
+*
+* A decoder returning `null` is a soft miss, never an error: it falls through
+* to the envelope fallback.
+*/
+function decodeRhinoGeometry(parsedData, rhinoType, rhino) {
+	const decoder = decoders.get(rhinoType);
+	let decoderThrew = false;
+	if (decoder) try {
+		const decoded = decoder(rhino, parsedData);
+		if (decoded != null) return decoded;
+	} catch (error) {
+		getLogger().warn(`Failed to decode Rhino type ${rhinoType}:`, error);
+		decoderThrew = true;
+	}
+	try {
+		if (isDecodableEnvelope(parsedData)) return rhino.CommonObject.decode(parsedData);
+	} catch (error) {
+		getLogger().warn(`Failed to decode ${rhinoType} with CommonObject:`, error);
+		return makeDecodeError(rhinoType, parsedData);
+	}
+	return decoderThrew ? makeDecodeError(rhinoType, parsedData) : parsedData;
+}
+var RHINO_GEOMETRY_PREFIX = "Rhino.Geometry.";
+var FILE_DATA_TYPE = "FileData";
+/** WebDisplay items are skipped entirely: kept, they would write `null` into the result. */
+function skipItem(type, stringOnly) {
+	return type.includes("WebDisplay") || stringOnly && type !== "System.String";
+}
+var looksStructured = (text) => text.startsWith("{") || text.startsWith("[");
+function tryDecodeJSON(value) {
+	if (typeof value !== "string") return value;
+	const trimmed = value.trim();
+	if (!looksStructured(trimmed) && !trimmed.startsWith("\"")) return value;
+	const first = tryParseJson(trimmed) ?? value;
+	return typeof first === "string" && looksStructured(first.trim()) ? tryParseJson(first) ?? first : first;
+}
+function decodeBySystemType(raw, type, rhino) {
+	if (type === "System.String") return typeof raw === "string" ? raw.replace(/^"(.*)"$/, "$1") : raw;
+	if (INTEGER_ITEM_TYPES.has(type)) {
+		const value = Number.parseInt(String(raw), 10);
+		return Number.isNaN(value) || Number.isSafeInteger(value) ? value : raw;
+	}
+	if (NUMERIC_ITEM_TYPES.has(type)) return Number.parseFloat(String(raw));
+	if (type === "System.Boolean") return String(raw).toLowerCase() === "true";
+	if (rhino && type.startsWith(RHINO_GEOMETRY_PREFIX)) return decodeRhinoGeometry(raw, type, rhino);
+	return raw;
+}
+function extractItemValue(item, type, parseValues, rhino) {
+	if (typeof item.data !== "string") return item.data;
+	const raw = parseValues ? tryDecodeJSON(item.data) : item.data;
+	if (parseValues && type.includes(FILE_DATA_TYPE)) return asFileData(raw) ?? raw;
+	return decodeBySystemType(raw, type, rhino);
+}
+/**
+* A parsed `FileData` blob in the camelCase shape {@link FileData} documents, or
+* `null` when a required field is missing. Fields are read with `readField`,
+* since their casing varies by server branch.
+*/
+function asFileData(value) {
+	if (!value || typeof value !== "object") return null;
+	const fileName = readField(value, "fileName");
+	const fileType = readField(value, "fileType");
+	const subFolder = readField(value, "subFolder");
+	const flag = readField(value, "isBase64Encoded");
+	if (typeof fileName !== "string" || typeof fileType !== "string") return null;
+	if (typeof subFolder !== "string") return null;
+	if (!hasField(value, "data")) return null;
+	if (typeof flag !== "boolean" && typeof flag !== "string") return null;
+	const metadata = readField(value, "metadata");
+	return {
+		fileName,
+		fileType,
+		data: readField(value, "data"),
+		isBase64Encoded: isBase64Flag(flag),
+		subFolder,
+		...metadata ? { metadata } : {}
+	};
+}
+/** Partial-success and warnings-only responses can arrive with no `values` at all. */
+function getResponseParams(response) {
+	const values = readField(response, "values");
+	return Array.isArray(values) ? values : [];
+}
+/** A param's item type, tolerating items whose `type` is missing/non-string. */
+function itemType(item) {
+	return typeof item.type === "string" ? item.type : "";
+}
+/** Tolerates a missing tree (warnings-only partial successes) and skips non-object items. */
+function forEachTreeItem(tree, handler) {
+	if (!tree || typeof tree !== "object") return;
+	for (const list of Object.values(tree)) if (Array.isArray(list)) {
+		for (const item of list) if (item && typeof item === "object") handler(item);
+	}
+}
+/**
+* Read all output values from a Grasshopper Compute response, keyed by parameter
+* name (or ID when `byId`). Duplicate keys aggregate into an array.
+*
+* Geometry decoded via `rhino` lives on the WASM heap: free it with `dispose()`.
+*
+* @param options.parseValues - Parse complex data types into JS objects (default true).
+* @param options.rhino - Rhino3dm instance for geometry decoding.
+* @param options.stringOnly - Keep only string-typed items.
+*/
+function getValues(response, byId = false, options = {}) {
+	const { parseValues = true, rhino, stringOnly = false } = options;
+	const result = {};
+	const aggregated = /* @__PURE__ */ new Set();
+	for (const param of getResponseParams(response)) {
+		const paramName = readField(param, "paramName");
+		forEachTreeItem(readField(param, "innerTree"), (item) => {
+			const type = itemType(item);
+			if (skipItem(type, stringOnly)) return;
+			const key = byId ? item.id : paramName;
+			if (!key) return;
+			const value = extractItemValue(item, type, parseValues, rhino);
+			if (!Object.hasOwn(result, key)) setOwnField(result, key, value);
+			else if (aggregated.has(key)) result[key].push(value);
+			else {
+				result[key] = [result[key], value];
+				aggregated.add(key);
+			}
+		});
+	}
+	return {
+		values: result,
+		dispose: () => disposeRhinoObjects(result)
+	};
+}
+/** Decode every file-data item in a response into {@link FileData} objects. */
+function extractFileData(response) {
+	const output = [];
+	for (const param of getResponseParams(response)) forEachTreeItem(readField(param, "innerTree"), (item) => {
+		if (!itemType(item).includes(FILE_DATA_TYPE)) return;
+		const file = asFileData(tryDecodeJSON(item.data));
+		if (file) output.push(file);
+	});
+	return output;
+}
+/**
+* Read one parameter's value(s) from a response — `byName` matches a `ParamName`,
+* `byId` matches an item ID. Returns `undefined` if absent, a single value for one
+* match, or an array for several.
+*
+* Geometry decoded via `rhino` lives on the WASM heap: free it with
+* {@link disposeRhinoObjects} once consumed.
+*
+* @param parseOptions.parseValues - Parse raw data into formatted values (default true).
+* @param parseOptions.rhino - Rhino3dm instance for geometry decoding.
+* @param parseOptions.stringOnly - Keep only string-typed items.
+*/
+function getValue(response, options, parseOptions = {}) {
+	const { parseValues = true, rhino, stringOnly = false } = parseOptions;
+	for (const param of getResponseParams(response)) {
+		const tree = readField(param, "innerTree");
+		let matched = false;
+		if ("byName" in options) {
+			if (readField(param, "paramName") !== options.byName) continue;
+			matched = true;
+		}
+		const collected = [];
+		forEachTreeItem(tree, (item) => {
+			if ("byId" in options) {
+				if (item.id !== options.byId) return;
+				matched = true;
+			}
+			const type = itemType(item);
+			if (skipItem(type, stringOnly)) return;
+			collected.push(extractItemValue(item, type, parseValues, rhino));
+		});
+		if (matched) {
+			if (collected.length === 0) return void 0;
+			if (collected.length === 1) return collected[0];
+			return collected;
+		}
+	}
+}
+/** Reads parsed values and produced files out of one compute response. */
+var GrasshopperResponseProcessor = class {
+	response;
+	constructor(response) {
+		this.response = response;
+	}
+	/**
+	* Extract all values in the response.
+	*
+	* @typeParam T - Expected structure of the return value. Defaults to a simple key/value map. (later cast as needed)
+	* @param byId - Key by parameter ID instead of name. Requires the VektorNode rhino.compute branch.
+	* @param options - Controls parsing behavior such as Rhino geometry decoding.
+	* @returns Parsed Grasshopper output values.
+	*
+	* @example
+	* ```ts
+	* const processor = new GrasshopperResponseProcessor(response);
+	* const { values } = processor.getValues();
+	* ```
+	*
+	*/
+	getValues(byId = false, options = {}) {
+		return getValues(this.response, byId, options);
+	}
+	/**
+	* Retrieve a specific value by parameter name or ID.
+	*
+	* @param selector - `{ byName }` for the human-readable name, `{ byId }` for the parameter GUID.
+	* @param options - Parsing configuration (e.g. disable parsing or enable Rhino).
+	* @returns Single parsed value, array of values, or undefined if the parameter is absent.
+	*
+	* `byId` requires the VektorNode rhino.compute branch.
+	*
+	* @example
+	* ```ts
+	* const schema = processor.getValue({ byName: 'Schema' });
+	* const output = processor.getValue({ byId: 'a4be1c1e-23f9-4c27-b942-7f3bb2c45c6f' });
+	* ```
+	*/
+	getValue(selector, options) {
+		return getValue(this.response, selector, options);
+	}
+	/**
+	* Download all files generated by Grasshopper, optionally including
+	* additional user-provided files.
+	*
+	* @param folderName - Name of the zip archive, without the extension.
+	* @param additionalFiles - Extra files to package (single file, array, or null).
+	*
+	* @example
+	* ```ts
+	* await processor.getAndDownloadFiles('gh-output');
+	* ```
+	*
+	* @example
+	* ```ts
+	* const extra = { fileName: 'notes.txt', filePath: 'https://example.com/notes.txt' };
+	* await processor.getAndDownloadFiles('project', extra);
+	* ```
+	*/
+	async getAndDownloadFiles(folderName, additionalFiles) {
+		await downloadFileData(extractFileData(this.response), folderName, additionalFiles);
+	}
+};
+/**
+* Read compute's `/grasshopper/schema` body: `[{ FileName, Schemas }]` per
+* uploaded file, or a bare object for a single file.
+*
+* Use this rather than unwrapping the body by hand: the wrapper keys' casing
+* varies by server branch, and a fixed-key read yields "no schemas" with a 200.
+* Only the two wrapper keys are read; schema contents pass through untouched.
+*
+* @typeParam TSchema - Your schema type (e.g. `UISchema`). Not inspected.
+*/
+function readSchemaResults(raw) {
+	return (Array.isArray(raw) ? raw : [raw]).map((entry) => ({
+		schemas: readField(entry, "schemas"),
+		error: readField(entry, "error")
+	}));
+}
+/**
+* Canonicalize a `/grasshopper/schema` body's key casing.
+*
+* Compute serializes the plugin's `UISchema`, whose camelCase wire names live in
+* Newtonsoft `[JsonProperty]` attributes. `Selva.gha` ILRepack-merges Newtonsoft,
+* so those attributes are `Selva!Newtonsoft.Json.JsonPropertyAttribute`. When
+* compute's OWN Newtonsoft serializes, it doesn't recognize them, reads no
+* attributes, and emits raw CLR names (`Inputs`, `SchemaVersion`). Nothing throws:
+* `schema.inputs` reads `undefined`, and so does the `schemaVersion` gate.
+*
+* A casing rule, not a key allowlist: the wire names are the CLR names run
+* through Newtonsoft's camelCase strategy, so reproducing it covers every key
+* without drifting each time `UISchema` gains a field.
+*/
+/** Maps keyed by the definition's author (dropdown labels): copied verbatim. */
+var USER_AUTHORED_MAPS = /* @__PURE__ */ new Set([
+	"options",
+	"defaultOptions",
+	"values"
+]);
+/** Maps with author or hash keys whose entries are schema objects: keys verbatim, entries normalized. */
+var USER_KEYED_OBJECT_MAPS = /* @__PURE__ */ new Set(["optionMedia", "assets"]);
+var isUpper = (ch) => ch >= "A" && ch <= "Z";
+/**
+* Newtonsoft's `CamelCaseNamingStrategy`: a leading run of capitals is lowercased
+* whole, except the last one when a lowercase word follows. `UV` → `uv`,
+* `UVMapping` → `uvMapping` (a first-character rule gives `uVMapping`).
+*/
+function toCamelCase(key) {
+	if (key.length === 0 || !isUpper(key[0])) return key;
+	let run = 0;
+	while (run < key.length && isUpper(key[run])) run++;
+	if (run > 1 && run < key.length) run--;
+	return key.slice(0, run).toLowerCase() + key.slice(run);
+}
+/**
+* Returns a schema whose structural keys are camelCase, whichever Newtonsoft
+* serialized it. Always a fresh object the caller may mutate; non-objects are
+* returned as-is.
+*/
+function normalizeUISchemaCasing(raw) {
+	return normalizeValue(raw);
+}
+function normalizeValue(value) {
+	if (Array.isArray(value)) return value.map(normalizeValue);
+	if (value === null || typeof value !== "object") return value;
+	const out = {};
+	for (const [key, child] of Object.entries(value)) {
+		const canonical = toCamelCase(key);
+		setOwnField(out, canonical, USER_AUTHORED_MAPS.has(canonical) ? child : USER_KEYED_OBJECT_MAPS.has(canonical) ? normalizeEntries(child) : normalizeValue(child));
+	}
+	return out;
+}
+function normalizeEntries(value) {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) return value;
+	const out = {};
+	for (const [key, child] of Object.entries(value)) setOwnField(out, key, normalizeValue(child));
+	return out;
+}
+/**
+* Builds the Grasshopper data trees a solve takes as input.
+*
+* @example
+* ```ts
+* const tree = new TreeBuilder('MyParam')
+*   .append([0], [1, 2, 3])
+*   .append([1], [4, 5])
+*   .toComputeFormat();
+* ```
+*/
+var TreeBuilder = class TreeBuilder {
+	innerTree;
+	paramName;
+	constructor(paramName) {
+		this.paramName = paramName;
+		this.innerTree = {};
+	}
+	/** Append values to the branch at `path` (`[0, 1]` is `{0;1}`). A `null` item is skipped. */
+	append(path, items) {
+		const branch = this.innerTree[TreeBuilder.formatPathString(path)] ??= [];
+		for (const item of items) if (item !== null) branch.push({ data: TreeBuilder.serializeValue(item) });
+		return this;
+	}
+	/** Replace the tree with a branch-path map like `{ '{0;1}': [1, 2] }`. */
+	fromDataTreeDefault(treeData) {
+		this.innerTree = {};
+		for (const [pathStr, items] of Object.entries(treeData)) {
+			if (!Array.isArray(items)) continue;
+			const path = TreeBuilder.parsePathString(pathStr);
+			this.append(path, items);
+		}
+		return this;
+	}
+	/** Append a value, or each value of an array, to branch `{0}`. */
+	appendFlat(values) {
+		const items = Array.isArray(values) ? values : [values];
+		return this.append([0], items);
+	}
+	/** The tree in the shape a solve request sends. */
+	toComputeFormat() {
+		return {
+			ParamName: this.paramName,
+			InnerTree: this.innerTree
+		};
+	}
+	/**
+	* One tree per input that has a default, keyed by its nickname. Defaults are coerced and
+	* clamped by the same rules as {@link TreeBuilder.fromValues}.
+	*/
+	static fromInputParams(inputs) {
+		return TreeBuilder.fromValues(inputs.map((input) => ({
+			paramName: input.nickname || "unnamed",
+			paramType: input.paramType,
+			value: input.default,
+			..."minimum" in input && {
+				minimum: input.minimum,
+				maximum: input.maximum
+			}
+		})));
+	}
+	/**
+	* One tree per entry, coercing UI values the way Grasshopper reads them. Number and Integer
+	* items go through the numeric coercion (Integer rounds) and are clamped to
+	* `minimum`/`maximum`; Boolean items also accept `'true'`/`'false'`; every other type passes
+	* through. An item that fails coercion is dropped with a warning. An entry left with no items
+	* is omitted, so Grasshopper uses its own value; `''` is an item, not an empty value.
+	*/
+	static fromValues(entries) {
+		const trees = [];
+		for (const entry of entries) {
+			const tree = new TreeBuilder(entry.paramName);
+			const coerce = TreeBuilder.itemCoercer(entry);
+			for (const [path, items] of TreeBuilder.branchesOf(entry.value)) {
+				const kept = [];
+				for (const item of items) {
+					if (item === null || item === void 0) continue;
+					const coerced = coerce(item);
+					if (coerced === null) getLogger().warn(`${entry.paramName}: dropped an item that is not a valid ${entry.paramType}`);
+					else kept.push(coerced);
+				}
+				if (kept.length > 0) tree.append(path, kept);
+			}
+			if (Object.keys(tree.innerTree).length > 0) trees.push(tree.toComputeFormat());
+		}
+		return trees;
+	}
+	static branchesOf(value) {
+		if (!TreeBuilder.hasValidValue(value)) return [];
+		if (isDataTreeDefault(value)) return Object.entries(value).map(([path, items]) => [TreeBuilder.parsePathString(path), items]);
+		return [[[0], Array.isArray(value) ? value : [value]]];
+	}
+	/** `null` means the item was rejected. */
+	static itemCoercer(entry) {
+		const { paramName, minimum, maximum } = entry;
+		const paramType = entry.paramType.toLowerCase();
+		if (paramType === "number" || paramType === "integer") return (item) => {
+			const n = numericTransformer(item);
+			if (n === null) return null;
+			const value = paramType === "integer" ? Math.round(n) : n;
+			return TreeBuilder.clampValue(value, minimum, maximum, paramName);
+		};
+		if (paramType === "boolean") return booleanTransformer;
+		return (item) => item;
+	}
+	/**
+	* Set or add `paramName`'s tree to `newValue`: a scalar, an array (branch `{0}`), or a
+	* branch-path map. Copy-on-write: returns a new array and leaves the caller's untouched, so
+	* assign the result.
+	*/
+	static replaceTreeValue(trees, paramName, newValue) {
+		const compiled = TreeBuilder.buildFromValue(paramName, newValue).toComputeFormat();
+		const result = trees.slice();
+		const idx = result.findIndex((t) => TreeBuilder.paramNameOf(t) === paramName);
+		if (idx === -1) result.push(compiled);
+		else result[idx] = compiled;
+		return result;
+	}
+	static buildFromValue(paramName, value) {
+		const tree = new TreeBuilder(paramName);
+		if (isDataTreeDefault(value)) tree.fromDataTreeDefault(value);
+		else tree.appendFlat(value);
+		return tree;
+	}
+	/**
+	* `paramName`'s whole tree from a solve result's `values`, keyed by branch path (`'{0;1}'`).
+	* `null` when no tree has that param, an empty `Map` when it has no branches. An item without
+	* `data` reads as `null` in place, so indices don't shift.
+	*/
+	static getTree(trees, paramName) {
+		const tree = trees.find((t) => TreeBuilder.paramNameOf(t) === paramName);
+		if (!tree) return null;
+		const branches = /* @__PURE__ */ new Map();
+		const inner = readField(tree, "InnerTree");
+		if (!inner || typeof inner !== "object") return branches;
+		for (const [path, items] of Object.entries(inner)) {
+			if (!Array.isArray(items)) continue;
+			branches.set(path, items.map((item) => item?.data !== void 0 ? TreeBuilder.deserializeValue(item.data) : null));
+		}
+		return branches;
+	}
+	/**
+	* `paramName`'s value when its tree has a single branch: one item unwrapped (`5`, not `[5]`),
+	* several as an array. `null` for a missing param or an empty tree.
+	*
+	* @throws {ComputeError} `INVALID_INPUT` when the tree has more than one branch; read those
+	*   with {@link TreeBuilder.getTree}.
+	*/
+	static getTreeValue(trees, paramName) {
+		const tree = TreeBuilder.getTree(trees, paramName);
+		if (!tree || tree.size === 0) return null;
+		if (tree.size > 1) throw new ComputeError(`"${paramName}" has ${tree.size} branches; read it with TreeBuilder.getTree`, ErrorCodes.INVALID_INPUT, { context: {
+			paramName,
+			branchCount: tree.size
+		} });
+		const [items] = tree.values();
+		if (items.length === 0) return null;
+		return items.length === 1 ? items[0] : items;
+	}
+	static paramNameOf(tree) {
+		return readField(tree, "ParamName");
+	}
+	/**
+	* Parse a branch path like `"{0;1;2}"` into `[0, 1, 2]`.
+	*
+	* @throws {ComputeError} `INVALID_INPUT` for a malformed path, rather than
+	*   collapsing it to a default branch where two bad keys would merge.
+	*/
+	static parsePathString(pathStr) {
+		const match = pathStr.match(TREE_PATH_RE);
+		if (!match) throw new ComputeError(`Invalid Grasshopper tree path: "${pathStr}". Expected "{}", "{0}", or "{0;1;2}" (negative indices allowed, no empty segments).`, ErrorCodes.INVALID_INPUT, { context: { pathStr } });
+		if (!match[1]) return [];
+		return match[1].split(";").map(Number);
+	}
+	/** `[0, 1, 2]` → `"{0;1;2}"`. */
+	static formatPathString(path) {
+		return `{${path.join(";")}}`;
+	}
+	/** Booleans and numbers stay primitives: Grasshopper reads them typed. */
+	static serializeValue(value) {
+		return typeof value === "object" ? JSON.stringify(value) : value;
+	}
+	static deserializeValue(data) {
+		if (typeof data !== "string") return data;
+		if (data.startsWith("{") || data.startsWith("[")) try {
+			return JSON.parse(data);
+		} catch {
+			return data;
+		}
+		const num = Number(data);
+		if (Number.isFinite(num) && String(num) === data) return num;
+		if (data === "true") return true;
+		if (data === "false") return false;
+		return data;
+	}
+	static hasValidValue(value) {
+		if (value === void 0 || value === null) return false;
+		if (typeof value === "string") return true;
+		if (Array.isArray(value) && value.length === 0) return false;
+		if (typeof value === "object" && !Array.isArray(value) && Object.keys(value).length === 0) return false;
+		return true;
+	}
+	static clampValue(value, min, max, inputName) {
+		let result = value;
+		if (min !== null && min !== void 0 && result < min) {
+			getLogger().warn(`${inputName}: ${value} below min ${min}, clamping`);
+			result = min;
+		}
+		if (max !== null && max !== void 0 && result > max) {
+			getLogger().warn(`${inputName}: ${value} above max ${max}, clamping`);
+			result = max;
+		}
+		return result;
+	}
+};
+
+export { ComputeError as C, ErrorCodes as E, GrasshopperClient as G, TreeBuilder as T, ComputeServerStats as a, GrasshopperResponseProcessor as b, classifyProbeFailure as c, subFolderSegments as d, enableDebugLogging as e, downloadFileDataByRoot as f, decodeBase64ToBinary as g, isDefinitionRef as i, normalizeUISchemaCasing as n, readSchemaResults as r, stableStringify as s };
+//# sourceMappingURL=grasshopper.js-BTMLax71.js.map