@softize/opus 25.1.0 → 25.3.0

package/src/ui/docs/content/action-list.md

@@ -215,6 +215,37 @@ periods: [
 // presetRange('last7') → { from: 'YYYY-MM-DD', to: 'YYYY-MM-DD' } — o mesmo cálculo do pattern.
 ```
 
+## Agrupamento
+
+Declare `grouping.fields` quando uma dimensão fechada puder organizar a tabela sem mudar o recorte
+de negócio. Cada campo precisa ser um filtro `select` com opções `static` ou `dictionary`; texto,
+número, data e lookup não são dimensões de agrupamento. O filtro pode aceitar uma ou várias opções:
+cada consulta de grupo envia um único valor na forma declarada. A lista continua plana por padrão,
+e a pessoa escolhe **Agrupar por** em **Exibição**.
+
+```ts
+filters: {
+  status: {
+    label: 'Status',
+    type: 'select',
+    options: { kind: 'dictionary', ref: 'workspace.status' },
+  },
+},
+grouping: { fields: ['status'] },
+paginate: 'offset',
+```
+
+O Opus consulta a mesma `ListAction` uma vez para cada opção, aplicando o valor ao filtro e
+preservando busca, período, demais filtros e ordenação. Por isso, o handler precisa devolver
+`total` e a action precisa usar `paginate: 'offset'`: o cabeçalho recolhível apresenta a contagem
+autoritativa, e **Carregar mais** expande apenas aquele grupo. A soma aparece no rodapé, sem paginador
+global. O limite é de doze opções por dimensão. Se um dicionário não estiver disponível ou exceder
+esse limite, a dimensão não é oferecida em **Agrupar por**.
+
+O agrupamento pertence à tabela derivada. Views alternativas e o modo `children` continuam planos.
+`groupBy` integra `ActionListState`; `listStateToParams` o serializa como `group=<campo>`, e filtros
+aplicados à mesma dimensão restringem os grupos exibidos.
+
 ## Paginação e carregamento
 
 `ActionList` envia `limit`, definido por `pageSize`, e `page` no input. O handler aplica o recorte e
@@ -481,21 +512,23 @@ render(
 
 ## Declaração na ListAction
 
-| Chave     | O que declara                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
-| --------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `columns` | `{ key, label, type?, sortable?, fit?, hidden?, dateFormat?, dictionary?, empty? }` — a tabela. `hidden` nasce oculta e pode ser exibida pelo seletor de colunas; `dictionary` nomeia o dicionário do provider; `empty` dá o significado da ausência.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
-| `filters` | `{ [nome]: { label, type, options?, multiple?, presentation?, searchable?, allowEmpty?, placement?, section?, depends?, … } }` — a toolbar. `placement` classifica o controle como `inline`, `advanced` ou `external`; filtros avançados com `section` são agrupados no diálogo; `external` mantém estado e input, mas delega a apresentação ao consumidor. `presentation: 'toggle'` mostra todas as opções curtas de um `select` de escolha única em um `ToggleGroup`; sem a propriedade, o controle continua sendo `Select`. `searchable` habilita busca local em `select`; `allowEmpty: false` omite a opção vazia. `depends` desabilita/cascateia; options `kind: 'lookup'` busca em uma action. Valor aplicado entra no input com o mesmo nome. |
-| `text`    | `{ fields }` — liga a busca; convenção: param `q` no input. Ela aparece depois dos filtros inline e imediatamente antes do acesso aos filtros avançados. A busca participa da contagem de controles inline: com mais de um controle, a barra exibe as labels; quando ela é o único recorte, sua label é omitida.                                                                                                                                                                                                                                                                                                                                                                                                                                     |
-| `sort`    | `{ fields, default }` — ordenação inicial; header ordenável escreve `sort: 'chave:dir'`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
-| `periods` | `{ value, label, default? }[]` — o controle de período (presets + Personalizado com calendário); `default: true` marca o preset inicial, senão vale o primeiro; materializa em `from`/`to` no input.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| Chave      | O que declara                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+| ---------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `columns`  | `{ key, label, type?, sortable?, fit?, hidden?, dateFormat?, dictionary?, empty? }` — a tabela. `hidden` nasce oculta e pode ser exibida pelo seletor de colunas; `dictionary` nomeia o dicionário do provider; `empty` dá o significado da ausência.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| `filters`  | `{ [nome]: { label, type, options?, multiple?, presentation?, searchable?, allowEmpty?, placement?, section?, depends?, … } }` — a toolbar. `placement` classifica o controle como `inline`, `advanced` ou `external`; filtros avançados com `section` são agrupados no diálogo; `external` mantém estado e input, mas delega a apresentação ao consumidor. `presentation: 'toggle'` mostra todas as opções curtas de um `select` de escolha única em um `ToggleGroup`; sem a propriedade, o controle continua sendo `Select`. `searchable` habilita busca local em `select`; `allowEmpty: false` omite a opção vazia. `depends` desabilita/cascateia; options `kind: 'lookup'` busca em uma action. Valor aplicado entra no input com o mesmo nome. |
+| `text`     | `{ fields }` — liga a busca; convenção: param `q` no input. Ela aparece depois dos filtros inline e imediatamente antes do acesso aos filtros avançados. A busca participa da contagem de controles inline: com mais de um controle, a barra exibe as labels; quando ela é o único recorte, sua label é omitida.                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| `sort`     | `{ fields, default }` — ordenação inicial; header ordenável escreve `sort: 'chave:dir'`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| `periods`  | `{ value, label, default? }[]` — o controle de período (presets + Personalizado com calendário); `default: true` marca o preset inicial, senão vale o primeiro; materializa em `from`/`to` no input.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
+| `grouping` | `{ fields }` — dimensões fechadas disponíveis em **Agrupar por**. Cada nome referencia um filtro `select` com opções estáticas ou de dicionário. Não define agrupamento inicial.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
 
 ## useListAction
 
-Quando o layout não cabe no `ActionList`, `useListAction(action, input)` entrega o mesmo fetch
+Quando o layout não cabe no `ActionList`, `useListAction(action, input, options?)` entrega o mesmo fetch
 declarativo (`items`, `total`, `error`, `isLoading`, `isFetching`, `refetch`) sob o
 `QueryClientProvider`, e `presetRange(preset)` materializa os presets de período (`today`, `last7`,
 `thisMonth`…) em `{ from, to }` no formato `YYYY-MM-DD` — o mesmo cálculo que o pattern faz antes de
-chamar a action.
+chamar a action. `options.enabled` suspende a consulta enquanto for `false`; sem a opção, vale
+`true`.
 
 ## Propriedades de ActionList
 

package/src/ui/docs/content/actions.md

@@ -136,7 +136,7 @@ name, kind
   → public, requires, authorize, loads
   → handler
   → audit, confirm, invalidates, rateLimit, idempotency
-  → ai, automatable, internal
+  → ai, assistant, automatable, internal
 ```
 
 Campos específicos de um kind, como `fields`, `paginate`, `columns`, `filters`, `expand`,
@@ -179,6 +179,102 @@ A autorização é fechada por padrão: sem `public: true`, a action exige usuá
 `authorize`, exige também a permissão declarada. `automatable: true` permite que um
 [schedule](/docs/scheduler) execute a action como o sistema, sem abri-la a chamadores anônimos.
 
+## Declarar o assistente do recurso
+
+Um produto pode oferecer, além do chat geral, uma conversa sobre um recurso específico: um cliente,
+um relatório, um pedido. Essa conversa precisa ler o recurso com a permissão de quem conversa, seguir
+o procedimento próprio daquele tipo de recurso e entregar ao modelo só os dados necessários. Os três
+ficam declarados num lugar só: a action `view` que lê o recurso declara `assistant` e passa a ser a
+**action dona** daquele tipo de recurso.
+
+```ts
+export const customerViewContract = defineContract({
+  name: 'customer.view',
+  kind: 'view',
+  label: 'Ver cliente',
+  input: z.object({ id: z.string().uuid() }),
+  output: customerViewSchema,
+  personalData: true,
+  requires: 'customer.read',
+  authorize: (ctx) => ctx.can('customer.read'),
+  ai: true,
+  assistant: {
+    resource: 'customer',
+    skill: 'review-customer',
+    label: 'Assistente do cliente',
+    title: 'name',
+    context: ['kind', 'stage', 'sources', 'leads.totalCount', 'leads.latest.status'],
+  },
+})
+```
+
+| Campo | O que declara |
+| --- | --- |
+| `resource` | O tipo de recurso de que a action é dona, em camelCase. Cada tipo tem uma única action dona. |
+| `skill` | A chave do procedimento que a IA segue ao tratar do recurso, em minúsculas com hífen. O Opus não conhece o procedimento; o produto o mantém e confere que a chave existe. |
+| `label` | O nome do assistente para pessoas. Entra no inventário do `opus copy`. |
+| `title` | O caminho, na saída, do campo que nomeia o recurso. |
+| `context` | Os caminhos, na saída, dos campos que o host pode entregar ao modelo como dado do recurso. |
+| `maxContextChars` | Opcional. O teto do dado entregue, em caracteres de JSON: 4.000 por padrão, de 1.000 a 16.000. |
+
+A action dona precisa ser `view`, estar publicada para a IA (`ai`), declarar `personalData` e
+receber só `{ id }`: o `id`, do tipo texto, é o único campo obrigatório da entrada, e outros campos,
+se houver, têm valor padrão ou são opcionais. Os caminhos usam ponto para descer em objetos; um
+caminho que passa por uma lista vale para cada item, e um campo intermediário `null` aparece como
+`null`. Declare em `context` só o que orienta a conversa: o exemplo deixa fora contato, documento e
+endereço, e o nome já vai como `title`. Um caminho que termina num objeto ou numa lista leva tudo o
+que está abaixo dele, inclusive campos acrescentados depois à saída; para conferir num teste o que
+cada caminho alcança, use `assistantContextLeaves`, de `@softize/opus/assistant-schema`, sobre o
+schema de saída do manifest. O `title` precisa apontar para texto ou número.
+
+O `opus check` cobra a forma da declaração (regra `assistant-declaration`), o `opus gen` recusa
+`title`, caminho de `context` ou entrada que não conferem com os schemas, e o registro recusa duas
+actions donas do mesmo recurso. O manifest, `runtime.aiTools()` e o MCP (`com.softize.opus/assistant`
+em `_meta`) levam a declaração, e o manifest passa a mostrar também a publicação para a IA.
+
+### Ler o recurso pela action dona
+
+O recurso de um assistente é lido, e o acesso a ele é conferido, somente pela action dona.
+`runtime.readResource` executa a action com `{ id }` pelo mesmo `execute` de qualquer chamada; a
+autorização, a auditoria e a marca de dado pessoal são as da action:
+
+```ts
+const read = await runtime.readResource('customer', id, base, { context: true })
+if (!read.ok) return notFound() // o erro da action, com a categoria dela
+read.resource // { kind: 'customer', id, title: 'Maria Souza', label: 'Assistente do cliente', skill: 'review-customer' }
+read.context // { data, truncated, omitted, personalData: true }
+```
+
+Sem `{ context: true }`, a leitura devolve só o descritor, que basta para conferir o acesso e
+mostrar o nome. Um tipo sem action dona devolve `runtime.assistant_resource_unknown` sem executar
+nada. `runtime.assistants()` lista as declarações com a action dona de cada uma, para o produto
+montar rotas e telas sem lista paralela e para conferir, num teste, que cada `skill` existe no
+registro de procedimentos dele. O Opus não enxerga as rotas HTTP que o produto registra por conta
+própria: um teste do produto deve garantir que nenhuma rota confere acesso a recurso sem passar por
+uma action.
+
+### O dado que vai ao modelo
+
+`context.data` traz só os caminhos declarados, com a estrutura da saída. Quando o JSON passa do
+teto, o corte acontece por etapas, até caber, e fica registrado em `omitted`:
+
+1. sai o último item da maior lista, repetidamente;
+2. com as listas vazias, o texto mais longo é encurtado pela metade, até 200 caracteres;
+3. por fim, saem campos inteiros, do último declarado para o primeiro.
+
+Com qualquer corte, `truncated` vale `true`. O título fica fora do teto e é encurtado a 200
+caracteres. Um caminho que falta na saída em execução é omitido com o motivo `missing` e gera um
+aviso no log, sem falhar a leitura. Quem recebe a saída por outro canal, como o MCP, aplica a mesma
+projeção com `projectAssistantContext(assistant, output)`.
+
+Entregue o dado ao modelo como bloco delimitado, numa mensagem de dado, nunca no prompt de sistema.
+`resourceDataBlock`, de `@softize/opus/ai`, monta o bloco com o tipo, o id, o título, os dados e,
+quando houve corte ou ausência, `truncated` e `omitted`, e escapa dentro dos valores o que poderia
+fechar o delimitador. Quando o modelo chama a action dona como ferramenta, recebe a saída completa
+do contrato, como em qualquer chamada: a projeção governa só o que o host entrega por iniciativa
+própria. Cada execução de uma action com dado pessoal é uma exposição registrada, então reaproveite
+a leitura que já conferiu o acesso em vez de executar a action de novo só para obter o contexto.
+
 ## Prototipar com dados simulados
 
 Para desenhar a interface antes de o backend existir, rode o app em modo design. Nesse modo, toda

package/src/ui/docs/content/ai.md

@@ -86,8 +86,10 @@ const { text } = await ctx.ai!.run('Quais notas a Empresa X emitiu em junho?')
 usado na execução e na auditoria; `title` traz a `label` legível da action, quando existe;
 `description` vem de `ai.description` (ou da `description` da action) e `inputSchema`, do input.
 `metadata.dataProducts` lista os [Produtos de Dados](/docs/data-products) relacionados e
-`metadata.dataProductLabels` associa cada identificador ao seu nome legível. Esses metadados servem ao host: não entram no
-prompt e não concedem acesso.
+`metadata.dataProductLabels` associa cada identificador ao seu nome legível. Na action dona de um
+tipo de recurso, `metadata.assistant` traz o [assistente declarado](/docs/actions): o recurso, a
+chave do procedimento, o nome, o campo do título, os campos do dado ao modelo e o teto. Esses
+metadados servem ao host: não entram no prompt e não concedem acesso.
 
 O agente só executa nomes que `aiTools()` anunciou; uma chamada a outra action volta como erro
 para o modelo. Actions marcadas com `ai: { destructive: true }` ou `ai: { requiresConfirmation: true }`

package/src/ui/docs/content/cli.md

@@ -21,7 +21,8 @@ opus seed check       # bindings, dependências, ciclos e scripts paralelos de s
 ```
 
 `opus check` lê o código-fonte sem executá-lo e aplica regras em quatro grupos: actions
-(`action-name`, `kind`, `field-order`, `export`, `requires-sem-authorize`, `ignored-by-kind`), UI
+(`action-name`, `kind`, `field-order`, `export`, `requires-sem-authorize`, `ignored-by-kind` e
+`assistant-declaration`, que cobra a forma do [assistente do recurso](/docs/actions)), UI
 (`ui-structure`, `ui-structure-split`, `ui-semantic-api`, `removed-ui-token`, `unpaired-ui-surface`),
 [Produtos de Dados](/docs/data-products) (`data-product-export`, `-id`, `-duplicate`, `-version`,
 `-interfaces`, `-interface`, `-entities` e `-entity`, todas com o prefixo `data-product`) e

package/src/ui/docs/content/mcp.md

@@ -60,7 +60,9 @@ Quando a action declara o que faz com os dados, a tool traz também as anotaçõ
 `readOnlyHint` vem de `effect`. Numa action que escreve, `destructiveHint` vai sempre explícito, a
 partir de `ai.destructive`, porque o MCP trata a ausência numa escrita como destrutiva.
 Em `_meta`, `com.softize.opus/effect` repete o efeito e `com.softize.opus/personal-data` diz se a
-resposta contém dado pessoal. Veja [Actions](/docs/actions).
+resposta contém dado pessoal. Na action dona de um tipo de recurso, `com.softize.opus/assistant`
+traz o assistente declarado, para o host conhecê-lo pelo catálogo que já consulta e aplicar à saída
+a mesma projeção com `projectAssistantContext`. Veja [Actions](/docs/actions).
 
 `CallTool` recusa com erro qualquer nome fora dessa lista; os demais seguem por `runtime.execute`.
 A exposição declarada em `ai` decide o que o cliente MCP pode executar, e a autorização do contexto

package/src/ui/drivers/context.tsx

@@ -0,0 +1,50 @@
+import { createContext, useContext, useMemo, type ReactNode } from 'react'
+import type { ClientAdapter } from '../../core/index.ts'
+
+/**
+ * Dicionário estrutural pro resolvedor de opções: qualquer coisa com `options()`
+ * satisfaz o contrato sem este driver importar o driver de schema.
+ */
+export interface DictLike {
+  options(): Array<{ value: string; label: string; icon?: string }>
+}
+
+interface OpusContextValue {
+  client: ClientAdapter
+  dicts: Record<string, DictLike>
+}
+
+const OpusContext = createContext<OpusContextValue | null>(null)
+
+export interface OpusProviderProps {
+  client: ClientAdapter
+  /** Dicionários por ref usados por filtros e campos declarativos. */
+  dicts?: Record<string, DictLike>
+  children: ReactNode
+}
+
+export function OpusProvider({ client, dicts, children }: OpusProviderProps): ReactNode {
+  const value = useMemo<OpusContextValue>(() => ({ client, dicts: dicts ?? {} }), [client, dicts])
+  return <OpusContext.Provider value={value}>{children}</OpusContext.Provider>
+}
+
+/** Acesso interno ao adapter; não é reexportado por `@softize/opus/ui/react`. */
+export function useClient(hook: string): ClientAdapter {
+  const ctx = useContext(OpusContext)
+  if (ctx === null) {
+    throw new Error(
+      `${hook} foi chamado fora de um <OpusProvider> e não tem como executar a action. ` +
+        'Os hooks de action e os componentes que os usam, como ActionForm, ActionList e ActionView, ' +
+        'precisam de um <OpusProvider client={...}> acima deles na árvore. Envolva a aplicação no provider; ' +
+        'em testes e previews, envolva o componente renderizado.',
+    )
+  }
+  return ctx.client
+}
+
+const NO_DICTS: Record<string, DictLike> = {}
+
+/** Dicionários do provider; fora dele, o resolvedor usa os fallbacks do contrato. */
+export function useDicts(): Record<string, DictLike> {
+  return useContext(OpusContext)?.dicts ?? NO_DICTS
+}

package/src/ui/drivers/react.tsx

@@ -12,12 +12,9 @@
  */
 
 import {
-  createContext,
   useCallback,
-  useContext,
   useMemo,
   useState,
-  type ReactNode,
 } from 'react'
 import {
   useForm,
@@ -32,7 +29,6 @@ import type {
   ActionContract,
   ActionDef,
   ActionError,
-  ClientAdapter,
   FormContract,
   Paginated,
 } from '../../core/index.ts'
@@ -42,74 +38,16 @@ import {
   idleAction,
   idleLookup,
 } from '../index.ts'
+import { useClient } from './context.tsx'
+export {
+  OpusProvider,
+  useDicts,
+  type DictLike,
+  type OpusProviderProps,
+} from './context.tsx'
 import { zodErrorMapPtBr } from '../lib/zod-pt-br.ts'
 import { objectSchemaShape } from '../lib/object-schema.ts'
 
-// =============================================================================
-// Provider
-// =============================================================================
-
-/**
- * Dicionário estrutural pro resolvedor de `options: { kind: 'dictionary', ref }`:
- * qualquer coisa com `options()` → `{ value, label, icon? }`. O `DictType` do `t.dict`
- * satisfaz direto — sem este driver importar o driver de schema. A metadata opcional
- * continua sendo declarada pelo dicionário; o provider não inventa apresentação.
- */
-export interface DictLike {
-  options(): Array<{ value: string; label: string; icon?: string }>
-}
-
-interface OpusContextValue {
-  client: ClientAdapter
-  dicts: Record<string, DictLike>
-}
-
-const OpusContext = createContext<OpusContextValue | null>(null)
-
-export interface OpusProviderProps {
-  client: ClientAdapter
-  /** Dicionários por ref — resolvem `options: { kind: 'dictionary', ref }` de
-   *  filters/fields (ActionList/ActionForm). Campo de dict sem registro aqui ainda
-   *  resolve pelo fallback (a meta do `t.dict` viaja no schema do contrato). */
-  dicts?: Record<string, DictLike>
-  children: ReactNode
-}
-
-export function OpusProvider({
-  client,
-  dicts,
-  children,
-}: OpusProviderProps): ReactNode {
-  const value = useMemo<OpusContextValue>(() => ({ client, dicts: dicts ?? {} }), [client, dicts])
-  return <OpusContext.Provider value={value}>{children}</OpusContext.Provider>
-}
-
-/**
- * O adapter do provider. `hook` nomeia quem chamou, para a mensagem apontar o hook que a
- * pessoa vê no stack — muitas vezes chamado por dentro de ActionForm, ActionList ou
- * ActionView, e não diretamente pela tela.
- */
-function useClient(hook: string): ClientAdapter {
-  const ctx = useContext(OpusContext)
-  if (ctx === null) {
-    throw new Error(
-      `${hook} foi chamado fora de um <OpusProvider> e não tem como executar a action. ` +
-        'Os hooks de action e os componentes que os usam, como ActionForm, ActionList e ActionView, ' +
-        'precisam de um <OpusProvider client={...}> acima deles na árvore. Envolva a aplicação no provider; ' +
-        'em testes e previews, envolva o componente renderizado.',
-    )
-  }
-  return ctx.client
-}
-
-const NO_DICTS: Record<string, DictLike> = {}
-
-/** Dicts do provider. Default {} — inclusive fora do provider: o resolvedor cai
- *  nos fallbacks (estáticas do spec, meta do `t.dict`) sem exigir registry. */
-export function useDicts(): Record<string, DictLike> {
-  return useContext(OpusContext)?.dicts ?? NO_DICTS
-}
-
 // =============================================================================
 // useAction
 // =============================================================================
@@ -265,6 +203,7 @@ export interface UseListActionResult<TItem> {
 export function useListAction<TItem = unknown, TInput extends Record<string, unknown> = Record<string, unknown>>(
   action: { name: string; kind: 'list' },
   input?: TInput,
+  options?: { enabled?: boolean },
 ): UseListActionResult<TItem> {
   const client = useClient('useListAction')
 
@@ -278,6 +217,7 @@ export function useListAction<TItem = unknown, TInput extends Record<string, unk
     // Input mudou (filtro/página) → mantém os itens na tela enquanto busca: o
     // ActionList esmaece em vez de piscar skeleton. isPending = só o 1º load.
     placeholderData: keepPreviousData,
+    enabled: options?.enabled ?? true,
   })
 
   const refetch = useCallback(async () => {

package/src/ui/meta.ts

@@ -388,7 +388,7 @@ export const componentMeta = {
     name: "action-list",
     ancestry: "opus",
     whenToUse:
-      "Apresente uma coleção pesquisável a partir de uma ListAction. O contrato declara colunas, filtros, período e busca; ActionList coordena visualizações, paginação, seleção em lote e sincronização com a URL. A tabela derivada não cria moldura própria. Em uma página, envolva a lista com Surface para manter título e criação junto da coleção. Para um único recurso, use ActionView.",
+      "Apresente uma coleção pesquisável a partir de uma ListAction. O contrato declara colunas, filtros, período, busca e dimensões fechadas de agrupamento; ActionList coordena visualizações, paginação, seleção em lote e sincronização com a URL. A tabela derivada não cria moldura própria. Em uma página, envolva a lista com Surface para manter título e criação junto da coleção. Para um único recurso, use ActionView.",
   },
   "action-trigger": {
     name: "action-trigger",