@selvajs/selva 4.7.4-beta.1 → 4.8.0-beta.11

package/build/server/chunks/chunks/computeLimits.js-D7YwfkMw.js

@@ -1,47 +0,0 @@
-import { b as private_env } from './shared-server.js-HBAhbQ8m.js';
-import { v as lazyLogger } from './providers.server.js-DdXZdijf.js';
-import { a as resolveComputeLimits } from './limits.js-CX18fbtQ.js';
-import './src.js-C5mUn1eC.js';
-import 'node:dns/promises';
-import 'node:net';
-
-//#region src/lib/server/computeLimits.ts
-/**
-* App-side binding for the compute limits. The knobs, defaults, and env
-* parsing now live in `@selvajs/server` (`resolveComputeLimits`) so a consuming
-* app can reuse them; this module is the thin adapter that reads SvelteKit's
-* dynamic private env ONCE and re-exports the resolved values as the named
-* constants the rest of the app already imports.
-*
-* Why `$env/dynamic/private` and not bare `process.env`: in `vite dev` Vite
-* loads `.env` into this module but does NOT mirror it into `process.env`, so a
-* raw `process.env[name]` is undefined in dev and every knob silently fell back
-* to its default regardless of `.env`.
-*
-* Client-side counterparts (the in-flight compute throttle and the slider
-* debounce on inputs) are bundled into the client, so they cannot read env — see
-* `async-throttle.ts` in `@selvajs/solve/client` and the input components.
-*/
-var limits = resolveComputeLimits(private_env, lazyLogger);
-/** The whole resolved object — passed wholesale to `SolveEngine` (`engine.server.ts`). */
-var computeLimits = limits;
-var MAX_SOLVE_DURATION_MS = limits.maxSolveDurationMs;
-var RATE_LIMIT_WINDOW_MS = limits.rateLimitWindowMs;
-var RATE_LIMIT_MAX_REQUESTS = limits.rateLimitMaxRequests;
-var MAX_GH_FILE_SIZE = limits.maxGhFileSize;
-var MAX_IMAGE_FILE_SIZE = limits.maxImageFileSize;
-var COMPUTE_REQUEST_MAX_BYTES = limits.computeRequestMaxBytes;
-var COMPUTE_RESPONSE_MAX_BYTES = limits.computeResponseMaxBytes;
-var REMOTE_DEFINITION_MAX_BYTES = limits.remoteDefinitionMaxBytes;
-var REMOTE_DEFINITION_FETCH_TIMEOUT_MS = limits.remoteDefinitionFetchTimeoutMs;
-var REMOTE_DEFINITION_CACHE_TTL_MS = limits.remoteDefinitionCacheTtlMs;
-limits.computeReuseDefinitionCache;
-limits.computeServerCachesolve;
-limits.computeCacheErroredSolves;
-limits.computeMaxQueueDepth;
-limits.computeQueueWaitMs;
-var COMPUTE_DEFINITION_CACHE_BYTES = limits.computeDefinitionCacheBytes;
-var COMPUTE_SOLVE_CACHE_BYTES = limits.computeSolveCacheBytes;
-
-export { COMPUTE_DEFINITION_CACHE_BYTES as C, MAX_IMAGE_FILE_SIZE as M, REMOTE_DEFINITION_CACHE_TTL_MS as R, COMPUTE_SOLVE_CACHE_BYTES as a, REMOTE_DEFINITION_FETCH_TIMEOUT_MS as b, computeLimits as c, REMOTE_DEFINITION_MAX_BYTES as d, COMPUTE_RESPONSE_MAX_BYTES as e, COMPUTE_REQUEST_MAX_BYTES as f, MAX_GH_FILE_SIZE as g, RATE_LIMIT_MAX_REQUESTS as h, RATE_LIMIT_WINDOW_MS as i, MAX_SOLVE_DURATION_MS as j };
-//# sourceMappingURL=computeLimits.js-D7YwfkMw.js.map

package/build/server/chunks/chunks/computeLimits.js-D7YwfkMw.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"computeLimits.js-D7YwfkMw.js","sources":["../../../../.svelte-kit/output/server/chunks/computeLimits.js"],"sourcesContent":["import { t as private_env } from \"./shared-server.js\";\nimport { S as lazyLogger } from \"./providers.server.js\";\nimport { n as resolveComputeLimits } from \"./limits.js\";\nimport \"./compute.js\";\n//#region src/lib/server/computeLimits.ts\n/**\n* App-side binding for the compute limits. The knobs, defaults, and env\n* parsing now live in `@selvajs/server` (`resolveComputeLimits`) so a consuming\n* app can reuse them; this module is the thin adapter that reads SvelteKit's\n* dynamic private env ONCE and re-exports the resolved values as the named\n* constants the rest of the app already imports.\n*\n* Why `$env/dynamic/private` and not bare `process.env`: in `vite dev` Vite\n* loads `.env` into this module but does NOT mirror it into `process.env`, so a\n* raw `process.env[name]` is undefined in dev and every knob silently fell back\n* to its default regardless of `.env`.\n*\n* Client-side counterparts (the in-flight compute throttle and the slider\n* debounce on inputs) are bundled into the client, so they cannot read env — see\n* `async-throttle.ts` in `@selvajs/solve/client` and the input components.\n*/\nvar limits = resolveComputeLimits(private_env, lazyLogger);\n/** The whole resolved object — passed wholesale to `SolveEngine` (`engine.server.ts`). */\nvar computeLimits = limits;\nvar MAX_SOLVE_DURATION_MS = limits.maxSolveDurationMs;\nvar RATE_LIMIT_WINDOW_MS = limits.rateLimitWindowMs;\nvar RATE_LIMIT_MAX_REQUESTS = limits.rateLimitMaxRequests;\nvar MAX_GH_FILE_SIZE = limits.maxGhFileSize;\nvar MAX_IMAGE_FILE_SIZE = limits.maxImageFileSize;\nvar COMPUTE_REQUEST_MAX_BYTES = limits.computeRequestMaxBytes;\nvar COMPUTE_RESPONSE_MAX_BYTES = limits.computeResponseMaxBytes;\nvar REMOTE_DEFINITION_MAX_BYTES = limits.remoteDefinitionMaxBytes;\nvar REMOTE_DEFINITION_FETCH_TIMEOUT_MS = limits.remoteDefinitionFetchTimeoutMs;\nvar REMOTE_DEFINITION_CACHE_TTL_MS = limits.remoteDefinitionCacheTtlMs;\nlimits.computeReuseDefinitionCache;\nlimits.computeServerCachesolve;\nlimits.computeCacheErroredSolves;\nlimits.computeMaxQueueDepth;\nlimits.computeQueueWaitMs;\nvar COMPUTE_DEFINITION_CACHE_BYTES = limits.computeDefinitionCacheBytes;\nvar COMPUTE_SOLVE_CACHE_BYTES = limits.computeSolveCacheBytes;\n//#endregion\nexport { MAX_GH_FILE_SIZE as a, RATE_LIMIT_MAX_REQUESTS as c, REMOTE_DEFINITION_FETCH_TIMEOUT_MS as d, REMOTE_DEFINITION_MAX_BYTES as f, COMPUTE_SOLVE_CACHE_BYTES as i, RATE_LIMIT_WINDOW_MS as l, COMPUTE_REQUEST_MAX_BYTES as n, MAX_IMAGE_FILE_SIZE as o, computeLimits as p, COMPUTE_RESPONSE_MAX_BYTES as r, MAX_SOLVE_DURATION_MS as s, COMPUTE_DEFINITION_CACHE_BYTES as t, REMOTE_DEFINITION_CACHE_TTL_MS as u };\n"],"names":[],"mappings":";;;;;;;AAIA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI,MAAM,GAAG,oBAAoB,CAAC,WAAW,EAAE,UAAU,CAAC;AAC1D;AACG,IAAC,aAAa,GAAG;AACjB,IAAC,qBAAqB,GAAG,MAAM,CAAC;AAChC,IAAC,oBAAoB,GAAG,MAAM,CAAC;AAC/B,IAAC,uBAAuB,GAAG,MAAM,CAAC;AAClC,IAAC,gBAAgB,GAAG,MAAM,CAAC;AAC3B,IAAC,mBAAmB,GAAG,MAAM,CAAC;AAC9B,IAAC,yBAAyB,GAAG,MAAM,CAAC;AACpC,IAAC,0BAA0B,GAAG,MAAM,CAAC;AACrC,IAAC,2BAA2B,GAAG,MAAM,CAAC;AACtC,IAAC,kCAAkC,GAAG,MAAM,CAAC;AAC7C,IAAC,8BAA8B,GAAG,MAAM,CAAC;AAC5C,MAAM,CAAC,2BAA2B;AAClC,MAAM,CAAC,uBAAuB;AAC9B,MAAM,CAAC,yBAAyB;AAChC,MAAM,CAAC,oBAAoB;AAC3B,MAAM,CAAC,kBAAkB;AACtB,IAAC,8BAA8B,GAAG,MAAM,CAAC;AACzC,IAAC,yBAAyB,GAAG,MAAM,CAAC;;;;"}

package/build/server/chunks/chunks/definitions.js-Bgi_EnOc.js

@@ -1,2 +0,0 @@
-import './src.js-C5mUn1eC.js';
-//# sourceMappingURL=definitions.js-Bgi_EnOc.js.map

package/build/server/chunks/chunks/definitions.js-Bgi_EnOc.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"definitions.js-Bgi_EnOc.js","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/build/server/chunks/chunks/engine.server.js-DRhY8FHd.js

@@ -1,575 +0,0 @@
-import { b as private_env } from './shared-server.js-HBAhbQ8m.js';
-import './src.js-C5mUn1eC.js';
-import { v as lazyLogger, g as getLogger } from './providers.server.js-DdXZdijf.js';
-import { N as NoopLogger } from './limits.js-CX18fbtQ.js';
-import { f as fe, p, l } from './chunk-XT3XWDDV.js-CgVdm1U0.js';
-import { l as le, T as T$1, X as X$1, O as O$1, m as mt } from './chunk-XHXJVNW7.js-Bj249C3T.js';
-import { c as computeLimits } from './computeLimits.js-D7YwfkMw.js';
-import { gunzipSync, gzip } from 'zlib';
-import { promisify } from 'util';
-
-//#region ../solve/dist/server.js
-function A(e, n) {
-	let t = {
-		id: e.id,
-		name: e.nickname,
-		nickname: e.nickname || null,
-		description: e.description || "",
-		paramType: e.paramType === "dynamicValueList" ? "valueList" : e.paramType,
-		treeAccess: e.inputStructure === "tree",
-		minimum: e.minimum ?? null,
-		maximum: e.maximum ?? null,
-		atLeast: 1,
-		atMost: 1,
-		stepSize: e.stepSize,
-		default: n ?? e.default
-	}, r = mt(t), o = n ?? e.default;
-	return r.default == null && o != null && (Array.isArray(o) || r.paramType === "ValueList" && typeof o != "object") && (r.default = o), r;
-}
-var j = promisify(gzip);
-var _ = "X-Selva-Compute-Version";
-function E(e, n) {
-	return X$1.fromInputParams(e.filter((t) => t.paramType).map((t) => A(t, n[t.id])));
-}
-async function B(e) {
-	let { client: n, signal: t } = e, r = performance.now(), o = e.inputTree ?? E(e.inputs, e.values), a = performance.now() - r, s = n.solveMeta.seq, m = n.rhinoTiming.seq, i, c = performance.now();
-	try {
-		i = await n.scheduler.solve(e.definitionSource, o, { signal: t });
-	} catch (v) {
-		let x = performance.now() - c;
-		if (v instanceof Error && v.name === "AbortError") return t.aborted ? {
-			kind: "client_abort",
-			durationMs: x
-		} : {
-			kind: "timeout",
-			durationMs: x,
-			message: `Solve exceeded the ${Math.round(e.maxSolveDurationMs / 1e3)}s deadline.`
-		};
-		if (v instanceof p) {
-			if (v.code === l.QUEUE_FULL) return {
-				kind: "shed",
-				durationMs: x,
-				reason: "queue_full",
-				retryAfterSeconds: 1,
-				message: "Compute server is at capacity. Retry shortly."
-			};
-			if (v.code === l.QUEUE_TIMEOUT) return {
-				kind: "shed",
-				durationMs: x,
-				reason: "queue_timeout",
-				retryAfterSeconds: 1,
-				message: "Compute request waited too long in the queue. Retry shortly."
-			};
-		}
-		return {
-			kind: "compute_error",
-			durationMs: x,
-			error: v
-		};
-	}
-	let u = performance.now() - c, p$1 = performance.now(), d;
-	try {
-		d = JSON.stringify(i);
-	} catch (v) {
-		if (v instanceof RangeError) return { kind: "too_large" };
-		throw v;
-	}
-	if (d.length > e.responseMaxBytes) return { kind: "too_large" };
-	let f = performance.now() - p$1, M = /\bgzip\b/i.test(e.acceptEncoding) && d.length > 1024, C = null, S = 0;
-	if (M) {
-		let v = performance.now();
-		C = await j(Buffer.from(d)), S = performance.now() - v;
-	}
-	let g = performance.now() - e.loadStartMs, l$1 = n.solveMeta.seq === s + 1 ? n.solveMeta.last : null, h = l$1 && !l$1.fromCache && n.rhinoTiming.seq === m + 1 ? n.rhinoTiming.last : null, y = {
-		"Content-Type": "application/json",
-		"Server-Timing": V({
-			defLoadMs: e.defLoadMs,
-			treeBuildMs: a,
-			solveMs: u,
-			serializeMs: f,
-			gzipMs: S,
-			serverTotalMs: g,
-			rhino: h,
-			settle: l$1,
-			byteRefOutcome: e.byteRefOutcome,
-			prepMarks: e.prepMarks ?? []
-		}),
-		[_]: String(1),
-		Vary: "Accept-Encoding"
-	}, R = {
-		treeBuildMs: a,
-		solveMs: u,
-		serializeMs: f,
-		gzipMs: S,
-		serverTotalMs: g,
-		serializedBytes: d.length,
-		compressedBytes: C?.byteLength ?? null
-	}, D;
-	return C ? (y["Content-Encoding"] = "gzip", y["Content-Length"] = String(C.byteLength), D = {
-		body: new Uint8Array(C),
-		encoding: "gzip",
-		headers: y,
-		result: i,
-		metrics: R
-	}) : (y["Content-Length"] = String(Buffer.byteLength(d)), D = {
-		body: d,
-		headers: y,
-		result: i,
-		metrics: R
-	}), {
-		kind: "ok",
-		envelope: D,
-		solveMs: u,
-		errorCount: i.errors?.length ?? 0,
-		warningCount: i.warnings?.length ?? 0
-	};
-}
-function T(e, n) {
-	let t = /\bgzip\b/i.test(n);
-	if (e.encoding === "gzip" && !t) {
-		let r = gunzipSync(e.body instanceof Uint8Array ? e.body : Buffer.from(e.body)).toString("utf8"), o = { ...e.headers };
-		return delete o["Content-Encoding"], o["Content-Length"] = String(Buffer.byteLength(r)), {
-			body: r,
-			headers: o
-		};
-	}
-	return {
-		body: e.body,
-		headers: e.headers
-	};
-}
-function V(e) {
-	let n = `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)}`, t = e.rhino;
-	if (t) {
-		let a = t.decode + t.solve + t.encode, s = Math.max(0, e.solveMs - a);
-		n += `, rhino_decode;dur=${t.decode.toFixed(1)}, rhino_solve;dur=${t.solve.toFixed(1)}, rhino_encode;dur=${t.encode.toFixed(1)}, compute_link;dur=${s.toFixed(1)}`;
-	}
-	for (let [a, s] of e.prepMarks) n += `, p_${a};dur=${s.toFixed(1)}`;
-	let r = e.settle;
-	r && (n += `, selva_cache;dur=${r.fromCache ? 1 : 0}`, r.definitionReuploaded !== void 0 && (n += `, def_reupload;dur=${r.definitionReuploaded ? 1 : 0}`));
-	let o = e.byteRefOutcome;
-	if (o) {
-		let a = o.loaded ? o.fromCache ? "hit" : "miss" : "skipped";
-		n += `, def_bytes;desc=${a}`;
-	}
-	return n;
-}
-var J = 16;
-var z = 1;
-var X = 3e5;
-function k(e) {
-	let n = e.maxWarmComputeServers ?? J, t = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Map();
-	e.debug === "verbose" && fe();
-	let o = (s) => {
-		e.debug && e.onDebugLog?.(s);
-	};
-	async function a(s, m) {
-		let i = {
-			last: null,
-			seq: 0
-		}, c = {
-			last: null,
-			seq: 0
-		}, u = e.debug === "verbose", p = {
-			serverUrl: s.serverUrl,
-			apiKey: s.apiKey,
-			debug: u,
-			cachesolve: e.cachesolve,
-			cacheerroredsolves: e.cacheerroredsolves,
-			onServerTiming: (g) => {
-				let l = g.decode ?? 0, h = g.solve ?? 0, b = g.encode ?? 0;
-				if (i.seq += 1, i.last = {
-					decode: l,
-					solve: h,
-					encode: b
-				}, !e.debug) return;
-				let y = l <= 1 ? "HIT (definition reused, no re-upload/parse)" : "miss (full parse)", R = e.cachesolve && h <= 1 ? "HIT (cached result, solve skipped)" : e.cachesolve ? "miss (solved fresh)" : "off";
-				o(`[Compute/rhino-cache] decode=${l}ms solve=${h}ms encode=${b}ms | definition-cache: ${y} | solve-cache (cachesolve): ${R}`);
-			}
-		};
-		m && (p.headers = { "X-Selva-Definition": m });
-		let d = await O$1.create(p), f = z, w = 0, M = false;
-		async function C(g) {
-			if (!M) {
-				M = true;
-				try {
-					let l = await Promise.resolve(d.serverStats?.getActiveChildren({ initialize: !1 })).catch(() => null);
-					w = Date.now();
-					let h = !l || l <= 0 ? z : l;
-					if (h === f) return;
-					o(`[Compute/client-cache] concurrency ${f} \u2192 ${h} (server child count)`), f = h, g?.setMaxConcurrent(h);
-				} finally {
-					M = false;
-				}
-			}
-		}
-		await C();
-		let S = d.createScheduler({
-			mode: "queue",
-			maxConcurrent: f,
-			maxQueueDepth: e.maxQueueDepth || void 0,
-			queueWaitMs: e.queueWaitMs || void 0,
-			timeoutMs: e.maxSolveDurationMs,
-			cache: e.responseCacheMaxBytes > 0 ? { maxBytes: e.responseCacheMaxBytes } : false,
-			reuseServerDefinitionCache: e.reuseServerDefinitionCache,
-			onSettle: (g, l) => {
-				if (c.seq += 1, l.status === "success" && (l.fromCache !== true && Date.now() - w >= X && C(S), c.last = {
-					fromCache: l.fromCache === true,
-					definitionReuploaded: l.definitionReuploaded
-				}, !!e.debug && (o(`[Compute/selva-cache] ${l.fromCache ? "HIT  — served from cache (no compute call)" : "miss — went to Rhino.Compute"} (${Math.round(l.durationMs)}ms)`), l.fromCache || o(l.definitionReuploaded === true ? "[Compute/def-cache] miss — definition RE-UPLOADED (pointer was cold/stale)" : l.definitionReuploaded === false ? "[Compute/def-cache] HIT  — definition reused from server cache (no upload)" : "[Compute/def-cache] n/a — reuse disabled or non-reusable definition"), !l.fromCache))) {
-					let h = l.response?.errors, b = Array.isArray(h) ? h.length : 0;
-					if (b > 0) {
-						let y = e.cacheerroredsolves ? "cached (cacheerroredsolves on)" : "not cached (cacheerroredsolves off) — re-run until fixed";
-						o(`[Compute/rhino-cache] ${b} GH error(s); ${y}. First: ${JSON.stringify(h[0])}`);
-					}
-				}
-			}
-		});
-		return {
-			client: d,
-			scheduler: S,
-			rhinoTiming: i,
-			solveMeta: c
-		};
-	}
-	return {
-		async getClient(s, m) {
-			let i = s.id, c = t.get(i);
-			if (c) return t.delete(i), t.set(i, c), c;
-			let u = r.get(i);
-			if (u) return u;
-			o(`[Compute/client-cache] miss \u2014 building warm client for server ${i}`);
-			let p = (async () => {
-				let d = await a(s, m?.definitionGuid);
-				if (t.size >= n) {
-					let f = t.keys().next().value;
-					f !== void 0 && (o(`[Compute/client-cache] LRU evicted warm client for server ${f} (cap ${n})`), t.get(f)?.scheduler.dispose(), t.delete(f));
-				}
-				return t.set(i, d), d;
-			})().finally(() => r.delete(i));
-			return r.set(i, p), p;
-		},
-		evict(s) {
-			let m = s, i = t.get(m);
-			i && (o(`[Compute/client-cache] evicted warm client for server ${m} (config change)`), i.scheduler.dispose(), t.delete(m));
-		},
-		solveCacheStats() {
-			let s = {
-				warmClients: t.size,
-				entries: 0,
-				bytes: 0,
-				hits: 0,
-				misses: 0,
-				evictions: 0
-			};
-			for (let m of t.values()) {
-				let i = m.scheduler.cacheStats();
-				s.entries += i.entries, s.bytes += i.bytes, s.hits += i.hits, s.misses += i.misses, s.evictions += i.evictions;
-			}
-			return s;
-		},
-		clearSolveCaches() {
-			o(`[Compute/client-cache] cleared solve caches on ${t.size} warm client(s)`);
-			for (let s of t.values()) s.scheduler.clearCache();
-		},
-		disposeAll() {
-			o(`[Compute/client-cache] disposing all ${t.size} warm client(s)`);
-			for (let s of t.values()) s.scheduler.dispose();
-			t.clear();
-		}
-	};
-}
-function P(e) {
-	let n = Math.max(0, Math.floor(e)), t = /* @__PURE__ */ new Map(), r = 0, o = {
-		hits: 0,
-		misses: 0,
-		evictions: 0
-	};
-	function a(i, c) {
-		t.delete(i), t.set(i, c);
-	}
-	function s() {
-		for (; r > n && t.size > 0;) {
-			let i = t.keys().next().value, c = t.get(i);
-			t.delete(i), r -= c.bytes.byteLength, o.evictions += 1;
-		}
-	}
-	function m(i, c) {
-		if (n === 0 || c.byteLength > n) return;
-		let u = t.get(i);
-		u && (r -= u.bytes.byteLength), t.set(i, { bytes: c }), r += c.byteLength, s();
-	}
-	return {
-		getOrLoad(i, c) {
-			let u = {
-				loaded: false,
-				fromCache: false
-			};
-			return {
-				key: i,
-				outcome: u,
-				load: async () => {
-					let p = t.get(i);
-					if (p) return a(i, p), o.hits += 1, u.loaded = true, u.fromCache = true, p.bytes;
-					o.misses += 1, u.loaded = true, u.fromCache = false;
-					let d = await c();
-					return m(i, d), d;
-				}
-			};
-		},
-		stats() {
-			return {
-				hits: o.hits,
-				misses: o.misses,
-				evictions: o.evictions,
-				entries: t.size,
-				bytes: r
-			};
-		},
-		clear() {
-			t.clear(), r = 0;
-		}
-	};
-}
-function O(e = {}) {
-	let n = /* @__PURE__ */ new Map();
-	return {
-		run(t, r, o) {
-			let a = n.get(t);
-			if (a) return e.onJoin?.(t), a.notifyOwner?.(), a.promise;
-			let s = {
-				notifyOwner: o,
-				promise: void 0
-			}, m = (async () => r())().finally(() => {
-				s.notifyOwner = void 0, n.get(t) === s && n.delete(t);
-			});
-			return s.promise = m, n.set(t, s), m;
-		},
-		inFlight() {
-			return n.size;
-		}
-	};
-}
-function te(e) {
-	return typeof e == "object" && e !== null && !(e instanceof Uint8Array) && "outcome" in e;
-}
-function ne(e) {
-	return typeof e == "object" && e !== null && !(e instanceof Uint8Array) && !("outcome" in e) && !("key" in e) && "versionId" in e;
-}
-var L = class {
-	limits;
-	clientCache;
-	byteCache;
-	singleFlight;
-	constructor(n) {
-		this.limits = n.limits;
-		let t = n.logger ?? new NoopLogger();
-		this.clientCache = k({
-			maxSolveDurationMs: this.limits.maxSolveDurationMs,
-			cachesolve: this.limits.computeServerCachesolve,
-			cacheerroredsolves: this.limits.computeCacheErroredSolves,
-			reuseServerDefinitionCache: this.limits.computeReuseDefinitionCache,
-			maxQueueDepth: this.limits.computeMaxQueueDepth,
-			queueWaitMs: this.limits.computeQueueWaitMs,
-			responseCacheMaxBytes: this.limits.computeSolveCacheBytes,
-			debug: n.debug ?? false,
-			maxWarmComputeServers: n.maxWarmComputeServers,
-			onDebugLog: n.onDebugLog ?? ((r) => t.debug(r, { component: "Compute/client-cache" }))
-		}), this.byteCache = P(this.limits.computeDefinitionCacheBytes), this.singleFlight = O({ onJoin: n.onSolveCoalesced });
-	}
-	getClient(n, t) {
-		return this.clientCache.getClient(n, t);
-	}
-	definitionRef(n, t) {
-		return this.byteCache.getOrLoad(n, t);
-	}
-	evictServer(n) {
-		this.clientCache.evict(n);
-	}
-	clearSolveCaches() {
-		this.clientCache.clearSolveCaches();
-	}
-	stats() {
-		return {
-			client: this.clientCache.solveCacheStats(),
-			definitionBytes: this.byteCache.stats(),
-			coalescing: { inFlight: this.singleFlight.inFlight() }
-		};
-	}
-	async solve(n) {
-		let { definitionSource: t, byteRefOutcome: r, identity: o } = this.resolveDefinitionSource(n), a = await this.clientCache.getClient(n.server, { definitionGuid: n.definitionGuid }), s = E(n.inputs, n.values), m = `${o}:${n.server.id}:${le(s)}`, i = new AbortController(), c = false;
-		n.signal.addEventListener("abort", () => {
-			c || i.abort();
-		}, { once: true });
-		let u = n.acceptEncoding ?? "", p = await this.singleFlight.run(m, () => B({
-			definitionSource: t,
-			byteRefOutcome: r,
-			inputs: n.inputs,
-			values: n.values,
-			inputTree: s,
-			client: a,
-			responseMaxBytes: this.limits.computeResponseMaxBytes,
-			maxSolveDurationMs: this.limits.maxSolveDurationMs,
-			acceptEncoding: u,
-			signal: i.signal,
-			loadStartMs: n.loadStartMs ?? performance.now(),
-			defLoadMs: n.defLoadMs ?? 0,
-			prepMarks: n.prepMarks
-		}), () => {
-			c = true;
-		});
-		if (p.kind !== "ok") return p;
-		let d = T(p.envelope, u);
-		return {
-			...p,
-			envelope: {
-				...p.envelope,
-				body: d.body,
-				headers: d.headers
-			}
-		};
-	}
-	toResponse(n, t) {
-		let r = (o, a) => {
-			t?.onError && t.onError(o, a);
-			let s = { "Content-Type": "application/json" };
-			return a.retryAfter !== void 0 && (s["Retry-After"] = String(a.retryAfter)), {
-				status: o,
-				headers: s,
-				body: JSON.stringify(a)
-			};
-		};
-		switch (n.kind) {
-			case "ok": return {
-				status: 200,
-				headers: n.envelope.headers,
-				body: n.envelope.body
-			};
-			case "timeout": return r(504, { message: n.message });
-			case "client_abort": return r(499, { message: "Client closed request" });
-			case "too_large": return r(413, { message: "Solve result is too large to return. This usually means a file output exceeds the supported size." });
-			case "shed": return r(503, {
-				message: n.message,
-				retryAfter: n.retryAfterSeconds
-			});
-			case "compute_error": throw n.error;
-		}
-	}
-	toWebResponse(n) {
-		let t = this.toResponse(n);
-		return new Response(typeof t.body == "string" ? t.body : new Uint8Array(t.body), {
-			status: t.status,
-			headers: t.headers
-		});
-	}
-	resolveDefinitionSource(n) {
-		let t = n.definitionSource;
-		if (ne(t)) {
-			let r = this.byteCache.getOrLoad(t.versionId, t.load);
-			return {
-				definitionSource: r,
-				byteRefOutcome: r.outcome,
-				identity: r.key
-			};
-		}
-		if (te(t)) return {
-			definitionSource: t,
-			byteRefOutcome: t.outcome,
-			identity: t.key
-		};
-		if (T$1(t)) return {
-			definitionSource: t,
-			identity: t.key
-		};
-		if (!n.definitionKey) throw new Error("SolveEngine.solve(): definitionKey is required when definitionSource is raw bytes or a string.");
-		return {
-			definitionSource: t,
-			identity: n.definitionKey
-		};
-	}
-};
-//#endregion
-//#region src/lib/server/compute/engine.server.ts
-/**
-* App-wide `SolveEngine` instance — replaces the previous hand-assembled trio
-* (`clientCache.server.ts` + `definitionByteCache.server.ts` + `solveCache.server.ts`)
-* with the facade from `@selvajs/solve/server`. One instance backs the warm
-* client cache, the definition-byte cache, and solve coalescing for the whole app.
-*/
-/**
-* `SELVA_FLAG_COMPUTE_DEBUG` is a three-way knob, not a boolean: `off` (default),
-* `on` (concise cache/timing logs), or `verbose` (adds FULL lib-level request/
-* response dumps, incl. base64 geometry). `verbose` implies `on` — there is no
-* way to get the verbose dump without the concise logs too.
-*
-* `SELVA_FLAG_COMPUTE_DEBUG_VERBOSE` merged into this var. Still honoured for
-* one minor version so an operator's existing `.env` degrades to a warning,
-* not a silent loss of the verbose logging they asked for.
-*/
-var COMPUTE_DEBUG_MODE = (() => {
-	const raw = (private_env.SELVA_FLAG_COMPUTE_DEBUG ?? "").toLowerCase();
-	if (raw === "verbose") return "verbose";
-	const on = [
-		"true",
-		"1",
-		"yes",
-		"on"
-	].includes(raw);
-	if ([
-		"true",
-		"1",
-		"yes"
-	].includes((private_env.SELVA_FLAG_COMPUTE_DEBUG_VERBOSE ?? "").toLowerCase())) {
-		getLogger().warn("Deprecated env var: rename it", {
-			component: "selva",
-			envVar: "SELVA_FLAG_COMPUTE_DEBUG_VERBOSE",
-			renamedTo: "SELVA_FLAG_COMPUTE_DEBUG=verbose"
-		});
-		return "verbose";
-	}
-	return on ? "on" : "off";
-})();
-/** Concise cache/timing logs (Selva cache hits, server decode/solve/encode). */
-var COMPUTE_DEBUG = COMPUTE_DEBUG_MODE !== "off";
-var engine = new L({
-	limits: computeLimits,
-	logger: lazyLogger,
-	debug: COMPUTE_DEBUG ? COMPUTE_DEBUG_MODE === "verbose" ? "verbose" : true : false,
-	onDebugLog: (message) => getLogger().debug(message, { component: "Compute/client-cache" }),
-	onSolveCoalesced: (key) => {
-		if (COMPUTE_DEBUG) getLogger().debug("Coalesced onto in-flight solve", {
-			component: "Compute/single-flight",
-			key: `${key.slice(0, 96)}…`
-		});
-	}
-});
-/**
-* Get (or create) the warm client + scheduler for a resolved compute server.
-* Also used by the render/IO path (`loadForRender.server.ts`), which is not a
-* solve but shares the same warm client for `getIO`.
-*/
-function getClient(serverConfig, opts) {
-	return engine.getClient({
-		id: serverConfig.id,
-		serverUrl: serverConfig.serverUrl,
-		apiKey: serverConfig.apiKey
-	}, opts);
-}
-/**
-* Drop the warm client for a server whose config just changed (URL/key rotation
-* or deletion via /admin/compute or /api/org/compute).
-*/
-function evictComputeClient(id) {
-	engine.evictServer(id);
-}
-/** Solve-cache counters for the admin panel's hit rate. */
-function solveCacheStats() {
-	return engine.stats().client;
-}
-/** Definition-byte-cache counters (hits/misses/evictions/entries/bytes) for admin/debug surfaces. */
-function definitionByteCacheStats() {
-	return engine.stats().definitionBytes;
-}
-
-export { COMPUTE_DEBUG as C, engine as a, definitionByteCacheStats as d, evictComputeClient as e, getClient as g, solveCacheStats as s };
-//# sourceMappingURL=engine.server.js-DRhY8FHd.js.map