@selvajs/selva 4.13.1 → 4.14.1

package/build/server/chunks/chunks/email.js-CfmiUBKY.js

@@ -0,0 +1,102 @@
+import { b as private_env } from './shared-server.js-BZy9KN6u.js';
+import { g as getLogger } from './providers.server.js-n7DF9bkc.js';
+
+//#region src/lib/server/email/config.ts
+function parsePort(raw) {
+	const n = Number(raw ?? 587);
+	return Number.isInteger(n) && n > 0 && n < 65536 ? n : 587;
+}
+/**
+* Returns null when mail is not configured — the caller treats that as "no
+* mail", not as an error.
+*
+* Throws only when `SMTP_HOST` is set but `SMTP_FROM` is missing: that
+* combination is a half-finished config, and failing loudly beats silently
+* never sending. Every message needs an envelope sender, and guessing one
+* produces mail that fails SPF at the recipient.
+*/
+function readSmtpConfig() {
+	const host = private_env.SMTP_HOST?.trim();
+	if (!host) return null;
+	const from = private_env.SMTP_FROM?.trim();
+	if (!from) throw new Error("SMTP_HOST is set but SMTP_FROM is missing — mail needs a sender address.");
+	const port = parsePort(private_env.SMTP_PORT);
+	const user = private_env.SMTP_USER?.trim();
+	const pass = private_env.SMTP_PASS;
+	return {
+		host,
+		port,
+		secure: private_env.SMTP_SECURE ? private_env.SMTP_SECURE === "true" : port === 465,
+		auth: user && pass ? {
+			user,
+			pass
+		} : void 0,
+		from
+	};
+}
+//#endregion
+//#region src/lib/server/email/mailer.ts
+/**
+* Send one message over SMTP.
+*
+* Never throws — delivery is best-effort by design. Every caller has a
+* fallback (the invite route still returns `acceptUrl` for manual sharing),
+* so a dead mail server must not turn a successful write into a 500.
+*
+* Logs the recipient address, which is personal data, at `warn`/`error` only.
+* That is the minimum needed to diagnose a bounce; do not add subject or body.
+*/
+async function sendMail(mail, log = getLogger()) {
+	let config;
+	try {
+		config = readSmtpConfig();
+	} catch (err) {
+		log.error("SMTP is misconfigured", {
+			component: "Mailer",
+			error: err instanceof Error ? err.message : String(err)
+		});
+		return {
+			status: "failed",
+			reason: "misconfigured"
+		};
+	}
+	if (!config) return { status: "not-configured" };
+	try {
+		const { createTransport } = await import('nodemailer');
+		await createTransport({
+			host: config.host,
+			port: config.port,
+			secure: config.secure,
+			auth: config.auth
+		}).sendMail({
+			from: config.from,
+			to: mail.to,
+			subject: mail.subject,
+			text: mail.text,
+			html: mail.html
+		});
+		return { status: "sent" };
+	} catch (err) {
+		const reason = err instanceof Error ? err.message : String(err);
+		log.warn("Failed to send mail", {
+			component: "Mailer",
+			to: mail.to,
+			reason
+		});
+		return {
+			status: "failed",
+			reason
+		};
+	}
+}
+/** Whether this instance can send mail at all — drives UI copy. */
+function isMailConfigured() {
+	try {
+		return readSmtpConfig() !== null;
+	} catch {
+		return false;
+	}
+}
+
+export { isMailConfigured as i, sendMail as s };
+//# sourceMappingURL=email.js-CfmiUBKY.js.map

package/build/server/chunks/chunks/email.js-CfmiUBKY.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"email.js-CfmiUBKY.js","sources":["../../../../.svelte-kit/output/server/chunks/email.js"],"sourcesContent":["import { t as private_env } from \"./shared-server.js\";\nimport { f as getLogger } from \"./providers.server.js\";\n//#region src/lib/server/email/config.ts\nfunction parsePort(raw) {\n\tconst n = Number(raw ?? 587);\n\treturn Number.isInteger(n) && n > 0 && n < 65536 ? n : 587;\n}\n/**\n* Returns null when mail is not configured — the caller treats that as \"no\n* mail\", not as an error.\n*\n* Throws only when `SMTP_HOST` is set but `SMTP_FROM` is missing: that\n* combination is a half-finished config, and failing loudly beats silently\n* never sending. Every message needs an envelope sender, and guessing one\n* produces mail that fails SPF at the recipient.\n*/\nfunction readSmtpConfig() {\n\tconst host = private_env.SMTP_HOST?.trim();\n\tif (!host) return null;\n\tconst from = private_env.SMTP_FROM?.trim();\n\tif (!from) throw new Error(\"SMTP_HOST is set but SMTP_FROM is missing — mail needs a sender address.\");\n\tconst port = parsePort(private_env.SMTP_PORT);\n\tconst user = private_env.SMTP_USER?.trim();\n\tconst pass = private_env.SMTP_PASS;\n\treturn {\n\t\thost,\n\t\tport,\n\t\tsecure: private_env.SMTP_SECURE ? private_env.SMTP_SECURE === \"true\" : port === 465,\n\t\tauth: user && pass ? {\n\t\t\tuser,\n\t\t\tpass\n\t\t} : void 0,\n\t\tfrom\n\t};\n}\n//#endregion\n//#region src/lib/server/email/mailer.ts\n/**\n* Send one message over SMTP.\n*\n* Never throws — delivery is best-effort by design. Every caller has a\n* fallback (the invite route still returns `acceptUrl` for manual sharing),\n* so a dead mail server must not turn a successful write into a 500.\n*\n* Logs the recipient address, which is personal data, at `warn`/`error` only.\n* That is the minimum needed to diagnose a bounce; do not add subject or body.\n*/\nasync function sendMail(mail, log = getLogger()) {\n\tlet config;\n\ttry {\n\t\tconfig = readSmtpConfig();\n\t} catch (err) {\n\t\tlog.error(\"SMTP is misconfigured\", {\n\t\t\tcomponent: \"Mailer\",\n\t\t\terror: err instanceof Error ? err.message : String(err)\n\t\t});\n\t\treturn {\n\t\t\tstatus: \"failed\",\n\t\t\treason: \"misconfigured\"\n\t\t};\n\t}\n\tif (!config) return { status: \"not-configured\" };\n\ttry {\n\t\tconst { createTransport } = await import(\"nodemailer\");\n\t\tawait createTransport({\n\t\t\thost: config.host,\n\t\t\tport: config.port,\n\t\t\tsecure: config.secure,\n\t\t\tauth: config.auth\n\t\t}).sendMail({\n\t\t\tfrom: config.from,\n\t\t\tto: mail.to,\n\t\t\tsubject: mail.subject,\n\t\t\ttext: mail.text,\n\t\t\thtml: mail.html\n\t\t});\n\t\treturn { status: \"sent\" };\n\t} catch (err) {\n\t\tconst reason = err instanceof Error ? err.message : String(err);\n\t\tlog.warn(\"Failed to send mail\", {\n\t\t\tcomponent: \"Mailer\",\n\t\t\tto: mail.to,\n\t\t\treason\n\t\t});\n\t\treturn {\n\t\t\tstatus: \"failed\",\n\t\t\treason\n\t\t};\n\t}\n}\n/** Whether this instance can send mail at all — drives UI copy. */\nfunction isMailConfigured() {\n\ttry {\n\t\treturn readSmtpConfig() !== null;\n\t} catch {\n\t\treturn false;\n\t}\n}\n//#endregion\nexport { sendMail as n, isMailConfigured as t };\n"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,568 @@
+import { b as private_env } from './shared-server.js-BZy9KN6u.js';
+import './src.js-B12bUNyu.js';
+import { g as getLogger, x as lazyLogger, N as NoopLogger } from './providers.server.js-n7DF9bkc.js';
+import { U, s, t, e } from './core-BQtRL5GE.js-B9MmO4om.js';
+import { S as S$1, $ as $e, p as pe, V as Ve } from './schema.js-BVfByvmD.js';
+import { c as computeLimits } from './computeLimits.js-Bd0sEBc0.js';
+import { gunzipSync, gzip } from 'node:zlib';
+import { promisify } from 'node:util';
+
+//#region ../solve/dist/server.js
+function p(e, t) {
+	let n = {
+		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: t ?? e.default
+	}, i = Ve(n), a = t ?? e.default;
+	return i.default == null && a != null && (Array.isArray(a) || i.paramType === `ValueList` && typeof a != `object`) && (i.default = a), i;
+}
+var m = promisify(gzip);
+var g = `X-Selva-Compute-Version`;
+function _(e, n) {
+	return $e.fromInputParams(e.filter((e) => e.paramType).map((e) => p(e, n[e.id])));
+}
+async function v(e$1) {
+	let { client: t$2, signal: n } = e$1, r = performance.now(), i = e$1.inputTree ?? _(e$1.inputs, e$1.values), s = performance.now() - r, c = t$2.solveMeta.seq, l = t$2.rhinoTiming.seq, u, d = performance.now();
+	try {
+		u = await t$2.scheduler.solve(e$1.definitionSource, i, { signal: n });
+	} catch (t$1) {
+		let r = performance.now() - d;
+		if (t$1 instanceof Error && t$1.name === `AbortError`) return n.aborted ? {
+			kind: `client_abort`,
+			durationMs: r
+		} : {
+			kind: `timeout`,
+			durationMs: r,
+			message: `Solve exceeded the ${Math.round(e$1.solveDeadlineMs / 1e3)}s deadline.`
+		};
+		if (t$1 instanceof t) {
+			if (t$1.code === e.QUEUE_FULL) return {
+				kind: `shed`,
+				durationMs: r,
+				reason: `queue_full`,
+				retryAfterSeconds: 1,
+				message: `Compute server is at capacity. Retry shortly.`
+			};
+			if (t$1.code === e.QUEUE_TIMEOUT) return {
+				kind: `shed`,
+				durationMs: r,
+				reason: `queue_timeout`,
+				retryAfterSeconds: 1,
+				message: `Compute request waited too long in the queue. Retry shortly.`
+			};
+		}
+		return {
+			kind: `compute_error`,
+			durationMs: r,
+			error: t$1
+		};
+	}
+	let f = performance.now() - d, p = performance.now(), h;
+	try {
+		h = JSON.stringify(u);
+	} catch (e) {
+		if (e instanceof RangeError) return { kind: `too_large` };
+		throw e;
+	}
+	if (h.length > e$1.responseMaxBytes) return { kind: `too_large` };
+	let v = performance.now() - p, y = /\bgzip\b/i.test(e$1.acceptEncoding) && h.length > 1024, x = null, S = 0;
+	if (y) {
+		let e = performance.now();
+		x = await m(Buffer.from(h)), S = performance.now() - e;
+	}
+	let C = performance.now() - e$1.loadStartMs, w = t$2.solveMeta.seq === c + 1 ? t$2.solveMeta.last : null, T = w && !w.fromCache && t$2.rhinoTiming.seq === l + 1 ? t$2.rhinoTiming.last : null, E = {
+		"Content-Type": `application/json`,
+		"Server-Timing": b({
+			defLoadMs: e$1.defLoadMs,
+			treeBuildMs: s,
+			solveMs: f,
+			serializeMs: v,
+			gzipMs: S,
+			serverTotalMs: C,
+			rhino: T,
+			settle: w,
+			byteRefOutcome: e$1.byteRefOutcome,
+			prepMarks: e$1.prepMarks ?? []
+		}),
+		[g]: `1`,
+		Vary: `Accept-Encoding`
+	}, D = {
+		treeBuildMs: s,
+		solveMs: f,
+		serializeMs: v,
+		gzipMs: S,
+		serverTotalMs: C,
+		serializedBytes: h.length,
+		compressedBytes: x?.byteLength ?? null
+	}, O;
+	return x ? (E[`Content-Encoding`] = `gzip`, E[`Content-Length`] = String(x.byteLength), O = {
+		body: new Uint8Array(x),
+		encoding: `gzip`,
+		headers: E,
+		result: u,
+		metrics: D
+	}) : (E[`Content-Length`] = String(Buffer.byteLength(h)), O = {
+		body: h,
+		headers: E,
+		result: u,
+		metrics: D
+	}), {
+		kind: `ok`,
+		envelope: O,
+		solveMs: f,
+		errorCount: u.errors?.length ?? 0,
+		warningCount: u.warnings?.length ?? 0
+	};
+}
+function y(e, t) {
+	let n = /\bgzip\b/i.test(t);
+	if (e.encoding === `gzip` && !n) {
+		let t = gunzipSync(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 b(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 + n.solve + n.encode, i = Math.max(0, e.solveMs - r);
+		t += `, rhino_decode;dur=${n.decode.toFixed(1)}, rhino_solve;dur=${n.solve.toFixed(1)}, rhino_encode;dur=${n.encode.toFixed(1)}, compute_link;dur=${i.toFixed(1)}`;
+	}
+	for (let [n, r] of e.prepMarks) t += `, p_${n};dur=${r.toFixed(1)}`;
+	let r = e.settle;
+	r && (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 S(t) {
+	let n = t.maxWarmComputeServers ?? 16, r = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map();
+	t.debug === `verbose` && s();
+	let a = (e) => {
+		t.debug && t.onDebugLog?.(e);
+	};
+	async function o(n, r) {
+		let i = {
+			last: null,
+			seq: 0
+		}, o = {
+			last: null,
+			seq: 0
+		}, s = t.debug === `verbose`, c = {
+			serverUrl: n.serverUrl,
+			apiKey: n.apiKey,
+			debug: s,
+			cachesolve: t.cachesolve,
+			cacheerroredsolves: t.cacheerroredsolves,
+			onServerTiming: (e) => {
+				let n = e.decode ?? 0, r = e.solve ?? 0, o = e.encode ?? 0;
+				if (i.seq += 1, i.last = {
+					decode: n,
+					solve: r,
+					encode: o
+				}, !t.debug) return;
+				let s = n <= 1 ? `HIT (definition reused, no re-upload/parse)` : `miss (full parse)`, c = t.cachesolve && r <= 1 ? `HIT (cached result, solve skipped)` : t.cachesolve ? `miss (solved fresh)` : `off`;
+				a(`[Compute/rhino-cache] decode=${n}ms solve=${r}ms encode=${o}ms | definition-cache: ${s} | solve-cache (cachesolve): ${c}`);
+			}
+		};
+		r && (c.headers = { "X-Selva-Definition": r });
+		let l = await pe.create(c), u = 1, d = 0, f = false;
+		async function p(e) {
+			if (!f) {
+				f = true;
+				try {
+					let t = await Promise.resolve(l.serverStats?.getActiveChildren({ initialize: !1 })).catch(() => null);
+					d = Date.now();
+					let n = !t || t <= 0 ? 1 : t;
+					if (n === u) return;
+					a(`[Compute/client-cache] concurrency ${u} → ${n} (server child count)`), u = n, e?.setMaxConcurrent(n);
+				} finally {
+					f = false;
+				}
+			}
+		}
+		await p();
+		let m = l.createScheduler({
+			mode: `queue`,
+			maxConcurrent: u,
+			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 (o.seq += 1, n.status === `success` && (n.fromCache !== true && Date.now() - d >= 3e5 && p(m), o.last = {
+					fromCache: n.fromCache === true,
+					definitionReuploaded: n.definitionReuploaded
+				}, t.debug && (a(`[Compute/selva-cache] ${n.fromCache ? `HIT  — served from cache (no compute call)` : `miss — went to Rhino.Compute`} (${Math.round(n.durationMs)}ms)`), n.fromCache || a(n.definitionReuploaded === true ? `[Compute/def-cache] miss — definition RE-UPLOADED (pointer was cold/stale)` : n.definitionReuploaded === false ? `[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, r = Array.isArray(e) ? e.length : 0;
+					if (r > 0) {
+						let n = t.cacheerroredsolves ? `cached (cacheerroredsolves on)` : `not cached (cacheerroredsolves off) — re-run until fixed`;
+						a(`[Compute/rhino-cache] ${r} GH error(s); ${n}. First: ${JSON.stringify(e[0])}`);
+					}
+				}
+			}
+		});
+		return {
+			client: l,
+			scheduler: m,
+			rhinoTiming: i,
+			solveMeta: o
+		};
+	}
+	return {
+		async getClient(e, t) {
+			let s = e.id, c = r.get(s);
+			if (c) return r.delete(s), r.set(s, c), c;
+			let l = i.get(s);
+			if (l) return l;
+			a(`[Compute/client-cache] miss — building warm client for server ${s}`);
+			let u = (async () => {
+				let i = await o(e, t?.definitionGuid);
+				if (r.size >= n) {
+					let e = r.keys().next().value;
+					e !== void 0 && (a(`[Compute/client-cache] LRU evicted warm client for server ${e} (cap ${n})`), r.get(e)?.scheduler.dispose(), r.delete(e));
+				}
+				return r.set(s, i), i;
+			})().finally(() => i.delete(s));
+			return i.set(s, u), u;
+		},
+		evict(e) {
+			let t = e, n = r.get(t);
+			n && (a(`[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() {
+			a(`[Compute/client-cache] cleared solve caches on ${r.size} warm client(s)`);
+			for (let e of r.values()) e.scheduler.clearCache();
+		},
+		disposeAll() {
+			a(`[Compute/client-cache] disposing all ${r.size} warm client(s)`);
+			for (let e of r.values()) e.scheduler.dispose();
+			r.clear();
+		}
+	};
+}
+function C(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: false,
+				fromCache: false
+			};
+			return {
+				key: e,
+				outcome: r,
+				load: async () => {
+					let o = n.get(e);
+					if (o) return a(e, o), i.hits += 1, r.loaded = true, r.fromCache = true, o.bytes;
+					i.misses += 1, r.loaded = true, r.fromCache = false;
+					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 w(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 T(e) {
+	return typeof e == `object` && !!e && !(e instanceof Uint8Array) && `outcome` in e;
+}
+function E(e) {
+	return typeof e == `object` && !!e && !(e instanceof Uint8Array) && !(`outcome` in e) && !(`key` in e) && `versionId` in e;
+}
+var D = class {
+	limits;
+	clientCache;
+	byteCache;
+	singleFlight;
+	constructor(e) {
+		this.limits = e.limits;
+		let t = e.logger ?? new NoopLogger();
+		this.clientCache = S({
+			solveDeadlineMs: this.limits.solveDeadlineMs,
+			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: e.debug ?? false,
+			maxWarmComputeServers: e.maxWarmComputeServers,
+			onDebugLog: e.onDebugLog ?? ((e) => t.debug(e, { component: `Compute/client-cache` }))
+		}), this.byteCache = C(this.limits.computeDefinitionCacheBytes), this.singleFlight = w({ 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();
+	}
+	stats() {
+		return {
+			client: this.clientCache.solveCacheStats(),
+			definitionBytes: this.byteCache.stats(),
+			coalescing: { inFlight: this.singleFlight.inFlight() }
+		};
+	}
+	async solve(e) {
+		let { definitionSource: t, byteRefOutcome: n, identity: r } = this.resolveDefinitionSource(e), a = await this.clientCache.getClient(e.server, { definitionGuid: e.definitionGuid }), o = _(e.inputs, e.values), s = `${r}:${e.server.id}:${S$1(o)}`, c = new AbortController(), l = false, u = () => {
+			l || c.abort();
+		};
+		e.signal.addEventListener(`abort`, u, { once: true });
+		let d = e.acceptEncoding ?? ``, f;
+		try {
+			f = await this.singleFlight.run(s, () => v({
+				definitionSource: t,
+				byteRefOutcome: n,
+				inputs: e.inputs,
+				values: e.values,
+				inputTree: o,
+				client: a,
+				responseMaxBytes: this.limits.computeResponseMaxBytes,
+				solveDeadlineMs: this.limits.solveDeadlineMs,
+				acceptEncoding: d,
+				signal: c.signal,
+				loadStartMs: e.loadStartMs ?? performance.now(),
+				defLoadMs: e.defLoadMs ?? 0,
+				prepMarks: e.prepMarks
+			}), () => {
+				l = !0;
+			});
+		} finally {
+			e.signal.removeEventListener(`abort`, u);
+		}
+		if (f.kind !== `ok`) return f;
+		let p = y(f.envelope, d);
+		return {
+			...f,
+			envelope: {
+				...f.envelope,
+				body: p.body,
+				headers: p.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 (E(t)) {
+			let e = this.byteCache.getOrLoad(t.versionId, t.load);
+			return {
+				definitionSource: e,
+				byteRefOutcome: e.outcome,
+				identity: e.key
+			};
+		}
+		if (T(t)) return {
+			definitionSource: t,
+			byteRefOutcome: t.outcome,
+			identity: t.key
+		};
+		if (U(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
+		};
+	}
+};
+//#endregion
+//#region src/lib/server/compute/engine.server.ts
+/**
+* App-wide `SolveEngine` instance (`@selvajs/solve/server`) — 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`.
+*
+* `SELVA_FLAG_COMPUTE_DEBUG_VERBOSE` merged into this var; still honoured 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";
+})();
+var COMPUTE_DEBUG = COMPUTE_DEBUG_MODE !== "off";
+var engine = new D({
+	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, which 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). */
+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-Ci7yj84d.js.map