@selvajs/ui 6.0.0-beta.0 → 6.0.0-beta.1

package/README.md

@@ -1,6 +1,14 @@
 # @selvajs/ui
 
-Shared Svelte components, utilities, and theme system for Selva applications.
+The Svelte layer over Selva's framework-free cores. Its npm surface is the **compute-app SDK**:
+everything an external host app needs to embed a Grasshopper-driven app, drive solves, and wire
+pre-step producers.
+
+The design system (`Button`, `Card`, `Dialog`, `AppShell`, …) lives here too, but is **internal to
+the monorepo** — it is reachable from the full barrel via the `@selvajs/source` export condition and
+never ships to npm. [`src/lib/public.ts`](./src/lib/public.ts) is the authoritative list of what a
+published consumer can import; promote a primitive there explicitly rather than assuming it is
+available.
 
 ## Installation
 
@@ -8,20 +16,41 @@ Shared Svelte components, utilities, and theme system for Selva applications.
 pnpm add @selvajs/ui
 ```
 
-Peer dependencies required: `svelte ^5`, `@sveltejs/kit ^2`, `bits-ui ^2`, `tailwind-variants ^3`, `@selvajs/compute ^1`
+Peer dependencies: `svelte ^5`, `@sveltejs/kit ^2`, `bits-ui ^2`, `tailwind-variants ^3`, plus the
+Selva cores this package wraps — `@selvajs/compute`, `@selvajs/schemas`, `@selvajs/solve`, and
+`@selvajs/visualization`.
+
+`three` is an **optional** peer: install it only if you use `Viewer`, the part that wraps
+`@selvajs/visualization`.
 
 ## Usage
 
+Embed a whole Grasshopper-driven app:
+
+```svelte
+<script lang="ts">
+	import { ComputeApp } from '@selvajs/ui';
+</script>
+```
+
+Or render meshes on their own, outside a `ComputeApp` host:
+
 ```svelte
 <script lang="ts">
-	import { Button, Card, Input } from '@selvajs/ui';
+	import { Viewer, type ViewerConfig } from '@selvajs/ui';
 </script>
 ```
 
+To drive a solve session yourself rather than letting `ComputeApp` own it:
+
 ```typescript
-import { cn, debounce, themeStore } from '@selvajs/ui';
+import { useSolveSession } from '@selvajs/ui';
 ```
 
+The session itself lives in `@selvajs/solve/client` and is framework-free. Inside a Svelte
+component always use `useSolveSession` — the raw `createSolveSession` factory returns correct
+values that never re-render.
+
 ## Styles
 
 In your `app.css`:
@@ -30,16 +59,20 @@ In your `app.css`:
 @import '@selvajs/ui/styles/base.css';
 ```
 
-Themes are available under `@selvajs/ui/styles/themes/*`.
+Themes are available under `@selvajs/ui/styles/themes/*` — `selva`, `neutral`, `ocean`, and
+`cyberpunk`.
+
+## Schema types
 
-## Generated Types
+Types generated from `packages/schemas/ui-schema.json` are published by `@selvajs/schemas`, not
+re-exported here:
 
 ```typescript
-import type { UISchema } from '@selvajs/ui';
+import type { SelvaUISchema } from '@selvajs/schemas';
 ```
 
-Types are generated from `packages/schemas/ui-schema.json`. After modifying the schema, run:
+After modifying the schema, run:
 
 ```bash
-cd packages/schemas && pnpm run generate:all
+cd packages/schemas && pnpm run generate
 ```

package/dist/components/compute/ComputeApp.svelte

@@ -7,6 +7,7 @@
 	import type { PresetLabels } from '../../types/presetLabels';
 	import { createSolvingIndicator } from '../../compute/solving.svelte';
 	import { createRequestResponseDriver } from '@selvajs/solve/client';
+	import type { RetainedSolveResult } from '@selvajs/solve/client';
 	import { meshPolicy } from '@selvajs/visualization/parse';
 	import { useSolveSession } from '../../compute/useSolveSession.svelte';
 	import { useFooterItem } from '../../composables/useFooterItem.svelte';
@@ -43,13 +44,25 @@
 		copyrightName?: string;
 		/** Fully overrides the footer copyright line. `{name}` and `{year}` are substituted. */
 		footerText?: string;
-		/** Per-solve abort timeout (ms). Falls back to createComputeThrottle's default. */
-		solveTimeoutMs?: number;
+		/**
+		 * How long one solve may take before the client aborts it (ms). Required: pass
+		 * the same value the server enforces (`COMPUTE_SOLVE_DEADLINE_MS`), so the client
+		 * doesn't abort a solve that would have finished.
+		 */
+		solveDeadlineMs: number;
 		footerComponent?: any;
 		footerComponentProps?: () => Record<string, unknown>;
 		footerItemId?: string;
 		footerItemPriority?: number;
-		onReady?: (api: { loadValues: (values: Record<string, unknown>) => void }) => void;
+		onReady?: (api: {
+			loadValues: (values: Record<string, unknown>) => void;
+			/**
+			 * The last result reported to the session — the one the viewer is showing, carrying
+			 * `source`/`values` even when a memo hit served it. Null before the first solve.
+			 * A getter, not a snapshot: `onReady` fires once.
+			 */
+			getLastResult: () => RetainedSolveResult | null;
+		}) => void;
 		headerRight?: Snippet;
 		// Replaces the built-in header; takes precedence over `headerRight`.
 		header?: Snippet;
@@ -83,7 +96,7 @@
 		presetLabels,
 		copyrightName,
 		footerText,
-		solveTimeoutMs,
+		solveDeadlineMs,
 		footerComponent,
 		footerComponentProps,
 		footerItemId = 'footer-item',
@@ -114,7 +127,7 @@
 	// reads the reporter lazily so it can capture the session it's wired into.
 	// svelte-ignore state_referenced_locally
 	const driver = createRequestResponseDriver(onSolve, () => session, {
-		timeout: solveTimeoutMs,
+		solveDeadlineMs,
 		// The driver's result memo caches whole solve results, meshes included — and the viewer
 		// disposes what it renders on the next scene update. `@selvajs/solve` keeps meshes opaque,
 		// so the three.js clone/dispose rules are injected from the renderer that owns them
@@ -137,7 +150,10 @@
 	const solvingIndicator = createSolvingIndicator(() => session.isSolving);
 
 	$effect(() => {
-		onReady?.({ loadValues: (incoming) => session.loadValues(incoming) });
+		onReady?.({
+			loadValues: (incoming) => session.loadValues(incoming),
+			getLastResult: () => session.lastResult
+		});
 	});
 
 	let previousDefinitionKey = $state('');

package/dist/components/compute/ComputeApp.svelte.d.ts

@@ -2,6 +2,7 @@ import type { UISchema, ParameterPreset } from '@selvajs/schemas';
 import type { ActionButton } from '../../types/actionButton';
 import type { SolveFn } from '@selvajs/solve/shared';
 import type { PresetLabels } from '../../types/presetLabels';
+import type { RetainedSolveResult } from '@selvajs/solve/client';
 import { type ClientSlot } from '../../contexts/clientSlotContext.svelte';
 import type { Locale } from '../../i18n/messages';
 import type { Snippet } from 'svelte';
@@ -28,14 +29,24 @@ interface Props {
     copyrightName?: string;
     /** Fully overrides the footer copyright line. `{name}` and `{year}` are substituted. */
     footerText?: string;
-    /** Per-solve abort timeout (ms). Falls back to createComputeThrottle's default. */
-    solveTimeoutMs?: number;
+    /**
+     * How long one solve may take before the client aborts it (ms). Required: pass
+     * the same value the server enforces (`COMPUTE_SOLVE_DEADLINE_MS`), so the client
+     * doesn't abort a solve that would have finished.
+     */
+    solveDeadlineMs: number;
     footerComponent?: any;
     footerComponentProps?: () => Record<string, unknown>;
     footerItemId?: string;
     footerItemPriority?: number;
     onReady?: (api: {
         loadValues: (values: Record<string, unknown>) => void;
+        /**
+         * The last result reported to the session — the one the viewer is showing, carrying
+         * `source`/`values` even when a memo hit served it. Null before the first solve.
+         * A getter, not a snapshot: `onReady` fires once.
+         */
+        getLastResult: () => RetainedSolveResult | null;
     }) => void;
     headerRight?: Snippet;
     header?: Snippet;

package/dist/components/viewer/Viewer.svelte

@@ -194,10 +194,10 @@
 			measure: { enabled: config.showToolsMenu },
 			events: {
 				onMeshMetadataClicked: config.enableMeshClick
-					? (metadata: Record<string, string>) => {
+					? (metadata: Record<string, unknown>) => {
 							if (hasUsefulMetadata(metadata)) {
 								selectedMeshMetadata = metadata;
-								selectedMeshName = metadata?.name || t.objectFallbackName;
+								selectedMeshName = String(metadata?.name ?? '') || t.objectFallbackName;
 							}
 						}
 					: undefined

package/dist/compute/useSolveSession.svelte.js

@@ -55,6 +55,9 @@ export function useSolveSession(args) {
         get meshes() {
             return track(() => session.meshes);
         },
+        get lastResult() {
+            return track(() => session.lastResult);
+        },
         get hasPendingChanges() {
             return track(() => session.hasPendingChanges);
         },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@selvajs/ui",
-  "version": "6.0.0-beta.0",
+  "version": "6.0.0-beta.1",
   "description": "Shared UI components and utilities for Selva applications",
   "license": "MIT",
   "author": "VektorNode",
@@ -60,9 +60,9 @@
     "svelte": "^5",
     "tailwind-variants": "^3.3.0",
     "three": "^0.185.1",
-    "@selvajs/compute": "^4.0.0-beta.0",
+    "@selvajs/compute": "^4.0.0-beta.1",
     "@selvajs/schemas": "^4.7.0",
-    "@selvajs/solve": "^0.2.0-beta.0",
+    "@selvajs/solve": "^1.0.0-beta.5",
     "@selvajs/visualization": "^1.0.0-beta.0"
   },
   "peerDependenciesMeta": {
@@ -93,7 +93,10 @@
     "tailwind-variants": "^3.3.0",
     "vitest": "^4.1.10",
     "@selvajs/config": "0.0.3",
-    "@selvajs/schemas": "4.7.0"
+    "@selvajs/schemas": "4.7.0",
+    "@selvajs/visualization": "1.0.0-beta.0",
+    "@selvajs/solve": "1.0.0-beta.5",
+    "@selvajs/compute": "4.0.0-beta.1"
   },
   "scripts": {
     "predev": "node ../../scripts/sync-shared-assets.js",

package/src/lib/components/compute/ComputeApp.svelte

@@ -7,6 +7,7 @@
 	import type { PresetLabels } from '../../types/presetLabels';
 	import { createSolvingIndicator } from '../../compute/solving.svelte';
 	import { createRequestResponseDriver } from '@selvajs/solve/client';
+	import type { RetainedSolveResult } from '@selvajs/solve/client';
 	import { meshPolicy } from '@selvajs/visualization/parse';
 	import { useSolveSession } from '../../compute/useSolveSession.svelte';
 	import { useFooterItem } from '../../composables/useFooterItem.svelte';
@@ -43,13 +44,25 @@
 		copyrightName?: string;
 		/** Fully overrides the footer copyright line. `{name}` and `{year}` are substituted. */
 		footerText?: string;
-		/** Per-solve abort timeout (ms). Falls back to createComputeThrottle's default. */
-		solveTimeoutMs?: number;
+		/**
+		 * How long one solve may take before the client aborts it (ms). Required: pass
+		 * the same value the server enforces (`COMPUTE_SOLVE_DEADLINE_MS`), so the client
+		 * doesn't abort a solve that would have finished.
+		 */
+		solveDeadlineMs: number;
 		footerComponent?: any;
 		footerComponentProps?: () => Record<string, unknown>;
 		footerItemId?: string;
 		footerItemPriority?: number;
-		onReady?: (api: { loadValues: (values: Record<string, unknown>) => void }) => void;
+		onReady?: (api: {
+			loadValues: (values: Record<string, unknown>) => void;
+			/**
+			 * The last result reported to the session — the one the viewer is showing, carrying
+			 * `source`/`values` even when a memo hit served it. Null before the first solve.
+			 * A getter, not a snapshot: `onReady` fires once.
+			 */
+			getLastResult: () => RetainedSolveResult | null;
+		}) => void;
 		headerRight?: Snippet;
 		// Replaces the built-in header; takes precedence over `headerRight`.
 		header?: Snippet;
@@ -83,7 +96,7 @@
 		presetLabels,
 		copyrightName,
 		footerText,
-		solveTimeoutMs,
+		solveDeadlineMs,
 		footerComponent,
 		footerComponentProps,
 		footerItemId = 'footer-item',
@@ -114,7 +127,7 @@
 	// reads the reporter lazily so it can capture the session it's wired into.
 	// svelte-ignore state_referenced_locally
 	const driver = createRequestResponseDriver(onSolve, () => session, {
-		timeout: solveTimeoutMs,
+		solveDeadlineMs,
 		// The driver's result memo caches whole solve results, meshes included — and the viewer
 		// disposes what it renders on the next scene update. `@selvajs/solve` keeps meshes opaque,
 		// so the three.js clone/dispose rules are injected from the renderer that owns them
@@ -137,7 +150,10 @@
 	const solvingIndicator = createSolvingIndicator(() => session.isSolving);
 
 	$effect(() => {
-		onReady?.({ loadValues: (incoming) => session.loadValues(incoming) });
+		onReady?.({
+			loadValues: (incoming) => session.loadValues(incoming),
+			getLastResult: () => session.lastResult
+		});
 	});
 
 	let previousDefinitionKey = $state('');

package/src/lib/components/viewer/Viewer.svelte

@@ -194,10 +194,10 @@
 			measure: { enabled: config.showToolsMenu },
 			events: {
 				onMeshMetadataClicked: config.enableMeshClick
-					? (metadata: Record<string, string>) => {
+					? (metadata: Record<string, unknown>) => {
 							if (hasUsefulMetadata(metadata)) {
 								selectedMeshMetadata = metadata;
-								selectedMeshName = metadata?.name || t.objectFallbackName;
+								selectedMeshName = String(metadata?.name ?? '') || t.objectFallbackName;
 							}
 						}
 					: undefined

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

@@ -62,6 +62,9 @@ export function useSolveSession(args: SolveSessionArgs): SolveSession {
 		get meshes() {
 			return track(() => session.meshes);
 		},
+		get lastResult() {
+			return track(() => session.lastResult);
+		},
 		get hasPendingChanges() {
 			return track(() => session.hasPendingChanges);
 		},

package/src/lib/compute/mesh-policy-wiring.test.ts

@@ -1,72 +0,0 @@
-import * as THREE from 'three';
-import { describe, expect, it } from 'vitest';
-
-import { createRequestResponseDriver, type SolveReporter } from '@selvajs/solve/client';
-import type { SolveResult } from '@selvajs/solve/shared';
-import { meshPolicy } from '@selvajs/visualization/parse';
-
-// The C1 seam test. `@selvajs/solve` keeps meshes opaque and `@selvajs/visualization` owns the
-// three.js clone/dispose rules; neither package can prove they compose, because neither may
-// import the other. This is the only place both are in scope — it exists to catch a
-// `ComputeApp` that forgets to pass `meshPolicy`, or a policy whose shape drifts from
-// `MeshPolicy`.
-
-function meshResult(tag: string): SolveResult<THREE.Object3D> {
-	const mesh = new THREE.Mesh(new THREE.BoxGeometry(1, 1, 1), new THREE.MeshBasicMaterial());
-	mesh.name = tag;
-	return { outputs: { out: tag }, meshes: [mesh] };
-}
-
-/** Mirrors the viewer's `clearScene`: it disposes the geometry of whatever it was handed. */
-function renderAndDispose(result: SolveResult<THREE.Object3D>): void {
-	result.meshes?.forEach((root) =>
-		root.traverse((child) => (child as Partial<THREE.Mesh>).geometry?.dispose())
-	);
-}
-
-function collectingReporter(): SolveReporter<THREE.Object3D> & {
-	reports: SolveResult<THREE.Object3D>[];
-} {
-	const reports: SolveResult<THREE.Object3D>[] = [];
-	return {
-		reports,
-		report: (result) => reports.push(result),
-		reportError: () => {}
-	};
-}
-
-const flush = () => new Promise((resolve) => setTimeout(resolve, 0));
-
-describe('mesh policy wiring (audit C1)', () => {
-	it('a memo hit serves a live mesh after the viewer disposed the previous one', async () => {
-		const onSolve = async () => meshResult('a');
-		const reporter = collectingReporter();
-		const driver = createRequestResponseDriver(onSolve, () => reporter, { meshPolicy });
-
-		driver.solve({ a: 1 });
-		await flush();
-		renderAndDispose(reporter.reports[0]); // the viewer eats solve 1's meshes
-
-		driver.solve({ a: 1 }); // same inputs → memo hit, no onSolve call
-		await flush();
-
-		expect(reporter.reports).toHaveLength(2);
-		const served = reporter.reports[1].meshes![0] as THREE.Mesh;
-		expect(served).not.toBe(reporter.reports[0].meshes![0]);
-		expect(served.geometry.attributes.position).toBeDefined();
-	});
-
-	it('without a policy the same flow serves the disposed instance (why the wiring matters)', async () => {
-		// Pins the failure mode, so the assertion above is known to be testing something.
-		const onSolve = async () => meshResult('a');
-		const reporter = collectingReporter();
-		const driver = createRequestResponseDriver(onSolve, () => reporter); // no meshPolicy
-
-		driver.solve({ a: 1 });
-		await flush();
-		driver.solve({ a: 1 });
-		await flush();
-
-		expect(reporter.reports[1].meshes![0]).toBe(reporter.reports[0].meshes![0]);
-	});
-});

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);
-	});
-});