@praxisui/manual-form 9.0.0-beta.1 → 9.0.0-beta.2

package/README.md

@@ -1,7 +1,7 @@
 ---
 title: "Manual Form"
 slug: "manual-form-overview"
-description: "Visao geral do @praxisui/manual-form com formularios declarativos, autodeteccao de campos, autosave, persistencia e hot update de metadata."
+description: "Public npm documentation for @praxisui/manual-form: declarative HTML forms with Praxis field metadata, autosave, persistence and metadata editor bridge."
 doc_type: "reference"
 document_kind: "component-overview"
 component: "manual-form"
@@ -24,7 +24,7 @@ icon: "file-pen"
 toc: true
 sidebar: true
 search_boost: 0.95
-reading_time: 14
+reading_time: 5
 estimated_setup_time: 20
 version: "1.0"
 related_docs:
@@ -38,492 +38,123 @@ keywords:
   - "manual form toolkit"
   - "form autosave"
   - "field metadata bridge"
-last_updated: "2026-03-07"
+last_updated: "2026-06-16"
 ---
 
-# Manual Form Toolkit
+# @praxisui/manual-form
 
-Biblioteca voltada a formularios declarativos baseados em componentes `pdx-*`, com suporte a persistencia, autodeteccao de campos e ponte com editores de metadata.
+`@praxisui/manual-form` lets a host write forms in Angular templates with `pdx-*` fields while still using Praxis metadata, autosave, persisted drafts, runtime field editing and the metadata editor bridge.
 
-## Documentation
+Use it when the host must own the HTML layout. Prefer `@praxisui/dynamic-form` when the whole screen should be driven by JSON metadata.
 
-- Documentação oficial: https://praxisui.dev
-- Aplicação de referência: https://github.com/codexrodrigues/praxis-ui-quickstart
-- Indicado para: equipes que precisam montar formularios Praxis manualmente sem perder consistencia, autosave e governanca
+## Install
 
-## When to use
+```bash
+npm i @praxisui/manual-form@latest
+```
 
-- Declarar formularios manualmente com componentes `pdx-*` sem abrir mao de infraestrutura
-- Adicionar autosave, persistencia e hot update de metadata ao fluxo do host
-- Reduzir o atrito entre formularios manuais e o restante do ecossistema Praxis UI
+Peer dependencies:
 
-## Instalação
+- `@angular/common`, `@angular/core`, `@angular/forms`, `@angular/router`, `@angular/cdk`, `@angular/material` `^21.0.0`
+- `@praxisui/core`, `@praxisui/dynamic-fields`, `@praxisui/settings-panel`, `@praxisui/metadata-editor`, `@praxisui/ai` `^9.0.0-beta.1`
+- `rxjs` `~7.8.0`
 
-```bash
-npm install @praxisui/manual-form@latest
-```
+## Recommended Typed Host
 
-## Minimal standalone host
+Apply `[formGroup]` directly on `<praxis-manual-form>`. This lets Angular Language Service validate `formControlName` while the Praxis container detects fields and manages metadata.
 
 ```ts
-import { Component } from '@angular/core';
-import { ReactiveFormsModule } from '@angular/forms';
+import { Component, inject } from '@angular/core';
+import { FormBuilder, ReactiveFormsModule, Validators } from '@angular/forms';
 import { ManualFormComponent } from '@praxisui/manual-form';
 
 @Component({
-  selector: 'app-manual-form-host',
+  selector: 'app-job-form',
   standalone: true,
   imports: [ReactiveFormsModule, ManualFormComponent],
   template: `
-    <praxis-manual-form formId="cargo" formTitle="Cargo">
-      <!-- Declare pdx-* fields owned by @praxisui/dynamic-fields here. -->
-    </praxis-manual-form>
-  `,
-})
-export class ManualFormHostComponent {}
-```
-
-Peers necessários (instale no app host):
-- `@angular/core` `^20.1.0`, `@angular/common` `^20.1.0`
-- `@praxisui/core` (ConfigStorage, GenericCrudService, ícones)
-- `@praxisui/dynamic-fields` (componentes de campo `pdx-*`)
-- `@praxisui/settings-panel` (integração com painel de configurações)
-- `@praxisui/metadata-editor` (edição visual de campos, opcional)
-
-## Problema
-
-Montar formulários Praxis manualmente (usando `<pdx-*>`) exigia montar `FormConfig`, `FormGroup`, persistência e metadados manualmente. Isso gerava atrito para hosts e dificultava a evolução.
-
-## Solução
-
-Criamos a biblioteca `@praxisui/manual-form` com:
-
-- **ManualFormComponent**: container que detecta campos, infere `FieldMetadata`, cria o `FormGroup`, mantém hot update e persiste via `ManualFormInstance`. Aceita inputs `formId`, `formTitle`, `actions`, `enableAutoSave` etc.
-- **ManualFormInstanceFactory**: runtime que cuida da persistência (`createManualFormSeed`, `saveDraft`, `resetToSeed`).
-- **ManualFormHeader/Actions**: componentes auxiliares para título/descritivo e ações (`submit/cancel/reset/custom`).
-- **ManualFieldMetadataBridgeService**: integra com o `@praxisui/metadata-editor`, aplica patches e garante persistência via `ManualFormInstance`.
-
-O exemplo `/cargos/manual-form` demonstra uso declarativo:
-
-```html
-<praxis-manual-form formId="cargo">
-  <pdx-text-input formControlName="nome" label="Nome" required></pdx-text-input>
-  <pdx-material-currency formControlName="salario" label="Salário"></pdx-material-currency>
-</praxis-manual-form>
-```
-
-### Padrão didático para exemplos renderizados
-
-Para páginas de documentação que precisam mostrar o componente antes de blocos longos de texto,
-use o wrapper `praxis-manual-form-doc-example`. Ele já entrega:
-
-- Banner curto com foco no exemplo live.
-- Tabs para alternar entre `Live`, `Template`, `TS` e `Config`.
-- Toggle de modo de customização (liga/desliga) com evento.
-- Botão de cópia do snippet ativo.
-- Callouts opcionais de `IMPORTANTE`, `NOTA` e `DICA`.
-
-```html
-<praxis-manual-form-doc-example
-  title="Cadastro de cargo"
-  subtitle="Preview primeiro, explicações depois."
-  level="Intermediario"
-  bannerTitle="Veja o componente em ação"
-  bannerDescription="Explore o live e abra código apenas quando necessário."
-  [templateCode]="templateSnippet"
-  [tsCode]="tsSnippet"
-  [configCode]="configSnippet"
-  [customizationEnabled]="editMode()"
-  (customizationEnabledChange)="editMode.set($event)"
-  important="Persista o draft no submit."
-  note="A aba Live abre por padrão."
-  tip="Use a aba Config para explicar contratos JSON."
->
-  <div exampleLive>
     <praxis-manual-form
       [formGroup]="form"
-      formId="cargo-manual-form"
-      [enableCustomization]="editMode()"
+      formId="job-form"
+      formTitle="Job"
+      [usePathNames]="true"
+      [enableCustomization]="editMode"
+      (submitted)="onSubmit($event.value)"
     >
-      <pdx-text-input formControlName="nome" label="Nome"></pdx-text-input>
+      <pdx-text-input formControlName="name" label="Name" pdxManualEdit="name" />
+
+      <div formGroupName="salary">
+        <pdx-material-currency
+          formControlName="amount"
+          label="Salary"
+          pdxManualEdit="salary.amount"
+        />
+      </div>
     </praxis-manual-form>
-  </div>
-
-  <div exampleDiagram>
-    <!-- Mermaid, SVG ou fluxo simplificado -->
-  </div>
-</praxis-manual-form-doc-example>
-```
-
-Também existe um showcase pronto para consumo direto:
-
-```html
-<praxis-manual-form-doc-example-showcase></praxis-manual-form-doc-example-showcase>
-```
-
-Esse showcase já inclui providers locais de `API_URL` e `ASYNC_CONFIG_STORAGE`, evitando erro de injeção em páginas de documentação.
-
-### Diagrama de funcionamento (alto nível)
-
-```mermaid
-flowchart LR
-  Host[Template com <pdx-*>] --> ManualForm[praxis-manual-form]
-  ManualForm --> Detect[Detecta campos]
-  Detect --> Meta[Infere FieldMetadata]
-  Meta --> Group[Cria/Adota FormGroup]
-  Group --> Render[Renderiza campos + validações]
-  ManualForm --> Instance[ManualFormInstance]
-  Instance --> Storage[ConfigStorage]
-  ManualForm -->|editMode| Editor[Metadata Editor]
-  Editor --> Patch[Aplica patch]
-  Patch --> Instance
-  Instance --> Persist[saveDraft / resetToSeed]
-```
-
-### Editor de metadados integrado
-
-Use o `ManualFieldMetadataBridgeService` para abrir o editor visual a partir de qualquer campo detectado pelo container. O serviço carrega o módulo sob demanda, aplica o patch retornado e chama `saveDraft()` para persistir as alterações no runtime.
-
-```ts
-@Component({
-  /* ... */
+  `,
 })
-export class CargoManualFormComponent {
-  @ViewChild(ManualFormComponent) manualForm?: ManualFormComponent;
-
-  constructor(private readonly metadataBridge: ManualFieldMetadataBridgeService) {}
-
-  openFieldEditor(fieldName: string): void {
-    const instance = this.manualForm?.instance;
-    if (!instance) {
-      return;
-    }
-    void this.metadataBridge.openEditor(instance, fieldName);
-  }
-}
-```
-
-### Toolbar de campo (modo de edicao)
-
-Quando `enableCustomization` estiver ativo, o manual-form exibe uma toolbar flutuante ao clicar
-no campo. Ela permite alternar `required`, `readOnly`, `hidden` e `disabled`, e abrir o editor
-completo de metadados.
-
-Atalhos de teclado (quando o campo esta focado):
-- `F2` ou `Alt+F10` abre a toolbar e move o foco para o primeiro botao.
-- `ESC` fecha a toolbar.
-
-Observacao: se um componente de campo interromper o clique (stopPropagation), a toolbar nao
-abrira via mouse. Use os atalhos de teclado ou evite bloquear o click no host do campo.
-
-Token de z-index:
-- `--pdx-manual-toolbar-z` (default: `2001`).
-Classe de overlay (para temas corporativos):
-- `.pdx-manual-toolbar-panel` (aplicada no CDK Overlay para customizacoes).
-
-## Motivações
-
-- DX coerente para formulários manuais (sem JSON).
-- Compatibilidade com o ecossistema (metadados, persistência, metadata editor).
-- Facilita adoção por hosts sem precisar do builder completo.
-
-## Estado atual
-
-- Container autodetecta campos (`selector`/`constructor → FieldControlType`), infere `label`, `validators.required`.
-- Persistência automática (`ManualFormInstance`/`ConfigStorage`).
-- Header/Ações padrões com `FormActionsLayout` (normalizado por `DEFAULT_ACTIONS`).
-- Seeds usam `ensureIds`.
-- Autosave opcional com debounce configurável (`enableAutoSave` + `autoSaveDebounceMs`).
-
-## Próximos passos
-
-1. Enriquecer inferência (opções, limites numéricos, etc.).
-2. Permitir layout personalizado via `@Input() sections` ou `layoutConfig`.
-3. Expandir testes unitários (detecção de campos, persistência, normalização de ações, nested paths).
-4. Documentar API pública com exemplos (README + docs).
-5. Adicionar feedbacks visuais pós-edição (notificações, toasts). 
-
-## Notas para evolução
-
-- Continue a trabalhar em `projects/praxis-manual-form` e atualize demos (ex. `/src/app/features/cargo-manual-form`).
-- Ao rodar `ng-packagr`, confirme que libs referenciadas (`@praxisui/core`, `@praxisui/dynamic-fields`) estão construídas ou apontam para `dist/`.
-- Respeite contratos de `FieldMetadata` e use helpers (`ensureIds`, `deepClone`).
-- Atenção a inputs obrigatórios (alguns componentes exigem `metadata`, `readonlyMode`, etc.).
-- Prefira inline styles para evitar warnings de arquivo ausente.
-
-Essa base permite que hosts manualmente criem formulários com componentes Praxis, mantendo compatibilidade com o restante do ecossistema (persistência, metadados e editor). 
-
-## Padrão corporativo recomendado
-
-- Host tipado: o host deve criar um `FormGroup` tipado e passá‑lo via `[formGroup]`. O container adota esse grupo, aplica metadados/validators e evita interceptações internas. Isso habilita o Angular Language Service a validar `formControlName` e melhora a DX.
-- Modo dinâmico: opção para PoCs e exemplos rápidos; veja os detalhes na seção “Guia rápido”.
-
-## Configurações avançadas
-
-- `@Input() usePathNames: boolean` (padrão: `false`)
-  - Quando habilitado, usa `FormControlName.path` (segmentos unidos por `.`) como `FieldMetadata.name`. Requer suporte a grupos aninhados — já implementado em `DynamicFormService`.
-- Mapeamentos de inferência via DI
-  - `MANUAL_FORM_SELECTOR_TO_CONTROL_TYPE` e `MANUAL_FORM_CONSTRUCTOR_TO_CONTROL_TYPE` permitem sobrescrever o mapa padrão de seletores/constructors → `FieldControlType`.
-- Autosave
-  - `@Input() enableAutoSave: boolean` (padrão: `true`) e `@Input() autoSaveDebounceMs: number` (padrão: `800`).
-
-### API pública adicional
-
-- `ManualFormInstance.metadataChanges()`
-  - Emite sempre que o mapa de `FieldMetadata` é atualizado no runtime.
-  - Timing: após `patchFieldMetadata()`, `replaceConfig()`, `resetToSeed()` e cargas de config persistida.
-
-## SSR (AsyncConfigStorage sem localStorage)
-
-Em SSR, `localStorage` não existe. Como `praxis-manual-form` depende do token `ASYNC_CONFIG_STORAGE`, você pode prover uma implementação segura no servidor (ex.: in‑memory) e manter `LocalStorageAsyncAdapter` no browser.
-
-Exemplo (Angular com `app.config.server.ts`):
-
-```ts
-// app.config.server.ts
-import { ApplicationConfig, PLATFORM_ID, inject, isPlatformServer } from '@angular/core';
-import { ASYNC_CONFIG_STORAGE, LocalStorageAsyncAdapter, type AsyncConfigStorage } from '@praxisui/core';
-import { EMPTY, of } from 'rxjs';
-
-class MemoryAsyncStorage implements AsyncConfigStorage {
-  private readonly map = new Map<string, any>();
-  loadConfig<T>(key: string) { return of((this.map.get(key) as T) ?? null); }
-  saveConfig<T>(key: string, config: T) { this.map.set(key, config); return EMPTY; }
-  clearConfig(key: string) { this.map.delete(key); return EMPTY; }
-}
-
-export const appConfig: ApplicationConfig = {
-  providers: [
-    {
-      provide: ASYNC_CONFIG_STORAGE,
-      useFactory: () => isPlatformServer(inject(PLATFORM_ID))
-        ? new MemoryAsyncStorage()
-        : inject(LocalStorageAsyncAdapter),
-    },
-  ],
-};
-```
-
-Alternativas no servidor: usar cookies, cache distribuído (ex.: Redis) ou persistir por sessão do usuário. Basta implementar a interface `AsyncConfigStorage`.
-
-### Exemplo (nested form)
-
-```html
-<form [formGroup]="form">
-  <praxis-manual-form formId="nested" [usePathNames]="true">
-    <div formGroupName="endereco">
-      <pdx-text-input formControlName="logradouro" label="Logradouro"></pdx-text-input>
-      <pdx-text-input formControlName="numero" label="Número"></pdx-text-input>
-    </div>
-  </praxis-manual-form>
-</form>
-```
-
-Com `usePathNames=true`, os metadados serão gerados com nomes `endereco.logradouro` e `endereco.numero`, mantendo o `FormGroup` aninhado do host.
-
-## Quando usar (e quando não)
-
-Use esta biblioteca quando:
-- Você quer controlar o layout via HTML, reaproveitando os componentes Praxis.
-- Prefere começar simples e evoluir metadados gradualmente (inferência + editor visual opcional).
-- Precisa integrar com persistência de rascunhos e editar propriedades de campos em runtime.
-
-Prefira o formulário totalmente dinâmico (JSON com `@praxisui/dynamic-form`) quando:
-- O layout deve ser 100% dirigido por metadados/JSON (sem HTML manual).
-- É necessário trocar telas apenas alterando seeds/backends.
-- Precisa de recursos avançados do motor dinâmico (regras, seções condicionais, layouts declarativos complexos).
-
-## Guia rápido (host tipado)
-
-```ts
-// component.ts
-@Component({ /* … */ })
-export class MinhaPagina {
+export class JobFormComponent {
   private readonly fb = inject(FormBuilder);
+  editMode = false;
+
   readonly form = this.fb.group({
-    nome: this.fb.control('', { nonNullable: true, validators: [Validators.required] }),
-    endereco: this.fb.group({ logradouro: this.fb.control('', { nonNullable: true }) }),
+    name: this.fb.control('', { nonNullable: true, validators: [Validators.required] }),
+    salary: this.fb.group({
+      amount: this.fb.control<number | null>(null),
+    }),
   });
-}
-```
-
-```html
-<praxis-manual-form
-  [formGroup]="form"
-  formId="meu-form"
-  [usePathNames]="true"
-  formTitle="Cadastro"
-  (submitted)="onSubmit($event)"
->
-  <pdx-text-input formControlName="nome" label="Nome"></pdx-text-input>
-  <div formGroupName="endereco">
-    <pdx-text-input formControlName="logradouro" label="Logradouro"></pdx-text-input>
-  </div>
-</praxis-manual-form>
-```
-
-Observações importantes:
-- Aplique `[formGroup]` diretamente no seletor `<praxis-manual-form>` (no host).
-- Evite envolver o componente com um `<form [formGroup]>` externo; não há necessidade e pode causar forms aninhados.
-
-Modo dinâmico (sem host tipado):
-- Quando nenhum `[formGroup]` é informado no host, o container renderiza internamente um `<form [formGroup]="formGroup">` para atender o Angular Forms e evitar o erro NG01050.
-- Isso dispensa qualquer “shim” externo para os exemplos dinâmicos.
-
-## API do ManualFormComponent (resumo)
 
-- Inputs (sinais):
-  - `formId: string` (obrigatório)
-  - `formTitle?: string`, `formDescription?: string`
-  - `actions?: FormActionsLayout | null`
-  - `showHeader = true`, `showActions = true`
-  - `enableAutoSave = true`, `autoSaveDebounceMs = 800`
-  - `enableCustomization = false` (habilita ações de customização — ex.: abrir editor por duplo clique)
-  - `persistenceOptions?: { namespace?, tenantId?, profileId?, locale? }`
-  - `usePathNames = false` (usa `FormControlName.path` como nome do campo)
-- Outputs (sinais):
-  - `submitted({ value, instance })`, `saved(instance)`, `reset(instance)`
-  - `metadataChange(FormConfig)`
-
-- Métodos públicos:
-  - `tryOpenFieldEditor(fieldName: string)`: tenta abrir o editor do campo, respeitando `enableCustomization` (no‑op quando `false`).
-
-## Contrato agentic de authoring
-
-`PRAXIS_MANUAL_FORM_AUTHORING_MANIFEST` e o contrato AI executavel do pacote.
-
-O manifesto governa a orquestracao do formulario manual:
-
-- `manualField.add`
-- `manualField.remove`
-- `manualField.label.set`
-- `layout.configure`
-- `toolbar.configure`
-- `autosave.enabled.set`
-- `submitBehavior.set`
-- `metadataBridge.configure`
-
-Regras de fronteira:
-
-- `ManualFormInstance` e a superficie runtime do pacote: config, mapa de metadata, `FormGroup` e persistencia devem permanecer coerentes
-- as operacoes escrevem nos paths reais do runtime (`currentConfig`, `currentFieldMetadata`, `form`, inputs como `enableCustomization`, `enableAutoSave`, `autoSaveDebounceMs`, `persistenceOptions`, e outputs como `submitted`, `saved`, `resetEvent`)
-- IDs de campo manual sao nomes estaveis de campo, nunca indice de array
-- remocao de campo exige confirmacao explicita
-- autosave deve declarar debounce seguro e chave de persistencia deterministica
-- toolbar de campo e metadata bridge sao entry points de runtime controlados por `enableCustomization`; nao existe objeto persistido `toolbar.*` ou `metadataBridge.*`
-- edicoes profundas de `FieldMetadata` sao delegadas ao `@praxisui/metadata-editor`
-- authoring avancado de `FormConfig` pertence ao `@praxisui/dynamic-form`
-
-## Header e Actions
-
-- `<praxis-manual-form-header>`: recebe `instance`, `title`, `description`, `saveLabel`, `resetLabel` e emite `save/reset`.
-- Quando `enableCustomization` está ativo no container, o header exibe um botão “Editar formulário” que emite `editForm`; o container trata esse evento chamando `openFormEditor()`.
-- `<praxis-manual-form-actions>`: recebe `actions: FormActionsLayout`, emite `actionClick` e aceita `trackByFn` opcional para listas grandes.
-
-## Editor de Metadados (visual)
-
-```ts
-@ViewChild(ManualFormComponent) manual?: ManualFormComponent;
-constructor(private readonly bridge: ManualFieldMetadataBridgeService) {}
-openEditor(fieldName: string) {
-  const inst = this.manual?.instance; if (!inst) return;
-  this.bridge.openEditor(inst, fieldName).catch(console.error);
+  onSubmit(value: unknown): void {
+    console.log(value);
+  }
 }
 ```
 
-Integração com Settings Panel: o `ManualFormComponent` utiliza `SettingsPanelService` para abrir o editor do formulário (lista de campos e flags) quando `enableCustomization` está ativo. É possível abrir programaticamente via `manualForm.openFormEditor()`.
-
-### Duplo clique com modo de edição
+If no host `FormGroup` is provided, the container creates an internal dynamic group for quick examples and prototypes. Use typed host forms for production screens.
 
-Para espelhar o comportamento das demais libs (permitir edição apenas quando o modo de edição está ativo), use o input `enableCustomization` no container e a diretiva `pdxManualEdit` nos campos:
+## Main Inputs And Outputs
 
-```html
-<praxis-manual-form formId="cargo" [enableCustomization]="custom.enabled()">
-  <pdx-text-input formControlName="nome" label="Nome" pdxManualEdit="nome"></pdx-text-input>
-  <pdx-material-currency formControlName="salario" label="Salário" pdxManualEdit="salario"></pdx-material-currency>
-</praxis-manual-form>
-```
+- `formId: string`: required stable id for persistence.
+- `formTitle`, `formDescription`: optional header copy.
+- `actions?: FormActionsLayout`: submit/cancel/reset/custom action layout.
+- `showHeader`, `showActions`: visibility flags.
+- `enableAutoSave`, `autoSaveDebounceMs`: draft persistence controls.
+- `componentInstanceId?: string`: disambiguates repeated instances.
+- `enableCustomization: boolean`: enables toolbar, form editor and semantic assistant affordances.
+- `persistenceOptions?: ManualFormPersistenceOptions`: namespace, tenant, profile and locale scope.
+- `usePathNames: boolean`: uses `FormControlName.path` such as `address.street` as `FieldMetadata.name`.
+- `submitted`, `saved`, `reset`, `metadataChange`: public lifecycle outputs.
 
-A diretiva chama `manualForm.tryOpenFieldEditor(fieldName)` e respeita `enableCustomization`, de modo que o duplo clique só abre o editor quando a edição está ligada.
+## Runtime Model
 
-### Editor do Formulário (lista de campos)
+`ManualFormComponent` detects projected `pdx-*` fields, infers minimal `FieldMetadata`, creates or adopts the `FormGroup`, and exposes a `ManualFormInstance`. The instance manages `createManualFormSeed`, `saveDraft`, `resetToSeed`, runtime metadata patches and `metadataChanges()`.
 
-O `ManualFormComponent` expõe `openFormEditor()` para abrir um editor simples do formulário que lista todos os campos e permite alternar: visibilidade (mostrar/ocultar), obrigatório, somente leitura e desabilitado — facilitando encontrar campos ocultos e reexibi‑los, além de ajustes rápidos. O editor respeita `enableCustomization` e usa o `SettingsPanelService`.
+Autosave and metadata persistence use `ASYNC_CONFIG_STORAGE`. Provide a browser or server-safe implementation in the host; do not rely on `localStorage` during SSR.
 
-Exemplo de uso no host:
-
-```html
-<button *ngIf="custom.enabled()" type="button" (click)="manualForm?.openFormEditor()">Editar formulário</button>
-<praxis-manual-form #manualForm [formGroup]="form" formId="'cargo'" [enableCustomization]="custom.enabled()">
-  <!-- campos -->
-</praxis-manual-form>
-```
-
-#### O que o editor cobre (tabs)
-
-O editor do formulario (Settings Panel) expõe:
-- **Campos**: visibilidade, obrigatorio, somente leitura, desabilitado.
-- **Acoes**: layout da barra, botoes padrao e acoes customizadas.
-- **Mensagens**: feedbacks de sucesso/erro, loading e confirmacoes.
-- **Comportamento**: flags de UX (ex.: focusFirstError, scrollToErrors).
-- **Dicas**: textos auxiliares para modos de tela (i18n/UX).
-- **Hooks**: JSON com hooks de lifecycle (antes/depois de init/submit).
-- **Regras**: regras de layout/visibilidade (JSON).
-- **Cascatas**: dependencias entre campos via metadados.
-
-Obs.: a execucao de hooks/regras depende do host registrar os providers correspondentes.
-
-## Extensibilidade por DI
-
-- Customize a inferência de `FieldControlType` via tokens:
-  - `MANUAL_FORM_SELECTOR_TO_CONTROL_TYPE`
-  - `MANUAL_FORM_CONSTRUCTOR_TO_CONTROL_TYPE`
-
-## ManualFieldDirective
-
-```html
-<ng-container *praxisManualField="'nome'; praxisManualFieldInstance: manual.instance as ctx">
-  Label atual: {{ ctx?.label }}
-</ng-container>
-```
-
-## ManualFieldEditorOnDblclickDirective (`pdxManualEdit`)
-
-- Usa o duplo clique para abrir o editor do campo, respeitando `enableCustomization` do `ManualFormComponent`.
-- Apenas funciona quando aplicada a elementos dentro de `<praxis-manual-form>`.
-
-```html
-<praxis-manual-form formId="cargo" [enableCustomization]="custom.enabled()">
-  <pdx-text-input formControlName="nome" label="Nome" pdxManualEdit="nome"></pdx-text-input>
-</praxis-manual-form>
-```
+## Runtime Editing
 
-## Boas práticas
+When `enableCustomization` is true:
 
-- Preferir host tipado e `usePathNames=true` para nested forms.
-- Habilitar autosave com debounce adequado.
-- Evitar lógica pesada em templates; delegar inferências ao container.
-- No SSR, sempre prover `ASYNC_CONFIG_STORAGE` compatível (sem localStorage).
+- the field toolbar can toggle required, read-only, hidden and disabled state;
+- `pdxManualEdit="fieldName"` opens the field editor on double click;
+- `tryOpenFieldEditor(fieldName)` and `openFormEditor()` can be called programmatically;
+- `ManualFieldMetadataBridgeService` delegates deep field edits to `@praxisui/metadata-editor` and persists the resulting patch.
 
-## Licença
+The toolbar and metadata bridge are runtime entry points. They are not separate persisted `toolbar.*` or `metadataBridge.*` objects.
 
-Apache-2.0 — consulte `LICENSE` neste pacote ou no repositório raiz.
+## Authoring
 
-## Limitações
+`PRAXIS_MANUAL_FORM_AUTHORING_MANIFEST` governs AI/tooling operations for field add/remove, labels, layout, toolbar behavior, autosave, submit behavior and metadata bridge configuration. Advanced `FieldMetadata` editing belongs to `@praxisui/metadata-editor`; advanced `FormConfig` authoring belongs to `@praxisui/dynamic-form`.
 
-- Inferência automática é propositalmente minimalista (label, required, tipo básico). Propriedades avançadas exigem metadados explícitos/edição visual.
-- Layout é responsabilidade do host; não há reordenação automática por metadados.
-- Modo dinâmico sem `[formGroup]` não habilita validação estática de `formControlName` no IDE.
+Free JSON patches from AI flows are not the public authoring contract. Local apply must come from a manifest-backed `componentEditPlan`.
 
-## Notas adicionais
+## Public API Snapshot
 
-- Quando `enableCustomization` estiver ativo, o container abre o shell compartilhado `PraxisAiAssistantShellComponent` e registra sessao global minimizavel em vez de embutir o assistente legado.
-- O contexto do assistente e seguro e semantico: identidade do formulario, `formId`, contagem de campos/secoes/acoes, nomes de campos, referencia ao `PRAXIS_MANUAL_FORM_AUTHORING_MANIFEST` e hints de governanca.
-- Prompts de regra, politica, compliance, publicacao, materializacao ou enforcement seguem para handoff governado `domain-rules/intake` e nao sao aplicados como patch local do formulario.
-- Patches JSON livres vindos do backend sao rejeitados. O apply local permanece bloqueado ate existir `componentEditPlan` compilado e validado pelo manifesto canonico.
-- `componentInstanceId` ajuda a compor a chave de persistencia (com `formId` e `persistenceOptions`), evitando conflito entre instancias da mesma tela.
+Main exports include `ManualFormComponent`, `ManualFormHeaderComponent`, `ManualFormActionsComponent`, `ManualFormConfigEditorComponent`, `ManualFormInstance`, seed helpers, manual field directives, metadata bridge services, DI tokens, AI capabilities and `PRAXIS_MANUAL_FORM_AUTHORING_MANIFEST`.
 
-## Comparativo — Manual vs Dinâmico (JSON)
+## Official Links
 
-- Manual: controle máximo do HTML; evolui por metadados incrementais; ótimo para telas estáveis com design específico.
-- Dinâmico: telas dirigidas por JSON com alto poder de reconfiguração; ideal para múltiplas telas e variações rápidas sem alterar HTML.
+- Documentation: https://praxisui.dev/components/manual-form
+- Live demo: https://praxis-ui-4e602.web.app
+- Quickstart repository: https://github.com/codexrodrigues/praxis-ui-quickstart
+- Source and issues: https://github.com/codexrodrigues/praxis-ui-angular

package/package.json

@@ -1,19 +1,19 @@
 {
   "name": "@praxisui/manual-form",
-  "version": "9.0.0-beta.1",
+  "version": "9.0.0-beta.2",
   "description": "Manual form toolkit for Praxis UI: container, instance factory and editor bridge for @praxisui/* fields.",
   "peerDependencies": {
     "@angular/common": "^21.0.0",
     "@angular/core": "^21.0.0",
-    "@praxisui/core": "^9.0.0-beta.1",
-    "@praxisui/dynamic-fields": "^9.0.0-beta.1",
-    "@praxisui/settings-panel": "^9.0.0-beta.1",
-    "@praxisui/metadata-editor": "^9.0.0-beta.1",
+    "@praxisui/core": "^9.0.0-beta.2",
+    "@praxisui/dynamic-fields": "^9.0.0-beta.2",
+    "@praxisui/settings-panel": "^9.0.0-beta.2",
+    "@praxisui/metadata-editor": "^9.0.0-beta.2",
     "@angular/cdk": "^21.0.0",
     "@angular/forms": "^21.0.0",
     "@angular/material": "^21.0.0",
     "@angular/router": "^21.0.0",
-    "@praxisui/ai": "^9.0.0-beta.1",
+    "@praxisui/ai": "^9.0.0-beta.2",
     "rxjs": "~7.8.0"
   },
   "dependencies": {
@@ -25,7 +25,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/codexrodrigues/praxis-ui-angular"
+    "url": "git+https://github.com/codexrodrigues/praxis-ui-angular.git"
   },
   "homepage": "https://praxisui.dev",
   "bugs": {