@praxisui/table 8.0.0-beta.92 → 8.0.0-beta.93

package/fesm2022/{praxisui-table-table-agentic-authoring-turn-flow-CGr29WF0.mjs → praxisui-table-table-agentic-authoring-turn-flow-DUu4AIDF.mjs}

@@ -40,6 +40,10 @@ class TableAgenticAuthoringTurnFlow {
         if (pendingCompletion) {
             return Promise.resolve(this.toTurnResult(this.compileAdapterResponse(pendingCompletion, request), request));
         }
+        const pendingNumericBandStyle = this.completePendingNumericBandStyleClarification(request);
+        if (pendingNumericBandStyle) {
+            return Promise.resolve(this.toTurnResult(this.compileAdapterResponse(pendingNumericBandStyle, request), request));
+        }
         const run = async () => {
             await this.prepareAuthoringContext();
             const runtimeState = this.optionalJsonObject(this.adapter.getRuntimeState?.());
@@ -313,15 +317,15 @@ class TableAgenticAuthoringTurnFlow {
         const guidedSelectedRecordsFilter = this.localGuidedSelectedRecordsFilterResponse(request, contextHints);
         if (guidedSelectedRecordsFilter)
             return guidedSelectedRecordsFilter;
+        const selectedRecordDerivedFilter = this.localSelectedRecordDerivedFilterResponse(request, contextHints);
+        if (selectedRecordDerivedFilter)
+            return selectedRecordDerivedFilter;
         const declaredFilter = this.localDeclaredFilterApplyResponse(request, contextHints);
         if (declaredFilter)
             return declaredFilter;
         const recommendedIntent = this.toRecord(contextHints?.['recommendedIntent']);
         const intentId = this.stringValue(recommendedIntent?.['id'])
             || this.stringValue(contextHints?.['opportunityId']);
-        if (intentId === 'table-discover-capabilities' || intentId === 'table.capabilities.discover') {
-            return this.capabilityDiscoveryGuidedResponse(request, contextHints);
-        }
         if (intentId === 'table-enable-advanced-filters' || intentId === 'table.filters.advanced.enable') {
             return this.advancedFiltersRecommendedIntentResponse(request, contextHints);
         }
@@ -380,58 +384,6 @@ class TableAgenticAuthoringTurnFlow {
             ],
         };
     }
-    capabilityDiscoveryGuidedResponse(request, contextHints) {
-        const recommendations = Array.isArray(contextHints?.['availableRecommendations'])
-            ? contextHints['availableRecommendations']
-            : [];
-        const optionPayloads = recommendations
-            .map((entry) => this.toRecord(entry))
-            .filter((entry) => !!entry && !!this.stringValue(entry['label']))
-            .slice(0, 6)
-            .map((entry, index) => this.capabilityDiscoveryOptionPayload(entry, index));
-        if (!optionPayloads.length) {
-            return {
-                type: 'info',
-                sessionId: request.sessionId,
-                message: 'Esta tabela já está em um estado estável. Posso orientar ajustes de filtros, colunas, ações, exportação e seleção conforme você precisar.',
-            };
-        }
-        return {
-            type: 'clarification',
-            sessionId: request.sessionId,
-            message: 'Encontrei estes próximos recursos úteis para esta tabela.',
-            questions: ['Por onde você quer começar?'],
-            optionPayloads,
-            warnings: [
-                'capability-discovery-local-guided-clarification',
-                'Resposta local gerada a partir do catalogo canonico de recommendedIntents da tabela; nao houve roteamento textual primario.',
-            ],
-        };
-    }
-    capabilityDiscoveryOptionPayload(entry, index) {
-        const label = this.stringValue(entry['label']) || `Opção ${index + 1}`;
-        const contextHints = this.toRecord(entry['contextHints']) ?? {};
-        const responseContract = this.toRecord(contextHints['responseContract']);
-        return {
-            value: label,
-            label,
-            contextHints: {
-                ...contextHints,
-                recommendedIntent: {
-                    id: this.stringValue(entry['id']) || `table-discovery-option-${index + 1}`,
-                    label,
-                    sourceCandidateIds: Array.isArray(entry['sourceCandidateIds']) ? entry['sourceCandidateIds'] : [],
-                },
-                ...(responseContract ? {} : { responseContract: this.toRecord(this.contextHintsForTurn?.['responseContract']) ?? undefined }),
-                presentation: {
-                    kind: 'guided-option',
-                    icon: this.stringValue(entry['icon']) || 'auto_awesome',
-                    description: this.stringValue(entry['description']),
-                    ctaLabel: this.stringValue(entry['requiresConfirmation']) === 'true' ? 'Revisar opção' : 'Usar opção',
-                },
-            },
-        };
-    }
     selectedRecordsGuidedAnalysisResponse(request, contextHints) {
         const selectedCount = this.extractSelectedRecordsCount(contextHints);
         if (selectedCount <= 0) {
@@ -523,6 +475,55 @@ class TableAgenticAuthoringTurnFlow {
             ],
         };
     }
+    localSelectedRecordDerivedFilterResponse(request, contextHints) {
+        if (this.selectedRecordsCountForTurn <= 0)
+            return null;
+        if (!this.runtimeOperationAllowed(contextHints, 'table.filter.apply'))
+            return null;
+        const normalizedPrompt = this.normalizeLabel(request.prompt ?? '');
+        if (!normalizedPrompt || !this.promptRequestsRuntimeFilter(normalizedPrompt))
+            return null;
+        if (this.promptRequestsVisualOrStructuralEdit(normalizedPrompt))
+            return null;
+        if (this.promptRequestsExportOperation(normalizedPrompt))
+            return null;
+        const candidates = this.selectedRecordFilterCandidates(contextHints)
+            .map((candidate) => {
+            const score = this.selectedRecordFilterPromptGroundingScore(normalizedPrompt, candidate);
+            const criteria = this.toRecord(candidate['criteria']);
+            return { candidate, score, criteria };
+        })
+            .filter((entry) => entry.score > 0 && entry.criteria && Object.keys(entry.criteria).length > 0)
+            .sort((left, right) => right.score - left.score);
+        const top = candidates[0];
+        if (!top || top.score < 70)
+            return null;
+        const secondScore = candidates[1]?.score ?? 0;
+        if (secondScore > 0 && top.score - secondScore < 30)
+            return null;
+        return {
+            type: 'patch',
+            sessionId: request.sessionId,
+            patch: {
+                tableRuntimeOperations: {
+                    kind: 'praxis.table.runtime-operation.batch',
+                    source: 'selected-record-filter-candidate-local-grounding',
+                    operations: [{
+                            operationId: 'table.filter.apply',
+                            input: {
+                                criteria: top.criteria,
+                                source: 'selected-records',
+                            },
+                        }],
+                },
+            },
+            explanation: `Filtro por ${this.stringValue(top.candidate['label']) || this.humanizeFilterField(this.stringValue(top.candidate['field']))} preparado a partir dos registros selecionados.`,
+            warnings: [
+                'selected-record-filter-candidate-materialized',
+                'Resposta local gerada somente depois de confirmar table.filter.apply no contrato runtime e ranquear candidatos canônicos de selectedRecordsContext.filterCandidates.',
+            ],
+        };
+    }
     localDeclaredFilterApplyResponse(request, contextHints) {
         if (!this.runtimeOperationAllowed(contextHints, 'table.filter.apply'))
             return null;
@@ -1492,6 +1493,21 @@ class TableAgenticAuthoringTurnFlow {
             'salário',
         ].some((token) => normalizedPrompt.includes(this.normalizeLabel(token)));
     }
+    promptRequestsExportOperation(normalizedPrompt) {
+        return [
+            'exporta',
+            'exportar',
+            'exportacao',
+            'exportação',
+            'csv',
+            'json',
+            'excel',
+            'xlsx',
+            'pdf',
+            'arquivo',
+            'download',
+        ].some((token) => normalizedPrompt.includes(this.normalizeLabel(token)));
+    }
     promptRequestsVisualOrStructuralEdit(normalizedPrompt) {
         return [
             'badge',
@@ -2167,6 +2183,7 @@ class TableAgenticAuthoringTurnFlow {
         if (response.sessionId && response.sessionId !== request.sessionId) {
             request = { ...request, sessionId: response.sessionId };
         }
+        response = this.normalizeComputedColumnAuxiliaryMaterializations(response);
         if (response.type === 'clarification') {
             const questions = this.toClarificationQuestions(response, request);
             const diagnostics = this.buildClarificationDiagnostics(response);
@@ -2270,6 +2287,10 @@ class TableAgenticAuthoringTurnFlow {
     }
     compileAdapterResponse(response, request) {
         response = this.normalizeCategoricalRendererPalette(response, request);
+        response = this.normalizeStatusPresentationPlan(response, request);
+        response = this.normalizeNumericBandConditionalStylePlan(response, request);
+        response = this.normalizeCompoundColumnPresentationPlan(response, request);
+        response = this.normalizeComputedColumnAuxiliaryMaterializations(response);
         if (response.type === 'clarification' || response.type === 'info' || response.type === 'error') {
             const continuedEarlyColumnPlan = this.columnPlanForMisroutedVisualSemanticsClarification(response, request);
             if (continuedEarlyColumnPlan) {
@@ -4671,6 +4692,14 @@ class TableAgenticAuthoringTurnFlow {
             ?? this.booleanSimNaoOperationsFromGroundedClarification(prompt, responseText, columns)
             ?? this.booleanSimNaoOperationsFromSingleGroundedBooleanColumn(prompt, responseText, columns)
             ?? this.booleanSimNaoOperationsFromGroundedResponseField(prompt, responseText, columns);
+        const statusPresentationOperations = this.statusPresentationOperationsFromPrompt(prompt, columns);
+        if (statusPresentationOperations.length) {
+            return this.componentEditPlanResponse(statusPresentationOperations, 'Vou ajustar a apresentacao visual do status sem filtrar as linhas.', [
+                ...(response.warnings ?? []),
+                'status-renderer-continued-from-filter-clarification',
+                'Residual continuity guard acted only after the LLM scoped a visual status formatting request but answered with a filter clarification instead of a componentEditPlan.',
+            ]);
+        }
         const promptRequestsSimNao = this.normalizedTextIncludesAny(this.normalizeLabel(prompt), [
             'sim nao',
             'sim/nao',
@@ -4712,6 +4741,14 @@ class TableAgenticAuthoringTurnFlow {
                 'Residual continuity guard acted only after the LLM scoped the boolean column and Sim/Nao option but answered informationally or as confirmation instead of materializing a direct request.',
             ]);
         }
+        const numericBandStyleOperations = this.numericBandConditionalStyleOperationsFromPrompt(prompt, responseText, columns);
+        if (numericBandStyleOperations.length) {
+            return this.componentEditPlanResponse(numericBandStyleOperations, 'Vou aplicar formatacao condicional em faixas visuais na coluna numerica indicada.', [
+                ...(response.warnings ?? []),
+                'numeric-band-conditional-style-continued-from-filter-clarification',
+                'Residual continuity guard acted only after the LLM scoped a numeric conditional-formatting request but answered with a filter clarification instead of a componentEditPlan.',
+            ]);
+        }
         if (!visualSemanticClarification && !booleanInfo)
             return null;
         const formatOperations = this.formatOperationsFromPrompt(prompt, responseText, columns);
@@ -4753,6 +4790,447 @@ class TableAgenticAuthoringTurnFlow {
             warnings,
         };
     }
+    normalizeCompoundColumnPresentationPlan(response, request) {
+        if (!request)
+            return response;
+        if ((response.warnings ?? []).includes('compound-column-presentation-normalized'))
+            return response;
+        if (this.responseHasComputedColumnAuthoringDecision(response)) {
+            return response;
+        }
+        const prompt = this.componentPresentationPromptForTurn(request);
+        if (!this.promptRequestsCompoundColumnPresentationEdit(this.normalizeLabel(prompt)))
+            return response;
+        const currentConfig = this.adapter.getCurrentConfig?.();
+        const columns = Array.isArray(currentConfig?.['columns'])
+            ? currentConfig['columns']
+                .map((column) => this.toRecord(column))
+                .filter((column) => !!column && !!this.stringValue(column['field']))
+            : [];
+        if (!columns.length)
+            return response;
+        const intendedOperations = this.compoundColumnPresentationOperationsFromPrompt(prompt, columns);
+        if (!intendedOperations.length)
+            return response;
+        const originalPlan = this.toRecord(response.componentEditPlan);
+        const originalOperations = this.componentEditOperations(originalPlan);
+        const normalizedOperations = this.mergeCompoundColumnPresentationOperations(originalOperations, intendedOperations);
+        if (!normalizedOperations.length)
+            return response;
+        return {
+            ...response,
+            ...(response.type === 'clarification' || response.type === 'info' ? { type: 'patch' } : {}),
+            componentEditPlan: {
+                ...(originalPlan ?? {}),
+                kind: this.stringValue(originalPlan?.['kind']) || 'praxis.table.component-edit-plan',
+                version: this.stringValue(originalPlan?.['version']) || '1.0',
+                componentId: this.stringValue(originalPlan?.['componentId'])
+                    || this.adapter.componentId
+                    || request.componentId
+                    || 'praxis-table',
+                operations: normalizedOperations,
+            },
+            explanation: response.explanation || 'Vou preparar a visualizacao solicitada preservando cada acao por coluna.',
+            warnings: [
+                ...(response.warnings ?? []),
+                'compound-column-presentation-normalized',
+                'Residual continuity guard preserved field-level actions after the LLM authored or clarified a compound visibility/sticky/highlight request.',
+            ],
+        };
+    }
+    normalizeStatusPresentationPlan(response, request) {
+        if (!request)
+            return response;
+        if ((response.warnings ?? []).includes('status-presentation-normalized'))
+            return response;
+        const currentConfig = this.adapter.getCurrentConfig?.();
+        const columns = Array.isArray(currentConfig?.['columns'])
+            ? currentConfig['columns']
+                .map((column) => this.toRecord(column))
+                .filter((column) => !!column && !!this.stringValue(column['field']))
+            : [];
+        if (!columns.length)
+            return response;
+        const operations = this.statusPresentationOperationsFromPrompt(this.componentPresentationPromptForTurn(request), columns);
+        if (!operations.length)
+            return response;
+        const statusFields = new Set(operations
+            .map((operation) => this.operationTargetField(operation))
+            .filter((field) => !!field));
+        const originalPlan = this.toRecord(response.componentEditPlan);
+        const originalOperations = this.componentEditOperations(originalPlan)
+            .filter((operation) => {
+            const field = this.operationTargetField(operation);
+            const operationId = this.stringValue(operation['operationId']);
+            return !(field && statusFields.has(field) && (operationId === 'column.visibility.set'
+                || operationId === 'column.renderer.set'
+                || operationId === 'column.conditionalRenderer.add'
+                || operationId === 'column.conditionalStyle.add'));
+        });
+        return {
+            ...response,
+            ...(response.type === 'clarification' || response.type === 'info' ? { type: 'patch' } : {}),
+            componentEditPlan: {
+                ...(originalPlan ?? {}),
+                kind: this.stringValue(originalPlan?.['kind']) || 'praxis.table.component-edit-plan',
+                version: this.stringValue(originalPlan?.['version']) || '1.0',
+                componentId: this.stringValue(originalPlan?.['componentId'])
+                    || this.adapter.componentId
+                    || request.componentId
+                    || 'praxis-table',
+                operations: [...originalOperations, ...operations],
+            },
+            explanation: response.explanation || 'Vou ajustar a apresentacao visual do status sem filtrar as linhas.',
+            warnings: [
+                ...(response.warnings ?? []),
+                'status-presentation-normalized',
+                'Residual continuity guard preserved a status visual presentation request after the LLM authored or clarified a weaker status operation.',
+            ],
+        };
+    }
+    normalizeNumericBandConditionalStylePlan(response, request) {
+        if (!request)
+            return response;
+        if ((response.warnings ?? []).includes('numeric-band-conditional-style-normalized'))
+            return response;
+        const currentConfig = this.adapter.getCurrentConfig?.();
+        const columns = Array.isArray(currentConfig?.['columns'])
+            ? currentConfig['columns']
+                .map((column) => this.toRecord(column))
+                .filter((column) => !!column && !!this.stringValue(column['field']))
+            : [];
+        if (!columns.length)
+            return response;
+        const operations = this.numericBandConditionalStyleOperationsFromPrompt(this.componentPresentationPromptForTurn(request), [
+            response.message,
+            response.explanation,
+            ...(response.questions ?? []),
+        ].join(' '), columns);
+        if (!operations.length)
+            return response;
+        const fields = new Set(operations
+            .map((operation) => this.operationTargetField(operation))
+            .filter((field) => !!field));
+        const originalPlan = this.toRecord(response.componentEditPlan);
+        const originalOperations = this.componentEditOperations(originalPlan)
+            .filter((operation) => {
+            const field = this.operationTargetField(operation);
+            return !(field && fields.has(field) && this.stringValue(operation['operationId']) === 'column.conditionalStyle.add');
+        });
+        return {
+            ...response,
+            ...(response.type === 'clarification' || response.type === 'info' ? { type: 'patch' } : {}),
+            componentEditPlan: {
+                ...(originalPlan ?? {}),
+                kind: this.stringValue(originalPlan?.['kind']) || 'praxis.table.component-edit-plan',
+                version: this.stringValue(originalPlan?.['version']) || '1.0',
+                componentId: this.stringValue(originalPlan?.['componentId'])
+                    || this.adapter.componentId
+                    || request.componentId
+                    || 'praxis-table',
+                operations: [...originalOperations, ...operations],
+            },
+            explanation: response.explanation || 'Vou aplicar formatacao condicional em faixas visuais na coluna numerica indicada.',
+            warnings: [
+                ...(response.warnings ?? []),
+                'numeric-band-conditional-style-normalized',
+                'Residual continuity guard grounded numeric band thresholds from the canonical dataProfile when available, avoiding accidental thresholds from prose or visual token numbers.',
+            ],
+        };
+    }
+    componentEditPlanHasAnyOperation(componentEditPlan, operationIds) {
+        if (!operationIds.length)
+            return false;
+        const expected = new Set(operationIds);
+        return this.componentEditOperations(componentEditPlan)
+            .some((operation) => expected.has(this.componentEditPlanOperationIdentity(operation)));
+    }
+    responseHasComputedColumnAuthoringDecision(response) {
+        if (this.componentEditPlanHasAnyOperation(response.componentEditPlan, ['column.computed.add', 'column.computed.set'])) {
+            return true;
+        }
+        const patch = this.toRecord(response.patch);
+        const columns = Array.isArray(patch?.['columns']) ? patch['columns'] : [];
+        return columns
+            .map((column) => this.toRecord(column))
+            .some((column) => !!column?.['computed']);
+    }
+    normalizeComputedColumnAuxiliaryMaterializations(response) {
+        const plan = this.toRecord(response.componentEditPlan);
+        const operations = this.componentEditOperations(plan);
+        if (!plan || operations.length < 2)
+            return response;
+        const computedFields = new Set(operations
+            .filter((operation) => this.componentEditPlanOperationIdentity(operation) === 'column.computed.add'
+            || this.componentEditPlanOperationIdentity(operation) === 'column.computed.set')
+            .map((operation) => this.operationTargetField(operation))
+            .filter((field) => !!field));
+        if (!computedFields.size) {
+            return response;
+        }
+        const auxiliaryAddedFields = new Set();
+        for (const operation of operations) {
+            const operationId = this.componentEditPlanOperationIdentity(operation);
+            const field = this.operationTargetField(operation);
+            if (!field)
+                continue;
+            if (operationId === 'column.add' && !computedFields.has(field)) {
+                auxiliaryAddedFields.add(field);
+            }
+        }
+        const removableFields = auxiliaryAddedFields;
+        if (!removableFields.size)
+            return response;
+        const normalizedOperations = operations.filter((operation) => {
+            const operationId = this.componentEditPlanOperationIdentity(operation);
+            const field = this.operationTargetField(operation);
+            return !(field && removableFields.has(field) && (operationId === 'column.add'
+                || operationId === 'column.renderer.set'));
+        });
+        if (normalizedOperations.length === operations.length)
+            return response;
+        return {
+            ...response,
+            componentEditPlan: {
+                ...plan,
+                operations: normalizedOperations,
+            },
+            warnings: [
+                ...(response.warnings ?? []),
+                'computed-column-auxiliary-materialization-normalized',
+                'Removed auxiliary column.add/column.renderer.set operations that conflicted with a canonical computed-column decision in the same componentEditPlan.',
+            ],
+        };
+    }
+    componentEditPlanOperationIdentity(operation) {
+        const operationId = this.stringValue(operation['operationId']);
+        if (operationId) {
+            return this.canonicalComponentEditPlanOperationIdentity(operationId);
+        }
+        const changeKind = this.stringValue(operation['changeKind']);
+        return this.canonicalComponentEditPlanOperationIdentity(changeKind);
+    }
+    canonicalComponentEditPlanOperationIdentity(operationId) {
+        switch (operationId) {
+            case 'addColumn':
+            case 'add_column':
+            case 'column_add':
+                return 'column.add';
+            case 'setColumnRenderer':
+            case 'set_column_renderer':
+            case 'column_renderer_set':
+                return 'column.renderer.set';
+            case 'set_column_computed':
+            case 'add_column_computed':
+            case 'add_computed_column':
+            case 'set_computed_column':
+            case 'column_computed_add':
+                return 'column.computed.add';
+            case 'column.computed.set':
+                return 'column.computed.add';
+            default:
+                return operationId;
+        }
+    }
+    componentPresentationPromptForTurn(request) {
+        const parts = [
+            request.pendingClarification?.sourcePrompt,
+            ...(request.messages ?? [])
+                .filter((message) => message.role === 'user')
+                .map((message) => message.text),
+            request.prompt,
+        ];
+        return parts
+            .map((part) => (part ?? '').trim())
+            .filter((part) => !!part)
+            .join(' ');
+    }
+    promptRequestsCompoundColumnPresentationEdit(normalizedPrompt) {
+        const hasVisibility = this.normalizedTextIncludesAny(normalizedPrompt, [
+            'oculta',
+            'ocultar',
+            'oculte',
+            'esconde',
+            'esconder',
+            'esconda',
+            'visao publica',
+            'visão publica',
+            'visualizacao publica',
+            'visualização publica',
+        ]);
+        const hasStickyOrHighlight = this.normalizedTextIncludesAny(normalizedPrompt, [
+            'fixa',
+            'fixe',
+            'fixar',
+            'pin',
+            'sticky',
+            'destaca',
+            'destaque',
+            'destacar',
+            'realca',
+            'realce',
+            'realçar',
+        ]);
+        return hasVisibility && hasStickyOrHighlight;
+    }
+    compoundColumnPresentationOperationsFromPrompt(prompt, columns) {
+        const normalizedPrompt = this.normalizeLabel(prompt);
+        const operations = [];
+        const seen = new Set();
+        for (const column of columns) {
+            const field = this.stringValue(column['field']);
+            if (!field)
+                continue;
+            const action = this.columnPresentationActionFromPrompt(normalizedPrompt, column);
+            if (!action)
+                continue;
+            const key = `${action}:${field}`;
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            if (action === 'hide') {
+                operations.push({
+                    operationId: 'column.visibility.set',
+                    target: { kind: 'column', field },
+                    input: { visible: false },
+                });
+                continue;
+            }
+            if (action === 'sticky') {
+                operations.push({
+                    operationId: 'column.sticky.set',
+                    target: { kind: 'column', field },
+                    input: { sticky: 'start' },
+                });
+                continue;
+            }
+            operations.push({
+                operationId: 'column.renderer.set',
+                target: { kind: 'column', field },
+                input: {
+                    renderer: {
+                        type: 'chip',
+                        chip: {
+                            textField: field,
+                            color: 'info',
+                            variant: 'outlined',
+                        },
+                    },
+                },
+            });
+        }
+        return operations;
+    }
+    columnPresentationActionFromPrompt(normalizedPrompt, column) {
+        const mentionIndex = this.columnMentionIndex(normalizedPrompt, column);
+        if (mentionIndex < 0)
+            return null;
+        const beforeMention = normalizedPrompt.slice(0, mentionIndex);
+        const tokens = [];
+        this.collectActionTokenIndexes(beforeMention, ['oculta', 'ocultar', 'oculte', 'esconde', 'esconder', 'esconda'], 'hide', tokens);
+        this.collectActionTokenIndexes(beforeMention, ['fixa', 'fixe', 'fixar', 'pin', 'sticky'], 'sticky', tokens);
+        this.collectActionTokenIndexes(beforeMention, ['destaca', 'destaque', 'destacar', 'realca', 'realce', 'realçar'], 'highlight', tokens);
+        tokens.sort((left, right) => right.index - left.index);
+        return tokens[0]?.action ?? null;
+    }
+    collectActionTokenIndexes(text, candidates, action, bucket) {
+        for (const candidate of candidates) {
+            const normalized = this.normalizeLabel(candidate);
+            let index = text.indexOf(normalized);
+            while (index >= 0) {
+                bucket.push({ action, index });
+                index = text.indexOf(normalized, index + normalized.length);
+            }
+        }
+    }
+    columnMentionIndex(normalizedPrompt, column) {
+        return this.columnPresentationAliases(column)
+            .map((alias) => normalizedPrompt.indexOf(alias))
+            .filter((index) => index >= 0)
+            .sort((left, right) => left - right)[0] ?? -1;
+    }
+    columnPresentationAliases(column) {
+        const aliases = new Set(this.columnMentionAliases(column));
+        const field = this.normalizeLabel(this.stringValue(column['field']));
+        const header = this.normalizeLabel(this.stringValue(column['header']));
+        if (field.startsWith('nome') || header.includes('nome'))
+            aliases.add('nome');
+        if (field.includes('funcionario') || header.includes('funcionario'))
+            aliases.add('nome');
+        if (field.includes('salario') || header.includes('salario'))
+            aliases.add('salario');
+        if (field.includes('salario') || header.includes('salario'))
+            aliases.add('salário');
+        return [...aliases].sort((left, right) => right.length - left.length);
+    }
+    mergeCompoundColumnPresentationOperations(originalOperations, intendedOperations) {
+        const protectedFields = new Map();
+        const protectedSemanticKeys = new Map();
+        for (const operation of intendedOperations) {
+            const field = this.operationTargetField(operation);
+            const action = this.compoundOperationAction(operation);
+            if (!field || !action)
+                continue;
+            const actions = protectedFields.get(field) ?? new Set();
+            actions.add(action);
+            protectedFields.set(field, actions);
+            const semanticKey = this.compoundOperationFieldSemanticKey(field);
+            if (semanticKey) {
+                const semanticActions = protectedSemanticKeys.get(semanticKey) ?? new Set();
+                semanticActions.add(action);
+                protectedSemanticKeys.set(semanticKey, semanticActions);
+            }
+        }
+        const filteredOriginal = originalOperations.filter((operation) => {
+            const action = this.compoundOperationAction(operation);
+            if (!action)
+                return true;
+            const field = this.operationTargetField(operation);
+            if (!field)
+                return false;
+            const intended = protectedFields.get(field);
+            if (intended)
+                return false;
+            const semanticKey = this.compoundOperationFieldSemanticKey(field);
+            if (semanticKey && protectedSemanticKeys.has(semanticKey))
+                return false;
+            return true;
+        });
+        return [...filteredOriginal, ...intendedOperations];
+    }
+    compoundOperationFieldSemanticKey(field) {
+        const normalized = this.normalizeLabel(field);
+        if (!normalized)
+            return '';
+        if (normalized.startsWith('nome') || normalized.includes('funcionario'))
+            return 'record-name';
+        return '';
+    }
+    compoundOperationAction(operation) {
+        const operationId = this.stringValue(operation['operationId']);
+        const input = this.toRecord(operation['input']) ?? {};
+        if (operationId === 'column.visibility.set' && this.booleanInput(input['visible']) === false)
+            return 'hide';
+        if (operationId === 'column.sticky.set')
+            return 'sticky';
+        if (operationId === 'column.renderer.set' || operationId === 'column.conditionalStyle.add')
+            return 'highlight';
+        return null;
+    }
+    operationTargetField(operation) {
+        const target = this.toRecord(operation['target']);
+        const input = this.toRecord(operation['input']) ?? {};
+        return this.stringValue(target?.['field'])
+            || this.stringValue(target?.['id'])
+            || this.stringValue(target?.['name'])
+            || this.stringValue(operation['target'])
+            || this.stringValue(operation['targetField'])
+            || this.stringValue(operation['field'])
+            || this.stringValue(input['targetField'])
+            || this.stringValue(input['field'])
+            || this.stringValue(input['id'])
+            || this.stringValue(input['name']);
+    }
     formatOperationsFromPrompt(prompt, responseText, columns) {
         const canonicalFormats = new Set([
             'dd/MM/yyyy',
@@ -4795,6 +5273,291 @@ class TableAgenticAuthoringTurnFlow {
         });
         return this.booleanSimNaoOperationsForColumn(column);
     }
+    statusPresentationOperationsFromPrompt(prompt, columns) {
+        const normalizedPrompt = this.normalizeLabel(prompt);
+        const asksStatusVisual = this.normalizedTextIncludesAny(normalizedPrompt, [
+            'status',
+            'ativo',
+            'inativo',
+            'inativos',
+        ]) && this.normalizedTextIncludesAny(normalizedPrompt, [
+            'badge',
+            'badges',
+            'chip',
+            'chips',
+            'semantico',
+            'semântico',
+            'verde',
+            'vermelho',
+            'discreto',
+            'discretos',
+            'format',
+            'renderer',
+        ]);
+        if (!asksStatusVisual)
+            return [];
+        const column = columns.find((candidate) => {
+            const text = this.normalizeLabel([
+                candidate['field'],
+                candidate['header'],
+                candidate['type'],
+                candidate['dataType'],
+                this.humanizeField(this.stringValue(candidate['field'])),
+            ].map((value) => this.stringValue(value)).join(' '));
+            return this.normalizedTextIncludesAny(text, ['status', 'ativo', 'boolean', 'bool']);
+        });
+        const field = this.stringValue(column?.['field']);
+        if (!field)
+            return [];
+        const operations = [
+            this.statusConditionalRendererOperation(field, true, 'Ativo', 'success'),
+            this.statusConditionalRendererOperation(field, false, 'Inativo', 'warn'),
+        ];
+        if (this.normalizedTextIncludesAny(normalizedPrompt, ['discreto', 'discretos', 'suave', 'suavizar', 'inativo', 'inativos'])) {
+            operations.push({
+                operationId: 'column.conditionalStyle.add',
+                target: { kind: 'rule', field },
+                input: {
+                    id: `${field}-inactive-muted`,
+                    condition: { '===': [{ var: field }, false] },
+                    style: { opacity: '0.62' },
+                    tooltip: { text: 'Funcionário inativo' },
+                    description: 'Funcionário inativo com leitura discreta.',
+                },
+            });
+        }
+        return operations;
+    }
+    numericBandConditionalStyleOperationsFromPrompt(prompt, responseText, columns) {
+        const normalizedPrompt = this.normalizeLabel(prompt);
+        const asksConditionalBands = this.normalizedTextIncludesAny(normalizedPrompt, [
+            'formatacao condicional',
+            'formatação condicional',
+            'conditional formatting',
+            'condicional',
+            'faixa',
+            'faixas',
+            'destaca',
+            'destaque',
+            'destacando',
+            'realca',
+            'realce',
+            'realçando',
+        ]) && this.normalizedTextIncludesAny(normalizedPrompt, [
+            'alta',
+            'alto',
+            'media',
+            'média',
+            'medio',
+            'médio',
+            'baixa',
+            'baixo',
+        ]);
+        if (!asksConditionalBands)
+            return [];
+        const column = columns.find((candidate) => this.numericColumnCandidate(candidate)
+            && (this.textMentionsColumn(prompt, candidate) || this.textMentionsColumn(responseText, candidate)));
+        const field = this.stringValue(column?.['field']);
+        if (!field)
+            return [];
+        const thresholds = this.numericBandThresholdsForField(field, responseText);
+        if (!thresholds)
+            return [];
+        return [
+            this.numericBandConditionalStyleOperation(field, 'high', {
+                condition: { '>=': [{ var: field }, thresholds.highStart] },
+                description: 'Faixa alta',
+                style: {
+                    backgroundColor: 'rgba(46, 125, 50, 0.16)',
+                    color: 'rgb(27, 94, 32)',
+                    fontWeight: '600',
+                },
+            }),
+            this.numericBandConditionalStyleOperation(field, 'medium', {
+                condition: {
+                    and: [
+                        { '>=': [{ var: field }, thresholds.mediumStart] },
+                        { '<': [{ var: field }, thresholds.highStart] },
+                    ],
+                },
+                description: 'Faixa media',
+                style: {
+                    backgroundColor: 'rgba(245, 158, 11, 0.16)',
+                    color: 'rgb(146, 64, 14)',
+                    fontWeight: '600',
+                },
+            }),
+            this.numericBandConditionalStyleOperation(field, 'low', {
+                condition: { '<': [{ var: field }, thresholds.mediumStart] },
+                description: 'Faixa baixa',
+                style: {
+                    backgroundColor: 'rgba(220, 38, 38, 0.12)',
+                    color: 'rgb(153, 27, 27)',
+                    fontWeight: '600',
+                },
+            }),
+        ];
+    }
+    completePendingNumericBandStyleClarification(request) {
+        if (request.action?.kind !== 'clarify')
+            return null;
+        const sourcePrompt = this.pendingClarificationSourcePromptForTurn(request, this.toRecord(request.pendingClarification?.diagnostics) ?? undefined);
+        if (!sourcePrompt)
+            return null;
+        const answerText = [
+            request.action?.displayPrompt,
+            request.action?.value,
+            request.prompt,
+        ].map((value) => this.stringValue(value)).filter(Boolean).join(' ');
+        if (!this.normalizedTextIncludesAny(this.normalizeLabel(answerText), [
+            'terco',
+            'terços',
+            'tertil',
+            'automatic',
+            'automático',
+            'automatico',
+            'limites absolutos',
+            'faixa',
+            'faixas',
+        ])) {
+            return null;
+        }
+        const columns = this.toArray(this.adapter.getCurrentConfig?.()?.['columns'])
+            .map((column) => this.toRecord(column))
+            .filter((column) => !!column && !!this.stringValue(column['field']));
+        if (!columns.length)
+            return null;
+        const responseText = [
+            request.pendingClarification?.assistantMessage,
+            ...(request.pendingClarification?.questions ?? []).map((question) => this.stringValue(question['prompt'])
+                || this.stringValue(question['question'])
+                || this.stringValue(question['label'])),
+            answerText,
+        ].join(' ');
+        const operations = this.numericBandConditionalStyleOperationsFromPrompt(sourcePrompt, responseText, columns);
+        if (!operations.length)
+            return null;
+        return this.componentEditPlanResponse(operations, 'Vou aplicar formatacao condicional em faixas visuais na coluna numerica indicada.', [
+            'numeric-band-conditional-style-continued-from-clarification-answer',
+            'A resposta de clarificacao continuou uma intencao visual ja ancorada em componentEditPlan; o grounding de campo veio das colunas declaradas e os limites vieram do dataProfile quando a clarificacao nao trouxe valores numericos.',
+        ]);
+    }
+    numericColumnCandidate(column) {
+        const text = this.normalizeLabel([
+            column['field'],
+            column['header'],
+            column['type'],
+            column['dataType'],
+            column['format'],
+            this.humanizeField(this.stringValue(column['field'])),
+        ].map((value) => this.stringValue(value)).join(' '));
+        return this.normalizedTextIncludesAny(text, [
+            'number',
+            'numeric',
+            'decimal',
+            'integer',
+            'currency',
+            'moeda',
+            'valor',
+            'preco',
+            'preço',
+            'salario',
+            'salário',
+            'brl',
+        ]);
+    }
+    numericBandThresholdsForField(field, text) {
+        return this.numericBandThresholdsFromDataProfile(field)
+            ?? this.numericBandThresholdsFromText(text);
+    }
+    numericBandThresholdsFromText(text) {
+        const values = this.extractNumericBandSamples(text);
+        if (values.length < 2)
+            return null;
+        const sorted = [...new Set(values)]
+            .sort((left, right) => left - right);
+        if (sorted.length < 2)
+            return null;
+        const min = sorted[0];
+        const max = sorted[sorted.length - 1];
+        if (!Number.isFinite(min) || !Number.isFinite(max) || max <= min)
+            return null;
+        const range = max - min;
+        return {
+            mediumStart: this.roundBandThreshold(min + range / 3),
+            highStart: this.roundBandThreshold(min + (range * 2) / 3),
+        };
+    }
+    numericBandThresholdsFromDataProfile(field) {
+        const dataProfile = this.toRecord(this.adapter.getDataProfile?.());
+        const columns = this.toRecord(dataProfile?.['columns']);
+        const stats = this.toRecord(columns?.[field]);
+        const min = this.numberValue(stats?.['min']);
+        const max = this.numberValue(stats?.['max']);
+        if (min === null || max === null || max <= min)
+            return null;
+        const range = max - min;
+        return {
+            mediumStart: this.roundBandThreshold(min + range / 3),
+            highStart: this.roundBandThreshold(min + (range * 2) / 3),
+        };
+    }
+    extractNumericBandSamples(text) {
+        const matches = text.match(/(?:R\$\s*)?\d{1,3}(?:[.\s]\d{3})*(?:,\d+)?|\d+(?:\.\d+)?/g) ?? [];
+        return matches
+            .map((match) => this.parseLocalizedNumber(match))
+            .filter((value) => Number.isFinite(value));
+    }
+    parseLocalizedNumber(value) {
+        const cleaned = value.replace(/[^\d.,-]+/g, '').trim();
+        if (!cleaned)
+            return null;
+        const normalized = cleaned.includes(',')
+            ? cleaned.replace(/\./g, '').replace(',', '.')
+            : cleaned.replace(/\s/g, '');
+        const parsed = Number(normalized);
+        return Number.isFinite(parsed) ? parsed : null;
+    }
+    roundBandThreshold(value) {
+        if (Math.abs(value) >= 1000)
+            return Math.round(value / 100) * 100;
+        if (Math.abs(value) >= 100)
+            return Math.round(value / 10) * 10;
+        return Math.round(value);
+    }
+    numericBandConditionalStyleOperation(field, band, input) {
+        return {
+            operationId: 'column.conditionalStyle.add',
+            target: { kind: 'rule', field },
+            input: {
+                id: `${field}-band-${band}`,
+                condition: input.condition,
+                style: input.style,
+                tooltip: { text: input.description },
+                description: input.description,
+            },
+        };
+    }
+    statusConditionalRendererOperation(field, value, text, color) {
+        return {
+            operationId: 'column.conditionalRenderer.add',
+            target: { kind: 'conditionalRenderer', field },
+            input: {
+                id: `${field}-${value ? 'active' : 'inactive'}-badge`,
+                condition: { '===': [{ var: field }, value] },
+                renderer: {
+                    type: 'badge',
+                    badge: {
+                        text,
+                        color,
+                        variant: 'soft',
+                    },
+                },
+                tooltip: { text },
+                description: text,
+            },
+        };
+    }
     booleanSimNaoOperationsFromGroundedClarification(prompt, responseText, columns) {
         const normalizedPrompt = this.normalizeLabel(prompt);
         const normalizedResponse = this.normalizeLabel(responseText.replace(/[^\p{Letter}\p{Number}\s/]+/gu, ' '));
@@ -5691,6 +6454,8 @@ class TableAgenticAuthoringTurnFlow {
     columnVisibilityPlanForInvalidExecutableError(response, request, compiledError) {
         if (!request)
             return null;
+        if ((response.warnings ?? []).includes('column-visibility-continued-from-invalid-executable-plan'))
+            return null;
         const prompt = this.columnVisibilityPromptForTurn(request);
         if (!this.promptRequestsColumnVisibilityEdit(this.normalizeLabel(prompt)))
             return null;
@@ -5718,10 +6483,15 @@ class TableAgenticAuthoringTurnFlow {
                 .map((column) => this.toRecord(column))
                 .filter((column) => !!column && !!this.stringValue(column['field']))
             : [];
-        const operations = this.columnVisibilityOperationsFromPrompt(prompt, columns);
+        const normalizedPrompt = this.normalizeLabel(prompt);
+        const operations = this.promptRequestsCompoundColumnPresentationEdit(normalizedPrompt)
+            ? this.compoundColumnPresentationOperationsFromPrompt(prompt, columns)
+            : this.columnVisibilityOperationsFromPrompt(prompt, columns);
         if (!operations.length)
             return null;
-        return this.componentEditPlanResponse(operations, 'Vou ocultar as colunas indicadas para a visualizacao solicitada.', [
+        return this.componentEditPlanResponse(operations, this.promptRequestsCompoundColumnPresentationEdit(normalizedPrompt)
+            ? 'Vou preparar a visualizacao solicitada preservando cada acao por coluna.'
+            : 'Vou ocultar as colunas indicadas para a visualizacao solicitada.', [
             ...(response.warnings ?? []),
             ...(compiledError.warnings ?? []),
             'column-visibility-continued-from-invalid-executable-plan',
@@ -7189,12 +7959,97 @@ class TableAgenticAuthoringTurnFlow {
     }
     withCapabilitySystemMessages(messages, contextHints, prompt = '') {
         const policies = [
+            this.buildRecommendedCapabilitiesSystemPolicy(contextHints),
+            this.buildComponentPresentationAuthoringSystemPolicy(contextHints, prompt),
             this.buildComponentLayoutAuthoringSystemPolicy(contextHints, prompt),
             this.buildFilterExpressionSystemPolicy(contextHints),
-            this.buildFilterAuthoringSystemPolicy(contextHints),
+            this.buildFilterAuthoringSystemPolicy(contextHints, prompt),
         ].filter((message) => !!message);
         return policies.length ? [...policies, ...messages] : messages;
     }
+    buildRecommendedCapabilitiesSystemPolicy(contextHints) {
+        const recommendedIntent = this.toRecord(contextHints?.['recommendedIntent']);
+        const intentId = this.stringValue(recommendedIntent?.['id'])
+            || this.stringValue(contextHints?.['opportunityId']);
+        const authoringMode = this.stringValue(contextHints?.['authoringMode']);
+        if (intentId !== 'table-discover-capabilities'
+            && intentId !== 'table.capabilities.discover'
+            && authoringMode !== 'table.recommended-capabilities.analysis') {
+            return null;
+        }
+        const candidates = Array.isArray(contextHints?.['availableRecommendations'])
+            ? contextHints['availableRecommendations']
+            : [];
+        const candidateLines = candidates
+            .map((entry, index) => {
+            const record = this.toRecord(entry);
+            if (!record)
+                return null;
+            const id = this.stringValue(record['id']) || `candidate-${index + 1}`;
+            const label = this.stringValue(record['label']) || id;
+            const description = this.stringValue(record['description']);
+            const group = this.stringValue(record['groupLabel']);
+            const sourceCandidateIds = Array.isArray(record['sourceCandidateIds'])
+                ? record['sourceCandidateIds'].map((value) => this.stringValue(value)).filter(Boolean)
+                : [];
+            return [
+                `- ${id}: ${label}`,
+                description ? `description=${description}` : null,
+                group ? `group=${group}` : null,
+                sourceCandidateIds.length ? `canonicalCandidates=${sourceCandidateIds.join(',')}` : null,
+            ].filter(Boolean).join('; ');
+        })
+            .filter((line) => !!line);
+        return {
+            role: 'system',
+            content: [
+                'Praxis table recommended capabilities policy:',
+                '- The user selected the canonical recommended-capabilities intent. Do not merely list all table features.',
+                '- Analyze currentState, runtimeState, schemaFields, dataProfile, and the declared availableRecommendations before answering.',
+                '- Exclude capabilities already materialized in currentState unless the recommendation is a refinement backed by column/data evidence.',
+                '- Prefer recommendations tied to specific columns, data profile signals, selected rows, resource surfaces, navigation destinations, or missing runtime capabilities.',
+                '- Return a concise ranked recommendation set. When a recommendation can be materialized by componentEditPlan or a declared runtime operation, include the safest executable proposal or guided option for review.',
+                '- Do not expose internal ids, operationIds, endpoint paths, or payload details unless the user explicitly asks for technical details.',
+                candidateLines.length ? 'Curated canonical candidate recommendations:' : 'Curated canonical candidate recommendations: none declared.',
+                ...candidateLines,
+            ].join('\n'),
+        };
+    }
+    buildComponentPresentationAuthoringSystemPolicy(contextHints, prompt) {
+        void contextHints;
+        const normalizedPrompt = this.normalizeLabel(prompt);
+        const presentationIntent = this.promptRequestsVisualOrStructuralEdit(normalizedPrompt)
+            || this.promptRequestsCompoundColumnPresentationEdit(normalizedPrompt);
+        if (!presentationIntent)
+            return null;
+        const columns = this.toArray(this.adapter.getCurrentConfig()?.['columns'])
+            .map((column) => this.toRecord(column))
+            .filter((column) => !!column && !!this.stringValue(column['field']))
+            .slice(0, 20);
+        if (!columns.length)
+            return null;
+        const columnLines = columns.map((column) => {
+            const field = this.stringValue(column['field']);
+            const label = this.stringValue(column['header']) || this.humanizeField(field);
+            const visible = column['visible'] === false ? 'hidden' : 'visible';
+            const type = this.stringValue(column['type'] ?? column['dataType']) || 'unknown';
+            return `- ${field} (${label}; ${type}; ${visible})`;
+        });
+        return {
+            role: 'system',
+            content: [
+                'Praxis table component presentation authoring policy:',
+                '- Use componentEditPlan operations for visual or structural table changes: renderers, badges, chips, conditional styles, column visibility, sticky columns, formats, and computed columns.',
+                '- Explicit presentation requests such as badge, chip, renderer, color, highlight, format, inactive visual state, public view, hide/show column, pin/sticky column, or calculated column are edit/componentEditPlan requests, not table.filter.apply.',
+                '- When the user asks to create a new column by joining, combining, concatenating, composing, deriving, calculating, merging, juntar, unir, concatenar, combinar, compor, derivar, calcular, or mesclar values from existing declared columns, author exactly one canonical column.computed.add operation for the new field. Use a JSON Logic cat expression for textual joins, include dependencies, and preserve the user requested header/name. Derive a stable camelCase input.field from the requested header/name when the field id is not explicitly provided; do not ask the user to choose a technical field id. Do not materialize derived columns as column.add plus column.renderer.set.',
+                '- For compound prompts, preserve the action attached to each declared column: hide only columns in the hide/privacy scope, pin/fix columns with column.sticky.set, and highlight/destacar columns with renderer or style operations. Never hide a column that the user asked to pin or highlight.',
+                '- If the user answers a previous component-edit clarification with a short option such as "sim", "opcao 2", or "prosseguir", continue the previous component-edit intent instead of treating the answer as a new filter request.',
+                '- Ask clarification only when the declared source columns or authoring capabilities are insufficient to choose a safe componentEditPlan. Do not ask clarification solely to pick an internal field id for a newly named computed column.',
+                'Declared table columns:',
+                ...columnLines,
+            ].join('\n'),
+        };
+    }
     buildComponentLayoutAuthoringSystemPolicy(contextHints, prompt) {
         const normalizedPrompt = this.normalizeLabel(prompt);
         const position = this.relativeOrderPosition(normalizedPrompt);
@@ -7227,7 +8082,7 @@ class TableAgenticAuthoringTurnFlow {
             ].join('\n'),
         };
     }
-    buildFilterAuthoringSystemPolicy(contextHints) {
+    buildFilterAuthoringSystemPolicy(contextHints, prompt = '') {
         if (!this.runtimeOperationAllowed(contextHints, 'table.filter.apply'))
             return null;
         const entries = this.filterFieldCatalogEntries.length
@@ -7235,6 +8090,7 @@ class TableAgenticAuthoringTurnFlow {
             : this.extractFilterFieldCatalogEntries(contextHints);
         if (!entries.length)
             return null;
+        const normalizedPrompt = this.normalizeLabel(prompt);
         const catalogLines = entries.slice(0, 12).map((entry) => {
             const relatedFields = entry.relatedColumnFields.length
                 ? ` related columns: ${entry.relatedColumnFields.join(', ')}.`
@@ -7248,6 +8104,9 @@ class TableAgenticAuthoringTurnFlow {
                 'Praxis table filter authoring policy:',
                 '- Use the declared filterFieldCatalog as the canonical grounding for row filtering decisions.',
                 '- When the user asks to restrict, search, list, show only, compare values, define ranges, or filter rows, prefer a table.filter.apply runtime operation over visual renderer or column formatting operations.',
+                ...(this.promptRequestsVisualOrStructuralEdit(normalizedPrompt)
+                    ? ['- This turn contains an explicit visual or structural table-edit signal; do not reinterpret that signal as a row filter unless the user also explicitly asks to restrict table rows.']
+                    : []),
                 '- For numeric and date comparisons, use the declared range filter field from filterFieldCatalog instead of the raw listing column field.',
                 '- If the user intent is ambiguous between filtering rows and changing visual presentation, ask a short clarification instead of choosing a renderer by default.',
                 '- Do not invent filter field names; use only declared filter fields and their related listing columns for grounding.',
@@ -8189,6 +9048,14 @@ class TableAgenticAuthoringTurnFlow {
     stringValue(value) {
         return typeof value === 'string' ? value.trim() : '';
     }
+    numberValue(value) {
+        const parsed = typeof value === 'number'
+            ? value
+            : typeof value === 'string'
+                ? Number(value.trim())
+                : Number.NaN;
+        return Number.isFinite(parsed) ? parsed : null;
+    }
     stringifySurfaceEvidence(value) {
         try {
             return JSON.stringify(value)?.slice(0, 4000) ?? '';