@selvajs/ui 5.0.0-beta.0 → 5.0.0-beta.2

package/dist/components/viewer/SceneManager.svelte

@@ -18,7 +18,11 @@
 	// @selvajs/compute. They aren't scene content, so they're hidden from the object list.
 	const HELPER_IDS = new Set(['grid', 'floor', 'label-layer', 'measure']);
 
-	const getSceneObjects = () => {
+	// Content objects of the scene, recomputed only when a solve bumps `sceneVersion` (scene.children is
+	// a plain array the library mutates in place, so that counter is the sole reactive trigger). Derived
+	// — not a function — so the several template sites that read it share one walk per solve instead of
+	// re-filtering scene.children on every render.
+	const sceneObjects = $derived.by(() => {
 		void sceneVersion;
 		return scene.children.filter(
 			(obj) =>
@@ -26,20 +30,19 @@
 				!(obj instanceof THREE.Light) &&
 				!HELPER_IDS.has(obj.userData?.id)
 		);
-	};
+	});
 
-	const getLayerGroups = () => {
-		const objects = getSceneObjects();
+	// Content grouped by layer. Derived from `sceneObjects`, so the grouping map is rebuilt once per
+	// solve rather than every time the list renders.
+	const layerGroups = $derived.by(() => {
 		const groups = new SvelteMap<string, THREE.Object3D[]>();
-
-		for (const obj of objects) {
+		for (const obj of sceneObjects) {
 			const layer: string = obj.userData?.layer || obj.userData?.category || 'Default';
 			if (!groups.has(layer)) groups.set(layer, []);
 			groups.get(layer)!.push(obj);
 		}
-
 		return groups;
-	};
+	});
 
 	let hiddenUuids = new SvelteSet<string>();
 
@@ -59,8 +62,7 @@
 
 	const toggleObject = (object: THREE.Object3D) => {
 		if (selectedUuids.has(object.uuid) && selectedUuids.size > 1) {
-			const allObjects = getSceneObjects();
-			const selected = allObjects.filter((o) => selectedUuids.has(o.uuid));
+			const selected = sceneObjects.filter((o) => selectedUuids.has(o.uuid));
 			const allHidden = selected.every((o) => hiddenUuids.has(o.uuid));
 			for (const o of selected) setObjectVisible(o, allHidden);
 		} else {
@@ -104,23 +106,25 @@
 
 	let searchQuery = $state('');
 
-	const getFilteredLayerGroups = () => {
-		const groups = getLayerGroups();
-		if (!searchQuery.trim()) return groups;
+	// Layer groups after the search filter. Derived from `layerGroups` + `searchQuery`, so filtering
+	// runs once per search keystroke — not twice per render (it's read by both the list and the
+	// empty-state check below).
+	const filteredLayerGroups = $derived.by(() => {
+		if (!searchQuery.trim()) return layerGroups;
 		const q = searchQuery.toLowerCase();
 		const filtered = new SvelteMap<string, THREE.Object3D[]>();
-		for (const [layerName, objects] of groups) {
+		for (const [layerName, objects] of layerGroups) {
 			const matchingObjects = layerName.toLowerCase().includes(q)
 				? objects
 				: objects.filter((obj) => getObjectLabel(obj).toLowerCase().includes(q));
 			if (matchingObjects.length > 0) filtered.set(layerName, matchingObjects);
 		}
 		return filtered;
-	};
+	});
 
 	const getFlatVisibleUuids = (): string[] => {
 		const result: string[] = [];
-		for (const [layerName, objects] of getFilteredLayerGroups()) {
+		for (const [layerName, objects] of filteredLayerGroups) {
 			if (!collapsedLayers.has(layerName)) {
 				for (const obj of objects) result.push(obj.uuid);
 			}
@@ -182,7 +186,7 @@
 	</div>
 
 	<div class="py-1 flex-1 overflow-y-auto">
-		{#each [...getFilteredLayerGroups()] as [layerName, objects] (layerName)}
+		{#each [...filteredLayerGroups] as [layerName, objects] (layerName)}
 			{@const layerHidden = isLayerHidden(objects)}
 			{@const layerPartial = isLayerPartial(objects)}
 			{@const collapsed = collapsedLayers.has(layerName)}
@@ -285,12 +289,12 @@
 		{/each}
 
 		<!-- Empty state -->
-		{#if getSceneObjects().length === 0}
+		{#if sceneObjects.length === 0}
 			<div class="py-12 flex flex-col items-center justify-center text-center">
 				<EyeOff class="mb-2 h-5 w-5 text-muted-foreground/30" />
 				<p class="text-xs text-muted-foreground">{t.noObjects}</p>
 			</div>
-		{:else if getFilteredLayerGroups().size === 0}
+		{:else if filteredLayerGroups.size === 0}
 			<div class="py-12 flex flex-col items-center justify-center text-center">
 				<Search class="mb-2 h-5 w-5 text-muted-foreground/30" />
 				<p class="text-xs text-muted-foreground">

package/dist/components/viewer/Viewer.svelte

@@ -107,6 +107,7 @@
 	let cameraController: CameraController | null = null;
 	let measureTool: MeasureTool | null = null;
 	let grid: Grid | null = null;
+	let applyEdges: ((root: THREE.Object3D) => void) | null = null;
 	let fitToView: (() => void) | null = null;
 	let viewerInitialized = false;
 	let sceneVersion = $state(0);
@@ -143,12 +144,15 @@
 	onMount(() => {
 		if (!canvas) return;
 
+		// Only options that differ from the library defaults. The default look is already 'technical'
+		// (flat ambient + HDR image-based lighting; baseHDR loads by default), so we just switch off the
+		// sun and shadows it doesn't need — and turn on the grid/measure/edges/click this viewer uses.
 		const opts: ThreeInitializerOptions = {
+			lighting: { enableSunlight: false },
+			render: { enableShadows: false },
 			environment: { backgroundColor: config.backgroundColor },
-			controls: {},
 			// Build the grid so it can be toggled at runtime, but start hidden (off by default).
 			grid: { enabled: config.showToolsMenu && config.showGridToggle },
-			gizmo: { enabled: false },
 			measure: { enabled: config.showToolsMenu },
 			events: {
 				onMeshMetadataClicked: config.enableMeshClick
@@ -170,11 +174,18 @@
 		measureTool = init.measureTool;
 		grid = init.grid;
 		grid?.setVisible(gridVisible);
+		applyEdges = init.applyEdges;
 		fitToView = init.fitToView;
 		projection = init.cameraController.getProjection();
 
+		const renderer = init.renderer;
+
 		return () => {
 			init.dispose();
+			// `{#key definitionKey}` recreates the canvas + WebGLRenderer + GL context
+			// on every definition switch; browsers cap live contexts (~16). Explicitly
+			// drop this one so the GPU-side context is released now rather than at GC.
+			renderer.forceContextLoss();
 		};
 	});
 
@@ -202,6 +213,9 @@
 	$effect(() => {
 		if (scene && camera && controls) {
 			updateScene(scene, meshes, camera, controls, viewerInitialized);
+			// Attach crease edges to the freshly-loaded meshes. updateScene clears and re-adds content
+			// each solve, so re-run over the scene root every time; addEdges is idempotent per mesh.
+			applyEdges?.(scene);
 			untrack(() => sceneVersion++);
 
 			if (!viewerInitialized && meshes.length > 0) {

package/dist/compute/computeThrottle.svelte.js

@@ -24,7 +24,12 @@ export function createComputeThrottle(computeFn, options = {}) {
         abortCurrent();
         currentAbortController = new AbortController();
         const { signal } = currentAbortController;
-        const timeoutId = setTimeout(() => currentAbortController?.abort(), timeout);
+        const timeoutId = setTimeout(() => {
+            // Cleared in `finally` on every other path, so firing means a genuine
+            // timeout — the only signal for it (the abort itself is swallowed below).
+            console.warn(`[Compute/throttle] solve exceeded ${timeout}ms — aborting`);
+            currentAbortController?.abort();
+        }, timeout);
         isComputing = true;
         try {
             await computeFn(values, signal);
@@ -50,6 +55,10 @@ export function createComputeThrottle(computeFn, options = {}) {
     }
     function trigger(values) {
         if (isComputing) {
+            if (pendingValues !== null) {
+                // Latest-wins: the previously-queued values are dropped, not solved.
+                console.debug('[Compute/throttle] superseded pending solve (latest-wins)');
+            }
             pendingValues = values;
         }
         else {

package/dist/compute/createSolveSession.svelte.d.ts

@@ -9,6 +9,12 @@ export interface SolveDriver {
     solve(values: Record<string, unknown>): void;
     cancel(): void;
     readonly isSolving: boolean;
+    /**
+     * Drops any cached solve results the driver holds. Optional — only drivers with a
+     * client-side memo (the request/response driver) implement it. Called on rebuild so a
+     * definition swap can't serve a stale result from a prior definition's input space.
+     */
+    clearCache?(): void;
 }
 export interface SolveSession {
     readonly values: Record<string, unknown>;

package/dist/compute/createSolveSession.svelte.js

@@ -4,6 +4,7 @@
 // SolveDriver. A completed solve re-enters via report().
 import { readExternalValue } from '../external/storage';
 import { createComputeThrottle } from './computeThrottle.svelte';
+import { createSolveMemo } from './solveMemo';
 import { buildInitialValues, makeInitialFlags, applyValueChange, applySolveResult, pickInputValues } from './solve-session-core';
 export function createSolveSession(args) {
     let currentSchema = args.schema;
@@ -73,6 +74,9 @@ export function createSolveSession(args) {
         },
         rebuild(schema, scopeKey) {
             currentSchema = schema;
+            // Drop the driver's result memo: the new definition has its own input space, so
+            // a matching input key from the prior definition must not serve its stale result.
+            args.driver.clearCache?.();
             state.meshes = [];
             state.error = '';
             state.computeErrors = [];
@@ -103,16 +107,38 @@ export function createSolveSession(args) {
  * lazily (`() => session`) so it can construct the session with the driver in hand.
  */
 export function createRequestResponseDriver(onSolve, getReporter, options = {}) {
+    // M2: a small LRU memoizing completed solves by their input values. A slider dragged
+    // back to a value already solved this session reports instantly without a network
+    // round-trip. The check lives inside the throttled computeFn so the throttle's
+    // latest-wins ordering still holds — a hit only serves after the throttle picks these
+    // values as the ones to run.
+    const memo = createSolveMemo();
     const throttle = createComputeThrottle(async (values, signal) => {
+        const cached = memo.get(values);
+        if (cached !== undefined) {
+            if (signal.aborted)
+                return;
+            getReporter().report(cached);
+            return;
+        }
         try {
             const result = await onSolve(values, signal);
-            if (signal.aborted)
+            if (signal.aborted) {
+                // Discarded on purpose (superseded/cancelled) — never memoized or reported.
+                console.debug('[Compute/session] solve completed after abort — result discarded');
                 return;
+            }
+            memo.set(values, result);
             getReporter().report(result);
         }
         catch (err) {
-            if (signal.aborted)
+            if (signal.aborted) {
+                console.debug('[Compute/session] solve aborted (superseded, cancelled, or timed out)');
                 return;
+            }
+            // reportError only sets reactive state; without this line a transport
+            // failure leaves no console trace at all.
+            console.warn('[Compute/session] solve failed:', err);
             getReporter().reportError(err instanceof Error ? err.message : String(err));
         }
     }, options);
@@ -125,6 +151,9 @@ export function createRequestResponseDriver(onSolve, getReporter, options = {})
         },
         get isSolving() {
             return throttle.isComputing;
+        },
+        clearCache() {
+            memo.clear();
         }
     };
 }

package/dist/compute/solveMemo.d.ts

@@ -0,0 +1,22 @@
+import type { SolveResult } from '../types/solveFn';
+/**
+ * Deterministic string key for a set of input values. Object keys are sorted at every
+ * level so two logically-equal inputs (built in different key order) collide, matching
+ * the server's stable-input keying intent. Values are plain JSON (numbers, strings,
+ * booleans, arrays) — the projected solve inputs never contain functions or cycles.
+ */
+export declare function stableInputKey(values: Record<string, unknown>): string;
+export interface SolveMemo {
+    /** Returns a previously stored result for these inputs, or undefined on a miss. */
+    get(values: Record<string, unknown>): SolveResult | undefined;
+    /** Records a completed solve result under its input key (evicting the LRU tail). */
+    set(values: Record<string, unknown>, result: SolveResult): void;
+    /** Drops every entry — called when the active definition changes. */
+    clear(): void;
+}
+/**
+ * A bounded LRU memo. `max` caps entries (not bytes); solve results can be large, so the
+ * default is deliberately small — this targets the tight slider-scrub loop, not a durable
+ * cache. Re-reading an entry refreshes its recency (Map insertion-order LRU).
+ */
+export declare function createSolveMemo(max?: number): SolveMemo;

package/dist/compute/solveMemo.js

@@ -0,0 +1,65 @@
+// Client-side solve result memo (M2). A small LRU keyed on a stable serialization of
+// the solve INPUTS, sitting in front of the request/response driver. Dragging a slider
+// back to a value already solved this session returns instantly without a network
+// round-trip — killing slider-scrub storms before they leave the browser. It pairs with
+// the throttle's latest-wins abort: the memo only serves values that fully solved, so a
+// hit is always a complete result.
+/**
+ * Deterministic string key for a set of input values. Object keys are sorted at every
+ * level so two logically-equal inputs (built in different key order) collide, matching
+ * the server's stable-input keying intent. Values are plain JSON (numbers, strings,
+ * booleans, arrays) — the projected solve inputs never contain functions or cycles.
+ */
+export 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;
+    const keys = Object.keys(obj).sort();
+    return `{${keys.map((k) => `${JSON.stringify(k)}:${serialize(obj[k])}`).join(',')}}`;
+}
+/**
+ * A bounded LRU memo. `max` caps entries (not bytes); solve results can be large, so the
+ * default is deliberately small — this targets the tight slider-scrub loop, not a durable
+ * cache. Re-reading an entry refreshes its recency (Map insertion-order LRU).
+ */
+export function createSolveMemo(max = 16) {
+    const entries = new Map();
+    return {
+        get(values) {
+            const key = stableInputKey(values);
+            const hit = entries.get(key);
+            if (hit === undefined)
+                return undefined;
+            // Refresh recency: re-insert at the tail.
+            entries.delete(key);
+            entries.set(key, hit);
+            // A memo hit skips the transport entirely, so no other log line fires —
+            // this debug line is the only trace it wasn't a fresh solve.
+            console.debug(`[Compute/memo] HIT — served from client memo (${entries.size}/${max})`);
+            return hit;
+        },
+        set(values, result) {
+            const key = stableInputKey(values);
+            entries.delete(key);
+            entries.set(key, result);
+            while (entries.size > max) {
+                const oldest = entries.keys().next().value;
+                if (oldest === undefined)
+                    break;
+                entries.delete(oldest);
+                console.debug(`[Compute/memo] evicted LRU entry (cap ${max})`);
+            }
+        },
+        clear() {
+            if (entries.size > 0) {
+                console.debug(`[Compute/memo] cleared ${entries.size} entries (definition changed)`);
+            }
+            entries.clear();
+        }
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@selvajs/ui",
-  "version": "5.0.0-beta.0",
+  "version": "5.0.0-beta.2",
   "description": "Shared UI components and utilities for Selva applications",
   "license": "MIT",
   "publishConfig": {
@@ -37,7 +37,7 @@
     "**/*.css"
   ],
   "peerDependencies": {
-    "@selvajs/compute": "^3.1.0-beta.3",
+    "@selvajs/compute": "^3.1.0-beta.6",
     "@sveltejs/kit": "^2",
     "bits-ui": "^2.18.0",
     "svelte": "^5",

package/src/lib/components/viewer/SceneManager.svelte

@@ -18,7 +18,11 @@
 	// @selvajs/compute. They aren't scene content, so they're hidden from the object list.
 	const HELPER_IDS = new Set(['grid', 'floor', 'label-layer', 'measure']);
 
-	const getSceneObjects = () => {
+	// Content objects of the scene, recomputed only when a solve bumps `sceneVersion` (scene.children is
+	// a plain array the library mutates in place, so that counter is the sole reactive trigger). Derived
+	// — not a function — so the several template sites that read it share one walk per solve instead of
+	// re-filtering scene.children on every render.
+	const sceneObjects = $derived.by(() => {
 		void sceneVersion;
 		return scene.children.filter(
 			(obj) =>
@@ -26,20 +30,19 @@
 				!(obj instanceof THREE.Light) &&
 				!HELPER_IDS.has(obj.userData?.id)
 		);
-	};
+	});
 
-	const getLayerGroups = () => {
-		const objects = getSceneObjects();
+	// Content grouped by layer. Derived from `sceneObjects`, so the grouping map is rebuilt once per
+	// solve rather than every time the list renders.
+	const layerGroups = $derived.by(() => {
 		const groups = new SvelteMap<string, THREE.Object3D[]>();
-
-		for (const obj of objects) {
+		for (const obj of sceneObjects) {
 			const layer: string = obj.userData?.layer || obj.userData?.category || 'Default';
 			if (!groups.has(layer)) groups.set(layer, []);
 			groups.get(layer)!.push(obj);
 		}
-
 		return groups;
-	};
+	});
 
 	let hiddenUuids = new SvelteSet<string>();
 
@@ -59,8 +62,7 @@
 
 	const toggleObject = (object: THREE.Object3D) => {
 		if (selectedUuids.has(object.uuid) && selectedUuids.size > 1) {
-			const allObjects = getSceneObjects();
-			const selected = allObjects.filter((o) => selectedUuids.has(o.uuid));
+			const selected = sceneObjects.filter((o) => selectedUuids.has(o.uuid));
 			const allHidden = selected.every((o) => hiddenUuids.has(o.uuid));
 			for (const o of selected) setObjectVisible(o, allHidden);
 		} else {
@@ -104,23 +106,25 @@
 
 	let searchQuery = $state('');
 
-	const getFilteredLayerGroups = () => {
-		const groups = getLayerGroups();
-		if (!searchQuery.trim()) return groups;
+	// Layer groups after the search filter. Derived from `layerGroups` + `searchQuery`, so filtering
+	// runs once per search keystroke — not twice per render (it's read by both the list and the
+	// empty-state check below).
+	const filteredLayerGroups = $derived.by(() => {
+		if (!searchQuery.trim()) return layerGroups;
 		const q = searchQuery.toLowerCase();
 		const filtered = new SvelteMap<string, THREE.Object3D[]>();
-		for (const [layerName, objects] of groups) {
+		for (const [layerName, objects] of layerGroups) {
 			const matchingObjects = layerName.toLowerCase().includes(q)
 				? objects
 				: objects.filter((obj) => getObjectLabel(obj).toLowerCase().includes(q));
 			if (matchingObjects.length > 0) filtered.set(layerName, matchingObjects);
 		}
 		return filtered;
-	};
+	});
 
 	const getFlatVisibleUuids = (): string[] => {
 		const result: string[] = [];
-		for (const [layerName, objects] of getFilteredLayerGroups()) {
+		for (const [layerName, objects] of filteredLayerGroups) {
 			if (!collapsedLayers.has(layerName)) {
 				for (const obj of objects) result.push(obj.uuid);
 			}
@@ -182,7 +186,7 @@
 	</div>
 
 	<div class="py-1 flex-1 overflow-y-auto">
-		{#each [...getFilteredLayerGroups()] as [layerName, objects] (layerName)}
+		{#each [...filteredLayerGroups] as [layerName, objects] (layerName)}
 			{@const layerHidden = isLayerHidden(objects)}
 			{@const layerPartial = isLayerPartial(objects)}
 			{@const collapsed = collapsedLayers.has(layerName)}
@@ -285,12 +289,12 @@
 		{/each}
 
 		<!-- Empty state -->
-		{#if getSceneObjects().length === 0}
+		{#if sceneObjects.length === 0}
 			<div class="py-12 flex flex-col items-center justify-center text-center">
 				<EyeOff class="mb-2 h-5 w-5 text-muted-foreground/30" />
 				<p class="text-xs text-muted-foreground">{t.noObjects}</p>
 			</div>
-		{:else if getFilteredLayerGroups().size === 0}
+		{:else if filteredLayerGroups.size === 0}
 			<div class="py-12 flex flex-col items-center justify-center text-center">
 				<Search class="mb-2 h-5 w-5 text-muted-foreground/30" />
 				<p class="text-xs text-muted-foreground">

package/src/lib/components/viewer/Viewer.svelte

@@ -107,6 +107,7 @@
 	let cameraController: CameraController | null = null;
 	let measureTool: MeasureTool | null = null;
 	let grid: Grid | null = null;
+	let applyEdges: ((root: THREE.Object3D) => void) | null = null;
 	let fitToView: (() => void) | null = null;
 	let viewerInitialized = false;
 	let sceneVersion = $state(0);
@@ -143,12 +144,15 @@
 	onMount(() => {
 		if (!canvas) return;
 
+		// Only options that differ from the library defaults. The default look is already 'technical'
+		// (flat ambient + HDR image-based lighting; baseHDR loads by default), so we just switch off the
+		// sun and shadows it doesn't need — and turn on the grid/measure/edges/click this viewer uses.
 		const opts: ThreeInitializerOptions = {
+			lighting: { enableSunlight: false },
+			render: { enableShadows: false },
 			environment: { backgroundColor: config.backgroundColor },
-			controls: {},
 			// Build the grid so it can be toggled at runtime, but start hidden (off by default).
 			grid: { enabled: config.showToolsMenu && config.showGridToggle },
-			gizmo: { enabled: false },
 			measure: { enabled: config.showToolsMenu },
 			events: {
 				onMeshMetadataClicked: config.enableMeshClick
@@ -170,11 +174,18 @@
 		measureTool = init.measureTool;
 		grid = init.grid;
 		grid?.setVisible(gridVisible);
+		applyEdges = init.applyEdges;
 		fitToView = init.fitToView;
 		projection = init.cameraController.getProjection();
 
+		const renderer = init.renderer;
+
 		return () => {
 			init.dispose();
+			// `{#key definitionKey}` recreates the canvas + WebGLRenderer + GL context
+			// on every definition switch; browsers cap live contexts (~16). Explicitly
+			// drop this one so the GPU-side context is released now rather than at GC.
+			renderer.forceContextLoss();
 		};
 	});
 
@@ -202,6 +213,9 @@
 	$effect(() => {
 		if (scene && camera && controls) {
 			updateScene(scene, meshes, camera, controls, viewerInitialized);
+			// Attach crease edges to the freshly-loaded meshes. updateScene clears and re-adds content
+			// each solve, so re-run over the scene root every time; addEdges is idempotent per mesh.
+			applyEdges?.(scene);
 			untrack(() => sceneVersion++);
 
 			if (!viewerInitialized && meshes.length > 0) {

package/src/lib/compute/computeThrottle.svelte.ts

@@ -49,7 +49,12 @@ export function createComputeThrottle<T>(
 
 		currentAbortController = new AbortController();
 		const { signal } = currentAbortController;
-		const timeoutId = setTimeout(() => currentAbortController?.abort(), timeout);
+		const timeoutId = setTimeout(() => {
+			// Cleared in `finally` on every other path, so firing means a genuine
+			// timeout — the only signal for it (the abort itself is swallowed below).
+			console.warn(`[Compute/throttle] solve exceeded ${timeout}ms — aborting`);
+			currentAbortController?.abort();
+		}, timeout);
 
 		isComputing = true;
 		try {
@@ -76,6 +81,10 @@ export function createComputeThrottle<T>(
 
 	function trigger(values: T) {
 		if (isComputing) {
+			if (pendingValues !== null) {
+				// Latest-wins: the previously-queued values are dropped, not solved.
+				console.debug('[Compute/throttle] superseded pending solve (latest-wins)');
+			}
 			pendingValues = values;
 		} else {
 			executeCompute(values);

package/src/lib/compute/createSolveSession.svelte.ts

@@ -7,6 +7,7 @@ import type { UISchema } from '@selvajs/schemas';
 import { readExternalValue } from '../external/storage';
 import type { SolveFn, SolveResult } from '../types/solveFn';
 import { createComputeThrottle } from './computeThrottle.svelte';
+import { createSolveMemo } from './solveMemo';
 import {
 	buildInitialValues,
 	makeInitialFlags,
@@ -25,6 +26,12 @@ export interface SolveDriver {
 	solve(values: Record<string, unknown>): void;
 	cancel(): void;
 	readonly isSolving: boolean;
+	/**
+	 * Drops any cached solve results the driver holds. Optional — only drivers with a
+	 * client-side memo (the request/response driver) implement it. Called on rebuild so a
+	 * definition swap can't serve a stale result from a prior definition's input space.
+	 */
+	clearCache?(): void;
 }
 
 export interface SolveSession {
@@ -134,6 +141,9 @@ export function createSolveSession(args: SolveSessionArgs): SolveSession {
 
 		rebuild(schema, scopeKey) {
 			currentSchema = schema;
+			// Drop the driver's result memo: the new definition has its own input space, so
+			// a matching input key from the prior definition must not serve its stale result.
+			args.driver.clearCache?.();
 			state.meshes = [];
 			state.error = '';
 			state.computeErrors = [];
@@ -177,13 +187,37 @@ export function createRequestResponseDriver(
 	getReporter: () => SolveReporter,
 	options: { timeout?: number } = {}
 ): SolveDriver {
+	// M2: a small LRU memoizing completed solves by their input values. A slider dragged
+	// back to a value already solved this session reports instantly without a network
+	// round-trip. The check lives inside the throttled computeFn so the throttle's
+	// latest-wins ordering still holds — a hit only serves after the throttle picks these
+	// values as the ones to run.
+	const memo = createSolveMemo();
+
 	const throttle = createComputeThrottle<Record<string, unknown>>(async (values, signal) => {
+		const cached = memo.get(values);
+		if (cached !== undefined) {
+			if (signal.aborted) return;
+			getReporter().report(cached);
+			return;
+		}
 		try {
 			const result = await onSolve(values, signal);
-			if (signal.aborted) return;
+			if (signal.aborted) {
+				// Discarded on purpose (superseded/cancelled) — never memoized or reported.
+				console.debug('[Compute/session] solve completed after abort — result discarded');
+				return;
+			}
+			memo.set(values, result);
 			getReporter().report(result);
 		} catch (err) {
-			if (signal.aborted) return;
+			if (signal.aborted) {
+				console.debug('[Compute/session] solve aborted (superseded, cancelled, or timed out)');
+				return;
+			}
+			// reportError only sets reactive state; without this line a transport
+			// failure leaves no console trace at all.
+			console.warn('[Compute/session] solve failed:', err);
 			getReporter().reportError(err instanceof Error ? err.message : String(err));
 		}
 	}, options);
@@ -197,6 +231,9 @@ export function createRequestResponseDriver(
 		},
 		get isSolving() {
 			return throttle.isComputing;
+		},
+		clearCache() {
+			memo.clear();
 		}
 	};
 }

package/src/lib/compute/createSolveSession.test.ts

@@ -1,6 +1,12 @@
-import { describe, expect, it } from 'vitest';
-import { createSolveSession, type SolveDriver } from './createSolveSession.svelte';
+import { describe, expect, it, vi } from 'vitest';
+import {
+	createSolveSession,
+	createRequestResponseDriver,
+	type SolveDriver,
+	type SolveReporter
+} from './createSolveSession.svelte';
 import type { UISchema } from '@selvajs/schemas';
+import type { SolveResult } from '../types/solveFn';
 
 // Covers the reactive wrapper's dispatch decisions — specifically the `forceSolve` path
 // added for dynamic-value-list reconciliation. The pure transition logic is pinned in
@@ -83,3 +89,80 @@ describe('createSolveSession.setValue', () => {
 		expect(driver.solves[0]).not.toHaveProperty('out');
 	});
 });
+
+// M2: the request/response driver's client-side result memo. Verifies a slider returning
+// to a solved value serves from memory (no onSolve call) and that a definition rebuild
+// drops the memo so a stale result can't cross the swap.
+describe('createRequestResponseDriver — client memo', () => {
+	// Collects reported results so the memo hit/miss can be observed without a session.
+	function collectingReporter(): SolveReporter & { reports: SolveResult[]; errors: string[] } {
+		const reports: SolveResult[] = [];
+		const errors: string[] = [];
+		return {
+			reports,
+			errors,
+			report: (r) => reports.push(r),
+			reportError: (m) => errors.push(m)
+		};
+	}
+
+	// Lets the throttle's fire-and-forget executeCompute settle.
+	const flush = () => new Promise((resolve) => setTimeout(resolve, 0));
+
+	it('serves a repeated input from the memo without calling onSolve again', async () => {
+		const onSolve = vi.fn(
+			async (values: Record<string, unknown>): Promise<SolveResult> => ({
+				outputs: { echo: values.a }
+			})
+		);
+		const reporter = collectingReporter();
+		const driver = createRequestResponseDriver(onSolve, () => reporter);
+
+		driver.solve({ a: 1 });
+		await flush();
+		driver.solve({ a: 2 });
+		await flush();
+		driver.solve({ a: 1 }); // repeat — should hit the memo
+		await flush();
+
+		expect(onSolve).toHaveBeenCalledTimes(2); // only the two distinct inputs
+		expect(reporter.reports).toHaveLength(3); // but all three solves reported
+		expect(reporter.reports[2]).toEqual({ outputs: { echo: 1 } });
+	});
+
+	it('clearCache drops the memo so the next identical solve re-runs', async () => {
+		const onSolve = vi.fn(async (): Promise<SolveResult> => ({ outputs: {} }));
+		const reporter = collectingReporter();
+		const driver = createRequestResponseDriver(onSolve, () => reporter);
+
+		driver.solve({ a: 1 });
+		await flush();
+		driver.clearCache?.();
+		driver.solve({ a: 1 }); // memo cleared → real solve again
+		await flush();
+
+		expect(onSolve).toHaveBeenCalledTimes(2);
+	});
+
+	it('session.rebuild clears the driver memo (no cross-definition stale hit)', async () => {
+		const onSolve = vi.fn(async (): Promise<SolveResult> => ({ outputs: {} }));
+		const reporter = collectingReporter();
+		let clears = 0;
+		// Wrap the real driver to observe clearCache being invoked from rebuild.
+		const base = createRequestResponseDriver(onSolve, () => reporter);
+		const driver: SolveDriver = {
+			solve: base.solve,
+			cancel: base.cancel,
+			get isSolving() {
+				return base.isSolving;
+			},
+			clearCache() {
+				clears += 1;
+				base.clearCache?.();
+			}
+		};
+		const session = createSolveSession({ schema: schema(true), scopeKey: 's', driver });
+		session.rebuild(schema(true), 's2');
+		expect(clears).toBe(1);
+	});
+});

package/src/lib/compute/solveMemo.test.ts

@@ -0,0 +1,87 @@
+import { describe, expect, it } from 'vitest';
+import { createSolveMemo, stableInputKey } from './solveMemo';
+import type { SolveResult } from '../types/solveFn';
+
+// Pins the client-side result memo (M2): stable keying across key order, LRU recency and
+// eviction, hit/miss semantics, and clear(). The driver wiring is pinned separately in
+// createSolveSession.test.ts.
+
+const result = (tag: string): SolveResult => ({ outputs: { out: tag } });
+
+describe('stableInputKey', () => {
+	it('is insensitive to object key order', () => {
+		expect(stableInputKey({ a: 1, b: 2 })).toBe(stableInputKey({ b: 2, a: 1 }));
+	});
+
+	it('sorts keys at every level (nested objects)', () => {
+		expect(stableInputKey({ o: { x: 1, y: 2 } })).toBe(stableInputKey({ o: { y: 2, x: 1 } }));
+	});
+
+	it('distinguishes different values', () => {
+		expect(stableInputKey({ a: 1 })).not.toBe(stableInputKey({ a: 2 }));
+	});
+
+	it('preserves array order (arrays are ordered)', () => {
+		expect(stableInputKey({ a: [1, 2] })).not.toBe(stableInputKey({ a: [2, 1] }));
+	});
+
+	it('handles null and primitive values', () => {
+		expect(stableInputKey({ a: null, b: 'x', c: true })).toBe(
+			stableInputKey({ c: true, b: 'x', a: null })
+		);
+	});
+});
+
+describe('createSolveMemo', () => {
+	it('returns undefined on a miss', () => {
+		const memo = createSolveMemo();
+		expect(memo.get({ a: 1 })).toBeUndefined();
+	});
+
+	it('round-trips a stored result by equal inputs regardless of key order', () => {
+		const memo = createSolveMemo();
+		memo.set({ a: 1, b: 2 }, result('r'));
+		expect(memo.get({ b: 2, a: 1 })).toEqual(result('r'));
+	});
+
+	it('caches errored results (a complete, deterministic solve outcome)', () => {
+		const memo = createSolveMemo();
+		const errored: SolveResult = { outputs: {}, errors: ['boom'] };
+		memo.set({ a: 1 }, errored);
+		expect(memo.get({ a: 1 })).toEqual(errored);
+	});
+
+	it('evicts the least-recently-used entry past capacity', () => {
+		const memo = createSolveMemo(2);
+		memo.set({ k: 1 }, result('1'));
+		memo.set({ k: 2 }, result('2'));
+		memo.set({ k: 3 }, result('3')); // evicts k:1
+		expect(memo.get({ k: 1 })).toBeUndefined();
+		expect(memo.get({ k: 2 })).toEqual(result('2'));
+		expect(memo.get({ k: 3 })).toEqual(result('3'));
+	});
+
+	it('a get refreshes recency, protecting the entry from eviction', () => {
+		const memo = createSolveMemo(2);
+		memo.set({ k: 1 }, result('1'));
+		memo.set({ k: 2 }, result('2'));
+		memo.get({ k: 1 }); // k:1 now most-recent
+		memo.set({ k: 3 }, result('3')); // evicts k:2, not k:1
+		expect(memo.get({ k: 1 })).toEqual(result('1'));
+		expect(memo.get({ k: 2 })).toBeUndefined();
+	});
+
+	it('re-setting an existing key updates the value without growing size', () => {
+		const memo = createSolveMemo(1);
+		memo.set({ k: 1 }, result('old'));
+		memo.set({ k: 1 }, result('new'));
+		expect(memo.get({ k: 1 })).toEqual(result('new'));
+	});
+
+	it('clear() drops every entry', () => {
+		const memo = createSolveMemo();
+		memo.set({ a: 1 }, result('r'));
+		memo.clear();
+		expect(memo.get({ a: 1 })).toBeUndefined();
+	});
+});

package/src/lib/compute/solveMemo.ts

@@ -0,0 +1,76 @@
+// Client-side solve result memo (M2). A small LRU keyed on a stable serialization of
+// the solve INPUTS, sitting in front of the request/response driver. Dragging a slider
+// back to a value already solved this session returns instantly without a network
+// round-trip — killing slider-scrub storms before they leave the browser. It pairs with
+// the throttle's latest-wins abort: the memo only serves values that fully solved, so a
+// hit is always a complete result.
+
+import type { SolveResult } from '../types/solveFn';
+
+/**
+ * Deterministic string key for a set of input values. Object keys are sorted at every
+ * level so two logically-equal inputs (built in different key order) collide, matching
+ * the server's stable-input keying intent. Values are plain JSON (numbers, strings,
+ * booleans, arrays) — the projected solve inputs never contain functions or cycles.
+ */
+export function stableInputKey(values: Record<string, unknown>): string {
+	return serialize(values);
+}
+
+function serialize(value: unknown): string {
+	if (value === null || typeof value !== 'object') return JSON.stringify(value) ?? 'null';
+	if (Array.isArray(value)) return `[${value.map(serialize).join(',')}]`;
+	const obj = value as Record<string, unknown>;
+	const keys = Object.keys(obj).sort();
+	return `{${keys.map((k) => `${JSON.stringify(k)}:${serialize(obj[k])}`).join(',')}}`;
+}
+
+export interface SolveMemo {
+	/** Returns a previously stored result for these inputs, or undefined on a miss. */
+	get(values: Record<string, unknown>): SolveResult | undefined;
+	/** Records a completed solve result under its input key (evicting the LRU tail). */
+	set(values: Record<string, unknown>, result: SolveResult): void;
+	/** Drops every entry — called when the active definition changes. */
+	clear(): void;
+}
+
+/**
+ * A bounded LRU memo. `max` caps entries (not bytes); solve results can be large, so the
+ * default is deliberately small — this targets the tight slider-scrub loop, not a durable
+ * cache. Re-reading an entry refreshes its recency (Map insertion-order LRU).
+ */
+export function createSolveMemo(max = 16): SolveMemo {
+	const entries = new Map<string, SolveResult>();
+
+	return {
+		get(values) {
+			const key = stableInputKey(values);
+			const hit = entries.get(key);
+			if (hit === undefined) return undefined;
+			// Refresh recency: re-insert at the tail.
+			entries.delete(key);
+			entries.set(key, hit);
+			// A memo hit skips the transport entirely, so no other log line fires —
+			// this debug line is the only trace it wasn't a fresh solve.
+			console.debug(`[Compute/memo] HIT — served from client memo (${entries.size}/${max})`);
+			return hit;
+		},
+		set(values, result) {
+			const key = stableInputKey(values);
+			entries.delete(key);
+			entries.set(key, result);
+			while (entries.size > max) {
+				const oldest = entries.keys().next().value;
+				if (oldest === undefined) break;
+				entries.delete(oldest);
+				console.debug(`[Compute/memo] evicted LRU entry (cap ${max})`);
+			}
+		},
+		clear() {
+			if (entries.size > 0) {
+				console.debug(`[Compute/memo] cleared ${entries.size} entries (definition changed)`);
+			}
+			entries.clear();
+		}
+	};
+}