@selvajs/ui 4.3.0 → 4.5.0

package/dist/compute/createSolveSession.svelte.js

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

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

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

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

@@ -0,0 +1,69 @@
+// Pure, framework-free transition logic for a Solve Session (see CONTEXT.md).
+//
+// This module holds the value/lifecycle state machine with no Svelte runes and no
+// transport: how values are seeded (including client-sourced hydration), when a value
+// change should dispatch a solve vs. defer it, and what a reported solve result does to
+// the flags. The reactive wrapper in createSolveSession.svelte.ts is a thin shell over
+// these functions; everything testable lives here.
+import { getDefaultValue } from '../schema/defaults';
+import { getExternalInputs } from '../external/storage';
+/**
+ * Builds the initial `values` map for a schema. Non-client inputs get their declared
+ * default (falling back to the paramType default); client-sourced inputs are hydrated
+ * from `read` and left absent when no stored value exists so the missing-inputs panel
+ * can detect them. Outputs are seeded to null.
+ */
+export function buildInitialValues(schema, scopeKey, read) {
+    const clientSet = new Set(getExternalInputs(schema).map((e) => e.paramId));
+    const values = {};
+    for (const input of schema.inputs) {
+        if (clientSet.has(input.id)) {
+            const stored = read({ scopeKey, inputId: input.id });
+            if (stored !== undefined)
+                values[input.id] = stored;
+            continue;
+        }
+        values[input.id] = input.default ?? getDefaultValue(input.paramType);
+    }
+    for (const output of schema.outputs) {
+        values[output.id] = null;
+    }
+    return values;
+}
+/**
+ * Initial lifecycle flags. Manual-solve schemas (instanceSolve === false) start dirty
+ * so the user must explicitly calculate; auto-solve schemas start clean.
+ */
+export function makeInitialFlags(instanceSolve) {
+    const manual = instanceSolve === false;
+    return { hasPendingChanges: manual, hasNeverSolved: manual };
+}
+/**
+ * Records a single value change and decides whether it should dispatch a solve now.
+ * Auto-solve mode dispatches immediately; manual mode defers (records the pending value
+ * and raises the dirty flag) and never dispatches.
+ */
+export function applyValueChange(state, id, value, instanceSolve) {
+    state.values[id] = value;
+    if (instanceSolve === false) {
+        state.pendingValues[id] = value;
+        state.hasPendingChanges = true;
+        return { state, shouldSolve: false };
+    }
+    return { state, shouldSolve: true };
+}
+/**
+ * Merges a reported solve result into the state and clears the post-solve lifecycle
+ * flags. Missing result arrays are treated as empty.
+ */
+export function applySolveResult(state, result) {
+    state.error = '';
+    state.computeErrors = result.errors ?? [];
+    state.computeWarnings = result.warnings ?? [];
+    state.meshes = result.meshes ?? [];
+    Object.assign(state.values, result.outputs);
+    state.pendingValues = {};
+    state.hasPendingChanges = false;
+    state.hasNeverSolved = false;
+    return state;
+}

package/dist/constants.d.ts

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

package/dist/constants.js

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

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

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

package/dist/contexts/footerContext.svelte.js

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

package/dist/external/storage.js

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

package/dist/index.d.ts

@@ -6,7 +6,9 @@ export * from './components/primitives';
 export { default as StateDisplay } from './components/primitives/StateDisplay.svelte';
 export { default as Viewer } from './components/viewer/Viewer.svelte';
 export * from './schema/defaults';
+export * from './schema/traversal';
 export * from './compute/solving.svelte';
+export { createSolveSession, createRequestResponseDriver, type SolveSession, type SolveSessionArgs, type SolveDriver, type SolveReporter } from './compute/createSolveSession.svelte';
 export * from './external/storage';
 export * from './contexts/footerContext.svelte';
 export * from './contexts/clientSlotContext.svelte';
@@ -14,5 +16,5 @@ export * from './composables/useFooterItem.svelte';
 export * from './utils';
 export { randomId } from './utils/randomId';
 export type { ActionButton } from './types/actionButton';
-export type { SolveFn } from './types/solveFn';
+export type { SolveFn, SolveResult } from './types/solveFn';
 export { DEFAULT_PRESET_LABELS, type PresetLabels } from './types/presetLabels';

package/dist/index.js

@@ -12,7 +12,12 @@ export { default as StateDisplay } from './components/primitives/StateDisplay.sv
 export { default as Viewer } from './components/viewer/Viewer.svelte';
 // Utilities
 export * from './schema/defaults';
+export * from './schema/traversal';
 export * from './compute/solving.svelte';
+// Solve Session seam (transport-agnostic value/lifecycle state machine + its driver
+// interface). Exported so transports outside this package — e.g. plugin-ui's WebSocket
+// driver — can satisfy SolveDriver and drive a session. See CONTEXT.md.
+export { createSolveSession, createRequestResponseDriver } from './compute/createSolveSession.svelte';
 // External-input transit storage (used by routes that wire pre-step producers)
 export * from './external/storage';
 // Contexts & Composables

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

@@ -10,6 +10,30 @@ export declare function validateSavedState(savedState: ParameterPreset, currentS
     issues: ValidationIssueMessage[];
     canLoad: boolean;
 };
-export declare function extractLoadableValues(savedState: ParameterPreset, currentSchema: UISchema, validation: ReturnType<typeof validateSavedState>): Record<string, unknown>;
+/**
+ * The subset of a preset's parameters that can safely be applied to the current schema:
+ * every param that still exists as an input. A param that no longer exists is dropped
+ * (it's the same condition `validateSavedState` flags as an error), so this derives its
+ * own "loadable" rule from the schema rather than re-reading validation issues — no
+ * coupling to how sentinel ids are encoded.
+ */
+export declare function extractLoadableValues(savedState: ParameterPreset, currentSchema: UISchema): Record<string, unknown>;
+/** The full outcome of loading a preset: what to apply, plus the diagnostics to surface. */
+export interface PresetLoadResult {
+    /** Values safe to apply now (params that still exist). */
+    values: Record<string, unknown>;
+    /** All validation issues (errors + warnings) for the load dialog. */
+    issues: ValidationIssueMessage[];
+    /** No issues at all — load silently. */
+    isValid: boolean;
+    /** No blocking errors — load is allowed (warnings are fine). */
+    canLoad: boolean;
+}
+/**
+ * Single entry point for applying a preset: validates against the current schema and, in
+ * the same pass, computes the loadable values. Callers get one object instead of
+ * threading a validation result back into a separate extraction step.
+ */
+export declare function loadPreset(savedState: ParameterPreset, currentSchema: UISchema): PresetLoadResult;
 export declare function exportStateAsJson(savedState: ParameterPreset): void;
 export declare function importStateFromJson(file: File): Promise<ParameterPreset>;

package/dist/schema/param-exporter.js

@@ -1,14 +1,5 @@
-import { APP_DEFAULTS } from '../constants';
 import { randomId } from '../utils/randomId';
-function getGroups(schema) {
-    if (!schema.layout)
-        return [];
-    if (schema.layout.type === 'tabbed')
-        return schema.layout.tabs.flatMap((t) => t.groups ?? []);
-    if (schema.layout.type === 'flat')
-        return schema.layout.groups ?? [];
-    return [];
-}
+import { getGroups } from '@selvajs/schemas';
 export function createSavedState(schema, currentValues, metadata) {
     const parameters = [];
     for (const group of getGroups(schema)) {
@@ -83,34 +74,46 @@ export function validateSavedState(savedState, currentSchema) {
     const hasErrors = issues.some((i) => i.severity === 'error');
     return { isValid: issues.length === 0, issues, canLoad: !hasErrors };
 }
-export function extractLoadableValues(savedState, currentSchema, validation) {
-    const errorParamIds = new Set(validation.issues
-        .filter((i) => i.severity === 'error' && !i.paramId.startsWith('__'))
-        .map((i) => i.paramId));
+/**
+ * The subset of a preset's parameters that can safely be applied to the current schema:
+ * every param that still exists as an input. A param that no longer exists is dropped
+ * (it's the same condition `validateSavedState` flags as an error), so this derives its
+ * own "loadable" rule from the schema rather than re-reading validation issues — no
+ * coupling to how sentinel ids are encoded.
+ */
+export function extractLoadableValues(savedState, currentSchema) {
     const values = {};
     for (const paramState of savedState.parameters) {
         const exists = currentSchema.inputs.some((i) => i.id === paramState.paramId);
-        if (!errorParamIds.has(paramState.paramId) && exists) {
+        if (exists) {
             values[paramState.paramId] = paramState.value;
         }
     }
     return values;
 }
+/**
+ * Single entry point for applying a preset: validates against the current schema and, in
+ * the same pass, computes the loadable values. Callers get one object instead of
+ * threading a validation result back into a separate extraction step.
+ */
+export function loadPreset(savedState, currentSchema) {
+    const validation = validateSavedState(savedState, currentSchema);
+    return {
+        values: extractLoadableValues(savedState, currentSchema),
+        issues: validation.issues,
+        isValid: validation.isValid,
+        canLoad: validation.canLoad
+    };
+}
 export function exportStateAsJson(savedState) {
     const blob = new Blob([JSON.stringify(savedState, null, 2)], { type: 'application/json' });
-    const url = URL.createObjectURL(blob);
+    const safeName = savedState.name.replace(/[^a-z0-9]/gi, '_');
+    const date = savedState.timestamp.split('T')[0].replace(/-/g, '_');
     const link = document.createElement('a');
-    link.href = url;
-    link.download = `${savedState.name.replace(/[^a-z0-9]/gi, '_')}_${savedState.timestamp.split('T')[0].replace(/-/g, '_')}.sps`;
-    link.style.display = 'none';
-    document.body.appendChild(link);
-    setTimeout(() => {
-        link.click();
-        setTimeout(() => {
-            document.body.removeChild(link);
-            URL.revokeObjectURL(url);
-        }, APP_DEFAULTS.TIMEOUTS.PARAM_EXPORT_DELAY);
-    }, 0);
+    link.href = URL.createObjectURL(blob);
+    link.download = `${safeName}_${date}.sps`;
+    link.click();
+    URL.revokeObjectURL(link.href);
 }
 export async function importStateFromJson(file) {
     const state = JSON.parse(await file.text());

package/dist/schema/traversal.d.ts

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

package/dist/schema/traversal.js

@@ -0,0 +1,5 @@
+// Schema layout traversal now lives in @selvajs/schemas (next to the types it walks) so
+// any package depending on the schema can traverse it without pulling in @selvajs/ui.
+// Re-exported here to keep it part of @selvajs/ui's published surface for existing
+// consumers.
+export { getGroups, getLayoutItems, getInputItems } from '@selvajs/schemas';

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

@@ -7,6 +7,18 @@ 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.
+ */
+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".
+ */
+export declare function buildVisibilityMap(items: LayoutItem[], values: Record<string, unknown>): Record<string, VisibilityResult>;
 export declare function evaluateGroupVisibility(group: {
     visibilityCondition?: GroupVisibilityCondition;
 }, values: Record<string, unknown>): boolean;

package/dist/schema/visibility-rules.js

@@ -57,6 +57,26 @@ 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.
+ */
+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".
+ */
+export function buildVisibilityMap(items, values) {
+    const map = {};
+    for (const item of items) {
+        map[itemKey(item)] = evaluateVisibility(item, values);
+    }
+    return map;
+}
 export function evaluateGroupVisibility(group, values) {
     if (!group.visibilityCondition?.rules)
         return true;

package/dist/types/solveFn.d.ts

@@ -6,7 +6,7 @@
  * @property errors - Optional array of error messages that occurred
  * @property warnings - Optional array of warning messages from the computation
  */
-interface SolveResult {
+export interface SolveResult {
     outputs: Record<string, unknown>;
     meshes?: any[];
     errors?: string[];
@@ -23,4 +23,3 @@ interface SolveResult {
  * @returns Promise resolving to the computation result
  */
 export type SolveFn = (values: Record<string, unknown>, signal: AbortSignal) => Promise<SolveResult>;
-export {};

package/dist/utils/file-download.d.ts

@@ -1,22 +1,10 @@
-/**
- * Wrapper utilities for file downloads from Grasshopper outputs
- * Uses the core package implementation for file handling
- */
 import { type FileData } from '@selvajs/compute';
-/**
- * Download file(s) from Grasshopper outputs
- * Single files are downloaded directly, multiple files are packaged as ZIP
- */
+export declare const MIME_BY_EXT: Record<string, string>;
 export declare function downloadFiles(fileData: FileData | FileData[], fileName?: string): Promise<void>;
-/**
- * Check if data is FileData
- */
 export declare function isFileData(data: unknown): data is FileData;
-/**
- * Format file size for display
- */
+export declare function groupMessages(messages: string[]): Array<{
+    message: string;
+    count: number;
+}>;
 export declare function formatFileSize(bytes: number): string;
-/**
- * Get approximate file size from base64 string
- */
 export declare function getBase64FileSize(base64: string): number;