@selvajs/ui 4.12.5 → 5.0.0-beta.1

package/dist/components/viewer/Viewer.svelte

@@ -173,8 +173,14 @@
 		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();
 		};
 	});
 

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,11 +107,25 @@ 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)
                 return;
+            memo.set(values, result);
             getReporter().report(result);
         }
         catch (err) {
@@ -125,6 +143,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,58 @@
+// 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);
+            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);
+            }
+        },
+        clear() {
+            entries.clear();
+        }
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@selvajs/ui",
-  "version": "4.12.5",
+  "version": "5.0.0-beta.1",
   "description": "Shared UI components and utilities for Selva applications",
   "license": "MIT",
   "publishConfig": {
@@ -37,13 +37,13 @@
     "**/*.css"
   ],
   "peerDependencies": {
-    "@selvajs/compute": "^3.0.1",
+    "@selvajs/compute": "^3.1.0-beta.6",
     "@sveltejs/kit": "^2",
     "bits-ui": "^2.18.0",
     "svelte": "^5",
     "tailwind-variants": "^3.2.2",
     "three": "^0.184.0",
-    "@selvajs/schemas": "^4.6.1"
+    "@selvajs/schemas": "^4.7.0-beta.0"
   },
   "peerDependenciesMeta": {
     "three": {
@@ -63,17 +63,17 @@
   },
   "devDependencies": {
     "@internationalized/date": "^3.12.1",
-    "@sveltejs/kit": "2.58.0",
+    "@sveltejs/kit": "2.69.1",
     "@sveltejs/vite-plugin-svelte": "^6.2.4",
     "@types/three": "^0.184.0",
     "bits-ui": "^2.18.0",
     "rhino3dm": "8.17.0",
     "rimraf": "^6.0.1",
-    "svelte": "5.55.5",
+    "svelte": "5.56.4",
     "tailwind-variants": "^3.2.2",
     "vitest": "^3.2.6",
     "@selvajs/config": "0.0.2",
-    "@selvajs/schemas": "4.6.1"
+    "@selvajs/schemas": "4.7.0-beta.0"
   },
   "scripts": {
     "dev": "vite dev",

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

@@ -173,8 +173,14 @@
 		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();
 		};
 	});
 

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,10 +187,24 @@ 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;
+			memo.set(values, result);
 			getReporter().report(result);
 		} catch (err) {
 			if (signal.aborted) return;
@@ -197,6 +221,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,69 @@
+// 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);
+			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);
+			}
+		},
+		clear() {
+			entries.clear();
+		}
+	};
+}