@selvajs/ui 6.0.0-beta.8 → 6.0.0

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

@@ -1,12 +1,10 @@
 import type { SolveSession, SolveSessionArgs } from '@selvajs/solve/client';
 /**
- * Wraps a Solve Session so its state reads reactively inside Svelte components.
+ * Wraps a Solve Session so its state reads reactively inside Svelte components. Use this in
+ * a component, never `createSolveSession` directly: the raw session's getters return correct
+ * values but never re-render.
  *
- * Returns the same `SolveSession` surface — every method delegates untouched, and every
- * getter additionally depends on the version counter. Callers use it exactly like the
- * session it wraps.
- *
- * Must be called during component initialization (it uses `$effect` to manage the
- * subscription, so teardown follows the owning component's lifecycle).
+ * Must be called during component initialization — the subscription is managed by `$effect`,
+ * so teardown follows the owning component's lifecycle.
  */
 export declare function useSolveSession(args: SolveSessionArgs): SolveSession;

package/dist/compute/useSolveSession.svelte.js

@@ -1,35 +1,22 @@
-// The Svelte binding for a Solve Session.
-//
-// The session itself lives in `@selvajs/solve/client` and is framework-free: it
-// exposes plain getters plus a `subscribe()` seam. That makes it usable headless, but a
-// plain getter read inside Svelte markup is NOT reactive — nothing tells the component to
-// re-run. This adapter closes that gap: it subscribes once, bumps a `$state` version
-// counter on every notification, and reads that counter inside each getter so any
-// component touching one re-runs when the session changes.
-//
-// The counter (rather than mirroring each field into its own `$state`) keeps this a pure
-// republish: no field list to keep in sync as the session grows, and no risk of a mirrored
-// copy drifting from the source of truth.
+// A version counter, rather than mirroring each field into its own `$state`, keeps this a
+// pure republish: no field list to keep in sync as the session grows, and no mirrored copy
+// that can drift from the source of truth.
 import { createSolveSession } from '@selvajs/solve/client';
 /**
- * Wraps a Solve Session so its state reads reactively inside Svelte components.
+ * Wraps a Solve Session so its state reads reactively inside Svelte components. Use this in
+ * a component, never `createSolveSession` directly: the raw session's getters return correct
+ * values but never re-render.
  *
- * Returns the same `SolveSession` surface — every method delegates untouched, and every
- * getter additionally depends on the version counter. Callers use it exactly like the
- * session it wraps.
- *
- * Must be called during component initialization (it uses `$effect` to manage the
- * subscription, so teardown follows the owning component's lifecycle).
+ * Must be called during component initialization — the subscription is managed by `$effect`,
+ * so teardown follows the owning component's lifecycle.
  */
 export function useSolveSession(args) {
     const session = createSolveSession(args);
-    // Bumped on every session notification. Reading it inside a getter is what registers
-    // the dependency; the value itself is never meaningful.
+    // Reading this inside a getter is what registers the dependency; the value never matters.
     let version = $state(0);
     $effect(() => {
-        // Re-read on mount and unsubscribe on teardown. The session outlives no component
-        // here — it is created alongside this adapter — so dropping the subscription is the
-        // whole cleanup.
+        // The session is created alongside this adapter and outlives no other component, so
+        // dropping the subscription is the whole cleanup.
         return session.subscribe(() => {
             version += 1;
         });

package/dist/constants.js

@@ -1,10 +1,10 @@
 export const APP_DEFAULTS = {
     // File upload limits
     // TEMP (dev): raised 150 MB → 300 MB so large dev file-widget inputs aren't
-    // blocked client-side. The server request cap (COMPUTE_REQUEST_MAX_BYTES) was
-    // bumped to 300 MB to match, but base64 inflates a raw file by ~4/3, so a
-    // full 300 MB upload still won't fit the 300 MB request body. Revert to 150
-    // before release.
+    // blocked client-side. The server request cap (COMPUTE_REQUEST_MAX_BYTES)
+    // still defaults to 210 MB, and base64 inflates a raw file by ~4/3, so
+    // anything over ~157 MB is rejected with a 413 after the client accepts it.
+    // Revert to 150 before release.
     FILE_UPLOAD: {
         MAX_SIZE_MB: 300,
         MAX_SIZE_BYTES: 300 * 1024 * 1024

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

@@ -4,13 +4,11 @@ export interface ClientSlotArgs {
     /** Grasshopper parameter instance GUID (LayoutItem.paramId / SchemaInput.id). */
     inputId: string;
     displayName: string;
-    /** The current value held for this input (e.g. the prefilled JSON), if any. */
     value: unknown;
     /**
-     * Commit a value for this input. Identical channel to a built-in widget's change
-     * — the value lands in the solve session and is sent to Compute on the next solve.
-     * `forceSolve` requests a solve even in manual-solve mode (system reconciliation).
-     * Lets a slot be an interactive control (a custom picker), not just a display cell.
+     * Commit a value for this input — the same channel a built-in widget's change uses, so a
+     * slot can be an interactive control rather than just a display cell. `forceSolve`
+     * requests a solve even in manual-solve mode.
      */
     onValueChange: (value: SupportedTypes, forceSolve?: boolean) => void;
 }

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

@@ -1,19 +1,17 @@
 import { type Component } from 'svelte';
 import { SvelteMap } from 'svelte/reactivity';
 /**
- * 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
+ * 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: Component<P>;
-    /** Called on every render — return reactive state to keep footer in sync. */
+    /**
+     * Re-invoked on every render. Return reactive state — `() => ({ status: s.status })` —
+     * or the footer never updates.
+     */
     getProps: () => P;
     position: 'left' | 'right';
     priority: number;

package/dist/external/storage.js

@@ -1,4 +1,3 @@
-// Moved to `@selvajs/solve/client`, where the Solve Session that hydrates from it
-// now lives. Re-exported here to keep the published `@selvajs/ui/external` sub-path — and
-// the pre-step producer routes that import it — working unchanged.
+// Moved to @selvajs/solve/client, beside the Solve Session that hydrates from it.
+// Re-exported to keep the published `@selvajs/ui/external` sub-path working unchanged.
 export { writeExternalValue, readExternalValue, clearExternalValue, getExternalInputs } from '@selvajs/solve/client';

package/dist/i18n/localeContext.svelte.d.ts

@@ -1,18 +1,16 @@
 import { type Locale, type ViewerMessages } from './messages';
 export interface LocaleContext {
-    /** Current locale. Called reactively — return reactive state to enable live switching. */
     readonly locale: Locale;
-    /** Resolved message catalog for the current locale. */
     readonly messages: ViewerMessages;
 }
 /**
- * Provide the locale to descendants. Pass a getter so a reactive source (a
- * `$state`, a store, the app's Paraglide locale) keeps consumers in sync.
+ * Provide the locale to descendants. Pass a getter, not a value: it is re-read on every
+ * consumer render, so a reactive source (a `$state`, the app's Paraglide locale) switches
+ * the language live.
  */
 export declare function setLocaleContext(getLocale: () => Locale | undefined): void;
 /**
- * Read the locale context. Falls back to an English-only context when no
- * provider exists (e.g. a primitive used in isolation), so consumers never
- * need a null check.
+ * Falls back to an English-only context when no provider exists (a primitive used in
+ * isolation), so consumers never need a null check.
  */
 export declare function getLocaleContext(): LocaleContext;

package/dist/i18n/localeContext.svelte.js

@@ -1,13 +1,7 @@
 import { getContext, setContext } from 'svelte';
 import { messagesFor, DEFAULT_LOCALE } from './messages';
-// ============================================================================
-// Viewer locale context
-// ============================================================================
-//
-// Carries the current UI locale down to the viewer and its panels without
-// threading a `lang` prop through every layer. The value is a getter so the
-// host can back it with reactive state — flip the language and the viewer
-// re-renders live.
+// Carries the UI locale down to the viewer and its panels without threading a
+// `lang` prop through every layer.
 //
 // Resolution order for any consuming component:
 //   explicit `lang` prop  →  nearest locale context  →  English default
@@ -15,12 +9,12 @@ import { messagesFor, DEFAULT_LOCALE } from './messages';
 // Two ways to provide it:
 //   - Standalone: <Viewer lang="de" /> — Viewer provides the context itself.
 //   - In an app: call setLocaleContext(() => app.locale) once at the root; the
-//     viewer (and anything else) reads it. selva later wires its Paraglide
-//     locale in here.
+//     viewer (and anything else) reads it.
 const LOCALE_CONTEXT_KEY = Symbol('viewer-locale-context');
 /**
- * Provide the locale to descendants. Pass a getter so a reactive source (a
- * `$state`, a store, the app's Paraglide locale) keeps consumers in sync.
+ * Provide the locale to descendants. Pass a getter, not a value: it is re-read on every
+ * consumer render, so a reactive source (a `$state`, the app's Paraglide locale) switches
+ * the language live.
  */
 export function setLocaleContext(getLocale) {
     const ctx = {
@@ -34,9 +28,8 @@ export function setLocaleContext(getLocale) {
     setContext(LOCALE_CONTEXT_KEY, ctx);
 }
 /**
- * Read the locale context. Falls back to an English-only context when no
- * provider exists (e.g. a primitive used in isolation), so consumers never
- * need a null check.
+ * Falls back to an English-only context when no provider exists (a primitive used in
+ * isolation), so consumers never need a null check.
  */
 export function getLocaleContext() {
     return (getContext(LOCALE_CONTEXT_KEY) ?? {

package/dist/i18n/messages.d.ts

@@ -7,9 +7,7 @@ export interface ViewerMessages {
     views: string;
     measure: string;
     grid: string;
-    /** "Display" submenu label — groups render style + edges. */
     display: string;
-    /** Edges show/hide toggle label. */
     edges: string;
     sceneManager: string;
     screenshot: string;

package/dist/i18n/messages.js

@@ -2,14 +2,9 @@
 // Viewer message catalog (library-owned strings)
 // ============================================================================
 //
-// These are the strings @selvajs/ui renders itself in the 3D viewer and its
-// panels — tool menu, view presets, scene manager, metadata dialog. They are
-// NOT the strings that come from a Grasshopper definition (mesh/layer/metadata
-// names): those live in the user's .gh file and can't be translated here.
-//
-// The library ships English + German. A host app can switch locale at runtime
-// via the locale context (see ./localeContext.svelte.ts) — e.g. selva feeds its
-// own Paraglide locale in. With no provider, components fall back to English.
+// Only the strings @selvajs/ui renders itself. Names coming from a Grasshopper
+// definition — meshes, layers, metadata keys — live in the user's .gh file and
+// cannot be translated here.
 const en = {
     toolsMenu: 'Viewer tools',
     switchTo2D: 'Switch to 2D',

package/dist/index.js

@@ -1,34 +1,28 @@
-// Layout components (page chrome: shell, header, footer, nav)
+// The in-monorepo barrel: everything public.ts publishes, plus the design system,
+// page chrome, contexts and utils that never ship to npm. Reached via the
+// "selva-source" export condition.
 export * from './components/layout';
-// Compute app (schema + viewer + solve controls composed into a runnable app)
 export { default as AppLayout } from './components/compute/AppLayout.svelte';
 export { default as ComputeApp } from './components/compute/ComputeApp.svelte';
-// Error screen
 export { default as ErrorScreen } from './components/ErrorScreen.svelte';
 // Design-system primitives (shadcn-svelte + custom)
 export * from './components/primitives';
 export { default as StateDisplay } from './components/primitives/StateDisplay.svelte';
-// 3D viewer
 export { default as Viewer } from './components/viewer/Viewer.svelte';
-// Utilities
 export * from './schema/defaults';
 export * from './schema/dynamic-value-list';
 export * from './schema/traversal';
 export * from './compute/solving.svelte';
-// Solve Session seam. The session itself now lives in `@selvajs/solve/client`
-// (framework-free); `useSolveSession` is this package's Svelte binding, which republishes
-// the session's subscribe() notifications as rune state so its getters read reactively in
-// markup. Re-exported so transports outside this package — e.g. plugin-ui's WebSocket
-// driver — can satisfy SolveDriver and drive a session. See CONTEXT.md.
+// Solve Session seam. Re-exported so transports outside this package — e.g.
+// plugin-ui's WebSocket driver — can satisfy SolveDriver and drive a session.
+// See CONTEXT.md.
 export { useSolveSession } from './compute/useSolveSession.svelte';
 export { createSolveSession, createRequestResponseDriver } from '@selvajs/solve/client';
-// External-input transit storage (used by routes that wire pre-step producers)
+// Pre-step producer transit storage
 export { writeExternalValue, readExternalValue, clearExternalValue, getExternalInputs } from '@selvajs/solve/client';
-// Contexts & Composables
 export * from './contexts/footerContext.svelte';
 export * from './contexts/clientSlotContext.svelte';
 export * from './composables/useFooterItem.svelte';
-// Utils (cn function)
 export * from './utils';
 export { randomId } from './utils/randomId';
 export { DEFAULT_PRESET_LABELS } from './types/presetLabels';

package/dist/public.js

@@ -1,46 +1,30 @@
-// ============================================================================
-// Published public API of @selvajs/ui
-// ============================================================================
+// The only surface npm consumers of @selvajs/ui see. package.json maps the "."
+// export's `svelte`/`types` conditions at this file's build output.
 //
-// This is the ONLY surface npm consumers of @selvajs/ui see (package.json maps
-// the "." export's `svelte`/`types` conditions at this file's build output).
-//
-// Scope: the compute-app SDK — everything an external host app needs to embed a
-// Grasshopper-driven app (ComputeApp), drive solves, and wire pre-step
-// producers. Verified against real external host apps: they import
-// ComputeApp + its types, the solve seam, and the external-input storage
-// helpers. Nothing else.
-//
-// Deliberately NOT public: design-system primitives (Button, Card, Dialog, …),
-// page-chrome layout (AppShell, SideNav, …), toast/Toaster, ThemeSwitcher,
-// DataTable, contexts/composables, cn/randomId. These remain importable from
-// the full barrel (./index.ts) INSIDE the monorepo via the "@selvajs/source"
-// export condition, but never ship to npm. If an external consumer ever needs a
-// primitive directly, promote it here explicitly rather than re-exporting the
-// whole primitives barrel.
-// Compute app (schema + viewer + solve controls composed into a runnable app)
+// Design-system primitives, page chrome, toasts, DataTable, contexts and small
+// utils stay out on purpose: they remain importable from ./index.ts inside the
+// monorepo via the "selva-source" export condition, but never ship to npm.
+// Promote a symbol here explicitly rather than re-exporting a whole barrel.
+// Compute app: schema + viewer + solve controls composed into a runnable app.
 export { default as AppLayout } from './components/compute/AppLayout.svelte';
 export { default as ComputeApp } from './components/compute/ComputeApp.svelte';
-// Standalone 3D viewer. Render Grasshopper meshes on their own, outside a
-// ComputeApp host — external apps drive it directly with a `meshes` array and
-// an optional `viewerConfig`. Pass `lang` to localize its chrome, or provide a
-// locale context (setLocaleContext) at the host root to drive it app-wide.
+// Standalone 3D viewer: renders Grasshopper meshes outside a ComputeApp host,
+// driven directly with a `meshes` array and an optional `viewerConfig`.
 export { default as Viewer } from './components/viewer/Viewer.svelte';
 export { appSource, isHostOwned, isOwnedBy, pointerToNdc } from '@selvajs/visualization/render';
 export { VIEWER_MESSAGES, DEFAULT_LOCALE, messagesFor } from './i18n/messages';
 export { setLocaleContext, getLocaleContext } from './i18n/localeContext.svelte';
-// Full-screen states a host app renders
+// Full-screen states a host app renders.
 export { default as ErrorScreen } from './components/ErrorScreen.svelte';
-// Solve Session seam (transport-agnostic value/lifecycle state machine + its
-// driver interface). The session lives in `@selvajs/solve/client` and is
+// Solve Session seam, for hosts driving a session themselves rather than
+// embedding <ComputeApp>. The session lives in `@selvajs/solve/client` and is
 // framework-free; `useSolveSession` is the Svelte binding that makes its getters
-// read reactively inside components. A host embedding <ComputeApp> needs neither —
-// both are re-exported for hosts driving a session themselves. See CONTEXT.md.
+// read reactively inside components. See CONTEXT.md.
 export { useSolveSession } from './compute/useSolveSession.svelte';
 export { createSolveSession, createRequestResponseDriver } from '@selvajs/solve/client';
 // Pre-step producer transit storage (host apps wire producers via these).
 export { writeExternalValue, readExternalValue, clearExternalValue, getExternalInputs } from '@selvajs/solve/client';
-// Schema utilities a ComputeApp host reasonably needs to read/shape values.
+// Schema utilities a ComputeApp host needs to read/shape values.
 export * from './schema/defaults';
 export * from './schema/traversal';
 export * from './schema/dynamic-value-list';

package/dist/schema/defaults.js

@@ -1,4 +1,3 @@
-// Moved to @selvajs/schemas so server-side callers can share it without pulling
-// in the UI package. Re-exported here to keep existing `@selvajs/ui` importers
-// working.
+// Moved to @selvajs/schemas so server-side callers can share it without pulling in the
+// UI package. Re-exported to keep existing @selvajs/ui importers working.
 export { getDefaultValue } from '@selvajs/schemas';

package/dist/schema/dynamic-value-list.js

@@ -27,12 +27,11 @@ function coercePayload(value) {
     return null;
 }
 // Memoizes string-payload coercion. In compute mode the payload arrives as a JSON
-// string — potentially several MB for a large options list — and the options map is
-// derived from `values` (TabLayout), so it recomputes on EVERY value change. Without
-// memoization each keystroke/output-merge re-parses megabytes and allocates a fresh
-// options object, whose new identity re-renders the entire dropdown subtree; with a
-// 6.4 MB payload this was measured driving a tab out of memory. Map keys use
-// SameValueZero, so an identical response string from a later solve also hits.
+// string — several MB for a large options list — and the options map is derived from
+// `values` (TabLayout), so it recomputes on EVERY value change. Unmemoized, each
+// keystroke re-parses megabytes and allocates a fresh options object whose new
+// identity re-renders the whole dropdown subtree; a 6.4 MB payload drove a tab OOM.
+// Map keys use SameValueZero, so an identical string from a later solve also hits.
 const coerceCache = new Map();
 const COERCE_CACHE_MAX = 8;
 function coercePayloadMemo(value) {
@@ -48,10 +47,9 @@ function coercePayloadMemo(value) {
     }
     const parseStart = performance.now();
     const parsed = coercePayload(value);
-    // Diagnostic: an expensive parse should happen ONCE per distinct solve result.
-    // If this line storms in the console, payload memoization is being defeated
-    // (e.g. payload strings differing per recompute) — the pre-memoization churn
-    // pattern that could OOM a tab.
+    // An expensive parse should happen ONCE per distinct solve result. If this line
+    // storms the console, memoization is being defeated (payload strings differing
+    // per recompute) — the churn pattern that could OOM a tab.
     if (value.length > 256 * 1024) {
         const optionCount = parsed?.options ? Object.keys(parsed.options).length : 0;
         console.info(`[DVL] parsed ${(value.length / (1024 * 1024)).toFixed(1)} MB options payload ` +
@@ -68,11 +66,11 @@ function coercePayloadMemo(value) {
 /**
  * Every dynamicValueList output reference in the schema.
  *
- * Canonical location is `schema.outputs[]` — the plugin's SchemaSynchronizer enforces that every
- * dynamicValueList layout item is mirrored there (see CanonicalizeDynamicValueListOutputs). We ALSO
- * scan the layout purely as back-compat defense for schemas persisted by an older plugin that lacked
- * that invariant; for current schemas the layout pass finds nothing new.
- * Deduped by id, outputs[] winning so the canonical record's targetInputId takes precedence.
+ * Canonical location is `schema.outputs[]` — the plugin's SchemaSynchronizer mirrors every
+ * dynamicValueList layout item there (`CanonicalizeDynamicValueListOutputs`). The layout scan is
+ * back-compat defense for schemas persisted by an older plugin that lacked that invariant; on
+ * current schemas it finds nothing new. Deduped by id, `outputs[]` winning so the canonical
+ * record's targetInputId takes precedence.
  */
 function collectDynamicValueListSources(schema) {
     const byId = new Map();

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

@@ -11,29 +11,22 @@ export declare function validateSavedState(savedState: ParameterPreset, currentS
     canLoad: boolean;
 };
 /**
- * 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.
+ * Params the current schema no longer has are dropped. That's the same condition
+ * `validateSavedState` flags as an error, but the rule is re-derived from the schema here
+ * rather than read back off the issue list — nothing couples 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). */
+    /** Safe to apply now — the params that still exist in the schema. */
     values: Record<string, unknown>;
-    /** All validation issues (errors + warnings) for the load dialog. */
+    /** Errors and warnings both, for the load dialog. */
     issues: ValidationIssueMessage[];
     /** No issues at all — load silently. */
     isValid: boolean;
-    /** No blocking errors — load is allowed (warnings are fine). */
+    /** No errors — warnings alone still allow the load. */
     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.
- */
+/** Validates and computes the loadable values in one pass, so callers thread one object. */
 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

@@ -75,11 +75,9 @@ export function validateSavedState(savedState, currentSchema) {
     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.
+ * Params the current schema no longer has are dropped. That's the same condition
+ * `validateSavedState` flags as an error, but the rule is re-derived from the schema here
+ * rather than read back off the issue list — nothing couples to how sentinel ids are encoded.
  */
 export function extractLoadableValues(savedState, currentSchema) {
     const values = {};
@@ -91,11 +89,7 @@ export function extractLoadableValues(savedState, currentSchema) {
     }
     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.
- */
+/** Validates and computes the loadable values in one pass, so callers thread one object. */
 export function loadPreset(savedState, currentSchema) {
     const validation = validateSavedState(savedState, currentSchema);
     return {
@@ -111,8 +105,8 @@ export function exportStateAsJson(savedState) {
     const date = savedState.timestamp.split('T')[0].replace(/-/g, '_');
     const link = document.createElement('a');
     link.href = URL.createObjectURL(blob);
-    // .slvp = Selva parameter preset. Import accepts legacy .sps files too — the content is
-    // identical JSON, only the writer's extension changed.
+    // .slvp = Selva parameter preset. Import still accepts the pre-rename .sps — same JSON,
+    // only the writer's extension changed.
     link.download = `${safeName}_${date}.slvp`;
     link.click();
     URL.revokeObjectURL(link.href);

package/dist/schema/traversal.js

@@ -1,5 +1,4 @@
-// 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.
+// Moved to @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 to keep existing
+// @selvajs/ui importers working.
 export { getGroups, getLayoutItems, getInputItems } from '@selvajs/schemas';

package/dist/schema/visibility-rules.d.ts

@@ -7,16 +7,12 @@ export interface VisibilityResult {
 export declare function evaluateRule(rule: VisibilityRule, values: Record<string, unknown>): boolean;
 export declare function evaluateCondition(condition: VisibilityCondition | GroupVisibilityCondition, values: Record<string, unknown>): boolean;
 export declare function evaluateVisibility(item: LayoutItem, values: Record<string, unknown>): VisibilityResult;
-/**
- * Stable key for a layout item: `paramId` for inputs/outputs, `id` for linebreaks.
- * Mirrors the key the renderers use in their `{#each}` blocks.
- */
+/** Must stay identical to the key the renderers use in their `{#each}` blocks. */
 export declare function itemKey(item: LayoutItem): string;
 /**
- * Evaluates every item's visibility once against the current values, keyed by itemKey.
- * Callers that touch the same items more than once per render (column layout + cell
- * render, plus the default-value sweep) read from this single map instead of
- * re-evaluating per access — one source of truth for "what's visible right now".
+ * Evaluates each item once per render. Callers that touch the same item several times
+ * (column layout, then cell render, then the default-value sweep) read this map instead of
+ * re-evaluating, so they can't disagree about what's visible mid-render.
  */
 export declare function buildVisibilityMap(items: LayoutItem[], values: Record<string, unknown>): Record<string, VisibilityResult>;
 export declare function evaluateGroupVisibility(group: {

package/dist/schema/visibility-rules.js

@@ -57,18 +57,14 @@ export function evaluateVisibility(item, values) {
     const actionFn = ACTIONS[action] ?? ACTIONS.show;
     return actionFn(met, defaultValue);
 }
-/**
- * Stable key for a layout item: `paramId` for inputs/outputs, `id` for linebreaks.
- * Mirrors the key the renderers use in their `{#each}` blocks.
- */
+/** Must stay identical to the key the renderers use in their `{#each}` blocks. */
 export function itemKey(item) {
     return item.type === 'linebreak' ? item.id : item.paramId;
 }
 /**
- * Evaluates every item's visibility once against the current values, keyed by itemKey.
- * Callers that touch the same items more than once per render (column layout + cell
- * render, plus the default-value sweep) read from this single map instead of
- * re-evaluating per access — one source of truth for "what's visible right now".
+ * Evaluates each item once per render. Callers that touch the same item several times
+ * (column layout, then cell render, then the default-value sweep) read this map instead of
+ * re-evaluating, so they can't disagree about what's visible mid-render.
  */
 export function buildVisibilityMap(items, values) {
     const map = {};

package/dist/types/actionButton.d.ts

@@ -1,31 +1,7 @@
-/**
- * Defines an action button for use in the UI.
- *
- * @example
- * ```typescript
- * const saveButton: ActionButton = {
- *   id: 'save-btn',
- *   label: 'Save Changes',
- *   icon: SaveIcon,
- *   variant: 'default',
- *   size: 'lg',
- *   onclick: async () => {
- *     await saveData();
- *     showNotification('Saved!');
- *   }
- * };
- * ```
- *
- * @property id - Unique identifier for this button
- * @property label - Display text shown on the button
- * @property icon - Optional icon component to display alongside the label
- * @property variant - Button styling variant (controls color/appearance)
- * @property size - Button size preset
- * @property onclick - Callback function executed when clicked; can be async
- */
 export interface ActionButton {
     id: string;
     label: string;
+    /** A Svelte component, rendered before the label. */
     icon?: any;
     variant?: 'default' | 'outline' | 'destructive' | 'secondary' | 'ghost';
     size?: 'default' | 'sm' | 'lg';

package/dist/types/presetLabels.d.ts

@@ -1,7 +1,6 @@
 /**
- * Overridable UI strings for the parameter-preset manager (Save/Load flow) and
- * footer copyright text. All optional — unset keys fall back to the English
- * defaults in `DEFAULT_PRESET_LABELS`. Pass a partial object to localize.
+ * Overridable UI strings for the parameter-preset manager. Pass a partial object to localize;
+ * unset keys fall back to `DEFAULT_PRESET_LABELS`.
  */
 export interface PresetLabels {
     saveButton: string;