@selvajs/ui 5.0.1 → 6.0.0-beta.0

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

@@ -1,239 +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 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,
-	applyValueChange,
-	applySolveResult,
-	pickInputValues,
-	type SolveSessionState
-} from './solve-session-core';
-
-/**
- * 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 function createSolveSession(args: SolveSessionArgs): SolveSession {
-	let currentSchema = args.schema;
-
-	const flags = makeInitialFlags(currentSchema?.instanceSolve);
-	const state = $state<SolveSessionState>({
-		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;
-		}
-	};
-}
-
-/** 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 function createRequestResponseDriver(
-	onSolve: SolveFn,
-	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) {
-				// 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/src/lib/compute/createSolveSession.test.ts

@@ -1,168 +0,0 @@
-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
-// solve-session-core.test.ts; this file pins how the rune shell turns those decisions into
-// driver.solve() calls. Rune module, so it runs under the svelte vitest plugin.
-
-function schema(instanceSolve?: boolean): UISchema {
-	return {
-		id: 'test',
-		name: 'Test',
-		instanceSolve,
-		inputs: [{ id: 'a', paramId: 'a', paramType: 'text', default: 'x' }],
-		outputs: [{ id: 'out' }],
-		layout: { type: 'flat', groups: [{ items: [] }] }
-	} as unknown as UISchema;
-}
-
-// Records every solve dispatch with the snapshot of values it received.
-function recordingDriver(): SolveDriver & { solves: Record<string, unknown>[] } {
-	const solves: Record<string, unknown>[] = [];
-	return {
-		solves,
-		solve(values) {
-			solves.push(values);
-		},
-		cancel() {},
-		get isSolving() {
-			return false;
-		}
-	};
-}
-
-describe('createSolveSession.setValue', () => {
-	it('auto-solve mode dispatches on every value change', () => {
-		const driver = recordingDriver();
-		const session = createSolveSession({ schema: schema(true), scopeKey: 's', driver });
-		session.setValue('a', 'y');
-		expect(driver.solves.length).toBe(1);
-		expect(driver.solves[0].a).toBe('y');
-	});
-
-	it('manual mode defers: marks pending, no dispatch', () => {
-		const driver = recordingDriver();
-		const session = createSolveSession({ schema: schema(false), scopeKey: 's', driver });
-		session.setValue('a', 'y');
-		expect(driver.solves.length).toBe(0);
-		expect(session.hasPendingChanges).toBe(true);
-	});
-
-	it('forceSolve dispatches even in manual mode and clears the dirty flags', () => {
-		const driver = recordingDriver();
-		const session = createSolveSession({ schema: schema(false), scopeKey: 's', driver });
-		// Reconcile a system-initiated change (e.g. a pruned dynamic-list selection).
-		session.setValue('a', 'reconciled', true);
-		expect(driver.solves.length).toBe(1);
-		expect(driver.solves[0].a).toBe('reconciled');
-		// The forced solve produces the matching output, so nothing is left pending.
-		expect(session.hasPendingChanges).toBe(false);
-	});
-
-	it('forceSolve in auto mode still dispatches exactly once', () => {
-		const driver = recordingDriver();
-		const session = createSolveSession({ schema: schema(true), scopeKey: 's', driver });
-		session.setValue('a', 'y', true);
-		expect(driver.solves.length).toBe(1);
-	});
-
-	it('never echoes output-keyed values back to the driver', () => {
-		const driver = recordingDriver();
-		const session = createSolveSession({ schema: schema(true), scopeKey: 's', driver });
-		// A solve result merges outputs into the session's values map (how widgets
-		// like dynamic value lists read them) — e.g. a multi-MB options payload.
-		session.report({ outputs: { out: { options: { huge: 'payload' } } } });
-		session.setValue('a', 'y');
-		expect(driver.solves.length).toBe(1);
-		expect(driver.solves[0].a).toBe('y');
-		// The output entry lives in session.values for widgets…
-		expect(session.values.out).toBeDefined();
-		// …but must not travel back through the transport.
-		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/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;
-}