@selvajs/solve 2.0.0-beta.11 → 2.0.0-beta.13

package/dist/server.js

@@ -1,249 +1,64 @@
+import { t as raceAbort } from "./abort-CNJ8Sn4g.js";
+import { getInputItems } from "@selvajs/schemas";
 import { GrasshopperClient, TreeBuilder, stableStringify } from "@selvajs/compute/grasshopper";
-import { ComputeError, ErrorCodes, enableDebugLogging, isDefinitionRef, isDefinitionRef as isDefinitionRef$1 } from "@selvajs/compute/core";
-import { gunzipSync, gzip } from "node:zlib";
-import { promisify } from "node:util";
+import { ComputeError, ErrorCodes, enableDebugLogging, isDefinitionRef } from "@selvajs/compute/core";
 import { Agent, fetch } from "undici";
-import { NoopLogger } from "@selvajs/platform";
-// src/server/transform-input.ts
-/** The input tree a solve sends: each input's value, or its schema default when it has none. */
-function buildSolveInputTree(inputs, values) {
-	return TreeBuilder.fromValues(inputs.filter((input) => input.paramType).map((input) => ({
-		paramName: input.nickname,
-		paramType: input.paramType,
-		value: values[input.id] ?? input.default,
-		minimum: input.minimum,
-		maximum: input.maximum
-	})));
-}
-// src/server/solve-pipeline.ts
+import { gzip } from "node:zlib";
+import { promisify } from "node:util";
+// src/server/concurrency-probe.ts
 /**
-* Transport-agnostic solve pipeline: given an already-resolved solve context
-* (`.gh` bytes, input params + user values, a warm `SolveScheduler`), runs the
-* solve and returns a discriminated {@link SolveOutcome} instead of throwing
-* for expected failures. Auth, the database, share tokens, rate limits, and
-* metric sinks are the calling route's job, not this file's.
+* Fallback concurrency while the first probe is still in flight, and the value
+* kept whenever a probe fails or reports 0 — never send more than a single
+* solve to a server whose real capacity is unknown.
 */
-const gzipAsync = promisify(gzip);
+const FALLBACK_CONCURRENCY = 1;
 /**
-* Display output is base64 of already-deflated bytes, where higher levels find nothing more:
-* level 1 lands within 1% of the default's size, in up to a fifth of the time.
+* How stale the compute server's child count may get before a solve triggers a
+* re-read. Short enough that a resized pool is picked up within a few solves,
+* long enough that a busy server is probed rarely — the probe rides on solve
+* completion, so an idle server is never polled at all.
 */
-const GZIP_LEVEL = 1;
+const CONCURRENCY_PROBE_INTERVAL_MS = 3e5;
 /**
-* A scheduler cache hit returns the same response object, so a repeat solve reuses its bytes rather
-* than paying to serialize and compress them again. Entries live exactly as long as the response.
-* Only the gzip form is kept: browsers always take it, and the JSON string would double the memory.
+* rhino.compute hands out children in strict rotation and never reports "busy", so nothing
+* downstream enforces a concurrency cap — send more than it has children and requests silently
+* double up on one. Rhino.Compute is the only source of truth for its own child count, so this
+* always probes rather than trusting an operator-supplied guess.
+*
+* The count is not static: children exit on their own under `-idlespan`, and `/launch-child` +
+* `/recycle-children` resize the pool at runtime. So the probe re-runs after solves rather than
+* only at connect.
 */
-const gzippedBodies = /* @__PURE__ */ new WeakMap();
-/** Compute-response contract version. Bump (and document the change) whenever the envelope's shape changes in a way a consumer could observe. */
-const COMPUTE_CONTRACT_VERSION = 1;
-const COMPUTE_VERSION_HEADER = "X-Selva-Compute-Version";
-async function runSolvePipeline(args) {
-	const { client, signal } = args;
-	const treeBuildStart = performance.now();
-	const inputTree = args.inputTree ?? buildSolveInputTree(args.inputs, args.values);
-	const treeBuildMs = performance.now() - treeBuildStart;
-	let rhino = null;
-	let result;
-	let settle;
-	const solveStart = performance.now();
-	try {
-		const detail = await client.scheduler.solveDetailed(args.definitionSource, inputTree, {
-			signal,
-			selvaevents: args.selvaEvents,
-			onServerTiming: (t) => {
-				rhino = t;
-			}
-		});
-		result = detail.response;
-		settle = {
-			fromCache: detail.fromCache,
-			definitionReuploaded: detail.definitionReuploaded
-		};
-	} catch (err) {
-		const durationMs = performance.now() - solveStart;
-		const isAbort = err instanceof Error && err.name === "AbortError" || err instanceof ComputeError && err.code === ErrorCodes.ABORTED;
-		const isDeadline = err instanceof ComputeError && err.code === ErrorCodes.TIMEOUT_ERROR;
-		if (isAbort || isDeadline) {
-			if (isAbort && signal.aborted) return {
-				kind: "client_abort",
-				durationMs
-			};
-			return {
-				kind: "timeout",
-				durationMs,
-				message: `Solve exceeded the ${Math.round(args.solveDeadlineMs / 1e3)}s deadline.`
-			};
-		}
-		if (err instanceof ComputeError) {
-			if (err.code === ErrorCodes.RESPONSE_TOO_LARGE) return { kind: "too_large" };
-			if (err.code === ErrorCodes.QUEUE_FULL) return {
-				kind: "shed",
-				durationMs,
-				reason: "queue_full",
-				retryAfterSeconds: 1,
-				message: "Compute server is at capacity. Retry shortly."
-			};
-			if (err.code === ErrorCodes.QUEUE_TIMEOUT) return {
-				kind: "shed",
-				durationMs,
-				reason: "queue_timeout",
-				retryAfterSeconds: 1,
-				message: "Compute request waited too long in the queue. Retry shortly."
-			};
-		}
-		return {
-			kind: "compute_error",
-			durationMs,
-			error: err
-		};
-	}
-	const solveMs = performance.now() - solveStart;
-	const clientWantsGzip = /\bgzip\b/i.test(args.acceptEncoding);
-	const remembered = clientWantsGzip ? gzippedBodies.get(result) : void 0;
-	let compressed = remembered?.body ?? null;
-	let serializedBytes = remembered?.serializedBytes ?? 0;
-	let serialized = "";
-	let serializeMs = 0;
-	let gzipMs = 0;
-	if (!remembered) {
-		const serializeStart = performance.now();
+function createConcurrencyProbe(client, debugLog) {
+	let maxConcurrent = FALLBACK_CONCURRENCY;
+	let lastProbeAt = 0;
+	let probing = false;
+	/** `initialize: false` keeps this from spawning children on an idle server, so a cold one reports 0. */
+	async function refresh(scheduler) {
+		if (probing) return;
+		probing = true;
 		try {
-			serialized = JSON.stringify(result);
-		} catch (err) {
-			if (err instanceof RangeError) return { kind: "too_large" };
-			throw err;
-		}
-		if (serialized.length > args.responseMaxBytes) return { kind: "too_large" };
-		serializeMs = performance.now() - serializeStart;
-		serializedBytes = serialized.length;
-		if (clientWantsGzip && serialized.length > 1024) {
-			const gzipStart = performance.now();
-			compressed = new Uint8Array(await gzipAsync(Buffer.from(serialized), { level: GZIP_LEVEL }));
-			gzipMs = performance.now() - gzipStart;
-			gzippedBodies.set(result, {
-				body: compressed,
-				serializedBytes
-			});
+			const children = await Promise.resolve(client.serverStats?.getActiveChildren({ initialize: false })).catch(() => null);
+			lastProbeAt = Date.now();
+			const next = !children || children <= 0 ? FALLBACK_CONCURRENCY : children;
+			if (next === maxConcurrent) return;
+			debugLog(`[Compute/client-cache] concurrency ${maxConcurrent} → ${next} (server child count)`);
+			maxConcurrent = next;
+			scheduler?.setMaxConcurrent(next);
+		} finally {
+			probing = false;
 		}
 	}
-	const serverTotalMs = performance.now() - args.loadStartMs;
-	const headers = {
-		"Content-Type": "application/json",
-		"Server-Timing": buildServerTiming({
-			defLoadMs: args.defLoadMs,
-			treeBuildMs,
-			solveMs,
-			serializeMs,
-			gzipMs,
-			serverTotalMs,
-			rhino,
-			settle,
-			byteRefOutcome: args.byteRefOutcome,
-			prepMarks: args.prepMarks ?? []
-		}),
-		[COMPUTE_VERSION_HEADER]: String(1),
-		Vary: "Accept-Encoding"
-	};
-	const metrics = {
-		treeBuildMs,
-		solveMs,
-		serializeMs,
-		gzipMs,
-		serverTotalMs,
-		serializedBytes,
-		compressedBytes: compressed?.byteLength ?? null
-	};
-	let envelope;
-	if (compressed) {
-		headers["Content-Encoding"] = "gzip";
-		headers["Content-Length"] = String(compressed.byteLength);
-		envelope = {
-			body: compressed,
-			encoding: "gzip",
-			headers,
-			result,
-			metrics
-		};
-	} else {
-		headers["Content-Length"] = String(Buffer.byteLength(serialized));
-		envelope = {
-			body: serialized,
-			headers,
-			result,
-			metrics
-		};
-	}
-	return {
-		kind: "ok",
-		envelope,
-		solveMs,
-		errorCount: result.errors?.length ?? 0,
-		warningCount: result.warnings?.length ?? 0
-	};
-}
-/**
-* Re-key a coalesced envelope to a single waiter's `Accept-Encoding`.
-*
-* The single-flight coalescer runs ONE pipeline execution for N identical
-* concurrent solves and hands every waiter the same {@link SolveEnvelope},
-* baked from the FIRST caller's `Accept-Encoding`. A later waiter with a
-* different `Accept-Encoding` would otherwise get a body labelled with the
-* wrong encoding — `Vary` can't help here, since it's one shared object, not a
-* cache lookup. Encoding is deliberately left out of the coalesce key so mixed
-* clients still coalesce; this adapts the shared result to each waiter instead.
-*
-* Only the correctness-critical direction is adapted: a gzip envelope served to
-* a non-gzip waiter is gunzipped back to JSON. The reverse (plain JSON to a
-* gzip-capable waiter) is left uncompressed — correct, just not maximally small.
-*/
-function adaptEnvelopeToEncoding(envelope, acceptEncoding) {
-	const waiterWantsGzip = /\bgzip\b/i.test(acceptEncoding);
-	if (envelope.encoding === "gzip" && !waiterWantsGzip) {
-		const json = gunzipSync(envelope.body instanceof Uint8Array ? envelope.body : Buffer.from(envelope.body)).toString("utf8");
-		const headers = { ...envelope.headers };
-		delete headers["Content-Encoding"];
-		headers["Content-Length"] = String(Buffer.byteLength(json));
-		return {
-			body: json,
-			headers
-		};
-	}
 	return {
-		body: envelope.body,
-		headers: envelope.headers
+		get maxConcurrent() {
+			return maxConcurrent;
+		},
+		refresh: () => refresh(),
+		refreshIfDue(scheduler) {
+			if (Date.now() - lastProbeAt >= CONCURRENCY_PROBE_INTERVAL_MS) refresh(scheduler);
+		}
 	};
 }
-/**
-* `total` is the server's headers-to-out wall time, so browser `ttfb − total`
-* ≈ network+send latency. When the compute server reports its own timing
-* (VektorNode fork), `rhino_*` is time on the compute server and `compute_link`
-* is everything between it (network + queue wait). `rhino_cache` is 1 when the
-* compute server answered from its own result cache.
-*/
-function buildServerTiming(parts) {
-	let header = `load;dur=${parts.defLoadMs.toFixed(1)}, tree;dur=${parts.treeBuildMs.toFixed(1)}, solve;dur=${parts.solveMs.toFixed(1)}, serialize;dur=${parts.serializeMs.toFixed(1)}, gzip;dur=${parts.gzipMs.toFixed(1)}, total;dur=${parts.serverTotalMs.toFixed(1)}`;
-	const rhino = parts.rhino;
-	if (rhino) {
-		const decode = rhino.decode ?? 0;
-		const solve = rhino.solve ?? 0;
-		const encode = rhino.encode ?? 0;
-		const computeLinkMs = Math.max(0, parts.solveMs - decode - solve - encode);
-		header += `, rhino_decode;dur=${decode.toFixed(1)}, rhino_solve;dur=${solve.toFixed(1)}, rhino_encode;dur=${encode.toFixed(1)}, compute_link;dur=${computeLinkMs.toFixed(1)}, rhino_cache;dur=${rhino.cacheHit ? 1 : 0}`;
-		if (rhino.gh !== void 0) header += `, rhino_gh;dur=${rhino.gh.toFixed(1)}`;
-		if (rhino.recomputed) header += `, rhino_recomputed;desc="${rhino.recomputed.ran}/${rhino.recomputed.total}"`;
-	}
-	for (const [label, ms] of parts.prepMarks) header += `, p_${label};dur=${ms.toFixed(1)}`;
-	const settle = parts.settle;
-	header += `, selva_cache;dur=${settle.fromCache ? 1 : 0}`;
-	if (settle.definitionReuploaded !== void 0) header += `, def_reupload;dur=${settle.definitionReuploaded ? 1 : 0}`;
-	const byteRef = parts.byteRefOutcome;
-	if (byteRef) {
-		const verdict = !byteRef.loaded ? "skipped" : byteRef.fromCache ? "hit" : "miss";
-		header += `, def_bytes;desc=${verdict}`;
-	}
-	return header;
-}
 // src/server/long-fetch.ts
 /** undici's default `headersTimeout` and `bodyTimeout`, which `timeoutMs` can't extend. */
 const UNDICI_DEFAULT_LIMIT_MS = 3e5;
@@ -254,30 +69,45 @@ const unlimited = new Agent({
 });
 const unlimitedFetch = ((input, init) => fetch(input, {
 	...init,
+	signal: init?.signal ?? AbortSignal.timeout(UNDICI_DEFAULT_LIMIT_MS),
 	dispatcher: unlimited
 }));
 /** The fetch for a solve deadline: `undefined` means the global one reaches it. */
 function fetchForDeadline(deadlineMs) {
 	return deadlineMs >= UNDICI_DEFAULT_LIMIT_MS ? unlimitedFetch : void 0;
 }
-// src/server/client-cache.ts
-function serverIdentity(server) {
-	return server.id;
-}
-const DEFAULT_MAX_WARM_COMPUTE_SERVERS = 16;
+// src/server/server-limits.ts
+/** Rhino.Compute's own default `--timeout`, for a server that can't report its own. */
+const DEFAULT_SOLVE_DEADLINE_MS = 1e5;
 /**
-* Fallback concurrency while the first probe is still in flight, and the value
-* kept whenever a probe fails or reports 0 — never send more than a single
-* solve to a server whose real capacity is unknown.
+* Ceiling on any solve deadline, whatever the server reports. Bounds how long a request, its
+* live-event token and a delegated session stay open; past an hour a solve belongs in a job.
 */
-const FALLBACK_CONCURRENCY = 1;
+const MAX_SOLVE_DEADLINE_MS = 36e5;
+/** Selva waits this much past the server's timeout, so Compute's own error arrives first. */
+const DEADLINE_SLACK_MS = 5e3;
+function solveLimitsFor(reported) {
+	if (!reported) return {
+		solveDeadlineMs: DEFAULT_SOLVE_DEADLINE_MS,
+		maxRequestBytes: null,
+		reuseDefinitionCache: false
+	};
+	return {
+		solveDeadlineMs: Math.min(reported.timeoutSeconds * 1e3 + DEADLINE_SLACK_MS, MAX_SOLVE_DEADLINE_MS),
+		maxRequestBytes: reported.maxRequestBytes,
+		reuseDefinitionCache: reported.signalsStaleDefinition
+	};
+}
+function sameSolveLimits(a, b) {
+	return a.solveDeadlineMs === b.solveDeadlineMs && a.maxRequestBytes === b.maxRequestBytes && a.reuseDefinitionCache === b.reuseDefinitionCache;
+}
+// src/server/client-cache.ts
+const DEFAULT_MAX_WARM_COMPUTE_SERVERS = 16;
 /**
-* How stale the compute server's child count may get before a solve triggers a
-* re-read. Short enough that a resized pool is picked up within a few solves,
-* long enough that a busy server is probed rarely — the probe rides on solve
-* completion, so an idle server is never polled at all.
+* How often a warm client re-reads its server's limits, riding on solve completion like the
+* concurrency probe. An operator who changes `--timeout` sees it within this window.
 */
-const CONCURRENCY_PROBE_INTERVAL_MS = 3e5;
+const LIMITS_RECHECK_MS = 3e5;
 /**
 * How long a failed build is remembered before the next `getClient` retries the
 * handshake. Without this, every solve against a down server pays the full probe
@@ -288,18 +118,40 @@ const CONCURRENCY_PROBE_INTERVAL_MS = 3e5;
 * out a long penalty window before the app notices.
 */
 const FAILED_BUILD_TTL_MS = 5e3;
+function describeSettledSolve(result) {
+	const lines = [`[Compute/selva-cache] ${result.fromCache ? "HIT  — served from cache (no compute call)" : "miss — went to Rhino.Compute"} (${Math.round(result.durationMs)}ms)`];
+	if (result.fromCache) return lines;
+	lines.push(result.definitionReuploaded === true ? "[Compute/def-cache] miss — definition RE-UPLOADED (pointer was cold/stale)" : result.definitionReuploaded === false ? "[Compute/def-cache] HIT  — definition reused from server cache (no upload)" : "[Compute/def-cache] n/a — reuse disabled or non-reusable definition");
+	const errors = result.response?.errors;
+	if (Array.isArray(errors) && errors.length > 0) lines.push(`[Compute/rhino-cache] ${errors.length} GH error(s); not cached by Rhino.Compute.`);
+	return lines;
+}
 function createClientCache(config) {
 	const maxWarmComputeServers = config.maxWarmComputeServers ?? DEFAULT_MAX_WARM_COMPUTE_SERVERS;
 	const cache = /* @__PURE__ */ new Map();
 	const pending = /* @__PURE__ */ new Map();
 	const failed = /* @__PURE__ */ new Map();
+	const draining = /* @__PURE__ */ new Set();
 	if (config.debug === "verbose") enableDebugLogging();
 	const debugLog = (message) => {
 		if (config.debug) config.onDebugLog?.(message);
 	};
+	function isIdle({ scheduler }) {
+		return scheduler.inFlightCount === 0 && scheduler.queueDepth === 0;
+	}
+	/** Disposing a busy scheduler aborts its solves, so a config write would fail them all. */
+	function retire(entry) {
+		if (isIdle(entry)) entry.scheduler.dispose();
+		else draining.add(entry);
+	}
+	function finishDraining(entry) {
+		if (!draining.has(entry) || !isIdle(entry)) return;
+		draining.delete(entry);
+		entry.scheduler.dispose();
+	}
 	async function build(server, definitionGuid) {
 		const debugVerbose = config.debug === "verbose";
-		const longFetch = fetchForDeadline(config.solveDeadlineMs);
+		const longFetch = fetchForDeadline(MAX_SOLVE_DEADLINE_MS);
 		const clientConfig = {
 			serverUrl: server.serverUrl,
 			apiKey: server.apiKey,
@@ -323,60 +175,54 @@ function createClientCache(config) {
 		};
 		if (definitionGuid) clientConfig.headers = { "X-Selva-Definition": definitionGuid };
 		const client = await GrasshopperClient.create(clientConfig);
-		let maxConcurrent = FALLBACK_CONCURRENCY;
-		let lastProbeAt = 0;
-		let probing = false;
-		/**
-		* Best-effort re-read of the server's child count. Never awaited by a caller:
-		* a probe must not add a round-trip to the solve path, so a changed count takes
-		* effect on the NEXT solve rather than the one that triggered the probe.
-		*
-		* `initialize: false` keeps this from spawning children on an idle server —
-		* which also means a cold server honestly reports 0. Both a failed probe and a
-		* 0 result fall back to `FALLBACK_CONCURRENCY` (1): an unknown-capacity server
-		* is safer under-used than oversent.
-		*/
-		async function refreshConcurrency(scheduler) {
-			if (probing) return;
-			probing = true;
-			try {
-				const children = await Promise.resolve(client.serverStats?.getActiveChildren({ initialize: false })).catch(() => null);
-				lastProbeAt = Date.now();
-				const next = !children || children <= 0 ? FALLBACK_CONCURRENCY : children;
-				if (next === maxConcurrent) return;
-				debugLog(`[Compute/client-cache] concurrency ${maxConcurrent} → ${next} (server child count)`);
-				maxConcurrent = next;
-				scheduler?.setMaxConcurrent(next);
-			} finally {
-				probing = false;
-			}
-		}
-		await refreshConcurrency();
+		const probe = createConcurrencyProbe(client, debugLog);
+		const readLimits = async () => solveLimitsFor(await Promise.resolve(client.serverStats?.getLimits?.()).catch(() => null) ?? null);
+		const [limits] = await Promise.all([readLimits(), probe.refresh()]);
+		debugLog(`[Compute/client-cache] server ${server.id}: deadline ${limits.solveDeadlineMs}ms, request cap ${limits.maxRequestBytes ?? "not reported"}, pointer reuse ${limits.reuseDefinitionCache}`);
+		let limitsCheckedAt = Date.now();
+		let checkingLimits = false;
+		const recheckLimitsIfDue = () => {
+			if (checkingLimits || Date.now() - limitsCheckedAt < LIMITS_RECHECK_MS) return;
+			checkingLimits = true;
+			readLimits().then((next) => {
+				limitsCheckedAt = Date.now();
+				if (sameSolveLimits(next, limits)) return;
+				debugLog(`[Compute/client-cache] server ${server.id} limits changed — rebuilding`);
+				if (cache.get(server.id) === entry) evictEntry(server.id);
+			}).finally(() => {
+				checkingLimits = false;
+			});
+		};
 		const scheduler = client.createScheduler({
 			mode: "queue",
-			maxConcurrent,
+			maxConcurrent: probe.maxConcurrent,
 			maxQueueDepth: config.maxQueueDepth || void 0,
 			queueWaitMs: config.queueWaitMs || void 0,
-			timeoutMs: config.solveDeadlineMs,
+			timeoutMs: limits.solveDeadlineMs,
 			cache: config.responseCacheMaxBytes > 0 ? { maxBytes: config.responseCacheMaxBytes } : false,
-			reuseServerDefinitionCache: config.reuseServerDefinitionCache,
+			reuseServerDefinitionCache: limits.reuseDefinitionCache,
 			onSettle: (_ctx, result) => {
+				queueMicrotask(() => finishDraining(entry));
 				if (result.status !== "success") return;
-				if (result.fromCache !== true && Date.now() - lastProbeAt >= CONCURRENCY_PROBE_INTERVAL_MS) refreshConcurrency(scheduler);
-				if (!config.debug) return;
-				debugLog(`[Compute/selva-cache] ${result.fromCache ? "HIT  — served from cache (no compute call)" : "miss — went to Rhino.Compute"} (${Math.round(result.durationMs)}ms)`);
-				if (!result.fromCache) debugLog(result.definitionReuploaded === true ? "[Compute/def-cache] miss — definition RE-UPLOADED (pointer was cold/stale)" : result.definitionReuploaded === false ? "[Compute/def-cache] HIT  — definition reused from server cache (no upload)" : "[Compute/def-cache] n/a — reuse disabled or non-reusable definition");
-				if (!result.fromCache) {
-					const errs = result.response?.errors;
-					const errCount = Array.isArray(errs) ? errs.length : 0;
-					if (errCount > 0) debugLog(`[Compute/rhino-cache] ${errCount} GH error(s); not cached by Rhino.Compute. First: ${JSON.stringify(errs[0])}`);
+				if (result.fromCache !== true) {
+					probe.refreshIfDue(scheduler);
+					recheckLimitsIfDue();
 				}
+				if (config.debug) describeSettledSolve(result).forEach(debugLog);
 			}
 		});
-		return {
+		const entry = {
 			client,
-			scheduler
+			scheduler,
+			limits
 		};
+		return entry;
+	}
+	function evictEntry(id) {
+		const entry = cache.get(id);
+		if (!entry) return;
+		cache.delete(id);
+		retire(entry);
 	}
 	return {
 		async getClient(server, opts) {
@@ -388,7 +234,7 @@ function createClientCache(config) {
 				return existing;
 			}
 			const inFlight = pending.get(key);
-			if (inFlight) return inFlight;
+			if (inFlight) return inFlight.promise;
 			const recentFailure = failed.get(key);
 			if (recentFailure) {
 				if (Date.now() - recentFailure.at < FAILED_BUILD_TTL_MS) {
@@ -398,39 +244,52 @@ function createClientCache(config) {
 				failed.delete(key);
 			}
 			debugLog(`[Compute/client-cache] miss — building warm client for server ${key}`);
-			const buildPromise = (async () => {
+			const token = { stale: false };
+			const promise = (async () => {
 				let entry;
 				try {
 					entry = await build(server, opts?.definitionGuid);
 				} catch (err) {
-					failed.set(key, {
+					if (!token.stale) failed.set(key, {
 						error: err,
 						at: Date.now()
 					});
 					throw err;
 				}
+				if (token.stale) {
+					entry.scheduler.dispose();
+					throw new ComputeError(`Compute server ${key} changed while connecting.`, ErrorCodes.ABORTED);
+				}
 				if (cache.size >= maxWarmComputeServers) {
 					const oldestKey = cache.keys().next().value;
 					if (oldestKey !== void 0) {
 						debugLog(`[Compute/client-cache] LRU evicted warm client for server ${oldestKey} (cap ${maxWarmComputeServers})`);
-						cache.get(oldestKey)?.scheduler.dispose();
+						const oldest = cache.get(oldestKey);
 						cache.delete(oldestKey);
+						if (oldest) retire(oldest);
 					}
 				}
 				cache.set(key, entry);
 				return entry;
-			})().finally(() => pending.delete(key));
-			pending.set(key, buildPromise);
-			return buildPromise;
+			})().finally(() => {
+				if (pending.get(key)?.token === token) pending.delete(key);
+			});
+			pending.set(key, {
+				promise,
+				token
+			});
+			return promise;
 		},
 		evict(id) {
-			const key = id;
-			failed.delete(key);
-			const entry = cache.get(key);
-			if (entry) {
-				debugLog(`[Compute/client-cache] evicted warm client for server ${key} (config change)`);
-				entry.scheduler.dispose();
-				cache.delete(key);
+			failed.delete(id);
+			const build = pending.get(id);
+			if (build) {
+				build.token.stale = true;
+				pending.delete(id);
+			}
+			if (cache.has(id)) {
+				debugLog(`[Compute/client-cache] evicted warm client for server ${id} (config change)`);
+				evictEntry(id);
 			}
 		},
 		solveCacheStats() {
@@ -458,48 +317,99 @@ function createClientCache(config) {
 		},
 		disposeAll() {
 			debugLog(`[Compute/client-cache] disposing all ${cache.size} warm client(s)`);
-			for (const entry of cache.values()) entry.scheduler.dispose();
+			for (const entry of [...cache.values(), ...draining]) entry.scheduler.dispose();
+			for (const build of pending.values()) build.token.stale = true;
+			pending.clear();
 			cache.clear();
+			draining.clear();
 			failed.clear();
 		}
 	};
 }
 // src/server/definition-byte-cache.ts
 /**
+* In-process cache of `.gh` definition bytes, keyed by immutable **version id**.
+*
+* Turns an eager `storage.get(fileKey)` on every solve request into a lazy
+* `DefinitionRef.load()`: the scheduler calls `load()` only when an upload is
+* unavoidable (a pointer-known re-solve never touches storage or this cache).
+*
+* The key MUST be the version id, never a `fileKey` — a delete-latest-then-
+* reupload can reuse a `fileKey` for different content, which would silently
+* serve one version's bytes for another with no diagnostic. Callers pass
+* `version.id`, and the returned `DefinitionRef.key` is that same id, so the
+* scheduler's own result/pointer cache keys on the same immutable identity.
+*
+* Eviction is LRU by total byte budget, not entry count — definitions range
+* from tens of KB to hundreds of MB, so a count cap would either pin
+* gigabytes or evict uselessly. `COMPUTE_DEFINITION_CACHE_MB` sets the
+* budget (see `createDefinitionByteCache`). No TTL: version ids are
+* immutable, so a cached entry can never go stale. An entry larger than the
+* whole budget is served but never retained.
+*/
+/** A `ByteCacheRef` carries `outcome`, which a plain `DefinitionRef` never has. */
+function isByteCacheRef(source) {
+	return typeof source === "object" && source !== null && "outcome" in source;
+}
+/**
 * @param maxBytes total retained-byte budget; `0` (or negative) disables caching
 *   entirely — every `load()` calls the loader and nothing is retained.
 */
 function createDefinitionByteCache(maxBytes) {
 	const budget = Math.max(0, Math.floor(maxBytes));
 	const cache = /* @__PURE__ */ new Map();
+	const loading = /* @__PURE__ */ new Map();
 	let retainedBytes = 0;
 	const stats = {
 		hits: 0,
 		misses: 0,
 		evictions: 0
 	};
-	function touch(key, entry) {
-		cache.delete(key);
-		cache.set(key, entry);
-	}
 	function evictToFit() {
-		while (retainedBytes > budget && cache.size > 0) {
-			const oldestKey = cache.keys().next().value;
-			const oldest = cache.get(oldestKey);
-			cache.delete(oldestKey);
-			retainedBytes -= oldest.bytes.byteLength;
+		for (const [key, bytes] of cache) {
+			if (retainedBytes <= budget) break;
+			cache.delete(key);
+			retainedBytes -= bytes.byteLength;
 			stats.evictions += 1;
 		}
 	}
 	function store(key, bytes) {
 		if (budget === 0) return;
 		if (bytes.byteLength > budget) return;
-		const existing = cache.get(key);
-		if (existing) retainedBytes -= existing.bytes.byteLength;
-		cache.set(key, { bytes });
+		cache.set(key, bytes);
 		retainedBytes += bytes.byteLength;
 		evictToFit();
 	}
+	function startLoad(key, load) {
+		const controller = new AbortController();
+		const entry = {
+			controller,
+			waiters: 0,
+			promise: (async () => {
+				const bytes = await load(controller.signal);
+				store(key, bytes);
+				return bytes;
+			})().finally(() => {
+				if (loading.get(key) === entry) loading.delete(key);
+			})
+		};
+		loading.set(key, entry);
+		return entry;
+	}
+	/**
+	* A caller gone stops waiting, but the read runs on for whoever else is on it. A caller with no
+	* signal can't leave, so it stays counted and the read is never aborted under it.
+	*/
+	async function wait(entry, signal) {
+		entry.waiters += 1;
+		if (!signal) return entry.promise;
+		try {
+			return await raceAbort(entry.promise, signal);
+		} finally {
+			entry.waiters -= 1;
+			if (entry.waiters === 0 && signal.aborted) entry.controller.abort();
+		}
+	}
 	return {
 		getOrLoad(versionId, load) {
 			const outcome = {
@@ -509,21 +419,29 @@ function createDefinitionByteCache(maxBytes) {
 			return {
 				key: versionId,
 				outcome,
-				load: async () => {
+				load: async function read(signal) {
+					outcome.loaded = true;
 					const hit = cache.get(versionId);
 					if (hit) {
-						touch(versionId, hit);
+						cache.delete(versionId);
+						cache.set(versionId, hit);
 						stats.hits += 1;
-						outcome.loaded = true;
 						outcome.fromCache = true;
-						return hit.bytes;
+						return hit;
+					}
+					const running = loading.get(versionId);
+					if (running?.controller.signal.aborted) {
+						const woundDown = running.promise.then(() => void 0, () => void 0);
+						await (signal ? raceAbort(woundDown, signal) : woundDown);
+						return read(signal);
+					}
+					if (running) {
+						stats.hits += 1;
+						outcome.fromCache = true;
+						return wait(running, signal);
 					}
 					stats.misses += 1;
-					outcome.loaded = true;
-					outcome.fromCache = false;
-					const bytes = await load();
-					store(versionId, bytes);
-					return bytes;
+					return wait(startLoad(versionId, load), signal);
 				}
 			};
 		},
@@ -542,73 +460,345 @@ function createDefinitionByteCache(maxBytes) {
 		}
 	};
 }
+// src/server/response-encoding.ts
+/**
+* Turns one solve's response into each caller's wire form. Runs after single-flight, not inside
+* it: coalesced callers can want different encodings, and each reports its own timing.
+*/
+const gzipAsync = promisify(gzip);
+/**
+* Display output is base64 of already-deflated bytes, where higher levels find nothing more:
+* level 1 lands within 1% of the default's size, in up to a fifth of the time.
+*/
+const GZIP_LEVEL = 1;
+/** Below this gzip isn't worth the CPU for the wire savings. */
+const GZIP_MIN_BYTES = 1024;
+/** Compute-response contract version. Bump (and document the change) whenever the envelope's shape changes in a way a consumer could observe. */
+const COMPUTE_CONTRACT_VERSION = 1;
+const COMPUTE_VERSION_HEADER = "X-Selva-Compute-Version";
+function buildEnvelope(encoded, result, serverTiming, metrics) {
+	const headers = {
+		"Content-Type": "application/json",
+		"Server-Timing": serverTiming,
+		[COMPUTE_VERSION_HEADER]: String(1),
+		Vary: "Accept-Encoding"
+	};
+	const { body, encoding } = encoded;
+	if (encoding === "gzip") headers["Content-Encoding"] = "gzip";
+	headers["Content-Length"] = String(typeof body === "string" ? Buffer.byteLength(body) : body.byteLength);
+	return {
+		body,
+		...encoding ? { encoding } : {},
+		headers,
+		result,
+		metrics
+	};
+}
+/** Whether an `Accept-Encoding` header takes gzip. `gzip;q=0` is a client refusing it. */
+function acceptsGzip(acceptEncoding) {
+	return acceptEncoding.split(",").some((part) => {
+		const [coding, ...params] = part.split(";").map((s) => s.trim().toLowerCase());
+		if (coding !== "gzip") return false;
+		const q = params.find((p) => p.startsWith("q="));
+		return q === void 0 || Number(q.slice(2)) > 0;
+	});
+}
+/**
+* A scheduler cache hit returns the same response object, so a repeat solve reuses its bytes rather
+* than paying to serialize and compress them again. Entries live exactly as long as the response.
+* Only the gzip form is kept: browsers always take it, and the JSON string would double the memory.
+* Holds the promise, so callers arriving during the compression share it.
+*/
+const gzippedBodies = /* @__PURE__ */ new WeakMap();
+function gzipOnce(response, json, serializedBytes) {
+	const pending = gzipAsync(Buffer.from(json), { level: GZIP_LEVEL }).then((body) => ({
+		body,
+		serializedBytes
+	}));
+	gzippedBodies.set(response, pending);
+	pending.catch(() => gzippedBodies.delete(response));
+	return pending;
+}
+/**
+* One per solve. The JSON is kept here rather than beside the gzip body: it only has to outlive the
+* callers of this flight, who would otherwise each stringify the same response and hold a copy.
+*/
+function createResponseEncoder(response, maxBytes) {
+	let serialized;
+	function serialize() {
+		if (serialized !== void 0) return serialized;
+		try {
+			const json = JSON.stringify(response);
+			const bytes = Buffer.byteLength(json);
+			serialized = bytes > maxBytes ? "too_large" : {
+				json,
+				bytes
+			};
+		} catch (err) {
+			if (!(err instanceof RangeError)) throw err;
+			serialized = "too_large";
+		}
+		return serialized;
+	}
+	return { async encode(acceptEncoding) {
+		const wantsGzip = acceptsGzip(acceptEncoding);
+		let gzipped = wantsGzip ? gzippedBodies.get(response) : void 0;
+		let serializeMs = 0;
+		if (!gzipped) {
+			const serializeStart = performance.now();
+			const plain = serialize();
+			serializeMs = performance.now() - serializeStart;
+			if (plain === "too_large") {
+				if (wantsGzip) gzippedBodies.set(response, Promise.resolve("too_large"));
+				return "too_large";
+			}
+			if (!wantsGzip || plain.bytes <= GZIP_MIN_BYTES) return {
+				body: plain.json,
+				serializedBytes: plain.bytes,
+				serializeMs,
+				gzipMs: 0
+			};
+			gzipped = gzipOnce(response, plain.json, plain.bytes);
+		}
+		const gzipStart = performance.now();
+		const verdict = await gzipped;
+		if (verdict === "too_large") return verdict;
+		return {
+			body: verdict.body,
+			encoding: "gzip",
+			serializedBytes: verdict.serializedBytes,
+			serializeMs,
+			gzipMs: performance.now() - gzipStart
+		};
+	} };
+}
+// src/server/server-timing.ts
+/**
+* `total` is the server's headers-to-out wall time, so browser `ttfb − total`
+* ≈ network+send latency. When the compute server reports its own timing
+* (VektorNode fork), `rhino_*` is time on the compute server and `compute_link`
+* is everything between it (network + queue wait). `rhino_cache` is 1 when the
+* compute server answered from its own result cache.
+*/
+function buildServerTiming(parts) {
+	let header = `load;dur=${parts.defLoadMs.toFixed(1)}, tree;dur=${parts.treeBuildMs.toFixed(1)}, solve;dur=${parts.solveMs.toFixed(1)}, serialize;dur=${parts.serializeMs.toFixed(1)}, gzip;dur=${parts.gzipMs.toFixed(1)}, total;dur=${parts.serverTotalMs.toFixed(1)}`;
+	const rhino = parts.rhino;
+	if (rhino) {
+		const decode = rhino.decode ?? 0;
+		const solve = rhino.solve ?? 0;
+		const encode = rhino.encode ?? 0;
+		const computeLinkMs = Math.max(0, parts.solveMs - decode - solve - encode);
+		header += `, rhino_decode;dur=${decode.toFixed(1)}, rhino_solve;dur=${solve.toFixed(1)}, rhino_encode;dur=${encode.toFixed(1)}, compute_link;dur=${computeLinkMs.toFixed(1)}, rhino_cache;dur=${rhino.cacheHit ? 1 : 0}`;
+		if (rhino.gh !== void 0) header += `, rhino_gh;dur=${rhino.gh.toFixed(1)}`;
+		if (rhino.recomputed) header += `, rhino_recomputed;desc="${rhino.recomputed.ran}/${rhino.recomputed.total}"`;
+	}
+	for (const [label, ms] of parts.prepMarks) header += `, p_${label};dur=${ms.toFixed(1)}`;
+	const settle = parts.settle;
+	header += `, selva_cache;dur=${settle.fromCache ? 1 : 0}`;
+	if (settle.definitionReuploaded !== void 0) header += `, def_reupload;dur=${settle.definitionReuploaded ? 1 : 0}`;
+	if (parts.defBytes) header += `, def_bytes;desc=${parts.defBytes}`;
+	return header;
+}
 // src/server/solve-cache-single-flight.ts
 function createSolveCacheSingleFlight(options = {}) {
 	const inflight = /* @__PURE__ */ new Map();
+	function free(key, flight) {
+		if (inflight.get(key) === flight) inflight.delete(key);
+	}
+	function attend(key, flight, signal) {
+		flight.callers += 1;
+		const leave = () => {
+			flight.callers -= 1;
+			if (flight.callers > 0) return;
+			free(key, flight);
+			flight.controller.abort();
+		};
+		signal.addEventListener("abort", leave, { once: true });
+		return flight.promise.finally(() => signal.removeEventListener("abort", leave));
+	}
 	return {
-		run(key, work, onWaiterJoined) {
+		run(key, work, callerSignal) {
 			const existing = inflight.get(key);
 			if (existing) {
-				options.onJoin?.(key);
-				existing.notifyOwner?.();
-				return existing.promise;
+				try {
+					options.onJoin?.(key);
+				} catch (err) {
+					console.error("[Solve/single-flight] onJoin threw:", err);
+				}
+				return attend(key, existing, callerSignal);
 			}
+			const controller = new AbortController();
 			const flight = {
-				notifyOwner: onWaiterJoined,
-				promise: void 0
+				controller,
+				callers: 0,
+				promise: (async () => work(controller.signal))().finally(() => free(key, flight))
 			};
-			const p = (async () => work())().finally(() => {
-				flight.notifyOwner = void 0;
-				if (inflight.get(key) === flight) inflight.delete(key);
-			});
-			flight.promise = p;
 			inflight.set(key, flight);
-			return p;
+			return attend(key, flight, callerSignal);
 		},
 		inFlight() {
 			return inflight.size;
 		}
 	};
 }
+// src/server/transform-input.ts
+/**
+* What `SolveEngine.solve` takes as `inputs`, from a schema the host stored. The bounds live on
+* the number widgets in the layout, not on `schema.inputs`, so without them nothing clamps.
+*/
+function solveInputsFromSchema(schema) {
+	const bounds = /* @__PURE__ */ new Map();
+	for (const item of getInputItems(schema)) if (item.widgetType === "number" && item.config) bounds.set(item.paramId, item.config);
+	return schema.inputs.map((input) => {
+		const widget = bounds.get(input.id);
+		return widget ? {
+			...input,
+			minimum: widget.minimum,
+			maximum: widget.maximum
+		} : input;
+	});
+}
+/** The input tree a solve sends: each input's value, or its schema default when it has none. */
+function buildSolveInputTree(inputs, values) {
+	return TreeBuilder.fromValues(inputs.filter((input) => input.paramType).map((input) => ({
+		paramName: input.nickname,
+		paramType: input.paramType,
+		value: (Object.hasOwn(values, input.id) ? values[input.id] : void 0) ?? input.default,
+		minimum: input.minimum,
+		maximum: input.maximum
+	})));
+}
+// src/server/solve-pipeline.ts
+/**
+* Runs one solve against a warm scheduler and classifies how it ended: a solved response, or an
+* expected failure as a value instead of a throw. This is the part single-flight shares, so
+* nothing here depends on who is asking.
+*/
+function shed(durationMs, reason, message) {
+	return {
+		kind: "shed",
+		durationMs,
+		reason,
+		retryAfterSeconds: 1,
+		message
+	};
+}
+/** The solve lost its client, and no caller asked for that: a config write or a shutdown. */
+function interrupted(durationMs) {
+	return shed(durationMs, "interrupted", "The solve was interrupted. Retry shortly.");
+}
+function classifyFailure(err, durationMs, args) {
+	if (!(err instanceof ComputeError)) return {
+		kind: "compute_error",
+		durationMs,
+		error: err
+	};
+	if (err.statusCode === 413) {
+		const cap = args.client.limits.maxRequestBytes;
+		return {
+			kind: "request_too_large",
+			durationMs,
+			message: `The inputs are larger than the compute server accepts` + (cap ? ` (${Math.round(cap / 1048576)} MB)` : "") + ". Its admin can raise RHINO_COMPUTE_MAX_REQUEST_SIZE."
+		};
+	}
+	switch (err.code) {
+		case ErrorCodes.TIMEOUT_ERROR: return {
+			kind: "timeout",
+			durationMs,
+			message: `Solve exceeded the ${Math.round(args.client.limits.solveDeadlineMs / 1e3)}s deadline set by the compute server.`
+		};
+		case ErrorCodes.ABORTED: return args.signal.aborted ? {
+			kind: "client_abort",
+			durationMs
+		} : interrupted(durationMs);
+		case ErrorCodes.RESPONSE_TOO_LARGE: return { kind: "too_large" };
+		case ErrorCodes.QUEUE_FULL: return shed(durationMs, "queue_full", "Compute server is at capacity. Retry shortly.");
+		case ErrorCodes.QUEUE_TIMEOUT: return shed(durationMs, "queue_timeout", "Compute request waited too long in the queue. Retry shortly.");
+		default: return {
+			kind: "compute_error",
+			durationMs,
+			error: err
+		};
+	}
+}
+function defBytesVerdict(source) {
+	if (!isByteCacheRef(source)) return void 0;
+	const { loaded, fromCache } = source.outcome;
+	return !loaded ? "skipped" : fromCache ? "hit" : "miss";
+}
+async function runSolvePipeline(args) {
+	let rhino = null;
+	const solveStart = performance.now();
+	try {
+		const detail = await args.client.scheduler.solveDetailed(args.definitionSource, args.inputTree, {
+			signal: args.signal,
+			selvaevents: args.selvaEvents,
+			onServerTiming: (t) => {
+				rhino = t;
+			}
+		});
+		const defBytes = defBytesVerdict(args.definitionSource);
+		return {
+			kind: "solved",
+			response: detail.response,
+			encoder: createResponseEncoder(detail.response, args.responseMaxBytes),
+			solveMs: performance.now() - solveStart,
+			rhino,
+			settle: {
+				fromCache: detail.fromCache,
+				definitionReuploaded: detail.definitionReuploaded
+			},
+			...defBytes ? { defBytes } : {}
+		};
+	} catch (err) {
+		return classifyFailure(err, performance.now() - solveStart, args);
+	}
+}
 // src/server/solve-engine.ts
 /**
 * Facade over the warm-client cache, definition-byte cache, single-flight
 * coalescing, and the solve pipeline — the primitives an app route would
 * otherwise wire up by hand.
 *
-* Doesn't read env itself: `@selvajs/server` owns `resolveComputeLimits` and
-* depends on `@selvajs/solve`, so calling it from here would be a circular
-* import. Callers resolve their own limits and pass in the fields below.
+* Doesn't read env itself: `@selvajs/server` owns `resolveComputeLimits`, and
+* this package stays independent of it. Callers resolve their own limits and
+* pass in the fields below.
 *
 * Stays out of auth, DB reads, share tokens, rate limiting, metrics, and
 * compute-server selection — all app policy, supplied per-call via
 * `SolveEngineSolveArgs.server`.
 */
-function isByteCacheRef(source) {
-	return typeof source === "object" && source !== null && !(source instanceof Uint8Array) && "outcome" in source;
-}
-function isVersionLoadPair(source) {
-	return typeof source === "object" && source !== null && !(source instanceof Uint8Array) && !("outcome" in source) && !("key" in source) && "versionId" in source;
+/** A deadline of 0 means no deadline, and a `NaN` budget retains without limit, both silently. */
+function assertValidLimits(limits) {
+	const check = (name, min) => {
+		const value = limits[name];
+		if (!Number.isFinite(value) || value < min) throw new RangeError(`SolveEngine: limits.${name} must be a number >= ${min}, got ${value}.`);
+	};
+	check("computeResponseMaxBytes", 1);
+	check("computeMaxQueueDepth", 0);
+	check("computeQueueWaitMs", 0);
+	check("computeDefinitionCacheBytes", 0);
+	check("computeSolveCacheBytes", 0);
 }
 var SolveEngine = class {
 	limits;
 	clientCache;
 	byteCache;
 	singleFlight;
+	clientGenerations = /* @__PURE__ */ new WeakMap();
+	lastClientGeneration = 0;
 	constructor(options) {
+		assertValidLimits(options.limits);
 		this.limits = options.limits;
-		const logger = options.logger ?? new NoopLogger();
 		this.clientCache = createClientCache({
-			solveDeadlineMs: this.limits.solveDeadlineMs,
 			cachesolve: this.limits.computeServerCachesolve,
-			reuseServerDefinitionCache: this.limits.computeReuseDefinitionCache,
 			maxQueueDepth: this.limits.computeMaxQueueDepth,
 			queueWaitMs: this.limits.computeQueueWaitMs,
 			responseCacheMaxBytes: this.limits.computeSolveCacheBytes,
 			maxResponseBytes: this.limits.computeResponseMaxBytes,
 			debug: options.debug ?? false,
 			maxWarmComputeServers: options.maxWarmComputeServers,
-			onDebugLog: options.onDebugLog ?? ((message) => logger.debug(message, { component: "Compute/client-cache" }))
+			onDebugLog: options.onDebugLog
 		});
 		this.byteCache = createDefinitionByteCache(this.limits.computeDefinitionCacheBytes);
 		this.singleFlight = createSolveCacheSingleFlight({ onJoin: options.onSolveCoalesced });
@@ -619,6 +809,10 @@ var SolveEngine = class {
 	definitionRef(versionId, load) {
 		return this.byteCache.getOrLoad(versionId, load);
 	}
+	/**
+	* Drops the warm client for `id`; call it when the server's URL or key changes. Solves already
+	* running finish on the old connection details first, so a revoked key stays in use until then.
+	*/
 	evictServer(id) {
 		this.clientCache.evict(id);
 	}
@@ -640,71 +834,119 @@ var SolveEngine = class {
 		};
 	}
 	async solve(args) {
-		const { definitionSource: resolvedSource, byteRefOutcome, identity } = this.resolveDefinitionSource(args);
-		const client = await this.clientCache.getClient(args.server, { definitionGuid: args.definitionGuid });
-		const inputTree = buildSolveInputTree(args.inputs, args.values);
-		const coalesceKey = `${identity}:${args.server.id}:${stableStringify(inputTree)}`;
-		const abortController = new AbortController();
-		let hasWaiters = false;
-		const onCallerAbort = () => {
-			if (!hasWaiters) abortController.abort();
+		const { definitionSource, identity } = this.resolveDefinitionSource(args);
+		const startedAt = performance.now();
+		const elapsed = () => performance.now() - startedAt;
+		if (args.signal.aborted) return {
+			kind: "client_abort",
+			durationMs: 0
 		};
-		args.signal.addEventListener("abort", onCallerAbort, { once: true });
-		const acceptEncoding = args.acceptEncoding ?? "";
-		let outcome;
+		let client;
 		try {
-			outcome = await this.singleFlight.run(coalesceKey, () => runSolvePipeline({
-				definitionSource: resolvedSource,
-				byteRefOutcome,
-				inputs: args.inputs,
-				values: args.values,
-				inputTree,
-				client,
-				responseMaxBytes: this.limits.computeResponseMaxBytes,
-				solveDeadlineMs: this.limits.solveDeadlineMs,
-				acceptEncoding,
-				selvaEvents: args.selvaEvents,
-				signal: abortController.signal,
-				loadStartMs: args.loadStartMs ?? performance.now(),
-				defLoadMs: args.defLoadMs ?? 0,
-				prepMarks: args.prepMarks
-			}), () => {
-				hasWaiters = true;
-			});
-		} finally {
-			args.signal.removeEventListener("abort", onCallerAbort);
+			client = await this.clientCache.getClient(args.server, { definitionGuid: args.definitionGuid });
+		} catch (error) {
+			if (args.signal.aborted) return {
+				kind: "client_abort",
+				durationMs: elapsed()
+			};
+			if (error instanceof ComputeError && error.code === ErrorCodes.ABORTED) return interrupted(elapsed());
+			return {
+				kind: "compute_error",
+				durationMs: elapsed(),
+				error
+			};
 		}
-		if (outcome.kind !== "ok") return outcome;
-		const wire = adaptEnvelopeToEncoding(outcome.envelope, acceptEncoding);
-		return {
-			...outcome,
-			envelope: {
-				...outcome.envelope,
-				body: wire.body,
-				headers: wire.headers
-			}
+		if (args.signal.aborted) return {
+			kind: "client_abort",
+			durationMs: elapsed()
 		};
-	}
-	toResponse(outcome, opts) {
-		const fail = (status, body) => {
-			if (opts?.onError) opts.onError(status, body);
-			const headers = { "Content-Type": "application/json" };
-			if (body.retryAfter !== void 0) headers["Retry-After"] = String(body.retryAfter);
+		const treeBuildStart = performance.now();
+		let inputTree;
+		try {
+			inputTree = buildSolveInputTree(args.inputs, args.values);
+		} catch (error) {
+			return {
+				kind: "compute_error",
+				durationMs: elapsed(),
+				error
+			};
+		}
+		const treeBuildMs = performance.now() - treeBuildStart;
+		const flight = await this.singleFlight.run(`${identity}:${args.server.id}:${this.clientGeneration(client)}:${stableStringify(inputTree)}`, (signal) => runSolvePipeline({
+			definitionSource,
+			inputTree,
+			client,
+			responseMaxBytes: this.limits.computeResponseMaxBytes,
+			selvaEvents: args.selvaEvents,
+			signal
+		}), args.signal);
+		if (args.signal.aborted) return {
+			kind: "client_abort",
+			durationMs: elapsed()
+		};
+		if (flight.kind !== "solved") return flight;
+		let encoded;
+		try {
+			encoded = await flight.encoder.encode(args.acceptEncoding ?? "");
+		} catch (error) {
 			return {
-				status,
-				headers,
-				body: JSON.stringify(body)
+				kind: "compute_error",
+				durationMs: elapsed(),
+				error
 			};
+		}
+		if (encoded === "too_large") return { kind: "too_large" };
+		const { body, serializedBytes, serializeMs, gzipMs } = encoded;
+		const { solveMs, response } = flight;
+		const serverTotalMs = performance.now() - (args.loadStartMs ?? startedAt);
+		const timing = {
+			defLoadMs: args.defLoadMs ?? 0,
+			treeBuildMs,
+			solveMs,
+			serializeMs,
+			gzipMs,
+			serverTotalMs,
+			rhino: flight.rhino,
+			settle: flight.settle,
+			...flight.defBytes ? { defBytes: flight.defBytes } : {}
 		};
+		const serverTiming = buildServerTiming({
+			...timing,
+			prepMarks: args.prepMarks ?? []
+		});
+		return {
+			kind: "ok",
+			envelope: buildEnvelope(encoded, response, serverTiming, {
+				...timing,
+				serializedBytes,
+				compressedBytes: encoded.encoding === "gzip" ? body.byteLength : null
+			}),
+			solveMs,
+			errorCount: response.errors?.length ?? 0,
+			warningCount: response.warnings?.length ?? 0
+		};
+	}
+	/**
+	* The response for an outcome; the mapping from outcome to status lives here. Throws
+	* `compute_error`'s error: what it means for the caller is the host's to decide.
+	*/
+	toWebResponse(outcome) {
+		const fail = (status, body) => new Response(JSON.stringify(body), {
+			status,
+			headers: {
+				"Content-Type": "application/json",
+				...body.retryAfter !== void 0 ? { "Retry-After": String(body.retryAfter) } : {}
+			}
+		});
 		switch (outcome.kind) {
-			case "ok": return {
+			case "ok": return new Response(outcome.envelope.body, {
 				status: 200,
-				headers: outcome.envelope.headers,
-				body: outcome.envelope.body
-			};
+				headers: outcome.envelope.headers
+			});
 			case "timeout": return fail(504, { message: outcome.message });
 			case "client_abort": return fail(499, { message: "Client closed request" });
 			case "too_large": return fail(413, { message: "Solve result is too large to return. This usually means a file output exceeds the supported size." });
+			case "request_too_large": return fail(413, { message: outcome.message });
 			case "shed": return fail(503, {
 				message: outcome.message,
 				retryAfter: outcome.retryAfterSeconds
@@ -712,29 +954,21 @@ var SolveEngine = class {
 			case "compute_error": throw outcome.error;
 		}
 	}
-	toWebResponse(outcome) {
-		const r = this.toResponse(outcome);
-		return new Response(typeof r.body === "string" ? r.body : new Uint8Array(r.body), {
-			status: r.status,
-			headers: r.headers
-		});
+	/**
+	* Part of the coalesce key: after an eviction the id stays and the client changes, and a new
+	* caller joining a draining flight would get an answer from the old URL or key.
+	*/
+	clientGeneration(client) {
+		let generation = this.clientGenerations.get(client);
+		if (generation === void 0) {
+			generation = ++this.lastClientGeneration;
+			this.clientGenerations.set(client, generation);
+		}
+		return generation;
 	}
 	resolveDefinitionSource(args) {
 		const source = args.definitionSource;
-		if (isVersionLoadPair(source)) {
-			const ref = this.byteCache.getOrLoad(source.versionId, source.load);
-			return {
-				definitionSource: ref,
-				byteRefOutcome: ref.outcome,
-				identity: ref.key
-			};
-		}
-		if (isByteCacheRef(source)) return {
-			definitionSource: source,
-			byteRefOutcome: source.outcome,
-			identity: source.key
-		};
-		if (isDefinitionRef$1(source)) return {
+		if (isByteCacheRef(source) || isDefinitionRef(source)) return {
 			definitionSource: source,
 			identity: source.key
 		};
@@ -745,6 +979,6 @@ var SolveEngine = class {
 		};
 	}
 };
-export { COMPUTE_CONTRACT_VERSION, COMPUTE_VERSION_HEADER, SolveEngine, adaptEnvelopeToEncoding, buildSolveInputTree, createClientCache, createDefinitionByteCache, createSolveCacheSingleFlight, isDefinitionRef, runSolvePipeline, serverIdentity };
+export { COMPUTE_CONTRACT_VERSION, COMPUTE_VERSION_HEADER, DEFAULT_SOLVE_DEADLINE_MS, MAX_SOLVE_DEADLINE_MS, SolveEngine, acceptsGzip, solveInputsFromSchema };
 
 //# sourceMappingURL=server.js.map