@selvajs/ui 6.5.1-beta.1 → 6.6.0-beta.11

package/dist/i18n/messages.js

@@ -5,6 +5,9 @@
 // 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.
+//
+// A `{name}` in a message is a placeholder the component fills in. Pairs ending in
+// `One`/`Other` are the singular and plural forms of one message.
 const en = {
     toolsMenu: 'Viewer tools',
     switchToOrthographic: 'Orthographic camera',
@@ -26,6 +29,13 @@ const en = {
     viewLeft: 'Left',
     viewBottom: 'Bottom',
     viewIso: 'Isometric',
+    lookTechnical: 'Technical',
+    lookStudio: 'Studio',
+    lookShowcase: 'Showcase',
+    lookArctic: 'Arctic',
+    lookXray: 'X-Ray',
+    lookLineart: 'Line Art',
+    lookWireframe: 'Wireframe',
     searchObjects: 'Search objects...',
     clearSearch: 'Clear search',
     expandLayer: 'Expand layer',
@@ -40,7 +50,7 @@ const en = {
     noResultsFor: 'No results for "{query}"',
     objectFallbackName: 'Object',
     noMetadata: 'No metadata',
-    loadingSchema: 'Loading schema...',
+    loadingSchema: 'Loading…',
     solveBlocked: 'The definition stopped this solve. No results were produced.',
     solveBlockedTitle: 'Solve stopped',
     solveMessagesTitle: 'Solve messages',
@@ -48,22 +58,129 @@ const en = {
     solveMessagesConfirm: 'Continue',
     solveMessagesDiscard: 'Discard',
     solveMessagesAbort: 'Abort',
+    solveMessagesEscHint: 'Esc aborts the solve',
     solveMessagesDismiss: 'Dismiss',
     solveSolving: 'Solving…',
     parametersTab: 'Parameters',
     moreTab: 'More',
-    expandPanel: 'Expand panel',
-    collapsePanel: 'Collapse panel',
+    scrollTabsBack: 'Previous tabs',
+    scrollTabsForward: 'More tabs',
     expandSidePanel: 'Expand {side} panel',
     panelSideLeft: 'left',
     panelSideRight: 'right',
     tabNoGroups: 'This tab has no groups configured.',
     solving: 'Solving',
     solvingEllipsis: 'Solving...',
-    solvingSubtitle: 'Grasshopper is calculating...',
+    solvingSubtitle: 'This can take a moment…',
     pressToCalculate: 'Press to calculate',
     calculate: 'Calculate',
-    upToDate: 'Up to date'
+    upToDate: 'Up to date',
+    moreActions: 'More actions',
+    calculatesFirst: 'Calculates first',
+    errorCountOne: '{count} error',
+    errorCountOther: '{count} errors',
+    warningCountOne: '{count} warning',
+    warningCountOther: '{count} warnings',
+    noteCountOne: '{count} note',
+    noteCountOther: '{count} notes',
+    lastSolveMessagesOne: '{count} message from the last solve',
+    lastSolveMessagesOther: '{count} messages from the last solve',
+    messagesTitle: 'Messages',
+    copyright: 'by {name} © {year}',
+    close: 'Close',
+    toggleTheme: 'Toggle theme',
+    errorTitle: 'Error',
+    goHome: 'Go Home',
+    selectOption: 'Select an option...',
+    noOptionsYet: 'No options available yet.',
+    minValue: 'Minimum value is {min}',
+    maxValue: 'Maximum value is {max}',
+    fineDragHint: 'Hold Shift to drag finely',
+    maxLength: 'Maximum {max} characters allowed',
+    invalidFormat: 'Invalid format',
+    invalidPattern: 'Invalid validation pattern configured',
+    geometryPickAnyOne: 'Pick an object',
+    geometryPickAnyOther: 'Pick objects',
+    geometryPicking: 'Pick in the viewport, Esc to cancel',
+    geometryPickInPanel: 'Pick in the Rhino panel',
+    geometryPickAgain: 'Pick again',
+    geometryClear: 'Clear',
+    geometryPickPointOne: 'Pick a point',
+    geometryPickPointOther: 'Pick points',
+    geometryPickPointCloudOne: 'Pick a point cloud',
+    geometryPickPointCloudOther: 'Pick point clouds',
+    geometryPickCurveOne: 'Pick a curve',
+    geometryPickCurveOther: 'Pick curves',
+    geometryPickLineOne: 'Pick a line',
+    geometryPickLineOther: 'Pick lines',
+    geometryPickPlaneOne: 'Pick a plane',
+    geometryPickPlaneOther: 'Pick planes',
+    geometryPickSurfaceOne: 'Pick a surface',
+    geometryPickSurfaceOther: 'Pick surfaces',
+    geometryPickPolysurfaceOne: 'Pick a polysurface',
+    geometryPickPolysurfaceOther: 'Pick polysurfaces',
+    geometryPickExtrusionOne: 'Pick an extrusion',
+    geometryPickExtrusionOther: 'Pick extrusions',
+    geometryPickMeshOne: 'Pick a mesh',
+    geometryPickMeshOther: 'Pick meshes',
+    geometryPickSubdOne: 'Pick a SubD',
+    geometryPickSubdOther: 'Pick SubDs',
+    geometryPickBlockOne: 'Pick a block',
+    geometryPickBlockOther: 'Pick blocks',
+    fileModeUpload: 'Upload',
+    fileModeUrl: 'URL',
+    fileUrlLabel: 'File URL',
+    fetchFile: 'Fetch',
+    fetchingFile: 'Fetching...',
+    fileUrlPublic: 'URL must be publicly accessible (no login required).',
+    chooseFile: 'Choose File or Drag & Drop',
+    acceptedFormats: 'Accepted formats: {formats}',
+    uploadedFile: 'Uploaded file ({ext})',
+    uploadedFileSize: 'Uploaded file ({ext}, {size}MB)',
+    fileLoaded: 'Loaded {ext} ({size} KB)',
+    urlInvalid: 'Invalid URL — make sure it starts with https://',
+    urlProtocolUnsupported: 'Only http:// and https:// URLs are supported.',
+    urlServerError: 'Server returned {status}. Check the URL is correct and publicly accessible.',
+    fileFormatNotAccepted: 'File format "{ext}" is not accepted. Allowed: {formats}',
+    fileTooLarge: 'File too large: {size}MB (max {max}MB).',
+    fileTooLargeUseUpload: 'Download it and use Upload instead.',
+    fileReadFailed: 'Failed to read the downloaded file.',
+    urlUnreachable: 'Could not reach "{host}" — the file may not exist, or the server does not allow browser access.',
+    urlUnreachableHint: 'Check that the URL is correct and the file is publicly accessible. If the server requires login, download the file and use the Upload option instead.',
+    urlHintSharePoint: 'SharePoint/OneDrive blocks browser access. Open the file in SharePoint, use "Download" to save it locally, then upload it here.',
+    urlHintGoogleDrive: 'Google Drive blocks browser access. Use "Download" in Google Drive to save the file locally, then upload it here.',
+    urlHintDropbox: 'Dropbox links may block browser access. Try changing "?dl=0" to "?dl=1" in the URL, or download and upload instead.',
+    unknownError: 'Unknown error',
+    waitingForData: 'Waiting for data...',
+    waitingForFiles: 'Waiting for file data...',
+    fileCount: '{count} files',
+    duplicateFilesTitle: 'Duplicate file names detected',
+    duplicatePathsOne: 'The following path appears more than once:',
+    duplicatePathsOther: 'The following paths appear more than once:',
+    duplicateFilesHint: 'Rename outputs in your Grasshopper definition so each file has a unique name.',
+    downloadFile: 'Download File',
+    downloadFiles: 'Download {count} Files',
+    downloading: 'Downloading...',
+    downloadFailed: 'Download failed',
+    copy: 'Copy',
+    copied: 'Copied!',
+    chartReceiving: 'Receiving chart data...',
+    chartRenderFailed: 'Failed to render chart',
+    fullscreenUnavailable: 'Fullscreen unavailable: {error}',
+    exitFullscreenFailed: 'Exit fullscreen failed: {error}',
+    imageViewer: 'image viewer',
+    imageLoading: 'Loading image…',
+    imageUnsupported: 'Unsupported image format: {ext}. Supported: {formats}',
+    imageUnknownFormat: '(unknown)',
+    imageDecodeFailed: "Couldn't decode {file}",
+    previousImage: 'Previous image',
+    nextImage: 'Next image',
+    zoomHint: 'Hold Ctrl or ⌘ and scroll to zoom',
+    zoomIn: 'Zoom in',
+    zoomOut: 'Zoom out',
+    zoomFit: 'Fit',
+    zoomActual: 'Actual pixels',
+    downloadImage: 'Download image'
 };
 const de = {
     toolsMenu: 'Viewer-Werkzeuge',
@@ -86,6 +203,13 @@ const de = {
     viewLeft: 'Links',
     viewBottom: 'Unten',
     viewIso: 'Isometrisch',
+    lookTechnical: 'Technisch',
+    lookStudio: 'Studio',
+    lookShowcase: 'Präsentation',
+    lookArctic: 'Arktis',
+    lookXray: 'Röntgen',
+    lookLineart: 'Strichzeichnung',
+    lookWireframe: 'Drahtgitter',
     searchObjects: 'Objekte suchen...',
     clearSearch: 'Suche löschen',
     expandLayer: 'Ebene aufklappen',
@@ -100,7 +224,7 @@ const de = {
     noResultsFor: 'Keine Ergebnisse für „{query}“',
     objectFallbackName: 'Objekt',
     noMetadata: 'Keine Metadaten',
-    loadingSchema: 'Schema wird geladen...',
+    loadingSchema: 'Wird geladen…',
     solveBlocked: 'Die Definition hat diese Berechnung gestoppt. Es wurden keine Ergebnisse erzeugt.',
     solveBlockedTitle: 'Berechnung gestoppt',
     solveMessagesTitle: 'Meldungen zur Berechnung',
@@ -108,22 +232,129 @@ const de = {
     solveMessagesConfirm: 'Weiter',
     solveMessagesDiscard: 'Verwerfen',
     solveMessagesAbort: 'Abbrechen',
+    solveMessagesEscHint: 'Esc bricht die Berechnung ab',
     solveMessagesDismiss: 'Schliessen',
     solveSolving: 'Berechnung läuft…',
     parametersTab: 'Parameter',
     moreTab: 'Mehr',
-    expandPanel: 'Bereich aufklappen',
-    collapsePanel: 'Bereich zuklappen',
+    scrollTabsBack: 'Vorherige Tabs',
+    scrollTabsForward: 'Weitere Tabs',
     expandSidePanel: '{side} Bereich aufklappen',
     panelSideLeft: 'Linken',
     panelSideRight: 'Rechten',
     tabNoGroups: 'Für diesen Tab sind keine Gruppen konfiguriert.',
     solving: 'Berechnung läuft',
     solvingEllipsis: 'Berechnung läuft...',
-    solvingSubtitle: 'Grasshopper berechnet...',
-    pressToCalculate: 'Zum Berechnen klicken',
+    solvingSubtitle: 'Das kann einen Moment dauern…',
+    pressToCalculate: 'Berechnen',
     calculate: 'Berechnen',
-    upToDate: 'Aktuell'
+    upToDate: 'Berechnet',
+    moreActions: 'Weitere Aktionen',
+    calculatesFirst: 'Berechnet zuerst',
+    errorCountOne: '{count} Fehler',
+    errorCountOther: '{count} Fehler',
+    warningCountOne: '{count} Warnung',
+    warningCountOther: '{count} Warnungen',
+    noteCountOne: '{count} Hinweis',
+    noteCountOther: '{count} Hinweise',
+    lastSolveMessagesOne: '{count} Meldung der letzten Berechnung',
+    lastSolveMessagesOther: '{count} Meldungen der letzten Berechnung',
+    messagesTitle: 'Meldungen',
+    copyright: 'von {name} © {year}',
+    close: 'Schliessen',
+    toggleTheme: 'Farbschema wechseln',
+    errorTitle: 'Fehler',
+    goHome: 'Zur Startseite',
+    selectOption: 'Option wählen…',
+    noOptionsYet: 'Noch keine Optionen verfügbar.',
+    minValue: 'Der kleinste erlaubte Wert ist {min}',
+    maxValue: 'Der grösste erlaubte Wert ist {max}',
+    fineDragHint: 'Umschalttaste halten für feine Schritte',
+    maxLength: 'Höchstens {max} Zeichen erlaubt',
+    invalidFormat: 'Ungültiges Format',
+    invalidPattern: 'Ungültiges Prüfmuster hinterlegt',
+    geometryPickAnyOne: 'Objekt wählen',
+    geometryPickAnyOther: 'Objekte wählen',
+    geometryPicking: 'Im Ansichtsfenster wählen, Esc bricht ab',
+    geometryPickInPanel: 'Im Rhino-Panel wählen',
+    geometryPickAgain: 'Neu wählen',
+    geometryClear: 'Leeren',
+    geometryPickPointOne: 'Punkt wählen',
+    geometryPickPointOther: 'Punkte wählen',
+    geometryPickPointCloudOne: 'Punktwolke wählen',
+    geometryPickPointCloudOther: 'Punktwolken wählen',
+    geometryPickCurveOne: 'Kurve wählen',
+    geometryPickCurveOther: 'Kurven wählen',
+    geometryPickLineOne: 'Linie wählen',
+    geometryPickLineOther: 'Linien wählen',
+    geometryPickPlaneOne: 'Ebene wählen',
+    geometryPickPlaneOther: 'Ebenen wählen',
+    geometryPickSurfaceOne: 'Fläche wählen',
+    geometryPickSurfaceOther: 'Flächen wählen',
+    geometryPickPolysurfaceOne: 'Flächenverband wählen',
+    geometryPickPolysurfaceOther: 'Flächenverbände wählen',
+    geometryPickExtrusionOne: 'Extrusion wählen',
+    geometryPickExtrusionOther: 'Extrusionen wählen',
+    geometryPickMeshOne: 'Netz wählen',
+    geometryPickMeshOther: 'Netze wählen',
+    geometryPickSubdOne: 'SubD wählen',
+    geometryPickSubdOther: 'SubDs wählen',
+    geometryPickBlockOne: 'Block wählen',
+    geometryPickBlockOther: 'Blöcke wählen',
+    fileModeUpload: 'Hochladen',
+    fileModeUrl: 'URL',
+    fileUrlLabel: 'Datei-URL',
+    fetchFile: 'Abrufen',
+    fetchingFile: 'Wird abgerufen…',
+    fileUrlPublic: 'Die URL muss öffentlich erreichbar sein (ohne Anmeldung).',
+    chooseFile: 'Datei wählen oder hierher ziehen',
+    acceptedFormats: 'Erlaubte Formate: {formats}',
+    uploadedFile: 'Hochgeladene Datei ({ext})',
+    uploadedFileSize: 'Hochgeladene Datei ({ext}, {size} MB)',
+    fileLoaded: '{ext} geladen ({size} KB)',
+    urlInvalid: 'Ungültige URL – sie muss mit https:// beginnen',
+    urlProtocolUnsupported: 'Nur http://- und https://-URLs werden unterstützt.',
+    urlServerError: 'Der Server antwortete mit {status}. Ist die URL korrekt und öffentlich erreichbar?',
+    fileFormatNotAccepted: 'Dateiformat „{ext}“ ist nicht erlaubt. Erlaubt: {formats}',
+    fileTooLarge: 'Datei zu gross: {size} MB (höchstens {max} MB).',
+    fileTooLargeUseUpload: 'Datei herunterladen und stattdessen über „Hochladen“ einfügen.',
+    fileReadFailed: 'Die heruntergeladene Datei konnte nicht gelesen werden.',
+    urlUnreachable: '„{host}“ ist nicht erreichbar – die Datei existiert vielleicht nicht, oder der Server erlaubt keinen Zugriff aus dem Browser.',
+    urlUnreachableHint: 'Prüfen, ob die URL stimmt und die Datei öffentlich erreichbar ist. Verlangt der Server eine Anmeldung: Datei herunterladen und über „Hochladen“ einfügen.',
+    urlHintSharePoint: 'SharePoint/OneDrive sperrt den Zugriff aus dem Browser. Datei in SharePoint öffnen, mit „Herunterladen“ lokal speichern und hier hochladen.',
+    urlHintGoogleDrive: 'Google Drive sperrt den Zugriff aus dem Browser. Datei in Google Drive mit „Herunterladen“ lokal speichern und hier hochladen.',
+    urlHintDropbox: 'Dropbox-Links sperren den Zugriff aus dem Browser oft. In der URL „?dl=0“ durch „?dl=1“ ersetzen oder die Datei herunterladen und hochladen.',
+    unknownError: 'Unbekannter Fehler',
+    waitingForData: 'Noch keine Daten',
+    waitingForFiles: 'Noch keine Dateien',
+    fileCount: '{count} Dateien',
+    duplicateFilesTitle: 'Doppelte Dateinamen',
+    duplicatePathsOne: 'Dieser Pfad kommt mehrfach vor:',
+    duplicatePathsOther: 'Diese Pfade kommen mehrfach vor:',
+    duplicateFilesHint: 'Ausgaben in der Grasshopper-Definition umbenennen, damit jede Datei einen eindeutigen Namen hat.',
+    downloadFile: 'Datei herunterladen',
+    downloadFiles: '{count} Dateien herunterladen',
+    downloading: 'Wird heruntergeladen…',
+    downloadFailed: 'Download fehlgeschlagen',
+    copy: 'Kopieren',
+    copied: 'Kopiert!',
+    chartReceiving: 'Diagrammdaten werden empfangen…',
+    chartRenderFailed: 'Diagramm konnte nicht dargestellt werden',
+    fullscreenUnavailable: 'Vollbild nicht verfügbar: {error}',
+    exitFullscreenFailed: 'Vollbild konnte nicht beendet werden: {error}',
+    imageViewer: 'Bildbetrachter',
+    imageLoading: 'Bild wird geladen…',
+    imageUnsupported: 'Bildformat nicht unterstützt: {ext}. Unterstützt: {formats}',
+    imageUnknownFormat: '(unbekannt)',
+    imageDecodeFailed: '{file} konnte nicht gelesen werden',
+    previousImage: 'Vorheriges Bild',
+    nextImage: 'Nächstes Bild',
+    zoomHint: 'Zum Zoomen Strg oder ⌘ halten und scrollen',
+    zoomIn: 'Vergrössern',
+    zoomOut: 'Verkleinern',
+    zoomFit: 'Einpassen',
+    zoomActual: 'Originalgrösse',
+    downloadImage: 'Bild herunterladen'
 };
 export const VIEWER_MESSAGES = { en, de };
 export const DEFAULT_LOCALE = 'en';
@@ -131,3 +362,22 @@ export const DEFAULT_LOCALE = 'en';
 export function messagesFor(locale) {
     return VIEWER_MESSAGES[locale ?? DEFAULT_LOCALE] ?? VIEWER_MESSAGES[DEFAULT_LOCALE];
 }
+/** Layers a host's partial overrides over a full catalog. An `undefined` entry keeps the base string. */
+export function withOverrides(base, overrides) {
+    if (!overrides)
+        return base;
+    const merged = { ...base };
+    for (const [key, value] of Object.entries(overrides)) {
+        if (value !== undefined)
+            merged[key] = value;
+    }
+    return merged;
+}
+/** Fills each `{name}` placeholder from `vars`; an unknown placeholder is left as written. */
+export function formatMessage(template, vars) {
+    return template.replace(/\{(\w+)\}/g, (placeholder, name) => name in vars ? String(vars[name]) : placeholder);
+}
+/** Picks the singular or plural form for `count` and fills its `{count}`. */
+export function formatCount(count, one, other) {
+    return formatMessage(count === 1 ? one : other, { count });
+}

package/dist/index.d.ts

@@ -9,15 +9,18 @@ export { default as Viewer } from './components/viewer/Viewer.svelte';
 export * from './schema/defaults';
 export * from './schema/dynamic-value-list';
 export * from './schema/traversal';
+export { type UIHost, type ElementKind, HOST_LABELS, isGeometryParamType, layoutItemKind, hostsFor, isSupportedOn, valuelessInputIds, unsupportedItems } from './schema/host-support';
 export * from './compute/solving.svelte';
 export { useSolveSession } from './compute/useSolveSession.svelte';
-export { createSolveSession, createRequestResponseDriver, type SolveSession, type SolveSessionArgs, type SolveDriver, type SolveReporter, type LiveSolveState, type SolvePhase, EMPTY_LIVE_SOLVE, decodeOutcome, finalizeResult, type SolveOutcome } from '@selvajs/solve/client';
+export { createSolveSession, createRequestResponseDriver, type SolveSession, type SolveSessionArgs, type SolveSettlement, type SolveDriver, type SolveReporter, type LiveSolveState, type SolvePhase, EMPTY_LIVE_SOLVE, decodeOutcome, finalizeResult, type SolveOutcome } from '@selvajs/solve/client';
 export { writeExternalValue, readExternalValue, clearExternalValue, getExternalInputs, type ExternalValueRef, type ExternalInput } from '@selvajs/solve/client';
 export * from './contexts/footerContext.svelte';
 export * from './contexts/clientSlotContext.svelte';
+export * from './contexts/hostContext.svelte';
 export * from './composables/useFooterItem.svelte';
 export * from './utils';
 export { randomId } from './utils/randomId';
+export { saveBlob, pickFile, setBlobSaver, setFilePicker, type BlobSaver, type FilePicker } from './utils/host-files';
 export type { ActionButton } from './types/actionButton';
 export type { SolveFn, SolveResult, SolveDiagnostic } from '@selvajs/solve/shared';
 export { DEFAULT_PRESET_LABELS, type PresetLabels } from './types/presetLabels';

package/dist/index.js

@@ -13,6 +13,7 @@ export { default as Viewer } from './components/viewer/Viewer.svelte';
 export * from './schema/defaults';
 export * from './schema/dynamic-value-list';
 export * from './schema/traversal';
+export { HOST_LABELS, isGeometryParamType, layoutItemKind, hostsFor, isSupportedOn, valuelessInputIds, unsupportedItems } from './schema/host-support';
 export * from './compute/solving.svelte';
 // Solve Session seam. Re-exported so transports outside this package — e.g.
 // plugin-ui's WebSocket driver — can satisfy SolveDriver and drive a session.
@@ -25,7 +26,9 @@ EMPTY_LIVE_SOLVE, decodeOutcome, finalizeResult } from '@selvajs/solve/client';
 export { writeExternalValue, readExternalValue, clearExternalValue, getExternalInputs } from '@selvajs/solve/client';
 export * from './contexts/footerContext.svelte';
 export * from './contexts/clientSlotContext.svelte';
+export * from './contexts/hostContext.svelte';
 export * from './composables/useFooterItem.svelte';
 export * from './utils';
 export { randomId } from './utils/randomId';
+export { saveBlob, pickFile, setBlobSaver, setFilePicker } from './utils/host-files';
 export { DEFAULT_PRESET_LABELS } from './types/presetLabels';

package/dist/public.d.ts

@@ -8,7 +8,7 @@ export { VIEWER_MESSAGES, DEFAULT_LOCALE, messagesFor } from './i18n/messages';
 export { setLocaleContext, getLocaleContext, type LocaleContext } from './i18n/localeContext.svelte';
 export { default as ErrorScreen } from './components/ErrorScreen.svelte';
 export { useSolveSession } from './compute/useSolveSession.svelte';
-export { createSolveSession, createRequestResponseDriver, type SolveSession, type SolveSessionArgs, type SolveDriver, type SolveReporter, type LiveSolveState, type SolvePhase } from '@selvajs/solve/client';
+export { createSolveSession, createRequestResponseDriver, type SolveSession, type SolveSessionArgs, type SolveSettlement, type SolveDriver, type SolveReporter, type LiveSolveState, type SolvePhase } from '@selvajs/solve/client';
 export type { ClientSlotArgs, ClientSlot } from './contexts/clientSlotContext.svelte';
 export { writeExternalValue, readExternalValue, clearExternalValue, getExternalInputs, type ExternalValueRef, type ExternalInput } from '@selvajs/solve/client';
 export * from './schema/defaults';

package/dist/schema/host-support.d.ts

@@ -0,0 +1,29 @@
+import type { InputLayoutItem, LayoutItem, SchemaInput, UISchema } from '@selvajs/schemas';
+/**
+ * Where a UI runs: `rhino` is the plugin's page inside Rhino, solving in the user's own
+ * Grasshopper; `selva` is the Selva app, solving headless on Rhino.Compute.
+ */
+export type UIHost = 'rhino' | 'selva';
+/**
+ * - `value`: an input or output every host renders.
+ * - `geometry`: a Rhino Get Geometry/Point/Line/Plane input, filled by picking in the viewport.
+ * - `trigger`: a boolean input shown as a button; a press solves once with `true`.
+ * - `unknown`: a layout item from a newer schema than this build knows.
+ */
+export type ElementKind = 'value' | 'geometry' | 'trigger' | 'unknown';
+export declare const HOST_LABELS: Record<UIHost, string>;
+/** The control comes from this, whatever the saved widgetType says: saved ones hold `text`. */
+export declare function isGeometryParamType(paramType: string | undefined): boolean;
+export declare function isTriggerItem(item: LayoutItem): boolean;
+export declare function layoutItemKind(item: LayoutItem, inputs: readonly SchemaInput[]): ElementKind;
+export declare function hostsFor(kind: ElementKind): readonly UIHost[];
+export declare function isSupportedOn(host: UIHost, kind: ElementKind): boolean;
+/**
+ * Inputs the form keeps no value for: geometry lives on the Grasshopper param after a pick, and a
+ * button only sends a press. Value updates and presets skip them; holding a button's `true` would
+ * fire its action again on every solve.
+ */
+export declare function isValuelessInput(item: InputLayoutItem, input: SchemaInput | undefined): boolean;
+export declare function valuelessInputIds(schema: UISchema): Set<string>;
+/** The placed items a host won't render, for the builder's summary of where the UI runs. */
+export declare function unsupportedItems(schema: UISchema, host: UIHost): LayoutItem[];

package/dist/schema/host-support.js

@@ -0,0 +1,97 @@
+// Which elements of a schema each host renders. Worked out from the schema on every read and
+// never stored in it: a stored copy goes stale the way a saved paramType does. Making an element
+// work on Selva later is a change to SUPPORT, with no schema change and no migration.
+import { getGroups } from '@selvajs/schemas';
+const SUPPORT = {
+    value: ['rhino', 'selva'],
+    geometry: ['rhino'],
+    trigger: ['rhino'],
+    unknown: []
+};
+export const HOST_LABELS = { rhino: 'Rhino', selva: 'Selva' };
+const GEOMETRY_PARAM_TYPES = new Set(['geometry', 'point', 'line', 'plane']);
+// Keyed by the schema's own widget unions, so a widget added to the schema fails to compile here
+// until someone decides which hosts render it.
+const INPUT_WIDGETS = {
+    number: true,
+    text: true,
+    dropdown: true,
+    dynamicValueList: true,
+    checkbox: true,
+    file: true,
+    color: true
+};
+const OUTPUT_WIDGETS = {
+    text: true,
+    number: true,
+    file: true,
+    chart: true,
+    image: true,
+    dynamicValueList: true
+};
+const KNOWN_WIDGETS = {
+    input: new Set(Object.keys(INPUT_WIDGETS)),
+    output: new Set(Object.keys(OUTPUT_WIDGETS))
+};
+/** The control comes from this, whatever the saved widgetType says: saved ones hold `text`. */
+export function isGeometryParamType(paramType) {
+    return paramType !== undefined && GEOMETRY_PARAM_TYPES.has(paramType);
+}
+export function isTriggerItem(item) {
+    return (item.type === 'input' &&
+        item.widgetType === 'checkbox' &&
+        item.config?.displayAs === 'button');
+}
+export function layoutItemKind(item, inputs) {
+    if (item.type === 'linebreak')
+        return 'value';
+    if (item.type !== 'input' && item.type !== 'output')
+        return 'unknown';
+    if (item.type === 'input') {
+        const paramType = inputs.find((i) => i.id === item.paramId)?.paramType;
+        if (isGeometryParamType(paramType))
+            return 'geometry';
+    }
+    if (!KNOWN_WIDGETS[item.type].has(item.widgetType))
+        return 'unknown';
+    return isTriggerItem(item) ? 'trigger' : 'value';
+}
+export function hostsFor(kind) {
+    return SUPPORT[kind];
+}
+export function isSupportedOn(host, kind) {
+    return SUPPORT[kind].includes(host);
+}
+/**
+ * Inputs the form keeps no value for: geometry lives on the Grasshopper param after a pick, and a
+ * button only sends a press. Value updates and presets skip them; holding a button's `true` would
+ * fire its action again on every solve.
+ */
+export function isValuelessInput(item, input) {
+    return isGeometryParamType(input?.paramType) || isTriggerItem(item);
+}
+export function valuelessInputIds(schema) {
+    const ids = new Set();
+    for (const input of schema.inputs) {
+        if (isGeometryParamType(input.paramType))
+            ids.add(input.id);
+    }
+    for (const group of getGroups(schema)) {
+        for (const item of group.items ?? []) {
+            if (isTriggerItem(item))
+                ids.add(item.paramId);
+        }
+    }
+    return ids;
+}
+/** The placed items a host won't render, for the builder's summary of where the UI runs. */
+export function unsupportedItems(schema, host) {
+    const items = [];
+    for (const group of getGroups(schema)) {
+        for (const item of group.items ?? []) {
+            if (!isSupportedOn(host, layoutItemKind(item, schema.inputs)))
+                items.push(item);
+        }
+    }
+    return items;
+}

package/dist/schema/option-display.d.ts

@@ -0,0 +1,12 @@
+import type { DropdownWidgetConfig, OptionMedia, UISchema } from '@selvajs/schemas';
+export type OptionDisplay = NonNullable<DropdownWidgetConfig['displayAs']>;
+export declare function resolveOptionDisplay(displayAs: string | undefined, optionCount: number): OptionDisplay;
+export type GlyphSource = {
+    kind: 'icon';
+    d: string;
+} | {
+    kind: 'image';
+    src: string;
+};
+/** What to draw beside an option: its thumbnail, else its icon. */
+export declare function optionGlyph(media: OptionMedia | undefined, assets: UISchema['assets'] | undefined): GlyphSource | undefined;

package/dist/schema/option-display.js

@@ -0,0 +1,29 @@
+// Past this a button row no longer fits a panel column. A computed list can grow past it at
+// runtime, so the row turns back into a dropdown instead of wrapping.
+const MAX_SEGMENTED_OPTIONS = 6;
+export function resolveOptionDisplay(displayAs, optionCount) {
+    switch (displayAs) {
+        case 'checklist':
+        case 'tiles':
+            return displayAs;
+        case 'segmented':
+            return optionCount <= MAX_SEGMENTED_OPTIONS ? 'segmented' : 'dropdown';
+        default:
+            return 'dropdown';
+    }
+}
+// The schema can come from any .gh, so an image reaches <img> only as an inline raster data URI.
+// Anything else could be a URL that makes every viewer's browser call wherever the file points.
+const RASTER_DATA_URI = /^data:image\/(webp|jpeg|png);base64,[A-Za-z0-9+/=]+$/;
+/** What to draw beside an option: its thumbnail, else its icon. */
+export function optionGlyph(media, assets) {
+    if (!media || !assets)
+        return undefined;
+    if (media.image) {
+        const src = assets[media.image]?.img;
+        if (src && RASTER_DATA_URI.test(src))
+            return { kind: 'image', src };
+    }
+    const d = media.icon ? assets[media.icon]?.d : undefined;
+    return d ? { kind: 'icon', d } : undefined;
+}

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

@@ -14,6 +14,8 @@ export declare function validateSavedState(savedState: ParameterPreset, currentS
  * 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.
+ * Valueless inputs are dropped too: a preset saved before an input became a button or a
+ * geometry input still holds a value for it.
  */
 export declare function extractLoadableValues(savedState: ParameterPreset, currentSchema: UISchema): Record<string, unknown>;
 export interface PresetLoadResult {
@@ -28,5 +30,6 @@ export interface PresetLoadResult {
 }
 /** 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;
+/** Resolves false when the user cancelled the save. */
+export declare function exportStateAsJson(savedState: ParameterPreset): Promise<boolean>;
 export declare function importStateFromJson(file: File): Promise<ParameterPreset>;

package/dist/schema/param-exporter.js

@@ -1,5 +1,7 @@
 import { randomId } from '../utils/randomId';
+import { saveBlob } from '../utils/host-files';
 import { getGroups } from '@selvajs/schemas';
+import { isValuelessInput, valuelessInputIds } from './host-support';
 export function createSavedState(schema, currentValues, metadata) {
     const parameters = [];
     for (const group of getGroups(schema)) {
@@ -8,6 +10,8 @@ export function createSavedState(schema, currentValues, metadata) {
                 continue;
             const value = currentValues[item.paramId];
             const inputDef = schema.inputs.find((i) => i.id === item.paramId);
+            if (isValuelessInput(item, inputDef))
+                continue;
             if (value !== undefined && inputDef) {
                 parameters.push({
                     paramId: item.paramId,
@@ -78,12 +82,15 @@ export function validateSavedState(savedState, currentSchema) {
  * 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.
+ * Valueless inputs are dropped too: a preset saved before an input became a button or a
+ * geometry input still holds a value for it.
  */
 export function extractLoadableValues(savedState, currentSchema) {
     const values = {};
+    const valueless = valuelessInputIds(currentSchema);
     for (const paramState of savedState.parameters) {
         const exists = currentSchema.inputs.some((i) => i.id === paramState.paramId);
-        if (exists) {
+        if (exists && !valueless.has(paramState.paramId)) {
             values[paramState.paramId] = paramState.value;
         }
     }
@@ -99,17 +106,14 @@ export function loadPreset(savedState, currentSchema) {
         canLoad: validation.canLoad
     };
 }
+/** Resolves false when the user cancelled the save. */
 export function exportStateAsJson(savedState) {
     const blob = new Blob([JSON.stringify(savedState, null, 2)], { type: 'application/json' });
     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.createObjectURL(blob);
     // .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);
+    return saveBlob(blob, `${safeName}_${date}.slvp`);
 }
 export async function importStateFromJson(file) {
     const state = JSON.parse(await file.text());