@selvajs/ui 6.6.0-beta.8 → 7.0.0

package/dist/compute/solving.svelte.js

@@ -1,68 +1,87 @@
 import { untrack } from 'svelte';
 import { APP_DEFAULTS } from '../constants';
 /**
- * Adaptive solving indicator: measures solve durations and adjusts its
- * visibility delay from the running average.
+ * When to show that a solve is running. A solve that ends within `SHOW_AFTER_MS` shows nothing:
+ * the result updating is feedback enough, and a spinner that flashes for a frame reads as jank.
+ * Once shown, the indicator stays `MIN_VISIBLE_MS` for the same reason. `slow` turns on past
+ * `SLOW_AFTER_MS`, the case of a Rhino.Compute round trip or a heavy definition.
  *
- * - Average under FAST_THRESHOLD_MS: never shown, so quick solves don't flicker
- * - Average over SLOW_THRESHOLD_MS: shown immediately
- * - Between the two: shown after a proportional slice of ANIMATION_DELAY
- * - First solve: shown immediately, there is no history yet
+ * `freezesDuringSolve` is for a host that can't paint while it solves (an embedded WebView on
+ * the solver's thread). A delay can't run there, so the indicator shows on every solve, before
+ * the solve takes the thread: it is the only place that host can say Esc aborts.
  */
-export function createSolvingIndicator(isSolving) {
-    const { FAST_THRESHOLD_MS, SLOW_THRESHOLD_MS, HISTORY_SIZE, ANIMATION_DELAY } = APP_DEFAULTS.SOLVING_INDICATOR;
+export function createSolvingIndicator(isSolving, options = {}) {
+    const { SHOW_AFTER_MS, MIN_VISIBLE_MS, SLOW_AFTER_MS } = APP_DEFAULTS.SOLVING_INDICATOR;
+    if (options.freezesDuringSolve) {
+        return {
+            // Read straight from `isSolving`, not through an effect: an effect would run a tick
+            // later, after the solve has already frozen the page.
+            get show() {
+                return isSolving();
+            },
+            slow: false
+        };
+    }
     let show = $state(false);
-    let timeout = null;
-    let solveStartTime = null;
-    const solveHistory = [];
+    let slow = $state(false);
+    let shownAt = 0;
+    let showTimer = null;
+    let slowTimer = null;
+    let hideTimer = null;
+    function clear(timer) {
+        if (timer)
+            clearTimeout(timer);
+        return null;
+    }
+    function hide() {
+        hideTimer = null;
+        show = false;
+        slow = false;
+    }
     $effect(() => {
         const solving = isSolving();
         untrack(() => {
             if (solving) {
-                solveStartTime = performance.now();
-                const avg = solveHistory.length === 0
-                    ? Infinity
-                    : solveHistory.reduce((a, b) => a + b, 0) / solveHistory.length;
-                if (solveHistory.length > 0 && avg < FAST_THRESHOLD_MS)
-                    return;
-                const delay = avg === Infinity || avg >= SLOW_THRESHOLD_MS
-                    ? 0
-                    : ((avg - FAST_THRESHOLD_MS) / (SLOW_THRESHOLD_MS - FAST_THRESHOLD_MS)) *
-                        ANIMATION_DELAY;
-                if (!timeout) {
-                    if (delay === 0) {
+                // A solve that starts while the last one's indicator is held keeps it up.
+                hideTimer = clear(hideTimer);
+                if (!show) {
+                    showTimer ??= setTimeout(() => {
+                        showTimer = null;
                         show = true;
-                    }
-                    else {
-                        timeout = setTimeout(() => {
-                            show = true;
-                            timeout = null;
-                        }, delay);
-                    }
+                        shownAt = performance.now();
+                    }, SHOW_AFTER_MS);
                 }
+                slowTimer ??= setTimeout(() => {
+                    slowTimer = null;
+                    slow = true;
+                }, SLOW_AFTER_MS);
             }
             else {
-                if (solveStartTime !== null) {
-                    solveHistory.push(performance.now() - solveStartTime);
-                    if (solveHistory.length > HISTORY_SIZE)
-                        solveHistory.shift();
-                    solveStartTime = null;
-                }
-                if (timeout) {
-                    clearTimeout(timeout);
-                    timeout = null;
-                }
-                show = false;
+                showTimer = clear(showTimer);
+                slowTimer = clear(slowTimer);
+                if (!show)
+                    return;
+                const remaining = MIN_VISIBLE_MS - (performance.now() - shownAt);
+                if (remaining > 0)
+                    hideTimer ??= setTimeout(hide, remaining);
+                else
+                    hide();
             }
         });
-        return () => {
-            if (timeout)
-                clearTimeout(timeout);
-        };
+    });
+    // Separate from the effect above: a cleanup there would run on every `isSolving` flip and
+    // cancel the timers it just set.
+    $effect(() => () => {
+        clear(showTimer);
+        clear(slowTimer);
+        clear(hideTimer);
     });
     return {
         get show() {
             return show;
+        },
+        get slow() {
+            return slow;
         }
     };
 }

package/dist/constants.d.ts

@@ -10,14 +10,12 @@ export declare const APP_DEFAULTS: {
         DRAWER_ANIMATION_MS: number;
     };
     SOLVING_INDICATOR: {
-        /** If solve is faster than this, don't show indicator (ms) */
-        FAST_THRESHOLD_MS: number;
-        /** If solve is slower than this, show indicator immediately (ms) */
-        SLOW_THRESHOLD_MS: number;
-        /** Animation delay for solve indicator (ms) */
-        ANIMATION_DELAY: number;
-        /** Number of solve durations to keep in history for averaging */
-        HISTORY_SIZE: number;
+        /** A solve that ends sooner shows no indicator (ms) */
+        SHOW_AFTER_MS: number;
+        /** Once shown, the indicator stays at least this long (ms) */
+        MIN_VISIBLE_MS: number;
+        /** Past this a solve counts as slow and the viewer dims its stale result (ms) */
+        SLOW_AFTER_MS: number;
     };
     FILE_SIZE: {
         /** Bytes per kilobyte */

package/dist/constants.js

@@ -1,8 +1,7 @@
 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)
-    // still defaults to 256 MB, and base64 inflates a raw file by ~4/3, so
+    // blocked client-side. The server request cap is 256 MB, and base64 inflates a raw file by ~4/3, so
     // anything over ~192 MB is rejected with a 413 after the client accepts it.
     // Revert to 150 before release.
     FILE_UPLOAD: {
@@ -16,16 +15,14 @@ export const APP_DEFAULTS = {
         /** Drawer open/close animation duration (ms) — matches the CSS transition. */
         DRAWER_ANIMATION_MS: 350
     },
-    // Solving indicator adaptive thresholds
+    // See createSolvingIndicator.
     SOLVING_INDICATOR: {
-        /** If solve is faster than this, don't show indicator (ms) */
-        FAST_THRESHOLD_MS: 200,
-        /** If solve is slower than this, show indicator immediately (ms) */
-        SLOW_THRESHOLD_MS: 600,
-        /** Animation delay for solve indicator (ms) */
-        ANIMATION_DELAY: 300,
-        /** Number of solve durations to keep in history for averaging */
-        HISTORY_SIZE: 3
+        /** A solve that ends sooner shows no indicator (ms) */
+        SHOW_AFTER_MS: 400,
+        /** Once shown, the indicator stays at least this long (ms) */
+        MIN_VISIBLE_MS: 500,
+        /** Past this a solve counts as slow and the viewer dims its stale result (ms) */
+        SLOW_AFTER_MS: 2000
     },
     // File size formatting
     FILE_SIZE: {

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

@@ -0,0 +1,39 @@
+import type { GeometryKind } from '@selvajs/schemas';
+import type { UIHost } from '../schema/host-support.js';
+export type GeometryPickResult = {
+    outcome: 'picked';
+    summary: string;
+} | {
+    outcome: 'cancelled';
+} | {
+    outcome: 'failed';
+    error: string;
+};
+/** What a pick button can ask for: a Get Geometry filter's kinds, or Get Point/Line/Plane's own. */
+export type PickKind = GeometryKind | 'line' | 'plane';
+/** What a geometry input lets the user pick, as the host discovered it on the canvas. */
+export interface GeometryPickTarget {
+    /** The kinds its filter allows; absent when it takes anything. */
+    kinds?: readonly GeometryKind[];
+    /** 1 picks a single object. */
+    atMost?: number;
+}
+export interface HostActions {
+    host: UIHost;
+    /** Prompts in the Rhino viewport for a geometry input. The picked geometry stays in Grasshopper. */
+    pickGeometry?: (paramId: string) => Promise<GeometryPickResult>;
+    /** Empties a geometry input again, back to the definition's own value. */
+    clearGeometry?: (paramId: string) => void;
+    /**
+     * Reports what the param holds after every pick or clear, including those another page asked
+     * for; null when nothing is picked into it. Returns an unsubscribe.
+     */
+    onGeometrySummary?: (paramId: string, listener: (summary: string | null) => void) => () => void;
+    describeGeometry?: (paramId: string) => GeometryPickTarget | undefined;
+    /** Presses a button input: one solve with `true`, then it goes back to `false`. */
+    trigger?: (paramId: string) => void;
+    /** Grasshopper refuses a press while it solves, so the button waits it out disabled. */
+    isSolving?: () => boolean;
+}
+export declare function setHostContext(actions: HostActions): void;
+export declare function getHostContext(): HostActions;

package/dist/contexts/hostContext.svelte.js

@@ -0,0 +1,9 @@
+import { getContext, setContext } from 'svelte';
+const SELVA_HOST = { host: 'selva' };
+const HOST_CONTEXT_KEY = Symbol('host-context');
+export function setHostContext(actions) {
+    setContext(HOST_CONTEXT_KEY, actions);
+}
+export function getHostContext() {
+    return getContext(HOST_CONTEXT_KEY) ?? SELVA_HOST;
+}

package/dist/features/chart/plotly-compat.d.ts

@@ -0,0 +1,15 @@
+type Json = Record<string, unknown>;
+export interface PlotlyFigure {
+    data: Json[];
+    layout?: Json;
+    config?: Json;
+    frames?: Json[];
+}
+/** Returns a rewritten copy; the input is not modified. */
+export declare function upgradePlotlyFigure(figure: PlotlyFigure): PlotlyFigure;
+/**
+ * Rewrites colour spellings Plotly 3 accepted but Plotly 4 rejects (hex without `#`, `hsv()`)
+ * into valid CSS. Anything else is returned unchanged.
+ */
+export declare function normalizePlotlyColor(color: string): string;
+export {};

package/dist/features/chart/plotly-compat.js

@@ -0,0 +1,124 @@
+import { hsvToRgb } from '../../utils/color-space.js';
+const REMOVED_MAP_TRACES = {
+    scattermapbox: 'scattermap',
+    choroplethmapbox: 'choroplethmap',
+    densitymapbox: 'densitymap'
+};
+const MAPBOX_SUBPLOT = /^mapbox(\d*)$/;
+const BARE_HEX = /^(?:[0-9a-f]{3,4}|[0-9a-f]{6}|[0-9a-f]{8})$/i;
+const HSV_FUNCTION = /^hsva?[\s(]+([-+\d.]+)%?[\s,]+([\d.]+)(%?)[\s,]+([\d.]+)(%?)(?:[\s,/]+([\d.]+)(%?))?[\s)]*$/i;
+const isObject = (v) => typeof v === 'object' && v !== null && !Array.isArray(v);
+/** Returns a rewritten copy; the input is not modified. */
+export function upgradePlotlyFigure(figure) {
+    const out = structuredClone(figure);
+    const layout = out.layout ?? {};
+    normalizeColors(layout);
+    let migratedMaps = false;
+    for (const trace of out.data ?? []) {
+        if (!isObject(trace))
+            continue;
+        normalizeColors(trace);
+        const replacement = REMOVED_MAP_TRACES[trace.type];
+        if (replacement) {
+            trace.type = replacement;
+            if (typeof trace.subplot === 'string')
+                trace.subplot = trace.subplot.replace(MAPBOX_SUBPLOT, 'map$1');
+            migratedMaps = true;
+        }
+        else if (trace.type === 'splom') {
+            keepSplomAxesUnlinked(trace);
+        }
+    }
+    if (migratedMaps)
+        migrateMapLayout(layout);
+    // Frame data replaces trace data during playback, so it needs the same colour fixes.
+    for (const frame of out.frames ?? [])
+        if (isObject(frame))
+            normalizeColors(frame);
+    return { ...out, layout };
+}
+// Plotly 4 links each dimension's x and y axes by default.
+function keepSplomAxesUnlinked(trace) {
+    if (!Array.isArray(trace.dimensions))
+        return;
+    for (const dim of trace.dimensions) {
+        if (!isObject(dim))
+            continue;
+        const axis = isObject(dim.axis) ? dim.axis : (dim.axis = {});
+        if (!('matches' in axis))
+            axis.matches = false;
+    }
+}
+function migrateMapLayout(layout) {
+    for (const key of Object.keys(layout)) {
+        const match = MAPBOX_SUBPLOT.exec(key);
+        if (!match)
+            continue;
+        const map = layout[key];
+        delete layout[key];
+        const newKey = `map${match[1]}`;
+        if (newKey in layout || !isObject(map))
+            continue;
+        delete map.accesstoken;
+        // Stamen and mapbox:// styles have no map equivalent.
+        if (typeof map.style === 'string' && /^(stamen|mapbox:\/\/)/.test(map.style))
+            map.style = 'open-street-map';
+        layout[newKey] = map;
+    }
+}
+// Plotly attributes that hold colours: *color, colorway, colorscale and pie's marker.colors.
+const isColorKey = (key) => key.toLowerCase().endsWith('color') ||
+    key === 'colors' ||
+    key === 'colorway' ||
+    key === 'colorscale';
+function normalizeColors(props) {
+    for (const [key, value] of Object.entries(props)) {
+        if (isColorKey(key))
+            props[key] = normalizeColorValue(value, false);
+        else if (isObject(value))
+            normalizeColors(value);
+        else if (Array.isArray(value))
+            for (const item of value)
+                if (isObject(item))
+                    normalizeColors(item);
+    }
+}
+// Covers a single colour, a per-point list and colorscale stops ([[0, "ff0000"], ...]).
+function normalizeColorValue(value, inList) {
+    if (Array.isArray(value))
+        return value.map((v) => normalizeColorValue(v, true));
+    if (typeof value !== 'string')
+        return value;
+    // Plotly reads numeric strings in a per-point list as numbers for the colorscale.
+    if (inList && /^\s*\d+\s*$/.test(value))
+        return value;
+    return normalizePlotlyColor(value);
+}
+/**
+ * Rewrites colour spellings Plotly 3 accepted but Plotly 4 rejects (hex without `#`, `hsv()`)
+ * into valid CSS. Anything else is returned unchanged.
+ */
+export function normalizePlotlyColor(color) {
+    const value = color.trim();
+    if (BARE_HEX.test(value))
+        return `#${value}`;
+    const hsv = HSV_FUNCTION.exec(value);
+    if (!hsv)
+        return color;
+    const { r, g, b } = hsvToRgb({
+        h: Number(hsv[1]),
+        s: unit(hsv[2], hsv[3] === '%'),
+        v: unit(hsv[4], hsv[5] === '%')
+    });
+    const rgb = `${Math.round(r)},${Math.round(g)},${Math.round(b)}`;
+    if (hsv[6] === undefined)
+        return `rgb(${rgb})`;
+    return `rgba(${rgb},${+unit(hsv[6], hsv[7] === '%').toFixed(3)})`;
+}
+// Plotly 3 (TinyColor) read 0..1 as a fraction and anything above 1 as a percentage.
+function unit(s, percent) {
+    let x = Number(s);
+    if (percent || x > 1)
+        x /= 100;
+    return Math.min(1, Math.max(0, x));
+}

package/dist/i18n/messages.d.ts

@@ -23,6 +23,8 @@ export interface ViewerMessages {
     lookTechnical: string;
     lookStudio: string;
     lookShowcase: string;
+    lookNight: string;
+    nightMode: string;
     lookArctic: string;
     lookXray: string;
     lookLineart: string;
@@ -50,8 +52,14 @@ export interface ViewerMessages {
     solveMessagesConfirm: string;
     solveMessagesDiscard: string;
     solveMessagesAbort: string;
+    /** Stands in for Abort where the page can't take a click mid-solve. */
+    solveMessagesEscHint: string;
     solveMessagesDismiss: string;
     solveSolving: string;
+    /** A visible solve has landed; followed by how long it took. */
+    solveDone: string;
+    /** A visible solve was aborted; the previous result stays. */
+    solveStopped: string;
     parametersTab: string;
     moreTab: string;
     scrollTabsBack: string;
@@ -100,7 +108,48 @@ export interface ViewerMessages {
     /** `{max}` is replaced with the field's character limit. */
     maxLength: string;
     invalidFormat: string;
+    /** Trigger label; `{color}` is the current hex value. */
+    colorPick: string;
+    colorArea: string;
+    /** `{s}` and `{v}` are percentages. */
+    colorAreaValue: string;
+    colorHue: string;
+    colorHex: string;
+    colorHexInvalid: string;
+    colorPresets: string;
+    colorEyedropper: string;
     invalidPattern: string;
+    /** The pick button when the input takes several kinds of object. */
+    geometryPickAnyOne: string;
+    geometryPickAnyOther: string;
+    /** Shown while Rhino's viewport prompt for a pick is open. */
+    geometryPicking: string;
+    /** Where this page may not pick, such as a browser tab beside the Rhino panel. */
+    geometryPickInPanel: string;
+    geometryPickAgain: string;
+    geometryClear: string;
+    geometryPickPointOne: string;
+    geometryPickPointOther: string;
+    geometryPickPointCloudOne: string;
+    geometryPickPointCloudOther: string;
+    geometryPickCurveOne: string;
+    geometryPickCurveOther: string;
+    geometryPickLineOne: string;
+    geometryPickLineOther: string;
+    geometryPickPlaneOne: string;
+    geometryPickPlaneOther: string;
+    geometryPickSurfaceOne: string;
+    geometryPickSurfaceOther: string;
+    geometryPickPolysurfaceOne: string;
+    geometryPickPolysurfaceOther: string;
+    geometryPickExtrusionOne: string;
+    geometryPickExtrusionOther: string;
+    geometryPickMeshOne: string;
+    geometryPickMeshOther: string;
+    geometryPickSubdOne: string;
+    geometryPickSubdOther: string;
+    geometryPickBlockOne: string;
+    geometryPickBlockOther: string;
     fileModeUpload: string;
     fileModeUrl: string;
     fileUrlLabel: string;
@@ -150,6 +199,7 @@ export interface ViewerMessages {
     copied: string;
     chartReceiving: string;
     chartRenderFailed: string;
+    downloadChartImage: string;
     /** `{error}` is replaced with the browser's reason. */
     fullscreenUnavailable: string;
     /** `{error}` is replaced with the browser's reason. */

package/dist/i18n/messages.js

@@ -32,6 +32,8 @@ const en = {
     lookTechnical: 'Technical',
     lookStudio: 'Studio',
     lookShowcase: 'Showcase',
+    lookNight: 'Night',
+    nightMode: 'Night mode',
     lookArctic: 'Arctic',
     lookXray: 'X-Ray',
     lookLineart: 'Line Art',
@@ -58,8 +60,11 @@ const en = {
     solveMessagesConfirm: 'Continue',
     solveMessagesDiscard: 'Discard',
     solveMessagesAbort: 'Abort',
+    solveMessagesEscHint: 'Esc aborts the solve',
     solveMessagesDismiss: 'Dismiss',
     solveSolving: 'Solving…',
+    solveDone: 'Done',
+    solveStopped: 'Stopped',
     parametersTab: 'Parameters',
     moreTab: 'More',
     scrollTabsBack: 'Previous tabs',
@@ -97,7 +102,43 @@ const en = {
     fineDragHint: 'Hold Shift to drag finely',
     maxLength: 'Maximum {max} characters allowed',
     invalidFormat: 'Invalid format',
+    colorPick: 'Choose color, currently {color}',
+    colorArea: 'Saturation and brightness',
+    colorAreaValue: 'Saturation {s}%, brightness {v}%',
+    colorHue: 'Hue',
+    colorHex: 'Hex color',
+    colorHexInvalid: 'Enter a hex color such as #2f6fd6',
+    colorPresets: 'Presets',
+    colorEyedropper: 'Pick a color from the screen',
     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',
@@ -137,6 +178,7 @@ const en = {
     copied: 'Copied!',
     chartReceiving: 'Receiving chart data...',
     chartRenderFailed: 'Failed to render chart',
+    downloadChartImage: 'Download plot as image',
     fullscreenUnavailable: 'Fullscreen unavailable: {error}',
     exitFullscreenFailed: 'Exit fullscreen failed: {error}',
     imageViewer: 'image viewer',
@@ -177,6 +219,8 @@ const de = {
     lookTechnical: 'Technisch',
     lookStudio: 'Studio',
     lookShowcase: 'Präsentation',
+    lookNight: 'Nacht',
+    nightMode: 'Nachtmodus',
     lookArctic: 'Arktis',
     lookXray: 'Röntgen',
     lookLineart: 'Strichzeichnung',
@@ -203,8 +247,11 @@ const de = {
     solveMessagesConfirm: 'Weiter',
     solveMessagesDiscard: 'Verwerfen',
     solveMessagesAbort: 'Abbrechen',
+    solveMessagesEscHint: 'Esc bricht die Berechnung ab',
     solveMessagesDismiss: 'Schliessen',
     solveSolving: 'Berechnung läuft…',
+    solveDone: 'Fertig',
+    solveStopped: 'Abgebrochen',
     parametersTab: 'Parameter',
     moreTab: 'Mehr',
     scrollTabsBack: 'Vorherige Tabs',
@@ -242,7 +289,43 @@ const de = {
     fineDragHint: 'Umschalttaste halten für feine Schritte',
     maxLength: 'Höchstens {max} Zeichen erlaubt',
     invalidFormat: 'Ungültiges Format',
+    colorPick: 'Farbe wählen, aktuell {color}',
+    colorArea: 'Sättigung und Helligkeit',
+    colorAreaValue: 'Sättigung {s} %, Helligkeit {v} %',
+    colorHue: 'Farbton',
+    colorHex: 'Hex-Farbe',
+    colorHexInvalid: 'Hex-Farbe eingeben, z. B. #2f6fd6',
+    colorPresets: 'Vorgaben',
+    colorEyedropper: 'Farbe vom Bildschirm aufnehmen',
     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',
@@ -282,6 +365,7 @@ const de = {
     copied: 'Kopiert!',
     chartReceiving: 'Diagrammdaten werden empfangen…',
     chartRenderFailed: 'Diagramm konnte nicht dargestellt werden',
+    downloadChartImage: 'Diagramm als Bild herunterladen',
     fullscreenUnavailable: 'Vollbild nicht verfügbar: {error}',
     exitFullscreenFailed: 'Vollbild konnte nicht beendet werden: {error}',
     imageViewer: 'Bildbetrachter',

package/dist/index.d.ts

@@ -5,19 +5,24 @@ export { default as SolveMessages } from './components/compute/SolveMessages.sve
 export { default as ErrorScreen } from './components/ErrorScreen.svelte';
 export * from './components/primitives';
 export { default as StateDisplay } from './components/primitives/StateDisplay.svelte';
+export { default as ColorInput } from './components/preview/inputs/ColorInput.svelte';
 export { default as Viewer } from './components/viewer/Viewer.svelte';
 export * from './schema/defaults';
 export * from './schema/dynamic-value-list';
 export * from './schema/traversal';
+export { visibleInputItems } from './schema/visibility-rules';
+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 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

@@ -9,10 +9,13 @@ 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';
+export { default as ColorInput } from './components/preview/inputs/ColorInput.svelte';
 export { default as Viewer } from './components/viewer/Viewer.svelte';
 export * from './schema/defaults';
 export * from './schema/dynamic-value-list';
 export * from './schema/traversal';
+export { visibleInputItems } from './schema/visibility-rules';
+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 +28,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';