@genispace/geniapp 0.3.0 → 0.5.0

package/dist/components/utils/dataConfigUtils.d.ts

@@ -0,0 +1,80 @@
+import { InsertDatasetConfig, UpdateDatasetConfig } from '../types';
+
+export declare function debugCurrentUser(): void;
+export declare function evaluateExpression(expression: string, formData: Record<string, any>, parameters: Record<string, any>): any;
+export declare function buildInsertDataFromConfig(insertFields: InsertDatasetConfig['insertFields'], formData: Record<string, any>, parameters?: Record<string, any>): Record<string, any>;
+export declare function buildUpdateDataFromConfig(updateFields: UpdateDatasetConfig['updateFields'], formData: Record<string, any>, parameters?: Record<string, any>): Record<string, any>;
+export declare function buildUpdateConditionsFromConfig(updateConditions: UpdateDatasetConfig['updateConditions'], formData: Record<string, any>, parameters?: Record<string, any>): Record<string, any>;
+export declare function buildDatabaseUpdateData(updateFields: Record<string, {
+    source: 'static' | 'parameter' | 'input_field' | 'column' | 'computed' | 'user';
+    value: string;
+    required?: boolean;
+    fieldType?: 'VARCHAR' | 'INT32' | 'FLOAT' | 'BOOL' | 'JSON' | 'DATETIME';
+    defaultValue?: any;
+    transform?: string;
+}>, rowData: Record<string, any>, parameters?: Record<string, any>): Record<string, any>;
+export declare function buildDatabaseUpdateConditions(updateConditions: Record<string, {
+    id?: string;
+    source: 'static' | 'parameter' | 'input_field' | 'column';
+    value: string;
+    operator?: 'equals' | 'not_equals' | 'in' | 'not_in' | 'like' | 'between';
+}>, rowData: Record<string, any>, parameters?: Record<string, any>): Record<string, any> | null;
+export interface DatasourceField {
+    name: string;
+    type: string;
+    title?: string;
+    description?: string;
+    required?: boolean;
+    format?: string;
+}
+export interface DatasourceSchema {
+    type: 'object';
+    properties: Record<string, {
+        type: string;
+        title?: string;
+        description?: string;
+        format?: string;
+    }>;
+    required?: string[];
+}
+export declare function extractOutputSchemaProperties(outputSchema: Record<string, unknown> | null | undefined): Record<string, {
+    type?: string;
+    title?: string;
+    description?: string;
+    format?: string;
+    nullable?: boolean;
+}> | null;
+export declare function parseOutputSchemaFields(outputSchema: Record<string, unknown> | null | undefined): Array<{
+    name: string;
+    type: string;
+    title?: string;
+    description?: string;
+    format?: string;
+    nullable?: boolean;
+    required?: boolean;
+}>;
+export declare function mapSchemaFieldType(schemaType: string, format?: string): 'VARCHAR' | 'INT32' | 'FLOAT' | 'BOOL' | 'JSON' | 'DATETIME';
+export declare function getRecommendedOperators(fieldType: 'VARCHAR' | 'INT32' | 'FLOAT' | 'BOOL' | 'JSON' | 'DATETIME'): Array<'equals' | 'not_equals' | 'in' | 'not_in' | 'like' | 'between'>;
+export declare function validateFieldTypeCompatibility(fieldName: string, sourceType: string, targetType: 'VARCHAR' | 'INT32' | 'FLOAT' | 'BOOL' | 'JSON' | 'DATETIME'): {
+    valid: boolean;
+    message?: string;
+};
+export interface InputSchemaParameter {
+    name: string;
+    type: string;
+    title?: string;
+    description?: string;
+    required?: boolean;
+    defaultValue?: any;
+}
+export interface InputSchema {
+    type: 'object';
+    properties: Record<string, {
+        type: string;
+        title?: string;
+        description?: string;
+        format?: string;
+        default?: any;
+    }>;
+    required?: string[];
+}

package/dist/components/utils/databaseDatasourceColumnValue.d.ts

@@ -0,0 +1,8 @@
+import { DatabaseDataSourceConfig } from '../types/databaseDataSource';
+
+export declare function queryDatabaseColumnValue(datasourceConfig: DatabaseDataSourceConfig, field: string, processedParams: Record<string, unknown>, condition?: string, opts?: {
+    nullAsEmpty?: boolean;
+}): Promise<{
+    result: number | string;
+    error?: string;
+}>;

package/dist/components/utils/databaseDatasourceParams.d.ts

@@ -0,0 +1,44 @@
+import { ParameterRecord, ParameterValue } from '../types/parameters';
+
+export declare function extractParameterNamesFromDatasourceParameters(parameters: Record<string, unknown> | undefined): string[];
+/**
+ * Source names of bound params that carry a configured default `value` (including `''`).
+ * Such params always resolve to at least their default ('' = "no filter"), so they must NOT
+ * gate the first fetch. Otherwise a component that mounts AFTER the params were broadcast
+ * (e.g. a lazy tab with `destroyInactiveTabPane: true`) waits forever for an already-passed
+ * broadcast and never fetches — the table shows up empty. Only genuinely-required bound params
+ * (declared without a default) should gate.
+ */
+export declare function extractDefaultedParameterNamesFromDatasourceParameters(parameters: Record<string, unknown> | undefined): string[];
+/**
+ * Fetch-gate groups for a datasource's bound parameters, per the `waitForValue` contract
+ * (editable in DatabaseDataSourceEditor's "wait for value" toggle):
+ * - `waitForValue: false` → never gates the first fetch (optional dimension).
+ * - `waitForValue: true`  → `strict`: the first fetch MUST wait until the param has an actual
+ *   value on the bus. Readiness marks alone don't count — FilterPanel marks its params ready
+ *   before async-resolved values (e.g. preset date ranges) land, which is exactly what used to
+ *   let empty-date queries through (all-time data overwriting the correct response).
+ * - absent → `legacy`: gates only when the param has NO configured default `value` (a default —
+ *   including `''` = "no filter" — self-resolves; waiting on it would stall components that
+ *   mount after the broadcast, e.g. lazy tabs). Readiness escapes stay valid for these.
+ * A source bound in several entries lands in the strictest group that claims it.
+ */
+export interface DatasourceFetchGateParams {
+    strict: string[];
+    legacy: string[];
+    all: string[];
+}
+export declare function extractFetchGateParamsFromDatasourceParameters(parameters: Record<string, unknown> | undefined): DatasourceFetchGateParams;
+/**
+ * Config KEYS (request-body field names, not bus source names) of bindings with an explicit
+ * `waitForValue: true`. For renderers that gate on the RESOLVED request body (Chart/Form/Tree/
+ * CollapsePanel style, where the body is a render-time memo): the fetch may only go out once
+ * every strict key actually resolved to a value — checking the body itself keeps gate and
+ * payload coherent by construction.
+ */
+export declare function extractStrictWaitParameterKeysFromDatasourceParameters(parameters: Record<string, unknown> | undefined): string[];
+export declare function hasResolvedDatasourceParameterValues(parameterNames: string[], getCurrentParameter: (name: string) => ParameterValue | undefined, rawParams: ParameterRecord): boolean;
+export declare function convertDatasourceParameterValue(value: unknown, type: string): unknown;
+export declare function processDataSourceParametersForQuery(parameters: Record<string, unknown> | undefined, parameterTypes: Record<string, string> | undefined, getCurrentParameter: (name: string) => ParameterValue | undefined, rawParams: ParameterRecord): Record<string, unknown>;
+export declare function extractParameterNamesFromCondition(condition: string | undefined): string[];
+export declare function replaceParametersInConditionString(condition: string | undefined, getCurrentParameter: (name: string) => ParameterValue | undefined, rawParams: ParameterRecord): string | undefined;

package/dist/components/utils/datasetOperationUtils.d.ts

@@ -0,0 +1,48 @@
+import { ParameterRecord } from '../types/parameters';
+import { TableDataType } from '../types/renderers';
+
+interface FieldMappingConfig {
+    source: string;
+    value: string;
+    fieldType?: string;
+    required?: boolean;
+}
+export declare function resolveTargetDatasetId(targetDatasetId: string | {
+    source: 'parameter' | 'static';
+    paramName?: string;
+    value?: string;
+}, parameters: ParameterRecord, pageParams?: ParameterRecord): string;
+export declare function executeDatasetOperation(operationType: 'update' | 'insert' | 'delete', config: {
+    targetDatasetId: string | {
+        source: 'parameter' | 'static';
+        paramName?: string;
+        value?: string;
+    };
+    updateFields?: Record<string, FieldMappingConfig & {
+        source?: string;
+    }>;
+    insertFields?: Record<string, FieldMappingConfig & {
+        source?: string;
+    }>;
+    updateConditions?: Record<string, FieldMappingConfig & {
+        source?: string;
+    }>;
+    deleteConditions?: Record<string, FieldMappingConfig & {
+        source?: string;
+    }>;
+}, record: TableDataType, parameters?: ParameterRecord, pageParams?: ParameterRecord, formValues?: Record<string, unknown>): Promise<import('../lib/types/api').ApiResponse<{
+    deletedCount?: number;
+    deleted_count?: number;
+    affectedRows?: number;
+    affected_rows?: number;
+}> | import('../lib/types/api').ApiResponse<{
+    updatedCount?: number;
+    updated_count?: number;
+    affectedRows?: number;
+    affected_rows?: number;
+}> | import('../lib/types/api').ApiResponse<{
+    ids?: Array<string | number>;
+    insertedCount?: number;
+    inserted_count?: number;
+}>>;
+export {};

package/dist/components/utils/datasourceVersion.d.ts

@@ -0,0 +1,61 @@
+import { WorkbenchConfigData } from '../types';
+
+/**
+ * Workbench-level datasource version pins.
+ *
+ * `config.datasourceVersions` is a sparse `{ [datasourceId]: version }` map:
+ * a missing entry means "follow the datasource default version". Runtime
+ * priority: workbench map > component/action-level version field > default.
+ *
+ * Renderers and hooks deep inside the tree do not receive the workbench
+ * config, so the layout syncs the map into a module-level registry
+ * (`setRuntimeDatasourceVersions`); call sites resolve through
+ * `resolveRuntimeDatasourceVersion` (imperative) or `useDatasourceVersions`
+ * (reactive).
+ */
+type DatasourceVersionsMap = Record<string, number>;
+/** Pure resolver per the design doc: read the map, fall back to the caller's version. */
+export declare function resolveDatasourceVersion(config: Pick<WorkbenchConfigData, 'datasourceVersions'> | null | undefined, datasourceId: string | null | undefined, fallback?: number): number | undefined;
+/** Called by WorkbenchLayout whenever the loaded/draft config changes. */
+export declare function setRuntimeDatasourceVersions(versions: DatasourceVersionsMap | undefined): void;
+export declare function getRuntimeDatasourceVersions(): DatasourceVersionsMap | undefined;
+/** Imperative resolution for event-driven call sites (actions, exports, caches). */
+export declare function resolveRuntimeDatasourceVersion(datasourceId: string | null | undefined, fallback?: number): number | undefined;
+/** Reactive read: components refetch when a pin changes. */
+export declare function useDatasourceVersions(): DatasourceVersionsMap | undefined;
+/**
+ * Sync the workbench-level pins from the loaded config into the module registry,
+ * clearing on unmount. Shared by every layout entry (desktop WorkbenchLayout and
+ * WorkbenchMobileLayout) so no viewport-specific entry can forget to populate it.
+ */
+export declare function useSyncRuntimeDatasourceVersions(config: Pick<WorkbenchConfigData, 'datasourceVersions'> | null | undefined): void;
+/**
+ * F6 fallback detection: backend `resolveDataSourceConfig(id, spaceId, version=N)`
+ * throws 404 `DATASOURCE_VERSION_NOT_FOUND` when the pinned version was deleted.
+ * BaseApiClient attaches the response body as `errorDetails`.
+ */
+export declare function isDatasourceVersionNotFoundError(error: unknown): boolean;
+export interface ReferencedDatasource {
+    datasourceId: string;
+    /** Name carried by the workbench config (databaseDataSourceConfig.datasourceName). */
+    name?: string;
+}
+/**
+ * All datasources referenced by the workbench — deduplicated, with the config-carried
+ * datasourceName when present. Deep-walks `config.pages` only.
+ *
+ * Reference shapes collected:
+ *  - component `databaseDataSourceConfig.datasourceId` (root-level or under props) — carries the name;
+ *  - action `targetDatasourceId` (update/insert/delete/transaction);
+ *  - ANY plain `{ datasourceId: string }` own property — catches FilterPanel-internal sources that
+ *    live outside databaseDataSourceConfig: filter option `dataSource`, presetDateRange
+ *    `dateRangeSource` / `customTabs[].source`, `updateTime`, filterSheet section/tab/tag sources, …;
+ *  - `{ stampDatasourceId: string }` (FilterPanel option-cache stamp meta source).
+ */
+export declare function collectReferencedDatasources(config: Pick<WorkbenchConfigData, 'pages'> | null | undefined): ReferencedDatasource[];
+/**
+ * All datasource ids referenced by the workbench — deduplicated.
+ * Convenience wrapper over collectReferencedDatasources.
+ */
+export declare function collectReferencedDatasourceIds(config: Pick<WorkbenchConfigData, 'pages'> | null | undefined): string[];
+export {};

package/dist/components/utils/debugUtils.d.ts

@@ -0,0 +1,34 @@
+export interface DebugInfo {
+    timestamp: number;
+    type: 'parameter_change' | 'component_render' | 'navigation' | 'error';
+    component?: string;
+    tabId?: string;
+    pageId?: string;
+    details: any;
+}
+declare class DebugLogger {
+    private logs;
+    private maxLogs;
+    private isEnabled;
+    log(type: DebugInfo['type'], details: any, component?: string, tabId?: string, pageId?: string): void;
+    getLogs(filter?: Partial<Pick<DebugInfo, 'type' | 'component' | 'tabId' | 'pageId'>>): DebugInfo[];
+    clear(): void;
+    getStats(): {
+        total: number;
+        byType: Record<string, number>;
+        byComponent: Record<string, number>;
+        byTab: Record<string, number>;
+    };
+}
+export declare const debugLogger: DebugLogger;
+export declare const logParameterChange: (key: string, value: any, oldValue: any, source: string, componentId?: string, tabId?: string) => void;
+export declare const logComponentRender: (componentId: string, componentType: string, renderProps: any, tabId?: string, pageId?: string) => void;
+export declare const logNavigation: (from: string, to: string, tabId?: string, pageId?: string) => void;
+export declare const logError: (error: Error, context: string, componentId?: string, tabId?: string, pageId?: string) => void;
+export declare const createPerformanceMonitor: (name: string) => {
+    end: () => number;
+};
+export declare const detectRenderingStateUpdates: () => void;
+export declare const setupGlobalErrorHandling: () => void;
+export declare const initDebugTools: () => void;
+export {};

package/dist/components/utils/errorFilter.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/utils/errorHandler.d.ts

@@ -0,0 +1,10 @@
+export interface ApiError {
+    message: string;
+    code?: string;
+    status?: number;
+    originalError?: unknown;
+}
+export declare const extractApiError: (error: unknown, namespaceHint?: string) => ApiError;
+export declare const getFriendlyErrorMessage: (error: ApiError, context?: string, namespaceHint?: string) => string;
+export declare const getErrorTitle: (error: ApiError) => string;
+export declare const handleApiError: (error: unknown, context?: string, namespaceHint?: string) => ApiError;

package/dist/components/utils/expressionUtils.d.ts

@@ -0,0 +1,13 @@
+export interface UserInfo {
+    id?: string;
+    name?: string;
+    email?: string;
+}
+export declare function evaluateComputedExpression(expression: string, userInfo?: UserInfo): string;
+export declare function getComputedExpressionTemplates(): {
+    label: string;
+    value: string;
+    description: string;
+    example: string;
+    category: string;
+}[];

package/dist/components/utils/extensionErrorHandler.d.ts

@@ -0,0 +1,4 @@
+export declare const isExtensionError: (error: Error | string) => boolean;
+export declare const handleExtensionError: (error: Error) => void;
+export declare const setupExtensionErrorHandler: () => void;
+export declare const diagnoseExtensionIssues: () => void;

package/dist/components/utils/filterPanelDateRangeUtils.d.ts

@@ -0,0 +1,34 @@
+export type DateRangeQuickSelectPresetKey = 'today' | 'yesterday' | 'yesterdayToToday' | 'last7days' | 'last30days';
+export type DateRangeQuickSelectItems = Partial<Record<DateRangeQuickSelectPresetKey, boolean>>;
+export type DateRangeDefaultConfig = {
+    type: string;
+    defaultValue?: unknown;
+    useSpecifiedTime?: boolean;
+    showTimePicker?: boolean;
+    specifiedStartTime?: string;
+    specifiedEndTime?: string;
+    quickSelectItems?: DateRangeQuickSelectItems;
+};
+export type TimeParts = {
+    h: number;
+    m: number;
+    s: number;
+};
+export declare function parseTimePartsFromConfig(value: string | undefined): TimeParts | undefined;
+export declare function combineDateWithTimeParts(d: Date, parts: TimeParts): Date;
+export declare function applyConfiguredTimeToDateRange(filter: DateRangeDefaultConfig, range: {
+    from: Date;
+    to: Date;
+}): {
+    from: Date;
+    to: Date;
+};
+export declare function formatDateRangeStartForParams(filter: DateRangeDefaultConfig, from: Date): string;
+export declare function formatDateRangeEndForParams(filter: DateRangeDefaultConfig, to: Date): string;
+export declare function resolveDateRangeDefault(filter: DateRangeDefaultConfig): {
+    from: Date;
+    to: Date;
+} | undefined;
+export declare function filterConfigKeyForReset(f: DateRangeDefaultConfig & {
+    key: string;
+}): string;

package/dist/components/utils/filterPanelMobileDateRangeUtils.d.ts

@@ -0,0 +1,17 @@
+import { DateRange } from 'react-day-picker';
+import { TFunction } from 'i18next';
+import { DateRangeDefaultConfig, DateRangeQuickSelectPresetKey, DateRangeQuickSelectItems } from './filterPanelDateRangeUtils';
+
+export type DateRangeSelectionMode = DateRangeQuickSelectPresetKey | 'custom';
+export declare const DATE_RANGE_PRESET_ORDER: DateRangeQuickSelectPresetKey[];
+export declare function isQuickPresetVisible(preset: DateRangeQuickSelectPresetKey, quickSelectItems?: DateRangeQuickSelectItems): boolean;
+export declare function getVisibleDateRangePresets(quickSelectItems?: DateRangeQuickSelectItems): DateRangeQuickSelectPresetKey[];
+export declare function buildDateRangeForPreset(preset: DateRangeQuickSelectPresetKey): {
+    from: Date;
+    to: Date;
+};
+export declare function areDateRangesEqual(a?: DateRange, b?: DateRange): boolean;
+export declare function matchDateRangeToPreset(range: DateRange | undefined, filter: DateRangeDefaultConfig, quickSelectItems?: DateRangeQuickSelectItems): DateRangeSelectionMode;
+export declare function getDateRangePresetLabel(preset: DateRangeQuickSelectPresetKey, t: TFunction): string;
+export declare function getCustomDateRangeLabel(t: TFunction): string;
+export declare function formatMobileDateRangeSummary(range: DateRange | undefined, mode: DateRangeSelectionMode, t: TFunction, dateFormatPattern?: string): string;

package/dist/components/utils/formActionVisibility.d.ts

@@ -0,0 +1,21 @@
+import { FormActionVisibility, FormActionVisibilityClause, FormActionVisibilityOperator, VisibilityCondition } from '../types';
+
+/** Minimal shape required by visibility-clause helpers. FormAction and TableAction both satisfy it. */
+type FormActionLike = {
+    actionVisibility?: FormActionVisibility;
+    visibilityCondition?: VisibilityCondition;
+};
+export declare function normalizeFormActionVisibilityClauses(action: FormActionLike): FormActionVisibilityClause[];
+export declare function collectFormFieldKeysFromFormActionVisibility(actions: (FormActionLike & {
+    id?: string;
+})[] | undefined): Set<string>;
+export declare function hasFormActionParameterVisibilityClauses(actions: FormActionLike[] | undefined): boolean;
+export declare function evaluateFormActionVisibility(action: FormActionLike, context: {
+    formValues: Record<string, unknown>;
+    parameters: Record<string, unknown>;
+}): boolean;
+export declare function stableSerializePageParams(pageParams: Record<string, unknown> | undefined): string;
+/** Parse compare value for editor: IN uses JSON array or comma-separated tokens. */
+export declare function parseVisibilityCompareValue(operator: FormActionVisibilityOperator, raw: string): unknown;
+export declare function formatVisibilityCompareValueForEditor(operator: FormActionVisibilityOperator, value: unknown): string;
+export {};

package/dist/components/utils/grid24LayoutSystem.d.ts

@@ -0,0 +1,108 @@
+import { Grid24Preset, Grid24Component, Grid24LayoutConfig } from '../types/components';
+
+export declare const MAX_GRID24_NESTING_DEPTH = 3;
+export interface Grid24PresetConfig {
+    rows: Array<{
+        colSpan: number;
+    }>;
+}
+/** Preset id → i18n key under `workbench:grid24.presets.*` (underscores). */
+export declare function grid24PresetToTranslationKey(preset: Exclude<Grid24Preset, 'custom'>): string;
+/** English labels for `t(..., defaultValue)` before workbench namespace loads. */
+export declare const GRID24_PRESET_LABEL_FALLBACK: Record<Exclude<Grid24Preset, 'custom'>, string>;
+export declare const GRID24_PRESETS: Record<Exclude<Grid24Preset, 'custom'>, Grid24PresetConfig>;
+export declare function generateComponentsFromPreset(preset: Exclude<Grid24Preset, 'custom'>, componentIds: string[]): Grid24Component[];
+export declare function computeRowCount(components: Grid24Component[]): number;
+export declare function groupComponentsByRow(components: Grid24Component[]): Grid24Component[][];
+export declare function validateRowColSpan(components: Grid24Component[]): boolean;
+export declare function detectOverlaps(components: Grid24Component[]): Grid24Component[][];
+export declare function getComponentGridRow(comp: Grid24Component): string;
+export declare function getComponentGridColumn(comp: Grid24Component): string;
+/** Fill spacing / row metrics when absent (e.g. legacy API omitting fields). */
+export declare function applyGrid24LayoutDefaults(config: Partial<Grid24LayoutConfig> & {
+    type: 'grid-24';
+    components?: Grid24Component[];
+}): Grid24LayoutConfig;
+export declare function createDefaultGrid24Layout(componentIds: string[]): Grid24LayoutConfig;
+/**
+ * Sizing capability model (see docs: workbench-component-sizing-plan.md).
+ *
+ * Height semantics per component type:
+ * - 'content'      height follows content; vertical resize is DISABLED in the
+ *                  canvas and the view renders its rows as auto-height.
+ * - 'fill'         the component stretches/scrolls to the assigned rowSpan;
+ *                  the view renders the cell at the exact band height.
+ * Every type has one explicit height owner. New/unknown components fail safe
+ * to content mode, so the editor never offers a vertical resize that the
+ * published renderer cannot honor.
+ *
+ * w/h are the DEFAULT spans (kept identical to the pre-model values — zero
+ * migration); min/max are enforced by canvas handles, keyboard nudge and the
+ * copilot layout tools.
+ */
+export type Grid24SizeMode = 'content' | 'fill';
+export interface Grid24SizeCapability {
+    w: number;
+    h: number;
+    mode: Grid24SizeMode;
+    minW: number;
+    maxW: number;
+    minH?: number;
+    maxH?: number;
+    widthResizable: boolean;
+    heightResizable: boolean;
+}
+export declare const GRID24_SIZE_CAPABILITIES: Record<string, Grid24SizeCapability>;
+export declare function getGrid24SizeCapability(type?: string): Grid24SizeCapability;
+/** Backward-compatible projections (palette drops, merge synthesis, copilot). */
+export declare const GRID24_DEFAULT_SIZES: Record<string, {
+    w: number;
+    h: number;
+}>;
+export declare function getGrid24DefaultSize(type?: string): {
+    w: number;
+    h: number;
+};
+/** Clamp a span patch to the type's capability (copilot layout tools, nudge).
+    content-mode heights are NOT adjustable: rowSpan writes are dropped (the
+    view sizes those rows to content and auto-fit maintains the nominal span). */
+export declare function clampGrid24SpanToCapability(type: string | undefined, span: {
+    colSpan?: number;
+    rowSpan?: number;
+}): {
+    colSpan?: number;
+    rowSpan?: number;
+};
+type Grid24Child = string | {
+    id: string;
+    type?: string;
+};
+/**
+ * Vertical gravity compaction in grid space (classic dashboard behavior —
+ * Retool/Appsmith/Gridstack default): every item floats UP until it touches
+ * another item or the top. Freed space (shrink/move-away) is reclaimed
+ * automatically instead of requiring manual pull-ups. Intentional vertical
+ * whitespace is expressed via component padding / future Spacer components,
+ * not empty rows.
+ */
+export declare function compactGrid24Vertical(components: Grid24Component[]): Grid24Component[];
+/**
+ * Push-down overlap resolution in grid space (mirror of the canvas compactor):
+ * identity when nothing overlaps; otherwise the activeId item keeps its cell
+ * (insert semantics — dropping between two components pushes the ones below
+ * DOWN, it never relocates the dropped item to the bottom) and later items in
+ * reading order yield downward.
+ */
+export declare function resolveGrid24Push(components: Grid24Component[], activeId?: string): Grid24Component[];
+/** Ensure every child id has a grid entry; append missing in new rows (full
+    width, type-default height when the child's type is provided). */
+export declare function mergeGrid24WithChildIds(config: Grid24LayoutConfig, children: Grid24Child[]): Grid24LayoutConfig;
+export declare function sortChildComponentsByGrid<T extends {
+    id: string;
+}>(children: T[] | undefined, grid: Grid24Component[]): T[];
+export declare function normalizeGrid24Components(components: Grid24Component[]): Grid24Component[];
+/**
+ * Label shown on 24-grid editor tiles: localized type + " · " + title (or untitled).
+ */
+export declare function getGrid24ComponentSlotLabel(component: any): string;
+export {};

package/dist/components/utils/iconUtils.d.ts

@@ -0,0 +1,22 @@
+import { default as React } from 'react';
+
+export declare const ICON_MAPPINGS: {
+    [key: string]: React.ComponentType<{
+        className?: string;
+    }>;
+};
+export declare const getLucideIcons: () => {
+    value: string;
+    label: string;
+}[];
+export declare const LUCIDE_ICONS: {
+    value: string;
+    label: string;
+}[];
+export declare const renderLucideIcon: (iconName: string, className?: string) => React.ReactNode;
+export declare const getIconComponent: (icon: string, size?: number, className?: string) => React.ReactNode;
+export declare const hasIcon: (iconName: string) => boolean;
+export declare const getAvailableIcons: () => {
+    value: string;
+    label: string;
+}[];

package/dist/components/utils/layoutContainerNesting.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Nesting depth of a layout container (Container | Card | Tabs) from the page root.
+ * Page is not counted. Top-level container depth = 0 (matches PageComponentRenderer default nestingLevel).
+ */
+export declare function getLayoutContainerNestingLevel(components: unknown[] | undefined, targetId: string, ancestorDepth?: number): number | null;