@praxisui/table 9.0.4-rc.48 → 9.0.4-rc.49

package/fesm2022/{praxisui-table-praxisui-table-CUH7vNfu.mjs → praxisui-table-praxisui-table-Cf63AwZs.mjs}

@@ -3121,6 +3121,56 @@ function validateTableAuthoringDocument(doc, context) {
             diagnostics.push(errorDiagnostic('table.config.columns.field.required', 'Column field is required', `config.columns[${index}].field`));
         }
     });
+    if ('columnProjection' in rawConfig) {
+        const projection = asRecord(rawConfig.columnProjection);
+        if (!rawConfig.columnProjection
+            || typeof rawConfig.columnProjection !== 'object'
+            || Array.isArray(rawConfig.columnProjection)) {
+            diagnostics.push(errorDiagnostic('table.config.columnProjection.invalid', 'config.columnProjection must be an object', 'config.columnProjection'));
+        }
+        else if (projection.source !== 'schema') {
+            diagnostics.push(errorDiagnostic('table.config.columnProjection.source.invalid', 'config.columnProjection.source must be schema', 'config.columnProjection.source'));
+        }
+        if ('include' in projection) {
+            if (!Array.isArray(projection.include)
+                || projection.include.some((field) => typeof field !== 'string' || !field.trim())
+                || new Set(projection.include).size !== projection.include.length) {
+                diagnostics.push(errorDiagnostic('table.config.columnProjection.include.invalid', 'config.columnProjection.include must be an ordered array of unique canonical field names', 'config.columnProjection.include'));
+            }
+        }
+        if ('overrides' in projection) {
+            const overrides = asRecord(projection.overrides);
+            if (!projection.overrides
+                || typeof projection.overrides !== 'object'
+                || Array.isArray(projection.overrides)) {
+                diagnostics.push(errorDiagnostic('table.config.columnProjection.overrides.invalid', 'config.columnProjection.overrides must be an object keyed by canonical field name', 'config.columnProjection.overrides'));
+            }
+            else {
+                Object.entries(overrides).forEach(([field, override]) => {
+                    if (!field.trim() || !override || typeof override !== 'object' || Array.isArray(override)) {
+                        diagnostics.push(errorDiagnostic('table.config.columnProjection.override.invalid', 'Each column projection override must be an object keyed by canonical field name', `config.columnProjection.overrides.${field}`));
+                        return;
+                    }
+                    if (hasOwnProperty(override, 'field')) {
+                        diagnostics.push(errorDiagnostic('table.config.columnProjection.override.field.forbidden', 'A schema column projection override cannot change the canonical field identity', `config.columnProjection.overrides.${field}.field`));
+                    }
+                });
+            }
+        }
+        if ('additions' in projection) {
+            if (!Array.isArray(projection.additions)) {
+                diagnostics.push(errorDiagnostic('table.config.columnProjection.additions.invalid', 'config.columnProjection.additions must be an array of editorial columns', 'config.columnProjection.additions'));
+            }
+            else {
+                const fields = projection.additions
+                    .map((column) => trimString(asRecord(column).field));
+                if (fields.some((field) => !field)
+                    || new Set(fields).size !== fields.length) {
+                    diagnostics.push(errorDiagnostic('table.config.columnProjection.additions.field.invalid', 'Each editorial addition must have a unique field', 'config.columnProjection.additions'));
+                }
+            }
+        }
+    }
     const bindings = normalized.bindings || {};
     const metaIdField = trimString(normalized.config?.meta?.idField);
     if ('horizontalScroll' in rawBindings &&
@@ -3133,6 +3183,9 @@ function validateTableAuthoringDocument(doc, context) {
         diagnostics.push(errorDiagnostic('table.bindings.horizontalScroll.invalid', 'horizontalScroll must be auto, wrap or none', 'bindings.horizontalScroll'));
     }
     const effectiveMode = resolveEffectiveDataMode(normalized, context);
+    if (rawConfig.columnProjection && effectiveMode !== 'remote') {
+        diagnostics.push(warnDiagnostic('table.config.columnProjection.remote-schema.required', 'Schema column projection requires a remote resourcePath at runtime', 'config.columnProjection'));
+    }
     if (effectiveMode === 'local') {
         if (normalized.config.behavior?.pagination?.strategy === 'server') {
             diagnostics.push(warnDiagnostic('table.behavior.pagination.strategy.invalid-for-local', 'Server pagination will be projected to client in local mode', 'config.behavior.pagination.strategy'));
@@ -41906,6 +41959,7 @@ class PraxisTable {
     paginatorIntl = inject(MatPaginatorIntl);
     schemaNormalizer = inject(SchemaNormalizerService);
     schemaFieldsSnapshot = [];
+    schemaColumnFieldsSnapshot = [];
     filterSchemaFieldsSnapshot = [];
     runtimeSchemaMeta = {};
     schemaError = false;
@@ -43269,8 +43323,12 @@ class PraxisTable {
     setSchemaFieldsSnapshot(fields) {
         if (!Array.isArray(fields) || fields.length === 0) {
             this.schemaFieldsSnapshot = [];
+            this.schemaColumnFieldsSnapshot = [];
             return;
         }
+        this.schemaColumnFieldsSnapshot = fields
+            .map((field) => this.clonePlainObject(field))
+            .filter((field) => String(field?.name || '').trim().length > 0);
         this.schemaFieldsSnapshot = fields
             .map((field) => ({
             name: (field?.name || '').toString(),
@@ -43423,6 +43481,7 @@ class PraxisTable {
     }
     clearSchemaFieldsSnapshot() {
         this.schemaFieldsSnapshot = [];
+        this.schemaColumnFieldsSnapshot = [];
     }
     componentKeyId() {
         try {
@@ -44054,7 +44113,7 @@ class PraxisTable {
         if (this.aiAdapter || this.aiAdapterLoadStarted)
             return;
         this.aiAdapterLoadStarted = true;
-        import('./praxisui-table-table-ai.adapter-B3JduSXn.mjs')
+        import('./praxisui-table-table-ai.adapter-iUYC2oD5.mjs')
             .then(({ TableAiAdapter }) => {
             if (!this.isAiAssistantEnabled()) {
                 this.aiAssistantOpenAfterAdapterLoad = false;
@@ -44800,7 +44859,7 @@ class PraxisTable {
     initializeAiAssistantController() {
         if (!this.aiAdapter || this.aiAssistantController)
             return;
-        import('./praxisui-table-table-agentic-authoring-turn-flow-DsM7fuli.mjs')
+        import('./praxisui-table-table-agentic-authoring-turn-flow-Cz_xmaGA.mjs')
             .then(({ TableAgenticAuthoringTurnFlow }) => {
             if (this.aiAssistantController || !this.aiAdapter)
                 return;
@@ -51077,7 +51136,7 @@ class PraxisTable {
         col.visible = visible;
         this.setupColumns();
         this.cdr.markForCheck();
-        this.configChange.emit(this.config);
+        this.configChange.emit(this.toPortableTableConfig());
     }
     onDensityChange(density) {
         if (density !== 'compact' && density !== 'comfortable' && density !== 'spacious')
@@ -51094,7 +51153,7 @@ class PraxisTable {
         };
         this.applyAppearanceVariables();
         this.cdr.markForCheck();
-        this.configChange.emit(this.config);
+        this.configChange.emit(this.toPortableTableConfig());
     }
     isCustomizationAvailable() {
         if (!this.enableCustomization) {
@@ -51197,6 +51256,11 @@ class PraxisTable {
     applyTableConfig(cfg, options) {
         this.debugLog('[PraxisTable] Applying table config', cfg);
         this.config = { ...cfg };
+        if (this.usesSchemaColumnProjection(this.config)
+            && this.schemaColumnFieldsSnapshot.length > 0
+            && (this.config.columns?.length ?? 0) === 0) {
+            this.config.columns = this.projectSchemaColumns(this.schemaColumnFieldsSnapshot, this.config.columnProjection);
+        }
         this.syncRuntimeSchemaMetaFromConfig();
         this.ensureConfigDefaults();
         this.enforceUnsupportedFeatureGuards();
@@ -51246,13 +51310,17 @@ class PraxisTable {
     }
     emitWidgetInputPatch(inputPatch, trigger) {
         try {
+            const portablePatch = this.cloneInputPatch(inputPatch);
+            if (Object.prototype.hasOwnProperty.call(portablePatch, 'config')) {
+                portablePatch['config'] = this.toPortableTableConfig(portablePatch['config']);
+            }
             this.widgetEvent.emit({
                 sourceComponentId: 'praxis-table',
                 output: 'tableInputPatch',
                 payload: {
                     trigger,
                     tableId: this.tableId,
-                    inputPatch: JSON.parse(JSON.stringify(inputPatch)),
+                    inputPatch: portablePatch,
                 },
             });
         }
@@ -51263,7 +51331,7 @@ class PraxisTable {
         setTimeout(() => {
             this.emitWidgetInputPatch(clonedPatch, trigger);
             if (Object.prototype.hasOwnProperty.call(clonedPatch, 'config')) {
-                this.configChange.emit(clonedPatch['config']);
+                this.configChange.emit(this.toPortableTableConfig(clonedPatch['config']));
             }
         }, 0);
     }
@@ -51313,7 +51381,8 @@ class PraxisTable {
                 this.persistHorizontalScrollInput(inputsKey, nextHs, trigger);
             }
         }
-        const cfg = this.attachRuntimeMetadataToEditorConfig(plan.canonicalConfig, plan.metadata?.attachServerMeta === true && !shouldReloadSchema, plan.persistence?.saveConfig === true);
+        const compactConfig = this.toPortableTableConfig(plan.canonicalConfig);
+        const cfg = this.attachRuntimeMetadataToEditorConfig(compactConfig, plan.metadata?.attachServerMeta === true && !shouldReloadSchema, plan.persistence?.saveConfig === true);
         if (plan.persistence?.saveConfig) {
             const cfgKey = this.tableConfigKey();
             if (cfgKey) {
@@ -52951,17 +53020,23 @@ class PraxisTable {
                 this.emitSchemaStatus({ outdated: false, serverHash: this.runtimeSchemaMeta.serverHash, lastVerifiedAt: this.runtimeSchemaMeta.lastVerifiedAt, resourcePath: this.resourcePath }, 'verification-304');
                 return;
             }
-            // status === 200: server hash changed or first verification without hash. Do not
-            // replace the column list, but keep existing columns enriched with safe schema
-            // presentation metadata such as semantic renderers, masks, and value mappings.
+            // status === 200: server hash changed or first verification without hash.
+            // Explicit column contracts remain stable and receive safe presentation metadata.
+            // Schema projections are rebuilt so newly published fields and governed defaults
+            // are reflected before their editorial overrides are reapplied.
             const newHash = res.schemaHash;
             try {
                 const fields = this.schemaNormalizer.normalizeSchema(res.schema);
                 this.setSchemaFieldsSnapshot(fields);
-                this.applySchemaFieldPresentationsToExistingColumns(fields);
+                if (this.usesSchemaColumnProjection()) {
+                    this.config.columns = this.projectSchemaColumns(fields);
+                }
+                else {
+                    this.applySchemaFieldPresentationsToExistingColumns(fields);
+                }
                 this.loadFilterSchemaSnapshot();
                 this.setupColumns();
-                this.configChange.emit(this.config);
+                this.configChange.emit(this.toPortableTableConfig());
             }
             catch { }
             this.runtimeSchemaMeta = {
@@ -53035,10 +53110,10 @@ class PraxisTable {
                 }
                 catch { }
                 const existing = this.config?.columns ?? [];
-                if (options?.replaceColumns === true || existing.length === 0) {
-                    this.config.columns = fields
-                        .filter((f) => !f.tableHidden && !f.hidden)
-                        .map((f) => this.convertFieldToColumn(f));
+                if (this.usesSchemaColumnProjection()
+                    || options?.replaceColumns === true
+                    || existing.length === 0) {
+                    this.config.columns = this.projectSchemaColumns(fields);
                 }
                 else {
                     this.applySchemaFieldPresentationsToExistingColumns(fields);
@@ -53048,7 +53123,7 @@ class PraxisTable {
                     resourcePath: this.resourcePath,
                     horizontalScroll: this.horizontalScroll,
                 }, 'schema-loaded');
-                this.configChange.emit(this.config);
+                this.configChange.emit(this.toPortableTableConfig());
                 const mountCtx = this.buildLoadingContext('mount', 'Montando colunas…', false);
                 this.beginLoading(mountCtx);
                 try {
@@ -53142,6 +53217,163 @@ class PraxisTable {
         catch { }
         return col;
     }
+    usesSchemaColumnProjection(config = this.config) {
+        return config?.columnProjection?.source === 'schema';
+    }
+    /**
+     * Materializa a projeção efetiva sem promover o JSON da página a fonte de
+     * verdade estrutural. Overrides desconhecidos não criam colunas e `field`
+     * nunca pode ser substituído pelo consumidor.
+     */
+    projectSchemaColumns(fields, projection = this.usesSchemaColumnProjection()
+        ? this.config?.columnProjection
+        : undefined) {
+        const overrides = projection?.overrides ?? {};
+        const include = Array.isArray(projection?.include)
+            ? projection.include
+                .map((field) => String(field || '').trim())
+                .filter((field, index, values) => !!field && values.indexOf(field) === index)
+            : [];
+        const includeOrder = new Map(include.map((field, index) => [field, index]));
+        const schemaColumns = (Array.isArray(fields) ? fields : [])
+            .filter((field) => !field.tableHidden && !field.hidden)
+            .filter((field) => include.length === 0 || includeOrder.has(field.name))
+            .sort((left, right) => {
+            if (include.length === 0)
+                return 0;
+            return (includeOrder.get(left.name) ?? Number.MAX_SAFE_INTEGER)
+                - (includeOrder.get(right.name) ?? Number.MAX_SAFE_INTEGER);
+        })
+            .map((field) => {
+            const base = this.convertFieldToColumn(field);
+            const override = overrides[field.name];
+            if (!override || typeof override !== 'object' || Array.isArray(override)) {
+                return base;
+            }
+            const merged = deepMerge(base, override);
+            return {
+                ...merged,
+                field: base.field,
+                _isApiField: base._isApiField,
+                _originalApiType: base._originalApiType,
+            };
+        });
+        const canonicalFields = new Set((Array.isArray(fields) ? fields : [])
+            .map((field) => String(field?.name || '').trim())
+            .filter(Boolean));
+        const additions = Array.isArray(projection?.additions)
+            ? projection.additions
+                .filter((column) => {
+                const field = String(column?.field || '').trim();
+                return !!field && !canonicalFields.has(field);
+            })
+                .map((column) => this.toPortableColumnDefinition(column))
+            : [];
+        return [...schemaColumns, ...additions];
+    }
+    /**
+     * Converte a configuração materializada usada pelo renderer de volta ao
+     * contrato compacto e persistível. O schema continua sendo a fonte
+     * estrutural; somente ordem/allowlist, diferenças editoriais e colunas sem
+     * correspondente canônico são serializadas.
+     */
+    toPortableTableConfig(config = this.config) {
+        const cloned = this.clonePlainObject(config);
+        if (!this.usesSchemaColumnProjection(cloned)
+            || this.schemaColumnFieldsSnapshot.length === 0
+            || !Array.isArray(cloned.columns)
+            || cloned.columns.length === 0) {
+            return cloned;
+        }
+        const projection = this.clonePlainObject(cloned.columnProjection);
+        const visibleSchemaFields = this.schemaColumnFieldsSnapshot
+            .filter((field) => !field.tableHidden && !field.hidden);
+        const canonicalFieldNames = new Set(visibleSchemaFields
+            .map((field) => String(field?.name || '').trim())
+            .filter(Boolean));
+        const authoredColumns = cloned.columns
+            .filter((column) => !!String(column?.field || '').trim());
+        const include = authoredColumns
+            .map((column) => String(column.field).trim())
+            .filter((field, index, values) => (canonicalFieldNames.has(field) && values.indexOf(field) === index));
+        const effectiveProjection = {
+            ...projection,
+            include,
+            overrides: {},
+            additions: [],
+        };
+        const baseColumns = this.projectSchemaColumns(visibleSchemaFields, effectiveProjection);
+        const baseByField = new Map(baseColumns.map((column) => [column.field, column]));
+        const previousOverrides = projection.overrides ?? {};
+        const overrides = {};
+        // Overrides de campos ausentes no snapshot são preservados, porém nunca
+        // criam uma coluna por conta própria.
+        Object.entries(previousOverrides).forEach(([field, override]) => {
+            if (!canonicalFieldNames.has(field) && override && typeof override === 'object') {
+                const safeOverride = this.clonePlainObject(override);
+                delete safeOverride['field'];
+                overrides[field] = safeOverride;
+            }
+        });
+        authoredColumns.forEach((column) => {
+            const field = String(column.field).trim();
+            const base = baseByField.get(field);
+            if (!base)
+                return;
+            const override = this.diffPortableColumnDefinition(base, column);
+            if (Object.keys(override).length > 0) {
+                overrides[field] = override;
+            }
+        });
+        const additions = authoredColumns
+            .filter((column) => !canonicalFieldNames.has(String(column.field).trim()))
+            .map((column) => this.toPortableColumnDefinition(column));
+        cloned.columns = [];
+        cloned.columnProjection = {
+            ...projection,
+            source: 'schema',
+            include,
+            ...(Object.keys(overrides).length > 0 ? { overrides } : { overrides: undefined }),
+            ...(additions.length > 0 ? { additions } : { additions: undefined }),
+        };
+        return cloned;
+    }
+    diffPortableColumnDefinition(base, authored) {
+        const portableBase = this.toPortableColumnDefinition(base);
+        const portableAuthored = this.toPortableColumnDefinition(authored);
+        const override = {};
+        Object.entries(portableAuthored).forEach(([key, value]) => {
+            if (key === 'field' || value === undefined)
+                return;
+            if (!this.arePortableValuesEqual(portableBase[key], value)) {
+                override[key] = this.clonePlainObject(value);
+            }
+        });
+        return override;
+    }
+    toPortableColumnDefinition(column) {
+        const cloned = this.clonePlainObject(column);
+        delete cloned['_isApiField'];
+        delete cloned['_originalApiType'];
+        return cloned;
+    }
+    arePortableValuesEqual(left, right) {
+        const canonicalize = (value) => {
+            if (Array.isArray(value))
+                return value.map(canonicalize);
+            if (!value || typeof value !== 'object')
+                return value;
+            return Object.keys(value)
+                .sort()
+                .reduce((result, key) => {
+                const candidate = value[key];
+                if (candidate !== undefined)
+                    result[key] = canonicalize(candidate);
+                return result;
+            }, {});
+        };
+        return JSON.stringify(canonicalize(left)) === JSON.stringify(canonicalize(right));
+    }
     applySchemaFieldPresentationsToExistingColumns(fields) {
         if (!Array.isArray(fields) || !fields.length)
             return;
@@ -61531,7 +61763,7 @@ const rendererSchema = {
  * Manifesto de authoring canônico para o componente praxis-table.
  * Este arquivo define o contrato executável para que agentes de IA editem tabelas.
  *
- * @version 2.2.2
+ * @version 2.2.3
  * @status COMPLIANT - Alinhado com o contrato v2 e TableConfig canônico.
  */
 const PRAXIS_TABLE_AUTHORING_MANIFEST = {
@@ -61539,7 +61771,7 @@ const PRAXIS_TABLE_AUTHORING_MANIFEST = {
     componentId: 'praxis-table',
     ownerPackage: '@praxisui/table',
     configSchemaId: 'TableConfig',
-    manifestVersion: '2.2.2',
+    manifestVersion: '2.2.3',
     runtimeInputs: [
         { name: 'config', type: 'TableConfig', description: 'Configuração completa da tabela' },
         { name: 'data', type: 'any[]', description: 'Dados a serem exibidos (modo client-side)' },
@@ -61552,6 +61784,7 @@ const PRAXIS_TABLE_AUTHORING_MANIFEST = {
     ],
     editableTargets: [
         { kind: 'column', resolver: 'column-by-field', description: 'Colunas base da tabela' },
+        { kind: 'columnProjection', resolver: 'schema-column-projection', description: 'Projecao de colunas derivada do schema com overrides editoriais' },
         { kind: 'computedColumn', resolver: 'column-by-field', description: 'Colunas calculadas' },
         { kind: 'renderer', resolver: 'renderer-in-column', description: 'Renderizador de célula' },
         { kind: 'conditionalRenderer', resolver: 'conditional-renderer-in-column', description: 'Renderizadores condicionais' },
@@ -61586,6 +61819,54 @@ const PRAXIS_TABLE_AUTHORING_MANIFEST = {
     ],
     operations: [
         // --- COLUMN OPERATIONS ---
+        {
+            operationId: 'column.projection.configure',
+            title: 'Usar colunas governadas pelo schema',
+            description: 'Mantem /schemas/filtered como fonte estrutural das colunas e registra somente diferencas editoriais por nome canonico de campo. Nao use para inventar campos ou contornar metadata ausente.',
+            scope: 'global',
+            targetKind: 'columnProjection',
+            target: { kind: 'columnProjection', resolver: 'schema-column-projection', ambiguityPolicy: 'fail', required: false },
+            inputSchema: {
+                type: 'object',
+                required: ['source'],
+                additionalProperties: false,
+                properties: {
+                    source: { const: 'schema' },
+                    include: {
+                        type: 'array',
+                        uniqueItems: true,
+                        items: { type: 'string', minLength: 1 },
+                        description: 'Allowlist ordenada de campos canonicos. Recomendada para dados sensiveis ou quando a pagina precisa de uma projecao focada.',
+                    },
+                    overrides: {
+                        type: 'object',
+                        description: 'Mapa indexado pelo nome canonico do campo. O objeto de override nao pode conter field.',
+                        additionalProperties: {
+                            type: 'object',
+                            not: { required: ['field'] },
+                        },
+                    },
+                    additions: {
+                        type: 'array',
+                        description: 'Colunas editoriais sem correspondente no schema, normalmente derivadas pelo round-trip de colunas computadas. Uma adicao nunca substitui um campo canonico.',
+                        items: {
+                            type: 'object',
+                            required: ['field'],
+                            properties: {
+                                field: { type: 'string', minLength: 1 },
+                                header: { type: ['string', 'object'] },
+                                type: { enum: COLUMN_TYPES },
+                            },
+                        },
+                    },
+                },
+            },
+            effects: [{ kind: 'set-value', path: 'columnProjection' }],
+            validators: ['schema-column-override-field-immutable', 'editor-round-trip-preserve'],
+            affectedPaths: ['columnProjection'],
+            submissionImpact: 'affects-schema-backed-data',
+            preconditions: ['config-initialized'],
+        },
         {
             operationId: 'column.add',
             title: 'Adicionar coluna',
@@ -63187,6 +63468,12 @@ const PRAXIS_TABLE_AUTHORING_MANIFEST = {
             level: 'error',
             code: 'TB019',
             description: 'Operacoes runtime devem usar operationId e input declarados em tableRuntimeOperations sem alterar a configuracao persistida.'
+        },
+        {
+            validatorId: 'schema-column-override-field-immutable',
+            level: 'error',
+            code: 'TB024',
+            description: 'Overrides de projecao podem alterar apresentacao e comportamento, mas nunca a identidade canonica field.'
         }
     ],
     roundTripRequirements: [

package/fesm2022/{praxisui-table-table-agentic-authoring-turn-flow-DsM7fuli.mjs → praxisui-table-table-agentic-authoring-turn-flow-Cz_xmaGA.mjs}

@@ -1,6 +1,6 @@
 import { Observable, firstValueFrom } from 'rxjs';
 import { withAuthoringScopePolicy } from '@praxisui/ai';
-import { ad as setTableActionGlobalActionRef } from './praxisui-table-praxisui-table-CUH7vNfu.mjs';
+import { ad as setTableActionGlobalActionRef } from './praxisui-table-praxisui-table-Cf63AwZs.mjs';
 
 class TableAgenticAuthoringTurnFlow {
     adapter;

package/fesm2022/{praxisui-table-table-ai.adapter-B3JduSXn.mjs → praxisui-table-table-ai.adapter-iUYC2oD5.mjs}

@@ -1,7 +1,7 @@
 import { firstValueFrom } from 'rxjs';
 import { BaseAiAdapter, sanitizePraxisAssistantText, createComponentAuthoringContext } from '@praxisui/ai';
 import { PRAXIS_GLOBAL_ACTION_CATALOG, deepMerge } from '@praxisui/core';
-import { I as TABLE_COMPONENT_EDIT_PLAN_OPERATION_IDS, l as PRAXIS_TABLE_AUTHORING_MANIFEST, T as TABLE_AI_CAPABILITIES, Z as coerceTableComponentEditPlans, $ as compileTableComponentEditPlans, L as TASK_PRESETS, a4 as getTableComponentEditPlanCapabilities, E as TABLE_COMPONENT_EDIT_PLAN_EXPECTED_PATHS, y as TABLE_COMPONENT_EDIT_PLAN_ALLOWED_CHANGE_KINDS, G as TABLE_COMPONENT_EDIT_PLAN_JSON_SCHEMA, K as TABLE_COMPONENT_EDIT_PLAN_VERSION, z as TABLE_COMPONENT_EDIT_PLAN_BATCH_KIND, H as TABLE_COMPONENT_EDIT_PLAN_KIND } from './praxisui-table-praxisui-table-CUH7vNfu.mjs';
+import { I as TABLE_COMPONENT_EDIT_PLAN_OPERATION_IDS, l as PRAXIS_TABLE_AUTHORING_MANIFEST, T as TABLE_AI_CAPABILITIES, Z as coerceTableComponentEditPlans, $ as compileTableComponentEditPlans, L as TASK_PRESETS, a4 as getTableComponentEditPlanCapabilities, E as TABLE_COMPONENT_EDIT_PLAN_EXPECTED_PATHS, y as TABLE_COMPONENT_EDIT_PLAN_ALLOWED_CHANGE_KINDS, G as TABLE_COMPONENT_EDIT_PLAN_JSON_SCHEMA, K as TABLE_COMPONENT_EDIT_PLAN_VERSION, z as TABLE_COMPONENT_EDIT_PLAN_BATCH_KIND, H as TABLE_COMPONENT_EDIT_PLAN_KIND } from './praxisui-table-praxisui-table-Cf63AwZs.mjs';
 
 const TABLE_ROW_EXPRESSION_CONTEXT_OPTION = {
     mode: 'expression',

package/fesm2022/praxisui-table.mjs

@@ -1 +1 @@
-export { A as ANALYTICS_TABLE_ROW_KEY_FIELD, a as AnalyticsTableConfigAdapterService, b as AnalyticsTableContractService, c as AnalyticsTableStatsApiService, B as BOOLEAN_PRESETS, d as BehaviorConfigEditorComponent, C as CURRENCY_PRESETS, e as ColumnsConfigEditorComponent, D as DATE_PRESETS, f as DataFormatterComponent, g as DataFormattingService, F as FORMULA_TEMPLATES, h as FilterConfigService, i as FilterSettingsComponent, j as FormulaGeneratorService, J as JsonConfigEditorComponent, M as MessagesLocalizationEditorComponent, N as NUMBER_PRESETS, P as PERCENTAGE_PRESETS, k as PRAXIS_FILTER_COMPONENT_METADATA, l as PRAXIS_TABLE_AUTHORING_MANIFEST, m as PRAXIS_TABLE_COMPONENT_METADATA, n as PRAXIS_TABLE_TOOLBAR_APPEARANCE_PRESETS, o as PRAXIS_TABLE_TOOLBAR_DEFAULT_APPEARANCE, p as PRAXIS_TABLE_TOOLBAR_TOKEN_PRESETS, q as PraxisFilter, r as PraxisFilterWidgetConfigEditor, s as PraxisTable, t as PraxisTableConfigEditor, u as PraxisTableInlineAuthoringEditorComponent, v as PraxisTableToolbar, w as PraxisTableWidgetConfigEditor, S as STRING_PRESETS, T as TABLE_AI_CAPABILITIES, x as TABLE_COMPONENT_AI_CAPABILITIES, y as TABLE_COMPONENT_EDIT_PLAN_ALLOWED_CHANGE_KINDS, z as TABLE_COMPONENT_EDIT_PLAN_BATCH_KIND, E as TABLE_COMPONENT_EDIT_PLAN_EXPECTED_PATHS, G as TABLE_COMPONENT_EDIT_PLAN_JSON_SCHEMA, H as TABLE_COMPONENT_EDIT_PLAN_KIND, K as TABLE_COMPONENT_EDIT_PLAN_VERSION, L as TASK_PRESETS, O as TableDefaultsProvider, Q as TableRulesEditorComponent, R as ToolbarActionsEditorComponent, V as ValueMappingEditorComponent, U as VisualFormulaBuilderComponent, W as analyticsComparisonMetricField, X as buildTableApplyPlan, Y as coerceTableComponentEditPlan, Z as coerceTableComponentEditPlans, _ as compileTableComponentEditPlan, $ as compileTableComponentEditPlans, a0 as createTableAuthoringDocument, a1 as getActionId, a2 as getEnum, a3 as getTableCapabilities, a4 as getTableComponentEditPlanCapabilities, a5 as isTableRendererSupportedByRichContentP0, a6 as mapTableRendererToRichContentP0, a7 as normalizeTableAuthoringDocument, a8 as parseLegacyOrTableDocument, a9 as providePraxisFilterMetadata, aa as providePraxisTableMetadata, ab as providePraxisTableToolbarAppearance, ac as serializeTableAuthoringDocument, ae as toCanonicalTableConfig, af as validateTableAuthoringDocument } from './praxisui-table-praxisui-table-CUH7vNfu.mjs';
+export { A as ANALYTICS_TABLE_ROW_KEY_FIELD, a as AnalyticsTableConfigAdapterService, b as AnalyticsTableContractService, c as AnalyticsTableStatsApiService, B as BOOLEAN_PRESETS, d as BehaviorConfigEditorComponent, C as CURRENCY_PRESETS, e as ColumnsConfigEditorComponent, D as DATE_PRESETS, f as DataFormatterComponent, g as DataFormattingService, F as FORMULA_TEMPLATES, h as FilterConfigService, i as FilterSettingsComponent, j as FormulaGeneratorService, J as JsonConfigEditorComponent, M as MessagesLocalizationEditorComponent, N as NUMBER_PRESETS, P as PERCENTAGE_PRESETS, k as PRAXIS_FILTER_COMPONENT_METADATA, l as PRAXIS_TABLE_AUTHORING_MANIFEST, m as PRAXIS_TABLE_COMPONENT_METADATA, n as PRAXIS_TABLE_TOOLBAR_APPEARANCE_PRESETS, o as PRAXIS_TABLE_TOOLBAR_DEFAULT_APPEARANCE, p as PRAXIS_TABLE_TOOLBAR_TOKEN_PRESETS, q as PraxisFilter, r as PraxisFilterWidgetConfigEditor, s as PraxisTable, t as PraxisTableConfigEditor, u as PraxisTableInlineAuthoringEditorComponent, v as PraxisTableToolbar, w as PraxisTableWidgetConfigEditor, S as STRING_PRESETS, T as TABLE_AI_CAPABILITIES, x as TABLE_COMPONENT_AI_CAPABILITIES, y as TABLE_COMPONENT_EDIT_PLAN_ALLOWED_CHANGE_KINDS, z as TABLE_COMPONENT_EDIT_PLAN_BATCH_KIND, E as TABLE_COMPONENT_EDIT_PLAN_EXPECTED_PATHS, G as TABLE_COMPONENT_EDIT_PLAN_JSON_SCHEMA, H as TABLE_COMPONENT_EDIT_PLAN_KIND, K as TABLE_COMPONENT_EDIT_PLAN_VERSION, L as TASK_PRESETS, O as TableDefaultsProvider, Q as TableRulesEditorComponent, R as ToolbarActionsEditorComponent, V as ValueMappingEditorComponent, U as VisualFormulaBuilderComponent, W as analyticsComparisonMetricField, X as buildTableApplyPlan, Y as coerceTableComponentEditPlan, Z as coerceTableComponentEditPlans, _ as compileTableComponentEditPlan, $ as compileTableComponentEditPlans, a0 as createTableAuthoringDocument, a1 as getActionId, a2 as getEnum, a3 as getTableCapabilities, a4 as getTableComponentEditPlanCapabilities, a5 as isTableRendererSupportedByRichContentP0, a6 as mapTableRendererToRichContentP0, a7 as normalizeTableAuthoringDocument, a8 as parseLegacyOrTableDocument, a9 as providePraxisFilterMetadata, aa as providePraxisTableMetadata, ab as providePraxisTableToolbarAppearance, ac as serializeTableAuthoringDocument, ae as toCanonicalTableConfig, af as validateTableAuthoringDocument } from './praxisui-table-praxisui-table-Cf63AwZs.mjs';

package/package.json

@@ -1,24 +1,24 @@
 {
   "name": "@praxisui/table",
-  "version": "9.0.4-rc.48",
+  "version": "9.0.4-rc.49",
   "description": "Advanced data table for Angular (Praxis UI) with editing, filtering, sorting, virtualization, and settings panel integration.",
   "peerDependencies": {
     "@angular/common": "^21.0.0",
     "@angular/core": "^21.0.0",
     "@angular/platform-browser": "^21.0.0",
-    "@praxisui/ai": "^9.0.4-rc.48",
-    "@praxisui/core": "^9.0.4-rc.48",
-    "@praxisui/dynamic-fields": "^9.0.4-rc.48",
-    "@praxisui/dynamic-form": "^9.0.4-rc.48",
-    "@praxisui/metadata-editor": "^9.0.4-rc.48",
-    "@praxisui/rich-content": "^9.0.4-rc.48",
-    "@praxisui/settings-panel": "^9.0.4-rc.48",
-    "@praxisui/table-rule-builder": "^9.0.4-rc.48",
+    "@praxisui/ai": "^9.0.4-rc.49",
+    "@praxisui/core": "^9.0.4-rc.49",
+    "@praxisui/dynamic-fields": "^9.0.4-rc.49",
+    "@praxisui/dynamic-form": "^9.0.4-rc.49",
+    "@praxisui/metadata-editor": "^9.0.4-rc.49",
+    "@praxisui/rich-content": "^9.0.4-rc.49",
+    "@praxisui/settings-panel": "^9.0.4-rc.49",
+    "@praxisui/table-rule-builder": "^9.0.4-rc.49",
     "@angular/cdk": "^21.0.0",
     "@angular/forms": "^21.0.0",
     "@angular/material": "^21.0.0",
     "@angular/router": "^21.0.0",
-    "@praxisui/dialog": "^9.0.4-rc.48",
+    "@praxisui/dialog": "^9.0.4-rc.49",
     "rxjs": "~7.8.0"
   },
   "dependencies": {

package/src/lib/praxis-table.json-api.md

@@ -914,10 +914,50 @@ Antes de plugar a tabela em uma aplicação, valide estes pontos:
 ### Top-level contract
 
 O contrato principal e `TableConfig` (alias de `TableConfigV2`) com extensoes de runtime aceitas no JSON:
-- Base tipada: `meta`, `columns`, `behavior`, `appearance`, `toolbar`, `actions`, `export`, `messages`, `localization`.
+- Base tipada: `meta`, `columns`, `columnProjection`, `behavior`, `appearance`, `toolbar`, `actions`, `export`, `messages`, `localization`.
 - Extensoes fora do tipo estrito: `dialogs.confirm.delete`, `rowConditionalRenderers[]`, aliases legados de `behavior.virtualScroll.*` e chaves legadas de header em `actions.row.*`.
 - Artefatos auxiliares fora do `TableConfig`: `crud-overrides:<componentKeyId>` e o envelope autorado `TableAuthoringDocument`, que carrega `bindings.resourcePath` e `bindings.horizontalScroll`. A chave operacional da linha pertence ao `TableConfig` em `config.meta.idField`.
 
+#### Projeção governada de colunas
+
+Quando `columnProjection.source = "schema"`, a lista estrutural de colunas é
+materializada a partir de `/schemas/filtered`; a página declara apenas diferenças
+em `columnProjection.overrides`, indexadas pelo nome canônico do campo:
+
+```json
+{
+  "columns": [],
+  "columnProjection": {
+    "source": "schema",
+    "include": ["competencia", "salarioBruto", "salarioLiquido"],
+    "overrides": {
+      "salarioLiquido": {
+        "sticky": "end",
+        "width": "160px"
+      }
+    }
+  }
+}
+```
+
+O runtime reaplica os overrides após bootstrap e atualização do schema. Uma chave
+desconhecida não cria coluna, e `field` não pode ser alterado pelo override. Este
+contrato não cria “defaults da surface” paralelos: tipo, visibilidade, ordem e
+apresentação continuam pertencendo ao schema canônico; a página conserva apenas
+as decisões editoriais específicas da experiência.
+
+Durante a renderização, `columns` contém a materialização completa somente em
+memória. Ao salvar, aplicar ou emitir `configChange`, o runtime compacta essa
+materialização novamente: a ordem e os campos canônicos formam `include`, as
+diferenças formam `overrides` e colunas computadas/client-owned sem equivalente
+no schema formam `additions`. Uma `addition` cujo `field` colida com o schema é
+ignorada; ela não pode sombrear a identidade canônica.
+
+`include` é uma allowlist ordenada. Em recursos financeiros, pessoais ou
+regulados, ela deve ser preferida para impedir que um novo campo do schema passe
+a integrar a experiência sem decisão editorial explícita. A ausência de
+`include` significa “todos os campos que o backend marcou como visíveis”.
+
 ### Coverage matrix
 
 Resumo de cobertura por bloco:

package/types/praxisui-table.d.ts

@@ -1368,6 +1368,7 @@ declare class PraxisTable implements OnInit, OnChanges, AfterViewInit, AfterCont
     private readonly paginatorIntl;
     private readonly schemaNormalizer;
     private schemaFieldsSnapshot;
+    private schemaColumnFieldsSnapshot;
     private filterSchemaFieldsSnapshot;
     private runtimeSchemaMeta;
     schemaError: boolean;
@@ -2129,6 +2130,23 @@ declare class PraxisTable implements OnInit, OnChanges, AfterViewInit, AfterCont
     private loadOrVerifyRemoteSchema;
     private loadFilterSchemaSnapshot;
     private convertFieldToColumn;
+    private usesSchemaColumnProjection;
+    /**
+     * Materializa a projeção efetiva sem promover o JSON da página a fonte de
+     * verdade estrutural. Overrides desconhecidos não criam colunas e `field`
+     * nunca pode ser substituído pelo consumidor.
+     */
+    private projectSchemaColumns;
+    /**
+     * Converte a configuração materializada usada pelo renderer de volta ao
+     * contrato compacto e persistível. O schema continua sendo a fonte
+     * estrutural; somente ordem/allowlist, diferenças editoriais e colunas sem
+     * correspondente canônico são serializadas.
+     */
+    private toPortableTableConfig;
+    private diffPortableColumnDefinition;
+    private toPortableColumnDefinition;
+    private arePortableValuesEqual;
     private applySchemaFieldPresentationsToExistingColumns;
     private applySchemaFieldPresentation;
     private applySchemaSemanticCellPresentation;
@@ -4380,7 +4398,7 @@ declare function serializeTableAuthoringDocument(doc: TableAuthoringDocument): u
  * Manifesto de authoring canônico para o componente praxis-table.
  * Este arquivo define o contrato executável para que agentes de IA editem tabelas.
  *
- * @version 2.2.2
+ * @version 2.2.3
  * @status COMPLIANT - Alinhado com o contrato v2 e TableConfig canônico.
  */
 declare const PRAXIS_TABLE_AUTHORING_MANIFEST: ComponentAuthoringManifest;