@praxisui/table 8.0.0-beta.33 → 8.0.0-beta.34

package/fesm2022/{praxisui-table-table-ai.adapter-DW9a89Gl.mjs → praxisui-table-table-ai.adapter-Whr5L9XO.mjs}

@@ -1,7 +1,7 @@
 import { firstValueFrom } from 'rxjs';
 import { BaseAiAdapter, createComponentAuthoringContext } from '@praxisui/ai';
 import { deepMerge } from '@praxisui/core';
-import { z as TABLE_COMPONENT_EDIT_PLAN_OPERATION_IDS, k as PRAXIS_TABLE_AUTHORING_MANIFEST, T as TABLE_AI_CAPABILITIES, R as coerceTableComponentEditPlans, W as compileTableComponentEditPlans, G as TASK_PRESETS, $ as getTableComponentEditPlanCapabilities, w as TABLE_COMPONENT_EDIT_PLAN_EXPECTED_PATHS, u as TABLE_COMPONENT_EDIT_PLAN_ALLOWED_CHANGE_KINDS, x as TABLE_COMPONENT_EDIT_PLAN_JSON_SCHEMA, E as TABLE_COMPONENT_EDIT_PLAN_VERSION, v as TABLE_COMPONENT_EDIT_PLAN_BATCH_KIND, y as TABLE_COMPONENT_EDIT_PLAN_KIND } from './praxisui-table-praxisui-table-BoDxoDos.mjs';
+import { z as TABLE_COMPONENT_EDIT_PLAN_OPERATION_IDS, k as PRAXIS_TABLE_AUTHORING_MANIFEST, T as TABLE_AI_CAPABILITIES, R as coerceTableComponentEditPlans, W as compileTableComponentEditPlans, G as TASK_PRESETS, $ as getTableComponentEditPlanCapabilities, w as TABLE_COMPONENT_EDIT_PLAN_EXPECTED_PATHS, u as TABLE_COMPONENT_EDIT_PLAN_ALLOWED_CHANGE_KINDS, x as TABLE_COMPONENT_EDIT_PLAN_JSON_SCHEMA, E as TABLE_COMPONENT_EDIT_PLAN_VERSION, v as TABLE_COMPONENT_EDIT_PLAN_BATCH_KIND, y as TABLE_COMPONENT_EDIT_PLAN_KIND } from './praxisui-table-praxisui-table-CBKUT72z.mjs';
 
 const TABLE_COMPONENT_CONTEXT_PACK = {
     version: 'v1',
@@ -396,6 +396,7 @@ const TABLE_COMPONENT_CONTEXT_PACK = {
             options: [
                 { value: 'filled', label: 'Filled' },
                 { value: 'outlined', label: 'Outlined' },
+                { value: 'soft', label: 'Soft' },
             ],
         },
         'columns[].renderer.rating.size': {
@@ -502,6 +503,7 @@ const TABLE_COMPONENT_CONTEXT_PACK = {
             options: [
                 { value: 'filled', label: 'Filled' },
                 { value: 'outlined', label: 'Outlined' },
+                { value: 'soft', label: 'Soft' },
             ],
         },
         'columns[].conditionalRenderers[].renderer.rating.size': {
@@ -714,6 +716,17 @@ const TABLE_COMPONENT_CONTEXT_PACK = {
                 columns: [{ field: '{{target}}', width: '{{value}}' }],
             },
         },
+        {
+            id: 'column.order.set',
+            intentExamples: ['ordem visual', 'mover coluna', 'colocar depois de', 'colocar antes de'],
+            scope: 'COLUMN',
+            valueType: 'NUMBER',
+            operation: 'update',
+            requiresExistingTarget: true,
+            patchTemplate: {
+                columns: [{ field: '{{target}}', order: '{{value}}' }],
+            },
+        },
         {
             id: 'column.align.set',
             intentExamples: ['align', 'alinhamento', 'left', 'center', 'right'],
@@ -1621,6 +1634,8 @@ const TABLE_COMPONENT_CONTEXT_PACK = {
         'Set columns[].type before choosing columns[].format presets to avoid mismatched formatting.',
         'Renderer config overrides format/valueMapping; avoid mixing unless required.',
         'Use ADD_CONDITIONAL_RENDERER with renderer.type + renderer.<type> config for conditional badges/chips.',
+        'When the table already shows a status/boolean column as valueMapping or chip/badge and the user refines colors, variants, icons, animation or tooltip, preserve the target column and create conditionalRenderers per semantic value instead of repeating the same valueMapping.',
+        'For boolean chips/badges, model true/false branches explicitly: condition {"==":[{"var":"<field>"},true]} for the positive label and {"==":[{"var":"<field>"},false]} for the negative label; use renderer.type "chip" or "badge" with text, color and variant.',
         'DOC: Widget purpose: data table with sorting, filtering, pagination, and actions.',
         'DOC: Host inputs: tableId (required), resourcePath (optional), config (optional).',
         'DOC: config defaults to createDefaultTableConfig(); columns may start empty.',
@@ -1752,7 +1767,7 @@ function isNonEmptyString(value) {
  * que ajudem a IA a sugerir renderers e formatos adequados.
  */
 class TableDataProfiler {
-    static SAMPLE_LIMIT = 3; // Analisa no máximo 3 linhas para performance
+    static SAMPLE_LIMIT = 50; // Mantem custo baixo sem perder categorias comuns da pagina.
     static VALUE_TRUNCATE = 50; // Trunca strings longas no contexto
     static profile(data, config, options) {
         const sampleLimit = options?.sampleLimit ?? this.SAMPLE_LIMIT;
@@ -1765,9 +1780,9 @@ class TableDataProfiler {
         if (!data || data.length === 0 || !config.columns) {
             return profile;
         }
-        // 1. Selecionar amostra (início, meio e fim se possível, ou apenas slice)
-        // Para simplicidade e estabilidade, pegamos os primeiros N itens.
-        const sample = data.slice(0, sampleLimit);
+        // 1. Selecionar amostra representativa. Para tabelas maiores, distribui a
+        // amostra pelo conjunto inteiro em vez de olhar apenas as primeiras linhas.
+        const sample = this.sampleRows(data, sampleLimit);
         // 2. Iterar colunas configuradas
         for (const col of config.columns) {
             if (!col || !col.field)
@@ -1827,6 +1842,23 @@ class TableDataProfiler {
             return undefined;
         return path.split('.').reduce((obj, key) => obj?.[key], row);
     }
+    static sampleRows(data, sampleLimit) {
+        if (!Array.isArray(data) || data.length === 0 || sampleLimit <= 0) {
+            return [];
+        }
+        if (data.length <= sampleLimit) {
+            return data.slice();
+        }
+        const indexes = new Set();
+        const maxIndex = data.length - 1;
+        for (let i = 0; i < sampleLimit; i += 1) {
+            indexes.add(Math.round((i * maxIndex) / Math.max(1, sampleLimit - 1)));
+        }
+        return Array.from(indexes)
+            .sort((a, b) => a - b)
+            .map(index => data[index])
+            .filter(row => row !== undefined && row !== null);
+    }
     static inferType(values) {
         const first = values[0];
         if (typeof first === 'number')
@@ -1851,6 +1883,22 @@ class TableDataProfiler {
     }
 }
 
+const TABLE_RUNTIME_OPERATION_PATCH_KEY = 'tableRuntimeOperations';
+const TABLE_RUNTIME_OPERATION_BATCH_KIND = 'praxis.table.runtime-operation.batch';
+const TABLE_RUNTIME_OPERATION_IDS = ['table.filter.apply', 'table.export.run'];
+const TABLE_EXPORT_SCOPES = ['auto', 'selected', 'filtered', 'currentPage', 'all'];
+const TABLE_EXPORT_FORMATS = ['excel', 'pdf', 'csv', 'json', 'print'];
+const TABLE_UNSUPPORTED_FILTER_COMBINATOR_KEYS = new Set([
+    '$and',
+    '$not',
+    '$or',
+    'allOf',
+    'and',
+    'anyOf',
+    'not',
+    'oneOf',
+    'or',
+]);
 /**
  * Adapter that connects the AI Engine to a specific PraxisTable instance.
  * Implements two-step intent flow + heuristics for contextual suggestions.
@@ -1872,14 +1920,26 @@ class TableAiAdapter extends BaseAiAdapter {
         await tableWithFilterSchema.ensureFilterSchemaFieldsSnapshot?.();
     }
     compileAiResponse(response) {
+        const runtimeOperations = this.coerceTableRuntimeOperationBatch(response);
+        if (runtimeOperations) {
+            return {
+                patch: {
+                    [TABLE_RUNTIME_OPERATION_PATCH_KEY]: runtimeOperations,
+                },
+                explanation: typeof response['explanation'] === 'string'
+                    ? response['explanation']
+                    : 'Preparei uma operacao de runtime para a tabela.',
+            };
+        }
         const componentEditPlans = coerceTableComponentEditPlans(response);
         if (!componentEditPlans) {
             return null;
         }
-        const compiled = compileTableComponentEditPlans(componentEditPlans, this.getCurrentConfig());
+        const compiled = compileTableComponentEditPlans(componentEditPlans, this.getCompileConfig());
         if (compiled.patch) {
+            const patch = this.hydratePatchColumnsFromSchema(compiled.patch);
             return {
-                patch: this.normalizePatch(compiled.patch),
+                patch: this.normalizePatch(patch),
                 explanation: typeof response['explanation'] === 'string' ? response['explanation'] : compiled.explanation,
                 warnings: compiled.warnings,
             };
@@ -1905,6 +1965,7 @@ class TableAiAdapter extends BaseAiAdapter {
         return TASK_PRESETS;
     }
     getRuntimeState() {
+        const selectedRowsContext = this.table.getAiAssistantSelectedRowsContext?.();
         return {
             resourcePath: this.table.resourcePath || null,
             rowsTotal: this.table.dataSource.data.length,
@@ -1913,11 +1974,15 @@ class TableAiAdapter extends BaseAiAdapter {
             sort: this.table.sort ? { active: this.table.sort.active, direction: this.table.sort.direction } : null,
             filters: this.table.filterCriteria,
             selectionCount: this.table.selection.selected.length,
+            ...(selectedRowsContext ? { selection: selectedRowsContext } : {}),
             isLoading: false // TODO: expose real loading flag
         };
     }
     getAuthoringContext() {
         const filterFieldCatalog = this.buildFilterFieldCatalog();
+        const selectedRowsContext = this.getSelectedRowsAuthoringContext();
+        const resourceCapabilities = this.getResourceCapabilityAuthoringContext();
+        const filterExpressionSupported = resourceCapabilities?.filterExpressionSupported === true;
         const responseModes = [
             {
                 kind: 'consult',
@@ -1932,6 +1997,12 @@ class TableAiAdapter extends BaseAiAdapter {
                 rules: [
                     'Return type "info" with message when answering a consultative question.',
                     'Do not ask the user to choose a dataset when the current table already exposes resourcePath.',
+                    'When runtimeState.selection exists, treat it as governed context for the rows selected by the user, using only its sanitized ids and sampleRows.',
+                    'When selectedRecordsContext.selectedCount is greater than zero, do not claim that no record is selected; answer from selectedRecordsContext.sampleRows even when there is only one selected row.',
+                    'When selectedRecordsContext.filterCandidates exists, treat those candidates as the canonical selection-derived bridge to advanced filters; prefer their labels and criteria over re-inferring values from prose.',
+                    'When the user asks how selected records can drive advanced filters or export, bridge the selected records to declared filterFieldCatalog fields and export scopes conceptually; ask for clarification when the shared property or export scope is ambiguous.',
+                    'For ambiguous selected-record bridge requests that can become a real table operation, prefer type "clarification" with concise user-facing options grounded in filterFieldCatalog labels or export scopes; do not answer with a long documentation-style explanation.',
+                    'Keep selected-record bridge responses human-facing: mention selected record count and meaningful labels, but do not expose raw ids, endpoint paths, operationIds, internal field names, schema keys, or payload examples unless the user explicitly asks for technical details.',
                     'For how-to or documentation-style turns, explain the governed operation shape and give a safe example instead of collecting missing edit parameters.',
                     'Do not return clarification for missing target fields, labels, formats, colors, conditions, or columns unless the selected response mode is edit/componentEditPlan.',
                     'Only produce componentEditPlan when the user asks to apply or materialize a table change.',
@@ -1954,10 +2025,15 @@ class TableAiAdapter extends BaseAiAdapter {
             responseModes,
             consultativeContext: {
                 resourcePath: this.table.resourcePath || null,
+                ...(resourceCapabilities ? { resourceCapabilities } : {}),
+                ...(selectedRowsContext ? { selectedRecordsContext: selectedRowsContext } : {}),
                 answerableQuestionKinds: [
                     'current-resource-path',
                     'current-endpoint',
                     'schema-fields',
+                    'selected-records',
+                    'selection-derived-filter-candidates',
+                    'selection-derived-export-scope',
                     'styling-capabilities',
                     'conditional-renderers',
                     'conditional-styles',
@@ -1979,14 +2055,82 @@ class TableAiAdapter extends BaseAiAdapter {
                     'Use componentEditPlan instead of free patch when the request fits an allowed table operationId or changeKind.',
                     'Prefer manifest operationId for governed agentic authoring responses.',
                     'Use batch kind with operations for multiple table edits in one request.',
+                    'For column.order.set, use a zero-based visual index from currentStateDigest.columnOrder; when the user says after a column, use that column index + 1, and when the user says before a column, use that column index.',
                     'Use Json Logic objects for computed expressions and conditional rules.',
+                    'For selected-record bridge requests, configure available table capabilities such as filter.advanced.configure, filter.advanced.fields.add, toolbar.action.add, or export.configure; do not invent a runtime apply-filter or run-export operation unless it is declared in the contract.',
                     'Do not invent fields, operationIds, changeKinds, capabilityPaths, formats, badge variants, or colors outside the provided contract.',
                 ],
                 operationRegistryCoverage: TABLE_AUTHORING_REGISTRY_COVERAGE,
             },
+            runtimeOperations: {
+                kind: TABLE_RUNTIME_OPERATION_BATCH_KIND,
+                allowedOperationIds: [...TABLE_RUNTIME_OPERATION_IDS],
+                filterExpression: {
+                    supported: filterExpressionSupported,
+                    source: resourceCapabilities?.source ?? 'unavailable',
+                    materialization: filterExpressionSupported
+                        ? 'Capability advertised by resource metadata; this table runtime still declares only table.filter.apply for simple conjunction criteria.'
+                        : 'Compound OR/nested boolean filters are not materializable by the current resource/runtime contract.',
+                },
+                operations: [
+                    {
+                        operationId: 'table.filter.apply',
+                        inputSchema: {
+                            criteria: 'object',
+                            criteriaSemantics: 'simple-conjunction',
+                            source: ['selected-records', 'manual', 'current-context'],
+                        },
+                        materializes: 'Aplica criterios em conjunto no estado runtime dos filtros avancados.',
+                    },
+                    {
+                        operationId: 'table.export.run',
+                        inputSchema: {
+                            format: [...TABLE_EXPORT_FORMATS],
+                            scope: [...TABLE_EXPORT_SCOPES],
+                        },
+                        materializes: 'Dispara exportacao da tabela usando o pipeline canonico de Collection Export.',
+                    },
+                ],
+                rules: [
+                    'Use table.filter.apply only when the user asks to apply current table filters now; criteria must be grounded in declared filterFieldCatalog fields and selectedRecordsContext values when selection is the source.',
+                    'When selectedRecordsContext.filterCandidates contains a candidate whose label or field matches the requested selected-record filter, emit table.filter.apply with that candidate criteria exactly.',
+                    'For filterFieldCatalog fields with criterionKind "range" and selectedRecordsContext as the source, derive criteria from the minimum and maximum selected values in relatedColumnFields and emit { start, end }; for criterionKind "date-range", emit { startDate, endDate } from the earliest and latest selected dates.',
+                    'When the user asks for similar, matching, related, or comparable records from selected records without naming which property should define similarity, return clarification with options derived from filterFieldCatalog labels instead of info text or a patch.',
+                    'When runtimeOperations.filterExpression.supported is not true, do not materialize OR, alternative groups, or nested boolean filters; ask which single filter field/value should be applied or explain the limitation.',
+                    'table.filter.apply accepts only simple conjunction criteria over declared fields; do not emit OR/AND groups, anyOf/oneOf/allOf, or nested boolean filter expressions. Ask for clarification or explain the limitation when the user needs alternatives.',
+                    'Use table.export.run only when the user asks to run an export now; choose scope selected for selected records, filtered for filtered results, and ask for clarification when the user does not specify enough context.',
+                    'For combined runtime requests, return every requested operation in order inside the same tableRuntimeOperations batch; when the user asks to filter and then export the filtered results, emit table.filter.apply first and table.export.run second with scope filtered.',
+                ],
+            },
         };
         return createComponentAuthoringContext(authoringContract);
     }
+    getSelectedRowsAuthoringContext() {
+        try {
+            const selection = this.table.getAiAssistantSelectedRowsContext?.();
+            return selection && typeof selection === 'object' ? selection : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    getResourceCapabilityAuthoringContext() {
+        const tableWithCapabilities = this.table;
+        try {
+            const digest = tableWithCapabilities.getResourceCapabilityDigest?.();
+            if (!digest || typeof digest !== 'object')
+                return null;
+            return {
+                source: digest['source'] || 'schema-x-ui-resource',
+                resourcePath: digest['resourcePath'] || this.table.resourcePath || null,
+                canonicalOperations: { ...(digest['canonicalOperations'] || {}) },
+                filterExpressionSupported: digest['filterExpressionSupported'] === true,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
     buildFilterFieldCatalog() {
         const fields = this.getFilterSchemaFields();
         if (!fields.length)
@@ -1997,11 +2141,17 @@ class TableAiAdapter extends BaseAiAdapter {
             resourcePath: this.table.resourcePath || null,
             fields: fields.map((field) => {
                 const aliases = this.buildFilterFieldAliases(field, columns);
+                const relatedColumnFields = this.toStringArray(field['relatedColumnFields']);
+                const relatedColumnLabels = this.toStringArray(field['relatedColumnLabels']);
+                const criterionSemantics = this.inferFilterCriterionSemantics(field);
                 return {
                     name: field['name'],
                     label: field['label'] ?? field['name'],
                     type: field['type'] ?? null,
                     controlType: field['controlType'] ?? null,
+                    ...(relatedColumnFields.length ? { relatedColumnFields } : {}),
+                    ...(relatedColumnLabels.length ? { relatedColumnLabels } : {}),
+                    ...(criterionSemantics ? criterionSemantics : {}),
                     ...(aliases.length ? { aliases } : {}),
                 };
             }),
@@ -2018,20 +2168,21 @@ class TableAiAdapter extends BaseAiAdapter {
     }
     buildFilterFieldAliases(field, columns) {
         const aliases = new Set();
+        const declaredAliases = Array.isArray(field['aliases']) ? field['aliases'] : [];
+        for (const value of declaredAliases) {
+            this.addFilterFieldAlias(aliases, value);
+        }
         for (const key of ['name', 'label']) {
             const value = this.normalizeAliasValue(field[key]);
-            if (value)
-                aliases.add(value);
+            this.addFilterFieldAlias(aliases, value);
         }
         for (const value of field['relatedColumnFields'] || []) {
             const alias = this.normalizeAliasValue(value);
-            if (alias)
-                aliases.add(alias);
+            this.addFilterFieldAlias(aliases, alias);
         }
         for (const value of field['relatedColumnLabels'] || []) {
             const alias = this.normalizeAliasValue(value);
-            if (alias)
-                aliases.add(alias);
+            this.addFilterFieldAlias(aliases, alias);
         }
         for (const column of columns || []) {
             const columnField = this.normalizeAliasValue(column?.field);
@@ -2040,14 +2191,41 @@ class TableAiAdapter extends BaseAiAdapter {
             const fieldName = this.normalizeAliasValue(field['name']);
             const fieldLabel = this.normalizeAliasValue(field['label']);
             if (fieldName.includes(columnField) || fieldLabel.includes(columnField)) {
-                aliases.add(columnField);
+                this.addFilterFieldAlias(aliases, columnField);
                 const header = this.normalizeAliasValue(column?.header);
-                if (header)
-                    aliases.add(header);
+                this.addFilterFieldAlias(aliases, header);
             }
         }
         return [...aliases];
     }
+    addFilterFieldAlias(aliases, value) {
+        const alias = this.normalizeAliasValue(value);
+        if (!alias)
+            return;
+        aliases.add(alias);
+        for (const variant of this.semanticFilterAliasVariants(alias)) {
+            aliases.add(variant);
+        }
+    }
+    semanticFilterAliasVariants(alias) {
+        const variants = new Set();
+        const tokens = alias.split(/\s+/u).filter((token) => token.length > 0);
+        const addIfTokenPresent = (token, values) => {
+            if (tokens.includes(token)) {
+                for (const value of values)
+                    variants.add(value);
+            }
+        };
+        addIfTokenPresent('departamento', ['depto', 'depart', 'department', 'departamento']);
+        addIfTokenPresent('departamentos', ['depto', 'depart', 'department', 'departamento']);
+        addIfTokenPresent('admissao', ['admitido', 'admitidos', 'entrada', 'ingresso']);
+        addIfTokenPresent('admissoes', ['admitido', 'admitidos', 'entrada', 'ingresso']);
+        addIfTokenPresent('salario', ['remuneracao', 'remuneracoes', 'ganho', 'ganhos']);
+        addIfTokenPresent('salarial', ['remuneracao', 'remuneracoes', 'ganho', 'ganhos']);
+        addIfTokenPresent('cargo', ['funcao', 'funcoes', 'papel', 'papeis']);
+        addIfTokenPresent('cargos', ['funcao', 'funcoes', 'papel', 'papeis']);
+        return [...variants];
+    }
     normalizeAliasValue(value) {
         if (typeof value !== 'string')
             return '';
@@ -2059,6 +2237,37 @@ class TableAiAdapter extends BaseAiAdapter {
             .trim()
             .toLowerCase();
     }
+    toStringArray(value) {
+        if (!Array.isArray(value))
+            return [];
+        return value.filter((item) => typeof item === 'string' && item.trim().length > 0);
+    }
+    inferFilterCriterionSemantics(field) {
+        const name = typeof field['name'] === 'string' ? field['name'] : '';
+        const normalizedName = this.normalizeAliasValue(name);
+        const normalizedType = this.normalizeAliasValue(field['type']);
+        const normalizedControlType = this.normalizeAliasValue(field['controlType']);
+        const isRange = normalizedControlType.includes('range')
+            || /(?:Between|Range)$/u.test(name);
+        if (!isRange) {
+            return /IdsIn$/u.test(name)
+                ? {
+                    criterionKind: 'set',
+                    criterionValueShape: 'array',
+                }
+                : null;
+        }
+        const isDate = normalizedType.includes('date')
+            || normalizedControlType.includes('date')
+            || normalizedType.includes('time')
+            || normalizedControlType.includes('time');
+        return {
+            criterionKind: isDate ? 'date-range' : 'range',
+            criterionValueShape: isDate ? 'startDate-endDate' : 'start-end',
+            selectedRecordsAggregation: 'min-max',
+            ...(normalizedName ? { semanticSourceHint: normalizedName } : {}),
+        };
+    }
     getSuggestionContext() {
         const config = this.getCurrentConfig();
         const behavior = config.behavior || {};
@@ -2150,12 +2359,86 @@ class TableAiAdapter extends BaseAiAdapter {
         return TableDataProfiler.profile(data, this.table.config);
     }
     getSchemaFields() {
+        const fieldsByName = new Map();
         try {
-            return this.table.getSchemaFieldsSnapshot();
+            for (const field of this.table.getSchemaFieldsSnapshot()) {
+                const name = String(field?.['name'] || '').trim();
+                if (name)
+                    fieldsByName.set(name, field);
+            }
         }
         catch {
-            return [];
+            // Optional runtime snapshot; filter schema below can still ground available fields.
+        }
+        for (const field of this.getFilterSchemaFields()) {
+            const name = String(field?.['name'] || '').trim();
+            if (!name || fieldsByName.has(name))
+                continue;
+            fieldsByName.set(name, field);
+        }
+        return Array.from(fieldsByName.values());
+    }
+    getCompileConfig() {
+        const currentConfig = this.getCurrentConfig();
+        const columns = [...(currentConfig.columns || [])];
+        const existingFields = new Set(columns
+            .map((column) => String(column?.field || '').trim())
+            .filter(Boolean));
+        for (const field of this.getSchemaFields()) {
+            const name = typeof field['name'] === 'string' ? field['name'].trim() : '';
+            if (!name || existingFields.has(name))
+                continue;
+            existingFields.add(name);
+            const header = typeof field['label'] === 'string' && field['label'].trim()
+                ? field['label'].trim()
+                : name;
+            const type = typeof field['type'] === 'string' && field['type'].trim()
+                ? field['type'].trim()
+                : undefined;
+            columns.push({
+                field: name,
+                header,
+                ...(type ? { type } : {}),
+            });
         }
+        return {
+            ...currentConfig,
+            columns,
+        };
+    }
+    hydratePatchColumnsFromSchema(patch) {
+        const patchColumns = patch.columns;
+        if (!Array.isArray(patchColumns) || patchColumns.length === 0)
+            return patch;
+        const currentFields = new Set((this.getCurrentConfig().columns || [])
+            .map((column) => String(column?.field || '').trim())
+            .filter(Boolean));
+        const schemaFieldsByName = new Map(this.getSchemaFields()
+            .map((field) => [String(field['name'] || '').trim(), field])
+            .filter(([name]) => !!name));
+        const columns = patchColumns.map((column) => {
+            const field = String(column?.field || '').trim();
+            if (!field || currentFields.has(field))
+                return column;
+            const schemaField = schemaFieldsByName.get(field);
+            if (!schemaField)
+                return column;
+            const header = typeof schemaField['label'] === 'string' && schemaField['label'].trim()
+                ? schemaField['label'].trim()
+                : field;
+            const type = typeof schemaField['type'] === 'string' && schemaField['type'].trim()
+                ? schemaField['type'].trim()
+                : undefined;
+            return {
+                ...column,
+                ...(!column.header ? { header } : {}),
+                ...(type && !column.type ? { type } : {}),
+            };
+        });
+        return {
+            ...patch,
+            columns,
+        };
     }
     createSnapshot() {
         return this.getCurrentConfig();
@@ -2165,13 +2448,141 @@ class TableAiAdapter extends BaseAiAdapter {
             return;
         this.applyConfig(snapshot);
     }
+    coerceTableRuntimeOperationBatch(source) {
+        if (!source)
+            return null;
+        const nestedPatch = this.toRecord(source['patch']);
+        if (nestedPatch) {
+            const nested = this.coerceTableRuntimeOperationBatch(nestedPatch);
+            if (nested)
+                return nested;
+        }
+        const nestedComponentEditPlan = this.toRecord(source['componentEditPlan'])
+            ?? (this.stringValue(source['type']) === 'componentEditPlan' ? source : null);
+        if (nestedComponentEditPlan && nestedComponentEditPlan !== source) {
+            const nested = this.coerceTableRuntimeOperationBatch(nestedComponentEditPlan);
+            if (nested)
+                return nested;
+        }
+        const raw = this.toRecord(source[TABLE_RUNTIME_OPERATION_PATCH_KEY])
+            ?? this.toRecord(source['runtimeOperationBatch'])
+            ?? this.toRecord(source['tableRuntimeOperation'])
+            ?? nestedComponentEditPlan;
+        const directOperation = this.toRecord(source['runtimeOperation']);
+        const directOperations = Array.isArray(source['runtimeOperations']) ? source['runtimeOperations'] : null;
+        const operationCandidates = raw
+            ? raw['operations']
+            : directOperation
+                ? [directOperation]
+                : directOperations;
+        if (!Array.isArray(operationCandidates))
+            return null;
+        const operations = operationCandidates
+            .map((candidate) => this.coerceTableRuntimeOperation(candidate))
+            .filter((operation) => !!operation);
+        if (!operations.length)
+            return null;
+        return {
+            kind: TABLE_RUNTIME_OPERATION_BATCH_KIND,
+            operations,
+        };
+    }
+    coerceTableRuntimeOperation(value) {
+        const record = this.toRecord(value);
+        if (!record)
+            return null;
+        const operationId = this.stringValue(record['operationId'] ?? record['type']);
+        if (!this.isRuntimeOperationId(operationId))
+            return null;
+        const input = this.toRecord(record['input'] ?? record['params']) ?? {};
+        return {
+            operationId,
+            input,
+        };
+    }
     async applyPatch(patch, intent) {
+        const runtimeOperations = this.coerceTableRuntimeOperationBatch(patch);
+        if (runtimeOperations) {
+            return this.executeTableRuntimeOperations(runtimeOperations);
+        }
         const current = this.getCurrentConfig();
         const normalizedPatch = this.normalizePatch(patch);
         const nextConfig = this.smartMergeTableConfig(current, normalizedPatch);
         this.applyConfig(nextConfig);
         return { success: true };
     }
+    async executeTableRuntimeOperations(batch) {
+        const warnings = [];
+        for (const operation of batch.operations) {
+            if (operation.operationId === 'table.filter.apply') {
+                const criteria = this.toRecord(operation.input['criteria']);
+                if (!criteria) {
+                    return {
+                        success: false,
+                        error: 'A operacao table.filter.apply exige criterios de filtro.',
+                    };
+                }
+                if (this.hasUnsupportedFilterCombinator(criteria)) {
+                    return {
+                        success: false,
+                        error: 'A operacao table.filter.apply aceita apenas criterios simples em conjunto. Expressoes booleanas compostas ainda nao fazem parte do contrato runtime da tabela.',
+                    };
+                }
+                this.table.onAdvancedFilterSubmit(criteria);
+                continue;
+            }
+            if (operation.operationId === 'table.export.run') {
+                const format = this.stringValue(operation.input['format']).toLowerCase();
+                if (!this.isExportFormat(format)) {
+                    return {
+                        success: false,
+                        error: 'A operacao table.export.run exige um formato de exportacao valido.',
+                    };
+                }
+                if (!this.table.canRunExportAction(format)) {
+                    return {
+                        success: false,
+                        error: 'A operacao table.export.run exige exportacao habilitada e um formato permitido pela configuracao da tabela.',
+                    };
+                }
+                const scope = this.stringValue(operation.input['scope']);
+                await this.table.onExportAction({
+                    format,
+                    ...(this.isExportScope(scope) ? { scope } : {}),
+                });
+                continue;
+            }
+            warnings.push(`Operacao runtime ignorada: ${operation.operationId}`);
+        }
+        return {
+            success: true,
+            ...(warnings.length ? { warnings } : {}),
+        };
+    }
+    isRuntimeOperationId(value) {
+        return TABLE_RUNTIME_OPERATION_IDS.includes(value);
+    }
+    isExportFormat(value) {
+        return TABLE_EXPORT_FORMATS.includes(value);
+    }
+    isExportScope(value) {
+        return TABLE_EXPORT_SCOPES.includes(value);
+    }
+    toRecord(value) {
+        return value && typeof value === 'object' && !Array.isArray(value)
+            ? value
+            : null;
+    }
+    hasUnsupportedFilterCombinator(criteria) {
+        return Object.entries(criteria).some(([key, value]) => {
+            if (!TABLE_UNSUPPORTED_FILTER_COMBINATOR_KEYS.has(key))
+                return false;
+            return Array.isArray(value) || this.toRecord(value) !== null;
+        });
+    }
+    stringValue(value) {
+        return typeof value === 'string' ? value.trim() : '';
+    }
     normalizeString(value) {
         if (typeof value !== 'string') {
             return null;
@@ -2494,10 +2905,11 @@ Columns Analysis:
         const result = await firstValueFrom(aiService.executeEnrichedPrompt(userInput, context.desc, context.config, caps));
         const componentEditPlans = coerceTableComponentEditPlans(result);
         if (componentEditPlans) {
-            const compiled = compileTableComponentEditPlans(componentEditPlans, this.getCurrentConfig());
+            const compiled = compileTableComponentEditPlans(componentEditPlans, this.getCompileConfig());
             if (compiled.patch) {
+                const patch = this.hydratePatchColumnsFromSchema(compiled.patch);
                 return {
-                    patch: this.normalizePatch(compiled.patch),
+                    patch: this.normalizePatch(patch),
                     explanation: result.explanation || compiled.explanation,
                     warnings: compiled.warnings,
                 };
@@ -2696,14 +3108,17 @@ Columns Analysis:
             return col;
         const next = { ...col };
         // Normalize formats
-        if (next.format && !next.type) {
-            if (this.looksLikeCurrencyFormat(next.format)) {
+        if (next.format) {
+            if (this.looksLikeMaskFormat(next.format)) {
+                next.type = 'string';
+            }
+            else if (!next.type && this.looksLikeCurrencyFormat(next.format)) {
                 next.type = 'currency';
             }
-            else if (this.looksLikeBooleanFormat(next.format)) {
+            else if (!next.type && this.looksLikeBooleanFormat(next.format)) {
                 next.type = 'boolean';
             }
-            else if (this.looksLikeDateFormat(next.format)) {
+            else if (!next.type && this.looksLikeDateFormat(next.format)) {
                 next.type = 'date';
             }
         }