@praxisui/table 8.0.0-beta.20 → 8.0.0-beta.21

package/README.md

@@ -163,6 +163,15 @@ Filtro runtime:
 - The default is `false`; hosts opt in when they want settings, authoring affordances and schema-drift UX.
 - Customization mode does not change the table data mode. It only gates configuration/editorial surfaces.
 
+## Praxis Semantic Assistant
+
+- The table assistant is part of the global Praxis semantic copilot experience, not a standalone table patch bot.
+- In customization mode, opening the assistant registers a `PraxisAssistantContextSnapshot` through `PraxisAssistantSessionRegistryService`.
+- The table session identity follows `table:{routeKey}:{componentInstanceId || tableId}` so multiple tables on the same page can preserve separate assistant sessions.
+- Minimizing the table shell keeps a global minimized session that the App Shell can reopen; the App Shell does not interpret or execute table semantics.
+- The table snapshot stores only safe context: table identity, target, context chips, manifest reference, resource path, schema field names, data/runtime digests, capability refs and governance hints.
+- Prompts that indicate shared business decisions, such as rules, policies, compliance, LGPD, approval, eligibility or access control, must be routed to governed `domain-rules` handoff instead of local table config patches.
+
 ## Migration Note
 
 - This release treats `enableCustomization=false` as the canonical default.
@@ -274,6 +283,25 @@ rowConditionalStyles: [
 ]
 ```
 
+O editor especializado tambem persiste `effects: RuleEffectDefinition[]` em
+`rowConditionalStyles` e `columns[].conditionalStyles`. O runtime consome esses
+efeitos diretamente e ainda preserva `cssClass`/`style` como fallback de
+compatibilidade, mantendo o ciclo abrir -> aplicar/salvar -> reabrir sem exigir
+que consumidores recompilem manualmente os efeitos visuais.
+
+Para renderizacao condicional, `columns[].conditionalRenderers` tambem aceita
+`effects: RuleEffectDefinition[]` como fonte canonica para renderer, tooltip e
+animacao. `rowConditionalRenderers` fica tipado no contrato publico para tooltip
+e animacao de linha, preservando os campos planos `tooltip`/`animation` como
+fallback.
+
+Colunas calculadas usam `columns[].computed.expression` como AST JSON Logic
+canonico. Regras, estilos e renderers condicionais podem referenciar esses
+valores via `computed.<field>`. Quando uma coluna calculada depende de outra
+coluna calculada, o runtime resolve a ordem de avaliacao por dependencias
+declaradas ou referencias `var: "computed.<field>"`, evitando que o resultado
+dependa da ordem fisica de `columns[]`.
+
 ```scss
 .app-table .mat-mdc-row.app-row--priority-high {
   background: linear-gradient(
@@ -471,6 +499,12 @@ por `PraxisAssistantTurnOrchestratorService`; a semantica especifica da tabela c
 
 ## Agentic Authoring & Manifest
 
+Para acoes globais de `toolbar`, `row` e `bulk`, o authoring agentic aceita somente `GlobalActionRef` governado:
+`actionId`, `payload`, `payloadExpr` e `meta`. O schema bloqueia propriedades arbitrarias e mantem `payloadExpr`
+como escape avancado explicito, nao como objeto livre. Configuracoes novas devem persistir a acao em
+`effects[].kind = "global-action"` com `effects[].globalAction`; `globalAction` plano permanece apenas como fallback
+de compatibilidade para documentos existentes.
+
 O `@praxisui/table` declara authoring agentic através de um `ComponentAuthoringManifest` canônico. O manifesto é a fonte versionada para descoberta de alvos, operações e validações de configuração da tabela.
 
 - **Component ID:** `praxis-table`
@@ -1814,6 +1848,20 @@ actions: {
         id: 'open-detail',
         label: 'Abrir detalhe',
         action: 'navigation.openRoute',
+        effects: [
+          {
+            kind: 'global-action',
+            globalAction: {
+              actionId: 'navigation.openRoute',
+              payload: {
+                path: '/clientes/detalhe',
+                query: {
+                  id: '${row.id}',
+                },
+              },
+            },
+          },
+        ],
         globalAction: {
           actionId: 'navigation.openRoute',
           payload: {
@@ -1831,3 +1879,24 @@ actions: {
 
 O runtime da tabela resolve templates como `${row.id}` antes de executar a
 global action, o que permite reutilizar o mesmo contrato em `list` e `table`.
+Para configuracoes novas, `effects[].kind = 'global-action'` e o envelope
+canonico alinhado a `PraxisRuntimeGlobalActionEffect`; `globalAction` plano
+continua aceito como fallback de compatibilidade.
+O editor de acoes usa o mesmo adapter interno para toolbar, row e bulk actions:
+ao escolher novamente a mesma global action, ele preserva `payload` estruturado
+ou `payloadExpr` existente; ao trocar o `actionId`, ele descarta o payload antigo
+para evitar executar parametros de outra acao.
+
+As acoes por linha tambem usam Json Logic canonico para `visibleWhen` e
+`disabledWhen`. O editor de acoes preserva esses objetos no fluxo
+abrir -> aplicar/salvar -> reabrir, por exemplo:
+
+```ts
+{
+  id: 'edit-active',
+  label: 'Editar',
+  action: 'edit',
+  visibleWhen: { '===': [{ var: 'status' }, 'Ativo'] },
+  disabledWhen: { '===': [{ var: 'status' }, 'Bloqueado'] },
+}
+```

package/fesm2022/{praxisui-table-table-agentic-authoring-turn-flow-tu7jtTwV.mjs → praxisui-table-table-agentic-authoring-turn-flow-DRuE55Mi.mjs}

@@ -26,6 +26,9 @@ class TableAgenticAuthoringTurnFlow {
             ?.map((field) => this.toAiJsonObject(field))
             .filter((field) => Object.keys(field).length > 0);
         const contextHints = this.optionalJsonObject(this.adapter.getAuthoringContext?.());
+        if (this.shouldRouteToGovernedDecision(prompt, contextHints)) {
+            return this.toGovernedDecisionHandoff(prompt, request);
+        }
         const response = await firstValueFrom(this.aiApi.getPatch({
             componentId,
             componentType,
@@ -173,9 +176,26 @@ class TableAgenticAuthoringTurnFlow {
     }
     compileAdapterResponse(response) {
         const compiled = this.adapter.compileAiResponse?.(response);
+        if (!compiled && response.patch && Object.keys(response.patch).length > 0) {
+            return {
+                type: 'error',
+                message: 'A tabela exige componentEditPlan validado pelo manifesto antes de gerar patch local.',
+                warnings: [
+                    'free-table-patch-rejected',
+                    'Use componentEditPlan validado contra PRAXIS_TABLE_AUTHORING_MANIFEST.',
+                ],
+            };
+        }
         if (!compiled) {
             return response;
         }
+        if (compiled.type === 'error') {
+            return {
+                type: 'error',
+                message: compiled.message || 'O componentEditPlan da tabela nao passou na validacao de capacidades.',
+                warnings: compiled.warnings,
+            };
+        }
         const warnings = [
             ...(response.warnings ?? []),
             ...(compiled.warnings ?? []),
@@ -183,6 +203,7 @@ class TableAgenticAuthoringTurnFlow {
         return {
             ...response,
             ...compiled,
+            patch: compiled.patch,
             warnings: warnings.length ? warnings : undefined,
         };
     }
@@ -251,6 +272,85 @@ class TableAgenticAuthoringTurnFlow {
             ...(rowCount !== undefined ? { rowCount } : {}),
         };
     }
+    shouldRouteToGovernedDecision(prompt, contextHints) {
+        const normalized = prompt.normalize('NFD').replace(/[\u0300-\u036f]/g, '').toLowerCase();
+        const recommendedFlow = this.toRecord(contextHints?.['domainCatalog'])?.['recommendedAuthoringFlow'];
+        if (recommendedFlow === 'shared_rule_authoring')
+            return true;
+        return [
+            'regra',
+            'politica',
+            'policy',
+            'compliance',
+            'lgpd',
+            'privacidade',
+            'aprovacao',
+            'aprovar',
+            'publicar',
+            'materializar',
+            'enforcement',
+            'validacao de negocio',
+            'validar negocio',
+            'elegibilidade',
+            'permissao',
+            'acesso',
+        ].some((term) => normalized.includes(term));
+    }
+    toGovernedDecisionHandoff(prompt, request) {
+        const message = 'Esse pedido parece alterar uma decisao de negocio compartilhada. A tabela pode ajudar a descrever o alvo, mas a regra deve seguir pelo fluxo governado de domain-rules antes de qualquer materializacao runtime.';
+        return {
+            state: 'clarification',
+            phase: 'clarify',
+            sessionId: request.sessionId,
+            assistantMessage: message,
+            statusText: 'Handoff governado necessario.',
+            canApply: false,
+            quickReplies: [
+                {
+                    id: 'shared-rule-handoff',
+                    label: 'Continuar como regra governada',
+                    prompt,
+                    kind: 'shared-rule-handoff',
+                    description: 'Criar intake de domain-rules em vez de aplicar patch local na tabela.',
+                    icon: 'rule',
+                    tone: 'warning',
+                    contextHints: {
+                        flowId: 'shared_rule_authoring',
+                        source: 'praxis-table',
+                        recommendedAction: 'domain-rules/intake',
+                    },
+                },
+            ],
+            clarificationQuestions: [
+                {
+                    id: 'table-governed-rule-confirmation',
+                    type: 'confirm',
+                    label: 'Deseja continuar pelo fluxo governado de regras compartilhadas?',
+                    description: 'Esse caminho permite intake, simulacao, aprovacao/publicacao, materializacao e validacao de enforcement.',
+                    required: true,
+                    options: [
+                        {
+                            id: 'shared-rule-handoff',
+                            label: 'Sim, continuar governado',
+                            value: prompt,
+                            description: 'Nao aplicar como patch local da tabela.',
+                            contextHints: {
+                                flowId: 'shared_rule_authoring',
+                                source: 'praxis-table',
+                            },
+                        },
+                    ],
+                },
+            ],
+            diagnostics: {
+                governedDecisionHandoff: {
+                    flowId: 'shared_rule_authoring',
+                    sourcePrompt: prompt,
+                    sourceComponent: 'praxis-table',
+                },
+            },
+        };
+    }
     optionalJsonObject(value) {
         if (value === undefined || value === null) {
             return undefined;