@praxisui/table 10.0.0-rc.36 → 10.0.0-rc.38

package/docs/governed-page-widget-adapter.md

@@ -0,0 +1,55 @@
+# Table em páginas governadas
+
+O adapter do owner mantém `definition.inputs.config` como a única fonte de configuração do filho.
+A página guarda autoria; o documento nativo é reconstruído a partir desses inputs. A projeção de
+execução é transitória e nunca deve ser gravada de volta no documento da página.
+
+O perfil inicial vem do contrato P0 `page-publication-p0` de `praxis-config-starter` (PR #506).
+Core valida estrutura, referências, limites e exige validators dos owners. Este adapter valida o
+perfil nativo local; não autoriza uma fonte, registra uma seed ou substitui a admissão no servidor.
+
+`decodeTablePageInputs` reconstrói `praxis.table.editor` v1 com config e somente os bindings
+presentes (`resourcePath`, `horizontalScroll`). `resourcePath: null` é desconexão explícita;
+ausência não é desconexão. Config precisa ser autoria compacta: `columns: []` e
+`columnProjection.source: 'schema'`. Null em qualquer nível de config é negado.
+
+`encodeTablePageInputs` é a projeção inversa sem defaults. Campos fora do perfil,
+blocos vazios sem representação nos inputs, identidade/storage e dados de execução recebem
+diagnóstico. O adapter não filtra silenciosamente autoria incompatível.
+
+`projectTablePageEditorChanges(authoredInputs, editorBaseline, editorValue)` aplica apenas
+deltas explícitos sobre a autoria original usando o reconciliador nativo do owner. Capture o
+baseline após a normalização/montagem do editor e preserve-o durante aquela sessão. Alterar
+bindings ou contexto do mesmo widget retorna `seed.replacement-required`; a página precisa
+substituir o widget com nova key e nova fonte admitida. A API de projeção altera somente o draft
+que o chamador recebe; ela não salva preferências nem persiste a página.
+
+`materializeTablePageRuntimeInputs(inputs, pageId, widgetKey)` usa o helper canônico Core para
+identidades `page:<pageId>:widget:<widgetKey>`, projeta `configPersistenceStrategy: 'volatile'`
+e desabilita customização/copiloto independentes no filho. Submit e dados continuam nos contratos
+de domínio existentes. Não existe input runtime `authoringDocument`.
+
+A estratégia `volatile` impede leitura, gravação e limpeza de preferências próprias e conexão
+persistida. Table também repassa o `disablePersistence` existente ao filtro embutido e impede
+reset por chave do filtro; largura, densidade e outros ajustes não escrevem preferências.
+Defaults visuais/materializações transitórias permanecem internos ao runtime e ao editor.
+
+Limites: JSON lossless, 256 KiB UTF-8 e profundidade 64 pelo helper Core compartilhado; o documento
+integral da página também tem o mesmo orçamento. Não há host publicado, endpoint de publicação,
+fonte admitida, banco ou release novos neste incremento. A integração Page Builder/host governado
+é trabalho posterior; os wrappers comuns continuam atendendo os fluxos não governados existentes.
+
+`volatile` também exclui overlays pessoais de configuração global nos defaults/estado de autoria
+que o owner consome. A instância compartilhada `GlobalConfigService` pode ler sua chave global;
+isso não é prova de zero leitura na aplicação. Tenant, cache, locale e CSP continuam infraestrutura
+do host. O gate comprova ausência de I/O nas chaves do filho e ausência de influência da autoria
+pessoal sobre a configuração publicada. Em Table, `TableDefaultsProvider.getDefaults(id,
+{ includeGlobal: false })` preserva defaults nativos sem duplicá-los; mudanças globais e reset
+seguem a mesma política, inclusive o fallback de timezone usado em regras JSON Logic.
+
+Native Table diagnostics historically use dot paths without escaping dynamic override field names.
+For those diagnostics, the page adapter deliberately points to the exact `columnProjection.overrides`
+ancestor rather than inventing a JSON Pointer by splitting a field such as `a.b` or `a[0]`.
+The diagnostic code still names the rejected native constraint.
+
+Respostas e filas de preferências capturam a geração, a identidade e a estratégia do filho. Trocar identidade, documento ou estratégia (inclusive A → volatile → A), ou destruir a instância, invalida a continuação antiga antes do próximo I/O ou da materialização. Uma requisição já enviada não é cancelada retroativamente. Respostas tardias de erro também passam pelo mesmo fence.

package/fesm2022/praxisui-table-authoring.mjs

@@ -1,5 +1,6 @@
 import { validateRichContentDocument, isSafeRichContentClassName } from '@praxisui/rich-content';
 import { resolveColumnTypeFromFieldDefinition, deepMerge, isPraxisPresentationVisualizationTableSafe, resolveTextMaskFormatFromFieldDefinition } from '@praxisui/core/schema';
+import { uiLayoutJsonIdentity, cloneBoundedUiLayoutJsonDocument, derivePageChildRuntimeId } from '@praxisui/core';
 
 const ORIGIN = '__praxisAuthoredDisabled';
 const hasOwn = (value, key) => Object.prototype.hasOwnProperty.call(value, key);
@@ -32,18 +33,28 @@ function identity(action) {
 }
 /** Projects only canonical action slots, never arbitrary business payloads or callback values. */
 function projectTableActionAuthoring(config, authored, report) {
+    const hasAuthoredBaseline = authored !== undefined && authored !== null;
     function actions(value, original, path) {
         if (!Array.isArray(value))
             return value;
         const originals = Array.isArray(original) ? original.filter(isAction) : [];
-        return value.map((item, index) => {
-            if (!isAction(item))
-                return item;
+        const projected = [];
+        value.forEach((item, index) => {
+            if (!isAction(item)) {
+                projected.push(item);
+                return;
+            }
             const key = identity(item);
             const matches = key ? originals.filter(candidate => identity(candidate) === key) : [];
             // No label matching, positional matching or guessing across duplicate identities.
             const source = matches.length === 1 && value.filter(candidate => isAction(candidate) && identity(candidate) === key).length === 1
                 ? matches[0] : undefined;
+            const isRuntimeSynthesizedOnly = Boolean(item['__praxisDiscoveredAction']) ||
+                Boolean(item['__praxisBulkSyncAction']) ||
+                (hasAuthoredBaseline && Boolean(item['__praxisCollectionCreateAction']));
+            if (isRuntimeSynthesizedOnly && !source) {
+                return;
+            }
             const result = { ...item };
             if (hasRuntimeState(item)) {
                 const origin = source && !hasRuntimeState(source) ? authoredDisabled(source) : authoredDisabled(item);
@@ -63,8 +74,9 @@ function projectTableActionAuthoring(config, authored, report) {
             }
             if (hasOwn(item, 'children'))
                 result['children'] = actions(item['children'], source?.['children'], `${path}[${index}].children`);
-            return result;
+            projected.push(result);
         });
+        return projected;
     }
     const result = { ...config };
     if (config?.toolbar)
@@ -1241,69 +1253,113 @@ class TableSchemaColumnProjector {
     }
     inferFieldTypeFromFieldName(fieldName) {
         const lowercaseName = fieldName.toLowerCase();
-        // Date/time patterns - more specific patterns first
+        // Date/time patterns - more specific patterns first (EN + PT-BR)
         if (lowercaseName.endsWith('date') ||
             lowercaseName.endsWith('time') ||
             lowercaseName.endsWith('at') ||
             lowercaseName.startsWith('date') ||
+            lowercaseName.startsWith('data') ||
+            lowercaseName.startsWith('dt_') ||
+            lowercaseName.startsWith('dt') ||
+            lowercaseName.endsWith('_em') ||
             lowercaseName === 'created' ||
             lowercaseName === 'updated' ||
             lowercaseName === 'modified' ||
+            lowercaseName === 'nascimento' ||
+            lowercaseName === 'admissao' ||
+            lowercaseName === 'demissao' ||
+            lowercaseName === 'vencimento' ||
             lowercaseName.includes('timestamp')) {
             return 'date';
         }
-        // Boolean patterns - most specific first to avoid conflicts
+        // Boolean patterns - most specific first to avoid conflicts (EN + PT-BR)
         if (lowercaseName.startsWith('is_') ||
             lowercaseName.startsWith('has_') ||
             lowercaseName.startsWith('can_') ||
             lowercaseName.startsWith('should_') ||
+            lowercaseName.startsWith('fl_') ||
+            lowercaseName.startsWith('ind_') ||
             lowercaseName === 'active' ||
+            lowercaseName === 'ativo' ||
+            lowercaseName === 'inativo' ||
             lowercaseName === 'enabled' ||
+            lowercaseName === 'habilitado' ||
             lowercaseName === 'visible' ||
+            lowercaseName === 'visivel' ||
             lowercaseName === 'deleted' ||
+            lowercaseName === 'excluido' ||
             lowercaseName === 'archived' ||
+            lowercaseName === 'arquivado' ||
             lowercaseName.endsWith('_flag') ||
             lowercaseName.endsWith('_enabled') ||
-            lowercaseName.endsWith('_active')) {
+            lowercaseName.endsWith('_active') ||
+            lowercaseName.endsWith('_ativo')) {
             return 'boolean';
         }
-        // Currency/money patterns - exclude common false positives
+        // Currency/money patterns - exclude common false positives (EN + PT-BR)
         if ((lowercaseName.includes('price') ||
+            lowercaseName.includes('preco') ||
             lowercaseName.includes('amount') ||
             lowercaseName.includes('cost') ||
+            lowercaseName.includes('custo') ||
             lowercaseName.includes('salary') ||
+            lowercaseName.includes('salario') ||
+            lowercaseName.includes('remuneracao') ||
+            lowercaseName.includes('orcamento') ||
+            lowercaseName.includes('indenizacao') ||
+            lowercaseName.includes('multa') ||
+            lowercaseName.includes('desconto') ||
+            lowercaseName.includes('liquido') ||
+            lowercaseName.includes('bruto') ||
             lowercaseName.includes('wage') ||
             lowercaseName.includes('fee') ||
-            (lowercaseName.includes('value') &&
+            ((lowercaseName.includes('value') || lowercaseName.includes('valor') || lowercaseName.startsWith('vl_')) &&
                 !lowercaseName.includes('id') &&
                 !lowercaseName.includes('key'))) &&
             !lowercaseName.includes('count') &&
-            !lowercaseName.includes('type')) {
+            !lowercaseName.includes('type') &&
+            !lowercaseName.includes('tipo')) {
             return 'currency';
         }
-        // Percentage patterns - be more specific
+        // Percentage patterns - be more specific (EN + PT-BR)
         if (lowercaseName.includes('percent') ||
+            lowercaseName.includes('percentual') ||
+            lowercaseName.includes('aliquota') ||
+            lowercaseName.includes('margem') ||
+            lowercaseName.startsWith('pct_') ||
             lowercaseName.endsWith('_rate') ||
             lowercaseName.endsWith('_ratio') ||
             lowercaseName.endsWith('_pct') ||
-            (lowercaseName.includes('rate') &&
+            lowercaseName.endsWith('_taxa') ||
+            ((lowercaseName.includes('rate') || lowercaseName.includes('taxa')) &&
                 !lowercaseName.includes('created') &&
                 !lowercaseName.includes('updated')) ||
             lowercaseName.endsWith('_score')) {
             return 'percentage';
         }
-        // Number patterns - exclude common false positives like string IDs
+        // Number patterns - exclude common false positives like string IDs (EN + PT-BR)
         if ((lowercaseName.endsWith('_id') && lowercaseName !== 'id') || // composite IDs might be strings
             lowercaseName === 'id' ||
             lowercaseName.includes('count') ||
             lowercaseName.includes('quantity') ||
+            lowercaseName.includes('quantidade') ||
+            lowercaseName.includes('qtd') ||
             lowercaseName.includes('number') ||
+            lowercaseName.includes('numero') ||
             lowercaseName.includes('total') ||
             lowercaseName.includes('sum') ||
+            lowercaseName.includes('soma') ||
             lowercaseName.includes('age') ||
+            lowercaseName.includes('idade') ||
             lowercaseName.includes('weight') ||
+            lowercaseName.includes('peso') ||
             lowercaseName.includes('height') ||
+            lowercaseName.includes('altura') ||
             lowercaseName.includes('size') ||
+            lowercaseName.includes('tamanho') ||
+            lowercaseName.includes('pontuacao') ||
+            lowercaseName.includes('score') ||
+            lowercaseName.includes('nota') ||
             lowercaseName.endsWith('_num') ||
             lowercaseName.endsWith('_number')) {
             return 'number';
@@ -1319,12 +1375,13 @@ class TableSchemaColumnProjector {
         const valuePresentationType = this.normalizePresentationToken(field.valuePresentation?.type);
         const displayFormat = this.firstNonEmptyString(field.displayFormat, field.extraProperties?.displayFormat);
         const valueMapping = this.resolveSchemaValueMapping(field);
-        if (valueMapping) {
+        if (valueMapping && (!col.valueMapping || Object.keys(col.valueMapping).length === 0)) {
             col.valueMapping = valueMapping;
         }
         const presentation = field.presentation;
         if (presentation?.presenter === 'microVisualization' &&
-            isPraxisPresentationVisualizationTableSafe(presentation?.visualization)) {
+            isPraxisPresentationVisualizationTableSafe(presentation?.visualization) &&
+            !col.renderer?.type) {
             col.renderer = {
                 ...(col.renderer || {}),
                 type: 'microVisualization',
@@ -1335,8 +1392,11 @@ class TableSchemaColumnProjector {
         }
         this.applySchemaSemanticCellPresentation(field, col, presentation);
         if (numericFormat === 'currency' || controlType === 'currency' || col.type === 'currency') {
+            const wasCurrency = col.type === 'currency';
             col.type = 'currency';
-            col.format = this.resolveSchemaCurrencyFormat(field);
+            if (!col.format || (!wasCurrency && !String(col.format).includes('|'))) {
+                col.format = this.resolveSchemaCurrencyFormat(field);
+            }
             return;
         }
         if (numericFormat === 'date' ||
@@ -1349,13 +1409,15 @@ class TableSchemaColumnProjector {
             controlType === 'date' ||
             controlType === 'datetime') {
             col.type = 'date';
-            col.format = displayFormat || (numericFormat === 'datetime' ||
-                valuePresentationType === 'datetime' ||
-                controlType === 'datetimepicker' ||
-                controlType === 'datetimelocal' ||
-                controlType === 'datetime'
-                ? 'dd/MM/yyyy HH:mm'
-                : 'dd/MM/yyyy');
+            if (!col.format) {
+                col.format = displayFormat || (numericFormat === 'datetime' ||
+                    valuePresentationType === 'datetime' ||
+                    controlType === 'datetimepicker' ||
+                    controlType === 'datetimelocal' ||
+                    controlType === 'datetime'
+                    ? 'dd/MM/yyyy HH:mm'
+                    : 'dd/MM/yyyy');
+            }
             return;
         }
         if (col.type === 'boolean' && !col.format) {
@@ -1364,7 +1426,10 @@ class TableSchemaColumnProjector {
         const schemaDataType = this.normalizePresentationToken(field.type);
         const schemaFormat = this.normalizePresentationToken(field.format);
         if (col.type === 'number' && !col.format) {
-            if (schemaDataType === 'integer' ||
+            if (displayFormat) {
+                col.format = displayFormat;
+            }
+            else if (schemaDataType === 'integer' ||
                 schemaFormat === 'integer' ||
                 schemaFormat === 'int32' ||
                 schemaFormat === 'int64' ||
@@ -1408,10 +1473,12 @@ class TableSchemaColumnProjector {
                     size: 32,
                 },
             };
-            // Sensible defaults for avatar column
+            // Sensible defaults for avatar column (84px prevents header truncation when centered with sort/resize gutters; not sortable by default)
             col.align = col.align || 'center';
+            if (col.sortable === undefined)
+                col.sortable = false;
             if (!col.width)
-                col.width = '56px';
+                col.width = '84px';
             return;
         }
     }
@@ -1726,8 +1793,323 @@ function deriveTableEditorDocument(input) {
     });
 }
 
+/** Shared presentation ordering; hidden columns must not shift visible fallback positions. */
+function orderTableColumns(columns) {
+    if (!columns.some(column => Number.isFinite(column.order)))
+        return [...columns];
+    let visibleIndex = 0;
+    return columns.map((column, originalIndex) => {
+        const fallback = column.visible === false ? originalIndex : visibleIndex++;
+        return { column, originalIndex, explicit: Number.isFinite(column.order), order: Number.isFinite(column.order) ? Number(column.order) : fallback };
+    }).sort((left, right) => left.order - right.order
+        || Number(right.explicit) - Number(left.explicit)
+        || left.originalIndex - right.originalIndex).map(entry => entry.column);
+}
+
+/** Preserve authored values; runtime/schema defaults remain transient unless explicitly edited. */
+function applyTableAuthoringChanges(authored, baseline, edited) {
+    return projectChanges(authored, baseline, edited, true);
+}
+function projectChanges(authored, baseline, edited, tableConfigRoot) {
+    if (sameAuthoringValue(baseline, edited))
+        return authored;
+    if (!edited || typeof edited !== 'object' || Array.isArray(edited))
+        return edited;
+    const original = authored && typeof authored === 'object' ? authored : {};
+    const before = baseline && typeof baseline === 'object' ? baseline : {};
+    const after = edited;
+    const result = { ...original };
+    for (const key of new Set([...Object.keys(before), ...Object.keys(after)])) {
+        if (sameAuthoringValue(before[key], after[key]))
+            continue;
+        if (!Object.hasOwn(after, key))
+            delete result[key];
+        else
+            Object.defineProperty(result, key, {
+                value: projectChanges(Object.hasOwn(original, key) ? original[key] : undefined, Object.hasOwn(before, key) ? before[key] : undefined, after[key], false),
+                enumerable: true, configurable: true, writable: true,
+            });
+    }
+    if (tableConfigRoot && isRecord(original['columnProjection']) && original['columnProjection']['source'] === 'schema'
+        && isRecord(result['columnProjection']) && result['columnProjection']['source'] === 'schema'
+        && Array.isArray(after['columns']) && JSON.stringify(before['columns']) !== JSON.stringify(after['columns'])) {
+        result['columns'] = [];
+        result['columnProjection'] = projectSchemaColumnChanges(result['columnProjection'], before['columns'], after['columns'], isRecord(before['columnProjection']) ? before['columnProjection'] : original['columnProjection'], after['columnProjection']);
+    }
+    return result;
+}
+/** Write the existing compact schema projection, never a partial columns snapshot. */
+function projectSchemaColumnChanges(authored, baseline, edited, baselineProjection, editedProjection) {
+    if (!isRecord(authored) || authored['source'] !== 'schema') {
+        throw new Error('Table schema authorship requires its canonical columnProjection.');
+    }
+    const projection = structuredClone(authored);
+    const overrides = Object.assign(Object.create(null), isRecord(projection['overrides']) ? projection['overrides'] : {});
+    const additions = columnsByField(Array.isArray(projection['additions']) ? projection['additions'] : []);
+    const before = columnsByField(Array.isArray(baseline) ? baseline : []);
+    const after = columnsByField(edited);
+    const nextAdditions = [...additions].filter(([field]) => !before.has(field) && !after.has(field))
+        .map(([, column]) => structuredClone(column));
+    for (const [field, column] of after) {
+        if (additions.has(field) || !before.has(field)) {
+            nextAdditions.push(structuredClone(column));
+            continue;
+        }
+        const previousOverride = isRecord(overrides[field]) ? overrides[field] : {};
+        if (Object.hasOwn(previousOverride, 'field')) {
+            throw new Error('Table schema overrides cannot replace canonical field identity.');
+        }
+        const projected = projectChanges({ field, ...previousOverride }, before.get(field), column, false);
+        const override = isRecord(projected) ? { ...projected } : {};
+        // A direct edit of native intent is stronger evidence than a rematerialized snapshot.
+        const baselineOverrides = isRecord(baselineProjection) && isRecord(baselineProjection['overrides'])
+            ? baselineProjection['overrides'] : {};
+        const editedOverrides = isRecord(editedProjection) && isRecord(editedProjection['overrides'])
+            ? editedProjection['overrides'] : {};
+        const oldIntent = isRecord(baselineOverrides[field]) ? baselineOverrides[field] : {};
+        const newIntent = isRecord(editedOverrides[field]) ? editedOverrides[field] : {};
+        if (isRecord(editedProjection)) {
+            for (const key of new Set([...Object.keys(oldIntent), ...Object.keys(newIntent)])) {
+                if (!changedNativeValue(oldIntent, newIntent, key))
+                    continue;
+                if (Object.hasOwn(previousOverride, key))
+                    override[key] = structuredClone(previousOverride[key]);
+                else
+                    delete override[key];
+            }
+        }
+        delete override['field'];
+        delete override['order']; // Ordering has a dedicated projection field.
+        if (Object.keys(override).length)
+            overrides[field] = override;
+        else
+            delete overrides[field];
+    }
+    // Missing fields do not erase their overrides; membership and intent are separate.
+    const previousOrder = orderedFields(before, additions);
+    const nextOrder = orderedFields(after, additions).filter(field => before.has(field));
+    if (!changedNativeValue(baselineProjection, editedProjection, 'include')
+        && previousOrder.some(field => !nextOrder.includes(field))) {
+        const include = Array.isArray(projection['include']) ? projection['include'] : [];
+        projection['include'] = [...nextOrder, ...include.filter(field => !before.has(field))];
+    }
+    if (!changedNativeValue(baselineProjection, editedProjection, 'order')
+        && JSON.stringify(previousOrder) !== JSON.stringify(nextOrder)) {
+        const order = Array.isArray(projection['order']) ? projection['order'] : [];
+        projection['order'] = [...nextOrder, ...order.filter(field => !before.has(field) && !nextOrder.includes(field))];
+    }
+    if (Object.keys(overrides).length)
+        projection['overrides'] = overrides;
+    else
+        delete projection['overrides'];
+    if (nextAdditions.length)
+        projection['additions'] = nextAdditions;
+    else
+        delete projection['additions'];
+    return projection;
+}
+function changedNativeValue(before, after, key) {
+    if (!isRecord(after))
+        return false;
+    const previous = isRecord(before) ? before : {};
+    return Object.hasOwn(previous, key) !== Object.hasOwn(after, key)
+        || !sameAuthoringValue(previous[key], after[key]);
+}
+function orderedFields(columns, additions) {
+    return orderTableColumns([...columns].map(([field, column]) => ({
+        field, order: typeof column['order'] === 'number' ? column['order'] : undefined,
+        visible: typeof column['visible'] === 'boolean' ? column['visible'] : undefined,
+    }))).map(column => column.field).filter(field => !additions.has(field));
+}
+function columnsByField(columns) {
+    const result = new Map();
+    for (const column of columns) {
+        if (!isRecord(column) || typeof column['field'] !== 'string' || !column['field'].trim()) {
+            throw new Error('Table authoring requires a non-empty column field identity.');
+        }
+        const identity = column['field'].trim();
+        if (result.has(identity))
+            throw new Error('Table authoring requires unique column field identities.');
+        result.set(identity, column);
+    }
+    return result;
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+/** Object insertion order is not authored intent; undefined is an internal absence sentinel. */
+function sameAuthoringValue(left, right) {
+    if (left === undefined || right === undefined)
+        return left === right;
+    try {
+        return uiLayoutJsonIdentity(left) === uiLayoutJsonIdentity(right);
+    }
+    catch {
+        if (Array.isArray(left) || Array.isArray(right))
+            return Array.isArray(left) && Array.isArray(right)
+                && left.length === right.length && left.every((value, index) => sameAuthoringValue(value, right[index]));
+        if (!isRecord(left) || !isRecord(right))
+            return left === right;
+        const keys = Object.keys(left).filter(key => left[key] !== undefined);
+        const otherKeys = Object.keys(right).filter(key => right[key] !== undefined);
+        return keys.length === otherKeys.length && keys.every(key => Object.prototype.hasOwnProperty.call(right, key)
+            && sameAuthoringValue(left[key], right[key]));
+    }
+}
+
+const BINDINGS = ['resourcePath', 'horizontalScroll'];
+const INPUTS = ['config', ...BINDINGS];
+/** Raw compact schema authorship only; native normalization remains an editor/runtime projection. */
+function decodeTablePageInputs(value) {
+    let inputs;
+    try {
+        inputs = cloneBoundedUiLayoutJsonDocument(value);
+    }
+    catch {
+        return { document: null, diagnostics: [problem('table.page.json.invalid', '/definition/inputs')] };
+    }
+    const diagnostics = [];
+    extras(inputs, INPUTS, '/definition/inputs', diagnostics);
+    const config = inputs['config'];
+    if (!record(config) || !Array.isArray(config['columns']) || config['columns'].length !== 0
+        || !record(config['columnProjection']) || config['columnProjection']['source'] !== 'schema')
+        diagnostics.push(problem('table.page.config.schema-required', '/definition/inputs/config'));
+    if (record(config))
+        nulls(config, '/definition/inputs/config', diagnostics);
+    if (Object.prototype.hasOwnProperty.call(inputs, 'resourcePath') && inputs['resourcePath'] !== null && (typeof inputs['resourcePath'] !== 'string' || [...inputs['resourcePath']].length > 1024))
+        diagnostics.push(problem('table.page.resourcePath.invalid', '/definition/inputs/resourcePath'));
+    if (Object.prototype.hasOwnProperty.call(inputs, 'horizontalScroll') && !['auto', 'wrap', 'none'].includes(inputs['horizontalScroll']))
+        diagnostics.push(problem('table.page.horizontalScroll.invalid', '/definition/inputs/horizontalScroll'));
+    const bindings = Object.fromEntries(BINDINGS.filter(key => Object.prototype.hasOwnProperty.call(inputs, key)).map(key => [key, inputs[key]]));
+    const document = { kind: 'praxis.table.editor', version: 1, config, ...(Object.keys(bindings).length ? { bindings } : {}) };
+    if (!diagnostics.length) {
+        try {
+            diagnostics.push(...validateTableAuthoringDocument(document).filter(d => d.level === 'error').map(d => ({ ...d, path: nativePath(d.path) })));
+        }
+        catch {
+            diagnostics.push(problem('table.page.native.invalid', '/definition/inputs/config'));
+        }
+    }
+    if (!diagnostics.length) {
+        try {
+            cloneBoundedUiLayoutJsonDocument(document);
+        }
+        catch {
+            diagnostics.push(problem('table.page.json.invalid', '/definition/inputs'));
+        }
+    }
+    return { document: diagnostics.length ? null : document, diagnostics };
+}
+/** Core prefixes these widget-relative JSON Pointers; this callback never resolves a source/latest. */
+function validateTablePageWidget(widget) {
+    if (widget.definition.id !== 'praxis-table')
+        return [{ code: 'table.page.component.invalid', path: '/definition/id' }];
+    return decodeTablePageInputs(widget.definition.inputs).diagnostics.map(d => ({ code: d.code, path: d.path ?? '/definition/inputs' }));
+}
+function encodeTablePageInputs(value) {
+    let document;
+    try {
+        document = cloneBoundedUiLayoutJsonDocument(value);
+    }
+    catch {
+        return { inputs: null, diagnostics: [problem('table.page.json.invalid', '/')] };
+    }
+    const diagnostics = [];
+    extras(document, ['kind', 'version', 'config', 'bindings'], '', diagnostics);
+    if (document['kind'] !== 'praxis.table.editor' || document['version'] !== 1)
+        diagnostics.push(problem('table.page.native.invalid', '/'));
+    const inputs = { config: document['config'] };
+    if (Object.prototype.hasOwnProperty.call(document, 'bindings')) {
+        const bindings = document['bindings'];
+        if (!record(bindings) || !Object.keys(bindings).length)
+            diagnostics.push(problem('table.page.envelope.unrepresentable', '/bindings'));
+        else {
+            extras(bindings, BINDINGS, '/bindings', diagnostics);
+            Object.assign(inputs, bindings);
+        }
+    }
+    const decoded = diagnostics.length ? null : decodeTablePageInputs(inputs);
+    return { inputs: diagnostics.length || decoded?.diagnostics.length ? null : inputs, diagnostics: [...diagnostics, ...(decoded?.diagnostics ?? [])] };
+}
+/** No-change values in a materialized native editor cannot author defaults or erase absent keys. */
+function projectTablePageEditorChanges(authoredInputs, editorBaseline, editorValue) {
+    const original = decodeTablePageInputs(authoredInputs);
+    if (!original.document)
+        return { inputs: null, diagnostics: original.diagnostics };
+    let baseline;
+    let edited;
+    try {
+        baseline = cloneBoundedUiLayoutJsonDocument(editorBaseline);
+        edited = cloneBoundedUiLayoutJsonDocument(editorValue);
+    }
+    catch {
+        return { inputs: null, diagnostics: [problem('table.page.json.invalid', '/')] };
+    }
+    const authored = original.document;
+    // Native config delta has schema-column projection semantics; envelope delta is plain JSON.
+    let candidate;
+    try {
+        candidate = applyTableAuthoringChanges(authored, baseline, edited);
+        candidate['config'] = applyTableAuthoringChanges(authored['config'], baseline['config'], edited['config']);
+    }
+    catch {
+        return { inputs: null, diagnostics: [problem('table.page.editor.invalid', '/definition/inputs/config')] };
+    }
+    const before = { ...authored };
+    const after = { ...candidate };
+    delete before['config'];
+    delete after['config'];
+    if (uiLayoutJsonIdentity(before) !== uiLayoutJsonIdentity(after))
+        return { inputs: null, diagnostics: [problem('table.page.seed.replacement-required', '/definition/inputs')] };
+    return encodeTablePageInputs(candidate);
+}
+function extras(source, allowed, path, diagnostics) {
+    for (const key of Object.keys(source))
+        if (!allowed.includes(key))
+            diagnostics.push(problem('table.page.profile.unsupported', path + '/' + pointer(key)));
+}
+function nulls(value, path, diagnostics) {
+    if (value === null)
+        diagnostics.push(problem('table.page.config.null', path));
+    else if (Array.isArray(value))
+        value.forEach((item, index) => nulls(item, path + '/' + index, diagnostics));
+    else if (record(value))
+        Object.entries(value).forEach(([key, item]) => nulls(item, path + '/' + pointer(key), diagnostics));
+}
+function pointer(key) { return key.replace(/~/g, '~0').replace(/\//g, '~1'); }
+function record(value) { return value !== null && typeof value === 'object' && !Array.isArray(value); }
+function problem(code, path) { return { level: 'error', code, path, message: code }; }
+/** Derive execution-only identity and disable independent preferences. Never persist this projection. */
+function materializeTablePageRuntimeInputs(value, pageId, widgetKey) {
+    const decoded = decodeTablePageInputs(value);
+    if (!decoded.document)
+        return { inputs: null, diagnostics: decoded.diagnostics };
+    let id;
+    try {
+        id = derivePageChildRuntimeId(pageId, widgetKey);
+    }
+    catch {
+        return { inputs: null, diagnostics: [problem('table.page.identity.invalid', '/key')] };
+    }
+    return {
+        inputs: { ...cloneBoundedUiLayoutJsonDocument(value), tableId: id, componentInstanceId: id,
+            configPersistenceStrategy: 'volatile', enableCustomization: false },
+        diagnostics: [],
+    };
+}
+function nativePath(value) {
+    // The native dot-path protocol does not escape dynamic field identities. Its
+    // overrides ancestor is precise; splitting that field would invent a pointer.
+    if (value?.startsWith('config.columnProjection.overrides.'))
+        return '/definition/inputs/config/columnProjection/overrides';
+    const parts = (value ?? 'config').replace(/\[(\d+)\]/g, '.$1').split('.');
+    if (parts[0] === 'bindings')
+        parts.shift();
+    return '/definition/inputs/' + parts.map(pointer).join('/');
+}
+
 /**
  * Generated bundle index. Do not edit.
  */
 
-export { buildTableApplyPlan, createTableAuthoringDocument, deriveTableEditorDocument, normalizeTableAuthoringDocument, parseLegacyOrTableDocument, serializeTableAuthoringDocument, toCanonicalTableConfig, validateTableAuthoringDocument };
+export { buildTableApplyPlan, createTableAuthoringDocument, decodeTablePageInputs, deriveTableEditorDocument, encodeTablePageInputs, materializeTablePageRuntimeInputs, normalizeTableAuthoringDocument, parseLegacyOrTableDocument, projectTablePageEditorChanges, serializeTableAuthoringDocument, toCanonicalTableConfig, validateTableAuthoringDocument, validateTablePageWidget };