@selvajs/ui 4.2.0 → 4.4.0

package/dist/composables/useFooterItem.svelte.js

@@ -1,33 +1,26 @@
 import { getContext, onMount, onDestroy } from 'svelte';
 import { FOOTER_CONTEXT_KEY } from '../contexts/footerContext.svelte';
 /**
- * Register a footer item component that reactively updates its props.
- * The `getProps` function is called on every render, so returning reactive state
- * (e.g. `() => ({ status: myState.status })`) will keep the footer in sync.
+ * Register a footer item for the lifetime of the calling component.
  *
- * Registration is deferred to onMount (client-side only) to avoid SSR context errors.
- *
- * @param id        - Unique identifier for this footer item
- * @param component - Svelte component to render
- * @param getProps  - Function returning current props (called reactively)
- * @param position  - Where to display ('left' or 'right'), defaults to 'left'
- * @param priority  - Higher values render first within their position
- * @param onClick   - Optional click handler (e.g. open a popup/dialog)
+ * Registration is deferred to onMount (client-side only) to avoid SSR context errors;
+ * it's unregistered on destroy. A no-op when no footer context is present (e.g. a
+ * component rendered outside the root layout) or no component is supplied.
  */
-export function useFooterItem(id, component, getProps, position = 'left', priority = 0, onClick) {
+export function useFooterItem(config) {
     onMount(() => {
         const store = getContext(FOOTER_CONTEXT_KEY);
-        if (!store || !component)
+        if (!store || !config.component)
             return;
-        store.register(id, component, getProps, position, priority, onClick);
+        store.register(config);
     });
     onDestroy(() => {
         try {
             const store = getContext(FOOTER_CONTEXT_KEY);
-            store?.unregister(id);
+            store?.unregister(config.id);
         }
         catch {
-            // Context may not exist during SSR cleanup — safe to ignore
+            // Context may not exist during SSR cleanup — safe to ignore.
         }
     });
 }

package/dist/compute/computeThrottle.svelte.js

@@ -30,8 +30,11 @@ export function createComputeThrottle(computeFn, options = {}) {
             await computeFn(values, signal);
         }
         catch (err) {
-            if (!(err instanceof Error && err.name === 'AbortError')) {
-                throw err;
+            // AbortError is expected (timeout or cancel). Non-abort errors must be
+            // handled inside computeFn — re-throwing here would produce an unhandled
+            // rejection because executeCompute is always called fire-and-forget.
+            if (!(err instanceof Error) || (err.name !== 'AbortError' && err.name !== 'TimeoutError')) {
+                console.error('[computeThrottle] unhandled error in computeFn:', err);
             }
         }
         finally {

package/dist/compute/createSolveSession.svelte.d.ts

@@ -0,0 +1,56 @@
+import type { UISchema } from '@selvajs/schemas';
+import type { SolveFn, SolveResult } from '../types/solveFn';
+/**
+ * The transport behind a Solve Session. Knows how to start and cancel a solve and
+ * reports its in-flight state. It does NOT return outputs — those come back via the
+ * session's report() so push transports (WebSocket) fit without contortion.
+ */
+export interface SolveDriver {
+    solve(values: Record<string, unknown>): void;
+    cancel(): void;
+    readonly isSolving: boolean;
+}
+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. */
+    setValue(id: string, value: unknown): void;
+    /** Explicit "calculate" — dispatches a solve with the current values. */
+    solve(): void;
+    /** Merges incoming values, then solves (auto) or marks dirty (manual). */
+    loadValues(incoming: Record<string, unknown>): void;
+    /** Re-seed for a new active definition: rebuild values, clear outputs, gate the solve. */
+    rebuild(schema: UISchema, scopeKey: string): void;
+    /** Feed a completed solve result back into the session (called by the driver/host). */
+    report(result: SolveResult): void;
+    /** Report a solve failure (transport/solver error) — surfaces in `error`. */
+    reportError(message: string): void;
+}
+export interface SolveSessionArgs {
+    schema: UISchema;
+    scopeKey: string;
+    driver: SolveDriver;
+}
+export declare function createSolveSession(args: SolveSessionArgs): SolveSession;
+/** The slice of a SolveSession a driver feeds completed/failed solves back into. */
+export interface SolveReporter {
+    report(result: SolveResult): void;
+    reportError(message: string): void;
+}
+/**
+ * Request/response Solve Driver: wraps createComputeThrottle around a SolveFn and feeds
+ * the resolved result back through the reporter. One solve in flight at a time; the
+ * latest triggered values win. Used by ComputeApp (Rhino.Compute over HTTP).
+ *
+ * Because the session and driver reference each other, the host passes the reporter
+ * lazily (`() => session`) so it can construct the session with the driver in hand.
+ */
+export declare function createRequestResponseDriver(onSolve: SolveFn, getReporter: () => SolveReporter, options?: {
+    timeout?: number;
+}): SolveDriver;

package/dist/compute/createSolveSession.svelte.js

@@ -0,0 +1,122 @@
+// Reactive Solve Session (see CONTEXT.md): the $state-backed shell over the pure
+// transition logic in solve-session-core.ts. It owns the live values/flags, delegates
+// every transition to the core, and drives solves through a transport-agnostic
+// SolveDriver. A completed solve re-enters via report().
+import { readExternalValue } from '../external/storage';
+import { createComputeThrottle } from './computeThrottle.svelte';
+import { buildInitialValues, makeInitialFlags, applyValueChange, applySolveResult } from './solve-session-core';
+export function createSolveSession(args) {
+    let currentSchema = args.schema;
+    const flags = makeInitialFlags(currentSchema?.instanceSolve);
+    const state = $state({
+        values: buildInitialValues(currentSchema, args.scopeKey, readExternalValue),
+        error: '',
+        computeErrors: [],
+        computeWarnings: [],
+        meshes: [],
+        pendingValues: {},
+        hasPendingChanges: flags.hasPendingChanges,
+        hasNeverSolved: flags.hasNeverSolved
+    });
+    function dispatch() {
+        args.driver.solve($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) {
+            const { shouldSolve } = applyValueChange(state, id, value, currentSchema?.instanceSolve);
+            if (shouldSolve)
+                dispatch();
+        },
+        solve() {
+            dispatch();
+        },
+        loadValues(incoming) {
+            Object.assign(state.values, incoming);
+            if (currentSchema?.instanceSolve !== false) {
+                dispatch();
+            }
+            else {
+                state.hasPendingChanges = true;
+            }
+        },
+        rebuild(schema, scopeKey) {
+            currentSchema = schema;
+            state.meshes = [];
+            state.error = '';
+            state.computeErrors = [];
+            state.computeWarnings = [];
+            state.pendingValues = {};
+            state.values = buildInitialValues(schema, scopeKey, readExternalValue);
+            const f = makeInitialFlags(schema?.instanceSolve);
+            state.hasPendingChanges = f.hasPendingChanges;
+            state.hasNeverSolved = f.hasNeverSolved;
+            if (schema && Object.keys(state.values).length > 0 && schema.instanceSolve !== false) {
+                dispatch();
+            }
+        },
+        report(result) {
+            applySolveResult(state, result);
+        },
+        reportError(message) {
+            state.error = message;
+        }
+    };
+}
+/**
+ * Request/response Solve Driver: wraps createComputeThrottle around a SolveFn and feeds
+ * the resolved result back through the reporter. One solve in flight at a time; the
+ * latest triggered values win. Used by ComputeApp (Rhino.Compute over HTTP).
+ *
+ * Because the session and driver reference each other, the host passes the reporter
+ * lazily (`() => session`) so it can construct the session with the driver in hand.
+ */
+export function createRequestResponseDriver(onSolve, getReporter, options = {}) {
+    const throttle = createComputeThrottle(async (values, signal) => {
+        try {
+            const result = await onSolve(values, signal);
+            if (signal.aborted)
+                return;
+            getReporter().report(result);
+        }
+        catch (err) {
+            if (signal.aborted)
+                return;
+            getReporter().reportError(err instanceof Error ? err.message : String(err));
+        }
+    }, options);
+    return {
+        solve(values) {
+            throttle.trigger(values);
+        },
+        cancel() {
+            throttle.cancel();
+        },
+        get isSolving() {
+            return throttle.isComputing;
+        }
+    };
+}

package/dist/compute/solve-session-core.d.ts

@@ -0,0 +1,45 @@
+import type { UISchema } from '@selvajs/schemas';
+import { type ExternalValueRef } from '../external/storage';
+import type { SolveResult } from '../types/solveFn';
+export interface SolveSessionState {
+    values: Record<string, unknown>;
+    error: string;
+    computeErrors: string[];
+    computeWarnings: string[];
+    meshes: unknown[];
+    /** Values changed since the last solve, in manual (instanceSolve === false) mode. */
+    pendingValues: Record<string, unknown>;
+    hasPendingChanges: boolean;
+    hasNeverSolved: boolean;
+}
+/** Reads a previously produced client-sourced value, or undefined if absent. */
+export type ExternalReader = (ref: ExternalValueRef) => unknown | undefined;
+/**
+ * Builds the initial `values` map for a schema. Non-client inputs get their declared
+ * default (falling back to the paramType default); client-sourced inputs are hydrated
+ * from `read` and left absent when no stored value exists so the missing-inputs panel
+ * can detect them. Outputs are seeded to null.
+ */
+export declare function buildInitialValues(schema: UISchema, scopeKey: string, read: ExternalReader): Record<string, unknown>;
+/**
+ * Initial lifecycle flags. Manual-solve schemas (instanceSolve === false) start dirty
+ * so the user must explicitly calculate; auto-solve schemas start clean.
+ */
+export declare function makeInitialFlags(instanceSolve: boolean | undefined): {
+    hasPendingChanges: boolean;
+    hasNeverSolved: boolean;
+};
+/**
+ * Records a single value change and decides whether it should dispatch a solve now.
+ * Auto-solve mode dispatches immediately; manual mode defers (records the pending value
+ * and raises the dirty flag) and never dispatches.
+ */
+export declare function applyValueChange(state: SolveSessionState, id: string, value: unknown, instanceSolve: boolean | undefined): {
+    state: SolveSessionState;
+    shouldSolve: boolean;
+};
+/**
+ * Merges a reported solve result into the state and clears the post-solve lifecycle
+ * flags. Missing result arrays are treated as empty.
+ */
+export declare function applySolveResult(state: SolveSessionState, result: SolveResult): SolveSessionState;

package/dist/compute/solve-session-core.js

@@ -0,0 +1,69 @@
+// 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 { getDefaultValue } from '../schema/defaults';
+import { getExternalInputs } from '../external/storage';
+/**
+ * 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, scopeKey, read) {
+    const clientSet = new Set(getExternalInputs(schema).map((e) => e.paramId));
+    const values = {};
+    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) {
+    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, id, value, instanceSolve) {
+    state.values[id] = value;
+    if (instanceSolve === false) {
+        state.pendingValues[id] = value;
+        state.hasPendingChanges = true;
+        return { state, shouldSolve: false };
+    }
+    return { state, shouldSolve: true };
+}
+/**
+ * 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, result) {
+    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;
+}

package/dist/constants.d.ts

@@ -6,8 +6,6 @@ export declare const APP_DEFAULTS: {
     TIMEOUTS: {
         /** Duration to show solving state (ms) */
         SOLVE_STATE_DURATION: number;
-        /** Parameter export callback delay (ms) */
-        PARAM_EXPORT_DELAY: number;
         /** Drawer open/close animation duration (ms) — matches the CSS transition. */
         DRAWER_ANIMATION_MS: number;
     };

package/dist/constants.js

@@ -8,8 +8,6 @@ export const APP_DEFAULTS = {
     TIMEOUTS: {
         /** Duration to show solving state (ms) */
         SOLVE_STATE_DURATION: 3500,
-        /** Parameter export callback delay (ms) */
-        PARAM_EXPORT_DELAY: 100,
         /** Drawer open/close animation duration (ms) — matches the CSS transition. */
         DRAWER_ANIMATION_MS: 350
     },

package/dist/contexts/clientSlotContext.svelte.d.ts

@@ -0,0 +1,13 @@
+import type { Snippet } from 'svelte';
+export interface ClientSlotArgs {
+    /** Grasshopper parameter instance GUID (LayoutItem.paramId / SchemaInput.id). */
+    inputId: string;
+    displayName: string;
+    /** Author-set label from the schema, passed through untouched. May be undefined. */
+    slotLabel?: string;
+    /** The current value held for this input (e.g. the prefilled JSON), if any. */
+    value: unknown;
+}
+export type ClientSlot = Snippet<[ClientSlotArgs]>;
+export declare function setClientSlot(slot: ClientSlot | undefined): void;
+export declare function getClientSlot(): ClientSlot | undefined;

package/dist/contexts/clientSlotContext.svelte.js

@@ -0,0 +1,8 @@
+import { getContext, setContext } from 'svelte';
+const CLIENT_SLOT_CONTEXT_KEY = Symbol('client-slot-context');
+export function setClientSlot(slot) {
+    setContext(CLIENT_SLOT_CONTEXT_KEY, slot);
+}
+export function getClientSlot() {
+    return getContext(CLIENT_SLOT_CONTEXT_KEY);
+}

package/dist/contexts/footerContext.svelte.d.ts

@@ -1,16 +1,28 @@
+import { type Component } from 'svelte';
 import { SvelteMap } from 'svelte/reactivity';
-export interface FooterItem {
+/**
+ * A footer item registered by a descendant of the root layout. `component` + `position`
+ * are fixed at registration; the renderer re-invokes `getProps` reactively, so return
+ * reactive state from it (e.g. `() => ({ status: myState.status })`) to keep the footer
+ * in sync.
+ *
+ * Generic over the component's props `P` so registration is type-checked at the call
+ * site. The store holds a heterogeneous mix of items, so its map widens `P` to
+ * `Record<string, unknown>` at the boundary.
+ */
+export interface FooterItem<P extends Record<string, unknown> = Record<string, unknown>> {
     id: string;
-    component: any;
-    /** Called on every render — return reactive state to keep footer in sync */
-    getProps: () => Record<string, any>;
+    component: Component<P>;
+    /** Called on every render — return reactive state to keep footer in sync. */
+    getProps: () => P;
     position: 'left' | 'right';
     priority: number;
     onClick?: () => void;
 }
 export interface FooterStore {
     items: SvelteMap<string, FooterItem>;
-    register(id: string, component: any, getProps: () => Record<string, any>, position?: 'left' | 'right', priority?: number, onClick?: () => void): void;
+    /** Register (or replace) a footer item. `position`/`priority` default to 'left'/0. */
+    register<P extends Record<string, unknown>>(item: Omit<FooterItem<P>, 'position' | 'priority'> & Partial<Pick<FooterItem<P>, 'position' | 'priority'>>): void;
     unregister(id: string): void;
 }
 export declare const FOOTER_CONTEXT_KEY: unique symbol;

package/dist/contexts/footerContext.svelte.js

@@ -5,8 +5,16 @@ export function initializeFooterContext() {
     const items = new SvelteMap();
     const store = {
         items,
-        register(id, component, getProps, position = 'left', priority = 0, onClick) {
-            items.set(id, { id, component, getProps, position, priority, onClick });
+        register(item) {
+            const { id, component, getProps, position = 'left', priority = 0, onClick } = item;
+            items.set(id, {
+                id,
+                component: component,
+                getProps: getProps,
+                position,
+                priority,
+                onClick
+            });
         },
         unregister(id) {
             items.delete(id);

package/dist/external/storage.js

@@ -7,6 +7,7 @@
 // definition guid in selva/library, etc.
 //
 // inputId is the Grasshopper parameter instance GUID (LayoutItem.paramId / SchemaInput.id).
+import { getInputItems } from '@selvajs/schemas';
 const STORAGE_PREFIX = 'external';
 function makeKey(scopeKey, inputId) {
     return `${STORAGE_PREFIX}:${scopeKey}:${inputId}`;
@@ -43,28 +44,11 @@ export function clearExternalValue(ref) {
         return;
     sessionStorage.removeItem(makeKey(scopeKey, inputId));
 }
-function* walkLayoutItems(schema) {
-    const groups = 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) {
-    const result = [];
-    for (const item of walkLayoutItems(schema)) {
-        if (item.type !== 'input')
-            continue;
-        const source = item.source;
-        if (source?.kind !== 'client')
-            continue;
-        result.push({
-            paramId: item.paramId,
-            displayName: item.displayName ?? item.paramId
-        });
-    }
-    return result;
+    return getInputItems(schema)
+        .filter((item) => item.source?.kind === 'client')
+        .map((item) => ({
+        paramId: item.paramId,
+        displayName: item.displayName ?? item.paramId
+    }));
 }

package/dist/index.d.ts

@@ -6,9 +6,11 @@ export * from './components/primitives';
 export { default as StateDisplay } from './components/primitives/StateDisplay.svelte';
 export { default as Viewer } from './components/viewer/Viewer.svelte';
 export * from './schema/defaults';
+export * from './schema/traversal';
 export * from './compute/solving.svelte';
 export * from './external/storage';
 export * from './contexts/footerContext.svelte';
+export * from './contexts/clientSlotContext.svelte';
 export * from './composables/useFooterItem.svelte';
 export * from './utils';
 export { randomId } from './utils/randomId';

package/dist/index.js

@@ -12,11 +12,13 @@ export { default as StateDisplay } from './components/primitives/StateDisplay.sv
 export { default as Viewer } from './components/viewer/Viewer.svelte';
 // Utilities
 export * from './schema/defaults';
+export * from './schema/traversal';
 export * from './compute/solving.svelte';
 // External-input transit storage (used by routes that wire pre-step producers)
 export * from './external/storage';
 // Contexts & Composables
 export * from './contexts/footerContext.svelte';
+export * from './contexts/clientSlotContext.svelte';
 export * from './composables/useFooterItem.svelte';
 // Utils (cn function)
 export * from './utils';

package/dist/schema/param-exporter.d.ts

@@ -10,6 +10,30 @@ export declare function validateSavedState(savedState: ParameterPreset, currentS
     issues: ValidationIssueMessage[];
     canLoad: boolean;
 };
-export declare function extractLoadableValues(savedState: ParameterPreset, currentSchema: UISchema, validation: ReturnType<typeof validateSavedState>): Record<string, unknown>;
+/**
+ * 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 declare function extractLoadableValues(savedState: ParameterPreset, currentSchema: UISchema): Record<string, unknown>;
+/** 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 declare function loadPreset(savedState: ParameterPreset, currentSchema: UISchema): PresetLoadResult;
 export declare function exportStateAsJson(savedState: ParameterPreset): void;
 export declare function importStateFromJson(file: File): Promise<ParameterPreset>;

package/dist/schema/param-exporter.js

@@ -1,14 +1,5 @@
-import { APP_DEFAULTS } from '../constants';
 import { randomId } from '../utils/randomId';
-function getGroups(schema) {
-    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 [];
-}
+import { getGroups } from '@selvajs/schemas';
 export function createSavedState(schema, currentValues, metadata) {
     const parameters = [];
     for (const group of getGroups(schema)) {
@@ -83,34 +74,46 @@ export function validateSavedState(savedState, currentSchema) {
     const hasErrors = issues.some((i) => i.severity === 'error');
     return { isValid: issues.length === 0, issues, canLoad: !hasErrors };
 }
-export function extractLoadableValues(savedState, currentSchema, validation) {
-    const errorParamIds = new Set(validation.issues
-        .filter((i) => i.severity === 'error' && !i.paramId.startsWith('__'))
-        .map((i) => i.paramId));
+/**
+ * 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, currentSchema) {
     const values = {};
     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;
 }
+/**
+ * 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, currentSchema) {
+    const validation = validateSavedState(savedState, currentSchema);
+    return {
+        values: extractLoadableValues(savedState, currentSchema),
+        issues: validation.issues,
+        isValid: validation.isValid,
+        canLoad: validation.canLoad
+    };
+}
 export function exportStateAsJson(savedState) {
     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) {
     const state = JSON.parse(await file.text());

package/dist/schema/traversal.d.ts

@@ -0,0 +1 @@
+export { getGroups, getLayoutItems, getInputItems, type InputLayoutItem } from '@selvajs/schemas';

package/dist/schema/traversal.js

@@ -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 } from '@selvajs/schemas';