@selvajs/ui 5.0.1 → 6.0.0-beta.1

package/src/lib/compute/solve-session-core.test.ts

@@ -1,153 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import {
-	buildInitialValues,
-	makeInitialFlags,
-	applyValueChange,
-	applySolveResult,
-	type SolveSessionState
-} from './solve-session-core';
-import type { UISchema } from '@selvajs/schemas';
-
-// These tests pin the lifecycle state machine that used to live inline in
-// ComputeApp.svelte: how values are seeded (incl. client-sourced hydration), when a
-// value change should dispatch a solve vs. defer it, and what a reported solve result
-// does to the flags. Reactivity is NOT exercised here — that's the thin rune wrapper's
-// job. This is the pure decision layer.
-
-// Minimal schema factory. `inputs`/`outputs` are the flat lists ComputeApp reads;
-// `layout` is what getExternalInputs walks for client-sourced inputs.
-function schema(partial: {
-	inputs?: { id: string; paramType: string; default?: unknown }[];
-	outputs?: { id: string }[];
-	clientInputs?: string[]; // ids that carry source.kind === 'client'
-	instanceSolve?: boolean;
-}): UISchema {
-	const clientSet = new Set(partial.clientInputs ?? []);
-	const items = (partial.inputs ?? []).map((i) => ({
-		type: 'input',
-		id: i.id,
-		paramId: i.id,
-		displayName: i.id,
-		...(clientSet.has(i.id) ? { source: { kind: 'client' } } : {})
-	}));
-	return {
-		id: 'test-schema',
-		name: 'Test',
-		instanceSolve: partial.instanceSolve,
-		inputs: partial.inputs ?? [],
-		outputs: partial.outputs ?? [],
-		layout: { type: 'flat', groups: [{ items }] }
-	} as unknown as UISchema;
-}
-
-describe('buildInitialValues', () => {
-	it('seeds non-client inputs from default, falling back to paramType default', () => {
-		const s = schema({
-			inputs: [
-				{ id: 'a', paramType: 'number', default: 5 },
-				{ id: 'b', paramType: 'text' } // no default -> getDefaultValue('text') === ''
-			],
-			outputs: [{ id: 'out' }]
-		});
-		const v = buildInitialValues(s, 'scope', () => undefined);
-		expect(v.a).toBe(5);
-		expect(v.b).toBe('');
-		expect(v.out).toBe(null); // outputs always seeded null
-	});
-
-	it('hydrates client-sourced inputs from the reader, leaving them undefined when absent', () => {
-		const s = schema({
-			inputs: [
-				{ id: 'c', paramType: 'text', default: 'should-be-ignored' },
-				{ id: 'd', paramType: 'text', default: 'also-ignored' }
-			],
-			clientInputs: ['c', 'd']
-		});
-		const read = (ref: { inputId: string }) => (ref.inputId === 'c' ? 'stored-c' : undefined);
-		const v = buildInitialValues(s, 'scope', read);
-		expect(v.c).toBe('stored-c');
-		// Absent client value stays undefined (NOT the default) so the missing-inputs
-		// panel can detect it.
-		expect('d' in v).toBe(false);
-	});
-});
-
-describe('makeInitialFlags', () => {
-	it('starts pending+never-solved when instanceSolve === false', () => {
-		expect(makeInitialFlags(false)).toEqual({ hasPendingChanges: true, hasNeverSolved: true });
-	});
-	it('starts clean when instanceSolve is true or absent', () => {
-		expect(makeInitialFlags(true)).toEqual({ hasPendingChanges: false, hasNeverSolved: false });
-		expect(makeInitialFlags(undefined)).toEqual({
-			hasPendingChanges: false,
-			hasNeverSolved: false
-		});
-	});
-});
-
-function state(overrides: Partial<SolveSessionState> = {}): SolveSessionState {
-	return {
-		values: {},
-		error: '',
-		computeErrors: [],
-		computeWarnings: [],
-		meshes: [],
-		pendingValues: {},
-		hasPendingChanges: false,
-		hasNeverSolved: false,
-		...overrides
-	};
-}
-
-describe('applyValueChange', () => {
-	it('in auto-solve mode, records the value and asks to dispatch', () => {
-		const s = state({ values: { a: 1 } });
-		const out = applyValueChange(s, 'a', 2, /* instanceSolve */ true);
-		expect(out.state.values.a).toBe(2);
-		expect(out.shouldSolve).toBe(true);
-		expect(out.state.hasPendingChanges).toBe(false);
-	});
-
-	it('in manual mode, defers: records pending + sets the flag, no dispatch', () => {
-		const s = state({ values: { a: 1 } });
-		const out = applyValueChange(s, 'a', 2, /* instanceSolve */ false);
-		expect(out.state.values.a).toBe(2);
-		expect(out.state.pendingValues.a).toBe(2);
-		expect(out.state.hasPendingChanges).toBe(true);
-		expect(out.shouldSolve).toBe(false);
-	});
-});
-
-describe('applySolveResult', () => {
-	it('merges outputs into values and clears the lifecycle flags', () => {
-		const s = state({
-			values: { a: 1, out: null },
-			pendingValues: { a: 1 },
-			hasPendingChanges: true,
-			hasNeverSolved: true,
-			error: 'stale'
-		});
-		const out = applySolveResult(s, {
-			outputs: { out: 42 },
-			errors: ['e'],
-			warnings: ['w'],
-			meshes: [{ id: 'm' }]
-		});
-		expect(out.values.out).toBe(42);
-		expect(out.values.a).toBe(1);
-		expect(out.computeErrors).toEqual(['e']);
-		expect(out.computeWarnings).toEqual(['w']);
-		expect(out.meshes).toEqual([{ id: 'm' }]);
-		expect(out.pendingValues).toEqual({});
-		expect(out.hasPendingChanges).toBe(false);
-		expect(out.hasNeverSolved).toBe(false);
-		expect(out.error).toBe('');
-	});
-
-	it('treats missing result arrays as empty', () => {
-		const out = applySolveResult(state(), { outputs: {} });
-		expect(out.computeErrors).toEqual([]);
-		expect(out.computeWarnings).toEqual([]);
-		expect(out.meshes).toEqual([]);
-	});
-});

package/src/lib/compute/solve-session-core.ts

@@ -1,122 +0,0 @@
-// Pure, framework-free transition logic for a Solve Session (see CONTEXT.md).
-//
-// This module holds the value/lifecycle state machine with no Svelte runes and no
-// transport: how values are seeded (including client-sourced hydration), when a value
-// change should dispatch a solve vs. defer it, and what a reported solve result does to
-// the flags. The reactive wrapper in createSolveSession.svelte.ts is a thin shell over
-// these functions; everything testable lives here.
-
-import type { UISchema } from '@selvajs/schemas';
-import { getDefaultValue } from '../schema/defaults';
-import { getExternalInputs, type ExternalValueRef } from '../external/storage';
-import type { SolveResult } from '../types/solveFn';
-
-export interface SolveSessionState {
-	values: Record<string, unknown>;
-	error: string;
-	computeErrors: string[];
-	computeWarnings: string[];
-	meshes: unknown[];
-	/** Values changed since the last solve, in manual (instanceSolve === false) mode. */
-	pendingValues: Record<string, unknown>;
-	hasPendingChanges: boolean;
-	hasNeverSolved: boolean;
-}
-
-/** Reads a previously produced client-sourced value, or undefined if absent. */
-export type ExternalReader = (ref: ExternalValueRef) => unknown | undefined;
-
-/**
- * Builds the initial `values` map for a schema. Non-client inputs get their declared
- * default (falling back to the paramType default); client-sourced inputs are hydrated
- * from `read` and left absent when no stored value exists so the missing-inputs panel
- * can detect them. Outputs are seeded to null.
- */
-export function buildInitialValues(
-	schema: UISchema,
-	scopeKey: string,
-	read: ExternalReader
-): Record<string, unknown> {
-	const clientSet = new Set(getExternalInputs(schema).map((e) => e.paramId));
-	const values: Record<string, unknown> = {};
-	for (const input of schema.inputs) {
-		if (clientSet.has(input.id)) {
-			const stored = read({ scopeKey, inputId: input.id });
-			if (stored !== undefined) values[input.id] = stored;
-			continue;
-		}
-		values[input.id] = input.default ?? getDefaultValue(input.paramType);
-	}
-	for (const output of schema.outputs) {
-		values[output.id] = null;
-	}
-	return values;
-}
-
-/**
- * Initial lifecycle flags. Manual-solve schemas (instanceSolve === false) start dirty
- * so the user must explicitly calculate; auto-solve schemas start clean.
- */
-export function makeInitialFlags(instanceSolve: boolean | undefined): {
-	hasPendingChanges: boolean;
-	hasNeverSolved: boolean;
-} {
-	const manual = instanceSolve === false;
-	return { hasPendingChanges: manual, hasNeverSolved: manual };
-}
-
-/**
- * Records a single value change and decides whether it should dispatch a solve now.
- * Auto-solve mode dispatches immediately; manual mode defers (records the pending value
- * and raises the dirty flag) and never dispatches.
- */
-export function applyValueChange(
-	state: SolveSessionState,
-	id: string,
-	value: unknown,
-	instanceSolve: boolean | undefined
-): { state: SolveSessionState; shouldSolve: boolean } {
-	state.values[id] = value;
-	if (instanceSolve === false) {
-		state.pendingValues[id] = value;
-		state.hasPendingChanges = true;
-		return { state, shouldSolve: false };
-	}
-	return { state, shouldSolve: true };
-}
-
-/**
- * Projects the session's live values down to solve INPUTS. Solve outputs are merged
- * into the same values map after each solve (applySolveResult) so widgets like
- * dynamic value lists can read them — but they are not solve inputs, and echoing
- * them back to the driver re-uploads potentially MB-sized payloads (a measured
- * 6.4 MB options list) that no backend reads. Every transport gets this projection
- * for free by going through the session's dispatch.
- */
-export function pickInputValues(
-	schema: UISchema | undefined,
-	values: Record<string, unknown>
-): Record<string, unknown> {
-	if (!schema?.inputs) return values;
-	const picked: Record<string, unknown> = {};
-	for (const input of schema.inputs) {
-		if (input.id in values) picked[input.id] = values[input.id];
-	}
-	return picked;
-}
-
-/**
- * Merges a reported solve result into the state and clears the post-solve lifecycle
- * flags. Missing result arrays are treated as empty.
- */
-export function applySolveResult(state: SolveSessionState, result: SolveResult): SolveSessionState {
-	state.error = '';
-	state.computeErrors = result.errors ?? [];
-	state.computeWarnings = result.warnings ?? [];
-	state.meshes = result.meshes ?? [];
-	Object.assign(state.values, result.outputs);
-	state.pendingValues = {};
-	state.hasPendingChanges = false;
-	state.hasNeverSolved = false;
-	return state;
-}

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

@@ -1,220 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import * as THREE from 'three';
-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 } });
-
-/** A mesh-bearing result — the shape that exposed audit C1. */
-function meshResult(tag: string): SolveResult {
-	const mesh = new THREE.Mesh(new THREE.BoxGeometry(1, 1, 1), new THREE.MeshBasicMaterial());
-	mesh.name = tag;
-	return { outputs: { out: tag }, meshes: [mesh] };
-}
-
-/** Mirrors `clearScene`'s disposal of whatever the viewer currently holds. */
-function disposeLikeViewer(res: SolveResult | undefined): void {
-	res?.meshes?.forEach((m: THREE.Object3D) =>
-		m.traverse((child) => {
-			const r = child as Partial<THREE.Mesh> & THREE.Object3D;
-			r.geometry?.dispose();
-			const mat = r.material;
-			if (!mat) return;
-			(Array.isArray(mat) ? mat : [mat]).forEach((m) => m.dispose());
-		})
-	);
-}
-
-/**
- * Count `dispose()` calls across ALL geometries for the duration of a test.
- *
- * The memo stores a private clone, so watching the object handed to `set` would prove
- * nothing — the retained copy is deliberately unreachable. Spying the prototype observes
- * disposal of whichever instance the memo actually owns, which is the real invariant:
- * an entry leaving the map must release its buffers.
- */
-function countDisposals(): { count: () => number; restore: () => void } {
-	const original = THREE.BufferGeometry.prototype.dispose;
-	let n = 0;
-	THREE.BufferGeometry.prototype.dispose = function (this: THREE.BufferGeometry) {
-		n++;
-		return original.call(this);
-	};
-	return {
-		count: () => n,
-		restore: () => {
-			THREE.BufferGeometry.prototype.dispose = original;
-		}
-	};
-}
-
-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();
-	});
-});
-
-// Audit C1. The memo caches whole SolveResults, including live three.js objects, but the
-// viewer's `clearScene` disposes the meshes it is handed on the next scene update. Every
-// pre-existing test above used mesh-free results, so nothing caught it.
-describe('createSolveMemo — GPU object ownership (audit C1)', () => {
-	it('serves a usable mesh after the viewer disposed the one it was given', () => {
-		const memo = createSolveMemo();
-		const stored = meshResult('a');
-		memo.set({ k: 1 }, stored);
-
-		// Solve 1 renders: the viewer owns and (on the next update) disposes these meshes.
-		const first = memo.get({ k: 1 })!;
-		disposeLikeViewer(first);
-
-		// Slider returns to the same value → memo hit. The served mesh must be renderable,
-		// not the corpse the viewer just disposed.
-		const second = memo.get({ k: 1 })!;
-		const geo = (second.meshes![0] as THREE.Mesh).geometry;
-		expect(geo.attributes.position).toBeDefined();
-		expect(second.meshes![0]).not.toBe(first.meshes![0]);
-	});
-
-	it('never hands the same mesh instance to two consumers', () => {
-		// The scene takes ownership of what it is given (updateScene → scene.add), so two
-		// hits handing out one instance means a double-add and a shared disposal fate.
-		const memo = createSolveMemo();
-		memo.set({ k: 1 }, meshResult('a'));
-		expect(memo.get({ k: 1 })!.meshes![0]).not.toBe(memo.get({ k: 1 })!.meshes![0]);
-	});
-
-	it('preserves non-mesh result fields on a hit', () => {
-		const memo = createSolveMemo();
-		const stored: SolveResult = { ...meshResult('a'), errors: ['e'], warnings: ['w'] };
-		memo.set({ k: 1 }, stored);
-		const hit = memo.get({ k: 1 })!;
-		expect(hit.outputs).toEqual({ out: 'a' });
-		expect(hit.errors).toEqual(['e']);
-		expect(hit.warnings).toEqual(['w']);
-	});
-
-	it('releases GPU memory when an entry is evicted', () => {
-		const memo = createSolveMemo(1);
-		memo.set({ k: 1 }, meshResult('a'));
-
-		const spy = countDisposals();
-		try {
-			memo.set({ k: 2 }, meshResult('b')); // evicts k:1
-			expect(spy.count()).toBe(1);
-		} finally {
-			spy.restore();
-		}
-		expect(memo.get({ k: 1 })).toBeUndefined();
-	});
-
-	it('releases GPU memory on clear() (definition switch)', () => {
-		const memo = createSolveMemo();
-		memo.set({ k: 1 }, meshResult('a'));
-		memo.set({ k: 2 }, meshResult('b'));
-
-		const spy = countDisposals();
-		try {
-			memo.clear();
-			expect(spy.count()).toBe(2);
-		} finally {
-			spy.restore();
-		}
-	});
-
-	it('releases the old value when a key is overwritten', () => {
-		const memo = createSolveMemo();
-		memo.set({ k: 1 }, meshResult('old'));
-
-		const spy = countDisposals();
-		try {
-			memo.set({ k: 1 }, meshResult('new'));
-			expect(spy.count()).toBe(1);
-		} finally {
-			spy.restore();
-		}
-		expect(memo.get({ k: 1 })!.outputs).toEqual({ out: 'new' });
-	});
-
-	it('handles mesh-free results without touching disposal paths', () => {
-		const memo = createSolveMemo(1);
-		memo.set({ k: 1 }, result('1'));
-		memo.set({ k: 2 }, result('2')); // evicts k:1 — must not throw
-		expect(memo.get({ k: 2 })).toEqual(result('2'));
-	});
-});

package/src/lib/compute/solveMemo.ts

@@ -1,140 +0,0 @@
-// 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.
-//
-// GPU ownership (audit C1): a SolveResult carries live three.js objects, and the viewer
-// takes ownership of every mesh array it renders — `updateScene` disposes the previous
-// content on the next update. So the memo can neither hand out its own instances (they'd
-// be disposed under it, then re-added dead on the next hit) nor drop entries silently
-// (their GPU buffers would leak). It therefore keeps private copies, serves a fresh clone
-// per hit, and disposes an entry whenever it leaves the map.
-
-import * as THREE from 'three';
-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(',')}}`;
-}
-
-/**
- * Deep-clone a solve's scene objects so the caller owns them outright.
- *
- * `Object3D.clone()` copies the transform hierarchy but SHARES `geometry` and `material`
- * by reference — which is exactly the aliasing that makes a naive clone useless here, so
- * geometry is copied explicitly. Materials are deliberately left shared: the viewer's
- * `clearScene` skips disposing anything in its SHARED_MATERIALS set (module-scope
- * singletons reused across solves), and per-mesh materials are cheap to recreate but
- * expensive to re-compile as new shader programs.
- */
-function cloneSceneObjects(meshes: THREE.Object3D[]): THREE.Object3D[] {
-	return meshes.map((root) => {
-		const copy = root.clone(true);
-		const sources: THREE.Object3D[] = [];
-		root.traverse((child) => sources.push(child));
-		let i = 0;
-		copy.traverse((child) => {
-			const source = sources[i++] as Partial<THREE.Mesh> & THREE.Object3D;
-			const target = child as Partial<THREE.Mesh> & THREE.Object3D;
-			if (source.geometry) target.geometry = source.geometry.clone();
-		});
-		return copy;
-	});
-}
-
-/**
- * Release an entry's GPU buffers. Mirrors `clearScene`'s traversal, minus materials —
- * the memo never owns those (see {@link cloneSceneObjects}), so disposing one here would
- * free a singleton still referenced by live scene content.
- */
-function disposeSceneObjects(result: SolveResult): void {
-	result.meshes?.forEach((root: THREE.Object3D) =>
-		root.traverse((child) => {
-			(child as Partial<THREE.Mesh>).geometry?.dispose();
-		})
-	);
-}
-
-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>();
-
-	/** Drop an entry and release its GPU buffers. No-op when the key is absent. */
-	function evict(key: string): void {
-		const entry = entries.get(key);
-		if (entry === undefined) return;
-		entries.delete(key);
-		disposeSceneObjects(entry);
-	}
-
-	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 line is the only trace it wasn't a fresh solve.
-			console.info(`[Compute/memo] HIT — served from client memo (${entries.size}/${max})`);
-			// Clone on the way out: the viewer disposes what it renders, so the retained
-			// entry must never be the instance handed to it (audit C1).
-			if (!hit.meshes?.length) return hit;
-			return { ...hit, meshes: cloneSceneObjects(hit.meshes) };
-		},
-		set(values, result) {
-			const key = stableInputKey(values);
-			// Overwriting a key strands the old value's buffers unless it's disposed first.
-			evict(key);
-			// Store a private copy for the same reason `get` clones: the caller reports this
-			// same object to the viewer, which will dispose it on the next scene update.
-			entries.set(
-				key,
-				result.meshes?.length ? { ...result, meshes: cloneSceneObjects(result.meshes) } : result
-			);
-			while (entries.size > max) {
-				const oldest = entries.keys().next().value;
-				if (oldest === undefined) break;
-				evict(oldest);
-				console.info(`[Compute/memo] evicted LRU entry (cap ${max})`);
-			}
-		},
-		clear() {
-			if (entries.size > 0) {
-				console.info(`[Compute/memo] cleared ${entries.size} entries (definition changed)`);
-			}
-			entries.forEach(disposeSceneObjects);
-			entries.clear();
-		}
-	};
-}