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

package/dist/client.js

@@ -1,22 +1,35 @@
-import { n as finalizeResult, r as outcomeFromComputeMessages, t as decodeOutcome } from "./outcome-ai_9fm43.js";
+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";
-function makeKey(scopeKey, inputId) {
-	return `${STORAGE_PREFIX}:${scopeKey}:${inputId}`;
+/** 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 { scopeKey, inputId, value } = args;
-	if (!scopeKey || !inputId) return;
-	if (typeof sessionStorage === "undefined") return;
-	sessionStorage.setItem(makeKey(scopeKey, inputId), JSON.stringify(value));
+	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 { scopeKey, inputId } = ref;
-	if (!scopeKey || !inputId) return void 0;
-	if (typeof sessionStorage === "undefined") return void 0;
-	const raw = sessionStorage.getItem(makeKey(scopeKey, inputId));
+	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);
@@ -25,10 +38,8 @@ function readExternalValue(ref) {
 	}
 }
 function clearExternalValue(ref) {
-	const { scopeKey, inputId } = ref;
-	if (!scopeKey || !inputId) return;
-	if (typeof sessionStorage === "undefined") return;
-	sessionStorage.removeItem(makeKey(scopeKey, inputId));
+	const slot = openSlot(ref);
+	slot?.storage.removeItem(slot.key);
 }
 function getExternalInputs(schema) {
 	return getInputItems(schema).filter((item) => item.source?.kind === "client").map((item) => ({
@@ -46,7 +57,12 @@ const EMPTY_LIVE_SOLVE = Object.freeze({
 	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,
@@ -66,10 +82,10 @@ function reduceLiveSolve(state, event) {
 		case "solveEnded": return {
 			...next,
 			running: false,
-			ended: { kind: typeof payload.kind === "string" ? payload.kind : "ok" }
+			ended: { kind: readEndedKind(payload) }
 		};
 		case "diagnostic": {
-			const [diagnostic] = decodeOutcome({ diagnostics: [payload] })?.diagnostics ?? [];
+			const diagnostic = decodeDiagnostic(payload);
 			return diagnostic ? {
 				...next,
 				diagnostics: [...next.diagnostics, diagnostic]
@@ -80,7 +96,7 @@ function reduceLiveSolve(state, event) {
 			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;
+			if (previous !== void 0 && (report.fraction ?? 0) < previous) report.fraction = previous;
 			progress.set(source, report);
 			return {
 				...next,
@@ -135,28 +151,39 @@ function buildInitialValues(schema, scopeKey, read) {
 	return values;
 }
 /** Manual-solve schemas (instanceSolve === false) start dirty; auto-solve schemas start clean. */
-function makeInitialFlags(instanceSolve) {
-	const manual = instanceSolve === false;
+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
+		hasNeverSolved: manual,
+		lastResult: null,
+		unsolved: null
 	};
 }
-/** Manual mode defers (records the pending value, raises the dirty flag) instead of solving. */
-function applyValueChange(state, id, value, instanceSolve) {
+/**
+* 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) {
-		state.pendingValues[id] = value;
-		state.hasPendingChanges = true;
-		return {
-			state,
-			shouldSolve: false
-		};
-	}
-	return {
-		state,
-		shouldSolve: true
-	};
+	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"]);
 /**
@@ -169,7 +196,7 @@ 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;
+	const paramType = schema.inputs.find((input) => input.id === id)?.paramType;
 	return !RESEND_UNCHANGED.has(paramType ?? "");
 }
 /**
@@ -178,32 +205,34 @@ function isRepeatOfLastSolve(schema, lastSent, values, id, value) {
 * 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];
+	for (const input of schema.inputs) if (Object.hasOwn(values, input.id)) picked[input.id] = values[input.id];
 	return picked;
 }
-function applySolveResult(state, result) {
+/** 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;
-	if (state.blocked) {
-		state.awaitingAck = false;
-		state.heldResult = null;
-		return commitSolveResult(state, result);
-	}
-	if (needsAcknowledgement(state.diagnostics)) {
-		state.awaitingAck = true;
+	state.unsolved = result.aborted ? "aborted" : null;
+	if (!state.blocked && needsAcknowledgement(state.diagnostics)) {
 		state.heldResult = result;
-		state.pendingValues = {};
-		state.hasPendingChanges = false;
-		return state;
+		state.hasPendingChanges &&= editedSinceSent;
+		return;
 	}
-	state.awaitingAck = false;
 	state.heldResult = null;
-	return commitSolveResult(state, result);
+	commitSolveResult(state, result, editedSinceSent);
 }
 /**
 * Every schema output set to null. A blocked solve reports `outputs: {}`, and merging that into
@@ -211,19 +240,25 @@ function applySolveResult(state, result) {
 */
 function blankOutputs(schema) {
 	const blank = {};
-	for (const output of schema?.outputs ?? []) blank[output.id] = null;
+	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) {
+function commitSolveResult(state, result, editedSinceSent) {
 	state.meshes = result.meshes ?? [];
 	const { meshes: _meshes, ...retained } = result;
 	state.lastResult = retained;
 	Object.assign(state.values, result.outputs);
-	state.pendingValues = {};
-	state.hasPendingChanges = false;
+	state.hasPendingChanges &&= editedSinceSent;
 	state.hasNeverSolved = false;
-	return state;
+}
+/** `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
@@ -231,7 +266,7 @@ function commitSolveResult(state, result) {
 */
 function solvePhase(state, isSolving) {
 	if (isSolving) return "solving";
-	if (state.awaitingAck) return "review";
+	if (state.heldResult) return "review";
 	if (state.blocked) return "blocked";
 	return "idle";
 }
@@ -247,34 +282,29 @@ function solvePhase(state, isSolving) {
 * 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
+* 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");
+	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;
-	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
-	};
+	let lastDispatched = null;
+	const state = createInitialState(currentSchema, args.scopeKey, readExternalValue);
+	let disposed = false;
 	const listeners = /* @__PURE__ */ new Set();
-	const emit = () => listeners.forEach((l) => l());
+	const emit = () => notifyAll(listeners, void 0);
 	const settledListeners = /* @__PURE__ */ new Set();
 	let waiters = [];
 	const ABORTED = {
@@ -282,13 +312,14 @@ function createSolveSession(args) {
 		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));
-		settledListeners.forEach((listener) => listener(settlement));
+		notifyAll(settledListeners, settlement);
 	}
 	/** Resolves waiting callers without telling listeners: no solve ended, the session moved on. */
 	function abandon() {
@@ -296,22 +327,42 @@ function createSolveSession(args) {
 		waiters = [];
 		waiting.forEach((resolve) => resolve(ABORTED));
 	}
-	function settleResult(result) {
+	function settlementOf(result) {
 		const diagnostics = state.diagnostics;
-		if (result.aborted) return settle({
+		if (result.aborted) return {
 			status: "aborted",
 			diagnostics
-		});
-		if (result.blocked) return settle({
+		};
+		if (result.blocked) return {
 			status: "blocked",
 			diagnostics
-		});
-		settle({
+		};
+		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);
@@ -325,7 +376,10 @@ function createSolveSession(args) {
 		return settled;
 	}
 	function dispatch() {
+		if (disposed) return;
+		dropHeld();
 		lastSent = { ...pickInputValues(currentSchema, state.values) };
+		lastDispatched = lastSent;
 		args.driver.solve(lastSent);
 		emit();
 	}
@@ -349,26 +403,23 @@ function createSolveSession(args) {
 			return state.blocked;
 		},
 		get awaitingAck() {
-			return state.awaitingAck;
+			return state.heldResult !== null;
 		},
 		acknowledge() {
-			if (!state.awaitingAck) return;
 			const held = state.heldResult;
-			state.awaitingAck = false;
+			if (!held) return;
 			state.heldResult = null;
-			if (held) commitSolveResult(state, held);
-			emit();
-			if (held) settleResult(held);
+			commitSolveResult(state, held, editedSinceSent());
+			land(() => settlementOf(held));
 		},
 		discard() {
-			if (!state.awaitingAck) return;
-			state.awaitingAck = false;
+			if (!state.heldResult) return;
 			state.heldResult = null;
-			emit();
-			settle({
+			state.unsolved = "discarded";
+			land(() => ({
 				status: "discarded",
 				diagnostics: state.diagnostics
-			});
+			}));
 		},
 		get live() {
 			return live;
@@ -396,26 +447,22 @@ function createSolveSession(args) {
 		},
 		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();
+			if (applyValueChange(state, id, value, currentSchema.instanceSolve, forceSolve)) 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",
+			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: "applied",
-				result: state.lastResult,
+				status: step,
 				diagnostics: state.diagnostics
 			});
 		},
@@ -424,59 +471,47 @@ function createSolveSession(args) {
 			return () => settledListeners.delete(listener);
 		},
 		loadValues(incoming) {
-			Object.assign(state.values, incoming);
-			if (currentSchema?.instanceSolve !== false) dispatch();
-			else {
-				state.hasPendingChanges = true;
-				emit();
-			}
+			if (applyLoadedValues(state, incoming, currentSchema.instanceSolve)) dispatch();
+			else emit();
 		},
 		rebuild(schema, scopeKey) {
+			if (disposed) return;
 			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();
+			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, result.blocked || result.aborted ? {
+			applySolveResult(state, rejected ? {
 				...result,
 				outputs: blankOutputs(currentSchema),
 				meshes: []
-			} : result);
-			emit();
-			if (state.awaitingAck || args.driver.hasQueued) return;
-			settleResult(result);
+			} : 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;
-			emit();
-			if (!args.driver.hasQueued) settle({
+			state.unsolved = null;
+			land(() => ({
 				status: "failed",
 				error: message
-			});
+			}));
 		},
 		reportAborted() {
 			lastSent = null;
-			emit();
-			if (!args.driver.hasQueued) settle(ABORTED);
+			state.unsolved = "aborted";
+			land(() => ABORTED);
 		},
 		subscribe(listener) {
 			listeners.add(listener);
@@ -484,14 +519,17 @@ function createSolveSession(args) {
 		},
 		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;
@@ -500,30 +538,29 @@ function createAsyncThrottle(run, options) {
 	function setRunning(next) {
 		if (isRunning === next) return;
 		isRunning = next;
-		onChange?.();
-	}
-	function abortCurrent() {
-		currentAbortController?.abort();
-		currentAbortController = null;
+		try {
+			onChange?.();
+		} catch (err) {
+			console.error("[Solve/throttle] onChange threw:", err);
+		}
 	}
 	async function execute(values) {
-		abortCurrent();
-		currentAbortController = new AbortController();
-		const { signal } = currentAbortController;
+		const controller = new AbortController();
+		currentAbortController = controller;
 		const deadlineId = setTimeout(() => {
 			console.warn(`[Solve/throttle] run exceeded ${runDeadlineMs}ms — aborting`);
-			currentAbortController?.abort(new DOMException("Run deadline exceeded", "TimeoutError"));
+			controller.abort(new DOMException("Run deadline exceeded", "TimeoutError"));
 		}, runDeadlineMs);
 		setRunning(true);
 		try {
-			await run(values, signal);
+			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);
-			currentAbortController = null;
-			if (pendingValues !== null) {
+			if (pendingValues !== null && !isRunning) {
 				const next = pendingValues;
 				pendingValues = null;
 				execute(next);
@@ -538,7 +575,8 @@ function createAsyncThrottle(run, options) {
 	}
 	function cancel() {
 		pendingValues = null;
-		abortCurrent();
+		currentAbortController?.abort();
+		currentAbortController = null;
 	}
 	return {
 		trigger,
@@ -554,16 +592,18 @@ function createAsyncThrottle(run, options) {
 // 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.
+* 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(values) {
-	return serialize(values);
-}
-function serialize(value) {
+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(serialize).join(",")}]`;
+	if (Array.isArray(value)) return `[${value.map(stableInputKey).join(",")}]`;
 	const obj = value;
-	return `{${Object.keys(obj).sort().map((k) => `${JSON.stringify(k)}:${serialize(obj[k])}`).join(",")}}`;
+	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;
@@ -591,22 +631,19 @@ function createSolveMemo(options = {}) {
 			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})`);
+			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));
-			while (entries.size > max) {
-				const oldest = entries.keys().next().value;
-				if (oldest === void 0) break;
+			for (const oldest of entries.keys()) {
+				if (entries.size <= max) 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();
 		}
@@ -620,62 +657,64 @@ function createSolveMemo(options = {}) {
 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 cached = memo.get(values);
-		if (cached !== void 0) {
-			if (signal.aborted) return reportStopped(signal);
-			getReporter().report(cached);
-			return;
-		}
+		const startedIn = generation;
+		let result;
 		try {
-			const result = await onSolve(values, signal);
-			if (signal.aborted) {
-				console.debug("[Solve/driver] solve completed after abort — result discarded");
-				return reportStopped(signal);
+			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);
 			}
-			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);
-			}
+			if (startedIn !== generation) return;
+			if (signal.aborted) return reportStopped(signal);
 			console.warn("[Solve/driver] solve failed:", err);
-			getReporter().reportError(err instanceof Error ? err.message : String(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() {
-			throttle.cancel();
-			events?.cancelCurrent?.();
-		},
+		cancel,
 		get isSolving() {
 			return throttle.isRunning;
 		},
 		get hasQueued() {
 			return throttle.hasPending;
 		},
-		clearCache() {
+		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("");
@@ -686,11 +725,17 @@ function createSolveEventStream(options) {
 	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}`;
-		source = new EventSource(url);
-		source.addEventListener("solve", (raw) => {
+		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);
@@ -701,6 +746,13 @@ function createSolveEventStream(options) {
 			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 {
@@ -710,7 +762,6 @@ function createSolveEventStream(options) {
 		},
 		subscribe(listener) {
 			listeners.add(listener);
-			open();
 			return () => {
 				listeners.delete(listener);
 			};
@@ -724,6 +775,7 @@ function createSolveEventStream(options) {
 			}).catch(() => {});
 		},
 		close() {
+			if (reconnectTimer) clearTimeout(reconnectTimer);
 			source?.close();
 			source = null;
 			listeners.clear();
@@ -733,18 +785,18 @@ function createSolveEventStream(options) {
 }
 // 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.
+* 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.
 *
-* 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`).
+* 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;
@@ -757,21 +809,52 @@ function parseServerTiming(header) {
 	}
 	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 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 new Error(`Rate limit reached. Try again in ${Math.ceil(remainingMs / 1e3)}s.`);
+		if (remainingMs > 0) throw rateLimited(remainingMs / 1e3);
 		const solveStart = performance.now();
 		const inputs = opts.inputs();
 		const outputs = opts.outputs();
@@ -798,49 +881,61 @@ function createComputeFetchSolveFn(opts) {
 				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 });
+			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 === "/login";
-		if (res.status === 401 || redirectedToLogin) (opts.onSessionExpired ?? defaultOnSessionExpired)();
+		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(() => "");
-			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.");
+			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 retryAfter = Number(res.headers.get("Retry-After")) || Number(d.retryAfter) || 5;
-				cooldownUntil = Date.now() + retryAfter * 1e3;
-				(opts.onRateLimited ?? defaultOnRateLimited)(retryAfter);
+				const seconds = retryAfter ?? DEFAULT_RETRY_AFTER_S;
+				cooldownUntil = Date.now() + seconds * 1e3;
+				throw rateLimited(seconds);
 			}
-			throw new Error(d.message || `Compute error (HTTP ${res.status})`);
+			throw new Error(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: {} };
+		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 bytes = bodyText.length;
-		let solved;
+		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 {
-			solved = JSON.parse(bodyText);
+			parsed = JSON.parse(bodyText);
 		} catch (err) {
-			throw new Error("Received an invalid response from the server. Reload the page and try again.", { cause: 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 }) : [];
+		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 });
@@ -851,11 +946,11 @@ function createComputeFetchSolveFn(opts) {
 			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 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 heapMB = performance.memory?.usedJSHeapSize;
-			const heap = heapMB !== void 0 ? ` | heap=${(heapMB / 1048576).toFixed(0)} MB` : "";
+			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";
@@ -869,6 +964,6 @@ function createComputeFetchSolveFn(opts) {
 		}, 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 };
+export { EMPTY_LIVE_SOLVE, clearExternalValue, createComputeFetchSolveFn, createRequestResponseDriver, createSolveEventStream, createSolveSession, decodeOutcome, finalizeResult, getExternalInputs, readExternalValue, stableInputKey, writeExternalValue };
 
 //# sourceMappingURL=client.js.map