@selvajs/ui 5.0.1 → 6.0.0-beta.0

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

@@ -0,0 +1,83 @@
+// The Svelte binding for a Solve Session.
+//
+// The session itself lives in `@selvajs/solve/client` and is framework-free: it
+// exposes plain getters plus a `subscribe()` seam. That makes it usable headless, but a
+// plain getter read inside Svelte markup is NOT reactive — nothing tells the component to
+// re-run. This adapter closes that gap: it subscribes once, bumps a `$state` version
+// counter on every notification, and reads that counter inside each getter so any
+// component touching one re-runs when the session changes.
+//
+// The counter (rather than mirroring each field into its own `$state`) keeps this a pure
+// republish: no field list to keep in sync as the session grows, and no risk of a mirrored
+// copy drifting from the source of truth.
+
+import type { SolveSession, SolveSessionArgs } from '@selvajs/solve/client';
+import { createSolveSession } from '@selvajs/solve/client';
+
+/**
+ * Wraps a Solve Session so its state reads reactively inside Svelte components.
+ *
+ * Returns the same `SolveSession` surface — every method delegates untouched, and every
+ * getter additionally depends on the version counter. Callers use it exactly like the
+ * session it wraps.
+ *
+ * Must be called during component initialization (it uses `$effect` to manage the
+ * subscription, so teardown follows the owning component's lifecycle).
+ */
+export function useSolveSession(args: SolveSessionArgs): SolveSession {
+	const session = createSolveSession(args);
+
+	// Bumped on every session notification. Reading it inside a getter is what registers
+	// the dependency; the value itself is never meaningful.
+	let version = $state(0);
+
+	$effect(() => {
+		// Re-read on mount and unsubscribe on teardown. The session outlives no component
+		// here — it is created alongside this adapter — so dropping the subscription is the
+		// whole cleanup.
+		return session.subscribe(() => {
+			version += 1;
+		});
+	});
+
+	/** Registers the reactive dependency, then returns the live value. */
+	function track<T>(read: () => T): T {
+		void version;
+		return read();
+	}
+
+	return {
+		get values() {
+			return track(() => session.values);
+		},
+		get error() {
+			return track(() => session.error);
+		},
+		get computeErrors() {
+			return track(() => session.computeErrors);
+		},
+		get computeWarnings() {
+			return track(() => session.computeWarnings);
+		},
+		get meshes() {
+			return track(() => session.meshes);
+		},
+		get hasPendingChanges() {
+			return track(() => session.hasPendingChanges);
+		},
+		get hasNeverSolved() {
+			return track(() => session.hasNeverSolved);
+		},
+		get isSolving() {
+			return track(() => session.isSolving);
+		},
+		setValue: (id, value, forceSolve) => session.setValue(id, value, forceSolve),
+		solve: () => session.solve(),
+		loadValues: (incoming) => session.loadValues(incoming),
+		rebuild: (schema, scopeKey) => session.rebuild(schema, scopeKey),
+		report: (result) => session.report(result),
+		reportError: (message) => session.reportError(message),
+		subscribe: (listener) => session.subscribe(listener),
+		notify: () => session.notify()
+	};
+}

package/src/lib/external/storage.ts

@@ -1,64 +1,12 @@
-// Client-supplied input transit storage.
-//
-// When an input has source.kind === 'client', a producer route writes the produced
-// value here, and the solver route reads it back. Scoped per (scopeKey, inputId) so
-// values for one solver/input don't bleed into another. The scope key is whatever
-// uniquely identifies the solver context — sessionId in plugin-ui/preview,
-// definition guid in selva/library, etc.
-//
-// inputId is the Grasshopper parameter instance GUID (LayoutItem.paramId / SchemaInput.id).
-
-import type { UISchema } from '@selvajs/schemas';
-import { getInputItems } from '@selvajs/schemas';
-
-const STORAGE_PREFIX = 'external';
-
-function makeKey(scopeKey: string, inputId: string): string {
-	return `${STORAGE_PREFIX}:${scopeKey}:${inputId}`;
-}
-
-export interface ExternalValueRef {
-	scopeKey: string;
-	inputId: string;
-}
-
-export function writeExternalValue(args: ExternalValueRef & { value: unknown }): void {
-	const { scopeKey, inputId, value } = args;
-	if (!scopeKey || !inputId) return;
-	if (typeof sessionStorage === 'undefined') return;
-	sessionStorage.setItem(makeKey(scopeKey, inputId), JSON.stringify(value));
-}
-
-export function readExternalValue(ref: ExternalValueRef): unknown | undefined {
-	const { scopeKey, inputId } = ref;
-	if (!scopeKey || !inputId) return undefined;
-	if (typeof sessionStorage === 'undefined') return undefined;
-	const raw = sessionStorage.getItem(makeKey(scopeKey, inputId));
-	if (raw === null) return undefined;
-	try {
-		return JSON.parse(raw);
-	} catch {
-		return undefined;
-	}
-}
-
-export function clearExternalValue(ref: ExternalValueRef): void {
-	const { scopeKey, inputId } = ref;
-	if (!scopeKey || !inputId) return;
-	if (typeof sessionStorage === 'undefined') return;
-	sessionStorage.removeItem(makeKey(scopeKey, inputId));
-}
-
-export interface ExternalInput {
-	paramId: string;
-	displayName: string;
-}
-
-export function getExternalInputs(schema: UISchema): ExternalInput[] {
-	return getInputItems(schema)
-		.filter((item) => item.source?.kind === 'client')
-		.map((item) => ({
-			paramId: item.paramId,
-			displayName: item.displayName ?? item.paramId
-		}));
-}
+// Moved to `@selvajs/solve/client`, where the Solve Session that hydrates from it
+// now lives. Re-exported here to keep the published `@selvajs/ui/external` sub-path — and
+// the pre-step producer routes that import it — working unchanged.
+
+export {
+	writeExternalValue,
+	readExternalValue,
+	clearExternalValue,
+	getExternalInputs,
+	type ExternalValueRef,
+	type ExternalInput
+} from '@selvajs/solve/client';

package/src/lib/index.ts

@@ -21,9 +21,12 @@ export * from './schema/dynamic-value-list';
 export * from './schema/traversal';
 export * from './compute/solving.svelte';
 
-// Solve Session seam (transport-agnostic value/lifecycle state machine + its driver
-// interface). Exported so transports outside this package — e.g. plugin-ui's WebSocket
+// Solve Session seam. The session itself now lives in `@selvajs/solve/client`
+// (framework-free); `useSolveSession` is this package's Svelte binding, which republishes
+// the session's subscribe() notifications as rune state so its getters read reactively in
+// markup. Re-exported so transports outside this package — e.g. plugin-ui's WebSocket
 // driver — can satisfy SolveDriver and drive a session. See CONTEXT.md.
+export { useSolveSession } from './compute/useSolveSession.svelte';
 export {
 	createSolveSession,
 	createRequestResponseDriver,
@@ -31,10 +34,17 @@ export {
 	type SolveSessionArgs,
 	type SolveDriver,
 	type SolveReporter
-} from './compute/createSolveSession.svelte';
+} from '@selvajs/solve/client';
 
 // External-input transit storage (used by routes that wire pre-step producers)
-export * from './external/storage';
+export {
+	writeExternalValue,
+	readExternalValue,
+	clearExternalValue,
+	getExternalInputs,
+	type ExternalValueRef,
+	type ExternalInput
+} from '@selvajs/solve/client';
 
 // Contexts & Composables
 export * from './contexts/footerContext.svelte';
@@ -47,5 +57,5 @@ export { randomId } from './utils/randomId';
 
 // UI-specific 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/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;