@selvajs/ui 5.0.1 → 6.0.0-beta.1

package/src/lib/external/storage.test.ts

@@ -1,99 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import {
-	getExternalInputs,
-	writeExternalValue,
-	readExternalValue,
-	clearExternalValue
-} from './storage';
-import type { UISchema } from '@selvajs/schemas';
-
-// getExternalInputs is the gate the whole client-input feature hangs on: it decides
-// which inputs a producer route must fill. These pin the source.kind === 'client'
-// filter and the displayName fallback. The read/write helpers are also covered with a
-// sessionStorage stub, including the no-storage guard (SSR / node).
-
-const input = (paramId: string, opts: { displayName?: string; source?: { kind: string } } = {}) =>
-	({ type: 'input', paramId, ...opts }) as never;
-
-function schema(items: unknown[]): UISchema {
-	return {
-		layout: { type: 'flat', groups: [{ id: 'g', label: 'g', items }] }
-	} as unknown as UISchema;
-}
-
-describe('getExternalInputs', () => {
-	it('keeps only inputs with source.kind === client', () => {
-		const s = schema([
-			input('a', { source: { kind: 'client' } }),
-			input('b', { source: { kind: 'user' } }),
-			input('c') // no source
-		]);
-		expect(getExternalInputs(s).map((e) => e.paramId)).toEqual(['a']);
-	});
-
-	it('falls back to paramId when displayName is absent', () => {
-		const s = schema([input('a', { source: { kind: 'client' } })]);
-		expect(getExternalInputs(s)[0].displayName).toBe('a');
-	});
-
-	it('uses displayName when present', () => {
-		const s = schema([input('a', { displayName: 'Width', source: { kind: 'client' } })]);
-		expect(getExternalInputs(s)[0].displayName).toBe('Width');
-	});
-});
-
-describe('read/write/clear with a sessionStorage stub', () => {
-	afterEach(() => {
-		vi.unstubAllGlobals();
-	});
-
-	function stubStorage() {
-		const store = new Map<string, string>();
-		vi.stubGlobal('sessionStorage', {
-			getItem: (k: string) => store.get(k) ?? null,
-			setItem: (k: string, v: string) => store.set(k, v),
-			removeItem: (k: string) => store.delete(k)
-		});
-		return store;
-	}
-
-	it('round-trips a value scoped by (scopeKey, inputId)', () => {
-		const store = stubStorage();
-		writeExternalValue({ scopeKey: 's1', inputId: 'p1', value: { x: 1 } });
-		expect(readExternalValue({ scopeKey: 's1', inputId: 'p1' })).toEqual({ x: 1 });
-		expect(store.has('external:s1:p1')).toBe(true);
-	});
-
-	it('scopes values so they do not bleed across scopeKey', () => {
-		stubStorage();
-		writeExternalValue({ scopeKey: 's1', inputId: 'p1', value: 'a' });
-		expect(readExternalValue({ scopeKey: 's2', inputId: 'p1' })).toBeUndefined();
-	});
-
-	it('clear removes the value', () => {
-		stubStorage();
-		writeExternalValue({ scopeKey: 's1', inputId: 'p1', value: 'a' });
-		clearExternalValue({ scopeKey: 's1', inputId: 'p1' });
-		expect(readExternalValue({ scopeKey: 's1', inputId: 'p1' })).toBeUndefined();
-	});
-
-	it('returns undefined for malformed JSON', () => {
-		const store = stubStorage();
-		store.set('external:s1:p1', '{not json');
-		expect(readExternalValue({ scopeKey: 's1', inputId: 'p1' })).toBeUndefined();
-	});
-});
-
-describe('no-storage guard (SSR / node)', () => {
-	it('read returns undefined and write/clear no-op when sessionStorage is absent', () => {
-		// node env: sessionStorage is undefined by default
-		expect(readExternalValue({ scopeKey: 's1', inputId: 'p1' })).toBeUndefined();
-		expect(() => writeExternalValue({ scopeKey: 's1', inputId: 'p1', value: 1 })).not.toThrow();
-		expect(() => clearExternalValue({ scopeKey: 's1', inputId: 'p1' })).not.toThrow();
-	});
-
-	it('ignores empty scopeKey or inputId', () => {
-		expect(readExternalValue({ scopeKey: '', inputId: 'p1' })).toBeUndefined();
-		expect(readExternalValue({ scopeKey: 's1', inputId: '' })).toBeUndefined();
-	});
-});

package/src/lib/schema/dynamic-value-list.test.ts

@@ -1,150 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { describe, expect, it } from 'vitest';
-import type { UISchema } from '@selvajs/schemas';
-import { buildDynamicValueListOptions } from './dynamic-value-list';
-
-// The collector keys `values` by the ContextBake GUID. A dynamicValueList output can live in
-// schema.outputs[] OR only in the layout (a routing sink). These pin that BOTH are honoured —
-// the layout-only case is the bug where the C# collector sent the payload but the UI threw it away.
-
-const BAKE = 'bake-guid';
-const TARGET = 'target-input-guid';
-
-function schemaWith(opts: { outputs?: UISchema['outputs']; layoutItems?: unknown[] }): UISchema {
-	return {
-		outputs: opts.outputs ?? [],
-		layout: {
-			type: 'tabbed',
-			tabs: [
-				{ id: 't1', groups: [{ id: 'g1', label: 'g1', order: 0, items: opts.layoutItems ?? [] }] }
-			]
-		}
-	} as unknown as UISchema;
-}
-
-const layoutItem = (paramId: string, targetInputId: string) =>
-	({
-		id: 'li1',
-		type: 'output',
-		widgetType: 'dynamicValueList',
-		paramId,
-		config: { targetInputId }
-	}) as unknown;
-
-const payload = (targetInputId: string | null, options: Record<string, string>) => ({
-	targetInputId,
-	options
-});
-
-describe('buildDynamicValueListOptions', () => {
-	it('routes options from a schema.outputs[] source', () => {
-		const schema = schemaWith({
-			outputs: [{ id: BAKE, type: 'dynamicValueList', targetInputId: TARGET }] as never
-		});
-
-		const result = buildDynamicValueListOptions(schema, {
-			[BAKE]: payload(TARGET, { A: '1', B: '2' })
-		});
-
-		expect(result[TARGET]).toEqual({ A: '1', B: '2' });
-	});
-
-	it('routes options from a LAYOUT-only source (the dropped-data bug)', () => {
-		const schema = schemaWith({ layoutItems: [layoutItem(BAKE, TARGET)] });
-
-		const result = buildDynamicValueListOptions(schema, {
-			[BAKE]: payload(TARGET, { Sphere: '0', Box: '1' })
-		});
-
-		expect(result[TARGET]).toEqual({ Sphere: '0', Box: '1' });
-	});
-
-	it("prefers the payload's targetInputId over the schema fallback", () => {
-		const schema = schemaWith({ layoutItems: [layoutItem(BAKE, 'stale-target')] });
-
-		const result = buildDynamicValueListOptions(schema, {
-			[BAKE]: payload('live-target', { A: '1' })
-		});
-
-		expect(result['live-target']).toEqual({ A: '1' });
-		expect(result['stale-target']).toBeUndefined();
-	});
-
-	it('falls back to the schema targetInputId when the payload omits it', () => {
-		const schema = schemaWith({ layoutItems: [layoutItem(BAKE, TARGET)] });
-
-		const result = buildDynamicValueListOptions(schema, {
-			[BAKE]: payload(null, { A: '1' })
-		});
-
-		expect(result[TARGET]).toEqual({ A: '1' });
-	});
-
-	it('parses a JSON-string payload (Rhino.Compute path)', () => {
-		const schema = schemaWith({ layoutItems: [layoutItem(BAKE, TARGET)] });
-
-		const result = buildDynamicValueListOptions(schema, {
-			[BAKE]: JSON.stringify(payload(TARGET, { A: '1' }))
-		});
-
-		expect(result[TARGET]).toEqual({ A: '1' });
-	});
-
-	it('returns the SAME parsed object for repeated large string payloads (memoization)', () => {
-		const schema = schemaWith({ layoutItems: [layoutItem(BAKE, TARGET)] });
-		// Above the 1024-char memoization threshold — the expensive compute-mode path.
-		const bigOptions: Record<string, string> = {};
-		for (let i = 0; i < 100; i++) bigOptions[`option-${i}-${'x'.repeat(20)}`] = String(i);
-		const str = JSON.stringify(payload(TARGET, bigOptions));
-
-		const first = buildDynamicValueListOptions(schema, { [BAKE]: str });
-		// A later solve delivering an identical (even newly-allocated) string must yield
-		// the same object reference — referential stability is what stops the dropdown
-		// subtree from re-rendering on every unrelated values change.
-		const second = buildDynamicValueListOptions(schema, { [BAKE]: String(str) });
-
-		expect(first[TARGET]).toEqual(bigOptions);
-		expect(second[TARGET]).toBe(first[TARGET]);
-	});
-
-	it('dedupes outputs[] over layout for the same id', () => {
-		const schema = schemaWith({
-			outputs: [{ id: BAKE, type: 'dynamicValueList', targetInputId: 'from-outputs' }] as never,
-			layoutItems: [layoutItem(BAKE, 'from-layout')]
-		});
-
-		// Payload omits targetInputId -> the outputs[] fallback wins (it's set last in the dedupe map).
-		const result = buildDynamicValueListOptions(schema, {
-			[BAKE]: payload(null, { A: '1' })
-		});
-
-		expect(result['from-outputs']).toEqual({ A: '1' });
-		expect(result['from-layout']).toBeUndefined();
-	});
-
-	it('ignores values with no matching source', () => {
-		const schema = schemaWith({ layoutItems: [layoutItem(BAKE, TARGET)] });
-
-		const result = buildDynamicValueListOptions(schema, {
-			'unrelated-id': payload(TARGET, { A: '1' })
-		});
-
-		expect(Object.keys(result)).toHaveLength(0);
-	});
-
-	// The SAME json file the C# DynamicValueListPayload test loads. If C# and TS stop agreeing on
-	// this shape, one side's CI goes red — that's the cross-stack drift guard.
-	it('routes the shared cross-stack golden fixture', () => {
-		const fixturePath = fileURLToPath(
-			new URL('../../../../schemas/fixtures/dynamic-value-list-payload.json', import.meta.url)
-		);
-		const fixture = JSON.parse(readFileSync(fixturePath, 'utf-8'));
-		const schema = schemaWith({ layoutItems: [layoutItem(BAKE, fixture.targetInputId)] });
-
-		const result = buildDynamicValueListOptions(schema, { [BAKE]: fixture });
-
-		expect(result[fixture.targetInputId]).toEqual(fixture.options);
-		expect(result[fixture.targetInputId]).toEqual({ Sphere: '0', Box: '1', Cone: '2' });
-	});
-});

package/src/lib/schema/param-exporter.test.ts

@@ -1,136 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { validateSavedState, extractLoadableValues, loadPreset } from './param-exporter';
-import type { UISchema, ParameterPreset } from '@selvajs/schemas';
-
-// These tests cover the load path a user hits when restoring a preset against a
-// schema that has drifted. The severity of each mismatch decides whether the
-// preset can load at all (error blocks, warning allows), so those are the cases
-// worth locking in — not the happy path.
-
-function schema(over: Partial<UISchema> = {}): UISchema {
-	return {
-		id: 'schema-1',
-		documentId: 'doc-1',
-		inputs: [
-			{ id: 'a', nickname: 'A', paramType: 'number' },
-			{ id: 'b', nickname: 'B', paramType: 'number' }
-		],
-		...over
-	} as unknown as UISchema;
-}
-
-function preset(over: Partial<ParameterPreset> = {}): ParameterPreset {
-	return {
-		id: 'p1',
-		name: 'My Preset',
-		schemaId: 'schema-1',
-		documentId: 'doc-1',
-		parameters: [
-			{ paramId: 'a', nickname: 'A', value: 1 },
-			{ paramId: 'b', nickname: 'B', value: 2 }
-		],
-		...over
-	} as unknown as ParameterPreset;
-}
-
-describe('validateSavedState', () => {
-	it('document-ID mismatch is a blocking error', () => {
-		const result = validateSavedState(preset({ documentId: 'other-doc' }), schema());
-		expect(result.canLoad).toBe(false);
-		expect(result.issues.some((i) => i.severity === 'error' && i.paramId === '__document__')).toBe(
-			true
-		);
-	});
-
-	it('schema-ID change is a warning that still allows loading', () => {
-		const result = validateSavedState(preset({ schemaId: 'old-schema' }), schema());
-		expect(result.canLoad).toBe(true);
-		expect(result.isValid).toBe(false);
-		expect(result.issues.some((i) => i.severity === 'warning' && i.paramId === '__schema__')).toBe(
-			true
-		);
-	});
-
-	it('a parameter missing from the schema is a blocking error', () => {
-		const p = preset({
-			parameters: [
-				{ paramId: 'a', nickname: 'A', value: 1 },
-				{ paramId: 'gone', nickname: 'Gone', value: 9 }
-			] as ParameterPreset['parameters']
-		});
-		const result = validateSavedState(p, schema());
-		expect(result.canLoad).toBe(false);
-		expect(result.issues.some((i) => i.severity === 'error' && i.paramId === 'gone')).toBe(true);
-	});
-
-	it('a renamed nickname is a warning, not a block', () => {
-		const renamed = schema({
-			inputs: [
-				{ id: 'a', nickname: 'A renamed', paramType: 'number' },
-				{ id: 'b', nickname: 'B', paramType: 'number' }
-			]
-		} as unknown as Partial<UISchema>);
-		const result = validateSavedState(preset(), renamed);
-		expect(result.canLoad).toBe(true);
-		expect(result.issues.some((i) => i.severity === 'warning' && i.paramId === 'a')).toBe(true);
-	});
-
-	it('a fully matching preset is valid with no issues', () => {
-		const result = validateSavedState(preset(), schema());
-		expect(result).toEqual({ isValid: true, issues: [], canLoad: true });
-	});
-});
-
-describe('extractLoadableValues', () => {
-	it('drops params that no longer exist in the schema, keeps the rest', () => {
-		const p = preset({
-			parameters: [
-				{ paramId: 'a', nickname: 'A', value: 1 },
-				{ paramId: 'gone', nickname: 'Gone', value: 9 } // not in schema
-			] as ParameterPreset['parameters']
-		});
-		expect(extractLoadableValues(p, schema())).toEqual({ a: 1 });
-	});
-
-	it('keeps a warned-but-valid param (nickname drift) on load', () => {
-		const renamed = schema({
-			inputs: [
-				{ id: 'a', nickname: 'A renamed', paramType: 'number' },
-				{ id: 'b', nickname: 'B', paramType: 'number' }
-			]
-		} as unknown as Partial<UISchema>);
-		expect(extractLoadableValues(preset(), renamed)).toEqual({ a: 1, b: 2 });
-	});
-});
-
-describe('loadPreset', () => {
-	it('fuses validation and extraction: valid preset loads cleanly', () => {
-		const result = loadPreset(preset(), schema());
-		expect(result.isValid).toBe(true);
-		expect(result.canLoad).toBe(true);
-		expect(result.issues).toEqual([]);
-		expect(result.values).toEqual({ a: 1, b: 2 });
-	});
-
-	it('blocks on a document mismatch but still returns loadable values', () => {
-		const result = loadPreset(preset({ documentId: 'other-doc' }), schema());
-		expect(result.canLoad).toBe(false);
-		expect(result.issues.some((i) => i.severity === 'error')).toBe(true);
-		// values are still computed (the caller decides whether to apply them)
-		expect(result.values).toEqual({ a: 1, b: 2 });
-	});
-
-	it('allows load with warnings (schema drift) and drops missing params', () => {
-		const p = preset({
-			parameters: [
-				{ paramId: 'a', nickname: 'A', value: 1 },
-				{ paramId: 'gone', nickname: 'Gone', value: 9 }
-			] as ParameterPreset['parameters'],
-			schemaId: 'old-schema'
-		});
-		const result = loadPreset(p, schema());
-		expect(result.isValid).toBe(false);
-		expect(result.canLoad).toBe(false); // missing param is an error
-		expect(result.values).toEqual({ a: 1 });
-	});
-});

package/src/lib/schema/traversal.test.ts

@@ -1,92 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { getGroups, getLayoutItems, getInputItems } from '@selvajs/schemas';
-import type { UISchema } from '@selvajs/schemas';
-
-// These pin the layout-union discrimination (tabbed vs flat) and the defensive contract
-// (missing layout / groups / items yield empty, never throw), since this module is the
-// single place every caller relies on to walk a schema.
-
-const input = (id: string, source?: { kind: string }) =>
-	({ type: 'input', paramId: id, displayName: id, ...(source ? { source } : {}) }) as never;
-const linebreak = (id: string) => ({ type: 'linebreak', id }) as never;
-const group = (id: string, items: unknown[]) => ({ id, label: id, items }) as never;
-
-function schema(layout: unknown): UISchema {
-	return { layout } as unknown as UISchema;
-}
-
-describe('getGroups — layout discrimination', () => {
-	it('flattens tabs into a single group list, tab order preserved', () => {
-		const s = schema({
-			type: 'tabbed',
-			tabs: [
-				{ id: 't1', label: 't1', groups: [group('g1', []), group('g2', [])] },
-				{ id: 't2', label: 't2', groups: [group('g3', [])] }
-			]
-		});
-		expect(getGroups(s).map((g) => g.id)).toEqual(['g1', 'g2', 'g3']);
-	});
-
-	it('returns flat groups directly', () => {
-		const s = schema({ type: 'flat', groups: [group('g1', []), group('g2', [])] });
-		expect(getGroups(s).map((g) => g.id)).toEqual(['g1', 'g2']);
-	});
-});
-
-describe('getGroups — defensive contract', () => {
-	it('returns [] when layout is missing', () => {
-		expect(getGroups({} as UISchema)).toEqual([]);
-	});
-
-	it('returns [] for an unknown layout type', () => {
-		expect(getGroups(schema({ type: 'mystery' }))).toEqual([]);
-	});
-
-	it('tolerates missing tabs / groups arrays', () => {
-		expect(getGroups(schema({ type: 'tabbed' }))).toEqual([]);
-		expect(getGroups(schema({ type: 'flat' }))).toEqual([]);
-	});
-
-	it('tolerates a tab with no groups', () => {
-		const s = schema({ type: 'tabbed', tabs: [{ id: 't1', label: 't1' }] });
-		expect(getGroups(s)).toEqual([]);
-	});
-});
-
-describe('getLayoutItems', () => {
-	it('collects items across all groups', () => {
-		const s = schema({
-			type: 'flat',
-			groups: [group('g1', [input('a'), linebreak('lb')]), group('g2', [input('b')])]
-		});
-		expect(getLayoutItems(s).map((i) => (i.type === 'linebreak' ? i.id : i.paramId))).toEqual([
-			'a',
-			'lb',
-			'b'
-		]);
-	});
-
-	it('tolerates a group with no items', () => {
-		const s = schema({ type: 'flat', groups: [{ id: 'g1', label: 'g1' }] });
-		expect(getLayoutItems(s)).toEqual([]);
-	});
-});
-
-describe('getInputItems', () => {
-	it('keeps only input items, dropping outputs and linebreaks', () => {
-		const s = schema({
-			type: 'flat',
-			groups: [group('g1', [input('a'), linebreak('lb'), { type: 'output', paramId: 'out' }])]
-		});
-		expect(getInputItems(s).map((i) => i.paramId)).toEqual(['a']);
-	});
-
-	it('preserves the source field so client-input filters work', () => {
-		const s = schema({
-			type: 'flat',
-			groups: [group('g1', [input('a', { kind: 'client' }), input('b')])]
-		});
-		const clients = getInputItems(s).filter((i) => i.source?.kind === 'client');
-		expect(clients.map((i) => i.paramId)).toEqual(['a']);
-	});
-});

package/src/lib/schema/visibility-rules.test.ts

@@ -1,173 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import {
-	evaluateRule,
-	evaluateVisibility,
-	evaluateGroupVisibility,
-	buildVisibilityMap,
-	itemKey
-} from './visibility-rules';
-import type { GroupVisibilityCondition, LayoutItem, VisibilityRule } from '@selvajs/schemas';
-
-// These tests pin the non-obvious branches: operator edge cases that are easy to
-// break in a refactor, and the action/short-circuit precedence in evaluateVisibility.
-// Trivial passthroughs (equals true === true) are omitted on purpose.
-
-// `operator` is widened to string so tests can exercise the unknown-operator path.
-function rule(partial: {
-	operator: string;
-	paramId: string;
-	value?: unknown;
-	values?: unknown[];
-}): VisibilityRule {
-	return partial as unknown as VisibilityRule;
-}
-
-describe('evaluateRule — operator edge cases', () => {
-	it('between requires exactly two values and is inclusive', () => {
-		const r = rule({ operator: 'between', paramId: 'x', values: [10, 20] });
-		expect(evaluateRule(r, { x: 10 })).toBe(true); // lower bound inclusive
-		expect(evaluateRule(r, { x: 20 })).toBe(true); // upper bound inclusive
-		expect(evaluateRule(r, { x: 21 })).toBe(false);
-		// Wrong arity must fail closed, not throw or pass.
-		expect(evaluateRule(rule({ operator: 'between', paramId: 'x', values: [10] }), { x: 15 })).toBe(
-			false
-		);
-	});
-
-	it('matches returns false for an invalid regex instead of throwing', () => {
-		const r = rule({ operator: 'matches', paramId: 'x', value: '(' });
-		expect(evaluateRule(r, { x: 'anything' })).toBe(false);
-	});
-
-	it('contains / containsAny coerce scalars and arrays through toStringArray', () => {
-		// scalar value is treated as a single-element array
-		expect(evaluateRule(rule({ operator: 'contains', paramId: 'x', value: '5' }), { x: 5 })).toBe(
-			true
-		);
-		expect(
-			evaluateRule(rule({ operator: 'containsAny', paramId: 'x', values: ['a', 'b'] }), {
-				x: ['b', 'c']
-			})
-		).toBe(true);
-	});
-
-	it('isEmpty treats empty string, null, and [] as empty but not a non-empty value', () => {
-		const empty = rule({ operator: 'isEmpty', paramId: 'x' });
-		expect(evaluateRule(empty, { x: '' })).toBe(true);
-		expect(evaluateRule(empty, { x: null })).toBe(true);
-		expect(evaluateRule(empty, { x: [] })).toBe(true);
-		expect(evaluateRule(empty, { x: '0' })).toBe(false);
-	});
-
-	it('unknown operator fails closed', () => {
-		expect(evaluateRule(rule({ operator: 'definitelyNotAnOp', paramId: 'x' }), { x: 1 })).toBe(
-			false
-		);
-	});
-});
-
-describe('evaluateVisibility — action & short-circuit precedence', () => {
-	const condition = {
-		rules: [{ operator: 'equals', paramId: 'mode', value: 'advanced' }],
-		mode: 'all'
-	};
-
-	it('explicit visible:false beats any visibility condition', () => {
-		const item = {
-			type: 'input',
-			paramId: 'p',
-			visible: false,
-			visibilityCondition: { ...condition, action: 'show' }
-		} as unknown as LayoutItem;
-		// Condition is met, but visible:false wins.
-		expect(evaluateVisibility(item, { mode: 'advanced' })).toEqual({
-			visible: false,
-			disabled: false
-		});
-	});
-
-	it('hide action inverts visibility and only carries defaultValue', () => {
-		const item = {
-			type: 'input',
-			paramId: 'p',
-			visibilityCondition: { ...condition, action: 'hide', defaultValue: 7 }
-		} as unknown as LayoutItem;
-		expect(evaluateVisibility(item, { mode: 'advanced' })).toEqual({
-			visible: false,
-			disabled: false,
-			defaultValue: 7
-		});
-		expect(evaluateVisibility(item, { mode: 'basic' }).visible).toBe(true);
-	});
-
-	it('disable action keeps item visible and only applies defaultValue when the condition is met', () => {
-		const item = {
-			type: 'input',
-			paramId: 'p',
-			visibilityCondition: { ...condition, action: 'disable', defaultValue: 'X' }
-		} as unknown as LayoutItem;
-		expect(evaluateVisibility(item, { mode: 'advanced' })).toEqual({
-			visible: true,
-			disabled: true,
-			defaultValue: 'X'
-		});
-		expect(evaluateVisibility(item, { mode: 'basic' })).toEqual({
-			visible: true,
-			disabled: false,
-			defaultValue: undefined
-		});
-	});
-
-	it('item without a condition is visible and enabled', () => {
-		const item = { type: 'input', paramId: 'p' } as unknown as LayoutItem;
-		expect(evaluateVisibility(item, {})).toEqual({ visible: true, disabled: false });
-	});
-});
-
-describe('buildVisibilityMap', () => {
-	const cond = {
-		rules: [{ operator: 'equals', paramId: 'mode', value: 'advanced' }],
-		mode: 'all'
-	};
-
-	it('keys each item by paramId (inputs/outputs) or id (linebreak) and matches evaluateVisibility', () => {
-		const items = [
-			{ type: 'input', paramId: 'a' },
-			{ type: 'linebreak', id: 'lb1' },
-			{
-				type: 'input',
-				paramId: 'b',
-				visibilityCondition: { ...cond, action: 'show' }
-			}
-		] as unknown as LayoutItem[];
-		const values = { mode: 'basic' };
-
-		const map = buildVisibilityMap(items, values);
-		expect(map.a).toEqual(evaluateVisibility(items[0], values));
-		expect(map.lb1).toEqual(evaluateVisibility(items[1], values));
-		// 'b' shows only when mode === 'advanced'; here it's hidden.
-		expect(map.b.visible).toBe(false);
-		expect(map.b).toEqual(evaluateVisibility(items[2], values));
-	});
-
-	it('itemKey returns paramId for controls and id for linebreaks', () => {
-		expect(itemKey({ type: 'input', paramId: 'p1' } as unknown as LayoutItem)).toBe('p1');
-		expect(itemKey({ type: 'linebreak', id: 'lb' } as unknown as LayoutItem)).toBe('lb');
-	});
-});
-
-describe('evaluateGroupVisibility', () => {
-	it('hide action inverts, show is the default, no condition means visible', () => {
-		const cond = (action?: string): { visibilityCondition: GroupVisibilityCondition } => ({
-			visibilityCondition: {
-				action,
-				mode: 'all',
-				rules: [{ operator: 'equals', paramId: 'show', value: true }]
-			} as unknown as GroupVisibilityCondition
-		});
-		expect(evaluateGroupVisibility(cond('hide'), { show: true })).toBe(false);
-		expect(evaluateGroupVisibility(cond('show'), { show: true })).toBe(true);
-		expect(evaluateGroupVisibility(cond(), { show: true })).toBe(true);
-		expect(evaluateGroupVisibility({}, {})).toBe(true);
-	});
-});

package/src/lib/types/solveFn.ts

@@ -1,29 +0,0 @@
-/**
- * Result returned from a solve operation.
- *
- * @property outputs - Key-value pairs of computed results
- * @property meshes - Optional array of 3D mesh data generated during computation
- * @property errors - Optional array of error messages that occurred
- * @property warnings - Optional array of warning messages from the computation
- */
-export interface SolveResult {
-	outputs: Record<string, unknown>;
-	meshes?: any[];
-	errors?: string[];
-	warnings?: string[];
-}
-
-/**
- * Function type for running a computation with given input values.
- *
- * Implementations should listen to the abort signal and clean up resources
- * when the signal is triggered (e.g., when the user cancels the operation).
- *
- * @param values - Input parameters for the computation
- * @param signal - AbortSignal to cancel ongoing operations
- * @returns Promise resolving to the computation result
- */
-export type SolveFn = (
-	values: Record<string, unknown>,
-	signal: AbortSignal
-) => Promise<SolveResult>;