@praxisui/manual-form 8.0.0-beta.3 → 8.0.0-beta.30

package/fesm2022/praxisui-manual-form.mjs

@@ -1,11 +1,11 @@
 import { ensureIds, DynamicFormService, ASYNC_CONFIG_STORAGE, RULE_PROPERTY_SCHEMA, deepMerge, resolveControlTypeAlias, FieldControlType, normalizeControlTypeKey, FormHooksRegistry, ComponentKeyService, FIELD_SELECTOR_REGISTRY_DISABLE_DEFAULTS, DEFAULT_FIELD_SELECTOR_CONTROL_TYPE_MAP, FieldSelectorRegistry, providePraxisI18n, PraxisI18nService, API_URL } from '@praxisui/core';
 import * as i0 from '@angular/core';
 import { inject, Optional, Inject, Injectable, input, output, ChangeDetectionStrategy, Component, Input, InjectionToken, isDevMode, EventEmitter, HostListener, ViewChild, Output, ChangeDetectorRef, DestroyRef, PLATFORM_ID, effect, ContentChildren, signal, computed, Directive } from '@angular/core';
-import { BehaviorSubject, debounceTime, fromEvent, of } from 'rxjs';
+import { BehaviorSubject, firstValueFrom, debounceTime, fromEvent, of } from 'rxjs';
 import { take } from 'rxjs/operators';
 import { CommonModule, isPlatformBrowser } from '@angular/common';
 import { ActivatedRoute } from '@angular/router';
-import { BaseAiAdapter, PraxisAiAssistantComponent } from '@praxisui/ai';
+import { BaseAiAdapter, shouldRoutePromptToGovernedDecision, AiBackendApiService, PraxisAssistantSessionRegistryService, PraxisAssistantTurnOrchestratorService, createPraxisAssistantViewportLayout, PraxisAiAssistantShellComponent } from '@praxisui/ai';
 import * as i1 from '@angular/forms';
 import { FormGroupDirective, FormGroup, FormControl, Validators, ReactiveFormsModule, FormControlName, ControlContainer, FormsModule } from '@angular/forms';
 import { takeUntilDestroyed } from '@angular/core/rxjs-interop';
@@ -576,7 +576,7 @@ const ENUMS = {
     headerAlign: ['start', 'center'],
     schemaType: ['response', 'request'],
     customizationSource: ['user', 'server', 'system'],
-    formRuleTargetType: ['field', 'section', 'action', 'row', 'column'],
+    formRuleTargetType: ['field', 'section', 'action', 'row', 'column', 'visualBlock'],
     formRuleContext: ['visibility', 'readOnly', 'style', 'validation', 'notification'],
     mode: ['create', 'edit', 'view'],
     schemaSource: ['resource', 'filter'],
@@ -1083,6 +1083,8 @@ const MANUAL_FORM_AI_CAPABILITIES = {
 class ManualFormAiAdapter extends BaseAiAdapter {
     host;
     componentName = 'Manual Form';
+    componentId = 'praxis-manual-form';
+    componentType = 'form';
     constructor(host) {
         super();
         this.host = host;
@@ -1105,6 +1107,48 @@ class ManualFormAiAdapter extends BaseAiAdapter {
             dirty: form?.dirty ?? false,
         };
     }
+    getDataProfile() {
+        const config = this.host.instance?.currentConfig;
+        return {
+            formId: this.safeFormId(),
+            sectionCount: config?.sections?.length ?? 0,
+            fieldCount: config?.fieldMetadata?.length ?? 0,
+            actionCount: [
+                config?.actions?.submit,
+                config?.actions?.cancel,
+                config?.actions?.reset,
+                ...(config?.actions?.custom ?? []),
+            ].filter(Boolean).length,
+            hasPersistence: !!this.host.persistenceOptions(),
+            autoSave: !!this.host.enableAutoSave(),
+        };
+    }
+    getSchemaFields() {
+        return (this.host.instance?.currentConfig?.fieldMetadata ?? [])
+            .map((field) => ({
+            name: field.name,
+            label: field.label,
+            type: field.type,
+            required: !!(field.required || field.validators?.required),
+            readonly: !!field.readonly,
+            hidden: !!field.hidden,
+        }))
+            .filter((field) => typeof field.name === 'string' && !!field.name.trim());
+    }
+    getAuthoringContext() {
+        return {
+            authoringManifestRef: 'PRAXIS_MANUAL_FORM_AUTHORING_MANIFEST',
+            runtimeAuthoringPolicy: {
+                mode: 'agentic-authoring',
+                enableCustomization: !!this.host.enableCustomization(),
+                canApplyLocalPatch: false,
+                reason: 'praxis-manual-form ainda exige componentEditPlan manifest-backed antes de aplicar patch local pelo copiloto.',
+            },
+            domainCatalog: {
+                recommendedAuthoringFlow: 'component_authoring',
+            },
+        };
+    }
     createSnapshot() {
         return this.getCurrentConfig();
     }
@@ -1178,6 +1222,317 @@ class ManualFormAiAdapter extends BaseAiAdapter {
     }
 }
 
+class ManualFormAgenticAuthoringTurnFlow {
+    adapter;
+    aiApi;
+    mode = 'agentic-authoring';
+    constructor(adapter, aiApi) {
+        this.adapter = adapter;
+        this.aiApi = aiApi;
+    }
+    async submit(request) {
+        const prompt = (request.prompt ?? '').trim();
+        if (!prompt) {
+            return {
+                state: 'listening',
+                phase: 'capture',
+                statusText: '',
+            };
+        }
+        const componentId = this.adapter.componentId || request.componentId || 'praxis-manual-form';
+        const componentType = this.adapter.componentType || request.componentType || 'form';
+        const currentState = this.toAiJsonObject(this.adapter.getCurrentConfig());
+        const dataProfile = this.optionalJsonObject(this.adapter.getDataProfile?.());
+        const runtimeState = this.optionalJsonObject(this.adapter.getRuntimeState?.());
+        const schemaFields = this.adapter.getSchemaFields?.()
+            ?.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,
+            userPrompt: prompt,
+            sessionId: request.sessionId,
+            clientTurnId: request.clientTurnId,
+            messages: this.toChatMessages(request.messages, prompt),
+            currentState,
+            currentStateDigest: this.buildCurrentStateDigest(dataProfile),
+            uiContextRef: {
+                componentId,
+                componentType,
+            },
+            ...(dataProfile ? { dataProfile } : {}),
+            ...(runtimeState ? { runtimeState } : {}),
+            ...(schemaFields?.length ? { schemaFields } : {}),
+            ...(contextHints ? { contextHints } : {}),
+        }));
+        return this.toTurnResult(this.compileAdapterResponse(response), request);
+    }
+    async apply(_request) {
+        return {
+            state: 'error',
+            phase: 'apply',
+            assistantMessage: 'O formulario manual ainda exige componentEditPlan validado pelo manifesto antes de aplicar mudancas locais.',
+            errorText: 'Aplicacao local bloqueada ate existir compilacao manifest-backed para praxis-manual-form.',
+            canApply: false,
+            pendingPatch: null,
+        };
+    }
+    cancel() {
+        return Promise.resolve({
+            state: 'listening',
+            phase: 'capture',
+            assistantMessage: 'Solicitacao cancelada.',
+            statusText: '',
+            canApply: false,
+            pendingPatch: null,
+            pendingClarification: null,
+        });
+    }
+    retry(request) {
+        const lastPrompt = [...(request.messages ?? [])].reverse()
+            .find((message) => message.role === 'user')?.text;
+        return this.submit({
+            ...request,
+            prompt: lastPrompt ?? request.prompt,
+            action: { kind: 'retry' },
+        });
+    }
+    toTurnResult(response, request) {
+        if (!response) {
+            return {
+                state: 'error',
+                phase: 'capture',
+                assistantMessage: 'Resposta vazia da IA.',
+                errorText: 'Resposta vazia da IA.',
+            };
+        }
+        if (response.type === 'clarification') {
+            return {
+                state: 'clarification',
+                phase: 'clarify',
+                sessionId: response.sessionId ?? request.sessionId,
+                assistantMessage: response.message || 'Preciso de mais detalhes para continuar.',
+                clarificationQuestions: this.toClarificationQuestions(response),
+                quickReplies: this.toQuickReplies(response),
+                canApply: false,
+            };
+        }
+        if (response.type === 'info') {
+            const message = response.message || response.explanation || 'Informacao gerada.';
+            return {
+                state: 'success',
+                phase: 'summarize',
+                sessionId: response.sessionId ?? request.sessionId,
+                assistantMessage: message,
+                statusText: message,
+                canApply: false,
+            };
+        }
+        if (response.type === 'error') {
+            const message = response.message || 'Falha ao gerar alteracao de formulario manual.';
+            return {
+                state: 'error',
+                phase: 'capture',
+                sessionId: response.sessionId ?? request.sessionId,
+                assistantMessage: message,
+                errorText: message,
+                diagnostics: response.warnings?.length ? { warnings: response.warnings } : undefined,
+            };
+        }
+        if (response.patch && Object.keys(response.patch).length > 0) {
+            return {
+                state: 'error',
+                phase: 'review',
+                sessionId: response.sessionId ?? request.sessionId,
+                assistantMessage: 'O formulario manual rejeitou patch livre. Gere um componentEditPlan validado pelo PRAXIS_MANUAL_FORM_AUTHORING_MANIFEST antes de propor alteracao local.',
+                errorText: 'Patch livre de formulario manual rejeitado.',
+                canApply: false,
+                pendingPatch: null,
+                diagnostics: {
+                    warnings: [
+                        'free-manual-form-patch-rejected',
+                        'Use componentEditPlan validado contra PRAXIS_MANUAL_FORM_AUTHORING_MANIFEST.',
+                    ],
+                },
+            };
+        }
+        return {
+            state: 'success',
+            phase: 'summarize',
+            sessionId: response.sessionId ?? request.sessionId,
+            assistantMessage: response.message || response.explanation || 'Nenhuma alteracao necessaria.',
+            statusText: response.message || response.explanation || 'Nenhuma alteracao necessaria.',
+            canApply: false,
+        };
+    }
+    compileAdapterResponse(response) {
+        const compiled = this.adapter.compileAiResponse?.(response);
+        if (!compiled) {
+            return response;
+        }
+        if (compiled.type === 'error') {
+            return {
+                type: 'error',
+                message: compiled.message || 'O componentEditPlan do formulario manual nao passou na validacao de capacidades.',
+                warnings: compiled.warnings,
+            };
+        }
+        const warnings = [
+            ...(response.warnings ?? []),
+            ...(compiled.warnings ?? []),
+        ];
+        return {
+            ...response,
+            ...compiled,
+            patch: compiled.patch,
+            warnings: warnings.length ? warnings : undefined,
+        };
+    }
+    toChatMessages(messages, prompt) {
+        const supported = (messages ?? [])
+            .filter((message) => message.role === 'user' || message.role === 'assistant' || message.role === 'system')
+            .map((message) => ({
+            role: message.role,
+            content: message.text,
+        }))
+            .filter((message) => message.content.trim().length > 0);
+        return supported.length ? supported : [{ role: 'user', content: prompt }];
+    }
+    toClarificationQuestions(response) {
+        const labels = response.questions?.length
+            ? response.questions
+            : response.message
+                ? [response.message]
+                : ['Qual ajuste voce quer aplicar no formulario manual?'];
+        const options = this.toQuickReplies(response).map((reply) => ({
+            id: reply.id,
+            label: reply.label,
+            value: reply.prompt,
+        }));
+        return labels.map((label, index) => ({
+            id: `manual-form-clarification-${index + 1}`,
+            type: options.length ? 'single-choice' : 'text',
+            label,
+            allowCustom: true,
+            options,
+        }));
+    }
+    toQuickReplies(response) {
+        const payloads = response.optionPayloads ?? [];
+        if (payloads.length) {
+            return payloads
+                .map((option, index) => {
+                const label = option.label?.trim() || option.value?.trim() || `Opcao ${index + 1}`;
+                const prompt = option.example?.trim() || option.value?.trim() || label;
+                return {
+                    id: `option-${index + 1}`,
+                    label,
+                    prompt,
+                    kind: 'clarification-option',
+                };
+            });
+        }
+        return (response.options ?? [])
+            .filter((option) => !!option?.trim())
+            .map((option, index) => ({
+            id: `option-${index + 1}`,
+            label: option.trim(),
+            prompt: option.trim(),
+            kind: 'clarification-option',
+        }));
+    }
+    buildCurrentStateDigest(dataProfile) {
+        const fieldCount = typeof dataProfile?.['fieldCount'] === 'number' ? dataProfile['fieldCount'] : undefined;
+        return fieldCount !== undefined ? { rowCount: fieldCount } : {};
+    }
+    shouldRouteToGovernedDecision(prompt, contextHints) {
+        return shouldRoutePromptToGovernedDecision(prompt, contextHints);
+    }
+    toGovernedDecisionHandoff(prompt, request) {
+        const message = 'Esse pedido parece alterar uma decisao de negocio compartilhada. O formulario manual pode localizar campos e experiencia afetada, 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 no formulario.',
+                    icon: 'rule',
+                    tone: 'warning',
+                    contextHints: {
+                        flowId: 'shared_rule_authoring',
+                        source: 'praxis-manual-form',
+                        recommendedAction: 'domain-rules/intake',
+                    },
+                },
+            ],
+            clarificationQuestions: [
+                {
+                    id: 'manual-form-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 do formulario.',
+                            contextHints: {
+                                flowId: 'shared_rule_authoring',
+                                source: 'praxis-manual-form',
+                            },
+                        },
+                    ],
+                },
+            ],
+            diagnostics: {
+                governedDecisionHandoff: {
+                    flowId: 'shared_rule_authoring',
+                    sourcePrompt: prompt,
+                    sourceComponent: 'praxis-manual-form',
+                },
+            },
+        };
+    }
+    optionalJsonObject(value) {
+        if (value === undefined || value === null) {
+            return undefined;
+        }
+        const object = this.toAiJsonObject(value);
+        return Object.keys(object).length ? object : undefined;
+    }
+    toAiJsonObject(value) {
+        const record = this.toRecord(value);
+        if (!record) {
+            return {};
+        }
+        try {
+            return JSON.parse(JSON.stringify(record));
+        }
+        catch {
+            return {};
+        }
+    }
+    toRecord(value) {
+        return value && typeof value === 'object' && !Array.isArray(value)
+            ? value
+            : null;
+    }
+}
+
 const MANUAL_FORM_SELECTOR_TO_CONTROL_TYPE = new InjectionToken('MANUAL_FORM_SELECTOR_TO_CONTROL_TYPE');
 const MANUAL_FORM_CONSTRUCTOR_TO_CONTROL_TYPE = new InjectionToken('MANUAL_FORM_CONSTRUCTOR_TO_CONTROL_TYPE');
 
@@ -1629,6 +1984,17 @@ class ManualFormComponent {
     catch {
         return undefined;
     } })();
+    aiApi = inject(AiBackendApiService);
+    assistantSessions = inject(PraxisAssistantSessionRegistryService);
+    aiTurnOrchestrator = inject(PraxisAssistantTurnOrchestratorService);
+    aiAssistantSessionEffect = effect(() => {
+        const session = this.assistantSessions.activeSession();
+        if (!session || session.id !== this.resolveAiAssistantSessionId())
+            return;
+        if (!this.aiAssistantOpen) {
+            this.openAiAssistantFromSession(session);
+        }
+    }, ...(ngDevMode ? [{ debugName: "aiAssistantSessionEffect" }] : []));
     warnedMissingId = false;
     disableSelectorDefaults = inject(FIELD_SELECTOR_REGISTRY_DISABLE_DEFAULTS, { optional: true }) ?? false;
     selectorToControlType = inject(MANUAL_FORM_SELECTOR_TO_CONTROL_TYPE, { optional: true }) ??
@@ -1669,6 +2035,21 @@ class ManualFormComponent {
     instance;
     resolvedActions;
     aiAdapter = new ManualFormAiAdapter(this);
+    aiAssistantOpen = false;
+    aiAssistantPrompt = '';
+    aiAssistantViewState = null;
+    aiAssistantLayout = createPraxisAssistantViewportLayout();
+    aiAssistantLabels = {
+        title: 'Copiloto semantico Praxis',
+        subtitle: 'Converse, revise e governe ajustes do formulario manual.',
+        prompt: 'Mensagem',
+        promptPlaceholder: 'Descreva o ajuste que voce precisa no formulario.',
+        emptyConversation: 'Diga o que voce quer alterar no formulario.',
+        submit: 'Interpretar pedido',
+        apply: 'Aplicar ajuste',
+    };
+    aiAssistantController = null;
+    aiAssistantStateSubscription = null;
     formGroup = new FormGroup({});
     registeredDirectives = [];
     constructor() {
@@ -1720,6 +2101,8 @@ class ManualFormComponent {
         this.metadataSubscription?.unsubscribe();
         this.toolbarOverlayRef?.dispose();
         this.outsideClickSubscription?.unsubscribe();
+        this.assistantSessions.removeContextSession(this.buildAiAssistantContextSnapshot().identity);
+        this.aiAssistantStateSubscription?.unsubscribe();
     }
     // =============================
     // ControlContainer interface
@@ -1945,6 +2328,308 @@ class ManualFormComponent {
         this.metadataChange.emit(this.instance.currentConfig);
         this.cdr.markForCheck();
     }
+    openAiAssistant() {
+        this.initializeAiAssistantController();
+        this.aiAssistantOpen = true;
+        this.aiAssistantController?.setContextItems(this.buildAiAssistantContextItems());
+        this.syncAiAssistantSession('active');
+        this.cdr.markForCheck();
+    }
+    openAiAssistantFromSession(session) {
+        if (session.id !== this.resolveAiAssistantSessionId())
+            return;
+        this.initializeAiAssistantController();
+        this.aiAssistantOpen = true;
+        this.aiAssistantController?.setContextItems(this.buildAiAssistantContextItems());
+        this.syncAiAssistantSession('active');
+        this.cdr.markForCheck();
+    }
+    closeAiAssistant() {
+        this.aiAssistantOpen = false;
+        this.syncAiAssistantSession('minimized');
+        this.cdr.markForCheck();
+    }
+    onAiAssistantPromptChange(prompt) {
+        this.aiAssistantPrompt = prompt;
+        this.syncAiAssistantSession();
+    }
+    onAiAssistantSubmit(prompt) {
+        this.aiAssistantController?.submitPrompt(prompt).subscribe((state) => {
+            this.aiAssistantPrompt = '';
+            this.aiAssistantViewState = state;
+            this.syncAiAssistantSession();
+            this.cdr.markForCheck();
+        });
+    }
+    onAiAssistantApply() {
+        this.aiAssistantController?.apply().subscribe((state) => {
+            this.aiAssistantViewState = state;
+            this.syncAiAssistantSession();
+            this.cdr.markForCheck();
+        });
+    }
+    onAiAssistantRetry() {
+        this.aiAssistantController?.retry().subscribe((state) => {
+            this.aiAssistantViewState = state;
+            this.syncAiAssistantSession();
+            this.cdr.markForCheck();
+        });
+    }
+    onAiAssistantCancel() {
+        this.aiAssistantController?.cancel().subscribe((state) => {
+            this.aiAssistantPrompt = '';
+            this.aiAssistantViewState = state;
+            this.syncAiAssistantSession();
+            this.cdr.markForCheck();
+        });
+    }
+    onAiAssistantQuickReply(reply) {
+        const controller = this.aiAssistantController;
+        if (!controller)
+            return;
+        const state = controller.snapshot();
+        const next$ = state.state === 'clarification'
+            ? controller.answerClarification(reply.prompt)
+            : controller.submitPrompt(reply.prompt, {
+                kind: reply.kind || 'quick-reply',
+                id: reply.id,
+                value: reply.prompt,
+            });
+        next$.subscribe((nextState) => {
+            this.aiAssistantPrompt = '';
+            this.aiAssistantViewState = nextState;
+            this.syncAiAssistantSession();
+            this.cdr.markForCheck();
+        });
+    }
+    onAiAssistantEditMessage(message) {
+        this.aiAssistantPrompt = message.text;
+        this.cdr.markForCheck();
+    }
+    onAiAssistantResendMessage(message) {
+        this.aiAssistantController?.resendMessage(message.id).subscribe((state) => {
+            this.aiAssistantPrompt = '';
+            this.aiAssistantViewState = state;
+            this.syncAiAssistantSession();
+            this.cdr.markForCheck();
+        });
+    }
+    onAiAssistantLayoutChange(layout) {
+        this.aiAssistantLayout = layout;
+    }
+    initializeAiAssistantController() {
+        if (this.aiAssistantController)
+            return;
+        const flow = new ManualFormAgenticAuthoringTurnFlow(this.aiAdapter, this.aiApi);
+        const controller = this.aiTurnOrchestrator.createController(flow, {
+            componentId: this.aiAdapter.componentId || 'praxis-manual-form',
+            componentType: this.aiAdapter.componentType || 'form',
+            contextItems: this.buildAiAssistantContextItems(),
+        });
+        this.aiAssistantController = controller;
+        this.aiAssistantViewState = controller.snapshot();
+        this.aiAssistantStateSubscription?.unsubscribe();
+        this.aiAssistantStateSubscription = controller.state$.subscribe((state) => {
+            this.aiAssistantViewState = state;
+            this.syncAiAssistantSession();
+            this.cdr.markForCheck();
+        });
+        this.cdr.markForCheck();
+    }
+    buildAiAssistantContextItems() {
+        const items = [
+            {
+                id: 'component',
+                label: 'Componente',
+                value: 'Formulario manual',
+                kind: 'component',
+                icon: 'edit_note',
+            },
+            {
+                id: 'form-id',
+                label: 'Formulario',
+                value: this.safeAiAssistantFormId(),
+                kind: 'custom',
+                icon: 'tag',
+            },
+        ];
+        const fieldsCount = this.instance?.currentConfig?.fieldMetadata?.length ?? 0;
+        if (fieldsCount > 0) {
+            items.push({
+                id: 'fields',
+                label: 'Campos',
+                value: String(fieldsCount),
+                kind: 'custom',
+                icon: 'view_list',
+            });
+        }
+        return items;
+    }
+    buildAiAssistantContextSnapshot() {
+        const fieldNames = this.collectAiAssistantFieldNames();
+        const counts = this.collectAiAssistantCounts();
+        return {
+            identity: {
+                sessionId: this.resolveAiAssistantSessionId(),
+                ownerId: this.resolveAiAssistantOwnerId(),
+                ownerType: 'manual-form',
+                componentId: 'praxis-manual-form',
+                componentType: 'form',
+                routeKey: this.resolveAiAssistantRouteKey(),
+            },
+            target: {
+                kind: 'component',
+                id: this.resolveAiAssistantOwnerId(),
+                label: this.formTitle() || this.safeAiAssistantFormId(),
+                metadata: {
+                    formId: this.safeAiAssistantFormId(),
+                    hasCustomization: !!this.enableCustomization(),
+                },
+            },
+            contextItems: this.buildAiAssistantContextItems().map((item) => ({
+                id: item.id,
+                label: item.label,
+                value: item.value || '',
+                kind: item.kind,
+            })),
+            mode: 'agentic-authoring',
+            authoringManifestRef: {
+                componentId: 'praxis-manual-form',
+                source: 'PRAXIS_MANUAL_FORM_AUTHORING_MANIFEST',
+            },
+            schemaFields: fieldNames.length ? fieldNames : undefined,
+            dataProfileDigest: {
+                summary: `${counts.fieldCount} campo(s), ${counts.sectionCount} secao(oes), ${counts.actionCount} acao(oes)`,
+                counts,
+            },
+            runtimeStateDigest: {
+                summary: this.instance
+                    ? `Formulario ${this.formGroup.valid ? 'valido' : 'invalido'} e ${this.formGroup.dirty ? 'alterado' : 'sem alteracoes'}`
+                    : 'Formulario ainda sem instancia runtime.',
+                fields: [
+                    'currentConfig',
+                    'fieldMetadata',
+                    'form',
+                    'metadataChange',
+                ],
+            },
+            capabilityRefs: [
+                {
+                    id: 'manual-form.component-edit-plan',
+                    label: 'Plano de edicao de formulario manual',
+                    source: 'PRAXIS_MANUAL_FORM_AUTHORING_MANIFEST',
+                    risk: 'medium',
+                },
+            ],
+            governanceHints: [
+                {
+                    kind: 'business-rule-boundary',
+                    label: 'Regras compartilhadas exigem governanca',
+                    reason: 'Politicas, validacoes reutilizaveis e compliance nao devem ser aplicados como patch local do formulario.',
+                    risk: 'high',
+                },
+            ],
+        };
+    }
+    syncAiAssistantSession(visibility = null) {
+        if (!this.enableCustomization())
+            return;
+        if (!this.aiAssistantOpen && !this.hasAiAssistantSessionState() && visibility !== 'minimized')
+            return;
+        const state = this.aiAssistantViewState;
+        this.assistantSessions.upsertContextSession(this.buildAiAssistantContextSnapshot(), {
+            title: 'Copiloto semantico Praxis',
+            summary: this.resolveAiAssistantSummary(),
+            mode: state?.mode || 'agentic-authoring',
+            state: state?.state || 'idle',
+            visibility: visibility ?? (this.aiAssistantOpen ? 'active' : 'minimized'),
+            badge: this.resolveAiAssistantBadge(),
+            icon: this.resolveAiAssistantIcon(),
+        });
+    }
+    hasAiAssistantSessionState() {
+        return !!this.aiAssistantPrompt.trim()
+            || !!this.aiAssistantViewState?.messages?.length
+            || !!this.aiAssistantViewState?.quickReplies?.length
+            || !!this.aiAssistantViewState?.pendingPatch
+            || !!this.aiAssistantViewState?.statusText?.trim()
+            || !!this.aiAssistantViewState?.errorText?.trim();
+    }
+    resolveAiAssistantSessionId() {
+        return `manual-form:${this.resolveAiAssistantRouteKey()}:${this.resolveAiAssistantOwnerId()}`;
+    }
+    resolveAiAssistantOwnerId() {
+        return (this.componentInstanceId() || this.safeAiAssistantFormId() || 'manual-form').trim() || 'manual-form';
+    }
+    safeAiAssistantFormId() {
+        try {
+            return String(this.formId() || '').trim();
+        }
+        catch {
+            return '';
+        }
+    }
+    resolveAiAssistantRouteKey() {
+        const routePath = this.route?.snapshot?.routeConfig?.path?.trim();
+        return routePath || 'local';
+    }
+    resolveAiAssistantSummary() {
+        const status = this.aiAssistantViewState?.statusText?.trim();
+        if (status)
+            return status;
+        const error = this.aiAssistantViewState?.errorText?.trim();
+        if (error)
+            return error;
+        const prompt = this.aiAssistantPrompt.trim();
+        if (prompt)
+            return prompt.length > 96 ? `${prompt.slice(0, 93)}...` : prompt;
+        const lastMessage = [...(this.aiAssistantViewState?.messages ?? [])].reverse()
+            .find((message) => message.role === 'assistant' || message.role === 'user');
+        if (lastMessage?.text) {
+            return lastMessage.text.length > 96 ? `${lastMessage.text.slice(0, 93)}...` : lastMessage.text;
+        }
+        return 'Assistente contextual do formulario manual.';
+    }
+    resolveAiAssistantBadge() {
+        const state = this.aiAssistantViewState?.state;
+        if (state === 'error')
+            return 'erro';
+        if (state === 'clarification')
+            return 'revisar';
+        if (state === 'review')
+            return 'preview';
+        if (state === 'success')
+            return 'ok';
+        return undefined;
+    }
+    resolveAiAssistantIcon() {
+        const state = this.aiAssistantViewState?.state;
+        if (state === 'error')
+            return 'error';
+        if (state === 'clarification')
+            return 'rule';
+        if (state === 'review')
+            return 'rate_review';
+        return 'auto_awesome';
+    }
+    collectAiAssistantFieldNames() {
+        return Array.from(new Set((this.instance?.currentConfig?.fieldMetadata ?? [])
+            .map((field) => field.name)
+            .filter((name) => typeof name === 'string' && !!name.trim())));
+    }
+    collectAiAssistantCounts() {
+        const config = this.instance?.currentConfig;
+        return {
+            sectionCount: config?.sections?.length ?? 0,
+            fieldCount: config?.fieldMetadata?.length ?? 0,
+            actionCount: [
+                config?.actions?.submit,
+                config?.actions?.cancel,
+                config?.actions?.reset,
+                ...(config?.actions?.custom ?? []),
+            ].filter(Boolean).length,
+        };
+    }
     async initialize(fromChanges) {
         this.syncHostFormGroupReference();
         if (!this.formId()) {
@@ -2540,20 +3225,20 @@ class ManualFormComponent {
     static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.3.17", type: ManualFormComponent, isStandalone: true, selector: "praxis-manual-form", inputs: { formId: { classPropertyName: "formId", publicName: "formId", isSignal: true, isRequired: true, transformFunction: null }, formTitle: { classPropertyName: "formTitle", publicName: "formTitle", isSignal: true, isRequired: false, transformFunction: null }, formDescription: { classPropertyName: "formDescription", publicName: "formDescription", isSignal: true, isRequired: false, transformFunction: null }, actions: { classPropertyName: "actions", publicName: "actions", isSignal: true, isRequired: false, transformFunction: null }, showHeader: { classPropertyName: "showHeader", publicName: "showHeader", isSignal: true, isRequired: false, transformFunction: null }, showActions: { classPropertyName: "showActions", publicName: "showActions", isSignal: true, isRequired: false, transformFunction: null }, enableAutoSave: { classPropertyName: "enableAutoSave", publicName: "enableAutoSave", isSignal: true, isRequired: false, transformFunction: null }, componentInstanceId: { classPropertyName: "componentInstanceId", publicName: "componentInstanceId", isSignal: true, isRequired: false, transformFunction: null }, enableCustomization: { classPropertyName: "enableCustomization", publicName: "enableCustomization", isSignal: true, isRequired: false, transformFunction: null }, persistenceOptions: { classPropertyName: "persistenceOptions", publicName: "persistenceOptions", isSignal: true, isRequired: false, transformFunction: null }, usePathNames: { classPropertyName: "usePathNames", publicName: "usePathNames", isSignal: true, isRequired: false, transformFunction: null }, autoSaveDebounceMs: { classPropertyName: "autoSaveDebounceMs", publicName: "autoSaveDebounceMs", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { submitted: "submitted", saved: "saved", resetEvent: "reset", metadataChange: "metadataChange" }, providers: [
             // Provide a ControlContainer at the host boundary so projected formControlName can resolve it
             { provide: ControlContainer, useExisting: ManualFormComponent },
-        ], queries: [{ propertyName: "formControls", predicate: FormControlName, descendants: true }], ngImport: i0, template: "<div class=\"pdx-manual-form\">\n  @if (showHeader()) {\n  <praxis-manual-form-header [instance]=\"instance\" [title]=\"formTitle()\" [description]=\"formDescription()\"\n    [enableCustomization]=\"enableCustomization()\" (editForm)=\"openFormEditor()\" (save)=\"handleSave()\"\n    (reset)=\"handleReset()\"></praxis-manual-form-header>\n  }\n\n  @if (enableCustomization()) {\n  <div class=\"pdx-manual-form__assistant\">\n    <praxis-ai-assistant [adapter]=\"aiAdapter\"></praxis-ai-assistant>\n  </div>\n  }\n\n  <form class=\"pdx-manual-form__form\" [formGroup]=\"formGroup\" (submit)=\"handleSubmit(); $event.preventDefault()\">\n    <ng-content></ng-content>\n  </form>\n\n  @if (showActions() && resolvedActions) {\n  <praxis-manual-form-actions [actions]=\"resolvedActions\"\n    (actionClick)=\"handleAction($event)\"></praxis-manual-form-actions>\n  }\n</div>\n", styles: [".pdx-manual-form{display:flex;flex-direction:column;gap:var(--pdx-manual-form-gap, 24px);color:var(--md-sys-color-on-surface)}.pdx-manual-form__form{display:grid;gap:var(--pdx-manual-form-field-gap, 16px);padding:var(--pdx-manual-form-padding, 20px);border-radius:var(--pdx-manual-form-radius, 16px);background:var(--pdx-manual-form-surface, var(--md-sys-color-surface-container));border:1px solid var(--pdx-manual-form-outline, var(--md-sys-color-outline-variant));box-shadow:var(--pdx-manual-form-shadow, var(--md-sys-elevation-level1, none))}.pdx-manual-form__form:focus-within{border-color:var(--pdx-manual-form-focus, var(--md-sys-color-primary));box-shadow:0 0 0 2px var(--md-sys-color-primary),var(--pdx-manual-form-shadow, var(--md-sys-elevation-level1, none))}.pdx-manual-form__assistant{display:flex;justify-content:flex-end}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i1.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i1.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i1.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "component", type: PraxisAiAssistantComponent, selector: "praxis-ai-assistant", inputs: ["adapter", "riskPolicy", "allowManualPatchEdit"] }, { kind: "component", type: ManualFormHeaderComponent, selector: "praxis-manual-form-header", inputs: ["instance", "title", "description", "saveLabel", "resetLabel", "enableCustomization", "editFormLabel"], outputs: ["save", "reset", "editForm"] }, { kind: "component", type: ManualFormActionsComponent, selector: "praxis-manual-form-actions", inputs: ["actions", "trackByFn"], outputs: ["actionClick"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+        ], queries: [{ propertyName: "formControls", predicate: FormControlName, descendants: true }], ngImport: i0, template: "<div class=\"pdx-manual-form\">\n  @if (showHeader()) {\n  <praxis-manual-form-header [instance]=\"instance\" [title]=\"formTitle()\" [description]=\"formDescription()\"\n    [enableCustomization]=\"enableCustomization()\" (editForm)=\"openFormEditor()\" (save)=\"handleSave()\"\n    (reset)=\"handleReset()\"></praxis-manual-form-header>\n  }\n\n  @if (enableCustomization()) {\n  <div class=\"pdx-manual-form__assistant\">\n    <button\n      type=\"button\"\n      class=\"pdx-manual-form__assistant-trigger\"\n      (click)=\"openAiAssistant()\"\n      aria-label=\"Abrir copiloto semantico Praxis do formulario manual\"\n      data-testid=\"praxis-manual-form-ai-assistant-trigger\"\n    >\n      Copiloto Praxis\n    </button>\n  </div>\n  }\n\n  @if (aiAssistantOpen && aiAssistantViewState) {\n  <praxis-ai-assistant-shell\n    [labels]=\"aiAssistantLabels\"\n    [mode]=\"aiAssistantViewState.mode\"\n    [state]=\"aiAssistantViewState.state\"\n    [contextItems]=\"aiAssistantViewState.contextItems\"\n    [attachments]=\"aiAssistantViewState.attachments\"\n    [messages]=\"aiAssistantViewState.messages\"\n    [quickReplies]=\"aiAssistantViewState.quickReplies\"\n    [prompt]=\"aiAssistantPrompt\"\n    [statusText]=\"aiAssistantViewState.statusText\"\n    [errorText]=\"aiAssistantViewState.errorText\"\n    [busy]=\"aiAssistantViewState.state === 'processing' || aiAssistantViewState.state === 'applying'\"\n    [canApply]=\"aiAssistantViewState.canApply\"\n    [layout]=\"aiAssistantLayout\"\n    testIdPrefix=\"praxis-manual-form-ai-assistant\"\n    (promptChange)=\"onAiAssistantPromptChange($event)\"\n    (submitPrompt)=\"onAiAssistantSubmit($event)\"\n    (apply)=\"onAiAssistantApply()\"\n    (retryTurn)=\"onAiAssistantRetry()\"\n    (cancelTurn)=\"onAiAssistantCancel()\"\n    (close)=\"closeAiAssistant()\"\n    (quickReply)=\"onAiAssistantQuickReply($event)\"\n    (editMessage)=\"onAiAssistantEditMessage($event)\"\n    (resendMessage)=\"onAiAssistantResendMessage($event)\"\n    (layoutChange)=\"onAiAssistantLayoutChange($event)\"\n  ></praxis-ai-assistant-shell>\n  }\n\n  <form class=\"pdx-manual-form__form\" [formGroup]=\"formGroup\" (submit)=\"handleSubmit(); $event.preventDefault()\">\n    <ng-content></ng-content>\n  </form>\n\n  @if (showActions() && resolvedActions) {\n  <praxis-manual-form-actions [actions]=\"resolvedActions\"\n    (actionClick)=\"handleAction($event)\"></praxis-manual-form-actions>\n  }\n</div>\n", styles: [".pdx-manual-form{display:flex;flex-direction:column;gap:var(--pdx-manual-form-gap, 24px);color:var(--md-sys-color-on-surface)}.pdx-manual-form__form{display:grid;gap:var(--pdx-manual-form-field-gap, 16px);padding:var(--pdx-manual-form-padding, 20px);border-radius:var(--pdx-manual-form-radius, 16px);background:var(--pdx-manual-form-surface, var(--md-sys-color-surface-container));border:1px solid var(--pdx-manual-form-outline, var(--md-sys-color-outline-variant));box-shadow:var(--pdx-manual-form-shadow, var(--md-sys-elevation-level1, none))}.pdx-manual-form__form:focus-within{border-color:var(--pdx-manual-form-focus, var(--md-sys-color-primary));box-shadow:0 0 0 2px var(--md-sys-color-primary),var(--pdx-manual-form-shadow, var(--md-sys-elevation-level1, none))}.pdx-manual-form__assistant{display:flex;justify-content:flex-end}.pdx-manual-form__assistant-trigger{border:0;border-radius:999px;padding:8px 14px;cursor:pointer;color:var(--md-sys-color-on-primary, #fff);background:var(--md-sys-color-primary, #3451d1);box-shadow:var(--md-sys-elevation-level2, 0 4px 12px rgba(0, 0, 0, .18))}.pdx-manual-form__assistant-trigger:hover{background:var(--md-sys-color-primary-container, #223fb6)}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: ReactiveFormsModule }, { kind: "directive", type: i1.ɵNgNoValidate, selector: "form:not([ngNoForm]):not([ngNativeValidate])" }, { kind: "directive", type: i1.NgControlStatusGroup, selector: "[formGroupName],[formArrayName],[ngModelGroup],[formGroup],form:not([ngNoForm]),[ngForm]" }, { kind: "directive", type: i1.FormGroupDirective, selector: "[formGroup]", inputs: ["formGroup"], outputs: ["ngSubmit"], exportAs: ["ngForm"] }, { kind: "component", type: PraxisAiAssistantShellComponent, selector: "praxis-ai-assistant-shell", inputs: ["labels", "mode", "state", "contextItems", "attachments", "messages", "quickReplies", "prompt", "statusText", "errorText", "testIdPrefix", "panelTestId", "submitTestId", "applyTestId", "primaryAction", "secondaryActions", "governanceActions", "busy", "canSubmit", "canApply", "submitOnEnter", "showAttachAction", "enablePastedAttachments", "enableFileAttachments", "attachmentAccept", "attachmentMultiple", "draggable", "resizable", "minWidth", "minHeight", "margin", "layout"], outputs: ["promptChange", "submitPrompt", "apply", "retryTurn", "cancelTurn", "shellAction", "close", "attach", "attachmentsPasted", "attachmentsSelected", "removeAttachment", "messageAction", "editMessage", "resendMessage", "quickReply", "layoutChange"] }, { kind: "component", type: ManualFormHeaderComponent, selector: "praxis-manual-form-header", inputs: ["instance", "title", "description", "saveLabel", "resetLabel", "enableCustomization", "editFormLabel"], outputs: ["save", "reset", "editForm"] }, { kind: "component", type: ManualFormActionsComponent, selector: "praxis-manual-form-actions", inputs: ["actions", "trackByFn"], outputs: ["actionClick"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: ManualFormComponent, decorators: [{
             type: Component,
             args: [{ selector: 'praxis-manual-form', standalone: true, imports: [
                         CommonModule,
                         ReactiveFormsModule,
-                        PraxisAiAssistantComponent,
+                        PraxisAiAssistantShellComponent,
                         ManualFormHeaderComponent,
                         ManualFormActionsComponent,
                     ], providers: [
                         // Provide a ControlContainer at the host boundary so projected formControlName can resolve it
                         { provide: ControlContainer, useExisting: ManualFormComponent },
-                    ], changeDetection: ChangeDetectionStrategy.OnPush, template: "<div class=\"pdx-manual-form\">\n  @if (showHeader()) {\n  <praxis-manual-form-header [instance]=\"instance\" [title]=\"formTitle()\" [description]=\"formDescription()\"\n    [enableCustomization]=\"enableCustomization()\" (editForm)=\"openFormEditor()\" (save)=\"handleSave()\"\n    (reset)=\"handleReset()\"></praxis-manual-form-header>\n  }\n\n  @if (enableCustomization()) {\n  <div class=\"pdx-manual-form__assistant\">\n    <praxis-ai-assistant [adapter]=\"aiAdapter\"></praxis-ai-assistant>\n  </div>\n  }\n\n  <form class=\"pdx-manual-form__form\" [formGroup]=\"formGroup\" (submit)=\"handleSubmit(); $event.preventDefault()\">\n    <ng-content></ng-content>\n  </form>\n\n  @if (showActions() && resolvedActions) {\n  <praxis-manual-form-actions [actions]=\"resolvedActions\"\n    (actionClick)=\"handleAction($event)\"></praxis-manual-form-actions>\n  }\n</div>\n", styles: [".pdx-manual-form{display:flex;flex-direction:column;gap:var(--pdx-manual-form-gap, 24px);color:var(--md-sys-color-on-surface)}.pdx-manual-form__form{display:grid;gap:var(--pdx-manual-form-field-gap, 16px);padding:var(--pdx-manual-form-padding, 20px);border-radius:var(--pdx-manual-form-radius, 16px);background:var(--pdx-manual-form-surface, var(--md-sys-color-surface-container));border:1px solid var(--pdx-manual-form-outline, var(--md-sys-color-outline-variant));box-shadow:var(--pdx-manual-form-shadow, var(--md-sys-elevation-level1, none))}.pdx-manual-form__form:focus-within{border-color:var(--pdx-manual-form-focus, var(--md-sys-color-primary));box-shadow:0 0 0 2px var(--md-sys-color-primary),var(--pdx-manual-form-shadow, var(--md-sys-elevation-level1, none))}.pdx-manual-form__assistant{display:flex;justify-content:flex-end}\n"] }]
+                    ], changeDetection: ChangeDetectionStrategy.OnPush, template: "<div class=\"pdx-manual-form\">\n  @if (showHeader()) {\n  <praxis-manual-form-header [instance]=\"instance\" [title]=\"formTitle()\" [description]=\"formDescription()\"\n    [enableCustomization]=\"enableCustomization()\" (editForm)=\"openFormEditor()\" (save)=\"handleSave()\"\n    (reset)=\"handleReset()\"></praxis-manual-form-header>\n  }\n\n  @if (enableCustomization()) {\n  <div class=\"pdx-manual-form__assistant\">\n    <button\n      type=\"button\"\n      class=\"pdx-manual-form__assistant-trigger\"\n      (click)=\"openAiAssistant()\"\n      aria-label=\"Abrir copiloto semantico Praxis do formulario manual\"\n      data-testid=\"praxis-manual-form-ai-assistant-trigger\"\n    >\n      Copiloto Praxis\n    </button>\n  </div>\n  }\n\n  @if (aiAssistantOpen && aiAssistantViewState) {\n  <praxis-ai-assistant-shell\n    [labels]=\"aiAssistantLabels\"\n    [mode]=\"aiAssistantViewState.mode\"\n    [state]=\"aiAssistantViewState.state\"\n    [contextItems]=\"aiAssistantViewState.contextItems\"\n    [attachments]=\"aiAssistantViewState.attachments\"\n    [messages]=\"aiAssistantViewState.messages\"\n    [quickReplies]=\"aiAssistantViewState.quickReplies\"\n    [prompt]=\"aiAssistantPrompt\"\n    [statusText]=\"aiAssistantViewState.statusText\"\n    [errorText]=\"aiAssistantViewState.errorText\"\n    [busy]=\"aiAssistantViewState.state === 'processing' || aiAssistantViewState.state === 'applying'\"\n    [canApply]=\"aiAssistantViewState.canApply\"\n    [layout]=\"aiAssistantLayout\"\n    testIdPrefix=\"praxis-manual-form-ai-assistant\"\n    (promptChange)=\"onAiAssistantPromptChange($event)\"\n    (submitPrompt)=\"onAiAssistantSubmit($event)\"\n    (apply)=\"onAiAssistantApply()\"\n    (retryTurn)=\"onAiAssistantRetry()\"\n    (cancelTurn)=\"onAiAssistantCancel()\"\n    (close)=\"closeAiAssistant()\"\n    (quickReply)=\"onAiAssistantQuickReply($event)\"\n    (editMessage)=\"onAiAssistantEditMessage($event)\"\n    (resendMessage)=\"onAiAssistantResendMessage($event)\"\n    (layoutChange)=\"onAiAssistantLayoutChange($event)\"\n  ></praxis-ai-assistant-shell>\n  }\n\n  <form class=\"pdx-manual-form__form\" [formGroup]=\"formGroup\" (submit)=\"handleSubmit(); $event.preventDefault()\">\n    <ng-content></ng-content>\n  </form>\n\n  @if (showActions() && resolvedActions) {\n  <praxis-manual-form-actions [actions]=\"resolvedActions\"\n    (actionClick)=\"handleAction($event)\"></praxis-manual-form-actions>\n  }\n</div>\n", styles: [".pdx-manual-form{display:flex;flex-direction:column;gap:var(--pdx-manual-form-gap, 24px);color:var(--md-sys-color-on-surface)}.pdx-manual-form__form{display:grid;gap:var(--pdx-manual-form-field-gap, 16px);padding:var(--pdx-manual-form-padding, 20px);border-radius:var(--pdx-manual-form-radius, 16px);background:var(--pdx-manual-form-surface, var(--md-sys-color-surface-container));border:1px solid var(--pdx-manual-form-outline, var(--md-sys-color-outline-variant));box-shadow:var(--pdx-manual-form-shadow, var(--md-sys-elevation-level1, none))}.pdx-manual-form__form:focus-within{border-color:var(--pdx-manual-form-focus, var(--md-sys-color-primary));box-shadow:0 0 0 2px var(--md-sys-color-primary),var(--pdx-manual-form-shadow, var(--md-sys-elevation-level1, none))}.pdx-manual-form__assistant{display:flex;justify-content:flex-end}.pdx-manual-form__assistant-trigger{border:0;border-radius:999px;padding:8px 14px;cursor:pointer;color:var(--md-sys-color-on-primary, #fff);background:var(--md-sys-color-primary, #3451d1);box-shadow:var(--md-sys-elevation-level2, 0 4px 12px rgba(0, 0, 0, .18))}.pdx-manual-form__assistant-trigger:hover{background:var(--md-sys-color-primary-container, #223fb6)}\n"] }]
         }], ctorParameters: () => [], propDecorators: { formId: [{ type: i0.Input, args: [{ isSignal: true, alias: "formId", required: true }] }], formTitle: [{ type: i0.Input, args: [{ isSignal: true, alias: "formTitle", required: false }] }], formDescription: [{ type: i0.Input, args: [{ isSignal: true, alias: "formDescription", required: false }] }], actions: [{ type: i0.Input, args: [{ isSignal: true, alias: "actions", required: false }] }], showHeader: [{ type: i0.Input, args: [{ isSignal: true, alias: "showHeader", required: false }] }], showActions: [{ type: i0.Input, args: [{ isSignal: true, alias: "showActions", required: false }] }], enableAutoSave: [{ type: i0.Input, args: [{ isSignal: true, alias: "enableAutoSave", required: false }] }], componentInstanceId: [{ type: i0.Input, args: [{ isSignal: true, alias: "componentInstanceId", required: false }] }], enableCustomization: [{ type: i0.Input, args: [{ isSignal: true, alias: "enableCustomization", required: false }] }], persistenceOptions: [{ type: i0.Input, args: [{ isSignal: true, alias: "persistenceOptions", required: false }] }], usePathNames: [{ type: i0.Input, args: [{ isSignal: true, alias: "usePathNames", required: false }] }], autoSaveDebounceMs: [{ type: i0.Input, args: [{ isSignal: true, alias: "autoSaveDebounceMs", required: false }] }], submitted: [{ type: i0.Output, args: ["submitted"] }], saved: [{ type: i0.Output, args: ["saved"] }], resetEvent: [{ type: i0.Output, args: ["reset"] }], metadataChange: [{ type: i0.Output, args: ["metadataChange"] }], formControls: [{
                 type: ContentChildren,
                 args: [FormControlName, { descendants: true }]
@@ -5359,6 +6044,348 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImpo
                 args: ['dblclick']
             }] } });
 
+const manualFieldAddSchema = {
+    type: 'object',
+    required: ['fieldName', 'controlType'],
+    properties: {
+        fieldName: { type: 'string' },
+        controlType: { type: 'string' },
+        label: { type: 'string' },
+        required: { type: 'boolean' },
+        sectionId: { type: 'string' },
+        source: { enum: ['manual-template', 'detected-component', 'metadata-bridge'] },
+        delegateFieldMetadataTo: { enum: ['praxis-metadata-editor'] },
+    },
+};
+const manualFieldRemoveSchema = {
+    type: 'object',
+    required: ['fieldName'],
+    properties: {
+        fieldName: { type: 'string' },
+        removeFromLayout: { type: 'boolean' },
+        clearPersistedValue: { type: 'boolean' },
+    },
+};
+const manualFieldLabelSetSchema = {
+    type: 'object',
+    required: ['fieldName', 'label'],
+    properties: {
+        fieldName: { type: 'string' },
+        label: { type: 'string' },
+        updatePlaceholderWhenEmpty: { type: 'boolean' },
+    },
+};
+const layoutConfigureSchema = {
+    type: 'object',
+    minProperties: 1,
+    properties: {
+        usePathNames: { type: 'boolean' },
+        sections: { type: 'array' },
+        rows: { type: 'array' },
+        columns: { type: 'array' },
+        fieldOrder: {
+            type: 'array',
+            items: { type: 'string' },
+        },
+        delegateAdvancedFormConfigTo: { enum: ['praxis-dynamic-form'] },
+    },
+};
+const toolbarConfigureSchema = {
+    type: 'object',
+    minProperties: 1,
+    properties: {
+        enableCustomization: { type: 'boolean' },
+        editableFlags: {
+            type: 'array',
+            items: { enum: ['required', 'readOnly', 'hidden', 'disabled', 'openMetadataEditor'] },
+        },
+    },
+};
+const autosaveEnabledSetSchema = {
+    type: 'object',
+    required: ['enabled'],
+    properties: {
+        enabled: { type: 'boolean' },
+        debounceMs: { type: 'number' },
+        storageKey: { type: 'string' },
+        namespace: { type: 'string' },
+        tenantId: { type: 'string' },
+        profileId: { type: 'string' },
+    },
+};
+const submitBehaviorSetSchema = {
+    type: 'object',
+    minProperties: 1,
+    properties: {
+        action: { enum: ['submit', 'saveDraft', 'reset', 'cancel', 'custom'] },
+        clearAfterSave: { type: 'boolean' },
+        focusFirstError: { type: 'boolean' },
+        scrollToErrors: { type: 'boolean' },
+        confirmOnUnsavedChanges: { type: 'boolean' },
+        delegateFormSubmitTo: { enum: ['praxis-dynamic-form'] },
+    },
+};
+const metadataBridgeConfigureSchema = {
+    type: 'object',
+    minProperties: 1,
+    properties: {
+        enabled: { type: 'boolean' },
+        fieldName: { type: 'string' },
+        openMode: { enum: ['field-toolbar', 'double-click', 'programmatic'] },
+        persistDraftAfterPatch: { type: 'boolean' },
+        delegateFieldMetadataTo: { enum: ['praxis-metadata-editor'] },
+        delegateControlDiscoveryTo: { enum: ['praxis-dynamic-fields'] },
+    },
+};
+const PRAXIS_MANUAL_FORM_AUTHORING_MANIFEST = {
+    schemaVersion: '1.0.0',
+    componentId: 'praxis-manual-form',
+    ownerPackage: '@praxisui/manual-form',
+    configSchemaId: 'ManualFormInstance',
+    manifestVersion: '1.0.0',
+    runtimeInputs: [
+        { name: 'formId', type: 'string', description: 'Required manual form id used for runtime state and persistence key composition.' },
+        { name: 'formGroup', type: 'FormGroup | null', description: 'Host-owned typed FormGroup adopted by the manual form runtime when provided.' },
+        { name: 'formTitle', type: 'string | null', description: 'Manual form title override.' },
+        { name: 'formDescription', type: 'string | null', description: 'Manual form description override.' },
+        { name: 'actions', type: 'FormActionsLayout | null', description: 'Manual toolbar/actions layout.' },
+        { name: 'enableAutoSave', type: 'boolean', description: 'Enables draft persistence through ManualFormInstance.saveDraft.' },
+        { name: 'autoSaveDebounceMs', type: 'number', description: 'Autosave debounce in milliseconds.' },
+        { name: 'enableCustomization', type: 'boolean', description: 'Enables field toolbar and metadata editor bridge.' },
+        { name: 'persistenceOptions', type: 'ManualFormPersistenceOptions | null', description: 'Namespace, tenant, profile, locale and storage key controls.' },
+        { name: 'usePathNames', type: 'boolean', description: 'Uses FormControlName.path as FieldMetadata.name for nested manual forms.' },
+    ],
+    editableTargets: [
+        { kind: 'manualField', resolver: 'manual-form-field-by-name', description: 'Detected or declared manual field tracked by ManualFormInstance field metadata.' },
+        { kind: 'layout', resolver: 'manual-form-layout', description: 'Manual layout ownership: host template layout plus optional FormConfig sections for authored structure.' },
+        { kind: 'toolbar', resolver: 'manual-form-customization-toolbar', description: 'Customization toolbar and quick metadata toggles.' },
+        { kind: 'autosave', resolver: 'manual-form-autosave-policy', description: 'Autosave enablement, debounce and persistence key controls.' },
+        { kind: 'metadataBridge', resolver: 'manual-field-metadata-bridge', description: 'Bridge from manual fields to @praxisui/metadata-editor patches.' },
+        { kind: 'submitBehavior', resolver: 'manual-form-submit-behavior', description: 'Submit, reset, validation focus and unsaved-change behavior.' },
+    ],
+    operations: [
+        {
+            operationId: 'manualField.add',
+            title: 'Add manual field metadata',
+            scope: 'field',
+            targetKind: 'manualField',
+            target: { kind: 'manualField', resolver: 'manual-form-field-by-name', ambiguityPolicy: 'fail', required: true },
+            inputSchema: manualFieldAddSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'manual-field-add', handlerContract: {
+                        reads: ['ManualFormInstance.currentConfig', 'ManualFormInstance.currentFieldMetadata', 'ManualFieldKeyService', 'dynamic-fields-control-discovery'],
+                        writes: ['currentConfig.fieldMetadata', 'currentFieldMetadata', 'form'],
+                        identityKeys: ['fieldName'],
+                        inputSchema: manualFieldAddSchema,
+                        failureModes: ['duplicate-manual-field-id', 'control-type-not-discovered', 'host-template-field-missing', 'field-metadata-delegation-required'],
+                        description: 'Adds metadata for a manual field while preserving host-owned template layout and delegating advanced FieldMetadata edits.',
+                    } }],
+            validators: ['manual-field-id-unique', 'control-type-discovered', 'host-template-field-exists', 'metadata-bridge-does-not-redefine-schema', 'manual-form-round-trip'],
+            affectedPaths: ['currentConfig.fieldMetadata', 'currentFieldMetadata', 'form'],
+            submissionImpact: 'affects-schema-backed-data',
+            preconditions: ['manual-form-instance-loaded'],
+            destructive: false,
+            requiresConfirmation: false,
+        },
+        {
+            operationId: 'manualField.remove',
+            title: 'Remove manual field metadata',
+            scope: 'field',
+            targetKind: 'manualField',
+            target: { kind: 'manualField', resolver: 'manual-form-field-by-name', ambiguityPolicy: 'fail', required: true },
+            inputSchema: manualFieldRemoveSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'manual-field-remove', handlerContract: {
+                        reads: ['ManualFormInstance.currentConfig', 'ManualFormInstance.currentFieldMetadata', 'ManualFormInstance.form', 'FormConfig.sections'],
+                        writes: ['currentConfig.fieldMetadata', 'currentConfig.sections', 'currentFieldMetadata', 'form'],
+                        identityKeys: ['fieldName'],
+                        inputSchema: manualFieldRemoveSchema,
+                        failureModes: ['manual-field-not-found', 'field-still-referenced-by-layout', 'persisted-value-removal-not-confirmed'],
+                        description: 'Removes a manual field by stable field name and requires explicit confirmation before metadata, layout or value loss.',
+                    } }],
+            destructive: true,
+            requiresConfirmation: true,
+            validators: ['manual-field-exists', 'field-removal-confirmed', 'layout-field-references-valid', 'manual-form-round-trip'],
+            affectedPaths: ['currentConfig.fieldMetadata', 'currentConfig.sections', 'currentFieldMetadata', 'form'],
+            submissionImpact: 'affects-schema-backed-data',
+            preconditions: ['manual-form-instance-loaded', 'explicit-confirmation-provided'],
+        },
+        {
+            operationId: 'manualField.label.set',
+            title: 'Set manual field label',
+            scope: 'field',
+            targetKind: 'manualField',
+            target: { kind: 'manualField', resolver: 'manual-form-field-by-name', ambiguityPolicy: 'fail', required: true },
+            inputSchema: manualFieldLabelSetSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'manual-field-label-set', handlerContract: {
+                        reads: ['ManualFormInstance.currentFieldMetadata', 'ManualFieldMetadataBridgeService'],
+                        writes: ['currentConfig.fieldMetadata[].label', 'currentConfig.fieldMetadata[].placeholder', 'currentFieldMetadata'],
+                        identityKeys: ['fieldName'],
+                        inputSchema: manualFieldLabelSetSchema,
+                        failureModes: ['manual-field-not-found', 'label-empty', 'metadata-patch-rejected'],
+                        description: 'Sets a manual field label through the metadata bridge without redefining backend schema semantics.',
+                    } }],
+            validators: ['manual-field-exists', 'field-label-valid', 'metadata-bridge-does-not-redefine-schema', 'manual-form-round-trip'],
+            affectedPaths: ['currentConfig.fieldMetadata[].label', 'currentConfig.fieldMetadata[].placeholder', 'currentFieldMetadata'],
+            submissionImpact: 'visual-only',
+            preconditions: ['manual-form-instance-loaded'],
+            destructive: false,
+            requiresConfirmation: false,
+        },
+        {
+            operationId: 'layout.configure',
+            title: 'Configure manual form layout',
+            scope: 'layout',
+            targetKind: 'layout',
+            target: { kind: 'layout', resolver: 'manual-form-layout', ambiguityPolicy: 'fail', required: false },
+            inputSchema: layoutConfigureSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'manual-layout-configure', handlerContract: {
+                        reads: ['ManualFormInstance.currentConfig', 'FormConfig.sections', 'host-template-layout', 'praxis-dynamic-form-authoring-manifest'],
+                        writes: ['currentConfig.sections', 'usePathNames'],
+                        identityKeys: ['sectionId', 'rowId', 'columnId', 'fieldName'],
+                        inputSchema: layoutConfigureSchema,
+                        failureModes: ['layout-field-reference-missing', 'advanced-form-config-delegation-required', 'host-template-layout-conflict'],
+                        description: 'Configures manual layout metadata and delegates advanced FormConfig layout semantics to the dynamic-form manifest.',
+                    } }],
+            validators: ['layout-field-references-valid', 'manual-layout-does-not-replace-host-template', 'delegates-form-config', 'manual-form-round-trip'],
+            affectedPaths: ['currentConfig.sections', 'usePathNames'],
+            submissionImpact: 'config-only',
+            preconditions: ['manual-form-instance-loaded'],
+            destructive: false,
+            requiresConfirmation: false,
+        },
+        {
+            operationId: 'toolbar.configure',
+            title: 'Configure manual form customization toolbar',
+            scope: 'toolbarUi',
+            targetKind: 'toolbar',
+            target: { kind: 'toolbar', resolver: 'manual-form-customization-toolbar', ambiguityPolicy: 'fail', required: false },
+            inputSchema: toolbarConfigureSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'manual-toolbar-configure', handlerContract: {
+                        reads: ['ManualFormComponent.enableCustomization', 'ManualFieldToolbarComponent', 'ManualFieldEditorOnDblclickDirective'],
+                        writes: ['enableCustomization'],
+                        identityKeys: ['formId'],
+                        inputSchema: toolbarConfigureSchema,
+                        failureModes: ['toolbar-disabled-with-required-bridge', 'unsupported-toolbar-flag'],
+                        description: 'Configures the manual customization toolbar and keeps metadata edit entry points behind enableCustomization.',
+                    } }],
+            validators: ['toolbar-flags-supported', 'metadata-bridge-gated-by-customization', 'manual-form-round-trip'],
+            affectedPaths: ['enableCustomization'],
+            submissionImpact: 'visual-only',
+            preconditions: ['manual-form-component-loaded'],
+            destructive: false,
+            requiresConfirmation: false,
+        },
+        {
+            operationId: 'autosave.enabled.set',
+            title: 'Set manual form autosave policy',
+            scope: 'interaction',
+            targetKind: 'autosave',
+            target: { kind: 'autosave', resolver: 'manual-form-autosave-policy', ambiguityPolicy: 'fail', required: false },
+            inputSchema: autosaveEnabledSetSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'manual-autosave-enabled-set', handlerContract: {
+                        reads: ['enableAutoSave', 'autoSaveDebounceMs', 'ManualFormPersistenceOptions', 'ASYNC_CONFIG_STORAGE'],
+                        writes: ['enableAutoSave', 'autoSaveDebounceMs', 'persistenceOptions'],
+                        identityKeys: ['formId', 'storageKey', 'namespace', 'tenantId', 'profileId'],
+                        inputSchema: autosaveEnabledSetSchema,
+                        failureModes: ['autosave-storage-missing', 'unsafe-debounce', 'ambiguous-storage-key', 'ssr-storage-not-safe'],
+                        description: 'Sets autosave explicitly and requires safe debounce plus deterministic persistence key composition.',
+                    } }],
+            validators: ['autosave-explicit', 'autosave-debounce-safe', 'autosave-storage-available', 'persistence-key-deterministic', 'manual-form-round-trip'],
+            affectedPaths: ['enableAutoSave', 'autoSaveDebounceMs', 'persistenceOptions'],
+            submissionImpact: 'config-only',
+            preconditions: ['manual-form-instance-loaded'],
+            destructive: false,
+            requiresConfirmation: false,
+        },
+        {
+            operationId: 'submitBehavior.set',
+            title: 'Set manual form submit behavior',
+            scope: 'interaction',
+            targetKind: 'submitBehavior',
+            target: { kind: 'submitBehavior', resolver: 'manual-form-submit-behavior', ambiguityPolicy: 'fail', required: false },
+            inputSchema: submitBehaviorSetSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'manual-submit-behavior-set', handlerContract: {
+                        reads: ['ManualFormComponent.submitted', 'ManualFormInstance.form', 'FormConfig.behavior', 'praxis-dynamic-form-authoring-manifest'],
+                        writes: ['currentConfig.behavior', 'submitted', 'saved', 'resetEvent'],
+                        identityKeys: ['formId', 'action'],
+                        inputSchema: submitBehaviorSetSchema,
+                        failureModes: ['submit-action-unsupported', 'advanced-form-submit-delegation-required', 'validation-focus-target-missing'],
+                        description: 'Configures manual submit/reset behavior and delegates dynamic-form submit payload semantics to the dynamic-form manifest.',
+                    } }],
+            validators: ['submit-behavior-supported', 'delegates-form-config', 'manual-form-round-trip'],
+            affectedPaths: ['currentConfig.behavior', 'submitted', 'saved', 'resetEvent'],
+            submissionImpact: 'affects-submission',
+            preconditions: ['manual-form-instance-loaded'],
+            destructive: false,
+            requiresConfirmation: false,
+        },
+        {
+            operationId: 'metadataBridge.configure',
+            title: 'Configure manual metadata bridge',
+            scope: 'fieldMetadataPath',
+            targetKind: 'metadataBridge',
+            target: { kind: 'metadataBridge', resolver: 'manual-field-metadata-bridge', ambiguityPolicy: 'fail', required: false },
+            inputSchema: metadataBridgeConfigureSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'manual-metadata-bridge-configure', handlerContract: {
+                        reads: ['ManualFieldMetadataBridgeService', 'SettingsPanelService', 'PRAXIS_METADATA_EDITOR_AUTHORING_MANIFEST', 'dynamic-fields-discovery'],
+                        writes: ['enableCustomization', 'currentFieldMetadata', 'currentConfig.fieldMetadata'],
+                        identityKeys: ['formId', 'fieldName', 'openMode'],
+                        inputSchema: metadataBridgeConfigureSchema,
+                        failureModes: ['metadata-editor-unavailable', 'field-metadata-delegation-required', 'control-discovery-delegation-required', 'draft-persistence-failed'],
+                        description: 'Configures the bridge that opens metadata-editor for manual fields and persists accepted patches through ManualFormInstance.',
+                    } }],
+            validators: ['metadata-bridge-does-not-redefine-schema', 'delegates-field-metadata', 'control-type-discovered', 'metadata-bridge-gated-by-customization', 'manual-form-round-trip'],
+            affectedPaths: ['enableCustomization', 'currentFieldMetadata', 'currentConfig.fieldMetadata'],
+            submissionImpact: 'affects-schema-backed-data',
+            preconditions: ['manual-form-instance-loaded'],
+            destructive: false,
+            requiresConfirmation: false,
+        },
+    ],
+    validators: [
+        { validatorId: 'manual-field-id-unique', level: 'error', code: 'MANUAL_FORM_FIELD_ID_UNIQUE', description: 'Manual field names must be unique in the instance metadata map.' },
+        { validatorId: 'manual-field-exists', level: 'error', code: 'MANUAL_FORM_FIELD_EXISTS', description: 'Target manual field must exist before patching or removing it.' },
+        { validatorId: 'field-removal-confirmed', level: 'error', code: 'MANUAL_FORM_FIELD_REMOVAL_CONFIRMED', description: 'Removing a field or its persisted value requires explicit confirmation.' },
+        { validatorId: 'field-label-valid', level: 'error', code: 'MANUAL_FORM_FIELD_LABEL_VALID', description: 'Manual field label must be a non-empty user-facing string.' },
+        { validatorId: 'host-template-field-exists', level: 'error', code: 'MANUAL_FORM_HOST_FIELD_EXISTS', description: 'Manual field metadata must correspond to a host template control or declared metadata bridge target.' },
+        { validatorId: 'control-type-discovered', level: 'error', code: 'MANUAL_FORM_CONTROL_TYPE_DISCOVERED', description: 'Control type must be discovered through dynamic-fields mappings or delegated discovery.' },
+        { validatorId: 'metadata-bridge-does-not-redefine-schema', level: 'error', code: 'MANUAL_FORM_METADATA_BRIDGE_SCHEMA_SAFE', description: 'Metadata bridge patches must not silently redefine backend schema or schema-driven FormConfig semantics.' },
+        { validatorId: 'delegates-field-metadata', level: 'error', code: 'MANUAL_FORM_DELEGATES_FIELD_METADATA', description: 'Advanced FieldMetadata edits must be delegated to the metadata-editor manifest.' },
+        { validatorId: 'delegates-form-config', level: 'error', code: 'MANUAL_FORM_DELEGATES_FORM_CONFIG', description: 'Advanced FormConfig semantics must be delegated to the dynamic-form manifest.' },
+        { validatorId: 'layout-field-references-valid', level: 'error', code: 'MANUAL_FORM_LAYOUT_FIELD_REFERENCES_VALID', description: 'Layout field references must resolve to manual fields.' },
+        { validatorId: 'manual-layout-does-not-replace-host-template', level: 'error', code: 'MANUAL_FORM_LAYOUT_HOST_TEMPLATE_SAFE', description: 'Manual layout metadata must not pretend to rewrite host-owned HTML template structure.' },
+        { validatorId: 'toolbar-flags-supported', level: 'error', code: 'MANUAL_FORM_TOOLBAR_FLAGS_SUPPORTED', description: 'Toolbar quick edit flags must be supported by the manual field toolbar.' },
+        { validatorId: 'metadata-bridge-gated-by-customization', level: 'error', code: 'MANUAL_FORM_METADATA_BRIDGE_GATED', description: 'Metadata bridge entry points must respect enableCustomization.' },
+        { validatorId: 'autosave-explicit', level: 'error', code: 'MANUAL_FORM_AUTOSAVE_EXPLICIT', description: 'Autosave enablement and persistence policy must be explicit.' },
+        { validatorId: 'autosave-debounce-safe', level: 'error', code: 'MANUAL_FORM_AUTOSAVE_DEBOUNCE_SAFE', description: 'Autosave debounce must be positive and safe for storage backends.' },
+        { validatorId: 'autosave-storage-available', level: 'error', code: 'MANUAL_FORM_AUTOSAVE_STORAGE_AVAILABLE', description: 'Autosave requires a valid AsyncConfigStorage implementation.' },
+        { validatorId: 'persistence-key-deterministic', level: 'error', code: 'MANUAL_FORM_PERSISTENCE_KEY_DETERMINISTIC', description: 'Persistence key composition must be deterministic across reopen/reload.' },
+        { validatorId: 'submit-behavior-supported', level: 'error', code: 'MANUAL_FORM_SUBMIT_BEHAVIOR_SUPPORTED', description: 'Submit behavior must map to supported manual form outputs or delegated dynamic-form semantics.' },
+        { validatorId: 'manual-form-round-trip', level: 'error', code: 'MANUAL_FORM_ROUND_TRIP', description: 'Open, edit, apply/save, reopen and runtime consume must preserve manual form config.' },
+    ],
+    roundTripRequirements: [
+        'ManualFormInstance is the package-level runtime document: config, field metadata map, FormGroup and persistence key must remain coherent.',
+        'Manual field ids are stable field names; array indexes are not canonical identity.',
+        'Field removal is destructive and requires confirmation before metadata, layout references or persisted values are removed.',
+        'Autosave must be explicit, have a safe debounce and use deterministic persistence key composition through ManualFormPersistenceOptions.',
+        'The metadata bridge may apply metadata-editor patches but must not silently redefine backend schema or duplicate FieldMetadata semantics.',
+        'Advanced FormConfig authoring belongs to praxis-dynamic-form; this manifest governs manual form orchestration and delegates deeper FormConfig semantics.',
+    ],
+    examples: [
+        { id: 'add-text-field', request: 'Add a manual text field for customer name.', operationId: 'manualField.add', params: { fieldName: 'customerName', controlType: 'input', label: 'Customer name', source: 'manual-template', delegateFieldMetadataTo: 'praxis-metadata-editor' }, isPositive: true },
+        { id: 'remove-obsolete-field', request: 'Remove the obsolete nickname field from the manual form.', operationId: 'manualField.remove', params: { fieldName: 'nickname', removeFromLayout: true, clearPersistedValue: true }, isPositive: true },
+        { id: 'rename-label', request: 'Change the label of cpf to CPF/CNPJ.', operationId: 'manualField.label.set', params: { fieldName: 'cpf', label: 'CPF/CNPJ' }, isPositive: true },
+        { id: 'enable-path-names', request: 'Use nested form paths as field names.', operationId: 'layout.configure', params: { usePathNames: true }, isPositive: true },
+        { id: 'configure-toolbar', request: 'Enable customization toolbar with required and hidden toggles.', operationId: 'toolbar.configure', params: { enableCustomization: true, editableFlags: ['required', 'hidden', 'openMetadataEditor'] }, isPositive: true },
+        { id: 'enable-autosave', request: 'Enable autosave every second for this tenant profile.', operationId: 'autosave.enabled.set', params: { enabled: true, debounceMs: 1000, namespace: 'sales', tenantId: 'acme', profileId: 'admin' }, isPositive: true },
+        { id: 'set-submit-behavior', request: 'Focus the first invalid field and scroll to errors on submit.', operationId: 'submitBehavior.set', params: { action: 'submit', focusFirstError: true, scrollToErrors: true }, isPositive: true },
+        { id: 'configure-metadata-bridge', request: 'Open metadata editor from the toolbar and persist draft after patch.', operationId: 'metadataBridge.configure', params: { enabled: true, openMode: 'field-toolbar', persistDraftAfterPatch: true, delegateFieldMetadataTo: 'praxis-metadata-editor', delegateControlDiscoveryTo: 'praxis-dynamic-fields' }, isPositive: true },
+        { id: 'reject-duplicate-field', request: 'Add another customerName field with a different label.', operationId: 'manualField.add', params: { fieldName: 'customerName', controlType: 'input', label: 'Duplicate customer' }, isPositive: false },
+        { id: 'reject-unconfirmed-removal', request: 'Remove email and clear its saved value without confirmation.', operationId: 'manualField.remove', params: { fieldName: 'email', clearPersistedValue: true }, isPositive: false },
+        { id: 'reject-unsafe-autosave', request: 'Autosave every millisecond with no storage identity.', operationId: 'autosave.enabled.set', params: { enabled: true, debounceMs: 1 }, isPositive: false },
+        { id: 'reject-schema-redefinition', request: 'Use manual form metadata bridge to replace the backend schema for cpf.', operationId: 'metadataBridge.configure', params: { enabled: true, fieldName: 'cpf', backendSchemaOverride: { type: 'number' } }, isPositive: false },
+    ],
+};
+
 /*
  * Public API Surface of praxis-manual-form
  */
@@ -5367,4 +6394,4 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImpo
  * Generated bundle index. Do not edit.
  */
 
-export { MANUAL_FORM_AI_CAPABILITIES, MANUAL_FORM_CONSTRUCTOR_TO_CONTROL_TYPE, MANUAL_FORM_SELECTOR_TO_CONTROL_TYPE, ManualFieldDirective, ManualFieldEditorOnDblclickDirective, ManualFieldKeyService, ManualFieldMetadataBridgeService, ManualFormActionsComponent, ManualFormComponent, ManualFormConfigEditorComponent, ManualFormDocExampleComponent, ManualFormDocExampleShowcaseComponent, ManualFormHeaderComponent, ManualFormInstance, ManualFormInstanceFactory, createManualFormSeed, toFieldMetadataMap };
+export { MANUAL_FORM_AI_CAPABILITIES, MANUAL_FORM_CONSTRUCTOR_TO_CONTROL_TYPE, MANUAL_FORM_SELECTOR_TO_CONTROL_TYPE, ManualFieldDirective, ManualFieldEditorOnDblclickDirective, ManualFieldKeyService, ManualFieldMetadataBridgeService, ManualFormActionsComponent, ManualFormComponent, ManualFormConfigEditorComponent, ManualFormDocExampleComponent, ManualFormDocExampleShowcaseComponent, ManualFormHeaderComponent, ManualFormInstance, ManualFormInstanceFactory, PRAXIS_MANUAL_FORM_AUTHORING_MANIFEST, createManualFormSeed, toFieldMetadataMap };