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

package/dist/client.js

@@ -1,2 +1,874 @@
-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}}const _=/* @__PURE__ */ new Set([`dynamicValueList`,`file`]);function v(e,t,n,r,i){if(!t||!(r in t)||typeof i==`object`&&i||!Object.is(t[r],i)||!Object.is(n[r],i))return!1;let a=e?.inputs?.find(e=>e.id===r)?.paramType;return!_.has(a??``)}function y(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 b(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,S(e,t)):w(e.diagnostics)?(e.awaitingAck=!0,e.heldResult=t,e.pendingValues={},e.hasPendingChanges=!1,e):(e.awaitingAck=!1,e.heldResult=null,S(e,t))}function x(e){let t={};for(let n of e?.outputs??[])t[n.id]=null;return t}function S(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 C(e,t){return t?`solving`:e.awaitingAck?`review`:e.blocked?`blocked`:`idle`}function w(e){return(e??[]).some(e=>e.isGate&&e.level!==`remark`)}function T(e){let t=e.schema,n=null,r=h(t?.instanceSolve),i={values:m(t,e.scopeKey,c),error:``,computeErrors:[],computeWarnings:[],diagnostics:[],blocked:!1,awaitingAck:!1,heldResult:null,meshes:[],pendingValues:{},hasPendingChanges:r.hasPendingChanges,hasNeverSolved:r.hasNeverSolved,lastResult:null},a=/* @__PURE__ */ new Set,o=()=>a.forEach(e=>e()),s=/* @__PURE__ */ new Set,l=[],u={status:`aborted`,diagnostics:[]};function p(){return new Promise(e=>l.push(e))}function _(e){let t=l;l=[],t.forEach(t=>t(e)),s.forEach(t=>t(e))}function w(){let e=l;l=[],e.forEach(e=>e(u))}function T(e){let t=i.diagnostics;if(e.aborted)return _({status:`aborted`,diagnostics:t});if(e.blocked)return _({status:`blocked`,diagnostics:t});_({status:`applied`,result:i.lastResult,diagnostics:t})}let E=d,D=e.driver.onEvent?.(e=>{let t=f(E,e);t!==E&&(E=t,o())});function O(){let e=p();return k(),e}function k(){n={...y(t,i.values)},e.driver.solve(n),o()}return{get values(){return i.values},get error(){return i.error},get computeErrors(){return i.computeErrors},get computeWarnings(){return i.computeWarnings},get diagnostics(){return i.diagnostics},get blocked(){return i.blocked},get awaitingAck(){return i.awaitingAck},acknowledge(){if(!i.awaitingAck)return;let e=i.heldResult;i.awaitingAck=!1,i.heldResult=null,e&&S(i,e),o(),e&&T(e)},discard(){i.awaitingAck&&(i.awaitingAck=!1,i.heldResult=null,o(),_({status:`discarded`,diagnostics:i.diagnostics}))},get live(){return E},get phase(){return C(i,e.driver.isSolving)},abort(){e.driver.cancel()},get meshes(){return i.meshes},get lastResult(){return i.lastResult},get hasPendingChanges(){return i.hasPendingChanges},get hasNeverSolved(){return i.hasNeverSolved},get isSolving(){return e.driver.isSolving},setValue(e,r,a=!1){if(!a&&v(t,n,i.values,e,r))return;let{shouldSolve:s}=g(i,e,r,t?.instanceSolve);s||a?(a&&!s&&(i.pendingValues={},i.hasPendingChanges=!1),k()):o()},solve:O,ensureSolved(){return e.driver.isSolving||e.driver.hasQueued||i.awaitingAck?p():i.hasPendingChanges||i.hasNeverSolved||i.error||!i.lastResult?O():i.blocked?Promise.resolve({status:`blocked`,diagnostics:i.diagnostics}):Promise.resolve({status:`applied`,result:i.lastResult,diagnostics:i.diagnostics})},onSettled(e){return s.add(e),()=>s.delete(e)},loadValues(e){Object.assign(i.values,e),t?.instanceSolve===!1?(i.hasPendingChanges=!0,o()):k()},rebuild(r,a){w(),t=r,n=null,e.driver.clearCache?.(),i.meshes=[],i.lastResult=null,i.error=``,i.computeErrors=[],i.computeWarnings=[],i.diagnostics=[],i.blocked=!1,i.awaitingAck=!1,i.heldResult=null,i.pendingValues={},i.values=m(r,a,c);let s=h(r?.instanceSolve);i.hasPendingChanges=s.hasPendingChanges,i.hasNeverSolved=s.hasNeverSolved,r&&Object.keys(i.values).length>0&&r.instanceSolve!==!1?k():o()},report(r){r.aborted&&(n=null),b(i,r.blocked||r.aborted?{...r,outputs:x(t),meshes:[]}:r),o(),!(i.awaitingAck||e.driver.hasQueued)&&T(r)},reportError(t){n=null,i.error=t,o(),e.driver.hasQueued||_({status:`failed`,error:t})},reportAborted(){n=null,o(),e.driver.hasQueued||_(u)},subscribe(e){return a.add(e),()=>a.delete(e)},notify:o,dispose(){D?.(),a.clear(),s.clear(),w()}}}function E(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 D(e){return O(e)}function O(e){if(typeof e!=`object`||!e)return JSON.stringify(e)??`null`;if(Array.isArray(e))return`[${e.map(O).join(`,`)}]`;let t=e;return`{${Object.keys(t).sort().map(e=>`${JSON.stringify(e)}:${O(t[e])}`).join(`,`)}}`}function k(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=D(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=D(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 A(e,t,n){let{meshPolicy:r,solveDeadlineMs:i,onChange:a,events:o}=n,s=k({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=E(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 j(){return typeof crypto<`u`&&`randomUUID`in crypto?crypto.randomUUID().replace(/-/g,``):Array.from({length:32},()=>Math.floor(Math.random()*16).toString(16)).join(``)}function M(e){let t=j(),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 N(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 P=e=>{throw Error(`Rate limit reached. Try again in ${Math.ceil(e)}s.`)},F=()=>{throw Error(`Your session has expired. Sign in again in a new tab, then re-run — your inputs are preserved.`)};function I(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??F)(),!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??P)(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=N(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,b as applySolveResult,g as applyValueChange,m as buildInitialValues,l as clearExternalValue,E as createAsyncThrottle,I as createComputeFetchSolveFn,A as createRequestResponseDriver,M as createSolveEventStream,k as createSolveMemo,T as createSolveSession,n as decodeOutcome,e as finalizeResult,u as getExternalInputs,h as makeInitialFlags,y as pickInputValues,c as readExternalValue,f as reduceLiveSolve,C as solvePhase,D as stableInputKey,s as writeExternalValue};
+import { n as finalizeResult, r as outcomeFromComputeMessages, t as decodeOutcome } from "./outcome-ai_9fm43.js";
+import { getDefaultValue, getInputItems } from "@selvajs/schemas";
+import { GrasshopperResponseProcessor } from "@selvajs/compute/grasshopper";
+// src/client/external-storage.ts
+const STORAGE_PREFIX = "external";
+function makeKey(scopeKey, inputId) {
+	return `${STORAGE_PREFIX}:${scopeKey}:${inputId}`;
+}
+function writeExternalValue(args) {
+	const { scopeKey, inputId, value } = args;
+	if (!scopeKey || !inputId) return;
+	if (typeof sessionStorage === "undefined") return;
+	sessionStorage.setItem(makeKey(scopeKey, inputId), JSON.stringify(value));
+}
+function readExternalValue(ref) {
+	const { scopeKey, inputId } = ref;
+	if (!scopeKey || !inputId) return void 0;
+	if (typeof sessionStorage === "undefined") return void 0;
+	const raw = sessionStorage.getItem(makeKey(scopeKey, inputId));
+	if (raw === null) return void 0;
+	try {
+		return JSON.parse(raw);
+	} catch {
+		return;
+	}
+}
+function clearExternalValue(ref) {
+	const { scopeKey, inputId } = ref;
+	if (!scopeKey || !inputId) return;
+	if (typeof sessionStorage === "undefined") return;
+	sessionStorage.removeItem(makeKey(scopeKey, inputId));
+}
+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 reduceLiveSolve(state, event) {
+	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: typeof payload.kind === "string" ? payload.kind : "ok" }
+		};
+		case "diagnostic": {
+			const [diagnostic] = decodeOutcome({ diagnostics: [payload] })?.diagnostics ?? [];
+			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 !== void 0 && report.fraction < 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 makeInitialFlags(instanceSolve) {
+	const manual = instanceSolve === false;
+	return {
+		hasPendingChanges: manual,
+		hasNeverSolved: manual
+	};
+}
+/** Manual mode defers (records the pending value, raises the dirty flag) instead of solving. */
+function applyValueChange(state, id, value, instanceSolve) {
+	state.values[id] = value;
+	if (instanceSolve === false) {
+		state.pendingValues[id] = value;
+		state.hasPendingChanges = true;
+		return {
+			state,
+			shouldSolve: false
+		};
+	}
+	return {
+		state,
+		shouldSolve: true
+	};
+}
+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) {
+	if (!schema?.inputs) return values;
+	const picked = {};
+	for (const input of schema.inputs) if (input.id in values) picked[input.id] = values[input.id];
+	return picked;
+}
+function applySolveResult(state, result) {
+	state.error = "";
+	state.computeErrors = result.errors ?? [];
+	state.computeWarnings = result.warnings ?? [];
+	state.diagnostics = result.diagnostics ?? [];
+	state.blocked = result.blocked ?? false;
+	if (state.blocked) {
+		state.awaitingAck = false;
+		state.heldResult = null;
+		return commitSolveResult(state, result);
+	}
+	if (needsAcknowledgement(state.diagnostics)) {
+		state.awaitingAck = true;
+		state.heldResult = result;
+		state.pendingValues = {};
+		state.hasPendingChanges = false;
+		return state;
+	}
+	state.awaitingAck = false;
+	state.heldResult = null;
+	return commitSolveResult(state, result);
+}
+/**
+* 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) {
+	state.meshes = result.meshes ?? [];
+	const { meshes: _meshes, ...retained } = result;
+	state.lastResult = retained;
+	Object.assign(state.values, result.outputs);
+	state.pendingValues = {};
+	state.hasPendingChanges = false;
+	state.hasNeverSolved = false;
+	return state;
+}
+/**
+* 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.awaitingAck) 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.
+*
+* Without `diagnostics` (a transport that reports no structure) 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
+function createSolveSession(args) {
+	let currentSchema = args.schema;
+	let lastSent = null;
+	const flags = makeInitialFlags(currentSchema?.instanceSolve);
+	const state = {
+		values: buildInitialValues(currentSchema, args.scopeKey, readExternalValue),
+		error: "",
+		computeErrors: [],
+		computeWarnings: [],
+		diagnostics: [],
+		blocked: false,
+		awaitingAck: false,
+		heldResult: null,
+		meshes: [],
+		pendingValues: {},
+		hasPendingChanges: flags.hasPendingChanges,
+		hasNeverSolved: flags.hasNeverSolved,
+		lastResult: null
+	};
+	const listeners = /* @__PURE__ */ new Set();
+	const emit = () => listeners.forEach((l) => l());
+	const settledListeners = /* @__PURE__ */ new Set();
+	let waiters = [];
+	const ABORTED = {
+		status: "aborted",
+		diagnostics: []
+	};
+	function nextSettlement() {
+		return new Promise((resolve) => waiters.push(resolve));
+	}
+	function settle(settlement) {
+		const waiting = waiters;
+		waiters = [];
+		waiting.forEach((resolve) => resolve(settlement));
+		settledListeners.forEach((listener) => listener(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 settleResult(result) {
+		const diagnostics = state.diagnostics;
+		if (result.aborted) return settle({
+			status: "aborted",
+			diagnostics
+		});
+		if (result.blocked) return settle({
+			status: "blocked",
+			diagnostics
+		});
+		settle({
+			status: "applied",
+			result: state.lastResult,
+			diagnostics
+		});
+	}
+	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() {
+		lastSent = { ...pickInputValues(currentSchema, state.values) };
+		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.awaitingAck;
+		},
+		acknowledge() {
+			if (!state.awaitingAck) return;
+			const held = state.heldResult;
+			state.awaitingAck = false;
+			state.heldResult = null;
+			if (held) commitSolveResult(state, held);
+			emit();
+			if (held) settleResult(held);
+		},
+		discard() {
+			if (!state.awaitingAck) return;
+			state.awaitingAck = false;
+			state.heldResult = null;
+			emit();
+			settle({
+				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;
+			const { shouldSolve } = applyValueChange(state, id, value, currentSchema?.instanceSolve);
+			if (shouldSolve || forceSolve) {
+				if (forceSolve && !shouldSolve) {
+					state.pendingValues = {};
+					state.hasPendingChanges = false;
+				}
+				dispatch();
+			} else emit();
+		},
+		solve,
+		ensureSolved() {
+			if (args.driver.isSolving || args.driver.hasQueued || state.awaitingAck) return nextSettlement();
+			if (state.hasPendingChanges || state.hasNeverSolved || state.error || !state.lastResult) return solve();
+			if (state.blocked) return Promise.resolve({
+				status: "blocked",
+				diagnostics: state.diagnostics
+			});
+			return Promise.resolve({
+				status: "applied",
+				result: state.lastResult,
+				diagnostics: state.diagnostics
+			});
+		},
+		onSettled(listener) {
+			settledListeners.add(listener);
+			return () => settledListeners.delete(listener);
+		},
+		loadValues(incoming) {
+			Object.assign(state.values, incoming);
+			if (currentSchema?.instanceSolve !== false) dispatch();
+			else {
+				state.hasPendingChanges = true;
+				emit();
+			}
+		},
+		rebuild(schema, scopeKey) {
+			abandon();
+			currentSchema = schema;
+			lastSent = null;
+			args.driver.clearCache?.();
+			state.meshes = [];
+			state.lastResult = null;
+			state.error = "";
+			state.computeErrors = [];
+			state.computeWarnings = [];
+			state.diagnostics = [];
+			state.blocked = false;
+			state.awaitingAck = false;
+			state.heldResult = null;
+			state.pendingValues = {};
+			state.values = buildInitialValues(schema, scopeKey, readExternalValue);
+			const f = makeInitialFlags(schema?.instanceSolve);
+			state.hasPendingChanges = f.hasPendingChanges;
+			state.hasNeverSolved = f.hasNeverSolved;
+			if (schema && Object.keys(state.values).length > 0 && schema.instanceSolve !== false) dispatch();
+			else emit();
+		},
+		report(result) {
+			if (result.aborted) lastSent = null;
+			applySolveResult(state, result.blocked || result.aborted ? {
+				...result,
+				outputs: blankOutputs(currentSchema),
+				meshes: []
+			} : result);
+			emit();
+			if (state.awaitingAck || args.driver.hasQueued) return;
+			settleResult(result);
+		},
+		reportError(message) {
+			lastSent = null;
+			state.error = message;
+			emit();
+			if (!args.driver.hasQueued) settle({
+				status: "failed",
+				error: message
+			});
+		},
+		reportAborted() {
+			lastSent = null;
+			emit();
+			if (!args.driver.hasQueued) settle(ABORTED);
+		},
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		},
+		notify: emit,
+		dispose() {
+			stopEvents?.();
+			listeners.clear();
+			settledListeners.clear();
+			abandon();
+		}
+	};
+}
+// src/client/async-throttle.ts
+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;
+		onChange?.();
+	}
+	function abortCurrent() {
+		currentAbortController?.abort();
+		currentAbortController = null;
+	}
+	async function execute(values) {
+		abortCurrent();
+		currentAbortController = new AbortController();
+		const { signal } = currentAbortController;
+		const deadlineId = setTimeout(() => {
+			console.warn(`[Solve/throttle] run exceeded ${runDeadlineMs}ms — aborting`);
+			currentAbortController?.abort(new DOMException("Run deadline exceeded", "TimeoutError"));
+		}, runDeadlineMs);
+		setRunning(true);
+		try {
+			await run(values, 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);
+			setRunning(false);
+			currentAbortController = null;
+			if (pendingValues !== null) {
+				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;
+		abortCurrent();
+	}
+	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.
+*/
+function stableInputKey(values) {
+	return serialize(values);
+}
+function serialize(value) {
+	if (value === null || typeof value !== "object") return JSON.stringify(value) ?? "null";
+	if (Array.isArray(value)) return `[${value.map(serialize).join(",")}]`;
+	const obj = value;
+	return `{${Object.keys(obj).sort().map((k) => `${JSON.stringify(k)}:${serialize(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.info(`[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));
+			while (entries.size > max) {
+				const oldest = entries.keys().next().value;
+				if (oldest === void 0) break;
+				evict(oldest);
+				console.info(`[Solve/memo] evicted LRU entry (cap ${max})`);
+			}
+		},
+		clear() {
+			if (entries.size > 0) console.info(`[Solve/memo] cleared ${entries.size} entries (definition changed)`);
+			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 });
+	function reportStopped(signal) {
+		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 cached = memo.get(values);
+		if (cached !== void 0) {
+			if (signal.aborted) return reportStopped(signal);
+			getReporter().report(cached);
+			return;
+		}
+		try {
+			const result = await onSolve(values, signal);
+			if (signal.aborted) {
+				console.debug("[Solve/driver] solve completed after abort — result discarded");
+				return reportStopped(signal);
+			}
+			const stamped = {
+				...result,
+				values
+			};
+			memo.set(values, stamped);
+			getReporter().report(stamped);
+		} catch (err) {
+			if (signal.aborted) {
+				console.debug("[Solve/driver] solve aborted (cancelled or timed out)");
+				return reportStopped(signal);
+			}
+			console.warn("[Solve/driver] solve failed:", err);
+			getReporter().reportError(err instanceof Error ? err.message : String(err));
+		}
+	}, {
+		runDeadlineMs: solveDeadlineMs,
+		onChange
+	});
+	return {
+		solve(values) {
+			throttle.trigger(values);
+		},
+		cancel() {
+			throttle.cancel();
+			events?.cancelCurrent?.();
+		},
+		get isSolving() {
+			return throttle.isRunning;
+		},
+		get hasQueued() {
+			return throttle.hasPending;
+		},
+		clearCache() {
+			memo.clear();
+		},
+		...events ? { onEvent: (listener) => events.subscribe(listener) } : {}
+	};
+}
+// src/client/events/solve-event-stream.ts
+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;
+	function open() {
+		if (source || typeof EventSource === "undefined") return;
+		const url = `${options.endpoint}${options.endpoint.includes("?") ? "&" : "?"}streamId=${streamId}`;
+		source = new EventSource(url);
+		source.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);
+		});
+	}
+	open();
+	return {
+		streamId,
+		get currentSolveId() {
+			return currentSolveId;
+		},
+		subscribe(listener) {
+			listeners.add(listener);
+			open();
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		cancelCurrent() {
+			const solveId = currentSolveId;
+			if (!solveId) return;
+			doFetch(options.cancelEndpoint(solveId), {
+				method: "POST",
+				keepalive: true
+			}).catch(() => {});
+		},
+		close() {
+			source?.close();
+			source = null;
+			listeners.clear();
+			currentSolveId = null;
+		}
+	};
+}
+// src/client/compute-fetch-solve-fn.ts
+/**
+* `createComputeFetchSolveFn` — a ready-made `SolveFn` that POSTs to a
+* `/api/compute`-shaped HTTP endpoint (the wire contract `runSolvePipeline` +
+* `SolveEngine` produce server-side) and unpacks the result.
+*
+* Ports the resilience behavior an interactive solve endpoint needs regardless
+* of app — 429 cooldown, session-expiry/redirect detection, non-JSON-response
+* guarding, and abort handling at every await point — so a new consumer gets it
+* for free instead of re-deriving it by hand. Mesh decoding is NOT built in:
+* this package stays renderer-agnostic (see `shared/solve-fn.ts`), so a
+* viewer-enabled consumer supplies its own `meshes.extract` hook (typically
+* `getThreeObjectsFromComputeResponse` from `@selvajs/visualization/parse`).
+*/
+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;
+}
+const defaultOnRateLimited = (retryAfterSeconds) => {
+	throw new Error(`Rate limit reached. Try again in ${Math.ceil(retryAfterSeconds)}s.`);
+};
+const defaultOnSessionExpired = () => {
+	throw new Error("Your session has expired. Sign in again in a new tab, then re-run — your inputs are preserved.");
+};
+function createComputeFetchSolveFn(opts) {
+	const debug = opts.debug ?? false;
+	const log = (...args) => {
+		if (debug) console.info(...args);
+	};
+	let cooldownUntil = 0;
+	return async (values, signal) => {
+		const remainingMs = cooldownUntil - Date.now();
+		if (remainingMs > 0) throw new Error(`Rate limit reached. Try again in ${Math.ceil(remainingMs / 1e3)}s.`);
+		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("Request blocked — your session may have expired. Reload the page to sign in again.", { 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 === "/login";
+		if (res.status === 401 || redirectedToLogin) (opts.onSessionExpired ?? defaultOnSessionExpired)();
+		if (!res.ok) {
+			const errorBody = await res.text().catch(() => "");
+			let d = {};
+			try {
+				d = JSON.parse(errorBody);
+			} catch {
+				if (errorBody) console.warn(`[Compute] non-JSON error body (HTTP ${res.status}):`, errorBody.slice(0, 300));
+			}
+			if (res.status === 503 || res.status === 504) throw new Error(d.message || "Compute server is offline or unreachable. Please try again later.");
+			if (res.status === 429) {
+				const retryAfter = Number(res.headers.get("Retry-After")) || Number(d.retryAfter) || 5;
+				cooldownUntil = Date.now() + retryAfter * 1e3;
+				(opts.onRateLimited ?? defaultOnRateLimited)(retryAfter);
+			}
+			throw new Error(d.message || `Compute error (HTTP ${res.status})`);
+		}
+		const ttfbMs = performance.now() - solveStart;
+		const downloadStart = performance.now();
+		const bodyText = await res.text();
+		if (signal.aborted) {
+			log("[Compute] solve aborted mid-download — empty result discarded");
+			return { outputs: {} };
+		}
+		const downloadMs = performance.now() - downloadStart;
+		const bytes = bodyText.length;
+		let solved;
+		try {
+			solved = JSON.parse(bodyText);
+		} catch (err) {
+			throw new Error("Received an invalid response from the server. Reload the page and try again.", { cause: err });
+		}
+		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 }) : [];
+		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 = bytes / 1048576;
+			const size = sizeMB >= 1 ? `${sizeMB.toFixed(2)} MB` : `${(bytes / 1024).toFixed(0)} KB`;
+			const mbps = downloadMs > 0 ? (sizeMB / (downloadMs / 1e3)).toFixed(1) : "∞";
+			const heapMB = performance.memory?.usedJSHeapSize;
+			const heap = heapMB !== void 0 ? ` | heap=${(heapMB / 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, applySolveResult, applyValueChange, buildInitialValues, clearExternalValue, createAsyncThrottle, createComputeFetchSolveFn, createRequestResponseDriver, createSolveEventStream, createSolveMemo, createSolveSession, decodeOutcome, finalizeResult, getExternalInputs, makeInitialFlags, pickInputValues, readExternalValue, reduceLiveSolve, solvePhase, stableInputKey, writeExternalValue };
+
 //# sourceMappingURL=client.js.map