@praxisui/core 9.0.4-rc.18 → 9.0.4-rc.19

package/fesm2022/praxisui-core.mjs

@@ -14021,8 +14021,341 @@ const SURFACE_OPEN_PRESETS = [
     },
 ];
 
+const RELATED_RESOURCE_OUTLET_I18N_NAMESPACE = 'relatedResourceOutlet';
+const RELATED_RESOURCE_OUTLET_I18N_CONFIG = {
+    namespaces: {
+        [RELATED_RESOURCE_OUTLET_I18N_NAMESPACE]: {
+            'pt-BR': {
+                'state.idle.title': 'Recurso relacionado não selecionado',
+                'state.idle.description': 'Selecione uma surface relacionada para carregar os dados.',
+                'state.resolving.title': 'Resolvendo recurso relacionado',
+                'state.resolving.description': 'Validando metadados e permissões da relação.',
+                'state.loading.title': 'Carregando recurso relacionado',
+                'state.loading.description': 'Aguarde enquanto a coleção relacionada é carregada.',
+                'state.empty.title': 'Nenhuma operação de leitura publicada',
+                'state.empty.description': 'A relação existe, mas não há operação de lista ou filtro disponível.',
+                'state.permission-limited.title': 'Acesso limitado',
+                'state.permission-limited.description': 'O contexto atual não permite abrir este recurso relacionado.',
+                'state.not-found.title': 'Relação indisponível',
+                'state.not-found.description': 'Não foi possível resolver a relação ou o identificador do registro pai.',
+                'state.error.title': 'Falha ao preparar recurso relacionado',
+                'state.error.description': 'Ocorreu um erro ao preparar a superfície relacionada.',
+                'emptyState.related.title': 'Sem registros em {label}',
+                'emptyState.related.description': 'Esta coleção relacionada não possui registros para o contexto selecionado.',
+                'emptyState.related.descriptionWithAction': 'Use a ação principal para adicionar um registro relacionado quando houver informações para registrar.',
+                'emptyState.related.action.create': 'Adicionar registro',
+                'action.open': 'Abrir relacionado',
+                'status.ready': 'Recurso relacionado pronto',
+            },
+            'en-US': {
+                'state.idle.title': 'Related resource not selected',
+                'state.idle.description': 'Select a related surface to load its data.',
+                'state.resolving.title': 'Resolving related resource',
+                'state.resolving.description': 'Validating relation metadata and permissions.',
+                'state.loading.title': 'Loading related resource',
+                'state.loading.description': 'Wait while the related collection is loaded.',
+                'state.empty.title': 'No read operation published',
+                'state.empty.description': 'The relation exists, but no list or filter operation is available.',
+                'state.permission-limited.title': 'Limited access',
+                'state.permission-limited.description': 'The current context cannot open this related resource.',
+                'state.not-found.title': 'Relation unavailable',
+                'state.not-found.description': 'The relation or parent record identifier could not be resolved.',
+                'state.error.title': 'Failed to prepare related resource',
+                'state.error.description': 'An error occurred while preparing the related surface.',
+                'emptyState.related.title': 'No records in {label}',
+                'emptyState.related.description': 'This related collection has no records for the selected context.',
+                'emptyState.related.descriptionWithAction': 'Use the primary action to add a related record when there is information to capture.',
+                'emptyState.related.action.create': 'Add record',
+                'action.open': 'Open related',
+                'status.ready': 'Related resource ready',
+            },
+        },
+    },
+};
+
+class RelatedResourceSurfaceResolverService {
+    i18n = inject(PraxisI18nService, { optional: true });
+    resolve(request) {
+        try {
+            if (!request?.surface) {
+                return { state: 'idle', reason: 'surface-not-provided' };
+            }
+            const surface = request.surface;
+            if (surface.availability?.allowed === false) {
+                return {
+                    state: 'permission-limited',
+                    reason: surface.availability.reason || 'surface-not-allowed',
+                    surface,
+                    relatedResource: surface.relatedResource ?? null,
+                };
+            }
+            const relatedResource = surface.relatedResource ?? null;
+            if (!this.isCompleteRelatedResource(relatedResource)) {
+                return {
+                    state: 'not-found',
+                    reason: 'related-resource-not-published',
+                    surface,
+                    relatedResource,
+                };
+            }
+            if (!this.hasReadOperation(relatedResource)) {
+                return {
+                    state: 'empty',
+                    reason: 'related-resource-read-operation-not-published',
+                    surface,
+                    relatedResource,
+                };
+            }
+            const parentResourceId = this.resolveParentResourceId(request, relatedResource);
+            if (parentResourceId == null || parentResourceId === '') {
+                return {
+                    state: 'not-found',
+                    reason: 'parent-resource-id-not-resolved',
+                    surface,
+                    relatedResource,
+                };
+            }
+            const queryContext = this.buildQueryContext(request.queryContext, relatedResource.childParentField, parentResourceId);
+            const payload = this.buildPayload(surface, relatedResource, parentResourceId, queryContext, request);
+            return {
+                state: 'ready',
+                surface,
+                relatedResource,
+                parentResourceId,
+                childResourcePath: relatedResource.childResourcePath,
+                childResourceKey: relatedResource.childResourceKey,
+                queryContext,
+                payload,
+            };
+        }
+        catch (error) {
+            return {
+                state: 'error',
+                reason: error instanceof Error ? error.message : 'related-resource-resolution-failed',
+                surface: request?.surface ?? null,
+                relatedResource: request?.surface?.relatedResource ?? null,
+            };
+        }
+    }
+    state(state, reason) {
+        return { state, reason };
+    }
+    buildPayload(surface, relatedResource, parentResourceId, queryContext, request) {
+        const preset = SURFACE_OPEN_PRESETS.find((candidate) => candidate.id === 'praxis-table');
+        if (!preset) {
+            throw new Error('Missing canonical surface preset "praxis-table".');
+        }
+        const payload = this.clone(preset.payload);
+        payload.presentation = request.presentation ?? payload.presentation;
+        payload.title = request.title || surface.title;
+        payload.subtitle = request.subtitle || surface.description || undefined;
+        payload.icon = request.icon || payload.icon;
+        payload.widget.inputs = {
+            ...(payload.widget.inputs || {}),
+            configPersistenceStrategy: 'volatile',
+            resourcePath: this.normalizeResourcePath(relatedResource.childResourcePath),
+            apiEndpointKey: request.apiEndpointKey ?? null,
+            apiUrlEntry: request.apiUrlEntry ?? null,
+            tableId: request.tableId || this.buildStableTableId(surface, relatedResource, parentResourceId),
+            config: this.buildTableConfig(surface, relatedResource, request),
+            queryContext,
+            enableCustomization: request.enableCustomization === true,
+            ...(this.trim(request.authoringCapability)
+                ? { authoringCapability: this.trim(request.authoringCapability) }
+                : {}),
+        };
+        payload.context = {
+            ...(payload.context || {}),
+            resource: {
+                resourceKey: surface.resourceKey,
+                resourcePath: this.normalizeResourcePath(request.parentResourcePath || ''),
+                resourceId: parentResourceId,
+            },
+            surface,
+            relatedResource,
+            childResource: {
+                resourceKey: relatedResource.childResourceKey,
+                resourcePath: this.normalizeResourcePath(relatedResource.childResourcePath),
+                parentField: relatedResource.childParentField,
+                selectable: relatedResource.selectable,
+                selectionKeyField: relatedResource.selectionKeyField,
+                operations: relatedResource.childOperations,
+            },
+        };
+        return payload;
+    }
+    buildTableConfig(surface, relatedResource, request) {
+        const tableConfig = request.tableConfig;
+        const emptyState = request.emptyState;
+        const hasTableConfig = !!tableConfig && typeof tableConfig === 'object' && !Array.isArray(tableConfig);
+        const hasEmptyState = !!emptyState && typeof emptyState === 'object' && !Array.isArray(emptyState);
+        const base = hasTableConfig ? tableConfig : {};
+        const toolbar = this.objectValue(base['toolbar']);
+        const columnsVisibility = this.objectValue(toolbar['columnsVisibility']);
+        const behavior = this.objectValue(base['behavior']);
+        const currentEmptyState = this.objectValue(behavior['emptyState']);
+        const hasCurrentEmptyState = Object.keys(currentEmptyState).length > 0;
+        const resolvedEmptyState = hasEmptyState
+            ? {
+                ...currentEmptyState,
+                ...emptyState,
+            }
+            : hasCurrentEmptyState
+                ? currentEmptyState
+                : this.buildRelatedEmptyState(surface, relatedResource, request);
+        if (!hasTableConfig && !resolvedEmptyState) {
+            return undefined;
+        }
+        return {
+            ...base,
+            toolbar: {
+                ...toolbar,
+                columnsVisibility: {
+                    enabled: false,
+                    ...columnsVisibility,
+                },
+            },
+            behavior: {
+                ...behavior,
+                emptyState: resolvedEmptyState,
+            },
+        };
+    }
+    buildRelatedEmptyState(surface, relatedResource, request) {
+        const label = this.trim(request.title)
+            || this.trim(surface.title)
+            || this.humanizeResourceKey(relatedResource.childResourceKey);
+        const canCreate = relatedResource.childOperations.includes('CREATE');
+        const descriptionKey = canCreate
+            ? 'emptyState.related.descriptionWithAction'
+            : 'emptyState.related.description';
+        const actions = canCreate
+            ? [
+                {
+                    label: this.t('emptyState.related.action.create', 'Adicionar registro'),
+                    action: 'create',
+                    icon: 'add',
+                    primary: true,
+                },
+            ]
+            : [];
+        return {
+            title: this.t('emptyState.related.title', 'Sem registros em {label}', { label }),
+            message: this.t(descriptionKey, canCreate
+                ? 'Use a ação principal para adicionar um registro relacionado quando houver informações para registrar.'
+                : 'Esta coleção relacionada não possui registros para o contexto selecionado.', { label }),
+            icon: this.trim(request.icon) || 'hub',
+            tone: 'neutral',
+            variant: 'inline',
+            density: 'compact',
+            alignment: 'center',
+            iconContainer: 'soft',
+            actions,
+        };
+    }
+    objectValue(value) {
+        return value && typeof value === 'object' && !Array.isArray(value)
+            ? value
+            : {};
+    }
+    buildQueryContext(queryContext, childParentField, parentResourceId) {
+        return {
+            ...(queryContext || {}),
+            filters: {
+                ...(queryContext?.filters || {}),
+                [childParentField]: parentResourceId,
+            },
+            meta: {
+                ...(queryContext?.meta || {}),
+                relatedResource: true,
+                parentFilterField: childParentField,
+            },
+        };
+    }
+    resolveParentResourceId(request, relatedResource) {
+        if (request.parentResourceId != null) {
+            return request.parentResourceId;
+        }
+        return this.readPath(request.parentRecord, relatedResource.parentIdPathVariable);
+    }
+    readPath(record, path) {
+        if (!record || !path) {
+            return null;
+        }
+        const value = path.split('.').reduce((current, segment) => {
+            if (!current || typeof current !== 'object' || Array.isArray(current)) {
+                return undefined;
+            }
+            return current[segment];
+        }, record);
+        return typeof value === 'string' || typeof value === 'number' ? value : null;
+    }
+    isCompleteRelatedResource(relatedResource) {
+        return !!relatedResource
+            && !!this.trim(relatedResource.childResourceKey)
+            && !!this.trim(relatedResource.childResourcePath)
+            && !!this.trim(relatedResource.childParentField)
+            && !!this.trim(relatedResource.parentIdPathVariable)
+            && Array.isArray(relatedResource.childOperations);
+    }
+    hasReadOperation(relatedResource) {
+        return relatedResource.childOperations.includes('LIST')
+            || relatedResource.childOperations.includes('FILTER');
+    }
+    buildStableTableId(surface, relatedResource, parentResourceId) {
+        return this.sanitizeStableId(`${relatedResource.childResourceKey}.${surface.id}.${String(parentResourceId)}`);
+    }
+    normalizeResourcePath(resourcePath) {
+        let normalized = this.trim(resourcePath);
+        if (/^https?:\/\//i.test(normalized)) {
+            try {
+                normalized = new URL(normalized).pathname;
+            }
+            catch {
+                return '';
+            }
+        }
+        return normalized
+            .replace(/^\/+/, '')
+            .replace(/^(?:api\/)+/i, '')
+            .replace(/\/+$/, '');
+    }
+    sanitizeStableId(value) {
+        return value.replace(/[^a-zA-Z0-9._-]+/g, '-');
+    }
+    humanizeResourceKey(value) {
+        const lastSegment = this.trim(value).split(/[./_-]+/).filter(Boolean).pop() || 'registros';
+        return lastSegment
+            .replace(/([a-z])([A-Z])/g, '$1 $2')
+            .replace(/\s+/g, ' ')
+            .trim();
+    }
+    t(key, fallback, params) {
+        if (this.i18n) {
+            return this.interpolate(this.i18n.t(key, params, fallback, RELATED_RESOURCE_OUTLET_I18N_NAMESPACE), params);
+        }
+        return this.interpolate(fallback, params);
+    }
+    interpolate(template, params) {
+        return Object.entries(params || {}).reduce((current, [name, value]) => current.replace(new RegExp(`\\{${name}\\}`, 'g'), String(value ?? '')), template);
+    }
+    trim(value) {
+        return typeof value === 'string' ? value.trim() : '';
+    }
+    clone(value) {
+        return value == null ? value : JSON.parse(JSON.stringify(value));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: RelatedResourceSurfaceResolverService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: RelatedResourceSurfaceResolverService, providedIn: 'any' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: RelatedResourceSurfaceResolverService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'any' }]
+        }] });
+
 class ResourceSurfaceOpenAdapterService {
     discovery = inject(ResourceDiscoveryService);
+    relatedResourceResolver = inject(RelatedResourceSurfaceResolverService);
     toPayload(surface, options) {
         const resourcePath = this.normalizeResourcePath(options.resourcePath);
         if (!resourcePath) {
@@ -14035,6 +14368,25 @@ class ResourceSurfaceOpenAdapterService {
             }
             : undefined;
         const resolvedApiEntry = this.discovery.resolveApiEntry(discoveryOptions);
+        const icon = options.icon ?? this.resolveDefaultIcon(surface);
+        if (surface.relatedResource) {
+            const resolution = this.relatedResourceResolver.resolve({
+                surface,
+                parentResourceId: options.resourceId ?? null,
+                parentResourcePath: resourcePath,
+                presentation: options.presentation,
+                title: options.title ?? surface.title,
+                subtitle: options.subtitle ?? surface.description ?? null,
+                icon,
+                queryContext: options.queryContext,
+                apiEndpointKey: options.endpointKey ?? null,
+                apiUrlEntry: options.apiUrlEntry ?? resolvedApiEntry,
+            });
+            if (resolution.state !== 'ready' || !resolution.payload) {
+                throw new Error(`ResourceSurfaceOpenAdapterService could not materialize related surface "${surface.id}": ${resolution.reason || resolution.state}.`);
+            }
+            return resolution.payload;
+        }
         const resolvedSchemaUrl = this.discovery.resolveHref(surface.schemaUrl, discoveryOptions);
         const resolvedSubmitUrl = this.isWritableFormSurface(surface.kind)
             ? this.discovery.resolveHref(surface.path, discoveryOptions)
@@ -14046,7 +14398,7 @@ class ResourceSurfaceOpenAdapterService {
             presentation: options.presentation ?? basePayload.presentation,
             title: options.title ?? surface.title ?? basePayload.title,
             subtitle: options.subtitle ?? surface.description ?? basePayload.subtitle,
-            icon: options.icon ?? basePayload.icon,
+            icon: icon ?? basePayload.icon,
             context: {
                 resource: {
                     resourceKey: surface.resourceKey,
@@ -14135,6 +14487,15 @@ class ResourceSurfaceOpenAdapterService {
         }
         return this.clone(preset.payload);
     }
+    resolveDefaultIcon(surface) {
+        if (surface.relatedResource) {
+            return 'dataset_linked';
+        }
+        if (surface.kind === 'VIEW' || surface.kind === 'READ_PROJECTION') {
+            return 'visibility';
+        }
+        return surface.scope === 'COLLECTION' ? 'add' : 'edit_note';
+    }
     buildStableInstanceId(surface) {
         return `${surface.resourceKey}.${surface.id}`.replace(/[^a-zA-Z0-9._-]+/g, '-');
     }
@@ -14959,558 +15320,226 @@ class PraxisRuntimeComponentObservationRegistryService {
         return clonePraxisRuntimeComponentObservation(observation);
     }
     isActiveObservation(observation) {
-        if (!observation.lifecycle.active) {
-            return false;
-        }
-        const ttlMs = observation.lifecycle.ttlMs;
-        if (ttlMs === undefined || ttlMs < 0) {
-            return true;
-        }
-        const capturedAt = Date.parse(observation.lifecycle.capturedAt);
-        return Number.isFinite(capturedAt) && Date.now() - capturedAt <= ttlMs;
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: PraxisRuntimeComponentObservationRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: PraxisRuntimeComponentObservationRegistryService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: PraxisRuntimeComponentObservationRegistryService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
-function registerPraxisRuntimeComponentObservation(provider, options = {}) {
-    const registry = inject(PraxisRuntimeComponentObservationRegistryService);
-    const destroyRef = options.destroyRef ?? inject(DestroyRef);
-    return registry.register(provider, { ...options, destroyRef });
-}
-
-class ResourceActionOpenAdapterService {
-    discovery = inject(ResourceDiscoveryService);
-    toPayload(action, options) {
-        const resourcePath = this.normalizeResourcePath(options.resourcePath);
-        if (!resourcePath) {
-            throw new Error('ResourceActionOpenAdapterService requires resourcePath.');
-        }
-        if (!action.requestSchemaUrl) {
-            throw new Error(`ResourceActionOpenAdapterService requires requestSchemaUrl for action "${action.id}".`);
-        }
-        const discoveryOptions = options.endpointKey || options.apiUrlEntry
-            ? {
-                ...(options.endpointKey ? { endpointKey: options.endpointKey } : {}),
-                ...(options.apiUrlEntry ? { apiUrlEntry: options.apiUrlEntry } : {}),
-            }
-            : undefined;
-        const resolvedRequestSchemaUrl = this.discovery.resolveHref(action.requestSchemaUrl, discoveryOptions);
-        const resolvedResponseSchemaUrl = action.responseSchemaUrl
-            ? this.discovery.resolveHref(action.responseSchemaUrl, discoveryOptions)
-            : null;
-        const resolvedSubmitUrl = this.discovery.resolveHref(action.path, discoveryOptions);
-        const payload = this.clone(this.resolveDynamicFormPreset());
-        payload.presentation = options.presentation ?? payload.presentation;
-        payload.title = options.title ?? action.title ?? payload.title;
-        payload.subtitle = options.subtitle ?? action.description ?? payload.subtitle;
-        payload.icon = options.icon ?? payload.icon;
-        payload.context = {
-            resource: {
-                resourceKey: action.resourceKey,
-                resourcePath,
-                resourceId: options.resourceId ?? null,
-                group: options.group ?? null,
-            },
-            action: {
-                id: action.id,
-                scope: action.scope,
-                operationId: action.operationId,
-                path: action.path,
-                method: action.method,
-                requestSchemaId: action.requestSchemaId ?? null,
-                requestSchemaUrl: action.requestSchemaUrl,
-                responseSchemaId: action.responseSchemaId ?? null,
-                responseSchemaUrl: action.responseSchemaUrl ?? null,
-                availability: action.availability,
-                successMessage: action.successMessage ?? null,
-                tags: action.tags,
-                execution: action.execution ?? null,
-            },
-        };
-        payload.widget.inputs = {
-            ...(payload.widget.inputs || {}),
-            resourcePath,
-            formId: this.buildStableInstanceId(action),
-            mode: 'create',
-            configPersistenceStrategy: 'input-first',
-            layoutPolicy: {
-                source: 'schema',
-                intent: 'command',
-                preset: 'groupedCommand',
-                lifecycle: 'live',
-                persistence: 'transient',
-                schemaType: 'request',
-            },
-            schemaUrl: resolvedRequestSchemaUrl,
-            apiEndpointKey: options.endpointKey ?? null,
-            apiUrlEntry: options.apiUrlEntry ?? (discoveryOptions ? this.discovery.resolveApiEntry(discoveryOptions) : null),
-            submitMethod: String(action.method || '').trim().toLowerCase(),
-            submitUrl: resolvedSubmitUrl,
-            responseSchemaUrl: resolvedResponseSchemaUrl,
-        };
-        if (options.initialValue) {
-            payload.widget.inputs['initialValue'] = this.clone(options.initialValue);
-        }
-        if (action.scope === 'ITEM') {
-            if (options.resourceId != null) {
-                payload.widget.inputs['resourceId'] = options.resourceId;
-            }
-            else if (options.idBindingPath) {
-                payload.bindings = [
-                    ...(payload.bindings || []),
-                    this.buildIdBinding(options.idBindingPath),
-                ];
-            }
-            else {
-                throw new Error(`ResourceActionOpenAdapterService requires resourceId or idBindingPath for item action "${action.id}".`);
-            }
-        }
-        this.applyExecutionInputs(payload, action, options);
-        return payload;
-    }
-    resolveDynamicFormPreset() {
-        const preset = SURFACE_OPEN_PRESETS.find((candidate) => candidate.id === 'praxis-dynamic-form');
-        if (!preset) {
-            throw new Error('Missing canonical surface preset "praxis-dynamic-form".');
-        }
-        return preset.payload;
-    }
-    buildStableInstanceId(action) {
-        return `${action.resourceKey}.action.${action.id}`.replace(/[^a-zA-Z0-9._-]+/g, '-');
-    }
-    applyExecutionInputs(payload, action, options) {
-        const execution = action.execution;
-        if (!execution) {
-            payload.widget.inputs['submitIdempotencyKey'] = this.createCommandIdentity('idempotency');
-            return;
-        }
-        const inputs = payload.widget.inputs;
-        if (execution.preconditions.idempotencyKey !== 'NONE') {
-            inputs['submitIdempotencyKey'] = this.createCommandIdentity('idempotency');
-        }
-        if (execution.preconditions.correlationId !== 'NONE') {
-            inputs['submitCorrelationId'] =
-                String(options.correlationId ?? '').trim() || this.createCommandIdentity('correlation');
-        }
-        if (execution.preconditions.resourceVersionTransport !== 'IF_MATCH') {
-            return;
-        }
-        if (options.resourceVersion != null && String(options.resourceVersion).trim()) {
-            inputs['submitResourceVersion'] = options.resourceVersion;
-            return;
-        }
-        if (options.resourceVersionBindingPath) {
-            payload.bindings = [
-                ...(payload.bindings || []),
-                {
-                    from: options.resourceVersionBindingPath,
-                    to: 'widget.inputs.submitResourceVersion',
-                    mode: 'path',
-                },
-            ];
-            return;
-        }
-        if (execution.preconditions.resourceVersion === 'REQUIRED') {
-            throw new Error(`ResourceActionOpenAdapterService requires resourceVersion or resourceVersionBindingPath for action "${action.id}".`);
-        }
-    }
-    createIdempotencyKey() {
-        const randomUuid = globalThis.crypto?.randomUUID?.bind(globalThis.crypto);
-        return randomUuid ? randomUuid() : `praxis-action-${Date.now()}-${Math.random().toString(16).slice(2)}`;
-    }
-    createCommandIdentity(kind) {
-        return `${kind}-${this.createIdempotencyKey()}`;
-    }
-    normalizeResourcePath(resourcePath) {
-        return String(resourcePath || '').trim().replace(/^\/+/, '').replace(/\/+$/, '');
-    }
-    buildIdBinding(idBindingPath) {
-        return {
-            from: idBindingPath,
-            to: 'widget.inputs.resourceId',
-            mode: 'path',
-        };
-    }
-    clone(value) {
-        return value == null ? value : JSON.parse(JSON.stringify(value));
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: ResourceActionOpenAdapterService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: ResourceActionOpenAdapterService, providedIn: 'any' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: ResourceActionOpenAdapterService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'any' }]
-        }] });
-
-class SurfaceOutletRegistryService {
-    registrations = new Map();
-    register(registration) {
-        const key = this.key(registration.resourceKey, registration.surfaceId);
-        this.registrations.set(key, [...(this.registrations.get(key) ?? []), registration]
-            .sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0)));
-        return () => {
-            const next = (this.registrations.get(key) ?? []).filter((item) => item !== registration);
-            next.length ? this.registrations.set(key, next) : this.registrations.delete(key);
-        };
-    }
-    async tryActivate(payload, context) {
-        const resourceKey = String(payload.context?.['surface']?.['resourceKey'] ?? '').trim();
-        const surfaceId = String(payload.context?.['surface']?.['id'] ?? '').trim();
-        if (!resourceKey || !surfaceId)
+        if (!observation.lifecycle.active) {
             return false;
-        for (const registration of this.registrations.get(this.key(resourceKey, surfaceId)) ?? []) {
-            if (await registration.activate(payload, context))
-                return true;
         }
-        return false;
-    }
-    key(resourceKey, surfaceId) {
-        return `${resourceKey.trim().toLowerCase()}::${surfaceId.trim().toLowerCase()}`;
+        const ttlMs = observation.lifecycle.ttlMs;
+        if (ttlMs === undefined || ttlMs < 0) {
+            return true;
+        }
+        const capturedAt = Date.parse(observation.lifecycle.capturedAt);
+        return Number.isFinite(capturedAt) && Date.now() - capturedAt <= ttlMs;
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: SurfaceOutletRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: SurfaceOutletRegistryService, providedIn: 'root' });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: PraxisRuntimeComponentObservationRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: PraxisRuntimeComponentObservationRegistryService, providedIn: 'root' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: SurfaceOutletRegistryService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: PraxisRuntimeComponentObservationRegistryService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
         }] });
+function registerPraxisRuntimeComponentObservation(provider, options = {}) {
+    const registry = inject(PraxisRuntimeComponentObservationRegistryService);
+    const destroyRef = options.destroyRef ?? inject(DestroyRef);
+    return registry.register(provider, { ...options, destroyRef });
+}
 
-const RELATED_RESOURCE_OUTLET_I18N_NAMESPACE = 'relatedResourceOutlet';
-const RELATED_RESOURCE_OUTLET_I18N_CONFIG = {
-    namespaces: {
-        [RELATED_RESOURCE_OUTLET_I18N_NAMESPACE]: {
-            'pt-BR': {
-                'state.idle.title': 'Recurso relacionado não selecionado',
-                'state.idle.description': 'Selecione uma surface relacionada para carregar os dados.',
-                'state.resolving.title': 'Resolvendo recurso relacionado',
-                'state.resolving.description': 'Validando metadados e permissões da relação.',
-                'state.loading.title': 'Carregando recurso relacionado',
-                'state.loading.description': 'Aguarde enquanto a coleção relacionada é carregada.',
-                'state.empty.title': 'Nenhuma operação de leitura publicada',
-                'state.empty.description': 'A relação existe, mas não há operação de lista ou filtro disponível.',
-                'state.permission-limited.title': 'Acesso limitado',
-                'state.permission-limited.description': 'O contexto atual não permite abrir este recurso relacionado.',
-                'state.not-found.title': 'Relação indisponível',
-                'state.not-found.description': 'Não foi possível resolver a relação ou o identificador do registro pai.',
-                'state.error.title': 'Falha ao preparar recurso relacionado',
-                'state.error.description': 'Ocorreu um erro ao preparar a superfície relacionada.',
-                'emptyState.related.title': 'Sem registros em {label}',
-                'emptyState.related.description': 'Esta coleção relacionada não possui registros para o contexto selecionado.',
-                'emptyState.related.descriptionWithAction': 'Use a ação principal para adicionar um registro relacionado quando houver informações para registrar.',
-                'emptyState.related.action.create': 'Adicionar registro',
-                'action.open': 'Abrir relacionado',
-                'status.ready': 'Recurso relacionado pronto',
-            },
-            'en-US': {
-                'state.idle.title': 'Related resource not selected',
-                'state.idle.description': 'Select a related surface to load its data.',
-                'state.resolving.title': 'Resolving related resource',
-                'state.resolving.description': 'Validating relation metadata and permissions.',
-                'state.loading.title': 'Loading related resource',
-                'state.loading.description': 'Wait while the related collection is loaded.',
-                'state.empty.title': 'No read operation published',
-                'state.empty.description': 'The relation exists, but no list or filter operation is available.',
-                'state.permission-limited.title': 'Limited access',
-                'state.permission-limited.description': 'The current context cannot open this related resource.',
-                'state.not-found.title': 'Relation unavailable',
-                'state.not-found.description': 'The relation or parent record identifier could not be resolved.',
-                'state.error.title': 'Failed to prepare related resource',
-                'state.error.description': 'An error occurred while preparing the related surface.',
-                'emptyState.related.title': 'No records in {label}',
-                'emptyState.related.description': 'This related collection has no records for the selected context.',
-                'emptyState.related.descriptionWithAction': 'Use the primary action to add a related record when there is information to capture.',
-                'emptyState.related.action.create': 'Add record',
-                'action.open': 'Open related',
-                'status.ready': 'Related resource ready',
-            },
-        },
-    },
-};
-
-class RelatedResourceSurfaceResolverService {
-    i18n = inject(PraxisI18nService, { optional: true });
-    resolve(request) {
-        try {
-            if (!request?.surface) {
-                return { state: 'idle', reason: 'surface-not-provided' };
-            }
-            const surface = request.surface;
-            if (surface.availability?.allowed === false) {
-                return {
-                    state: 'permission-limited',
-                    reason: surface.availability.reason || 'surface-not-allowed',
-                    surface,
-                    relatedResource: surface.relatedResource ?? null,
-                };
-            }
-            const relatedResource = surface.relatedResource ?? null;
-            if (!this.isCompleteRelatedResource(relatedResource)) {
-                return {
-                    state: 'not-found',
-                    reason: 'related-resource-not-published',
-                    surface,
-                    relatedResource,
-                };
-            }
-            if (!this.hasReadOperation(relatedResource)) {
-                return {
-                    state: 'empty',
-                    reason: 'related-resource-read-operation-not-published',
-                    surface,
-                    relatedResource,
-                };
-            }
-            const parentResourceId = this.resolveParentResourceId(request, relatedResource);
-            if (parentResourceId == null || parentResourceId === '') {
-                return {
-                    state: 'not-found',
-                    reason: 'parent-resource-id-not-resolved',
-                    surface,
-                    relatedResource,
-                };
-            }
-            const queryContext = this.buildQueryContext(request.queryContext, relatedResource.childParentField, parentResourceId);
-            const payload = this.buildPayload(surface, relatedResource, parentResourceId, queryContext, request);
-            return {
-                state: 'ready',
-                surface,
-                relatedResource,
-                parentResourceId,
-                childResourcePath: relatedResource.childResourcePath,
-                childResourceKey: relatedResource.childResourceKey,
-                queryContext,
-                payload,
-            };
-        }
-        catch (error) {
-            return {
-                state: 'error',
-                reason: error instanceof Error ? error.message : 'related-resource-resolution-failed',
-                surface: request?.surface ?? null,
-                relatedResource: request?.surface?.relatedResource ?? null,
-            };
+class ResourceActionOpenAdapterService {
+    discovery = inject(ResourceDiscoveryService);
+    toPayload(action, options) {
+        const resourcePath = this.normalizeResourcePath(options.resourcePath);
+        if (!resourcePath) {
+            throw new Error('ResourceActionOpenAdapterService requires resourcePath.');
         }
-    }
-    state(state, reason) {
-        return { state, reason };
-    }
-    buildPayload(surface, relatedResource, parentResourceId, queryContext, request) {
-        const preset = SURFACE_OPEN_PRESETS.find((candidate) => candidate.id === 'praxis-table');
-        if (!preset) {
-            throw new Error('Missing canonical surface preset "praxis-table".');
+        if (!action.requestSchemaUrl) {
+            throw new Error(`ResourceActionOpenAdapterService requires requestSchemaUrl for action "${action.id}".`);
         }
-        const payload = this.clone(preset.payload);
-        payload.presentation = request.presentation ?? payload.presentation;
-        payload.title = request.title || surface.title;
-        payload.subtitle = request.subtitle || surface.description || undefined;
-        payload.icon = request.icon || payload.icon;
-        payload.widget.inputs = {
-            ...(payload.widget.inputs || {}),
-            configPersistenceStrategy: 'volatile',
-            resourcePath: this.normalizeResourcePath(relatedResource.childResourcePath),
-            apiEndpointKey: request.apiEndpointKey ?? null,
-            apiUrlEntry: request.apiUrlEntry ?? null,
-            tableId: request.tableId || this.buildStableTableId(surface, relatedResource, parentResourceId),
-            config: this.buildTableConfig(surface, relatedResource, request),
-            queryContext,
-            enableCustomization: request.enableCustomization === true,
-            ...(this.trim(request.authoringCapability)
-                ? { authoringCapability: this.trim(request.authoringCapability) }
-                : {}),
-        };
-        payload.context = {
-            ...(payload.context || {}),
-            resource: {
-                resourceKey: surface.resourceKey,
-                resourcePath: this.normalizeResourcePath(request.parentResourcePath || ''),
-                resourceId: parentResourceId,
-            },
-            surface,
-            relatedResource,
-            childResource: {
-                resourceKey: relatedResource.childResourceKey,
-                resourcePath: this.normalizeResourcePath(relatedResource.childResourcePath),
-                parentField: relatedResource.childParentField,
-                selectable: relatedResource.selectable,
-                selectionKeyField: relatedResource.selectionKeyField,
-                operations: relatedResource.childOperations,
-            },
-        };
-        return payload;
-    }
-    buildTableConfig(surface, relatedResource, request) {
-        const tableConfig = request.tableConfig;
-        const emptyState = request.emptyState;
-        const hasTableConfig = !!tableConfig && typeof tableConfig === 'object' && !Array.isArray(tableConfig);
-        const hasEmptyState = !!emptyState && typeof emptyState === 'object' && !Array.isArray(emptyState);
-        const base = hasTableConfig ? tableConfig : {};
-        const toolbar = this.objectValue(base['toolbar']);
-        const columnsVisibility = this.objectValue(toolbar['columnsVisibility']);
-        const behavior = this.objectValue(base['behavior']);
-        const currentEmptyState = this.objectValue(behavior['emptyState']);
-        const hasCurrentEmptyState = Object.keys(currentEmptyState).length > 0;
-        const resolvedEmptyState = hasEmptyState
+        const discoveryOptions = options.endpointKey || options.apiUrlEntry
             ? {
-                ...currentEmptyState,
-                ...emptyState,
+                ...(options.endpointKey ? { endpointKey: options.endpointKey } : {}),
+                ...(options.apiUrlEntry ? { apiUrlEntry: options.apiUrlEntry } : {}),
             }
-            : hasCurrentEmptyState
-                ? currentEmptyState
-                : this.buildRelatedEmptyState(surface, relatedResource, request);
-        if (!hasTableConfig && !resolvedEmptyState) {
-            return undefined;
-        }
-        return {
-            ...base,
-            toolbar: {
-                ...toolbar,
-                columnsVisibility: {
-                    enabled: false,
-                    ...columnsVisibility,
-                },
+            : undefined;
+        const resolvedRequestSchemaUrl = this.discovery.resolveHref(action.requestSchemaUrl, discoveryOptions);
+        const resolvedResponseSchemaUrl = action.responseSchemaUrl
+            ? this.discovery.resolveHref(action.responseSchemaUrl, discoveryOptions)
+            : null;
+        const resolvedSubmitUrl = this.discovery.resolveHref(action.path, discoveryOptions);
+        const payload = this.clone(this.resolveDynamicFormPreset());
+        payload.presentation = options.presentation ?? payload.presentation;
+        payload.title = options.title ?? action.title ?? payload.title;
+        payload.subtitle = options.subtitle ?? action.description ?? payload.subtitle;
+        payload.icon = options.icon ?? payload.icon;
+        payload.context = {
+            resource: {
+                resourceKey: action.resourceKey,
+                resourcePath,
+                resourceId: options.resourceId ?? null,
+                group: options.group ?? null,
             },
-            behavior: {
-                ...behavior,
-                emptyState: resolvedEmptyState,
+            action: {
+                id: action.id,
+                scope: action.scope,
+                operationId: action.operationId,
+                path: action.path,
+                method: action.method,
+                requestSchemaId: action.requestSchemaId ?? null,
+                requestSchemaUrl: action.requestSchemaUrl,
+                responseSchemaId: action.responseSchemaId ?? null,
+                responseSchemaUrl: action.responseSchemaUrl ?? null,
+                availability: action.availability,
+                successMessage: action.successMessage ?? null,
+                tags: action.tags,
+                execution: action.execution ?? null,
             },
         };
-    }
-    buildRelatedEmptyState(surface, relatedResource, request) {
-        const label = this.trim(request.title)
-            || this.trim(surface.title)
-            || this.humanizeResourceKey(relatedResource.childResourceKey);
-        const canCreate = relatedResource.childOperations.includes('CREATE');
-        const descriptionKey = canCreate
-            ? 'emptyState.related.descriptionWithAction'
-            : 'emptyState.related.description';
-        const actions = canCreate
-            ? [
-                {
-                    label: this.t('emptyState.related.action.create', 'Adicionar registro'),
-                    action: 'create',
-                    icon: 'add',
-                    primary: true,
-                },
-            ]
-            : [];
-        return {
-            title: this.t('emptyState.related.title', 'Sem registros em {label}', { label }),
-            message: this.t(descriptionKey, canCreate
-                ? 'Use a ação principal para adicionar um registro relacionado quando houver informações para registrar.'
-                : 'Esta coleção relacionada não possui registros para o contexto selecionado.', { label }),
-            icon: this.trim(request.icon) || 'hub',
-            tone: 'neutral',
-            variant: 'inline',
-            density: 'compact',
-            alignment: 'center',
-            iconContainer: 'soft',
-            actions,
-        };
-    }
-    objectValue(value) {
-        return value && typeof value === 'object' && !Array.isArray(value)
-            ? value
-            : {};
-    }
-    buildQueryContext(queryContext, childParentField, parentResourceId) {
-        return {
-            ...(queryContext || {}),
-            filters: {
-                ...(queryContext?.filters || {}),
-                [childParentField]: parentResourceId,
-            },
-            meta: {
-                ...(queryContext?.meta || {}),
-                relatedResource: true,
-                parentFilterField: childParentField,
+        payload.widget.inputs = {
+            ...(payload.widget.inputs || {}),
+            resourcePath,
+            formId: this.buildStableInstanceId(action),
+            mode: 'create',
+            configPersistenceStrategy: 'input-first',
+            layoutPolicy: {
+                source: 'schema',
+                intent: 'command',
+                preset: 'groupedCommand',
+                lifecycle: 'live',
+                persistence: 'transient',
+                schemaType: 'request',
             },
+            schemaUrl: resolvedRequestSchemaUrl,
+            apiEndpointKey: options.endpointKey ?? null,
+            apiUrlEntry: options.apiUrlEntry ?? (discoveryOptions ? this.discovery.resolveApiEntry(discoveryOptions) : null),
+            submitMethod: String(action.method || '').trim().toLowerCase(),
+            submitUrl: resolvedSubmitUrl,
+            responseSchemaUrl: resolvedResponseSchemaUrl,
         };
-    }
-    resolveParentResourceId(request, relatedResource) {
-        if (request.parentResourceId != null) {
-            return request.parentResourceId;
-        }
-        return this.readPath(request.parentRecord, relatedResource.parentIdPathVariable);
-    }
-    readPath(record, path) {
-        if (!record || !path) {
-            return null;
+        if (options.initialValue) {
+            payload.widget.inputs['initialValue'] = this.clone(options.initialValue);
         }
-        const value = path.split('.').reduce((current, segment) => {
-            if (!current || typeof current !== 'object' || Array.isArray(current)) {
-                return undefined;
+        if (action.scope === 'ITEM') {
+            if (options.resourceId != null) {
+                payload.widget.inputs['resourceId'] = options.resourceId;
             }
-            return current[segment];
-        }, record);
-        return typeof value === 'string' || typeof value === 'number' ? value : null;
-    }
-    isCompleteRelatedResource(relatedResource) {
-        return !!relatedResource
-            && !!this.trim(relatedResource.childResourceKey)
-            && !!this.trim(relatedResource.childResourcePath)
-            && !!this.trim(relatedResource.childParentField)
-            && !!this.trim(relatedResource.parentIdPathVariable)
-            && Array.isArray(relatedResource.childOperations);
-    }
-    hasReadOperation(relatedResource) {
-        return relatedResource.childOperations.includes('LIST')
-            || relatedResource.childOperations.includes('FILTER');
-    }
-    buildStableTableId(surface, relatedResource, parentResourceId) {
-        return this.sanitizeStableId(`${relatedResource.childResourceKey}.${surface.id}.${String(parentResourceId)}`);
-    }
-    normalizeResourcePath(resourcePath) {
-        let normalized = this.trim(resourcePath);
-        if (/^https?:\/\//i.test(normalized)) {
-            try {
-                normalized = new URL(normalized).pathname;
+            else if (options.idBindingPath) {
+                payload.bindings = [
+                    ...(payload.bindings || []),
+                    this.buildIdBinding(options.idBindingPath),
+                ];
             }
-            catch {
-                return '';
+            else {
+                throw new Error(`ResourceActionOpenAdapterService requires resourceId or idBindingPath for item action "${action.id}".`);
             }
         }
-        return normalized
-            .replace(/^\/+/, '')
-            .replace(/^(?:api\/)+/i, '')
-            .replace(/\/+$/, '');
+        this.applyExecutionInputs(payload, action, options);
+        return payload;
     }
-    sanitizeStableId(value) {
-        return value.replace(/[^a-zA-Z0-9._-]+/g, '-');
+    resolveDynamicFormPreset() {
+        const preset = SURFACE_OPEN_PRESETS.find((candidate) => candidate.id === 'praxis-dynamic-form');
+        if (!preset) {
+            throw new Error('Missing canonical surface preset "praxis-dynamic-form".');
+        }
+        return preset.payload;
     }
-    humanizeResourceKey(value) {
-        const lastSegment = this.trim(value).split(/[./_-]+/).filter(Boolean).pop() || 'registros';
-        return lastSegment
-            .replace(/([a-z])([A-Z])/g, '$1 $2')
-            .replace(/\s+/g, ' ')
-            .trim();
+    buildStableInstanceId(action) {
+        return `${action.resourceKey}.action.${action.id}`.replace(/[^a-zA-Z0-9._-]+/g, '-');
     }
-    t(key, fallback, params) {
-        if (this.i18n) {
-            return this.interpolate(this.i18n.t(key, params, fallback, RELATED_RESOURCE_OUTLET_I18N_NAMESPACE), params);
+    applyExecutionInputs(payload, action, options) {
+        const execution = action.execution;
+        if (!execution) {
+            payload.widget.inputs['submitIdempotencyKey'] = this.createCommandIdentity('idempotency');
+            return;
+        }
+        const inputs = payload.widget.inputs;
+        if (execution.preconditions.idempotencyKey !== 'NONE') {
+            inputs['submitIdempotencyKey'] = this.createCommandIdentity('idempotency');
+        }
+        if (execution.preconditions.correlationId !== 'NONE') {
+            inputs['submitCorrelationId'] =
+                String(options.correlationId ?? '').trim() || this.createCommandIdentity('correlation');
+        }
+        if (execution.preconditions.resourceVersionTransport !== 'IF_MATCH') {
+            return;
+        }
+        if (options.resourceVersion != null && String(options.resourceVersion).trim()) {
+            inputs['submitResourceVersion'] = options.resourceVersion;
+            return;
+        }
+        if (options.resourceVersionBindingPath) {
+            payload.bindings = [
+                ...(payload.bindings || []),
+                {
+                    from: options.resourceVersionBindingPath,
+                    to: 'widget.inputs.submitResourceVersion',
+                    mode: 'path',
+                },
+            ];
+            return;
+        }
+        if (execution.preconditions.resourceVersion === 'REQUIRED') {
+            throw new Error(`ResourceActionOpenAdapterService requires resourceVersion or resourceVersionBindingPath for action "${action.id}".`);
         }
-        return this.interpolate(fallback, params);
     }
-    interpolate(template, params) {
-        return Object.entries(params || {}).reduce((current, [name, value]) => current.replace(new RegExp(`\\{${name}\\}`, 'g'), String(value ?? '')), template);
+    createIdempotencyKey() {
+        const randomUuid = globalThis.crypto?.randomUUID?.bind(globalThis.crypto);
+        return randomUuid ? randomUuid() : `praxis-action-${Date.now()}-${Math.random().toString(16).slice(2)}`;
     }
-    trim(value) {
-        return typeof value === 'string' ? value.trim() : '';
+    createCommandIdentity(kind) {
+        return `${kind}-${this.createIdempotencyKey()}`;
+    }
+    normalizeResourcePath(resourcePath) {
+        return String(resourcePath || '').trim().replace(/^\/+/, '').replace(/\/+$/, '');
+    }
+    buildIdBinding(idBindingPath) {
+        return {
+            from: idBindingPath,
+            to: 'widget.inputs.resourceId',
+            mode: 'path',
+        };
     }
     clone(value) {
         return value == null ? value : JSON.parse(JSON.stringify(value));
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: RelatedResourceSurfaceResolverService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: RelatedResourceSurfaceResolverService, providedIn: 'any' });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: ResourceActionOpenAdapterService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: ResourceActionOpenAdapterService, providedIn: 'any' });
 }
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: RelatedResourceSurfaceResolverService, decorators: [{
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: ResourceActionOpenAdapterService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'any' }]
         }] });
 
+class SurfaceOutletRegistryService {
+    registrations = new Map();
+    register(registration) {
+        const key = this.key(registration.resourceKey, registration.surfaceId);
+        this.registrations.set(key, [...(this.registrations.get(key) ?? []), registration]
+            .sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0)));
+        return () => {
+            const next = (this.registrations.get(key) ?? []).filter((item) => item !== registration);
+            next.length ? this.registrations.set(key, next) : this.registrations.delete(key);
+        };
+    }
+    async tryActivate(payload, context) {
+        const resourceKey = String(payload.context?.['surface']?.['resourceKey'] ?? '').trim();
+        const surfaceId = String(payload.context?.['surface']?.['id'] ?? '').trim();
+        if (!resourceKey || !surfaceId)
+            return false;
+        for (const registration of this.registrations.get(this.key(resourceKey, surfaceId)) ?? []) {
+            if (await registration.activate(payload, context))
+                return true;
+        }
+        return false;
+    }
+    key(resourceKey, surfaceId) {
+        return `${resourceKey.trim().toLowerCase()}::${surfaceId.trim().toLowerCase()}`;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: SurfaceOutletRegistryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: SurfaceOutletRegistryService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.14", ngImport: i0, type: SurfaceOutletRegistryService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
 class SurfaceOpenMaterializerService {
     discovery = inject(ResourceDiscoveryService);
     async materialize(payload, context) {
@@ -15784,6 +15813,8 @@ class SurfaceOpenMaterializerService {
                             path: '',
                             schemaPath: schemaResourcePath || null,
                             idField: this.resolveRelatedSelectionKeyField(payload),
+                            title: payload.title || null,
+                            formTitle: payload.title || null,
                             endpointKey: previousInputs['apiEndpointKey'] ?? undefined,
                             apiUrlEntry: previousInputs['apiUrlEntry'] ?? undefined,
                         },
@@ -15793,12 +15824,6 @@ class SurfaceOpenMaterializerService {
                         queryContext: null,
                         defaults: {
                             openMode: 'drawer',
-                            modal: {
-                                width: 'min(720px, 100vw)',
-                                maxWidth: '100vw',
-                                height: '100vh',
-                                position: 'end',
-                            },
                         },
                         actions,
                     },
@@ -16029,12 +16054,14 @@ class SurfaceOpenMaterializerService {
     buildRelatedCrudActions(payload, operations, paths) {
         const noun = this.resolveRelatedActionNoun(payload);
         const formIdPrefix = this.stableSurfaceId(payload);
+        const contextFields = this.buildRelatedContextFields(payload);
         const actions = [];
         if (operations.has('CREATE')) {
             actions.push({
                 id: 'create',
                 action: 'create',
-                label: `Novo ${noun}`,
+                label: `Adicionar ${noun}`,
+                tooltip: this.resolveRelatedActionDescription(payload, 'create', noun),
                 formId: `${formIdPrefix}.create`,
                 icon: 'add',
                 color: 'primary',
@@ -16042,7 +16069,7 @@ class SurfaceOpenMaterializerService {
                 position: 'end',
                 target: { scope: 'collection' },
                 openMode: 'drawer',
-                form: this.buildExplicitRelatedActionForm('create', paths),
+                form: this.buildExplicitRelatedActionForm('create', paths, this.buildRelatedParentInitialValue(payload), contextFields),
             });
         }
         if (operations.has('UPDATE')) {
@@ -16050,6 +16077,7 @@ class SurfaceOpenMaterializerService {
                 id: 'edit',
                 action: 'edit',
                 label: `Editar ${noun}`,
+                tooltip: this.resolveRelatedActionDescription(payload, 'edit', noun),
                 formId: `${formIdPrefix}.edit`,
                 icon: 'edit',
                 color: 'primary',
@@ -16060,14 +16088,15 @@ class SurfaceOpenMaterializerService {
                     cardinality: { min: 1, max: 1 },
                 },
                 openMode: 'drawer',
-                form: this.buildExplicitRelatedActionForm('edit', paths),
+                form: this.buildExplicitRelatedActionForm('edit', paths, undefined, contextFields),
             });
         }
         if (operations.has('DELETE')) {
             actions.push({
                 id: 'delete',
                 action: 'delete',
-                label: `Apagar ${noun}`,
+                label: `Remover ${noun}`,
+                tooltip: this.resolveRelatedActionDescription(payload, 'delete', noun),
                 formId: `${formIdPrefix}.delete`,
                 icon: 'delete',
                 color: 'warn',
@@ -16109,7 +16138,7 @@ class SurfaceOpenMaterializerService {
             },
         };
     }
-    buildExplicitRelatedActionForm(action, paths) {
+    buildExplicitRelatedActionForm(action, paths, initialValue, contextFields) {
         const resourcePath = this.normalizeResourcePath(paths?.resourcePath || '');
         const schemaResourcePath = this.normalizeResourcePath(paths?.schemaResourcePath || resourcePath);
         if (!resourcePath) {
@@ -16120,7 +16149,10 @@ class SurfaceOpenMaterializerService {
                 schemaUrl: this.buildSchemaUrl(schemaResourcePath, 'post', 'request'),
                 submitUrl: resourcePath,
                 submitMethod: 'post',
-                layoutPolicy: this.buildRelatedCommandLayoutPolicy('create'),
+                ...(initialValue && Object.keys(initialValue).length
+                    ? { initialValue }
+                    : {}),
+                layoutPolicy: this.buildRelatedCommandLayoutPolicy('create', contextFields),
             };
         }
         const itemSchemaPath = schemaResourcePath ? `${schemaResourcePath}/{id}` : '';
@@ -16130,7 +16162,7 @@ class SurfaceOpenMaterializerService {
                 schemaUrl: this.buildSchemaUrl(itemSchemaPath, 'put', 'request'),
                 submitUrl: itemSubmitUrl,
                 submitMethod: 'put',
-                layoutPolicy: this.buildRelatedCommandLayoutPolicy('update'),
+                layoutPolicy: this.buildRelatedCommandLayoutPolicy('update', contextFields),
             };
         }
         return {
@@ -16138,7 +16170,7 @@ class SurfaceOpenMaterializerService {
             submitMethod: 'delete',
         };
     }
-    buildRelatedCommandLayoutPolicy(schemaOperation) {
+    buildRelatedCommandLayoutPolicy(schemaOperation, contextFields) {
         return {
             source: 'schema',
             intent: 'command',
@@ -16147,6 +16179,9 @@ class SurfaceOpenMaterializerService {
             persistence: 'transient',
             schemaOperation,
             schemaType: 'request',
+            ...(contextFields?.length
+                ? { groupedCommand: { contextFields } }
+                : {}),
         };
     }
     buildSchemaUrl(path, operation, schemaType) {
@@ -16178,6 +16213,21 @@ class SurfaceOpenMaterializerService {
         const relatedResource = payload.context?.['relatedResource'];
         return relatedResource;
     }
+    buildRelatedParentInitialValue(payload) {
+        const parentField = String(this.resolveRelatedResource(payload)?.childParentField || '').trim();
+        const resource = payload.context?.['resource'];
+        const parentResourceId = resource?.['resourceId'];
+        if (!parentField ||
+            parentResourceId == null ||
+            String(parentResourceId).trim() === '') {
+            return undefined;
+        }
+        return { [parentField]: parentResourceId };
+    }
+    buildRelatedContextFields(payload) {
+        const parentField = String(this.resolveRelatedResource(payload)?.childParentField || '').trim();
+        return parentField ? [parentField] : [];
+    }
     resolveRelatedSelectionKeyField(payload) {
         const relatedResource = this.resolveRelatedResource(payload);
         const field = String(relatedResource?.selectionKeyField || '').trim();
@@ -16214,22 +16264,42 @@ class SurfaceOpenMaterializerService {
         ]
             .map((value) => String(value || '').trim())
             .find(Boolean) || '';
-        const normalized = source
-            .normalize('NFD')
-            .replace(/[\u0300-\u036f]/g, '')
-            .toLowerCase();
-        if (/\b(documentos?|documents?)\b/.test(normalized)) {
-            return 'documento';
-        }
-        const firstToken = normalized
-            .split(/[^a-z0-9]+/)
+        const firstToken = source
+            .split(/[^\p{L}\p{N}]+/u)
             .filter(Boolean)
-            .find((token) => !['de', 'da', 'do', 'das', 'dos', 'legal', 'legais'].includes(token));
-        if (firstToken && firstToken.length > 3) {
-            return firstToken.endsWith('s') ? firstToken.slice(0, -1) : firstToken;
+            .find((token) => !['de', 'da', 'do', 'das', 'dos'].includes(token.toLocaleLowerCase('pt-BR')));
+        if (firstToken && firstToken.length > 2) {
+            return this.singularizePtBrWord(firstToken).toLocaleLowerCase('pt-BR');
         }
         return 'item';
     }
+    singularizePtBrWord(word) {
+        if (/ções$/iu.test(word))
+            return word.replace(/ções$/iu, 'ção');
+        if (/ões$/iu.test(word))
+            return word.replace(/ões$/iu, 'ão');
+        if (/ais$/iu.test(word))
+            return word.replace(/ais$/iu, 'al');
+        if (/eis$/iu.test(word))
+            return word.replace(/eis$/iu, 'el');
+        if (/res$/iu.test(word))
+            return word.replace(/es$/iu, '');
+        if (/s$/iu.test(word) && !/ss$/iu.test(word))
+            return word.replace(/s$/iu, '');
+        return word;
+    }
+    resolveRelatedActionDescription(payload, action, noun) {
+        const surfaceDescription = String(payload.subtitle
+            || payload.context?.['surface']?.['description']
+            || '').trim();
+        if (surfaceDescription)
+            return surfaceDescription;
+        if (action === 'create')
+            return `Adicione ${noun} ao contexto selecionado.`;
+        if (action === 'edit')
+            return `Atualize os dados de ${noun} no contexto selecionado.`;
+        return `Remova ${noun} do contexto selecionado.`;
+    }
     inferColumnsFromData(data) {
         const first = data.find((item) => item && typeof item === 'object' && !Array.isArray(item));
         if (!first || typeof first !== 'object')
@@ -23415,6 +23485,7 @@ function normalizeLayoutPolicy(policy) {
             ? {
                 orphanFieldExpansion: policy?.groupedCommand?.orphanFieldExpansion ??
                     'medium-and-wide',
+                contextFields: normalizeFieldNameList(policy?.groupedCommand?.contextFields),
             }
             : policy?.groupedCommand,
     };
@@ -23692,6 +23763,12 @@ function spanForColumns(columns) {
     return Math.max(1, Math.min(12, Math.floor(12 / columns)));
 }
 function fieldsForPolicy(fields, policy) {
+    if (policy.preset === 'groupedCommand') {
+        const contextFields = groupedCommandContextFields(policy);
+        return fields.map((field) => contextFields.has(field.name)
+            ? { ...field, formHidden: true, hidden: true }
+            : field);
+    }
     if (policy.preset !== 'compactPresentation') {
         return fields;
     }
@@ -23710,11 +23787,23 @@ function fieldsForPolicy(fields, policy) {
     }));
 }
 function fieldsForLayoutPolicy(fields, policy) {
+    if (policy.preset === 'groupedCommand') {
+        const contextFields = groupedCommandContextFields(policy);
+        return fields.filter((field) => !contextFields.has(field.name));
+    }
     if (policy.preset !== 'compactPresentation') {
         return fields;
     }
     return resolveDetailSummaryFields(fields, policy);
 }
+function groupedCommandContextFields(policy) {
+    return new Set(normalizeFieldNameList(policy.groupedCommand?.contextFields));
+}
+function normalizeFieldNameList(value) {
+    return Array.from(new Set((value || [])
+        .map((fieldName) => String(fieldName || '').trim())
+        .filter(Boolean)));
+}
 function resolvePresentationFields(fields) {
     return fields.filter((field) => !isFormHidden(field));
 }