@praxisui/manual-form 8.0.0-beta.2 → 8.0.0-beta.20

package/README.md

@@ -368,6 +368,32 @@ Modo dinâmico (sem host tipado):
 - 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`.

package/fesm2022/praxisui-manual-form.mjs

@@ -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'],
@@ -5359,6 +5359,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 +5709,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 };

package/index.d.ts

@@ -1,4 +1,4 @@
-import { FormConfig, FieldMetadata, DynamicFormService, AsyncConfigStorage, FormActionsLayout, FormActionButton, AiCapability, FormMessagesLayout, FormBehaviorLayout, FormHookStage, FieldDefinition, FieldControlType, AiCapabilityCategory, AiValueKind, AiCapabilityCatalog } from '@praxisui/core';
+import { FormConfig, FieldMetadata, DynamicFormService, AsyncConfigStorage, FormActionsLayout, FormActionButton, AiCapability, FormMessagesLayout, FormBehaviorLayout, FormHookStage, FieldDefinition, FieldControlType, AiCapabilityCategory, AiValueKind, AiCapabilityCatalog, ComponentAuthoringManifest } from '@praxisui/core';
 import { FormGroup, FormControlName, FormGroupName, AbstractControl, FormControl } from '@angular/forms';
 import { Observable, BehaviorSubject } from 'rxjs';
 import * as _angular_core from '@angular/core';
@@ -524,5 +524,7 @@ interface CapabilityCatalog extends AiCapabilityCatalog {
 }
 declare const MANUAL_FORM_AI_CAPABILITIES: CapabilityCatalog;
 
-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 };
+declare const PRAXIS_MANUAL_FORM_AUTHORING_MANIFEST: ComponentAuthoringManifest;
+
+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 };
 export type { Capability, CapabilityCatalog, CapabilityCategory, ManualFieldKeyResolution, ManualFieldMetadataMap, ManualFormDocExampleLevel, ManualFormDocExampleTab, ManualFormId, ManualFormPersistenceOptions, ManualFormSeed, ManualFormSeedOptions, ManualFormSnapshot, ManualFormState, ValueKind };

package/package.json

@@ -1,14 +1,20 @@
 {
   "name": "@praxisui/manual-form",
-  "version": "8.0.0-beta.2",
+  "version": "8.0.0-beta.20",
   "description": "Manual form toolkit for Praxis UI: container, instance factory and editor bridge for @praxisui/* fields.",
   "peerDependencies": {
     "@angular/common": "^20.1.0",
     "@angular/core": "^20.1.0",
-    "@praxisui/core": "^8.0.0-beta.2",
-    "@praxisui/dynamic-fields": "^8.0.0-beta.2",
-    "@praxisui/settings-panel": "^8.0.0-beta.2",
-    "@praxisui/metadata-editor": "^8.0.0-beta.2"
+    "@praxisui/core": "^8.0.0-beta.20",
+    "@praxisui/dynamic-fields": "^8.0.0-beta.20",
+    "@praxisui/settings-panel": "^8.0.0-beta.20",
+    "@praxisui/metadata-editor": "^8.0.0-beta.20",
+    "@angular/cdk": "^20.1.0",
+    "@angular/forms": "^20.1.0",
+    "@angular/material": "^20.1.0",
+    "@angular/router": "^20.1.0",
+    "@praxisui/ai": "^8.0.0-beta.20",
+    "rxjs": "~7.8.0"
   },
   "dependencies": {
     "tslib": "^2.3.0"