@selvajs/ui 4.3.0 → 4.5.0

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

@@ -0,0 +1,99 @@
+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/external/storage.ts

@@ -8,7 +8,8 @@
 //
 // inputId is the Grasshopper parameter instance GUID (LayoutItem.paramId / SchemaInput.id).
 
-import type { UISchema, LayoutItem, GroupConfig, InputSource } from '@selvajs/schemas';
+import type { UISchema } from '@selvajs/schemas';
+import { getInputItems } from '@selvajs/schemas';
 
 const STORAGE_PREFIX = 'external';
 
@@ -53,28 +54,11 @@ export interface ExternalInput {
 	displayName: string;
 }
 
-function* walkLayoutItems(schema: UISchema): Generator<LayoutItem> {
-	const groups: GroupConfig[] =
-		schema.layout.type === 'tabbed'
-			? schema.layout.tabs.flatMap((t) => t.groups)
-			: schema.layout.groups;
-	for (const group of groups) {
-		for (const item of group.items) {
-			yield item;
-		}
-	}
-}
-
 export function getExternalInputs(schema: UISchema): ExternalInput[] {
-	const result: ExternalInput[] = [];
-	for (const item of walkLayoutItems(schema)) {
-		if (item.type !== 'input') continue;
-		const source = (item as { source?: InputSource }).source;
-		if (source?.kind !== 'client') continue;
-		result.push({
+	return getInputItems(schema)
+		.filter((item) => item.source?.kind === 'client')
+		.map((item) => ({
 			paramId: item.paramId,
 			displayName: item.displayName ?? item.paramId
-		});
-	}
-	return result;
+		}));
 }

package/src/lib/index.ts

@@ -17,8 +17,21 @@ export { default as Viewer } from './components/viewer/Viewer.svelte';
 
 // Utilities
 export * from './schema/defaults';
+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
+// driver — can satisfy SolveDriver and drive a session. See CONTEXT.md.
+export {
+	createSolveSession,
+	createRequestResponseDriver,
+	type SolveSession,
+	type SolveSessionArgs,
+	type SolveDriver,
+	type SolveReporter
+} from './compute/createSolveSession.svelte';
+
 // External-input transit storage (used by routes that wire pre-step producers)
 export * from './external/storage';
 
@@ -33,5 +46,5 @@ export { randomId } from './utils/randomId';
 
 // UI-specific runtime types (not from schema)
 export type { ActionButton } from './types/actionButton';
-export type { SolveFn } from './types/solveFn';
+export type { SolveFn, SolveResult } from './types/solveFn';
 export { DEFAULT_PRESET_LABELS, type PresetLabels } from './types/presetLabels';

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

@@ -0,0 +1,136 @@
+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/param-exporter.ts

@@ -1,5 +1,5 @@
-import { APP_DEFAULTS } from '../constants';
 import { randomId } from '../utils/randomId';
+import { getGroups } from '@selvajs/schemas';
 import type {
 	UISchema,
 	ParameterPreset,
@@ -7,13 +7,6 @@ import type {
 	ValidationIssueMessage
 } from '@selvajs/schemas';
 
-function getGroups(schema: UISchema) {
-	if (!schema.layout) return [];
-	if (schema.layout.type === 'tabbed') return schema.layout.tabs.flatMap((t) => t.groups ?? []);
-	if (schema.layout.type === 'flat') return schema.layout.groups ?? [];
-	return [];
-}
-
 export function createSavedState(
 	schema: UISchema,
 	currentValues: Record<string, unknown>,
@@ -113,43 +106,64 @@ export function validateSavedState(
 	return { isValid: issues.length === 0, issues, canLoad: !hasErrors };
 }
 
+/**
+ * The subset of a preset's parameters that can safely be applied to the current schema:
+ * every param that still exists as an input. A param that no longer exists is dropped
+ * (it's the same condition `validateSavedState` flags as an error), so this derives its
+ * own "loadable" rule from the schema rather than re-reading validation issues — no
+ * coupling to how sentinel ids are encoded.
+ */
 export function extractLoadableValues(
 	savedState: ParameterPreset,
-	currentSchema: UISchema,
-	validation: ReturnType<typeof validateSavedState>
+	currentSchema: UISchema
 ): Record<string, unknown> {
-	const errorParamIds = new Set(
-		validation.issues
-			.filter((i) => i.severity === 'error' && !i.paramId.startsWith('__'))
-			.map((i) => i.paramId)
-	);
-
 	const values: Record<string, unknown> = {};
 	for (const paramState of savedState.parameters) {
 		const exists = currentSchema.inputs.some((i) => i.id === paramState.paramId);
-		if (!errorParamIds.has(paramState.paramId) && exists) {
+		if (exists) {
 			values[paramState.paramId] = paramState.value;
 		}
 	}
 	return values;
 }
 
+/** The full outcome of loading a preset: what to apply, plus the diagnostics to surface. */
+export interface PresetLoadResult {
+	/** Values safe to apply now (params that still exist). */
+	values: Record<string, unknown>;
+	/** All validation issues (errors + warnings) for the load dialog. */
+	issues: ValidationIssueMessage[];
+	/** No issues at all — load silently. */
+	isValid: boolean;
+	/** No blocking errors — load is allowed (warnings are fine). */
+	canLoad: boolean;
+}
+
+/**
+ * Single entry point for applying a preset: validates against the current schema and, in
+ * the same pass, computes the loadable values. Callers get one object instead of
+ * threading a validation result back into a separate extraction step.
+ */
+export function loadPreset(savedState: ParameterPreset, currentSchema: UISchema): PresetLoadResult {
+	const validation = validateSavedState(savedState, currentSchema);
+	return {
+		values: extractLoadableValues(savedState, currentSchema),
+		issues: validation.issues,
+		isValid: validation.isValid,
+		canLoad: validation.canLoad
+	};
+}
+
 export function exportStateAsJson(savedState: ParameterPreset): void {
 	const blob = new Blob([JSON.stringify(savedState, null, 2)], { type: 'application/json' });
-	const url = URL.createObjectURL(blob);
+	const safeName = savedState.name.replace(/[^a-z0-9]/gi, '_');
+	const date = savedState.timestamp.split('T')[0].replace(/-/g, '_');
+
 	const link = document.createElement('a');
-	link.href = url;
-	link.download = `${savedState.name.replace(/[^a-z0-9]/gi, '_')}_${savedState.timestamp.split('T')[0].replace(/-/g, '_')}.sps`;
-	link.style.display = 'none';
-	document.body.appendChild(link);
-
-	setTimeout(() => {
-		link.click();
-		setTimeout(() => {
-			document.body.removeChild(link);
-			URL.revokeObjectURL(url);
-		}, APP_DEFAULTS.TIMEOUTS.PARAM_EXPORT_DELAY);
-	}, 0);
+	link.href = URL.createObjectURL(blob);
+	link.download = `${safeName}_${date}.sps`;
+	link.click();
+	URL.revokeObjectURL(link.href);
 }
 
 export async function importStateFromJson(file: File): Promise<ParameterPreset> {

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

@@ -0,0 +1,92 @@
+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/traversal.ts

@@ -0,0 +1,5 @@
+// Schema layout traversal now lives in @selvajs/schemas (next to the types it walks) so
+// any package depending on the schema can traverse it without pulling in @selvajs/ui.
+// Re-exported here to keep it part of @selvajs/ui's published surface for existing
+// consumers.
+export { getGroups, getLayoutItems, getInputItems, type InputLayoutItem } from '@selvajs/schemas';

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

@@ -0,0 +1,173 @@
+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);
+	});
+});