@praxisui/metadata-editor 8.0.0-beta.11 → 8.0.0-beta.12

package/README.md

@@ -122,6 +122,32 @@ Funcionalidades:
 - `SchemaNormalizerService` — normaliza defaults, converte valores e aplica opções de provider.
 - `ContextValidatorRegistryService` — registrador de validadores contextuais.
 
+## Agentic Authoring Contract
+
+`praxis-metadata-editor` publica um manifesto executavel em `PRAXIS_METADATA_EDITOR_AUTHORING_MANIFEST`.
+
+Esse contrato governa a edicao estrutural de metadata:
+
+- propriedades canonicas de `FieldMetadata`
+- troca de `controlType` com descoberta em dynamic-fields
+- `optionSource`
+- cascatas e `dependencyFilterMap`
+- cobertura do renderer visual
+- regras de validacao
+- hints/contexto
+- normalizacao de schema
+
+O manifesto nao cria shapes paralelos para hosts. Quando a metadata vier de backend `x-ui`, a edicao deve preservar a semantica canonica, especialmente `x-ui.optionSource.dependsOn` e `x-ui.optionSource.dependencyFilterMap`. Suporte apenas por JSON cru nao e aceito quando a propriedade exige cobertura visual no editor.
+
+Regras do contrato:
+
+- `FieldMetadata` e o documento canonico editado.
+- `controlType` precisa existir na descoberta de dynamic-fields e na cobertura visual do metadata-editor.
+- cascatas devem preservar campos existentes, evitar ciclos e manter a distincao entre a forma backend `x-ui.optionSource.dependsOn`/`dependencyFilterMap` e o contrato de save do editor em `dependencyFields`/`dependencyFilterMap`.
+- normalizacao nao pode remover propriedades canonicas avancadas.
+- round-trip deve preservar abrir, editar, aplicar/salvar, reabrir e consumo runtime.
+- cada operacao declara target, resolver, ambiguity policy, preconditions, validators, effects, affected paths e `submissionImpact` tipado.
+
 ## Build e Publicação
 
 ```bash

package/fesm2022/praxisui-metadata-editor.mjs

@@ -8724,6 +8724,353 @@ const METADATA_EDITOR_AI_CAPABILITY_CATALOG = {
     enums: {},
 };
 
+const fieldMetadataPropertySchema = {
+    type: 'object',
+    required: ['path', 'value'],
+    properties: {
+        path: {
+            enum: [
+                'name',
+                'label',
+                'description',
+                'controlType',
+                'placeholder',
+                'defaultValue',
+                'group',
+                'order',
+                'required',
+                'disabled',
+                'readOnly',
+                'hidden',
+                'source',
+                'transient',
+                'submitPolicy',
+                'hint',
+                'helpText',
+                'tooltip',
+                'options',
+                'optionSource',
+                'validators',
+                'conditionalRequired',
+                'conditionalDisplay',
+                'visibleIn',
+                'ariaLabel',
+                'ariaDescribedBy',
+            ],
+        },
+        value: {},
+        merge: { type: 'boolean' },
+    },
+};
+const optionSourceSchema = {
+    type: 'object',
+    minProperties: 1,
+    properties: {
+        kind: { enum: ['static', 'remote', 'resource', 'lookup'] },
+        resource: { type: 'string' },
+        endpoint: { type: 'string' },
+        valueField: { type: 'string' },
+        labelField: { type: 'string' },
+        dependsOn: { type: 'string' },
+        dependencyFilterMap: { type: 'object' },
+        options: { type: 'array' },
+    },
+};
+const cascadeSchema = {
+    type: 'object',
+    required: ['dependentField'],
+    properties: {
+        dependentField: { type: 'string' },
+        sourceField: { type: 'string' },
+        strategy: { enum: ['replace', 'merge'] },
+        debounceMs: { type: 'number' },
+        loadMode: { enum: ['immediate', 'manual', 'respectLoadOn'] },
+        dependencyFilterMap: { type: 'object' },
+    },
+};
+const PRAXIS_METADATA_EDITOR_AUTHORING_MANIFEST = {
+    schemaVersion: '1.0.0',
+    componentId: 'praxis-metadata-editor',
+    ownerPackage: '@praxisui/metadata-editor',
+    configSchemaId: 'FieldMetadata',
+    manifestVersion: '1.0.0',
+    runtimeInputs: [
+        { name: 'controlType', type: 'FieldControlType', description: 'Canonical control type used to resolve editor property coverage.' },
+        { name: 'seed', type: 'Partial<FieldMetadata | FieldDefinition>', description: 'Initial canonical field metadata used to hydrate the editor.' },
+        { name: 'fields', type: 'Array<FieldMetadata | FieldDefinition>', description: 'Available fields used by cascade authoring and context validation.' },
+        { name: 'properties', type: 'EditorProperty[]', description: 'Renderer property catalog resolved from ConfigRegistryService.' },
+        { name: 'form', type: 'FormGroup', description: 'Dynamic form generated from canonical editor properties by DynamicFormFactoryService.' },
+    ],
+    editableTargets: [
+        { kind: 'fieldMetadata', resolver: 'field-metadata-json-path', description: 'Canonical FieldMetadata root and property paths.' },
+        { kind: 'controlType', resolver: 'dynamic-fields-control-type-discovery', description: 'Control type selected from dynamic-fields discovery and editor config registry.' },
+        { kind: 'optionSource', resolver: 'field-metadata-option-source', description: 'Canonical option source including backend x-ui option source fields where applicable.' },
+        { kind: 'cascade', resolver: 'metadata-editor-cascade-rules', description: 'Cascade dependencies and dependency filter mappings edited through CascadeManagerTab.' },
+        { kind: 'renderer', resolver: 'metadata-editor-renderer-property', description: 'Dynamic editor renderer property coverage and editor component mapping.' },
+        { kind: 'validation', resolver: 'field-metadata-validation-rules', description: 'Field validation rules and contextual validators.' },
+        { kind: 'contextHint', resolver: 'metadata-editor-context-hints', description: 'Authoring hints, help text and contextual guidance for metadata editors.' },
+        { kind: 'normalization', resolver: 'metadata-editor-schema-normalizer', description: 'Schema normalization and seed hydration rules.' },
+    ],
+    operations: [
+        {
+            operationId: 'fieldMetadata.property.set',
+            title: 'Set FieldMetadata property',
+            scope: 'fieldMetadataPath',
+            targetKind: 'fieldMetadata',
+            target: { kind: 'fieldMetadata', resolver: 'field-metadata-json-path', ambiguityPolicy: 'fail', required: true },
+            inputSchema: fieldMetadataPropertySchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'metadata-field-property-set', handlerContract: {
+                        reads: ['fieldMetadata', 'fieldMetadataPath', 'SchemaNormalizerService'],
+                        writes: ['fieldMetadata'],
+                        identityKeys: ['field.name', 'path'],
+                        inputSchema: fieldMetadataPropertySchema,
+                        failureModes: ['unknown-field-metadata-path', 'non-canonical-shape', 'readonly-field', 'normalization-failed'],
+                        description: 'Sets a canonical FieldMetadata property through a governed metadata path and re-runs schema normalization.',
+                    } }],
+            destructive: false,
+            requiresConfirmation: false,
+            validators: ['field-metadata-shape-canonical', 'field-path-supported-by-editor', 'metadata-round-trip'],
+            affectedPaths: ['fieldMetadata'],
+            submissionImpact: 'affects-schema-backed-data',
+            preconditions: ['field-metadata-loaded'],
+        },
+        {
+            operationId: 'controlType.set',
+            title: 'Set control type',
+            scope: 'controlType',
+            targetKind: 'controlType',
+            target: { kind: 'controlType', resolver: 'dynamic-fields-control-type-discovery', ambiguityPolicy: 'fail', required: true },
+            inputSchema: {
+                type: 'object',
+                required: ['controlType'],
+                properties: {
+                    controlType: { type: 'string' },
+                    preserveCompatibleProperties: { type: 'boolean' },
+                },
+            },
+            effects: [{ kind: 'compile-domain-patch', handler: 'metadata-control-type-set', handlerContract: {
+                        reads: ['FieldControlType', 'ConfigRegistryService', 'dynamic-fields-discovery', 'fieldMetadata'],
+                        writes: ['fieldMetadata.controlType', 'properties', 'normalizedSeed'],
+                        identityKeys: ['field.name', 'controlType'],
+                        inputSchema: { type: 'object', required: ['controlType'], properties: { controlType: { type: 'string' }, preserveCompatibleProperties: { type: 'boolean' } } },
+                        failureModes: ['control-type-not-discovered', 'editor-coverage-missing', 'incompatible-metadata-preservation'],
+                        description: 'Changes control type only when dynamic-fields discovery and metadata-editor config registry both expose renderer/editor coverage.',
+                    } }],
+            destructive: false,
+            requiresConfirmation: false,
+            validators: ['control-type-exists-in-discovery', 'editor-coverage-exists', 'metadata-round-trip'],
+            affectedPaths: ['fieldMetadata.controlType', 'properties', 'normalizedSeed'],
+            submissionImpact: 'affects-schema-backed-data',
+            preconditions: ['dynamic-fields-discovery-loaded'],
+        },
+        {
+            operationId: 'optionSource.configure',
+            title: 'Configure option source',
+            scope: 'dataBinding',
+            targetKind: 'optionSource',
+            target: { kind: 'optionSource', resolver: 'field-metadata-option-source', ambiguityPolicy: 'fail', required: false },
+            inputSchema: optionSourceSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'metadata-option-source-configure', handlerContract: {
+                        reads: ['fieldMetadata.optionSource', 'backend.x-ui.optionSource', 'SchemaNormalizerService'],
+                        writes: ['fieldMetadata.optionSource'],
+                        identityKeys: ['field.name', 'optionSource.kind', 'optionSource.resource'],
+                        inputSchema: optionSourceSchema,
+                        failureModes: ['invalid-option-source-kind', 'remote-source-missing-governed-resource', 'dependency-filter-map-invalid'],
+                        description: 'Configures canonical optionSource fields while preserving backend x-ui dependsOn and dependencyFilterMap semantics.',
+                    } }],
+            destructive: false,
+            requiresConfirmation: false,
+            validators: ['option-source-shape-canonical', 'remote-option-source-governed', 'cascade-backend-shape-preserved', 'metadata-round-trip'],
+            affectedPaths: ['fieldMetadata.optionSource'],
+            submissionImpact: 'affects-remote-binding',
+            preconditions: ['field-metadata-loaded'],
+        },
+        {
+            operationId: 'cascade.configure',
+            title: 'Configure cascade rule',
+            scope: 'interaction',
+            targetKind: 'cascade',
+            target: { kind: 'cascade', resolver: 'metadata-editor-cascade-rules', ambiguityPolicy: 'fail', required: false },
+            inputSchema: cascadeSchema,
+            effects: [{ kind: 'compile-domain-patch', handler: 'metadata-cascade-configure', handlerContract: {
+                        reads: ['CascadeManagerTabComponent', 'CascadeRulesService', 'fields', 'fieldMetadata.optionSource', 'fieldMetadata.dependencyFields', 'fieldMetadata.dependencyFilterMap'],
+                        writes: ['fieldMetadata.dependencyFields', 'fieldMetadata.enableDependencyCascade', 'fieldMetadata.resetOnDependentChange', 'fieldMetadata.dependencyFilterMap', 'fieldMetadata.dependencyValuePath', 'fieldMetadata.dependencyMergeStrategy', 'fieldMetadata.dependencyDebounceMs', 'fieldMetadata.dependencyLoadOnChange'],
+                        identityKeys: ['dependentField', 'sourceField'],
+                        inputSchema: cascadeSchema,
+                        failureModes: ['dependent-field-not-found', 'source-field-not-found', 'cascade-cycle-detected', 'dependency-filter-map-invalid'],
+                        description: 'Applies cascade dependencies through CascadeRulesService using the metadata-editor save contract while preserving backend x-ui optionSource dependency semantics during hydration.',
+                    } }],
+            destructive: false,
+            requiresConfirmation: false,
+            validators: ['cascade-fields-exist', 'cascade-cycle-free', 'cascade-backend-shape-preserved', 'metadata-round-trip'],
+            affectedPaths: ['fieldMetadata.dependencyFields', 'fieldMetadata.enableDependencyCascade', 'fieldMetadata.resetOnDependentChange', 'fieldMetadata.dependencyFilterMap', 'fieldMetadata.dependencyValuePath', 'fieldMetadata.dependencyMergeStrategy', 'fieldMetadata.dependencyDebounceMs', 'fieldMetadata.dependencyLoadOnChange'],
+            submissionImpact: 'config-only',
+            preconditions: ['field-list-loaded'],
+        },
+        {
+            operationId: 'renderer.configure',
+            title: 'Configure renderer coverage',
+            scope: 'editorCoverage',
+            targetKind: 'renderer',
+            target: { kind: 'renderer', resolver: 'metadata-editor-renderer-property', ambiguityPolicy: 'fail', required: true },
+            inputSchema: {
+                type: 'object',
+                required: ['propertyName', 'editorType'],
+                properties: {
+                    propertyName: { type: 'string' },
+                    editorType: { type: 'string' },
+                    group: { type: 'string' },
+                    required: { type: 'boolean' },
+                    options: { type: 'array' },
+                },
+            },
+            effects: [{ kind: 'compile-domain-patch', handler: 'metadata-renderer-configure', handlerContract: {
+                        reads: ['DynamicEditorRendererComponent', 'EditorComponentRegistryService', 'ConfigRegistryService', 'EditorProperty'],
+                        writes: ['properties', 'editorCoverage'],
+                        identityKeys: ['controlType', 'propertyName'],
+                        inputSchema: { type: 'object', required: ['propertyName', 'editorType'], properties: { propertyName: { type: 'string' }, editorType: { type: 'string' }, group: { type: 'string' } } },
+                        failureModes: ['editor-type-not-registered', 'property-not-covered', 'json-only-coverage-not-accepted'],
+                        description: 'Configures visual renderer coverage for a metadata property and rejects JSON-only support for required visual authoring.',
+                    } }],
+            destructive: false,
+            requiresConfirmation: false,
+            validators: ['renderer-editor-type-registered', 'visual-editor-coverage-required', 'editor-coverage-exists', 'metadata-round-trip'],
+            affectedPaths: ['properties', 'editorCoverage'],
+            submissionImpact: 'config-only',
+            preconditions: ['config-registry-loaded'],
+        },
+        {
+            operationId: 'validationRule.add',
+            title: 'Add validation rule',
+            scope: 'fieldMetadataPath',
+            targetKind: 'validation',
+            target: { kind: 'validation', resolver: 'field-metadata-validation-rules', ambiguityPolicy: 'fail', required: false },
+            inputSchema: {
+                type: 'object',
+                required: ['rule'],
+                properties: {
+                    rule: { type: 'object' },
+                    message: { type: 'string' },
+                    contextValidatorId: { type: 'string' },
+                },
+            },
+            effects: [{ kind: 'compile-domain-patch', handler: 'metadata-validation-rule-add', handlerContract: {
+                        reads: ['fieldMetadata.validators', 'ContextValidatorRegistryService', 'DynamicFormFactoryService'],
+                        writes: ['fieldMetadata.validators'],
+                        identityKeys: ['field.name', 'rule.type', 'contextValidatorId'],
+                        inputSchema: { type: 'object', required: ['rule'], properties: { rule: { type: 'object' }, message: { type: 'string' }, contextValidatorId: { type: 'string' } } },
+                        failureModes: ['validation-rule-invalid', 'context-validator-not-registered', 'duplicate-validation-rule'],
+                        description: 'Adds a canonical validation rule and verifies contextual validator availability before persistence.',
+                    } }],
+            destructive: false,
+            requiresConfirmation: false,
+            validators: ['validation-rule-canonical', 'context-validator-registered', 'metadata-round-trip'],
+            affectedPaths: ['fieldMetadata.validators'],
+            submissionImpact: 'affects-submission',
+            preconditions: ['field-metadata-loaded'],
+        },
+        {
+            operationId: 'contextHint.set',
+            title: 'Set metadata context hint',
+            scope: 'meta',
+            targetKind: 'contextHint',
+            target: { kind: 'contextHint', resolver: 'metadata-editor-context-hints', ambiguityPolicy: 'fail', required: false },
+            inputSchema: {
+                type: 'object',
+                required: ['hintPath', 'value'],
+                properties: {
+                    hintPath: { enum: ['hint', 'helpText', 'description', 'tooltip', 'ariaLabel', 'ariaDescribedBy'] },
+                    value: {},
+                    localeKey: { type: 'string' },
+                },
+            },
+            effects: [{ kind: 'compile-domain-patch', handler: 'metadata-context-hint-set', handlerContract: {
+                        reads: ['fieldMetadata.hint', 'fieldMetadata.helpText', 'fieldMetadata.description', 'fieldMetadata.tooltip', 'fieldMetadata.ariaLabel', 'fieldMetadata.ariaDescribedBy', 'metadata-editor-i18n'],
+                        writes: ['fieldMetadata.hint', 'fieldMetadata.helpText', 'fieldMetadata.description', 'fieldMetadata.tooltip', 'fieldMetadata.ariaLabel', 'fieldMetadata.ariaDescribedBy'],
+                        identityKeys: ['field.name', 'hintPath'],
+                        inputSchema: { type: 'object', required: ['hintPath', 'value'], properties: { hintPath: { enum: ['hint', 'helpText', 'description', 'tooltip', 'ariaLabel', 'ariaDescribedBy'] }, value: {}, localeKey: { type: 'string' } } },
+                        failureModes: ['hint-path-not-canonical', 'hint-value-not-serializable', 'i18n-key-missing'],
+                        description: 'Sets structured FieldMetadata hint/help/accessibility text through canonical metadata paths and metadata-editor i18n constraints.',
+                    } }],
+            destructive: false,
+            requiresConfirmation: false,
+            validators: ['context-hint-shape-canonical', 'context-hint-i18n-compatible', 'metadata-round-trip'],
+            affectedPaths: ['fieldMetadata.hint', 'fieldMetadata.helpText', 'fieldMetadata.description', 'fieldMetadata.tooltip', 'fieldMetadata.ariaLabel', 'fieldMetadata.ariaDescribedBy'],
+            submissionImpact: 'visual-only',
+            preconditions: ['field-metadata-loaded'],
+        },
+        {
+            operationId: 'normalization.apply',
+            title: 'Apply schema normalization',
+            scope: 'runtimeCoverage',
+            targetKind: 'normalization',
+            target: { kind: 'normalization', resolver: 'metadata-editor-schema-normalizer', ambiguityPolicy: 'fail', required: false },
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    mode: { enum: ['hydrate-seed', 'coerce-types', 'apply-defaults', 'preserve-advanced-properties'] },
+                    preserveUnknownCanonicalFields: { type: 'boolean' },
+                },
+            },
+            effects: [{ kind: 'compile-domain-patch', handler: 'metadata-normalization-apply', handlerContract: {
+                        reads: ['SchemaNormalizerService', 'fieldMetadata', 'properties', 'DynamicFormFactoryService'],
+                        writes: ['normalizedSeed', 'form', 'fieldMetadata'],
+                        identityKeys: ['field.name', 'controlType', 'mode'],
+                        inputSchema: { type: 'object', properties: { mode: { enum: ['hydrate-seed', 'coerce-types', 'apply-defaults', 'preserve-advanced-properties'] }, preserveUnknownCanonicalFields: { type: 'boolean' } } },
+                        failureModes: ['normalizer-missing', 'type-coercion-failed', 'advanced-property-lost', 'runtime-editor-drift'],
+                        description: 'Runs metadata-editor schema normalization while preserving canonical advanced FieldMetadata properties and editor/runtime round-trip.',
+                    } }],
+            destructive: false,
+            requiresConfirmation: false,
+            validators: ['normalization-preserves-canonical-fields', 'runtime-editor-round-trip', 'metadata-round-trip'],
+            affectedPaths: ['normalizedSeed', 'form', 'fieldMetadata'],
+            submissionImpact: 'config-only',
+            preconditions: ['field-metadata-loaded', 'editor-properties-loaded'],
+        },
+    ],
+    validators: [
+        { validatorId: 'field-metadata-shape-canonical', level: 'error', code: 'METADATA_FIELD_SHAPE_CANONICAL', description: 'Edited metadata must remain compatible with canonical FieldMetadata.' },
+        { validatorId: 'field-path-supported-by-editor', level: 'error', code: 'METADATA_FIELD_PATH_SUPPORTED', description: 'Edited paths must be supported by visual editor coverage or explicitly delegated.' },
+        { validatorId: 'control-type-exists-in-discovery', level: 'error', code: 'METADATA_CONTROL_TYPE_DISCOVERED', description: 'Control type must exist in dynamic-fields discovery.' },
+        { validatorId: 'editor-coverage-exists', level: 'error', code: 'METADATA_EDITOR_COVERAGE_EXISTS', description: 'Control type and property must have metadata-editor coverage.' },
+        { validatorId: 'option-source-shape-canonical', level: 'error', code: 'METADATA_OPTION_SOURCE_CANONICAL', description: 'Option source must use canonical FieldMetadata/x-ui shape.' },
+        { validatorId: 'remote-option-source-governed', level: 'error', code: 'METADATA_REMOTE_OPTION_SOURCE_GOVERNED', description: 'Remote option sources must resolve through governed resource or endpoint metadata.' },
+        { validatorId: 'cascade-fields-exist', level: 'error', code: 'METADATA_CASCADE_FIELDS_EXIST', description: 'Cascade source and dependent fields must exist.' },
+        { validatorId: 'cascade-cycle-free', level: 'error', code: 'METADATA_CASCADE_CYCLE_FREE', description: 'Cascade dependencies must not create cycles.' },
+        { validatorId: 'cascade-backend-shape-preserved', level: 'error', code: 'METADATA_CASCADE_BACKEND_SHAPE_PRESERVED', description: 'Cascade config must preserve x-ui optionSource dependsOn and dependencyFilterMap semantics.' },
+        { validatorId: 'renderer-editor-type-registered', level: 'error', code: 'METADATA_RENDERER_TYPE_REGISTERED', description: 'Renderer editor type must be registered.' },
+        { validatorId: 'visual-editor-coverage-required', level: 'error', code: 'METADATA_VISUAL_COVERAGE_REQUIRED', description: 'JSON-only support is not accepted for required visual authoring coverage.' },
+        { validatorId: 'validation-rule-canonical', level: 'error', code: 'METADATA_VALIDATION_RULE_CANONICAL', description: 'Validation rule must use canonical metadata shape.' },
+        { validatorId: 'context-validator-registered', level: 'error', code: 'METADATA_CONTEXT_VALIDATOR_REGISTERED', description: 'Contextual validator must be registered before use.' },
+        { validatorId: 'context-hint-shape-canonical', level: 'error', code: 'METADATA_CONTEXT_HINT_CANONICAL', description: 'Context hints must remain structured metadata, not free-form host-only strings.' },
+        { validatorId: 'context-hint-i18n-compatible', level: 'warning', code: 'METADATA_CONTEXT_HINT_I18N_COMPATIBLE', description: 'Authoring hint text must remain compatible with metadata-editor i18n.' },
+        { validatorId: 'normalization-preserves-canonical-fields', level: 'error', code: 'METADATA_NORMALIZATION_PRESERVES_FIELDS', description: 'Normalization must not drop canonical advanced FieldMetadata properties.' },
+        { validatorId: 'runtime-editor-round-trip', level: 'error', code: 'METADATA_RUNTIME_EDITOR_ROUND_TRIP', description: 'Runtime and editor must consume the same normalized metadata shape.' },
+        { validatorId: 'metadata-round-trip', level: 'error', code: 'METADATA_ROUND_TRIP', description: 'Open, edit, apply/save, reopen and runtime consume must preserve metadata.' },
+    ],
+    roundTripRequirements: [
+        'FieldMetadata is the canonical edited document shape; backend x-ui-derived metadata must not be rewritten into host-only aliases.',
+        'Control type changes require both dynamic-fields discovery and metadata-editor visual coverage.',
+        'Option source cascades preserve x-ui optionSource.dependsOn and optionSource.dependencyFilterMap semantics.',
+        'JSON-only support is incomplete when visual editor coverage is required.',
+        'Schema normalization must preserve advanced canonical properties through open, edit, apply/save, reopen and runtime consumption.',
+    ],
+    examples: [
+        { id: 'set-label', request: 'Set this field label to Customer name.', operationId: 'fieldMetadata.property.set', params: { path: 'label', value: 'Customer name' }, isPositive: true },
+        { id: 'set-control-type', request: 'Change this field to a select control.', operationId: 'controlType.set', params: { controlType: 'select', preserveCompatibleProperties: true }, isPositive: true },
+        { id: 'configure-remote-options', request: 'Load options from the customers resource using id and name.', operationId: 'optionSource.configure', params: { kind: 'resource', resource: 'customers', valueField: 'id', labelField: 'name' }, isPositive: true },
+        { id: 'configure-cascade', request: 'Filter city options when state changes.', operationId: 'cascade.configure', params: { dependentField: 'city', sourceField: 'state', dependencyFilterMap: { stateId: 'state.id' } }, isPositive: true },
+        { id: 'configure-renderer', request: 'Expose placeholder in the visual editor as a text field.', operationId: 'renderer.configure', params: { propertyName: 'placeholder', editorType: 'text', group: 'Presentation' }, isPositive: true },
+        { id: 'add-required-validation', request: 'Make this field required with a validation message.', operationId: 'validationRule.add', params: { rule: { type: 'required' }, message: 'Required field' }, isPositive: true },
+        { id: 'set-context-hint', request: 'Add a contextual hint for sales users.', operationId: 'contextHint.set', params: { hintPath: 'helpText', value: 'Use the legal customer name.' }, isPositive: true },
+        { id: 'normalize-seed', request: 'Normalize this imported field metadata while preserving advanced properties.', operationId: 'normalization.apply', params: { mode: 'preserve-advanced-properties', preserveUnknownCanonicalFields: true }, isPositive: true },
+        { id: 'reject-unknown-control', request: 'Use an unknown control type named magic-picker.', operationId: 'controlType.set', params: { controlType: 'magic-picker' }, isPositive: false },
+        { id: 'reject-json-only-coverage', request: 'Support this field only by editing raw JSON.', operationId: 'renderer.configure', params: { propertyName: 'optionSource', editorType: 'json' }, isPositive: false },
+        { id: 'reject-cascade-cycle', request: 'Make field A depend on B and B depend on A.', operationId: 'cascade.configure', params: { dependentField: 'a', sourceField: 'b' }, isPositive: false },
+        { id: 'reject-host-only-option-source', request: 'Save a host-only URL string as the option source.', operationId: 'optionSource.configure', params: { kind: 'remote', endpoint: 'local-only://options' }, isPositive: false },
+    ],
+};
+
 /** Metadata for Praxis Metadata Editor component */
 const PRAXIS_METADATA_EDITOR_COMPONENT_METADATA = {
     id: 'praxis-metadata-editor',
@@ -8778,4 +9125,4 @@ function providePraxisMetadataEditorMetadata() {
  * Generated bundle index. Do not edit.
  */
 
-export { CascadeManagerTabComponent, CascadeRulesService, ConfigRegistryService, ContextValidatorRegistryService, DynamicEditorRendererComponent, DynamicFormFactoryService, EditorComponentRegistryService, FieldMetadataEditorComponent, METADATA_EDITOR_AI_CAPABILITIES, METADATA_EDITOR_AI_CAPABILITY_CATALOG, PRAXIS_METADATA_EDITOR_COMPONENT_METADATA, SchemaNormalizerService, providePraxisMetadataEditorMetadata };
+export { CascadeManagerTabComponent, CascadeRulesService, ConfigRegistryService, ContextValidatorRegistryService, DynamicEditorRendererComponent, DynamicFormFactoryService, EditorComponentRegistryService, FieldMetadataEditorComponent, METADATA_EDITOR_AI_CAPABILITIES, METADATA_EDITOR_AI_CAPABILITY_CATALOG, PRAXIS_METADATA_EDITOR_AUTHORING_MANIFEST, PRAXIS_METADATA_EDITOR_COMPONENT_METADATA, SchemaNormalizerService, providePraxisMetadataEditorMetadata };

package/index.d.ts

@@ -1,5 +1,5 @@
 import { ValidatorFn, FormBuilder, FormGroup, AbstractControl } from '@angular/forms';
-import { FieldControlType, FieldDefinition, FieldMetadata, IconPickerService, AiCapabilityCatalog, ComponentDocMeta } from '@praxisui/core';
+import { FieldControlType, FieldDefinition, FieldMetadata, IconPickerService, AiCapabilityCatalog, ComponentAuthoringManifest, ComponentDocMeta } from '@praxisui/core';
 import * as i0 from '@angular/core';
 import { Type, OnChanges, SimpleChanges, OnInit, EventEmitter, Provider } from '@angular/core';
 import { MatDialog } from '@angular/material/dialog';
@@ -300,10 +300,12 @@ interface AiComponentCapabilities {
 declare const METADATA_EDITOR_AI_CAPABILITIES: AiComponentCapabilities;
 declare const METADATA_EDITOR_AI_CAPABILITY_CATALOG: AiCapabilityCatalog;
 
+declare const PRAXIS_METADATA_EDITOR_AUTHORING_MANIFEST: ComponentAuthoringManifest;
+
 /** Metadata for Praxis Metadata Editor component */
 declare const PRAXIS_METADATA_EDITOR_COMPONENT_METADATA: ComponentDocMeta;
 /** Provider para auto-registrar metadados do componente Metadata Editor. */
 declare function providePraxisMetadataEditorMetadata(): Provider;
 
-export { CascadeManagerTabComponent, CascadeRulesService, ConfigRegistryService, ContextValidatorRegistryService, DynamicEditorRendererComponent, DynamicFormFactoryService, EditorComponentRegistryService, FieldMetadataEditorComponent, METADATA_EDITOR_AI_CAPABILITIES, METADATA_EDITOR_AI_CAPABILITY_CATALOG, PRAXIS_METADATA_EDITOR_COMPONENT_METADATA, SchemaNormalizerService, providePraxisMetadataEditorMetadata };
+export { CascadeManagerTabComponent, CascadeRulesService, ConfigRegistryService, ContextValidatorRegistryService, DynamicEditorRendererComponent, DynamicFormFactoryService, EditorComponentRegistryService, FieldMetadataEditorComponent, METADATA_EDITOR_AI_CAPABILITIES, METADATA_EDITOR_AI_CAPABILITY_CATALOG, PRAXIS_METADATA_EDITOR_AUTHORING_MANIFEST, PRAXIS_METADATA_EDITOR_COMPONENT_METADATA, SchemaNormalizerService, providePraxisMetadataEditorMetadata };
 export type { CascadeRuleViewModel, ConfigMap, EditorProperty };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@praxisui/metadata-editor",
-  "version": "8.0.0-beta.11",
+  "version": "8.0.0-beta.12",
   "description": "Metadata editor for Praxis UI fields and components with runtime integration.",
   "peerDependencies": {
     "@angular/common": "^20.0.0",