@selvajs/solve 2.0.0-beta.9 → 2.0.0

package/dist/server.js

@@ -1,2 +1,985 @@
-import{GrasshopperClient as e,TreeBuilder as t,stableStringify as n}from"@selvajs/compute/grasshopper";import{ComputeError as r,ErrorCodes as i,enableDebugLogging as a,isDefinitionRef as o,isDefinitionRef as s}from"@selvajs/compute/core";import{gunzipSync as c,gzip as l}from"node:zlib";import{promisify as u}from"node:util";import{NoopLogger as d}from"@selvajs/platform";function f(e,n){return t.fromValues(e.filter(e=>e.paramType).map(e=>({paramName:e.nickname,paramType:e.paramType,value:n[e.id]??e.default,minimum:e.minimum,maximum:e.maximum})))}const p=u(l),m=1,h=`X-Selva-Compute-Version`;async function g(e){let{client:t,signal:n}=e,a=performance.now(),o=e.inputTree??f(e.inputs,e.values),s=performance.now()-a,c=null,l,u,d=performance.now();try{let r=await t.scheduler.solveDetailed(e.definitionSource,o,{signal:n,selvaevents:e.selvaEvents,onServerTiming:e=>{c=e}});l=r.response,u={fromCache:r.fromCache,definitionReuploaded:r.definitionReuploaded}}catch(t){let a=performance.now()-d,o=t instanceof Error&&t.name===`AbortError`||t instanceof r&&t.code===i.ABORTED,s=t instanceof r&&t.code===i.TIMEOUT_ERROR;if(o||s)return o&&n.aborted?{kind:`client_abort`,durationMs:a}:{kind:`timeout`,durationMs:a,message:`Solve exceeded the ${Math.round(e.solveDeadlineMs/1e3)}s deadline.`};if(t instanceof r){if(t.code===i.RESPONSE_TOO_LARGE)return{kind:`too_large`};if(t.code===i.QUEUE_FULL)return{kind:`shed`,durationMs:a,reason:`queue_full`,retryAfterSeconds:1,message:`Compute server is at capacity. Retry shortly.`};if(t.code===i.QUEUE_TIMEOUT)return{kind:`shed`,durationMs:a,reason:`queue_timeout`,retryAfterSeconds:1,message:`Compute request waited too long in the queue. Retry shortly.`}}return{kind:`compute_error`,durationMs:a,error:t}}let m=performance.now()-d,g=performance.now(),_;try{_=JSON.stringify(l)}catch(e){if(e instanceof RangeError)return{kind:`too_large`};throw e}if(_.length>e.responseMaxBytes)return{kind:`too_large`};let y=performance.now()-g,b=/\bgzip\b/i.test(e.acceptEncoding)&&_.length>1024,x=null,S=0;if(b){let e=performance.now();x=await p(Buffer.from(_)),S=performance.now()-e}let C=performance.now()-e.loadStartMs,w={"Content-Type":`application/json`,"Server-Timing":v({defLoadMs:e.defLoadMs,treeBuildMs:s,solveMs:m,serializeMs:y,gzipMs:S,serverTotalMs:C,rhino:c,settle:u,byteRefOutcome:e.byteRefOutcome,prepMarks:e.prepMarks??[]}),[h]:`1`,Vary:`Accept-Encoding`},T={treeBuildMs:s,solveMs:m,serializeMs:y,gzipMs:S,serverTotalMs:C,serializedBytes:_.length,compressedBytes:x?.byteLength??null},E;return x?(w[`Content-Encoding`]=`gzip`,w[`Content-Length`]=String(x.byteLength),E={body:new Uint8Array(x),encoding:`gzip`,headers:w,result:l,metrics:T}):(w[`Content-Length`]=String(Buffer.byteLength(_)),E={body:_,headers:w,result:l,metrics:T}),{kind:`ok`,envelope:E,solveMs:m,errorCount:l.errors?.length??0,warningCount:l.warnings?.length??0}}function _(e,t){let n=/\bgzip\b/i.test(t);if(e.encoding===`gzip`&&!n){let t=c(e.body instanceof Uint8Array?e.body:Buffer.from(e.body)).toString(`utf8`),n={...e.headers};return delete n[`Content-Encoding`],n[`Content-Length`]=String(Buffer.byteLength(t)),{body:t,headers:n}}return{body:e.body,headers:e.headers}}function v(e){let t=`load;dur=${e.defLoadMs.toFixed(1)}, tree;dur=${e.treeBuildMs.toFixed(1)}, solve;dur=${e.solveMs.toFixed(1)}, serialize;dur=${e.serializeMs.toFixed(1)}, gzip;dur=${e.gzipMs.toFixed(1)}, total;dur=${e.serverTotalMs.toFixed(1)}`,n=e.rhino;if(n){let r=n.decode??0,i=n.solve??0,a=n.encode??0,o=Math.max(0,e.solveMs-r-i-a);t+=`, rhino_decode;dur=${r.toFixed(1)}, rhino_solve;dur=${i.toFixed(1)}, rhino_encode;dur=${a.toFixed(1)}, compute_link;dur=${o.toFixed(1)}, rhino_cache;dur=${+!!n.cacheHit}`,n.gh!==void 0&&(t+=`, rhino_gh;dur=${n.gh.toFixed(1)}`),n.recomputed&&(t+=`, rhino_recomputed;desc="${n.recomputed.ran}/${n.recomputed.total}"`)}for(let[n,r]of e.prepMarks)t+=`, p_${n};dur=${r.toFixed(1)}`;let r=e.settle;t+=`, selva_cache;dur=${+!!r.fromCache}`,r.definitionReuploaded!==void 0&&(t+=`, def_reupload;dur=${+!!r.definitionReuploaded}`);let i=e.byteRefOutcome;if(i){let e=i.loaded?i.fromCache?`hit`:`miss`:`skipped`;t+=`, def_bytes;desc=${e}`}return t}function y(e){return e.id}const b=5e3;function x(t){let n=t.maxWarmComputeServers??16,r=/* @__PURE__ */ new Map,i=/* @__PURE__ */ new Map,o=/* @__PURE__ */ new Map;t.debug===`verbose`&&a();let s=e=>{t.debug&&t.onDebugLog?.(e)};async function c(n,r){let i=t.debug===`verbose`,a={serverUrl:n.serverUrl,apiKey:n.apiKey,debug:i,cachesolve:t.cachesolve,maxResponseBytes:t.maxResponseBytes};t.debug&&(a.onServerTiming=e=>{if(e.cacheHit){s(`[Compute/rhino-cache] solve-cache (cachesolve): HIT (cached result, solve skipped)`);return}let n=e.decode??0,r=e.solve??0,i=e.encode??0,a=n<=1?`HIT (definition reused, no re-upload/parse)`:`miss (full parse)`,o=t.cachesolve?`miss (solved fresh)`:`off`,c=e.recomputed?` | ran ${e.recomputed.ran}/${e.recomputed.total} objects`:``;s(`[Compute/rhino-cache] decode=${n}ms solve=${r}ms encode=${i}ms | definition-cache: ${a} | solve-cache (cachesolve): ${o}${c}`)}),r&&(a.headers={"X-Selva-Definition":r});let o=await e.create(a),c=1,l=0,u=!1;async function d(e){if(!u){u=!0;try{let t=await Promise.resolve(o.serverStats?.getActiveChildren({initialize:!1})).catch(()=>null);l=Date.now();let n=!t||t<=0?1:t;if(n===c)return;s(`[Compute/client-cache] concurrency ${c} → ${n} (server child count)`),c=n,e?.setMaxConcurrent(n)}finally{u=!1}}}await d();let f=o.createScheduler({mode:`queue`,maxConcurrent:c,maxQueueDepth:t.maxQueueDepth||void 0,queueWaitMs:t.queueWaitMs||void 0,timeoutMs:t.solveDeadlineMs,cache:t.responseCacheMaxBytes>0&&{maxBytes:t.responseCacheMaxBytes},reuseServerDefinitionCache:t.reuseServerDefinitionCache,onSettle:(e,n)=>{if(n.status===`success`&&(n.fromCache!==!0&&Date.now()-l>=3e5&&d(f),t.debug&&(s(`[Compute/selva-cache] ${n.fromCache?`HIT  — served from cache (no compute call)`:`miss — went to Rhino.Compute`} (${Math.round(n.durationMs)}ms)`),n.fromCache||s(n.definitionReuploaded===!0?`[Compute/def-cache] miss — definition RE-UPLOADED (pointer was cold/stale)`:n.definitionReuploaded===!1?`[Compute/def-cache] HIT  — definition reused from server cache (no upload)`:`[Compute/def-cache] n/a — reuse disabled or non-reusable definition`),!n.fromCache))){let e=n.response?.errors,t=Array.isArray(e)?e.length:0;t>0&&s(`[Compute/rhino-cache] ${t} GH error(s); not cached by Rhino.Compute. First: ${JSON.stringify(e[0])}`)}}});return{client:o,scheduler:f}}return{async getClient(e,t){let a=e.id,l=r.get(a);if(l)return r.delete(a),r.set(a,l),l;let u=i.get(a);if(u)return u;let d=o.get(a);if(d){if(Date.now()-d.at<b)throw s(`[Compute/client-cache] server ${a} failed to build <${b}ms ago — replaying error`),d.error;o.delete(a)}s(`[Compute/client-cache] miss — building warm client for server ${a}`);let f=(async()=>{let i;try{i=await c(e,t?.definitionGuid)}catch(e){throw o.set(a,{error:e,at:Date.now()}),e}if(r.size>=n){let e=r.keys().next().value;e!==void 0&&(s(`[Compute/client-cache] LRU evicted warm client for server ${e} (cap ${n})`),r.get(e)?.scheduler.dispose(),r.delete(e))}return r.set(a,i),i})().finally(()=>i.delete(a));return i.set(a,f),f},evict(e){let t=e;o.delete(t);let n=r.get(t);n&&(s(`[Compute/client-cache] evicted warm client for server ${t} (config change)`),n.scheduler.dispose(),r.delete(t))},solveCacheStats(){let e={warmClients:r.size,entries:0,bytes:0,hits:0,misses:0,evictions:0};for(let t of r.values()){let n=t.scheduler.cacheStats();e.entries+=n.entries,e.bytes+=n.bytes,e.hits+=n.hits,e.misses+=n.misses,e.evictions+=n.evictions}return e},clearSolveCaches(){s(`[Compute/client-cache] cleared solve caches on ${r.size} warm client(s)`);for(let e of r.values())e.scheduler.clearCache()},disposeAll(){s(`[Compute/client-cache] disposing all ${r.size} warm client(s)`);for(let e of r.values())e.scheduler.dispose();r.clear(),o.clear()}}}function S(e){let t=Math.max(0,Math.floor(e)),n=/* @__PURE__ */ new Map,r=0,i={hits:0,misses:0,evictions:0};function a(e,t){n.delete(e),n.set(e,t)}function o(){for(;r>t&&n.size>0;){let e=n.keys().next().value,t=n.get(e);n.delete(e),r-=t.bytes.byteLength,i.evictions+=1}}function s(e,i){if(t===0||i.byteLength>t)return;let a=n.get(e);a&&(r-=a.bytes.byteLength),n.set(e,{bytes:i}),r+=i.byteLength,o()}return{getOrLoad(e,t){let r={loaded:!1,fromCache:!1};return{key:e,outcome:r,load:async()=>{let o=n.get(e);if(o)return a(e,o),i.hits+=1,r.loaded=!0,r.fromCache=!0,o.bytes;i.misses+=1,r.loaded=!0,r.fromCache=!1;let c=await t();return s(e,c),c}}},stats(){return{hits:i.hits,misses:i.misses,evictions:i.evictions,entries:n.size,bytes:r}},clear(){n.clear(),r=0}}}function C(e={}){let t=/* @__PURE__ */ new Map;return{run(n,r,i){let a=t.get(n);if(a)return e.onJoin?.(n),a.notifyOwner?.(),a.promise;let o={notifyOwner:i,promise:void 0},s=(async()=>r())().finally(()=>{o.notifyOwner=void 0,t.get(n)===o&&t.delete(n)});return o.promise=s,t.set(n,o),s},inFlight(){return t.size}}}function w(e){return typeof e==`object`&&!!e&&!(e instanceof Uint8Array)&&`outcome`in e}function T(e){return typeof e==`object`&&!!e&&!(e instanceof Uint8Array)&&!(`outcome`in e)&&!(`key`in e)&&`versionId`in e}var E=class{limits;clientCache;byteCache;singleFlight;constructor(e){this.limits=e.limits;let t=e.logger??new d;this.clientCache=x({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:e.debug??!1,maxWarmComputeServers:e.maxWarmComputeServers,onDebugLog:e.onDebugLog??(e=>t.debug(e,{component:`Compute/client-cache`}))}),this.byteCache=S(this.limits.computeDefinitionCacheBytes),this.singleFlight=C({onJoin:e.onSolveCoalesced})}getClient(e,t){return this.clientCache.getClient(e,t)}definitionRef(e,t){return this.byteCache.getOrLoad(e,t)}evictServer(e){this.clientCache.evict(e)}clearSolveCaches(){this.clientCache.clearSolveCaches()}clearDefinitionCache(){this.byteCache.clear()}stats(){return{client:this.clientCache.solveCacheStats(),definitionBytes:this.byteCache.stats(),coalescing:{inFlight:this.singleFlight.inFlight()}}}async solve(e){let{definitionSource:t,byteRefOutcome:r,identity:i}=this.resolveDefinitionSource(e),a=await this.clientCache.getClient(e.server,{definitionGuid:e.definitionGuid}),o=f(e.inputs,e.values),s=`${i}:${e.server.id}:${n(o)}`,c=new AbortController,l=!1,u=()=>{l||c.abort()};e.signal.addEventListener(`abort`,u,{once:!0});let d=e.acceptEncoding??``,p;try{p=await this.singleFlight.run(s,()=>g({definitionSource:t,byteRefOutcome:r,inputs:e.inputs,values:e.values,inputTree:o,client:a,responseMaxBytes:this.limits.computeResponseMaxBytes,solveDeadlineMs:this.limits.solveDeadlineMs,acceptEncoding:d,selvaEvents:e.selvaEvents,signal:c.signal,loadStartMs:e.loadStartMs??performance.now(),defLoadMs:e.defLoadMs??0,prepMarks:e.prepMarks}),()=>{l=!0})}finally{e.signal.removeEventListener(`abort`,u)}if(p.kind!==`ok`)return p;let m=_(p.envelope,d);return{...p,envelope:{...p.envelope,body:m.body,headers:m.headers}}}toResponse(e,t){let n=(e,n)=>{t?.onError&&t.onError(e,n);let r={"Content-Type":`application/json`};return n.retryAfter!==void 0&&(r[`Retry-After`]=String(n.retryAfter)),{status:e,headers:r,body:JSON.stringify(n)}};switch(e.kind){case`ok`:return{status:200,headers:e.envelope.headers,body:e.envelope.body};case`timeout`:return n(504,{message:e.message});case`client_abort`:return n(499,{message:`Client closed request`});case`too_large`:return n(413,{message:`Solve result is too large to return. This usually means a file output exceeds the supported size.`});case`shed`:return n(503,{message:e.message,retryAfter:e.retryAfterSeconds});case`compute_error`:throw e.error}}toWebResponse(e){let t=this.toResponse(e);return new Response(typeof t.body==`string`?t.body:new Uint8Array(t.body),{status:t.status,headers:t.headers})}resolveDefinitionSource(e){let t=e.definitionSource;if(T(t)){let e=this.byteCache.getOrLoad(t.versionId,t.load);return{definitionSource:e,byteRefOutcome:e.outcome,identity:e.key}}if(w(t))return{definitionSource:t,byteRefOutcome:t.outcome,identity:t.key};if(s(t))return{definitionSource:t,identity:t.key};if(!e.definitionKey)throw Error(`SolveEngine.solve(): definitionKey is required when definitionSource is raw bytes or a string.`);return{definitionSource:t,identity:e.definitionKey}}};export{m as COMPUTE_CONTRACT_VERSION,h as COMPUTE_VERSION_HEADER,E as SolveEngine,_ as adaptEnvelopeToEncoding,f as buildSolveInputTree,x as createClientCache,S as createDefinitionByteCache,C as createSolveCacheSingleFlight,o as isDefinitionRef,g as runSolvePipeline,y as serverIdentity};
+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 } from "@selvajs/compute/core";
+import { Agent, fetch } from "undici";
+import { gzip } from "node:zlib";
+import { promisify } from "node:util";
+// src/server/concurrency-probe.ts
+/**
+* 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 FALLBACK_CONCURRENCY = 1;
+/**
+* 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 CONCURRENCY_PROBE_INTERVAL_MS = 3e5;
+/**
+* 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.
+*/
+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 {
+			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;
+		}
+	}
+	return {
+		get maxConcurrent() {
+			return maxConcurrent;
+		},
+		refresh: () => refresh(),
+		refreshIfDue(scheduler) {
+			if (Date.now() - lastProbeAt >= CONCURRENCY_PROBE_INTERVAL_MS) refresh(scheduler);
+		}
+	};
+}
+// src/server/long-fetch.ts
+/** undici's default `headersTimeout` and `bodyTimeout`, which `timeoutMs` can't extend. */
+const UNDICI_DEFAULT_LIMIT_MS = 3e5;
+/** Both off, not raised: the scheduler's `timeoutMs` stays the one deadline on a solve. */
+const unlimited = new Agent({
+	headersTimeout: 0,
+	bodyTimeout: 0
+});
+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/server-limits.ts
+/** Rhino.Compute's own default `--timeout`, for a server that can't report its own. */
+const DEFAULT_SOLVE_DEADLINE_MS = 1e5;
+/**
+* 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 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 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 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
+* ladder again, so a user clicking Solve twice waits twice.
+*
+* Short on purpose: this is a convenience for the rapid-retry case, not a
+* circuit breaker. An operator who starts the compute VM should not have to wait
+* 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(MAX_SOLVE_DEADLINE_MS);
+		const clientConfig = {
+			serverUrl: server.serverUrl,
+			apiKey: server.apiKey,
+			debug: debugVerbose,
+			cachesolve: config.cachesolve,
+			maxResponseBytes: config.maxResponseBytes,
+			...longFetch && { fetch: longFetch }
+		};
+		if (config.debug) clientConfig.onServerTiming = (t) => {
+			if (t.cacheHit) {
+				debugLog("[Compute/rhino-cache] solve-cache (cachesolve): HIT (cached result, solve skipped)");
+				return;
+			}
+			const decode = t.decode ?? 0;
+			const solve = t.solve ?? 0;
+			const encode = t.encode ?? 0;
+			const defCache = decode <= 1 ? "HIT (definition reused, no re-upload/parse)" : "miss (full parse)";
+			const solveCache = config.cachesolve ? "miss (solved fresh)" : "off";
+			const ran = t.recomputed ? ` | ran ${t.recomputed.ran}/${t.recomputed.total} objects` : "";
+			debugLog(`[Compute/rhino-cache] decode=${decode}ms solve=${solve}ms encode=${encode}ms | definition-cache: ${defCache} | solve-cache (cachesolve): ${solveCache}${ran}`);
+		};
+		if (definitionGuid) clientConfig.headers = { "X-Selva-Definition": definitionGuid };
+		const client = await GrasshopperClient.create(clientConfig);
+		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: probe.maxConcurrent,
+			maxQueueDepth: config.maxQueueDepth || void 0,
+			queueWaitMs: config.queueWaitMs || void 0,
+			timeoutMs: limits.solveDeadlineMs,
+			cache: config.responseCacheMaxBytes > 0 ? { maxBytes: config.responseCacheMaxBytes } : false,
+			reuseServerDefinitionCache: limits.reuseDefinitionCache,
+			onSettle: (_ctx, result) => {
+				queueMicrotask(() => finishDraining(entry));
+				if (result.status !== "success") return;
+				if (result.fromCache !== true) {
+					probe.refreshIfDue(scheduler);
+					recheckLimitsIfDue();
+				}
+				if (config.debug) describeSettledSolve(result).forEach(debugLog);
+			}
+		});
+		const entry = {
+			client,
+			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) {
+			const key = server.id;
+			const existing = cache.get(key);
+			if (existing) {
+				cache.delete(key);
+				cache.set(key, existing);
+				return existing;
+			}
+			const inFlight = pending.get(key);
+			if (inFlight) return inFlight.promise;
+			const recentFailure = failed.get(key);
+			if (recentFailure) {
+				if (Date.now() - recentFailure.at < FAILED_BUILD_TTL_MS) {
+					debugLog(`[Compute/client-cache] server ${key} failed to build <${FAILED_BUILD_TTL_MS}ms ago — replaying error`);
+					throw recentFailure.error;
+				}
+				failed.delete(key);
+			}
+			debugLog(`[Compute/client-cache] miss — building warm client for server ${key}`);
+			const token = { stale: false };
+			const promise = (async () => {
+				let entry;
+				try {
+					entry = await build(server, opts?.definitionGuid);
+				} catch (err) {
+					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})`);
+						const oldest = cache.get(oldestKey);
+						cache.delete(oldestKey);
+						if (oldest) retire(oldest);
+					}
+				}
+				cache.set(key, entry);
+				return entry;
+			})().finally(() => {
+				if (pending.get(key)?.token === token) pending.delete(key);
+			});
+			pending.set(key, {
+				promise,
+				token
+			});
+			return promise;
+		},
+		evict(id) {
+			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() {
+			const total = {
+				warmClients: cache.size,
+				entries: 0,
+				bytes: 0,
+				hits: 0,
+				misses: 0,
+				evictions: 0
+			};
+			for (const entry of cache.values()) {
+				const s = entry.scheduler.cacheStats();
+				total.entries += s.entries;
+				total.bytes += s.bytes;
+				total.hits += s.hits;
+				total.misses += s.misses;
+				total.evictions += s.evictions;
+			}
+			return total;
+		},
+		clearSolveCaches() {
+			debugLog(`[Compute/client-cache] cleared solve caches on ${cache.size} warm client(s)`);
+			for (const entry of cache.values()) entry.scheduler.clearCache();
+		},
+		disposeAll() {
+			debugLog(`[Compute/client-cache] disposing all ${cache.size} warm client(s)`);
+			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 evictToFit() {
+		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;
+		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 = {
+				loaded: false,
+				fromCache: false
+			};
+			return {
+				key: versionId,
+				outcome,
+				load: async function read(signal) {
+					outcome.loaded = true;
+					const hit = cache.get(versionId);
+					if (hit) {
+						cache.delete(versionId);
+						cache.set(versionId, hit);
+						stats.hits += 1;
+						outcome.fromCache = true;
+						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;
+					return wait(startLoad(versionId, load), signal);
+				}
+			};
+		},
+		stats() {
+			return {
+				hits: stats.hits,
+				misses: stats.misses,
+				evictions: stats.evictions,
+				entries: cache.size,
+				bytes: retainedBytes
+			};
+		},
+		clear() {
+			cache.clear();
+			retainedBytes = 0;
+		}
+	};
+}
+// 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, callerSignal) {
+			const existing = inflight.get(key);
+			if (existing) {
+				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 = {
+				controller,
+				callers: 0,
+				promise: (async () => work(controller.signal))().finally(() => free(key, flight))
+			};
+			inflight.set(key, flight);
+			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
+* 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`.
+*/
+/** 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;
+		this.clientCache = createClientCache({
+			cachesolve: this.limits.computeServerCachesolve,
+			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
+		});
+		this.byteCache = createDefinitionByteCache(this.limits.computeDefinitionCacheBytes);
+		this.singleFlight = createSolveCacheSingleFlight({ onJoin: options.onSolveCoalesced });
+	}
+	getClient(server, opts) {
+		return this.clientCache.getClient(server, opts);
+	}
+	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);
+	}
+	clearSolveCaches() {
+		this.clientCache.clearSolveCaches();
+	}
+	/**
+	* Drop every retained `.gh` byte entry. Safe at any time: entries key on an
+	* immutable version id, so clearing costs a storage re-read and nothing else.
+	*/
+	clearDefinitionCache() {
+		this.byteCache.clear();
+	}
+	stats() {
+		return {
+			client: this.clientCache.solveCacheStats(),
+			definitionBytes: this.byteCache.stats(),
+			coalescing: { inFlight: this.singleFlight.inFlight() }
+		};
+	}
+	async solve(args) {
+		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
+		};
+		let client;
+		try {
+			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 (args.signal.aborted) return {
+			kind: "client_abort",
+			durationMs: elapsed()
+		};
+		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 live = args.selvaEvents ? `:live:${args.selvaEvents.solveId}` : "";
+		const flight = await this.singleFlight.run(`${identity}:${args.server.id}:${this.clientGeneration(client)}:${stableStringify(inputTree)}${live}`, (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 {
+				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 new Response(outcome.envelope.body, {
+				status: 200,
+				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
+			});
+			case "compute_error": throw outcome.error;
+		}
+	}
+	/**
+	* 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 (isByteCacheRef(source) || isDefinitionRef(source)) return {
+			definitionSource: source,
+			identity: source.key
+		};
+		if (!args.definitionKey) throw new Error("SolveEngine.solve(): definitionKey is required when definitionSource is raw bytes or a string.");
+		return {
+			definitionSource: source,
+			identity: args.definitionKey
+		};
+	}
+};
+export { COMPUTE_CONTRACT_VERSION, COMPUTE_VERSION_HEADER, DEFAULT_SOLVE_DEADLINE_MS, MAX_SOLVE_DEADLINE_MS, SolveEngine, acceptsGzip, solveInputsFromSchema };
+
 //# sourceMappingURL=server.js.map