@selvajs/ui 5.0.0 → 6.0.0-beta.0

package/src/lib/public.ts

@@ -8,7 +8,8 @@
 // Scope: the compute-app SDK — everything an external host app needs to embed a
 // Grasshopper-driven app (ComputeApp), drive solves, and wire pre-step
 // producers. Verified against real external host apps: they import
-// ComputeApp + its types, the solve seam, and external/storage. Nothing else.
+// ComputeApp + its types, the solve seam, and the external-input storage
+// helpers. Nothing else.
 //
 // Deliberately NOT public: design-system primitives (Button, Card, Dialog, …),
 // page-chrome layout (AppShell, SideNav, …), toast/Toaster, ThemeSwitcher,
@@ -44,8 +45,11 @@ export {
 export { default as ErrorScreen } from './components/ErrorScreen.svelte';
 
 // Solve Session seam (transport-agnostic value/lifecycle state machine + its
-// driver interface). Exported so transports outside this package can satisfy
-// SolveDriver and drive a session. See CONTEXT.md.
+// driver interface). The session lives in `@selvajs/solve/client` and is
+// framework-free; `useSolveSession` is the Svelte binding that makes its getters
+// read reactively inside components. A host embedding <ComputeApp> needs neither —
+// both are re-exported for hosts driving a session themselves. See CONTEXT.md.
+export { useSolveSession } from './compute/useSolveSession.svelte';
 export {
 	createSolveSession,
 	createRequestResponseDriver,
@@ -53,14 +57,21 @@ export {
 	type SolveSessionArgs,
 	type SolveDriver,
 	type SolveReporter
-} from './compute/createSolveSession.svelte';
+} from '@selvajs/solve/client';
 
 // Client-slot context type (host apps render their own cell for client-sourced
 // inputs, and may commit a value back via ClientSlotArgs.onValueChange).
 export type { ClientSlotArgs, ClientSlot } from './contexts/clientSlotContext.svelte';
 
 // Pre-step producer transit storage (host apps wire producers via these).
-export * from './external/storage';
+export {
+	writeExternalValue,
+	readExternalValue,
+	clearExternalValue,
+	getExternalInputs,
+	type ExternalValueRef,
+	type ExternalInput
+} from '@selvajs/solve/client';
 
 // Schema utilities a ComputeApp host reasonably needs to read/shape values.
 export * from './schema/defaults';
@@ -69,5 +80,5 @@ export * from './schema/dynamic-value-list';
 
 // UI-facing runtime types (not from schema)
 export type { ActionButton } from './types/actionButton';
-export type { SolveFn, SolveResult } from './types/solveFn';
+export type { SolveFn, SolveResult } from '@selvajs/solve/shared';
 export { DEFAULT_PRESET_LABELS, type PresetLabels } from './types/presetLabels';

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

@@ -1,24 +0,0 @@
-/**
- * Compute throttle utility for managing async compute requests.
- *
- * - Only one request in-flight at a time
- * - Latest values always win (no queue)
- * - AbortController support to cancel stale requests
- * - Configurable timeout with automatic abort
- */
-interface ComputeThrottleOptions {
-    timeout?: number;
-}
-/**
- * Creates a throttled compute handler that keeps only one request in-flight.
- * If a new value arrives while one is running, it overwrites the single pending
- * slot — older pending values are dropped. The pending value runs once the
- * current request finishes (or aborts).
- */
-export declare function createComputeThrottle<T>(computeFn: (values: T, signal: AbortSignal) => Promise<void>, options?: ComputeThrottleOptions): {
-    trigger: (values: T) => void;
-    readonly isComputing: boolean;
-    readonly hasPending: boolean;
-    cancel: () => void;
-};
-export {};

package/dist/compute/computeThrottle.svelte.js

@@ -1,82 +0,0 @@
-/**
- * Fallback per-solve abort timeout (ms) when the caller doesn't pass one.
- * Used only by callers without a deployment-specific limit (e.g. plugin-ui
- * over WebSocket); the selva app supplies `MAX_SOLVE_DURATION_MS` from its
- * server config via `ComputeApp`'s `solveTimeoutMs` prop.
- */
-const DEFAULT_TIMEOUT_MS = 60_000;
-/**
- * Creates a throttled compute handler that keeps only one request in-flight.
- * If a new value arrives while one is running, it overwrites the single pending
- * slot — older pending values are dropped. The pending value runs once the
- * current request finishes (or aborts).
- */
-export function createComputeThrottle(computeFn, options = {}) {
-    const { timeout = DEFAULT_TIMEOUT_MS } = options;
-    let isComputing = $state(false);
-    let pendingValues = $state(null);
-    let currentAbortController = null;
-    function abortCurrent() {
-        currentAbortController?.abort();
-        currentAbortController = null;
-    }
-    async function executeCompute(values) {
-        abortCurrent();
-        currentAbortController = new AbortController();
-        const { signal } = currentAbortController;
-        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);
-        }
-        catch (err) {
-            // AbortError is expected (timeout or cancel). Non-abort errors must be
-            // handled inside computeFn — re-throwing here would produce an unhandled
-            // rejection because executeCompute is always called fire-and-forget.
-            if (!(err instanceof Error) || (err.name !== 'AbortError' && err.name !== 'TimeoutError')) {
-                console.error('[computeThrottle] unhandled error in computeFn:', err);
-            }
-        }
-        finally {
-            clearTimeout(timeoutId);
-            isComputing = false;
-            currentAbortController = null;
-            if (pendingValues !== null) {
-                const next = pendingValues;
-                pendingValues = null;
-                executeCompute(next);
-            }
-        }
-    }
-    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 {
-            executeCompute(values);
-        }
-    }
-    function cancel() {
-        pendingValues = null;
-        abortCurrent();
-    }
-    return {
-        trigger,
-        get isComputing() {
-            return isComputing;
-        },
-        get hasPending() {
-            return pendingValues !== null;
-        },
-        cancel
-    };
-}

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

@@ -1,66 +0,0 @@
-import type { UISchema } from '@selvajs/schemas';
-import type { SolveFn, SolveResult } from '../types/solveFn';
-/**
- * The transport behind a Solve Session. Knows how to start and cancel a solve and
- * reports its in-flight state. It does NOT return outputs — those come back via the
- * session's report() so push transports (WebSocket) fit without contortion.
- */
-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>;
-    readonly error: string;
-    readonly computeErrors: string[];
-    readonly computeWarnings: string[];
-    readonly meshes: unknown[];
-    readonly hasPendingChanges: boolean;
-    readonly hasNeverSolved: boolean;
-    readonly isSolving: boolean;
-    /**
-     * Records a value change and dispatches a solve unless the schema is manual-solve.
-     * `forceSolve` overrides manual mode for system-initiated reconciliation (e.g. a dynamic
-     * value list pruning a vanished selection), so the output can't lag behind the new value.
-     */
-    setValue(id: string, value: unknown, forceSolve?: boolean): void;
-    /** Explicit "calculate" — dispatches a solve with the current values. */
-    solve(): void;
-    /** Merges incoming values, then solves (auto) or marks dirty (manual). */
-    loadValues(incoming: Record<string, unknown>): void;
-    /** Re-seed for a new active definition: rebuild values, clear outputs, gate the solve. */
-    rebuild(schema: UISchema, scopeKey: string): void;
-    /** Feed a completed solve result back into the session (called by the driver/host). */
-    report(result: SolveResult): void;
-    /** Report a solve failure (transport/solver error) — surfaces in `error`. */
-    reportError(message: string): void;
-}
-export interface SolveSessionArgs {
-    schema: UISchema;
-    scopeKey: string;
-    driver: SolveDriver;
-}
-export declare function createSolveSession(args: SolveSessionArgs): SolveSession;
-/** The slice of a SolveSession a driver feeds completed/failed solves back into. */
-export interface SolveReporter {
-    report(result: SolveResult): void;
-    reportError(message: string): void;
-}
-/**
- * Request/response Solve Driver: wraps createComputeThrottle around a SolveFn and feeds
- * the resolved result back through the reporter. One solve in flight at a time; the
- * latest triggered values win. Used by ComputeApp (Rhino.Compute over HTTP).
- *
- * Because the session and driver reference each other, the host passes the reporter
- * lazily (`() => session`) so it can construct the session with the driver in hand.
- */
-export declare function createRequestResponseDriver(onSolve: SolveFn, getReporter: () => SolveReporter, options?: {
-    timeout?: number;
-}): SolveDriver;

package/dist/compute/createSolveSession.svelte.js

@@ -1,159 +0,0 @@
-// Reactive Solve Session (see CONTEXT.md): the $state-backed shell over the pure
-// transition logic in solve-session-core.ts. It owns the live values/flags, delegates
-// every transition to the core, and drives solves through a transport-agnostic
-// 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;
-    const flags = makeInitialFlags(currentSchema?.instanceSolve);
-    const state = $state({
-        values: buildInitialValues(currentSchema, args.scopeKey, readExternalValue),
-        error: '',
-        computeErrors: [],
-        computeWarnings: [],
-        meshes: [],
-        pendingValues: {},
-        hasPendingChanges: flags.hasPendingChanges,
-        hasNeverSolved: flags.hasNeverSolved
-    });
-    function dispatch() {
-        // Input values only: outputs merged into state.values (for widgets that read
-        // them, e.g. dynamic value lists) must not be echoed back to the transport.
-        args.driver.solve(pickInputValues(currentSchema, $state.snapshot(state.values)));
-    }
-    return {
-        get values() {
-            return state.values;
-        },
-        get error() {
-            return state.error;
-        },
-        get computeErrors() {
-            return state.computeErrors;
-        },
-        get computeWarnings() {
-            return state.computeWarnings;
-        },
-        get meshes() {
-            return state.meshes;
-        },
-        get hasPendingChanges() {
-            return state.hasPendingChanges;
-        },
-        get hasNeverSolved() {
-            return state.hasNeverSolved;
-        },
-        get isSolving() {
-            return args.driver.isSolving;
-        },
-        setValue(id, value, forceSolve = false) {
-            const { shouldSolve } = applyValueChange(state, id, value, currentSchema?.instanceSolve);
-            if (shouldSolve || forceSolve) {
-                // A forced solve reconciles the deferred output; clear the dirty flags it raised.
-                if (forceSolve && !shouldSolve) {
-                    state.pendingValues = {};
-                    state.hasPendingChanges = false;
-                }
-                dispatch();
-            }
-        },
-        solve() {
-            dispatch();
-        },
-        loadValues(incoming) {
-            Object.assign(state.values, incoming);
-            if (currentSchema?.instanceSolve !== false) {
-                dispatch();
-            }
-            else {
-                state.hasPendingChanges = true;
-            }
-        },
-        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 = [];
-            state.computeWarnings = [];
-            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();
-            }
-        },
-        report(result) {
-            applySolveResult(state, result);
-        },
-        reportError(message) {
-            state.error = message;
-        }
-    };
-}
-/**
- * Request/response Solve Driver: wraps createComputeThrottle around a SolveFn and feeds
- * the resolved result back through the reporter. One solve in flight at a time; the
- * latest triggered values win. Used by ComputeApp (Rhino.Compute over HTTP).
- *
- * Because the session and driver reference each other, the host passes the reporter
- * 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) {
-                // 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) {
-                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);
-    return {
-        solve(values) {
-            throttle.trigger(values);
-        },
-        cancel() {
-            throttle.cancel();
-        },
-        get isSolving() {
-            return throttle.isComputing;
-        },
-        clearCache() {
-            memo.clear();
-        }
-    };
-}

package/dist/compute/solve-session-core.d.ts

@@ -1,54 +0,0 @@
-import type { UISchema } from '@selvajs/schemas';
-import { 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 declare function buildInitialValues(schema: UISchema, scopeKey: string, read: ExternalReader): Record<string, unknown>;
-/**
- * Initial lifecycle flags. Manual-solve schemas (instanceSolve === false) start dirty
- * so the user must explicitly calculate; auto-solve schemas start clean.
- */
-export declare function makeInitialFlags(instanceSolve: boolean | undefined): {
-    hasPendingChanges: boolean;
-    hasNeverSolved: boolean;
-};
-/**
- * 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 declare function applyValueChange(state: SolveSessionState, id: string, value: unknown, instanceSolve: boolean | undefined): {
-    state: SolveSessionState;
-    shouldSolve: boolean;
-};
-/**
- * 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 declare function pickInputValues(schema: UISchema | undefined, values: Record<string, unknown>): Record<string, unknown>;
-/**
- * Merges a reported solve result into the state and clears the post-solve lifecycle
- * flags. Missing result arrays are treated as empty.
- */
-export declare function applySolveResult(state: SolveSessionState, result: SolveResult): SolveSessionState;

package/dist/compute/solve-session-core.js

@@ -1,87 +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 { getDefaultValue } from '../schema/defaults';
-import { getExternalInputs } from '../external/storage';
-/**
- * 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, scopeKey, read) {
-    const clientSet = new Set(getExternalInputs(schema).map((e) => e.paramId));
-    const values = {};
-    for (const input of schema.inputs) {
-        if (clientSet.has(input.id)) {
-            const stored = read({ scopeKey, inputId: input.id });
-            if (stored !== 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) {
-    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, id, value, instanceSolve) {
-    state.values[id] = value;
-    if (instanceSolve === false) {
-        state.pendingValues[id] = value;
-        state.hasPendingChanges = true;
-        return { state, shouldSolve: false };
-    }
-    return { state, shouldSolve: true };
-}
-/**
- * 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, values) {
-    if (!schema?.inputs)
-        return values;
-    const picked = {};
-    for (const input of schema.inputs) {
-        if (input.id in values)
-            picked[input.id] = values[input.id];
-    }
-    return picked;
-}
-/**
- * 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, result) {
-    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/dist/compute/solveMemo.d.ts

@@ -1,22 +0,0 @@
-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

@@ -1,124 +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';
-/**
- * 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(',')}}`;
-}
-/**
- * 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) {
-    return meshes.map((root) => {
-        const copy = root.clone(true);
-        const sources = [];
-        root.traverse((child) => sources.push(child));
-        let i = 0;
-        copy.traverse((child) => {
-            const source = sources[i++];
-            const target = child;
-            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) {
-    result.meshes?.forEach((root) => root.traverse((child) => {
-        child.geometry?.dispose();
-    }));
-}
-/**
- * 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();
-    /** Drop an entry and release its GPU buffers. No-op when the key is absent. */
-    function evict(key) {
-        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();
-        }
-    };
-}