@selvajs/solve 2.0.0-beta.9 → 2.0.1

package/dist/client.js

@@ -1,2 +1,969 @@
-import{n as e,r as t,t as n}from"./outcome-BOrAeRAQ.js";import{getDefaultValue as r,getInputItems as i}from"@selvajs/schemas";import{GrasshopperResponseProcessor as a}from"@selvajs/compute/grasshopper";function o(e,t){return`external:${e}:${t}`}function s(e){let{scopeKey:t,inputId:n,value:r}=e;t&&n&&typeof sessionStorage<`u`&&sessionStorage.setItem(o(t,n),JSON.stringify(r))}function c(e){let{scopeKey:t,inputId:n}=e;if(!t||!n||typeof sessionStorage>`u`)return;let r=sessionStorage.getItem(o(t,n));if(r!==null)try{return JSON.parse(r)}catch{return}}function l(e){let{scopeKey:t,inputId:n}=e;t&&n&&typeof sessionStorage<`u`&&sessionStorage.removeItem(o(t,n))}function u(e){return i(e).filter(e=>e.source?.kind===`client`).map(e=>({paramId:e.paramId,displayName:e.displayName??e.paramId}))}const d=Object.freeze({solveId:null,running:!1,diagnostics:[],progress:/* @__PURE__ */ new Map,ended:null,other:[],lastSeq:0});function f(e,t){let r=t.solveId===e.solveId?e:{...d,solveId:t.solveId,running:!0};if(t.seq<=r.lastSeq)return e;let i={...r,lastSeq:t.seq},a=t.payload??{};switch(t.type){case`solveStarted`:return{...i,running:!0};case`solveEnded`:return{...i,running:!1,ended:{kind:typeof a.kind==`string`?a.kind:`ok`}};case`diagnostic`:{let[e]=n({diagnostics:[a]})?.diagnostics??[];return e?{...i,diagnostics:[...i.diagnostics,e]}:i}case`progress`:{let e=typeof a.source==`string`?a.source:``,t=new Map(i.progress),n=p(a),r=i.progress.get(e)?.fraction;return r!==void 0&&n.fraction!==void 0&&n.fraction<r&&(n.fraction=r),t.set(e,n),{...i,progress:t}}default:return{...i,other:[...i.other,t]}}}function p(e){let t=e=>typeof e==`number`&&Number.isFinite(e)?e:void 0,n=t(e.fraction),r=t(e.done),i=t(e.total),a=t(e.nextFraction),o=t(e.stepMs),s=e=>Math.min(1,Math.max(0,e));return{...typeof e.source==`string`?{source:e.source}:{},...n===void 0?{}:{fraction:s(n)},...r===void 0?{}:{done:r},...i===void 0?{}:{total:i},...typeof e.label==`string`?{label:e.label}:{},...a===void 0?{}:{nextFraction:s(a)},...o!==void 0&&o>0?{stepMs:o}:{}}}function m(e,t,n){let i=new Set(u(e).map(e=>e.paramId)),a={};for(let o of e.inputs)if(i.has(o.id)){let e=n({scopeKey:t,inputId:o.id});e!==void 0&&(a[o.id]=e)}else a[o.id]=o.default??r(o.paramType);for(let t of e.outputs)a[t.id]=null;return a}function h(e){let t=e===!1;return{hasPendingChanges:t,hasNeverSolved:t}}function g(e,t,n,r){return e.values[t]=n,r===!1?(e.pendingValues[t]=n,e.hasPendingChanges=!0,{state:e,shouldSolve:!1}):{state:e,shouldSolve:!0}}function _(e,t){if(!e?.inputs)return t;let n={};for(let r of e.inputs)r.id in t&&(n[r.id]=t[r.id]);return n}function v(e,t){return e.error=``,e.computeErrors=t.errors??[],e.computeWarnings=t.warnings??[],e.diagnostics=t.diagnostics??[],e.blocked=t.blocked??!1,e.blocked?(e.awaitingAck=!1,e.heldResult=null,b(e,t)):S(e.diagnostics)?(e.awaitingAck=!0,e.heldResult=t,e.pendingValues={},e.hasPendingChanges=!1,e):(e.awaitingAck=!1,e.heldResult=null,b(e,t))}function y(e){let t={};for(let n of e?.outputs??[])t[n.id]=null;return t}function b(e,t){e.meshes=t.meshes??[];let{meshes:n,...r}=t;return e.lastResult=r,Object.assign(e.values,t.outputs),e.pendingValues={},e.hasPendingChanges=!1,e.hasNeverSolved=!1,e}function x(e,t){return t?`solving`:e.awaitingAck?`review`:e.blocked?`blocked`:`idle`}function S(e){return(e??[]).some(e=>e.isGate&&e.level!==`remark`)}function C(e){let t=e.schema,n=h(t?.instanceSolve),r={values:m(t,e.scopeKey,c),error:``,computeErrors:[],computeWarnings:[],diagnostics:[],blocked:!1,awaitingAck:!1,heldResult:null,meshes:[],pendingValues:{},hasPendingChanges:n.hasPendingChanges,hasNeverSolved:n.hasNeverSolved,lastResult:null},i=/* @__PURE__ */ new Set,a=()=>i.forEach(e=>e()),o=/* @__PURE__ */ new Set,s=[],l={status:`aborted`,diagnostics:[]};function u(){return new Promise(e=>s.push(e))}function p(e){let t=s;s=[],t.forEach(t=>t(e)),o.forEach(t=>t(e))}function S(){let e=s;s=[],e.forEach(e=>e(l))}function C(e){let t=r.diagnostics;if(e.aborted)return p({status:`aborted`,diagnostics:t});if(e.blocked)return p({status:`blocked`,diagnostics:t});p({status:`applied`,result:r.lastResult,diagnostics:t})}let w=d,T=e.driver.onEvent?.(e=>{let t=f(w,e);t!==w&&(w=t,a())});function E(){let e=u();return D(),e}function D(){e.driver.solve({..._(t,r.values)}),a()}return{get values(){return r.values},get error(){return r.error},get computeErrors(){return r.computeErrors},get computeWarnings(){return r.computeWarnings},get diagnostics(){return r.diagnostics},get blocked(){return r.blocked},get awaitingAck(){return r.awaitingAck},acknowledge(){if(!r.awaitingAck)return;let e=r.heldResult;r.awaitingAck=!1,r.heldResult=null,e&&b(r,e),a(),e&&C(e)},discard(){r.awaitingAck&&(r.awaitingAck=!1,r.heldResult=null,a(),p({status:`discarded`,diagnostics:r.diagnostics}))},get live(){return w},get phase(){return x(r,e.driver.isSolving)},abort(){e.driver.cancel()},get meshes(){return r.meshes},get lastResult(){return r.lastResult},get hasPendingChanges(){return r.hasPendingChanges},get hasNeverSolved(){return r.hasNeverSolved},get isSolving(){return e.driver.isSolving},setValue(e,n,i=!1){let{shouldSolve:o}=g(r,e,n,t?.instanceSolve);o||i?(i&&!o&&(r.pendingValues={},r.hasPendingChanges=!1),D()):a()},solve:E,ensureSolved(){return e.driver.isSolving||e.driver.hasQueued||r.awaitingAck?u():r.hasPendingChanges||r.hasNeverSolved||r.error||!r.lastResult?E():r.blocked?Promise.resolve({status:`blocked`,diagnostics:r.diagnostics}):Promise.resolve({status:`applied`,result:r.lastResult,diagnostics:r.diagnostics})},onSettled(e){return o.add(e),()=>o.delete(e)},loadValues(e){Object.assign(r.values,e),t?.instanceSolve===!1?(r.hasPendingChanges=!0,a()):D()},rebuild(n,i){S(),t=n,e.driver.clearCache?.(),r.meshes=[],r.lastResult=null,r.error=``,r.computeErrors=[],r.computeWarnings=[],r.diagnostics=[],r.blocked=!1,r.awaitingAck=!1,r.heldResult=null,r.pendingValues={},r.values=m(n,i,c);let o=h(n?.instanceSolve);r.hasPendingChanges=o.hasPendingChanges,r.hasNeverSolved=o.hasNeverSolved,n&&Object.keys(r.values).length>0&&n.instanceSolve!==!1?D():a()},report(n){v(r,n.blocked||n.aborted?{...n,outputs:y(t),meshes:[]}:n),a(),!(r.awaitingAck||e.driver.hasQueued)&&C(n)},reportError(t){r.error=t,a(),e.driver.hasQueued||p({status:`failed`,error:t})},reportAborted(){a(),e.driver.hasQueued||p(l)},subscribe(e){return i.add(e),()=>i.delete(e)},notify:a,dispose(){T?.(),i.clear(),o.clear(),S()}}}function w(e,t){let{runDeadlineMs:n,onChange:r}=t,i=!1,a=null,o=null;function s(e){i!==e&&(i=e,r?.())}function c(){o?.abort(),o=null}async function l(t){c(),o=new AbortController;let{signal:r}=o,i=setTimeout(()=>{console.warn(`[Solve/throttle] run exceeded ${n}ms — aborting`),o?.abort(new DOMException(`Run deadline exceeded`,`TimeoutError`))},n);s(!0);try{await e(t,r)}catch(e){(!(e instanceof Error)||e.name!==`AbortError`&&e.name!==`TimeoutError`)&&console.error(`[Solve/throttle] unhandled error in run:`,e)}finally{if(clearTimeout(i),s(!1),o=null,a!==null){let e=a;a=null,l(e)}}}function u(e){i?(a!==null&&console.debug(`[Solve/throttle] superseded pending run (latest-wins)`),a=e):l(e)}function d(){a=null,c()}return{trigger:u,get isRunning(){return i},get hasPending(){return a!==null},cancel:d}}function T(e){return E(e)}function E(e){if(typeof e!=`object`||!e)return JSON.stringify(e)??`null`;if(Array.isArray(e))return`[${e.map(E).join(`,`)}]`;let t=e;return`{${Object.keys(t).sort().map(e=>`${JSON.stringify(e)}:${E(t[e])}`).join(`,`)}}`}function D(e={}){let{max:t=16,meshPolicy:n}=e,r=/* @__PURE__ */ new Map;function i(e){e.meshes?.length&&n?.release(e.meshes)}function a(e){return!n||!e.meshes?.length?e:{...e,meshes:n.clone(e.meshes)}}function o(e){let t=r.get(e);t!==void 0&&(r.delete(e),i(t))}return{get(e){let n=T(e),i=r.get(n);if(i!==void 0)return r.delete(n),r.set(n,i),console.info(`[Solve/memo] HIT — served from client memo (${r.size}/${t})`),a(i)},set(e,n){let i=T(e);for(o(i),r.set(i,a(n));r.size>t;){let e=r.keys().next().value;if(e===void 0)break;o(e),console.info(`[Solve/memo] evicted LRU entry (cap ${t})`)}},clear(){r.size>0&&console.info(`[Solve/memo] cleared ${r.size} entries (definition changed)`),r.forEach(i),r.clear()}}}function O(e,t,n){let{meshPolicy:r,solveDeadlineMs:i,onChange:a,events:o}=n,s=D({meshPolicy:r});function c(e){e.reason?.name===`TimeoutError`?t().reportError(`The solve took longer than ${Math.round(i/1e3)} s and was stopped.`):t().reportAborted()}let l=w(async(n,r)=>{let i=s.get(n);if(i!==void 0){if(r.aborted)return c(r);t().report(i)}else try{let i=await e(n,r);if(r.aborted)return console.debug(`[Solve/driver] solve completed after abort — result discarded`),c(r);let a={...i,values:n};s.set(n,a),t().report(a)}catch(e){if(r.aborted)return console.debug(`[Solve/driver] solve aborted (cancelled or timed out)`),c(r);console.warn(`[Solve/driver] solve failed:`,e),t().reportError(e instanceof Error?e.message:String(e))}},{runDeadlineMs:i,onChange:a});return{solve(e){l.trigger(e)},cancel(){l.cancel(),o?.cancelCurrent?.()},get isSolving(){return l.isRunning},get hasQueued(){return l.hasPending},clearCache(){s.clear()},...o?{onEvent:e=>o.subscribe(e)}:{}}}function k(){return typeof crypto<`u`&&`randomUUID`in crypto?crypto.randomUUID().replace(/-/g,``):Array.from({length:32},()=>Math.floor(Math.random()*16).toString(16)).join(``)}function A(e){let t=k(),n=/* @__PURE__ */ new Set,r=e.fetch??((...e)=>fetch(...e)),i=null,a=null;function o(){if(i||typeof EventSource>`u`)return;let r=`${e.endpoint}${e.endpoint.includes(`?`)?`&`:`?`}streamId=${t}`;i=new EventSource(r),i.addEventListener(`solve`,e=>{let t;try{t=JSON.parse(e.data)}catch{return}t.type===`solveStarted`?a=t.solveId:t.type===`solveEnded`&&a===t.solveId&&(a=null);for(let e of n)e(t)})}return o(),{streamId:t,get currentSolveId(){return a},subscribe(e){return n.add(e),o(),()=>{n.delete(e)}},cancelCurrent(){let t=a;t&&r(e.cancelEndpoint(t),{method:`POST`,keepalive:!0}).catch(()=>{})},close(){i?.close(),i=null,n.clear(),a=null}}}function j(e){let t={};if(!e)return t;for(let n of e.split(`,`)){let[e,...r]=n.split(`;`).map(e=>e.trim()),i=r.find(e=>e.startsWith(`dur=`));if(!e||!i)continue;let a=Number(i.slice(4));Number.isFinite(a)&&(t[e]=a)}return t}const M=e=>{throw Error(`Rate limit reached. Try again in ${Math.ceil(e)}s.`)},N=()=>{throw Error(`Your session has expired. Sign in again in a new tab, then re-run — your inputs are preserved.`)};function P(r){let i=r.debug??!1,o=(...e)=>{i&&console.info(...e)},s=0;return async(c,l)=>{let u=s-Date.now();if(u>0)throw Error(`Rate limit reached. Try again in ${Math.ceil(u/1e3)}s.`);let d=performance.now(),f=r.inputs(),p=r.outputs(),m=r.channel?.(),h=r.versionId?.(),g=r.streamId?.(),_=JSON.stringify({inputs:f,values:c,definitionUrl:r.definitionUrl(),...h?{versionId:h}:m===`draft`?{channel:`draft`}:{},...g?{streamId:g}:{}}),v;try{v=await fetch(r.endpoint,{method:`POST`,headers:{"Content-Type":`application/json`},body:_,signal:l})}catch(e){if(l.aborted)return o(`[Compute] solve aborted during fetch — empty result discarded`),{outputs:{}};throw Error(`Request blocked — your session may have expired. Reload the page to sign in again.`,{cause:e})}if(l.aborted)return o(`[Compute] solve aborted after headers — empty result discarded`),{outputs:{}};let y=v.redirected&&new URL(v.url).pathname===`/login`;if((v.status===401||y)&&(r.onSessionExpired??N)(),!v.ok){let e=await v.text().catch(()=>``),t={};try{t=JSON.parse(e)}catch{e&&console.warn(`[Compute] non-JSON error body (HTTP ${v.status}):`,e.slice(0,300))}if(v.status===503||v.status===504)throw Error(t.message||`Compute server is offline or unreachable. Please try again later.`);if(v.status===429){let e=Number(v.headers.get(`Retry-After`))||Number(t.retryAfter)||5;s=Date.now()+e*1e3,(r.onRateLimited??M)(e)}throw Error(t.message||`Compute error (HTTP ${v.status})`)}let b=performance.now()-d,x=performance.now(),S=await v.text();if(l.aborted)return o(`[Compute] solve aborted mid-download — empty result discarded`),{outputs:{}};let C=performance.now()-x,w=S.length,T;try{T=JSON.parse(S)}catch(e){throw Error(`Received an invalid response from the server. Reload the page and try again.`,{cause:e})}let E=new a(T),D=n(T.selva?.outcome)??t(T.errors??[],T.warnings??[]),O=D.blocked||D.aborted,k=r.meshes&&!O?await r.meshes.extract(E.response,{debug:i}):[],A={};for(let e of O?[]:p){let t=E.getValue({byId:e.id},{parseValues:!0});A[e.id]=t??(e.nickname?E.getValue({byName:e.nickname},{parseValues:!0}):void 0)}if(i){let e=JSON.stringify(c).length,t=j(v.headers.get(`Server-Timing`)),n=t.total??0,r=Math.max(0,b-n),i=w/1048576,a=i>=1?`${i.toFixed(2)} MB`:`${(w/1024).toFixed(0)} KB`,s=C>0?(i/(C/1e3)).toFixed(1):`∞`,l=performance.memory?.usedJSHeapSize,u=l===void 0?``:` | heap=${(l/1048576).toFixed(0)} MB`;if(o(`[Compute] req=${(_.length/1024).toFixed(0)}KB (values ${(e/1024).toFixed(0)}KB) | ttfb=${b.toFixed(0)}ms (network≈${r.toFixed(0)} + server ${n.toFixed(0)}) | download=${C.toFixed(0)}ms (${a} @ ${s} MB/s)${u}`),t.selva_cache!==void 0){let e=t.selva_cache?`HIT — served without calling compute`:t.rhino_cache?`HIT — Rhino.Compute's result cache, solved nothing`:`miss — solved on Rhino.Compute`;o(`[Compute]   └─ cache: ${e}`)}}return e({outputs:A,meshes:k,source:T},D)}}export{d as EMPTY_LIVE_SOLVE,v as applySolveResult,g as applyValueChange,m as buildInitialValues,l as clearExternalValue,w as createAsyncThrottle,P as createComputeFetchSolveFn,O as createRequestResponseDriver,A as createSolveEventStream,D as createSolveMemo,C as createSolveSession,n as decodeOutcome,e as finalizeResult,u as getExternalInputs,h as makeInitialFlags,_ as pickInputValues,c as readExternalValue,f as reduceLiveSolve,x as solvePhase,T as stableInputKey,s as writeExternalValue};
+import { i as outcomeFromComputeMessages, n as decodeOutcome, r as finalizeResult, t as decodeDiagnostic } from "./outcome-DNrffAXp.js";
+import { t as raceAbort } from "./abort-CNJ8Sn4g.js";
+import { getDefaultValue, getInputItems } from "@selvajs/schemas";
+import { GrasshopperResponseProcessor } from "@selvajs/compute/grasshopper";
+// src/client/external-storage.ts
+const STORAGE_PREFIX = "external";
+/** Null without a usable store. Merely reading `sessionStorage` throws when the browser blocks it. */
+function openSlot(ref) {
+	if (!ref.scopeKey || !ref.inputId) return null;
+	try {
+		if (typeof sessionStorage === "undefined") return null;
+		return {
+			storage: sessionStorage,
+			key: `${STORAGE_PREFIX}:${ref.scopeKey}:${ref.inputId}`
+		};
+	} catch {
+		return null;
+	}
+}
+function writeExternalValue(args) {
+	const slot = openSlot(args);
+	if (!slot) return;
+	try {
+		slot.storage.setItem(slot.key, JSON.stringify(args.value));
+	} catch (err) {
+		console.warn("[Solve/storage] could not store an external value:", err);
+	}
+}
+function readExternalValue(ref) {
+	const slot = openSlot(ref);
+	if (!slot) return void 0;
+	const raw = slot.storage.getItem(slot.key);
+	if (raw === null) return void 0;
+	try {
+		return JSON.parse(raw);
+	} catch {
+		return;
+	}
+}
+function clearExternalValue(ref) {
+	const slot = openSlot(ref);
+	slot?.storage.removeItem(slot.key);
+}
+function getExternalInputs(schema) {
+	return getInputItems(schema).filter((item) => item.source?.kind === "client").map((item) => ({
+		paramId: item.paramId,
+		displayName: item.displayName ?? item.paramId
+	}));
+}
+// src/client/events/live-solve.ts
+const EMPTY_LIVE_SOLVE = Object.freeze({
+	solveId: null,
+	running: false,
+	diagnostics: [],
+	progress: /* @__PURE__ */ new Map(),
+	ended: null,
+	other: [],
+	lastSeq: 0
+});
+function readEndedKind(payload) {
+	const { kind } = payload;
+	return kind === "ok" || kind === "blocked" || kind === "aborted" ? kind : "error";
+}
+function reduceLiveSolve(state, event) {
+	if (event.type === "solveEnded" && state.solveId !== null && event.solveId !== state.solveId) return state;
+	const base = event.solveId === state.solveId ? state : {
+		...EMPTY_LIVE_SOLVE,
+		solveId: event.solveId,
+		running: true
+	};
+	if (event.seq <= base.lastSeq) return state;
+	const next = {
+		...base,
+		lastSeq: event.seq
+	};
+	const payload = event.payload ?? {};
+	switch (event.type) {
+		case "solveStarted": return {
+			...next,
+			running: true
+		};
+		case "solveEnded": return {
+			...next,
+			running: false,
+			ended: { kind: readEndedKind(payload) }
+		};
+		case "diagnostic": {
+			const diagnostic = decodeDiagnostic(payload);
+			return diagnostic ? {
+				...next,
+				diagnostics: [...next.diagnostics, diagnostic]
+			} : next;
+		}
+		case "progress": {
+			const source = typeof payload.source === "string" ? payload.source : "";
+			const progress = new Map(next.progress);
+			const report = readProgress(payload);
+			const previous = next.progress.get(source)?.fraction;
+			if (previous !== void 0 && (report.fraction ?? 0) < previous) report.fraction = previous;
+			progress.set(source, report);
+			return {
+				...next,
+				progress
+			};
+		}
+		default: return {
+			...next,
+			other: [...next.other, event]
+		};
+	}
+}
+function readProgress(payload) {
+	const num = (v) => typeof v === "number" && Number.isFinite(v) ? v : void 0;
+	const fraction = num(payload.fraction);
+	const done = num(payload.done);
+	const total = num(payload.total);
+	const nextFraction = num(payload.nextFraction);
+	const stepMs = num(payload.stepMs);
+	const clamp = (v) => Math.min(1, Math.max(0, v));
+	return {
+		...typeof payload.source === "string" ? { source: payload.source } : {},
+		...fraction !== void 0 ? { fraction: clamp(fraction) } : {},
+		...done !== void 0 ? { done } : {},
+		...total !== void 0 ? { total } : {},
+		...typeof payload.label === "string" ? { label: payload.label } : {},
+		...nextFraction !== void 0 ? { nextFraction: clamp(nextFraction) } : {},
+		...stepMs !== void 0 && stepMs > 0 ? { stepMs } : {}
+	};
+}
+// src/client/session/solve-session-core.ts
+/**
+* Client-sourced inputs are hydrated from `read` and left absent when no stored value
+* exists, so the missing-inputs panel can detect them. Other inputs fall back to their
+* declared default, then the paramType default.
+*/
+function buildInitialValues(schema, scopeKey, read) {
+	const clientSet = new Set(getExternalInputs(schema).map((e) => e.paramId));
+	const values = {};
+	for (const input of schema.inputs) {
+		if (clientSet.has(input.id)) {
+			const stored = read({
+				scopeKey,
+				inputId: input.id
+			});
+			if (stored !== void 0) values[input.id] = stored;
+			continue;
+		}
+		values[input.id] = input.default ?? getDefaultValue(input.paramType);
+	}
+	for (const output of schema.outputs) values[output.id] = null;
+	return values;
+}
+/** Manual-solve schemas (instanceSolve === false) start dirty; auto-solve schemas start clean. */
+function createInitialState(schema, scopeKey, read) {
+	const manual = schema.instanceSolve === false;
+	return {
+		values: buildInitialValues(schema, scopeKey, read),
+		error: "",
+		computeErrors: [],
+		computeWarnings: [],
+		diagnostics: [],
+		blocked: false,
+		heldResult: null,
+		meshes: [],
+		hasPendingChanges: manual,
+		hasNeverSolved: manual,
+		lastResult: null,
+		unsolved: null
+	};
+}
+/**
+* Whether the change should dispatch. Manual mode defers and raises the dirty flag instead;
+* `force` overrides that, and what it solves is every pending edit.
+*/
+function applyValueChange(state, id, value, instanceSolve, force = false) {
+	state.values[id] = value;
+	if (instanceSolve !== false) return true;
+	state.hasPendingChanges = !force;
+	return force;
+}
+/** Same rule as `applyValueChange`, for a whole set. Whether it should dispatch. */
+function applyLoadedValues(state, incoming, instanceSolve) {
+	Object.assign(state.values, incoming);
+	if (instanceSolve !== false) return true;
+	state.hasPendingChanges = true;
+	return false;
+}
+const RESEND_UNCHANGED = /* @__PURE__ */ new Set(["dynamicValueList", "file"]);
+/**
+* Whether setting `value` would solve again for nothing: it is what the last solve sent and what
+* the session holds, and nothing failed or aborted since (`lastSent` is null then). A field that
+* reports on input and again on blur would otherwise solve twice, and Grasshopper re-applies every
+* dynamic list on each update, so the repeat is a real solve. Objects never count as repeats.
+*/
+function isRepeatOfLastSolve(schema, lastSent, values, id, value) {
+	if (!lastSent || !(id in lastSent)) return false;
+	if (value !== null && typeof value === "object") return false;
+	if (!Object.is(lastSent[id], value) || !Object.is(values[id], value)) return false;
+	const paramType = schema.inputs.find((input) => input.id === id)?.paramType;
+	return !RESEND_UNCHANGED.has(paramType ?? "");
+}
+/**
+* Solve outputs live in the same `values` map as inputs (so widgets like dynamic value
+* lists can read them) but must not be echoed back to the driver: a measured 6.4 MB
+* options-list output showed this can re-upload a multi-MB payload no backend reads.
+*/
+function pickInputValues(schema, values) {
+	const picked = {};
+	for (const input of schema.inputs) if (Object.hasOwn(values, input.id)) picked[input.id] = values[input.id];
+	return picked;
+}
+/** An input was edited after `sent` was dispatched, so a result for `sent` does not cover it. */
+function inputsChangedSince(schema, values, sent) {
+	if (!sent) return false;
+	const current = pickInputValues(schema, values);
+	return Object.keys(current).some((id) => !Object.hasOwn(sent, id) || !Object.is(current[id], sent[id]));
+}
+/**
+* `editedSinceSent` keeps the dirty flag for a value changed while the solve ran: its result
+* answers the older value, and clearing the flag would hide the Calculate prompt on a stale answer.
+*/
+function applySolveResult(state, result, editedSinceSent) {
+	state.error = "";
+	state.computeErrors = result.errors ?? [];
+	state.computeWarnings = result.warnings ?? [];
+	state.diagnostics = result.diagnostics ?? [];
+	state.blocked = result.blocked ?? false;
+	state.unsolved = result.aborted ? "aborted" : null;
+	if (!state.blocked && needsAcknowledgement(state.diagnostics)) {
+		state.heldResult = result;
+		state.hasPendingChanges &&= editedSinceSent;
+		return;
+	}
+	state.heldResult = null;
+	commitSolveResult(state, result, editedSinceSent);
+}
+/**
+* Every schema output set to null. A blocked solve reports `outputs: {}`, and merging that into
+* `values` would leave the previous solve's outputs behind.
+*/
+function blankOutputs(schema) {
+	const blank = {};
+	for (const output of schema.outputs) blank[output.id] = null;
+	return blank;
+}
+/** Writes a result into the state. Shared by the clean path and by `acknowledge()`. */
+function commitSolveResult(state, result, editedSinceSent) {
+	state.meshes = result.meshes ?? [];
+	const { meshes: _meshes, ...retained } = result;
+	state.lastResult = retained;
+	Object.assign(state.values, result.outputs);
+	state.hasPendingChanges &&= editedSinceSent;
+	state.hasNeverSolved = false;
+}
+/** `busy`: the driver is solving or has a solve queued. */
+function ensureSolvedStep(state, busy) {
+	if (busy || state.heldResult) return "wait";
+	if (state.hasPendingChanges) return "solve";
+	if (state.unsolved === "discarded") return "discarded";
+	if (state.unsolved || state.hasNeverSolved || state.error || !state.lastResult) return "solve";
+	return state.blocked ? "blocked" : "applied";
+}
+/**
+* One value for what a host should show. Solving wins: a new solve supersedes a held or refused
+* result. `isSolving` is passed in because the driver owns it.
+*/
+function solvePhase(state, isSolving) {
+	if (isSolving) return "solving";
+	if (state.heldResult) return "review";
+	if (state.blocked) return "blocked";
+	return "idle";
+}
+/**
+* Whether this solve's messages still need the user's acknowledgement.
+*
+* Only a Selva Message component gates. Grasshopper raises warnings constantly for reasons that
+* concern whoever is editing the definition, not whoever is using the app — a component
+* complaining about its own inputs is not something an end user can act on, and interrupting
+* them for it trains them to dismiss the one message that mattered.
+*
+* Every solve that gates asks again, by design — an acknowledgement covers the solve in front of
+* the user, never a future one. Under `instanceSolve` with a live warning that means a dialog
+* per solve, which is the intended checkpoint, not an oversight.
+*
+* A transport that reports no structure has no diagnostics, so nothing gates: the messages are
+* still shown, just without interrupting.
+*/
+function needsAcknowledgement(diagnostics) {
+	return diagnostics.some((d) => d.isGate && d.level !== "remark");
+}
+// src/client/session/solve-session.ts
+/** One listener's bug must not cost the others their update, or strand a solve mid-landing. */
+function notifyAll(listeners, value) {
+	for (const listener of [...listeners]) try {
+		listener(value);
+	} catch (err) {
+		console.error("[Solve/session] listener threw:", err);
+	}
+}
+function createSolveSession(args) {
+	let currentSchema = args.schema;
+	let lastSent = null;
+	let lastDispatched = null;
+	const state = createInitialState(currentSchema, args.scopeKey, readExternalValue);
+	let disposed = false;
+	const listeners = /* @__PURE__ */ new Set();
+	const emit = () => notifyAll(listeners, void 0);
+	const settledListeners = /* @__PURE__ */ new Set();
+	let waiters = [];
+	const ABORTED = {
+		status: "aborted",
+		diagnostics: []
+	};
+	function nextSettlement() {
+		if (disposed) return Promise.resolve(ABORTED);
+		return new Promise((resolve) => waiters.push(resolve));
+	}
+	function settle(settlement) {
+		const waiting = waiters;
+		waiters = [];
+		waiting.forEach((resolve) => resolve(settlement));
+		notifyAll(settledListeners, settlement);
+	}
+	/** Resolves waiting callers without telling listeners: no solve ended, the session moved on. */
+	function abandon() {
+		const waiting = waiters;
+		waiters = [];
+		waiting.forEach((resolve) => resolve(ABORTED));
+	}
+	function settlementOf(result) {
+		const diagnostics = state.diagnostics;
+		if (result.aborted) return {
+			status: "aborted",
+			diagnostics
+		};
+		if (result.blocked) return {
+			status: "blocked",
+			diagnostics
+		};
+		return {
+			status: "applied",
+			result: state.lastResult,
+			diagnostics
+		};
+	}
+	/** One solve ended. Tells subscribers, then settles unless a queued solve is about to replace it. */
+	function land(settlement) {
+		emit();
+		if (!args.driver.hasQueued) settle(settlement());
+	}
+	/**
+	* Waiters stay: `solve()` resolves with what lands, and that is now the newer solve. Only
+	* listeners hear of it, so the dropped solve still settles exactly once.
+	*/
+	function dropHeld() {
+		if (!state.heldResult) return;
+		state.heldResult = null;
+		notifyAll(settledListeners, {
+			status: "discarded",
+			diagnostics: state.diagnostics
+		});
+	}
+	function editedSinceSent() {
+		return inputsChangedSince(currentSchema, state.values, lastDispatched);
+	}
+	let live = EMPTY_LIVE_SOLVE;
+	const stopEvents = args.driver.onEvent?.((event) => {
+		const next = reduceLiveSolve(live, event);
+		if (next === live) return;
+		live = next;
+		emit();
+	});
+	function solve() {
+		const settled = nextSettlement();
+		dispatch();
+		return settled;
+	}
+	function dispatch() {
+		if (disposed) return;
+		dropHeld();
+		lastSent = { ...pickInputValues(currentSchema, state.values) };
+		lastDispatched = lastSent;
+		args.driver.solve(lastSent);
+		emit();
+	}
+	return {
+		get values() {
+			return state.values;
+		},
+		get error() {
+			return state.error;
+		},
+		get computeErrors() {
+			return state.computeErrors;
+		},
+		get computeWarnings() {
+			return state.computeWarnings;
+		},
+		get diagnostics() {
+			return state.diagnostics;
+		},
+		get blocked() {
+			return state.blocked;
+		},
+		get awaitingAck() {
+			return state.heldResult !== null;
+		},
+		acknowledge() {
+			const held = state.heldResult;
+			if (!held) return;
+			state.heldResult = null;
+			commitSolveResult(state, held, editedSinceSent());
+			land(() => settlementOf(held));
+		},
+		discard() {
+			if (!state.heldResult) return;
+			state.heldResult = null;
+			state.unsolved = "discarded";
+			land(() => ({
+				status: "discarded",
+				diagnostics: state.diagnostics
+			}));
+		},
+		get live() {
+			return live;
+		},
+		get phase() {
+			return solvePhase(state, args.driver.isSolving);
+		},
+		abort() {
+			args.driver.cancel();
+		},
+		get meshes() {
+			return state.meshes;
+		},
+		get lastResult() {
+			return state.lastResult;
+		},
+		get hasPendingChanges() {
+			return state.hasPendingChanges;
+		},
+		get hasNeverSolved() {
+			return state.hasNeverSolved;
+		},
+		get isSolving() {
+			return args.driver.isSolving;
+		},
+		setValue(id, value, forceSolve = false) {
+			if (!forceSolve && isRepeatOfLastSolve(currentSchema, lastSent, state.values, id, value)) return;
+			if (applyValueChange(state, id, value, currentSchema.instanceSolve, forceSolve)) dispatch();
+			else emit();
+		},
+		solve,
+		ensureSolved() {
+			const busy = args.driver.isSolving || args.driver.hasQueued === true;
+			const step = ensureSolvedStep(state, busy);
+			if (step === "wait") return nextSettlement();
+			if (step === "solve") return solve();
+			if (step === "applied") return Promise.resolve({
+				status: step,
+				result: state.lastResult,
+				diagnostics: state.diagnostics
+			});
+			return Promise.resolve({
+				status: step,
+				diagnostics: state.diagnostics
+			});
+		},
+		onSettled(listener) {
+			settledListeners.add(listener);
+			return () => settledListeners.delete(listener);
+		},
+		loadValues(incoming) {
+			if (applyLoadedValues(state, incoming, currentSchema.instanceSolve)) dispatch();
+			else emit();
+		},
+		rebuild(schema, scopeKey) {
+			if (disposed) return;
+			abandon();
+			currentSchema = schema;
+			lastSent = null;
+			lastDispatched = null;
+			args.driver.reset?.();
+			Object.assign(state, createInitialState(schema, scopeKey, readExternalValue));
+			if (Object.keys(state.values).length > 0 && schema.instanceSolve !== false) dispatch();
+			else emit();
+		},
+		report(result) {
+			const rejected = result.blocked || result.aborted;
+			const edited = result.aborted === true || editedSinceSent();
+			if (result.aborted) lastSent = null;
+			applySolveResult(state, rejected ? {
+				...result,
+				outputs: blankOutputs(currentSchema),
+				meshes: []
+			} : result, edited);
+			if (args.driver.hasQueued) state.heldResult = null;
+			if (state.heldResult) return emit();
+			land(() => settlementOf(result));
+		},
+		reportError(message) {
+			dropHeld();
+			lastSent = null;
+			state.error = message;
+			state.unsolved = null;
+			land(() => ({
+				status: "failed",
+				error: message
+			}));
+		},
+		reportAborted() {
+			lastSent = null;
+			state.unsolved = "aborted";
+			land(() => ABORTED);
+		},
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		},
+		notify: emit,
+		dispose() {
+			disposed = true;
+			stopEvents?.();
+			listeners.clear();
+			settledListeners.clear();
+			args.driver.reset?.();
+			abandon();
+		}
+	};
+}
+// src/client/async-throttle.ts
+/** `run` must settle once its signal fires: the slot frees only then. */
+function createAsyncThrottle(run, options) {
+	const { runDeadlineMs, onChange } = options;
+	let isRunning = false;
+	let pendingValues = null;
+	let currentAbortController = null;
+	function setRunning(next) {
+		if (isRunning === next) return;
+		isRunning = next;
+		try {
+			onChange?.();
+		} catch (err) {
+			console.error("[Solve/throttle] onChange threw:", err);
+		}
+	}
+	async function execute(values) {
+		const controller = new AbortController();
+		currentAbortController = controller;
+		const deadlineId = setTimeout(() => {
+			console.warn(`[Solve/throttle] run exceeded ${runDeadlineMs}ms — aborting`);
+			controller.abort(new DOMException("Run deadline exceeded", "TimeoutError"));
+		}, runDeadlineMs);
+		setRunning(true);
+		try {
+			await run(values, controller.signal);
+		} catch (err) {
+			if (!(err instanceof Error) || err.name !== "AbortError" && err.name !== "TimeoutError") console.error("[Solve/throttle] unhandled error in run:", err);
+		} finally {
+			clearTimeout(deadlineId);
+			if (currentAbortController === controller) currentAbortController = null;
+			setRunning(false);
+			if (pendingValues !== null && !isRunning) {
+				const next = pendingValues;
+				pendingValues = null;
+				execute(next);
+			}
+		}
+	}
+	function trigger(values) {
+		if (isRunning) {
+			if (pendingValues !== null) console.debug("[Solve/throttle] superseded pending run (latest-wins)");
+			pendingValues = values;
+		} else execute(values);
+	}
+	function cancel() {
+		pendingValues = null;
+		currentAbortController?.abort();
+		currentAbortController = null;
+	}
+	return {
+		trigger,
+		get isRunning() {
+			return isRunning;
+		},
+		get hasPending() {
+			return pendingValues !== null;
+		},
+		cancel
+	};
+}
+// src/client/solve-memo.ts
+/**
+* Deterministic string key for a set of input values. Sorts object keys at every level so
+* two logically-equal inputs built in different key order collide. Otherwise matches what
+* `JSON.stringify` sends: `toJSON` is honoured and an `undefined` property is absent, which a
+* server treats differently from `null`.
+*
+* Throws on a `bigint`, as `JSON.stringify` does.
+*/
+function stableInputKey(input) {
+	const value = input !== null && typeof input === "object" && typeof input.toJSON === "function" ? input.toJSON() : input;
+	if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null";
+	if (Array.isArray(value)) return `[${value.map(stableInputKey).join(",")}]`;
+	const obj = value;
+	return `{${Object.keys(obj).filter((k) => obj[k] !== void 0).sort().map((k) => `${JSON.stringify(k)}:${stableInputKey(obj[k])}`).join(",")}}`;
+}
+function createSolveMemo(options = {}) {
+	const { max = 16, meshPolicy } = options;
+	const entries = /* @__PURE__ */ new Map();
+	function release(result) {
+		if (result.meshes?.length) meshPolicy?.release(result.meshes);
+	}
+	function copy(result) {
+		if (!meshPolicy || !result.meshes?.length) return result;
+		return {
+			...result,
+			meshes: meshPolicy.clone(result.meshes)
+		};
+	}
+	function evict(key) {
+		const entry = entries.get(key);
+		if (entry === void 0) return;
+		entries.delete(key);
+		release(entry);
+	}
+	return {
+		get(values) {
+			const key = stableInputKey(values);
+			const hit = entries.get(key);
+			if (hit === void 0) return void 0;
+			entries.delete(key);
+			entries.set(key, hit);
+			console.debug(`[Solve/memo] HIT — served from client memo (${entries.size}/${max})`);
+			return copy(hit);
+		},
+		set(values, result) {
+			const key = stableInputKey(values);
+			evict(key);
+			entries.set(key, copy(result));
+			for (const oldest of entries.keys()) {
+				if (entries.size <= max) break;
+				evict(oldest);
+			}
+		},
+		clear() {
+			entries.forEach(release);
+			entries.clear();
+		}
+	};
+}
+// src/client/drivers/request-response.ts
+/**
+* `getReporter` is lazy (`() => session`) because the session and driver reference each
+* other — the host builds the driver first, then the session, then can hand this back.
+*/
+function createRequestResponseDriver(onSolve, getReporter, options) {
+	const { meshPolicy, solveDeadlineMs, onChange, events } = options;
+	const memo = createSolveMemo({ meshPolicy });
+	let generation = 0;
+	function reportStopped(signal) {
+		console.debug("[Solve/driver] solve stopped (cancelled or timed out)");
+		if (signal.reason?.name === "TimeoutError") getReporter().reportError(`The solve took longer than ${Math.round(solveDeadlineMs / 1e3)} s and was stopped.`);
+		else getReporter().reportAborted();
+	}
+	const throttle = createAsyncThrottle(async (values, signal) => {
+		const startedIn = generation;
+		let result;
+		try {
+			const cached = memo.get(values);
+			if (cached !== void 0) result = cached;
+			else {
+				result = {
+					...await raceAbort(onSolve(values, signal), signal),
+					values
+				};
+				if (!result.aborted && startedIn === generation) memo.set(values, result);
+			}
+		} catch (err) {
+			if (startedIn !== generation) return;
+			if (signal.aborted) return reportStopped(signal);
+			console.warn("[Solve/driver] solve failed:", err);
+			return getReporter().reportError(err instanceof Error ? err.message : String(err));
+		}
+		if (startedIn !== generation) return;
+		if (signal.aborted) return reportStopped(signal);
+		getReporter().report(result);
+	}, {
+		runDeadlineMs: solveDeadlineMs,
+		onChange
+	});
+	function cancel() {
+		throttle.cancel();
+		events?.cancelCurrent?.();
+	}
+	return {
+		solve(values) {
+			throttle.trigger(values);
+		},
+		cancel,
+		get isSolving() {
+			return throttle.isRunning;
+		},
+		get hasQueued() {
+			return throttle.hasPending;
+		},
+		reset() {
+			generation += 1;
+			cancel();
+			memo.clear();
+		},
+		...events ? { onEvent: (listener) => events.subscribe(listener) } : {}
+	};
+}
+// src/client/events/solve-event-stream.ts
+const MIN_RECONNECT_MS = 1e3;
+const MAX_RECONNECT_MS = 3e4;
+function mintStreamId() {
+	if (typeof crypto !== "undefined" && "randomUUID" in crypto) return crypto.randomUUID().replace(/-/g, "");
+	return Array.from({ length: 32 }, () => Math.floor(Math.random() * 16).toString(16)).join("");
+}
+function createSolveEventStream(options) {
+	const streamId = mintStreamId();
+	const listeners = /* @__PURE__ */ new Set();
+	const doFetch = options.fetch ?? ((...args) => fetch(...args));
+	let source = null;
+	let currentSolveId = null;
+	let reconnectMs = MIN_RECONNECT_MS;
+	let reconnectTimer = null;
+	function open() {
+		if (source || typeof EventSource === "undefined") return;
+		const url = `${options.endpoint}${options.endpoint.includes("?") ? "&" : "?"}streamId=${streamId}`;
+		const opened = new EventSource(url);
+		source = opened;
+		opened.addEventListener("open", () => {
+			reconnectMs = MIN_RECONNECT_MS;
+		});
+		opened.addEventListener("solve", (raw) => {
+			let event;
+			try {
+				event = JSON.parse(raw.data);
+			} catch {
+				return;
+			}
+			if (event.type === "solveStarted") currentSolveId = event.solveId;
+			else if (event.type === "solveEnded" && currentSolveId === event.solveId) currentSolveId = null;
+			for (const listener of listeners) listener(event);
+		});
+		opened.addEventListener("error", () => {
+			if (opened.readyState !== EventSource.CLOSED || source !== opened) return;
+			source = null;
+			currentSolveId = null;
+			reconnectTimer = setTimeout(open, reconnectMs);
+			reconnectMs = Math.min(reconnectMs * 2, MAX_RECONNECT_MS);
+		});
+	}
+	open();
+	return {
+		streamId,
+		get currentSolveId() {
+			return currentSolveId;
+		},
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		cancelCurrent() {
+			const solveId = currentSolveId;
+			if (!solveId) return;
+			doFetch(options.cancelEndpoint(solveId), {
+				method: "POST",
+				keepalive: true
+			}).catch(() => {});
+		},
+		close() {
+			if (reconnectTimer) clearTimeout(reconnectTimer);
+			source?.close();
+			source = null;
+			listeners.clear();
+			currentSolveId = null;
+		}
+	};
+}
+// src/client/compute-fetch-solve-fn.ts
+/**
+* A ready-made `SolveFn` that POSTs to a `/api/compute`-shaped endpoint (the wire contract
+* `SolveEngine` produces) and unpacks the result, with 429 cooldown, session-expiry detection,
+* a bad-response guard, and abort handling at every await.
+*
+* Mesh decoding is NOT built in: this package stays renderer-agnostic, so a viewer-enabled
+* consumer supplies `meshes.extract` (typically `getThreeObjectsFromComputeResponse` from
+* `@selvajs/visualization/parse`).
+*/
+/** Applied to a 429 that names no wait. */
+const DEFAULT_RETRY_AFTER_S = 5;
+/** A server's hint, not a lock: past this the client tries again anyway. */
+const MAX_RETRY_AFTER_S = 3600;
+function parseServerTiming(header) {
+	const out = {};
+	if (!header) return out;
+	for (const part of header.split(",")) {
+		const [name, ...params] = part.split(";").map((s) => s.trim());
+		const dur = params.find((p) => p.startsWith("dur="));
+		if (!name || !dur) continue;
+		const ms = Number(dur.slice(4));
+		if (Number.isFinite(ms)) out[name] = ms;
+	}
+	return out;
+}
+function rateLimitedError(retryAfterSeconds) {
+	return /* @__PURE__ */ new Error(`Rate limit reached. Try again in ${Math.ceil(retryAfterSeconds)}s.`);
+}
+function sessionExpiredError() {
+	return /* @__PURE__ */ new Error("Your session has expired. Sign in again in a new tab, then re-run — your inputs are preserved.");
+}
+/** `Retry-After` in either RFC form. Null when it names no usable wait. */
+function parseRetryAfter(value) {
+	if (!value.trim()) return null;
+	const seconds = Number(value);
+	if (!Number.isNaN(seconds)) return Number.isFinite(seconds) && seconds >= 0 ? seconds : null;
+	const at = Date.parse(value);
+	return Number.isNaN(at) ? null : Math.max(0, (at - Date.now()) / 1e3);
+}
+function readRetryAfter(header, bodyHint) {
+	const seconds = (header === null ? null : parseRetryAfter(header)) ?? (typeof bodyHint === "number" ? parseRetryAfter(String(bodyHint)) : null);
+	return seconds === null ? null : Math.min(seconds, MAX_RETRY_AFTER_S);
+}
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseErrorBody(text) {
+	try {
+		const body = JSON.parse(text);
+		if (!isPlainObject(body)) return {};
+		return {
+			...typeof body.message === "string" ? { message: body.message } : {},
+			retryAfter: body.retryAfter
+		};
+	} catch {
+		return {};
+	}
+}
+function createComputeFetchSolveFn(opts) {
+	const debug = opts.debug ?? false;
+	const log = (...args) => {
+		if (debug) console.info(...args);
+	};
+	let cooldownUntil = 0;
+	function rateLimited(retryAfterSeconds) {
+		opts.onRateLimited?.(retryAfterSeconds);
+		return rateLimitedError(retryAfterSeconds);
+	}
+	return async (values, signal) => {
+		const remainingMs = cooldownUntil - Date.now();
+		if (remainingMs > 0) throw rateLimited(remainingMs / 1e3);
+		const solveStart = performance.now();
+		const inputs = opts.inputs();
+		const outputs = opts.outputs();
+		const channel = opts.channel?.();
+		const versionId = opts.versionId?.();
+		const streamId = opts.streamId?.();
+		const payload = JSON.stringify({
+			inputs,
+			values,
+			definitionUrl: opts.definitionUrl(),
+			...versionId ? { versionId } : channel === "draft" ? { channel: "draft" } : {},
+			...streamId ? { streamId } : {}
+		});
+		let res;
+		try {
+			res = await fetch(opts.endpoint, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: payload,
+				signal
+			});
+		} catch (err) {
+			if (signal.aborted) {
+				log("[Compute] solve aborted during fetch — empty result discarded");
+				return { outputs: {} };
+			}
+			throw new Error("Could not reach the server. Check your connection, or reload the page if your session expired.", { cause: err });
+		}
+		if (signal.aborted) {
+			log("[Compute] solve aborted after headers — empty result discarded");
+			return { outputs: {} };
+		}
+		const redirectedToLogin = res.redirected && new URL(res.url).pathname === (opts.loginPath ?? "/login");
+		if (res.status === 401 || redirectedToLogin) {
+			opts.onSessionExpired?.();
+			throw sessionExpiredError();
+		}
+		if (!res.ok) {
+			const errorBody = await res.text().catch(() => "");
+			const { message, retryAfter: bodyHint } = parseErrorBody(errorBody);
+			if (errorBody && message === void 0) log(`[Compute] unreadable error body (HTTP ${res.status}, ${errorBody.length} chars)`);
+			const retryAfter = readRetryAfter(res.headers.get("Retry-After"), bodyHint);
+			if (retryAfter !== null) cooldownUntil = Date.now() + retryAfter * 1e3;
+			if (res.status === 503 || res.status === 504) throw new Error(message || "Compute server is offline or unreachable. Please try again later.");
+			if (res.status === 429) {
+				const seconds = retryAfter ?? DEFAULT_RETRY_AFTER_S;
+				cooldownUntil = Date.now() + seconds * 1e3;
+				throw rateLimited(seconds);
+			}
+			throw new Error(message || `Compute error (HTTP ${res.status})`);
+		}
+		const ttfbMs = performance.now() - solveStart;
+		const downloadStart = performance.now();
+		let bodyText;
+		try {
+			bodyText = await res.text();
+		} catch (err) {
+			if (signal.aborted) {
+				log("[Compute] solve aborted mid-download — empty result discarded");
+				return { outputs: {} };
+			}
+			throw new Error("The connection dropped while receiving the result. Please try again.", { cause: err });
+		}
+		const downloadMs = performance.now() - downloadStart;
+		const bodyChars = bodyText.length;
+		const invalidResponse = (cause) => new Error("Received an invalid response from the server. Reload the page and try again.", { cause });
+		let parsed;
+		try {
+			parsed = JSON.parse(bodyText);
+		} catch (err) {
+			throw invalidResponse(err);
+		}
+		if (!isPlainObject(parsed)) throw invalidResponse();
+		const solved = parsed;
+		const processor = new GrasshopperResponseProcessor(solved);
+		const outcome = decodeOutcome(solved.selva?.outcome) ?? outcomeFromComputeMessages(solved.errors ?? [], solved.warnings ?? []);
+		const rejected = outcome.blocked || outcome.aborted;
+		const meshes = opts.meshes && !rejected ? await opts.meshes.extract(processor.response, {
+			debug,
+			signal
+		}) : [];
+		const resultOutputs = {};
+		for (const o of rejected ? [] : outputs) {
+			const byId = processor.getValue({ byId: o.id }, { parseValues: true });
+			resultOutputs[o.id] = byId ?? (o.nickname ? processor.getValue({ byName: o.nickname }, { parseValues: true }) : void 0);
+		}
+		if (debug) {
+			const valuesBytes = JSON.stringify(values).length;
+			const serverTiming = parseServerTiming(res.headers.get("Server-Timing"));
+			const serverTotal = serverTiming.total ?? 0;
+			const networkMs = Math.max(0, ttfbMs - serverTotal);
+			const sizeMB = bodyChars / 1048576;
+			const size = sizeMB >= 1 ? `${sizeMB.toFixed(2)} MB` : `${(bodyChars / 1024).toFixed(0)} KB`;
+			const mbps = downloadMs > 0 ? (sizeMB / (downloadMs / 1e3)).toFixed(1) : "∞";
+			const heapBytes = performance.memory?.usedJSHeapSize;
+			const heap = heapBytes !== void 0 ? ` | heap=${(heapBytes / 1048576).toFixed(0)} MB` : "";
+			log(`[Compute] req=${(payload.length / 1024).toFixed(0)}KB (values ${(valuesBytes / 1024).toFixed(0)}KB) | ttfb=${ttfbMs.toFixed(0)}ms (network≈${networkMs.toFixed(0)} + server ${serverTotal.toFixed(0)}) | download=${downloadMs.toFixed(0)}ms (${size} @ ${mbps} MB/s)${heap}`);
+			if (serverTiming.selva_cache !== void 0) {
+				const cacheMsg = serverTiming.selva_cache ? "HIT — served without calling compute" : serverTiming.rhino_cache ? "HIT — Rhino.Compute's result cache, solved nothing" : "miss — solved on Rhino.Compute";
+				log(`[Compute]   └─ cache: ${cacheMsg}`);
+			}
+		}
+		return finalizeResult({
+			outputs: resultOutputs,
+			meshes,
+			source: solved
+		}, outcome);
+	};
+}
+export { EMPTY_LIVE_SOLVE, clearExternalValue, createComputeFetchSolveFn, createRequestResponseDriver, createSolveEventStream, createSolveSession, decodeOutcome, finalizeResult, getExternalInputs, readExternalValue, stableInputKey, writeExternalValue };
+
 //# sourceMappingURL=client.js.map