@praxisui/metadata-editor 10.0.0-rc.37 → 10.0.0-rc.38

package/README.md

@@ -166,6 +166,8 @@ Funcionalidades:
 - Edição de dependentes, estratégia de merge, debounce, modo de carregamento (imediato/manual/respeitar loadOn).
 - Mapeamento de filtros com dot‑path e valuePath por dependente, preview com exemplo gerado.
 
+Abrir uma cascata e salvá-la sem alterações preserva mapeamentos de filtro não idênticos (entradas string ou objeto) e a extração `dependencyValuePath` em formato string ou mapa por dependência. Sugestões completam apenas valores ausentes. Durante a edição, as linhas de mapeamento representam o rascunho atual; um snapshot JSON anterior não sobrescreve alterações feitas na tabela. Remover uma dependência remove também o seu mapeamento e override de extração; adicioná-la novamente não recupera caminhos antigos. O preview ilustrativo não comprova a execução do filtro na API.
+
 ### Reactive Determination Diagnostics (somente leitura)
 
 `ReactiveDeterminationDiagnosticsComponent` recebe o documento exato de

package/ai/component-registry.json

@@ -1,8 +1,8 @@
 {
   "schemaVersion": "1.0.0",
-  "generatedAt": "2026-10-21T22:13:30.176Z",
+  "generatedAt": "2026-10-23T20:24:09.136Z",
   "packageName": "@praxisui/metadata-editor",
-  "packageVersion": "10.0.0-rc.37",
+  "packageVersion": "10.0.0-rc.38",
   "sourceRegistry": "praxis-component-registry-ingestion",
   "sourceRegistryVersion": "1.0.0",
   "componentCount": 1,

package/fesm2022/praxisui-metadata-editor.mjs

@@ -6,7 +6,7 @@ import * as i3$2 from '@angular/common';
 import { CommonModule } from '@angular/common';
 import { isValidCssColor, DynamicFieldLoaderDirective, normalizeCssColorToRgb, providePraxisDynamicFieldsI18n } from '@praxisui/dynamic-fields';
 import * as i2$2 from '@praxisui/core';
-import { providePraxisI18n, PraxisI18nService, PraxisIconDirective, FieldControlType, INLINE_FILTER_CONTROL_TYPES, resolveInlineFilterControlType, ResourceDiscoveryService, normalizeControlTypeToken, providePraxisI18nConfig, RESOURCE_DISCOVERY_I18N_CONFIG, normalizeReactiveDeterminations, ComponentMetadataRegistry } from '@praxisui/core';
+import { providePraxisI18n, PraxisI18nService, PraxisIconDirective, FieldControlType, INLINE_FILTER_CONTROL_TYPES, resolveInlineFilterControlType, ResourceDiscoveryService, mapCatalogFieldsToMetadata, humanizeCatalogFieldName, normalizeControlTypeToken, hasSemanticFieldCalibrationDiff, calibrateFieldMetadataFromSemantics, providePraxisI18nConfig, RESOURCE_DISCOVERY_I18N_CONFIG, normalizeReactiveDeterminations, ComponentMetadataRegistry } from '@praxisui/core';
 import * as i5$1 from '@angular/material/expansion';
 import { MatExpansionModule } from '@angular/material/expansion';
 import * as i2$1 from '@angular/material/icon';
@@ -653,6 +653,8 @@ const METADATA_EDITOR_EN_US = {
     'praxis.metadataEditor.colorPalette.moveDown': 'Move down',
     'praxis.metadataEditor.colorPalette.remove': 'Remove',
     'praxis.metadataEditor.colorPalette.invalid': 'Enter a valid CSS color or var(--token).',
+    'praxis.metadataEditor.smartCalibrate.action': 'Calibrate from schema',
+    'praxis.metadataEditor.smartCalibrate.tooltip': 'Automatically infers control type (Currency, CPF/CNPJ, Date, Email, Phone, Select, Textarea), humanized label, and corporate defaults from field name and metadata.',
 };
 
 const METADATA_EDITOR_PT_BR = {
@@ -905,6 +907,8 @@ const METADATA_EDITOR_PT_BR = {
     'praxis.metadataEditor.colorPalette.moveDown': 'Mover para baixo',
     'praxis.metadataEditor.colorPalette.remove': 'Remover',
     'praxis.metadataEditor.colorPalette.invalid': 'Informe uma cor CSS válida ou var(--token).',
+    'praxis.metadataEditor.smartCalibrate.action': 'Calibrar pelo schema',
+    'praxis.metadataEditor.smartCalibrate.tooltip': 'Infere automaticamente o tipo de controle (Moeda, CPF/CNPJ, Data, E-mail, Telefone, Seleção, Texto longo), rótulo humanizado e padrões corporativos a partir do nome e metadados do campo.',
 };
 
 function createPraxisMetadataEditorI18nConfig(options = {}) {
@@ -10925,6 +10929,7 @@ class FieldMetadataEditorComponent {
     renderedProps = [];
     initialSnapshot = null;
     initialControlType;
+    initialSeed;
     baselineReady = false;
     formRebuild$ = new Subject();
     hostApplyPatch;
@@ -11104,17 +11109,86 @@ class FieldMetadataEditorComponent {
             if (!option?.responseFields?.length) {
                 continue;
             }
-            const key = this.normalizeResourceCacheKey(option.value);
-            if (key && !this.resourceSchemaFieldsByPath.has(key)) {
-                this.resourceSchemaFieldsByPath.set(key, option.responseFields
-                    .filter((field) => Boolean(field?.name && String(field.name).trim()))
-                    .map((field) => ({
-                    name: String(field.name).trim(),
-                    label: String(field.label ?? '').trim() || String(field.name).trim(),
-                    type: String(field.type ?? field.controlType ?? 'string').trim() || 'string',
-                    controlType: String(field.controlType ?? '').trim() || undefined,
+            const mappedMetas = mapCatalogFieldsToMetadata(option.responseFields);
+            const metaByName = new Map(mappedMetas.map((meta) => [meta.name, meta]));
+            const definitions = option.responseFields
+                .filter((field) => Boolean(field?.name && String(field.name).trim()))
+                .map((field) => {
+                const name = String(field.name).trim();
+                const rawLabel = String(field.label ?? '').trim();
+                const label = rawLabel && rawLabel !== name
+                    ? rawLabel
+                    : humanizeCatalogFieldName(name);
+                const mapped = metaByName.get(name);
+                return {
+                    name,
+                    label,
+                    type: String(field.type ?? field.controlType ?? 'string').trim() ||
+                        'string',
+                    controlType: String(field.controlType ?? mapped?.controlType ?? '').trim() ||
+                        undefined,
                     description: String(field.description ?? '').trim() || undefined,
-                })));
+                    ...(typeof field.format === 'string' && field.format.trim()
+                        ? { format: field.format.trim() }
+                        : {}),
+                    ...(typeof field.required === 'boolean'
+                        ? { required: field.required }
+                        : {}),
+                    ...(typeof field.minimum === 'number'
+                        ? { minimum: field.minimum }
+                        : {}),
+                    ...(typeof field.maximum === 'number'
+                        ? { maximum: field.maximum }
+                        : {}),
+                    ...(typeof field.minLength === 'number'
+                        ? { minLength: field.minLength }
+                        : {}),
+                    ...(typeof field.maxLength === 'number'
+                        ? { maxLength: field.maxLength }
+                        : {}),
+                    ...(typeof field.pattern === 'string' && field.pattern.trim()
+                        ? { pattern: field.pattern.trim() }
+                        : {}),
+                    ...(Array.isArray(field.enumValues)
+                        ? { enumValues: field.enumValues }
+                        : {}),
+                    ...(mapped?.options?.length
+                        ? {
+                            options: mapped.options.map((opt) => {
+                                const optLabel = String(opt.label ?? opt.text ?? opt.value);
+                                return {
+                                    key: String(opt.value),
+                                    value: String(opt.value),
+                                    label: optLabel,
+                                    text: opt.text ?? optLabel,
+                                };
+                            }),
+                        }
+                        : {}),
+                };
+            });
+            if (!definitions.length) {
+                continue;
+            }
+            const candidateKeys = new Set();
+            for (const candidate of [option.value, option.path, option.resourceKey]) {
+                const raw = String(candidate ?? '').trim();
+                if (!raw)
+                    continue;
+                const normalized = this.normalizeResourceCacheKey(raw);
+                if (normalized)
+                    candidateKeys.add(normalized);
+                const stripped = raw.replace(/^\/+|\/+$/g, '');
+                if (stripped)
+                    candidateKeys.add(stripped);
+                const withoutApi = stripped.replace(/^api\/+/i, '');
+                if (withoutApi)
+                    candidateKeys.add(withoutApi);
+            }
+            for (const cacheKey of candidateKeys) {
+                if (!this.resourceSchemaFieldsByPath.has(cacheKey)) {
+                    this.resourceSchemaFieldsByPath.set(cacheKey, definitions);
+                }
             }
         }
     }
@@ -11256,6 +11330,9 @@ class FieldMetadataEditorComponent {
         if (this.initialControlType === undefined) {
             this.initialControlType = ct;
         }
+        if (this.initialSeed === undefined) {
+            this.initialSeed = this.cloneSnapshot(this.seed ?? {});
+        }
         this.controlType = ct;
         let props = this.registry.getProperties(this.controlType);
         const controlTypeToken = normalizeControlTypeToken(this.controlType);
@@ -11999,6 +12076,9 @@ class FieldMetadataEditorComponent {
         }
     }
     reset() {
+        if (this.initialSeed !== undefined) {
+            this.seed = this.cloneSnapshot(this.initialSeed);
+        }
         if (this.initialControlType !== undefined && this.controlType !== this.initialControlType) {
             this.rebuildEditorForType(this.initialControlType);
         }
@@ -12019,6 +12099,79 @@ class FieldMetadataEditorComponent {
         if (value != null)
             this.onControlTypeChange(value);
     }
+    tx(key, fallback) {
+        const namespacedKey = key.startsWith('praxis.metadataEditor.')
+            ? key
+            : `praxis.metadataEditor.${key}`;
+        return this.i18n?.t(namespacedKey, undefined, fallback) ?? fallback;
+    }
+    buildCurrentSemanticFieldSnapshot() {
+        const currentRaw = this.form?.getRawValue?.() ?? {};
+        const merged = {
+            ...(this.seed || {}),
+        };
+        for (const [k, v] of Object.entries(currentRaw)) {
+            if (v !== undefined && v !== null && v !== '') {
+                merged[k] = v;
+            }
+        }
+        merged['name'] = String(currentRaw?.name ?? this.seed?.name ?? '').trim();
+        merged['controlType'] = this.controlType;
+        return merged;
+    }
+    canCalibrateFromSemantics() {
+        const snapshot = this.buildCurrentSemanticFieldSnapshot();
+        return hasSemanticFieldCalibrationDiff(snapshot);
+    }
+    calibrateFromSemantics() {
+        const mergedField = this.buildCurrentSemanticFieldSnapshot();
+        if (!hasSemanticFieldCalibrationDiff(mergedField)) {
+            return;
+        }
+        const calibrated = calibrateFieldMetadataFromSemantics(mergedField);
+        this.seed = {
+            ...(this.seed || {}),
+            ...calibrated,
+        };
+        const nextControlType = (calibrated.controlType ?? this.controlType);
+        if (nextControlType && nextControlType !== this.controlType) {
+            this.rebuildEditorForType(nextControlType);
+        }
+        const getByPath = (obj, path) => {
+            if (!obj || typeof obj !== 'object' || !path)
+                return undefined;
+            return path.split('.').reduce((acc, part) => (acc == null ? undefined : acc[part]), obj);
+        };
+        const formPatch = {};
+        for (const prop of this.normalizedProps || []) {
+            const propName = String(prop?.name ?? '').trim();
+            if (!propName)
+                continue;
+            const rawVal = getByPath(calibrated, propName);
+            if (rawVal === undefined)
+                continue;
+            const controlVal = this.toEditorControlValue(prop, rawVal);
+            if (controlVal !== undefined && controlVal !== null) {
+                try {
+                    this.factory.setValueByPath(this.form, propName, controlVal);
+                }
+                catch { }
+                if (!propName.includes('.') && this.form?.get(propName)) {
+                    formPatch[propName] = controlVal;
+                }
+            }
+        }
+        if (calibrated.options !== undefined &&
+            !this.form?.get('options') &&
+            this.form?.get('providerOptions')) {
+            const prop = this.normalizedProps?.find((p) => p?.name === 'providerOptions');
+            formPatch['providerOptions'] = this.toEditorControlValue(prop, calibrated.options);
+        }
+        if (Object.keys(formPatch).length > 0) {
+            this.form.patchValue(formPatch, { emitEvent: true });
+        }
+        this.isDirty$.next(true);
+    }
     withSharedFieldMetadataProperties(props) {
         const propNames = new Set(props.map((prop) => prop.name));
         const sharedProps = [...fieldPresentationProperties, ...fieldSubmitProperties];
@@ -12323,6 +12476,7 @@ class FieldMetadataEditorComponent {
         const statusKey = findExact([
             'status',
             'situacao',
+            'situacaofuncional',
             'ativo',
             'active',
             'estado',
@@ -12460,6 +12614,20 @@ class FieldMetadataEditorComponent {
         ], ngImport: i0, template: `
     @if (form) {
       <div class="p-3">
+        @if (canCalibrateFromSemantics()) {
+          <div class="d-flex justify-content-end mb-2">
+            <button
+              mat-stroked-button
+              type="button"
+              data-testid="field-metadata-smart-calibrate-btn"
+              (click)="calibrateFromSemantics()"
+              [matTooltip]="tx('smartCalibrate.tooltip', 'Infere automaticamente o tipo de controle, rótulo humanizado e padrões corporativos a partir do nome e metadados do campo.')"
+            >
+              <mat-icon aria-hidden="true">auto_fix_high</mat-icon>
+              {{ tx('smartCalibrate.action', 'Calibrar pelo schema') }}
+            </button>
+          </div>
+        }
         <praxis-dynamic-editor-renderer
           [properties]="renderedProps"
           [form]="form"
@@ -12472,7 +12640,7 @@ class FieldMetadataEditorComponent {
         }
       </div>
     }
-    `, isInline: true, dependencies: [{ kind: "ngmodule", type: ReactiveFormsModule }, { kind: "component", type: DynamicEditorRendererComponent, selector: "praxis-dynamic-editor-renderer", inputs: ["properties", "form"] }, { kind: "component", type: ArrayItemSchemaFieldsEditorComponent, selector: "praxis-array-item-schema-fields-editor", inputs: ["control", "arrayControl"] }] });
+    `, isInline: true, dependencies: [{ kind: "ngmodule", type: ReactiveFormsModule }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i1$2.MatButton, selector: "    button[matButton], a[matButton], button[mat-button], button[mat-raised-button],    button[mat-flat-button], button[mat-stroked-button], a[mat-button], a[mat-raised-button],    a[mat-flat-button], a[mat-stroked-button]  ", inputs: ["matButton"], exportAs: ["matButton", "matAnchor"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i2$1.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "ngmodule", type: MatTooltipModule }, { kind: "directive", type: i3$1.MatTooltip, selector: "[matTooltip]", inputs: ["matTooltipPosition", "matTooltipPositionAtOrigin", "matTooltipDisabled", "matTooltipShowDelay", "matTooltipHideDelay", "matTooltipTouchGestures", "matTooltip", "matTooltipClass"], exportAs: ["matTooltip"] }, { kind: "component", type: DynamicEditorRendererComponent, selector: "praxis-dynamic-editor-renderer", inputs: ["properties", "form"] }, { kind: "component", type: ArrayItemSchemaFieldsEditorComponent, selector: "praxis-array-item-schema-fields-editor", inputs: ["control", "arrayControl"] }] });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: FieldMetadataEditorComponent, decorators: [{
             type: Component,
@@ -12481,6 +12649,9 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImpo
                     standalone: true,
                     imports: [
                         ReactiveFormsModule,
+                        MatButtonModule,
+                        MatIconModule,
+                        MatTooltipModule,
                         DynamicEditorRendererComponent,
                         ArrayItemSchemaFieldsEditorComponent
                     ],
@@ -12492,6 +12663,20 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImpo
                     template: `
     @if (form) {
       <div class="p-3">
+        @if (canCalibrateFromSemantics()) {
+          <div class="d-flex justify-content-end mb-2">
+            <button
+              mat-stroked-button
+              type="button"
+              data-testid="field-metadata-smart-calibrate-btn"
+              (click)="calibrateFromSemantics()"
+              [matTooltip]="tx('smartCalibrate.tooltip', 'Infere automaticamente o tipo de controle, rótulo humanizado e padrões corporativos a partir do nome e metadados do campo.')"
+            >
+              <mat-icon aria-hidden="true">auto_fix_high</mat-icon>
+              {{ tx('smartCalibrate.action', 'Calibrar pelo schema') }}
+            </button>
+          </div>
+        }
         <praxis-dynamic-editor-renderer
           [properties]="renderedProps"
           [form]="form"
@@ -12677,10 +12862,13 @@ class CascadeRulesService {
             dependencyLoadOnChange: null,
         };
     }
-    /** Suggest a basic mapping dep->dep and a default valuePath */
+    /** Fill missing mappings and value paths without replacing authored values. */
     suggest(rule, inferredValueKey) {
-        const map = {};
-        (rule.dependencyFields || []).forEach((dep) => (map[dep] = dep));
+        const map = { ...rule.dependencyFilterMap };
+        (rule.dependencyFields || []).forEach((dep) => {
+            if (!Object.prototype.hasOwnProperty.call(map, dep))
+                map[dep] = dep;
+        });
         return {
             ...rule,
             dependencyFilterMap: Object.keys(map).length ? map : rule.dependencyFilterMap,
@@ -12729,12 +12917,13 @@ class CascadeManagerTabComponent {
     editLoadOn = 'respectLoadOn';
     editDebounce = 150;
     editValuePath = '';
-    editFilterMapJson = '';
     importMode = false;
     importJson = '';
     feedbackMessage = '';
     feedbackTone = 'info';
     editMapRows = [];
+    editInitialFilterMap = {};
+    editInitialValuePath = 'id';
     setFeedback(message, tone = 'info') {
         this.feedbackMessage = message;
         this.feedbackTone = tone;
@@ -12836,12 +13025,9 @@ class CascadeManagerTabComponent {
         this.editLoadOn = suggested.dependencyLoadOnChange || 'respectLoadOn';
         this.editDebounce = suggested.dependencyDebounceMs ?? 150;
         this.editValuePath = (typeof suggested.dependencyValuePath === 'string' ? suggested.dependencyValuePath : 'id') || '';
-        try {
-            this.editFilterMapJson = suggested.dependencyFilterMap ? JSON.stringify(suggested.dependencyFilterMap, null, 2) : '';
-        }
-        catch {
-            this.editFilterMapJson = '';
-        }
+        this.editInitialFilterMap = structuredClone(suggested.dependencyFilterMap || {});
+        this.editInitialValuePath = structuredClone(suggested.dependencyValuePath || 'id');
+        this.editMapRows = [];
         // Build mapping rows from dependencies
         this.buildMapRowsFromDeps();
         this.editing.set(true);
@@ -12851,20 +13037,45 @@ class CascadeManagerTabComponent {
     saveEdit(name) {
         // Build rule from editor
         const deps = this.editDepList.filter((s) => !!s && s !== name);
-        // Build map from rows; fallback to JSON when provided
-        let map = {};
-        this.editMapRows.forEach((r) => { if (!r.key && r.dep)
-            r.key = r.dep; if (r.dep)
-            map[r.dep] = r.valuePath ? { key: r.key || r.dep, valuePath: r.valuePath } : (r.key || r.dep); });
-        const raw = (this.editFilterMapJson || '').trim();
-        if (raw) {
-            try {
-                const fromJson = JSON.parse(raw);
-                map = { ...map, ...fromJson };
+        // The rows own the draft. The opening snapshot only preserves entry shape;
+        // merging the original JSON after the rows would silently undo visual edits.
+        const map = structuredClone(this.editInitialFilterMap);
+        const dependenciesRemoved = (this.ruleFor(name)?.dependencyFields || [])
+            .some((dep) => !deps.includes(dep));
+        if (dependenciesRemoved) {
+            for (const dep of Object.keys(map)) {
+                if (!deps.includes(dep))
+                    delete map[dep];
             }
-            catch {
-                this.setFeedback('Mapeamento de filtros inválido (JSON).', 'error');
-                return;
+        }
+        for (const row of this.editMapRows) {
+            if (!deps.includes(row.dep))
+                continue;
+            const initial = this.editInitialFilterMap[row.dep];
+            const initialPath = this.initialRowValuePath(row.dep);
+            if (typeof initial === 'object' && initial !== null) {
+                const entry = { ...initial, key: row.key || row.dep };
+                if (row.valuePath !== initialPath) {
+                    if (row.valuePath)
+                        entry.valuePath = row.valuePath;
+                    else
+                        delete entry.valuePath;
+                }
+                map[row.dep] = entry;
+            }
+            else {
+                map[row.dep] = row.valuePath && row.valuePath !== initialPath
+                    ? { key: row.key || row.dep, valuePath: row.valuePath }
+                    : row.key || row.dep;
+            }
+        }
+        const valuePaths = this.buildValuePathOverrides(deps);
+        // Removed dependencies must lose their extraction overrides as well as their
+        // filter mappings, otherwise re-adding one resurrects stale extraction state.
+        if (dependenciesRemoved && typeof valuePaths === 'object') {
+            for (const dep of Object.keys(valuePaths)) {
+                if (!deps.includes(dep))
+                    delete valuePaths[dep];
             }
         }
         this.setFeedback('');
@@ -12874,7 +13085,7 @@ class CascadeManagerTabComponent {
             enableDependencyCascade: this.editEnable,
             resetOnDependentChange: this.editReset,
             dependencyFilterMap: map,
-            dependencyValuePath: this.buildValuePathOverrides(deps),
+            dependencyValuePath: valuePaths,
             dependencyMergeStrategy: this.editMerge,
             dependencyDebounceMs: this.editDebounce ?? 150,
             dependencyLoadOnChange: this.editLoadOn,
@@ -12989,33 +13200,65 @@ class CascadeManagerTabComponent {
         this.editLoadOn = 'respectLoadOn';
         this.editDebounce = 150;
         this.editValuePath = 'id';
+        this.editInitialFilterMap = {};
+        this.editInitialValuePath = 'id';
+        this.editMapRows = [];
         this.buildMapRowsFromDeps();
         this.editing.set(true);
     }
     buildMapRowsFromDeps() {
         const deps = this.editDepList;
-        const existing = (() => { try {
-            return JSON.parse(this.editFilterMapJson || '{}');
-        }
-        catch {
-            return {};
-        } })();
+        const current = new Map(this.editMapRows.map((row) => [row.dep, row]));
         this.editMapRows = deps.map((dep) => {
-            const entry = existing[dep];
-            if (!entry)
-                return { dep, key: dep };
-            if (typeof entry === 'string')
-                return { dep, key: entry };
-            return { dep, key: entry.key || dep, valuePath: entry.valuePath };
+            const edited = current.get(dep);
+            if (edited)
+                return edited;
+            const entry = this.editInitialFilterMap[dep];
+            const key = typeof entry === 'string' ? entry : entry?.key || dep;
+            return { dep, key, valuePath: this.initialRowValuePath(dep) };
         });
     }
+    initialRowValuePath(dep) {
+        const entry = this.editInitialFilterMap[dep];
+        if (typeof entry === 'object' && entry?.valuePath)
+            return entry.valuePath;
+        return typeof this.editInitialValuePath === 'object'
+            ? this.editInitialValuePath[dep]
+            : undefined;
+    }
     buildValuePathOverrides(deps) {
-        // If any row defines a valuePath, return a record; else return default string
-        const record = {};
-        this.editMapRows.forEach((r) => { if (r.valuePath)
-            record[r.dep] = r.valuePath; });
-        const hasAny = Object.keys(record).length > 0;
-        return hasAny ? record : (this.editValuePath || 'id');
+        const initialDefault = typeof this.editInitialValuePath === 'string'
+            ? this.editInitialValuePath
+            : 'id';
+        const defaultChanged = this.editValuePath !== initialDefault;
+        const pathsChanged = this.editMapRows.some((row) => row.valuePath !== this.initialRowValuePath(row.dep));
+        if (!defaultChanged && !pathsChanged)
+            return structuredClone(this.editInitialValuePath);
+        const wasRecord = typeof this.editInitialValuePath === 'object';
+        if (!pathsChanged && !wasRecord)
+            return this.editValuePath || 'id';
+        // A specific extraction path must not erase the default/overrides used by
+        // other dependencies. Unchanged documents keep their original shape above.
+        const record = typeof this.editInitialValuePath === 'object'
+            ? { ...this.editInitialValuePath }
+            : {};
+        for (const dep of deps) {
+            const row = this.editMapRows.find((candidate) => candidate.dep === dep);
+            if (row && row.valuePath !== this.initialRowValuePath(dep)) {
+                record[dep] = row.valuePath || this.editValuePath || 'id';
+            }
+            else if (typeof this.editInitialValuePath === 'object') {
+                const existing = this.editInitialValuePath[dep];
+                if (existing !== undefined)
+                    record[dep] = existing;
+                else if (defaultChanged)
+                    record[dep] = this.editValuePath || 'id';
+            }
+            else {
+                record[dep] = this.editValuePath || 'id';
+            }
+        }
+        return record;
     }
     buildPreview() {
         try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@praxisui/metadata-editor",
-  "version": "10.0.0-rc.37",
+  "version": "10.0.0-rc.38",
   "description": "Metadata editor for Praxis UI fields and components with runtime integration.",
   "peerDependencies": {
     "@angular/common": "^21.0.0",
@@ -8,10 +8,10 @@
     "@angular/cdk": "^21.0.0",
     "@angular/forms": "^21.0.0",
     "@angular/material": "^21.0.0",
-    "@praxisui/ai": "^10.0.0-rc.37",
-    "@praxisui/core": "^10.0.0-rc.37",
-    "@praxisui/dynamic-fields": "^10.0.0-rc.37",
-    "@praxisui/settings-panel": "^10.0.0-rc.37",
+    "@praxisui/ai": "^10.0.0-rc.38",
+    "@praxisui/core": "^10.0.0-rc.38",
+    "@praxisui/dynamic-fields": "^10.0.0-rc.38",
+    "@praxisui/settings-panel": "^10.0.0-rc.38",
     "rxjs": "~7.8.0"
   },
   "dependencies": {

package/types/praxisui-metadata-editor.d.ts

@@ -160,6 +160,7 @@ declare class FieldMetadataEditorComponent implements OnInit {
     renderedProps: any[];
     private initialSnapshot;
     private initialControlType?;
+    private initialSeed?;
     private baselineReady;
     private readonly formRebuild$;
     private readonly hostApplyPatch?;
@@ -227,6 +228,10 @@ declare class FieldMetadataEditorComponent implements OnInit {
     reset(): void;
     onControlTypeChange(next: FieldControlType): void;
     onControlTypeChangeEvent(event: Event): void;
+    tx(key: string, fallback: string): string;
+    private buildCurrentSemanticFieldSnapshot;
+    canCalibrateFromSemantics(): boolean;
+    calibrateFromSemantics(): void;
     private withSharedFieldMetadataProperties;
     get isArrayEditor(): boolean;
     private static readonly ROOT_DEPENDENT_FIELD_KEY_PROPS;
@@ -298,7 +303,7 @@ declare class CascadeRulesService {
     hydrateRule(field: FieldDefinition | FieldMetadata): CascadeRuleViewModel | null;
     dehydratePatch(rule: CascadeRuleViewModel): Partial<FieldDefinition>;
     clearPatch(): Partial<FieldDefinition>;
-    /** Suggest a basic mapping dep->dep and a default valuePath */
+    /** Fill missing mappings and value paths without replacing authored values. */
     suggest(rule: CascadeRuleViewModel, inferredValueKey?: string): CascadeRuleViewModel;
     private normalizeDependencyFields;
     static ɵfac: i0.ɵɵFactoryDeclaration<CascadeRulesService, never>;
@@ -327,7 +332,6 @@ declare class CascadeManagerTabComponent implements OnChanges {
     editLoadOn: 'respectLoadOn' | 'immediate' | 'manual';
     editDebounce: number | null;
     editValuePath: string;
-    editFilterMapJson: string;
     importMode: boolean;
     importJson: string;
     feedbackMessage: string;
@@ -337,6 +341,8 @@ declare class CascadeManagerTabComponent implements OnChanges {
         key: string;
         valuePath?: string;
     }>;
+    private editInitialFilterMap;
+    private editInitialValuePath;
     private setFeedback;
     constructor(svc: CascadeRulesService);
     ngOnInit(): void;
@@ -366,6 +372,7 @@ declare class CascadeManagerTabComponent implements OnChanges {
     applyImport(): void;
     startTemplate(name: string, tpl: 'rota-destino' | 'rota-destino-propriedade'): void;
     buildMapRowsFromDeps(): void;
+    private initialRowValuePath;
     buildValuePathOverrides(deps: string[]): string | Record<string, string>;
     buildPreview(): string;
     copyPreview(): void;