@praxisui/core 3.0.0-beta.5 → 3.0.0-beta.7

package/fesm2022/praxisui-core.mjs

@@ -1,35 +1,39 @@
 import * as i0 from '@angular/core';
-import { Component, InjectionToken, Injectable, inject, Inject, makeEnvironmentProviders, Optional, ENVIRONMENT_INITIALIZER, ErrorHandler, APP_INITIALIZER, Input, ChangeDetectionStrategy, Directive, SecurityContext, EventEmitter, Output, ViewContainerRef, ContentChild, signal, HostListener, computed, ViewChild } from '@angular/core';
+import { Component, InjectionToken, Injectable, inject, Inject, makeEnvironmentProviders, Optional, ENVIRONMENT_INITIALIZER, ErrorHandler, APP_INITIALIZER, EventEmitter, Output, Input, ChangeDetectionStrategy, Directive, SecurityContext, ViewContainerRef, ContentChild, signal, HostListener, computed, ViewChild } from '@angular/core';
 import * as i1 from '@angular/common/http';
-import { HttpHeaders, HttpClient, HttpParams, HttpContextToken, HTTP_INTERCEPTORS, withInterceptors } from '@angular/common/http';
+import { HttpHeaders, HttpClient, HttpParams, HttpResponse, HttpContextToken, HTTP_INTERCEPTORS, withInterceptors } from '@angular/common/http';
 import { of, defer, throwError, from, EMPTY, BehaviorSubject, firstValueFrom, Subject } from 'rxjs';
 import { switchMap, take, map, catchError, concatMap, tap, shareReplay, takeUntil, toArray, finalize } from 'rxjs/operators';
-import * as i1$1 from '@angular/common';
+import * as i1$2 from '@angular/common';
 import { Location, CommonModule } from '@angular/common';
 import { Router, ActivatedRoute } from '@angular/router';
-import * as i2$1 from '@angular/forms';
+import * as i1$1 from '@angular/forms';
 import { Validators, FormGroup, FormControl, FormsModule } from '@angular/forms';
 import { MatSnackBar } from '@angular/material/snack-bar';
+import * as i2 from '@angular/material/button';
+import { MatButtonModule } from '@angular/material/button';
+import * as i3 from '@angular/material/form-field';
+import { MatFormFieldModule } from '@angular/material/form-field';
 import * as i4 from '@angular/material/icon';
 import { MatIconModule } from '@angular/material/icon';
+import * as i5 from '@angular/material/input';
+import { MatInputModule } from '@angular/material/input';
+import * as i6 from '@angular/material/select';
+import { MatSelectModule } from '@angular/material/select';
+import * as i7 from '@angular/material/slide-toggle';
+import { MatSlideToggleModule } from '@angular/material/slide-toggle';
+import * as i5$1 from '@angular/material/tooltip';
+import { MatTooltipModule } from '@angular/material/tooltip';
 import { DomSanitizer } from '@angular/platform-browser';
-import * as i2 from '@angular/material/button';
-import { MatButtonModule } from '@angular/material/button';
 import * as i4$1 from '@angular/material/menu';
 import { MatMenuModule } from '@angular/material/menu';
-import * as i5 from '@angular/material/tooltip';
-import { MatTooltipModule } from '@angular/material/tooltip';
-import * as i3 from '@angular/material/card';
+import * as i3$1 from '@angular/material/card';
 import { MatCardModule } from '@angular/material/card';
-import * as i3$1 from '@angular/material/form-field';
-import { MatFormFieldModule } from '@angular/material/form-field';
-import * as i4$2 from '@angular/material/input';
-import { MatInputModule } from '@angular/material/input';
 import * as i8 from '@angular/material/chips';
 import { MatChipsModule } from '@angular/material/chips';
-import * as i1$2 from '@angular/material/dialog';
+import * as i1$3 from '@angular/material/dialog';
 import { MAT_DIALOG_DATA, MatDialogModule, MatDialog } from '@angular/material/dialog';
-import * as i2$2 from '@angular/material/tabs';
+import * as i2$1 from '@angular/material/tabs';
 import { MatTabsModule } from '@angular/material/tabs';
 
 class PraxisCore {
@@ -594,6 +598,24 @@ function resolveControlTypeAlias(value, fallback = FieldControlType.INPUT) {
     return raw;
 }
 
+const VALUE_PRESENTATION_TYPES = new Set([
+    'string',
+    'number',
+    'currency',
+    'percentage',
+    'date',
+    'datetime',
+    'time',
+    'boolean',
+]);
+const VALUE_PRESENTATION_STYLES = new Set([
+    'default',
+    'short',
+    'medium',
+    'long',
+    'full',
+    'compact',
+]);
 /**
  * SchemaNormalizerService
  * -----------------------
@@ -712,6 +734,41 @@ class SchemaNormalizerService {
         }
         return optionSource;
     }
+    parseValuePresentation(value) {
+        if (!value || typeof value !== 'object' || Array.isArray(value)) {
+            return undefined;
+        }
+        const typeToken = String(value.type ?? '').trim();
+        if (!typeToken || !VALUE_PRESENTATION_TYPES.has(typeToken)) {
+            if (typeToken) {
+                console.warn(`[SchemaNormalizer] Ignoring invalid x-ui.valuePresentation.type: ${typeToken}`);
+            }
+            return undefined;
+        }
+        const presentation = {
+            type: typeToken,
+        };
+        const styleToken = String(value.style ?? '').trim();
+        if (styleToken) {
+            if (VALUE_PRESENTATION_STYLES.has(styleToken)) {
+                presentation.style = styleToken;
+            }
+            else {
+                console.warn(`[SchemaNormalizer] Ignoring invalid x-ui.valuePresentation.style: ${styleToken}`);
+            }
+        }
+        const formatToken = String(value.format ?? '').trim();
+        if (formatToken) {
+            presentation.format = formatToken;
+        }
+        if (value.currency && typeof value.currency === 'object') {
+            presentation.currency = { ...value.currency };
+        }
+        if (value.number && typeof value.number === 'object') {
+            presentation.number = { ...value.number };
+        }
+        return presentation;
+    }
     /**
      * Converte string/Function em função real.
      * Atenção: usa `new Function` para avaliar strings – requer backend confiável.
@@ -955,6 +1012,10 @@ class SchemaNormalizerService {
                 field.numericFormat = numericFormat;
                 field.format = numericFormat;
             }
+            const valuePresentation = this.parseValuePresentation(ui.valuePresentation);
+            if (valuePresentation) {
+                field.valuePresentation = valuePresentation;
+            }
             if (ui.controlType) {
                 field.controlType = ui.controlType;
             }
@@ -1458,6 +1519,8 @@ function resolveDefaultHeaders() {
  * HTTP-based storage that talks to praxis-config-starter user-config API.
  */
 class ApiConfigStorage {
+    static unavailableLoadBaseUrls = new Set();
+    static loadAvailabilityProbes = new Map();
     http = inject(HttpClient);
     opts = inject(API_CONFIG_STORAGE_OPTIONS, { optional: true });
     baseUrl = (this.opts?.baseUrl || '/api/praxis/config/ui').replace(/\/$/, '');
@@ -1472,13 +1535,86 @@ class ApiConfigStorage {
     // Simple in-memory cache of etag/payload per key to support 304 reuse
     cache = new Map();
     constructor() { }
+    shouldLogLoadError(key, err) {
+        if (err?.status === 404)
+            return false;
+        return this.shouldPropagateLoadError(key, err);
+    }
+    shouldLogSaveError(key, err) {
+        if (err?.status === 404)
+            return false;
+        return this.shouldPropagateSaveError(key);
+    }
+    shouldLogClearError(key, err) {
+        if (err?.status === 404)
+            return false;
+        return this.shouldPropagateClearError(key);
+    }
     loadConfig(key) {
+        if (ApiConfigStorage.unavailableLoadBaseUrls.has(this.baseUrl)) {
+            return of(null);
+        }
+        const existingProbe = ApiConfigStorage.loadAvailabilityProbes.get(this.baseUrl);
+        if (existingProbe) {
+            return defer(() => from(existingProbe).pipe(switchMap((available) => available ? this.executeLoadConfigRequest(key, false) : of(null))));
+        }
+        return this.executeLoadConfigRequest(key, true);
+    }
+    executeLoadConfigRequest(key, establishAvailability) {
         const cached = this.cache.get(key);
         const etag = cached?.etag;
         const { type, id } = this.resolveKey(key);
         const url = `${this.baseUrl}`;
         const params = this.buildParams(type, id);
         const headers = this.buildHeaders(etag ? { 'If-None-Match': this.formatEtag(etag) } : {});
+        let releaseProbe = null;
+        if (establishAvailability) {
+            let resolveProbe;
+            const probe = new Promise((resolve) => {
+                resolveProbe = resolve;
+            });
+            ApiConfigStorage.loadAvailabilityProbes.set(this.baseUrl, probe);
+            releaseProbe = () => {
+                ApiConfigStorage.loadAvailabilityProbes.delete(this.baseUrl);
+            };
+            const previousRelease = releaseProbe;
+            releaseProbe = () => {
+                resolveProbe(true);
+                previousRelease();
+            };
+            const markUnavailable = () => {
+                ApiConfigStorage.unavailableLoadBaseUrls.add(this.baseUrl);
+                resolveProbe(false);
+                previousRelease();
+            };
+            return this.http
+                .get(url, { observe: 'response', headers, params })
+                .pipe(map((resp) => {
+                const nextEtag = this.stripQuotes(resp.headers.get('ETag'));
+                const body = resp.body;
+                if (nextEtag) {
+                    this.cache.set(key, { etag: nextEtag, payload: body?.payload });
+                }
+                releaseProbe?.();
+                return body?.payload ?? null;
+            }), catchError((err) => {
+                if (err.status === 304 && cached?.payload !== undefined) {
+                    releaseProbe?.();
+                    return of(cached.payload);
+                }
+                if (err.status === 404) {
+                    markUnavailable();
+                    return of(null);
+                }
+                releaseProbe?.();
+                if (this.shouldLogLoadError(key, err)) {
+                    console.warn('[ApiConfigStorage] load error', err);
+                }
+                return this.shouldPropagateLoadError(key, err)
+                    ? throwError(() => err)
+                    : of(null);
+            }));
+        }
         return this.http
             .get(url, { observe: 'response', headers, params })
             .pipe(map((resp) => {
@@ -1493,9 +1629,13 @@ class ApiConfigStorage {
             if (err.status === 304 && cached?.payload !== undefined) {
                 return of(cached.payload);
             }
-            if (err.status === 404)
+            if (err.status === 404) {
+                ApiConfigStorage.unavailableLoadBaseUrls.add(this.baseUrl);
                 return of(null);
-            console.warn('[ApiConfigStorage] load error', err);
+            }
+            if (this.shouldLogLoadError(key, err)) {
+                console.warn('[ApiConfigStorage] load error', err);
+            }
             return this.shouldPropagateLoadError(key, err)
                 ? throwError(() => err)
                 : of(null);
@@ -1513,7 +1653,9 @@ class ApiConfigStorage {
             const payload = resp.body?.payload ?? config;
             this.cache.set(key, { etag: nextEtag, payload });
         }), catchError((err) => {
-            console.warn('[ApiConfigStorage] save error', err);
+            if (this.shouldLogSaveError(key, err)) {
+                console.warn('[ApiConfigStorage] save error', err);
+            }
             return this.shouldPropagateSaveError(key)
                 ? throwError(() => err)
                 // Soft-fail path: complete without next so runtime can treat as
@@ -1550,7 +1692,9 @@ class ApiConfigStorage {
             .pipe(map(() => {
             this.cache.delete(key);
         }), catchError((err) => {
-            console.warn('[ApiConfigStorage] clear error', err);
+            if (this.shouldLogClearError(key, err)) {
+                console.warn('[ApiConfigStorage] clear error', err);
+            }
             return this.shouldPropagateClearError(key)
                 ? throwError(() => err)
                 // Soft-fail path: complete without next so runtime can treat as
@@ -1978,6 +2122,7 @@ class GenericCrudService {
         emptyEntity: 'A entidade não pode ser nula ou vazia.',
         unconfiguredService: 'Serviço não configurado. Chame configure() antes de usar.',
     };
+    static unavailableFilteredSchemaUrls = new Set();
     baseApiUrl; // Root URL for the API
     apiUrl; // Full base path for the configured resource
     endpoints = {}; // Stores user-defined custom endpoints
@@ -2183,6 +2328,10 @@ class GenericCrudService {
         // Build cache key including the API origin (not the app origin)
         const schemaId = buildSchemaId({ path, operation, schemaType, includeInternalSchemas: false, tenant, locale, apiOrigin });
         const headersBase = composeHeadersWithVersion(entry);
+        const shouldUseDirectSchemaEndpoint = GenericCrudService.unavailableFilteredSchemaUrls.has(filteredUrl);
+        if (shouldUseDirectSchemaEndpoint) {
+            return this.fetchDirectSchema(url, schemaId, apiOrigin, entry, locale, tenant, options?.httpContext);
+        }
         return from(this.ensureSchemaCacheReady()).pipe(concatMap(() => from(this._schemaCache.get(schemaId)).pipe(concatMap((cached) => {
             let headers = (headersBase instanceof HttpHeaders ? headersBase : new HttpHeaders(headersBase));
             if (cached?.schemaHash) {
@@ -2279,6 +2428,10 @@ class GenericCrudService {
         }), 
         // Angular HttpClient treats 304 as error; also handle status 0 (CORS/network) by reusing cache
         catchError((err) => {
+            if (err?.status === 404) {
+                GenericCrudService.unavailableFilteredSchemaUrls.add(filteredUrl);
+                return this.fetchDirectSchema(url, schemaId, apiOrigin, entry, locale, tenant, options?.httpContext);
+            }
             if (err?.status === 304 || err?.status === 0) {
                 return from(this._schemaCache.get(schemaId)).pipe(concatMap((cached) => {
                     if (cached?.schema) {
@@ -2335,6 +2488,69 @@ class GenericCrudService {
             return this.handleError(err);
         }))), shareReplay(1));
     }
+    fetchDirectSchema(url, schemaId, apiOrigin, entry, locale, tenant, httpContext) {
+        return from(this.ensureSchemaCacheReady()).pipe(concatMap(() => from(this._schemaCache.get(schemaId)).pipe(concatMap((cached) => {
+            const baseHeaders = composeHeadersWithVersion(entry);
+            let headers = (baseHeaders instanceof HttpHeaders ? baseHeaders : new HttpHeaders(baseHeaders));
+            if (cached?.schemaHash) {
+                headers = headers.set('If-None-Match', `"${cached.schemaHash}"`);
+            }
+            if (locale)
+                headers = headers.set('Accept-Language', locale);
+            if (tenant)
+                headers = headers.set('X-Tenant', tenant);
+            return this.http.get(url, {
+                headers,
+                observe: 'response',
+                context: httpContext,
+            }).pipe(concatMap((resp) => {
+                const response = resp instanceof HttpResponse
+                    ? resp
+                    : new HttpResponse({ status: 200, body: resp });
+                const body = response.body;
+                const etag = response.headers.get('ETag') || '';
+                const xHash = response.headers.get('X-Schema-Hash');
+                const schemaHash = (xHash || etag).replace(/^W\//, '').replace(/^"|"$/g, '');
+                const now = new Date().toISOString();
+                const entryToCache = {
+                    schema: body,
+                    schemaHash,
+                    meta: {
+                        version: '2.0.0',
+                        name: 'Grid/Response Schema',
+                        createdAt: now,
+                        updatedAt: now,
+                        resourcePath: this.resourcePath,
+                        schemaId,
+                        apiOrigin,
+                    },
+                };
+                this._schemaCache.set(schemaId, entryToCache);
+                this._lastSchemaInfo = { schemaId, schemaHash };
+                try {
+                    const idField = body?.['x-ui']?.resource?.idField;
+                    this._lastResourceMeta = { idField, resourcePath: this.resourcePath };
+                }
+                catch { }
+                return of(this.schemaNormalizer.normalizeSchema(body));
+            }), catchError((err) => {
+                if ((err?.status === 304 || err?.status === 0) && cached?.schema) {
+                    try {
+                        const idField = cached.schema?.['x-ui']?.resource?.idField;
+                        this._lastResourceMeta = {
+                            idField: idField || this._lastResourceMeta.idField,
+                            resourcePath: this.resourcePath,
+                        };
+                    }
+                    catch { }
+                    const cachedHash = cached.schemaHash || '';
+                    this._lastSchemaInfo = { schemaId, schemaHash: cachedHash };
+                    return of(this.schemaNormalizer.normalizeSchema(cached.schema));
+                }
+                return this.handleError(err);
+            }));
+        }))));
+    }
     /** Retorna o campo identificador do recurso (ex.: 'id', 'codigo'), quando derivado do schema. */
     getResourceIdField() {
         const key = (this._lastResourceMeta?.idField || '').trim();
@@ -4418,6 +4634,147 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImpo
             args: [{ providedIn: 'root' }]
         }] });
 
+class SurfaceBindingRuntimeService {
+    resolveWidget(widget, bindings, actionPayload, actionContext, explicitContext) {
+        const context = this.buildContext(actionPayload, actionContext, explicitContext);
+        let resolvedWidget = this.clone(widget);
+        resolvedWidget = this.resolveTemplate(resolvedWidget, context);
+        for (const binding of bindings || []) {
+            const targetPath = this.normalizeTargetPath(binding?.to);
+            if (!targetPath)
+                continue;
+            const value = this.resolveBindingValue(binding, context);
+            resolvedWidget = this.setValueAtPath(resolvedWidget, targetPath, value);
+        }
+        return resolvedWidget;
+    }
+    extractByPath(obj, path) {
+        if (!path)
+            return obj;
+        return String(path)
+            .split('.')
+            .reduce((acc, key) => acc?.[key], obj);
+    }
+    resolveTemplate(node, context) {
+        if (node == null)
+            return node;
+        if (Array.isArray(node))
+            return node.map((value) => this.resolveTemplate(value, context));
+        if (typeof node === 'object') {
+            const out = {};
+            for (const [key, value] of Object.entries(node)) {
+                out[key] = this.resolveTemplate(value, context);
+            }
+            return out;
+        }
+        if (typeof node === 'string') {
+            const exact = node.match(/^\s*\$\{([^}]+)\}\s*$/);
+            if (exact) {
+                return this.extractByPath(context, exact[1].trim());
+            }
+            return node.replace(/\$\{([^}]+)\}/g, (_match, path) => {
+                const value = this.extractByPath(context, String(path).trim());
+                return value != null ? String(value) : '';
+            });
+        }
+        return node;
+    }
+    setValueAtPath(obj, rawPath, value) {
+        const path = this.tokenizePath(rawPath);
+        if (!path.length)
+            return obj;
+        const clone = Array.isArray(obj) ? obj.slice() : { ...obj };
+        let cursor = clone;
+        for (let i = 0; i < path.length; i++) {
+            const key = path[i];
+            const isLast = i === path.length - 1;
+            if (isLast) {
+                cursor[key] = value;
+                continue;
+            }
+            const next = cursor[key];
+            const nextIsIndex = typeof path[i + 1] === 'number';
+            const created = next != null
+                ? (Array.isArray(next) ? next.slice() : { ...next })
+                : (nextIsIndex ? [] : {});
+            cursor[key] = created;
+            cursor = created;
+        }
+        return clone;
+    }
+    buildContext(actionPayload, actionContext, explicitContext) {
+        return {
+            payload: actionContext?.payload,
+            context: explicitContext || {},
+            pageContext: actionContext?.pageContext || undefined,
+            meta: actionContext?.meta || undefined,
+            runtime: actionContext?.runtime || undefined,
+            action: actionPayload,
+            sourceId: actionContext?.sourceId,
+            widgetKey: actionContext?.widgetKey,
+            output: actionContext?.output,
+        };
+    }
+    resolveBindingValue(binding, context) {
+        const mode = binding.mode || (binding.value !== undefined ? 'constant' : 'path');
+        if (mode === 'constant')
+            return this.clone(binding.value);
+        if (mode === 'template') {
+            const templateSource = binding.value !== undefined ? binding.value : binding.from;
+            return this.resolveTemplate(templateSource, context);
+        }
+        return this.extractByPath(context, binding.from);
+    }
+    normalizeTargetPath(rawPath) {
+        const path = String(rawPath || '').trim();
+        if (!path)
+            return '';
+        return path.startsWith('widget.') ? path.slice('widget.'.length) : path;
+    }
+    tokenizePath(path) {
+        const tokens = [];
+        let buffer = '';
+        for (let i = 0; i < path.length; i++) {
+            const char = path[i];
+            if (char === '.') {
+                if (buffer) {
+                    tokens.push(buffer);
+                    buffer = '';
+                }
+                continue;
+            }
+            if (char === '[') {
+                if (buffer) {
+                    tokens.push(buffer);
+                    buffer = '';
+                }
+                let num = '';
+                i++;
+                while (i < path.length && path[i] !== ']') {
+                    num += path[i];
+                    i++;
+                }
+                const index = Number(num);
+                tokens.push(Number.isNaN(index) ? num : index);
+                continue;
+            }
+            buffer += char;
+        }
+        if (buffer)
+            tokens.push(buffer);
+        return tokens;
+    }
+    clone(value) {
+        return value == null ? value : JSON.parse(JSON.stringify(value));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: SurfaceBindingRuntimeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: SurfaceBindingRuntimeService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: SurfaceBindingRuntimeService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
 const GLOBAL_ACTION_HANDLERS = new InjectionToken('GLOBAL_ACTION_HANDLERS');
 const GLOBAL_DIALOG_SERVICE = new InjectionToken('GLOBAL_DIALOG_SERVICE');
 const GLOBAL_TOAST_SERVICE = new InjectionToken('GLOBAL_TOAST_SERVICE');
@@ -4432,6 +4789,8 @@ function provideGlobalActionHandler(entry) {
     };
 }
 
+const GLOBAL_SURFACE_SERVICE = new InjectionToken('GLOBAL_SURFACE_SERVICE');
+
 class GlobalActionService {
     handlers = new Map();
     router = (() => { try {
@@ -4459,10 +4818,12 @@ class GlobalActionService {
         return null;
     } })();
     dialog = inject(GLOBAL_DIALOG_SERVICE, { optional: true });
+    surface = inject(GLOBAL_SURFACE_SERVICE, { optional: true });
     toast = inject(GLOBAL_TOAST_SERVICE, { optional: true });
     analytics = inject(GLOBAL_ANALYTICS_SERVICE, { optional: true });
     api = inject(GLOBAL_API_CLIENT, { optional: true });
     guardResolver = inject(GLOBAL_ROUTE_GUARD_RESOLVER, { optional: true });
+    surfaceBindingRuntime = inject(SurfaceBindingRuntimeService);
     constructor() {
         const entries = inject(GLOBAL_ACTION_HANDLERS, { optional: true });
         (entries || []).forEach((e) => this.register(e.id, e.handler));
@@ -4535,6 +4896,17 @@ class GlobalActionService {
             const data = await this.dialog.open(payload || {});
             return { success: true, data };
         });
+        this.register('surface.open', async (payload, context) => {
+            if (!this.surface)
+                return { success: false, error: 'Surface service not available' };
+            const surfacePayload = payload;
+            if (!surfacePayload?.widget?.id) {
+                return { success: false, error: 'surface.open requires widget.id' };
+            }
+            const resolvedWidget = this.surfaceBindingRuntime.resolveWidget(surfacePayload.widget, surfacePayload.bindings, surfacePayload, context, surfacePayload.context);
+            const data = await this.surface.open({ ...surfacePayload, widget: resolvedWidget }, context);
+            return { success: true, data };
+        });
         this.register('toast.success', async (payload) => {
             const message = payload?.message || payload;
             if (!message)
@@ -7868,6 +8240,42 @@ const PRAXIS_GLOBAL_ACTION_CATALOG = [
             example: { componentId: 'praxis-dynamic-form', inputs: { formId: 'clientes' } },
         },
     },
+    {
+        id: 'surface.open',
+        label: 'Abrir Surface',
+        icon: 'open_in_new',
+        description: 'Abre modal ou drawer com um widget registrado e bindings dinâmicos.',
+        payloadSchema: {
+            type: 'object',
+            properties: {
+                presentation: { type: 'string', description: 'Tipo de apresentação: modal ou drawer.' },
+                title: { type: 'string', description: 'Título opcional da surface.' },
+                subtitle: { type: 'string', description: 'Subtítulo opcional da surface.' },
+                icon: { type: 'string', description: 'Ícone opcional da surface.' },
+                size: { type: 'object', description: 'Configuração opcional de tamanho da surface.' },
+                widget: { type: 'object', description: 'WidgetDefinition do componente a ser renderizado.' },
+                bindings: { type: 'array', description: 'Bindings declarativos aplicados sobre widget.inputs.*.' },
+                context: { type: 'object', description: 'Contexto explícito adicional exposto ao runtime de bindings.' },
+            },
+            required: ['presentation', 'widget'],
+            example: {
+                presentation: 'drawer',
+                title: 'Detalhes do Funcionário',
+                widget: {
+                    id: 'praxis-dynamic-form',
+                    bindingOrder: ['resourcePath', 'formId', 'resourceId'],
+                    inputs: {
+                        resourcePath: 'human-resources/employees',
+                        formId: 'employee-detail',
+                        mode: 'view',
+                    },
+                },
+                bindings: [
+                    { from: 'payload.row.id', to: 'widget.inputs.resourceId' },
+                ],
+            },
+        },
+    },
     {
         id: 'toast.success',
         label: 'Toast Sucesso',
@@ -8007,6 +8415,17 @@ const GLOBAL_ACTION_CATALOG = [
             example: 'https://docs.exemplo.com',
         },
     },
+    {
+        id: 'surface.open',
+        label: 'Abrir Surface',
+        description: 'Abre modal ou drawer com um componente registrado e payload dinâmico.',
+        param: {
+            label: 'Payload (JSON)',
+            placeholder: '{"presentation":"drawer","widget":{"id":"praxis-dynamic-form","inputs":{"resourcePath":"employees","formId":"employee-detail"}}}',
+            hint: 'Use o editor especializado para configurar widget, inputs e bindings da surface.',
+            example: '{"presentation":"drawer","widget":{"id":"praxis-dynamic-form","inputs":{"resourcePath":"employees","formId":"employee-detail"}}}',
+        },
+    },
     {
         id: 'showAlert',
         label: 'Alerta simples',
@@ -8178,6 +8597,110 @@ function findGlobalActionSpec(id) {
     return GLOBAL_ACTION_CATALOG.find((item) => item.id === id);
 }
 
+const SURFACE_OPEN_I18N_NAMESPACE = 'surfaceOpen';
+const SURFACE_OPEN_I18N_CONFIG = {
+    namespaces: {
+        [SURFACE_OPEN_I18N_NAMESPACE]: {
+            'pt-BR': {
+                'editor.presets.title': 'Presets',
+                'editor.presets.help': 'Aplique um preset para começar com inputs mínimos e depois configure bindings conforme a origem da action.',
+                'editor.surface.title': 'Surface',
+                'editor.surface.presentation': 'Apresentação',
+                'editor.surface.presentation.modal': 'Modal',
+                'editor.surface.presentation.drawer': 'Drawer',
+                'editor.surface.titleLabel': 'Título',
+                'editor.surface.subtitleLabel': 'Subtítulo',
+                'editor.surface.iconLabel': 'Ícone',
+                'editor.surface.widthLabel': 'Largura',
+                'editor.surface.heightLabel': 'Altura',
+                'editor.surface.minWidthLabel': 'Largura mínima',
+                'editor.surface.maxWidthLabel': 'Largura máxima',
+                'editor.component.title': 'Componente',
+                'editor.component.select': 'Componente registrado',
+                'editor.component.selectPlaceholder': '-- Selecionar --',
+                'editor.component.bindingOrder': 'bindingOrder (CSV)',
+                'editor.component.bindingOrderPlaceholder': 'resourcePath, formId, resourceId',
+                'editor.inputs.title': 'Inputs',
+                'editor.inputs.empty': 'Selecione um componente registrado para configurar inputs públicos.',
+                'editor.bindings.title': 'Bindings',
+                'editor.bindings.add': 'Binding',
+                'editor.bindings.source': 'Origem',
+                'editor.bindings.target': 'Destino',
+                'editor.bindings.mode': 'Modo',
+                'editor.bindings.constantValue': 'Valor constante',
+                'editor.bindings.remove': 'Remover binding',
+                'editor.bindings.empty': 'Nenhum binding configurado ainda.',
+                'editor.bindings.suggestedSources': 'Origens sugeridas: {{value}}',
+                'editor.bindings.suggestedTargets': 'Destinos sugeridos: {{value}}',
+                'editor.context.title': 'Contexto extra',
+                'editor.context.label': 'context (JSON)',
+                'editor.context.hint': 'Opcional. Mesclado ao contexto da action no runtime.',
+                'editor.validation.invalidJson': 'JSON inválido.',
+                'editor.validation.objectJson': 'Informe um objeto JSON.',
+                'preset.praxis-dynamic-form.label': 'Formulário',
+                'preset.praxis-dynamic-form.description': 'Abre um formulário dinâmico com resourcePath, formId e resourceId.',
+                'preset.praxis-table.label': 'Tabela',
+                'preset.praxis-table.description': 'Abre uma tabela configurável com resourcePath, tableId e queryContext.',
+                'preset.praxis-list.label': 'Lista',
+                'preset.praxis-list.description': 'Abre uma lista com listId e config básicos.',
+                'preset.praxis-crud.label': 'CRUD',
+                'preset.praxis-crud.description': 'Abre a surface de CRUD com resourcePath, formId e bindings configuráveis.',
+                'action.surfaceOpen.label': 'Abrir Surface',
+                'action.surfaceOpen.description': 'Abre modal ou drawer com um componente registrado e payload dinâmico.',
+                'action.surfaceOpen.hint': 'Use o editor especializado para configurar widget, inputs e bindings da surface.',
+            },
+            'en-US': {
+                'editor.presets.title': 'Presets',
+                'editor.presets.help': 'Apply a preset to start with minimal inputs, then configure bindings for the action source.',
+                'editor.surface.title': 'Surface',
+                'editor.surface.presentation': 'Presentation',
+                'editor.surface.presentation.modal': 'Modal',
+                'editor.surface.presentation.drawer': 'Drawer',
+                'editor.surface.titleLabel': 'Title',
+                'editor.surface.subtitleLabel': 'Subtitle',
+                'editor.surface.iconLabel': 'Icon',
+                'editor.surface.widthLabel': 'Width',
+                'editor.surface.heightLabel': 'Height',
+                'editor.surface.minWidthLabel': 'Min width',
+                'editor.surface.maxWidthLabel': 'Max width',
+                'editor.component.title': 'Component',
+                'editor.component.select': 'Registered component',
+                'editor.component.selectPlaceholder': '-- Select --',
+                'editor.component.bindingOrder': 'bindingOrder (CSV)',
+                'editor.component.bindingOrderPlaceholder': 'resourcePath, formId, resourceId',
+                'editor.inputs.title': 'Inputs',
+                'editor.inputs.empty': 'Select a registered component to configure public inputs.',
+                'editor.bindings.title': 'Bindings',
+                'editor.bindings.add': 'Binding',
+                'editor.bindings.source': 'Source',
+                'editor.bindings.target': 'Target',
+                'editor.bindings.mode': 'Mode',
+                'editor.bindings.constantValue': 'Constant value',
+                'editor.bindings.remove': 'Remove binding',
+                'editor.bindings.empty': 'No bindings configured yet.',
+                'editor.bindings.suggestedSources': 'Suggested sources: {{value}}',
+                'editor.bindings.suggestedTargets': 'Suggested targets: {{value}}',
+                'editor.context.title': 'Extra context',
+                'editor.context.label': 'context (JSON)',
+                'editor.context.hint': 'Optional. Merged into the action context at runtime.',
+                'editor.validation.invalidJson': 'Invalid JSON.',
+                'editor.validation.objectJson': 'Provide a JSON object.',
+                'preset.praxis-dynamic-form.label': 'Form',
+                'preset.praxis-dynamic-form.description': 'Opens a dynamic form with resourcePath, formId and resourceId.',
+                'preset.praxis-table.label': 'Table',
+                'preset.praxis-table.description': 'Opens a configurable table with resourcePath, tableId and queryContext.',
+                'preset.praxis-list.label': 'List',
+                'preset.praxis-list.description': 'Opens a list with basic listId and config inputs.',
+                'preset.praxis-crud.label': 'CRUD',
+                'preset.praxis-crud.description': 'Opens the CRUD surface with resourcePath, formId and configurable bindings.',
+                'action.surfaceOpen.label': 'Open Surface',
+                'action.surfaceOpen.description': 'Opens a modal or drawer with a registered component and dynamic payload.',
+                'action.surfaceOpen.hint': 'Use the dedicated editor to configure the surface widget, inputs and bindings.',
+            },
+        },
+    },
+};
+
 const SETTINGS_PANEL_BRIDGE = new InjectionToken('SETTINGS_PANEL_BRIDGE');
 // Optional data token for consumers that still use DI-based data passing.
 // Prefer using component inputs when opening via SettingsPanelBridge.
@@ -8390,6 +8913,169 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImpo
                     args: [PRAXIS_I18N_TRANSLATOR]
                 }] }] });
 
+const DEFAULT_LOCALE = 'en-US';
+const DEFAULT_DATE_TIME = {
+    dateFormat: 'shortDate',
+    timeFormat: 'shortTime',
+    dateTimeFormat: 'short',
+    firstDayOfWeek: 0,
+    relativeTime: false,
+};
+const DEFAULT_NUMBER = {
+    decimalSeparator: '.',
+    thousandsSeparator: ',',
+    defaultPrecision: 2,
+    negativeSign: '-',
+    negativeSignPosition: 'before',
+};
+const DEFAULT_CURRENCY = {
+    code: 'USD',
+    symbol: '$',
+    position: 'before',
+    spacing: false,
+    precision: 2,
+};
+const IMPLICIT_FORMAT_TYPES = new Set([
+    'number',
+    'currency',
+    'percentage',
+    'date',
+    'datetime',
+    'time',
+]);
+function resolveValuePresentation(config, context) {
+    const localization = context?.localization ?? null;
+    const locale = resolveValuePresentationLocale(context, localization);
+    const number = resolveNumberLocaleConfig(config, localization);
+    const currency = resolveCurrencyLocaleConfig(config, localization);
+    const dateTime = resolveDateTimeLocaleConfig(localization);
+    return {
+        type: config.type,
+        locale,
+        style: config.style,
+        format: config.format ||
+            resolveDefaultValuePresentationFormat(config.type, config.style, {
+                localization,
+                number,
+                currency,
+                dateTime,
+            }),
+        currency: config.type === 'currency' ? currency : undefined,
+        number: config.type === 'number' || config.type === 'percentage'
+            ? number
+            : undefined,
+        dateTime: config.type === 'date' ||
+            config.type === 'datetime' ||
+            config.type === 'time'
+            ? dateTime
+            : undefined,
+    };
+}
+function resolveValuePresentationLocale(context, localization) {
+    return (context?.valueLocale ||
+        localization?.locale ||
+        context?.surfaceLocale ||
+        context?.appLocale ||
+        DEFAULT_LOCALE);
+}
+function supportsImplicitValuePresentation(type) {
+    return !!type && IMPLICIT_FORMAT_TYPES.has(type);
+}
+function resolveDefaultValuePresentationFormat(type, style, context) {
+    switch (type) {
+        case 'date':
+            return resolveDateFormat(style, context.dateTime.dateFormat);
+        case 'datetime':
+            return resolveDateTimeFormat(style, context.dateTime.dateTimeFormat);
+        case 'time':
+            return resolveTimeFormat(style, context.dateTime.timeFormat);
+        case 'number':
+            return resolveDigitsFormat(context.number.defaultPrecision);
+        case 'currency':
+            return `${context.currency.code}|symbol|${context.currency.precision}`;
+        case 'percentage':
+            return (context.localization?.formatting?.percentageFormat ||
+                resolveDigitsFormat(context.number.defaultPrecision));
+        default:
+            return undefined;
+    }
+}
+function resolveDateTimeLocaleConfig(localization) {
+    return {
+        ...DEFAULT_DATE_TIME,
+        ...(localization?.dateTime || {}),
+    };
+}
+function resolveNumberLocaleConfig(config, localization) {
+    return {
+        ...DEFAULT_NUMBER,
+        ...(localization?.number || {}),
+        ...(config.number || {}),
+    };
+}
+function resolveCurrencyLocaleConfig(config, localization) {
+    return {
+        ...DEFAULT_CURRENCY,
+        ...(localization?.currency || {}),
+        ...(config.currency || {}),
+    };
+}
+function resolveDateFormat(style, fallback) {
+    switch (style) {
+        case 'short':
+            return 'shortDate';
+        case 'medium':
+            return 'mediumDate';
+        case 'long':
+            return 'longDate';
+        case 'full':
+            return 'fullDate';
+        default:
+            return fallback || DEFAULT_DATE_TIME.dateFormat;
+    }
+}
+function resolveDateTimeFormat(style, fallback) {
+    switch (style) {
+        case 'short':
+            return 'short';
+        case 'medium':
+            return 'medium';
+        case 'long':
+            return 'long';
+        case 'full':
+            return 'full';
+        default:
+            return fallback || DEFAULT_DATE_TIME.dateTimeFormat;
+    }
+}
+function resolveTimeFormat(style, fallback) {
+    switch (style) {
+        case 'short':
+            return 'shortTime';
+        case 'medium':
+            return 'mediumTime';
+        case 'long':
+            return 'longTime';
+        case 'full':
+            return 'fullTime';
+        default:
+            return fallback || DEFAULT_DATE_TIME.timeFormat;
+    }
+}
+function resolveDigitsFormat(defaultPrecision) {
+    const precision = clampPrecision(defaultPrecision);
+    return `1.${precision}-${precision}`;
+}
+function clampPrecision(value) {
+    if (typeof value !== 'number' || Number.isNaN(value)) {
+        return DEFAULT_NUMBER.defaultPrecision;
+    }
+    if (value < 0) {
+        return 0;
+    }
+    return Math.floor(value);
+}
+
 /**
  * Enum que define os tipos de dados (`TYPE`) disponíveis para configuração dos campos de formulário.
  */
@@ -9790,6 +10476,7 @@ const RULE_PROPERTY_SCHEMA = {
             ],
         },
         { name: 'sectionHeader.initialsMaxLength', type: 'number', label: 'Máximo de iniciais' },
+        { name: 'headerActions', type: 'object', label: 'Ações do cabeçalho' },
         { name: 'className', type: 'string', label: 'Classe CSS' },
         { name: 'style', type: 'object', label: 'Estilos inline' },
         { name: 'borderColor', type: 'string', label: 'Cor da borda' },
@@ -10894,6 +11581,66 @@ function createPersistedPage(identity, page, opts) {
 
 // Global Dialog domain types for GlobalConfig (kept independent of @praxisui/dialog types)
 
+function normalizeRecord(record) {
+    if (!record || typeof record !== 'object')
+        return null;
+    const next = Object.entries(record).reduce((acc, [key, value]) => {
+        if (value === null || value === undefined)
+            return acc;
+        if (Array.isArray(value) && value.length === 0)
+            return acc;
+        if (typeof value === 'string' && value.trim() === '')
+            return acc;
+        acc[key] = value;
+        return acc;
+    }, {});
+    return Object.keys(next).length ? next : null;
+}
+function normalizePraxisDataQueryContext(context) {
+    if (!context || typeof context !== 'object')
+        return null;
+    const filters = normalizeRecord(context.filters);
+    const meta = normalizeRecord(context.meta);
+    const sort = Array.isArray(context.sort)
+        ? context.sort
+            .map((item) => (typeof item === 'string' ? item.trim() : ''))
+            .filter((item) => item.length > 0)
+        : [];
+    const limit = typeof context.limit === 'number' && Number.isFinite(context.limit)
+        ? Math.max(0, Math.trunc(context.limit))
+        : null;
+    const page = context.page && typeof context.page === 'object'
+        ? {
+            index: typeof context.page.index === 'number' && Number.isFinite(context.page.index)
+                ? Math.max(0, Math.trunc(context.page.index))
+                : null,
+            size: typeof context.page.size === 'number' && Number.isFinite(context.page.size)
+                ? Math.max(0, Math.trunc(context.page.size))
+                : null,
+        }
+        : null;
+    const next = {};
+    if (filters)
+        next.filters = filters;
+    if (sort.length)
+        next.sort = sort;
+    if (limit !== null)
+        next.limit = limit;
+    if (page && (page.index !== null || page.size !== null))
+        next.page = page;
+    if (meta)
+        next.meta = meta;
+    return Object.keys(next).length ? next : null;
+}
+function resolvePraxisFilterCriteria(filterCriteria, queryContext) {
+    const normalizedFilterCriteria = normalizeRecord(filterCriteria);
+    const normalizedQueryContext = normalizePraxisDataQueryContext(queryContext);
+    return {
+        ...(normalizedFilterCriteria || {}),
+        ...(normalizedQueryContext?.filters || {}),
+    };
+}
+
 const DEFAULT_FIELD_SELECTOR_CONTROL_TYPE_MAP = {
     'pdx-text-input': FieldControlType.INPUT,
     'pdx-email-input': FieldControlType.EMAIL_INPUT,
@@ -11155,6 +11902,18 @@ function mapFieldDefinitionToMetadata(field) {
     if (field.type) {
         metadata.dataType = field.type;
     }
+    if (field.valuePresentation) {
+        const valuePresentation = {
+            ...field.valuePresentation,
+        };
+        if (field.valuePresentation.currency) {
+            valuePresentation.currency = { ...field.valuePresentation.currency };
+        }
+        if (field.valuePresentation.number) {
+            valuePresentation.number = { ...field.valuePresentation.number };
+        }
+        metadata.valuePresentation = valuePresentation;
+    }
     const simpleProps = [
         'order',
         'group',
@@ -11454,15 +12213,19 @@ function normalizeTargets(rule) {
         (Array.isArray(rule.targetFields) && rule.targetFields.length && rule.targetFields) ||
         [];
     const targetType = rule.targetType ||
-        (rawTargets.some((t) => t?.startsWith('section:')) ? 'section'
-            : rawTargets.some((t) => t?.startsWith('action:')) ? 'action'
-                : rawTargets.some((t) => t?.startsWith('row:')) ? 'row'
-                    : rawTargets.some((t) => t?.startsWith('column:')) ? 'column'
-                        : 'field');
+        (rawTargets.some((t) => isScopedSectionHeaderActionTarget(t) || isUnscopedSectionHeaderActionTarget(t)) ? 'action'
+            : rawTargets.some((t) => t?.startsWith('section:')) ? 'section'
+                : rawTargets.some((t) => t?.startsWith('action:')) ? 'action'
+                    : rawTargets.some((t) => t?.startsWith('row:')) ? 'row'
+                        : rawTargets.some((t) => t?.startsWith('column:')) ? 'column'
+                            : 'field');
     const targets = rawTargets.map((t) => stripPrefix(t));
     return { targetType, targets };
 }
 function stripPrefix(value) {
+    if (isScopedSectionHeaderActionTarget(value) || isUnscopedSectionHeaderActionTarget(value)) {
+        return value;
+    }
     if (value?.startsWith('section:'))
         return value.substring('section:'.length);
     if (value?.startsWith('action:'))
@@ -11473,6 +12236,12 @@ function stripPrefix(value) {
         return value.substring('column:'.length);
     return value;
 }
+function isScopedSectionHeaderActionTarget(value) {
+    return !!value && value.startsWith('section:') && value.includes(':header-action:');
+}
+function isUnscopedSectionHeaderActionTarget(value) {
+    return !!value && value.startsWith('header-action:');
+}
 function inferPropertiesFromContext(context) {
     switch (context) {
         case 'visibility':
@@ -11844,6 +12613,12 @@ const dialogFieldsWithModeDependency = dialogFieldsWithoutMessage.map((field) =>
     hint: field.hint ?? 'Disponível quando "Usar diálogo" estiver ativo.',
 }));
 const GLOBAL_ACTION_UI_SCHEMAS = [
+    {
+        id: 'surface.open',
+        label: 'Abrir Surface',
+        fields: [],
+        editorMode: 'surface-open',
+    },
     {
         id: 'navigate',
         label: 'Navegar',
@@ -12051,41 +12826,1209 @@ function getGlobalActionUiSchema(id) {
     return GLOBAL_ACTION_UI_SCHEMAS.find((schema) => schema.id === id);
 }
 
-/**
- * Catálogo de capacidades genéricas de FieldMetadata para uso da IA.
- * Baseado em projects/praxis-core/src/lib/models/component-metadata.interface.ts
- */
-const ENUMS$1 = {
-    fieldControlType: Object.values(FieldControlType),
-    fieldDataType: Object.values(FieldDataType),
-    componentContext: ['form', 'filter', 'table', 'dialog', 'standalone'],
-    iconPosition: ['start', 'end'],
-    iconSize: ['small', 'medium', 'large'],
-    validationMode: ['immediate', 'blur', 'submit'],
-    validatorTrigger: ['change', 'blur', 'submit', 'immediate'],
-    validatorErrorPosition: ['bottom', 'top', 'tooltip'],
-    dependencyMergeStrategy: ['replace', 'merge'],
-    dependencyLoadOnChange: ['respectLoadOn', 'immediate', 'manual'],
-    textTransformApply: ['displayOnly', 'saveOnly', 'both'],
-    visibleIn: ['form', 'filter', 'table', 'dialog'],
-    appearance: ['fill', 'outline'],
-    color: ['primary', 'accent', 'warn'],
-    floatLabel: ['auto', 'always', 'never'],
-    hintPosition: ['start', 'end'],
-    align: ['start', 'center', 'end', 'stretch'],
-    sectionTitleStyle: ['titleLarge', 'titleMedium', 'titleSmall', 'headlineSmall'],
-    sectionDescriptionStyle: ['bodyLarge', 'bodyMedium', 'bodySmall'],
-};
-const FIELD_METADATA_CAPABILITIES = {
-    version: 'v1.3',
-    enums: ENUMS$1,
-    notes: [
-        'Este catálogo define as capacidades genéricas de FieldMetadata.',
-        'O host típico para estes metadados é FormConfig (via fieldMetadata[]) ou FormLayout.',
-        'Detalhes específicos de cada controle (ex: opções de datepicker, máscaras específicas) devem ser consultados nos catálogos de microcomponentes.',
-        'POLICY: Arrays e objetos (ex: options, validators) devem sofrer merge/append, nunca substituição completa sem confirmação.',
-        'Funções (conditionalRequired, transforms) não são serializáveis. O LLM não deve gerar código de função, apenas expressões string se suportado pelo interpretador, ou solicitar configuração manual.',
-    ],
+const SURFACE_OPEN_PRESETS = [
+    {
+        id: 'praxis-dynamic-form',
+        label: 'Formulário',
+        description: 'Abre um formulário dinâmico com resourcePath, formId e resourceId.',
+        payload: {
+            presentation: 'drawer',
+            widget: {
+                id: 'praxis-dynamic-form',
+                bindingOrder: ['resourcePath', 'formId', 'resourceId'],
+                inputs: {
+                    resourcePath: '',
+                    formId: '',
+                    mode: 'view',
+                },
+            },
+            bindings: [],
+        },
+    },
+    {
+        id: 'praxis-table',
+        label: 'Tabela',
+        description: 'Abre uma tabela filtrável usando inputs declarativos e queryContext.',
+        payload: {
+            presentation: 'drawer',
+            widget: {
+                id: 'praxis-table',
+                bindingOrder: ['resourcePath', 'tableId', 'queryContext'],
+                inputs: {
+                    resourcePath: '',
+                    tableId: '',
+                    queryContext: {
+                        filters: {},
+                    },
+                },
+            },
+            bindings: [],
+        },
+    },
+    {
+        id: 'praxis-list',
+        label: 'Lista',
+        description: 'Abre uma lista com config/listId e bindings configuráveis.',
+        payload: {
+            presentation: 'drawer',
+            widget: {
+                id: 'praxis-list',
+                bindingOrder: ['listId', 'config'],
+                inputs: {
+                    listId: '',
+                    config: {},
+                },
+            },
+            bindings: [],
+        },
+    },
+    {
+        id: 'praxis-crud',
+        label: 'CRUD',
+        description: 'Abre a surface de CRUD com inputs mínimos e bindings configuráveis.',
+        payload: {
+            presentation: 'drawer',
+            widget: {
+                id: 'praxis-crud',
+                bindingOrder: ['resourcePath', 'formId', 'resourceId'],
+                inputs: {
+                    resourcePath: '',
+                    formId: '',
+                },
+            },
+            bindings: [],
+        },
+    },
+];
+
+class SurfaceOpenActionEditorComponent {
+    value;
+    hostKind;
+    valueChange = new EventEmitter();
+    draft = this.createDefaultPayload();
+    inputJsonDrafts = {};
+    inputErrors = {};
+    contextDraft = '';
+    contextError = '';
+    registry = inject(ComponentMetadataRegistry);
+    i18n = inject(PraxisI18nService);
+    static nextInstanceId = 0;
+    instanceId = ++SurfaceOpenActionEditorComponent.nextInstanceId;
+    sourceSuggestionsListId = `surface-binding-source-suggestions-${this.instanceId}`;
+    targetSuggestionsListId = `surface-binding-target-suggestions-${this.instanceId}`;
+    get availablePresets() {
+        return SURFACE_OPEN_PRESETS;
+    }
+    get componentOptions() {
+        return this.registry
+            .getAll()
+            .slice()
+            .sort((a, b) => String(a.friendlyName || a.id).localeCompare(String(b.friendlyName || b.id)));
+    }
+    get selectedComponentMeta() {
+        return this.draft.widget?.id ? this.registry.get(this.draft.widget.id) : undefined;
+    }
+    get selectedInputs() {
+        return this.selectedComponentMeta?.inputs || [];
+    }
+    get bindingOrderText() {
+        return (this.draft.widget.bindingOrder || []).join(', ');
+    }
+    get bindingSourceSuggestions() {
+        const generic = [
+            'payload.id',
+            'payload.resourceId',
+            'payload.row.id',
+            'payload.item.id',
+            'payload.formData.id',
+            'context.resourceId',
+            'pageContext.resourceId',
+        ];
+        const byHost = {
+            table: ['payload.row.id', 'payload.row.departmentId', 'payload.selection.ids', 'runtime.row.id'],
+            form: ['payload.resourceId', 'payload.formData.customerId', 'runtime.formData.id'],
+            list: ['payload.item.id', 'payload.item.status', 'payload.selection.ids', 'runtime.item.id'],
+            page: ['pageContext.filters.status', 'pageContext.selection.ids', 'context.pageState.activeId'],
+        };
+        return this.uniqueStrings([...(byHost[this.hostKind || ''] || []), ...generic]);
+    }
+    get bindingTargetSuggestions() {
+        const metaTargets = this.selectedInputs.map((input) => `widget.inputs.${input.name}`);
+        const commonTargets = [
+            'widget.inputs.resourcePath',
+            'widget.inputs.formId',
+            'widget.inputs.resourceId',
+            'widget.inputs.tableId',
+            'widget.inputs.listId',
+            'widget.inputs.queryContext',
+            'widget.inputs.queryContext.filters',
+            'widget.inputs.filterCriteria',
+        ];
+        return this.uniqueStrings([...metaTargets, ...commonTargets]);
+    }
+    get bindingSourceSuggestionsPreview() {
+        return this.bindingSourceSuggestions.slice(0, 5).join(', ');
+    }
+    get bindingTargetSuggestionsPreview() {
+        return this.bindingTargetSuggestions.slice(0, 5).join(', ');
+    }
+    ngOnChanges(changes) {
+        if (changes['value']) {
+            this.draft = this.normalizePayload(this.value);
+            this.refreshJsonDrafts();
+        }
+    }
+    updatePresentation(value) {
+        this.draft.presentation = value === 'drawer' ? 'drawer' : 'modal';
+        this.emitDraft();
+    }
+    updateTextField(field, value) {
+        this.assignTextField(field, value);
+        this.emitDraft();
+    }
+    updateSizeField(field, value) {
+        const text = String(value || '').trim();
+        if (!text) {
+            if (this.draft.size) {
+                delete this.draft.size[field];
+                if (!Object.keys(this.draft.size).length) {
+                    delete this.draft.size;
+                }
+            }
+        }
+        else {
+            this.draft.size = { ...(this.draft.size || {}), [field]: text };
+        }
+        this.emitDraft();
+    }
+    updateWidgetId(componentId) {
+        const nextId = String(componentId || '').trim();
+        const previousInputs = { ...(this.draft.widget.inputs || {}) };
+        this.draft.widget.id = nextId;
+        this.draft.widget.inputs = this.reconcileInputsForComponent(nextId, previousInputs);
+        this.refreshJsonDrafts();
+        this.emitDraft();
+    }
+    updateBindingOrder(value) {
+        const items = String(value || '')
+            .split(',')
+            .map((item) => item.trim())
+            .filter(Boolean);
+        if (items.length) {
+            this.draft.widget.bindingOrder = items;
+        }
+        else {
+            delete this.draft.widget.bindingOrder;
+        }
+        this.emitDraft();
+    }
+    applyPreset(preset) {
+        this.draft = this.normalizePayload(preset.payload);
+        this.refreshJsonDrafts();
+        this.emitDraft();
+    }
+    isBooleanType(type) {
+        return /^(bool|boolean)$/i.test(String(type || ''));
+    }
+    isNumberType(type) {
+        return /^(number|int|float|double)$/i.test(String(type || ''));
+    }
+    isJsonType(type) {
+        return /(json|object|record|map|array|\[\]|criteria|config|input|params)/i.test(String(type || ''));
+    }
+    getBooleanInputValue(name) {
+        return Boolean(this.draft.widget.inputs?.[name]);
+    }
+    getScalarInputValue(name) {
+        return this.draft.widget.inputs?.[name] ?? '';
+    }
+    getJsonInputDraft(name) {
+        if (!(name in this.inputJsonDrafts)) {
+            this.inputJsonDrafts[name] = this.stringifyJson(this.draft.widget.inputs?.[name]);
+        }
+        return this.inputJsonDrafts[name];
+    }
+    scalarPlaceholder(input) {
+        if (input.default !== undefined && input.default !== null && input.default !== '') {
+            return String(input.default);
+        }
+        return '';
+    }
+    jsonPlaceholder(input) {
+        if (input.default !== undefined && input.default !== null && input.default !== '') {
+            return this.stringifyJson(input.default);
+        }
+        return '{ }';
+    }
+    updateBooleanInput(name, value) {
+        this.ensureWidgetInputs();
+        this.draft.widget.inputs[name] = Boolean(value);
+        this.emitDraft();
+    }
+    updateScalarInput(name, type, value) {
+        this.ensureWidgetInputs();
+        const text = String(value ?? '');
+        if (!text.trim()) {
+            delete this.draft.widget.inputs[name];
+        }
+        else if (this.isNumberType(type)) {
+            const parsed = Number(text);
+            this.draft.widget.inputs[name] = Number.isFinite(parsed) ? parsed : text;
+        }
+        else {
+            this.draft.widget.inputs[name] = value;
+        }
+        this.emitDraft();
+    }
+    updateJsonInput(name, value) {
+        const raw = String(value || '');
+        this.inputJsonDrafts[name] = raw;
+        if (!raw.trim()) {
+            delete this.inputErrors[name];
+            if (this.draft.widget.inputs) {
+                delete this.draft.widget.inputs[name];
+            }
+            this.emitDraft();
+            return;
+        }
+        try {
+            const parsed = JSON.parse(raw);
+            delete this.inputErrors[name];
+            this.ensureWidgetInputs();
+            this.draft.widget.inputs[name] = parsed;
+            this.emitDraft();
+        }
+        catch {
+            this.inputErrors[name] = this.t('editor.validation.invalidJson', 'JSON inválido.');
+        }
+    }
+    addBinding() {
+        const bindings = [...(this.draft.bindings || [])];
+        bindings.push({
+            from: '',
+            to: this.selectedInputs[0]
+                ? `widget.inputs.${this.selectedInputs[0].name}`
+                : 'widget.inputs.resourceId',
+            mode: 'path',
+        });
+        this.draft.bindings = bindings;
+        this.emitDraft();
+    }
+    updateBinding(index, field, value) {
+        const bindings = [...(this.draft.bindings || [])];
+        const current = { ...(bindings[index] || { to: 'widget.inputs.resourceId', mode: 'path' }) };
+        if (field === 'mode') {
+            current.mode = value || 'path';
+            if (current.mode !== 'constant') {
+                delete current.value;
+            }
+            else if (current.value === undefined) {
+                current.value = '';
+            }
+        }
+        else if (field === 'value') {
+            current.value = value;
+        }
+        else if (field === 'from') {
+            current.from = String(value || '').trim();
+        }
+        else if (field === 'to') {
+            current.to = String(value || '').trim();
+        }
+        bindings[index] = current;
+        this.draft.bindings = bindings;
+        this.emitDraft();
+    }
+    removeBinding(index) {
+        const bindings = [...(this.draft.bindings || [])];
+        bindings.splice(index, 1);
+        this.draft.bindings = bindings.length ? bindings : undefined;
+        this.emitDraft();
+    }
+    updateContext(value) {
+        const raw = String(value || '');
+        this.contextDraft = raw;
+        if (!raw.trim()) {
+            this.contextError = '';
+            delete this.draft.context;
+            this.emitDraft();
+            return;
+        }
+        try {
+            const parsed = JSON.parse(raw);
+            if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+                this.contextError = this.t('editor.validation.objectJson', 'Informe um objeto JSON.');
+                return;
+            }
+            this.contextError = '';
+            this.draft.context = parsed;
+            this.emitDraft();
+        }
+        catch {
+            this.contextError = this.t('editor.validation.invalidJson', 'JSON inválido.');
+        }
+    }
+    presetLabel(preset) {
+        return this.t(`preset.${preset.id}.label`, preset.label);
+    }
+    presetDescription(preset) {
+        return this.t(`preset.${preset.id}.description`, preset.description);
+    }
+    t(key, fallback, params) {
+        return this.i18n.t(key, params, fallback, SURFACE_OPEN_I18N_NAMESPACE);
+    }
+    refreshJsonDrafts() {
+        this.inputJsonDrafts = {};
+        this.inputErrors = {};
+        for (const input of this.selectedInputs) {
+            if (this.isJsonType(input.type)) {
+                this.inputJsonDrafts[input.name] = this.stringifyJson(this.draft.widget.inputs?.[input.name]);
+            }
+        }
+        this.contextDraft = this.stringifyJson(this.draft.context);
+        this.contextError = '';
+    }
+    emitDraft() {
+        const normalized = this.normalizePayload(this.draft);
+        this.draft = normalized;
+        this.valueChange.emit(this.clone(normalized));
+    }
+    ensureWidgetInputs() {
+        this.draft.widget.inputs = { ...(this.draft.widget.inputs || {}) };
+    }
+    reconcileInputsForComponent(componentId, previousInputs) {
+        const meta = componentId ? this.registry.get(componentId) : undefined;
+        if (!meta?.inputs?.length) {
+            return {};
+        }
+        const nextInputs = {};
+        for (const input of meta.inputs) {
+            if (Object.prototype.hasOwnProperty.call(previousInputs, input.name)) {
+                nextInputs[input.name] = previousInputs[input.name];
+                continue;
+            }
+            if (input.default !== undefined) {
+                nextInputs[input.name] = this.clone(input.default);
+            }
+        }
+        return nextInputs;
+    }
+    assignTextField(field, value) {
+        const text = String(value || '').trim();
+        if (text) {
+            this.draft[field] = text;
+        }
+        else {
+            delete this.draft[field];
+        }
+    }
+    normalizePayload(value) {
+        const clone = this.clone(value || this.createDefaultPayload());
+        const normalized = {
+            presentation: clone.presentation === 'drawer' ? 'drawer' : 'modal',
+            widget: {
+                id: String(clone.widget?.id || '').trim(),
+                inputs: { ...(clone.widget?.inputs || {}) },
+            },
+        };
+        if (clone.title)
+            normalized.title = clone.title;
+        if (clone.subtitle)
+            normalized.subtitle = clone.subtitle;
+        if (clone.icon)
+            normalized.icon = clone.icon;
+        if (clone.size && Object.keys(clone.size).length) {
+            normalized.size = { ...clone.size };
+        }
+        if (clone.widget?.bindingOrder?.length) {
+            normalized.widget.bindingOrder = clone.widget.bindingOrder
+                .map((item) => String(item || '').trim())
+                .filter(Boolean);
+        }
+        if (clone.bindings?.length) {
+            normalized.bindings = clone.bindings
+                .map((binding) => ({
+                from: binding.from ? String(binding.from).trim() : undefined,
+                to: String(binding.to || '').trim(),
+                mode: binding.mode || 'path',
+                value: binding.value,
+            }))
+                .filter((binding) => !!binding.to);
+        }
+        if (clone.context && typeof clone.context === 'object' && !Array.isArray(clone.context)) {
+            normalized.context = { ...clone.context };
+        }
+        return normalized;
+    }
+    createDefaultPayload() {
+        return {
+            presentation: 'modal',
+            widget: {
+                id: '',
+                inputs: {},
+            },
+            bindings: [],
+        };
+    }
+    stringifyJson(value) {
+        if (value === undefined || value === null || value === '')
+            return '';
+        if (typeof value === 'string')
+            return value;
+        try {
+            return JSON.stringify(value, null, 2);
+        }
+        catch {
+            return '';
+        }
+    }
+    clone(value) {
+        return value == null ? value : JSON.parse(JSON.stringify(value));
+    }
+    uniqueStrings(values) {
+        return Array.from(new Set(values
+            .map((value) => String(value || '').trim())
+            .filter(Boolean)));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: SurfaceOpenActionEditorComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.3.17", type: SurfaceOpenActionEditorComponent, isStandalone: true, selector: "praxis-surface-open-action-editor", inputs: { value: "value", hostKind: "hostKind" }, outputs: { valueChange: "valueChange" }, providers: [providePraxisI18nConfig(SURFACE_OPEN_I18N_CONFIG)], usesOnChanges: true, ngImport: i0, template: `
+    <div class="surface-editor">
+      <div class="surface-section">
+        <div class="surface-section-title">{{ t('editor.presets.title', 'Presets') }}</div>
+        <div class="surface-preset-row">
+          @for (preset of availablePresets; track preset.id) {
+            <button
+              mat-stroked-button
+              type="button"
+              (click)="applyPreset(preset)"
+              [matTooltip]="presetDescription(preset)"
+            >
+              {{ presetLabel(preset) }}
+            </button>
+          }
+        </div>
+        <div class="surface-empty">
+          {{
+            t(
+              'editor.presets.help',
+              'Aplique um preset para começar com inputs mínimos e depois configure bindings conforme a origem da action.'
+            )
+          }}
+        </div>
+      </div>
+
+      <div class="surface-section">
+        <div class="surface-section-title">{{ t('editor.surface.title', 'Surface') }}</div>
+        <div class="surface-grid">
+          <mat-form-field appearance="outline">
+            <mat-label>{{ t('editor.surface.presentation', 'Apresentação') }}</mat-label>
+            <mat-select
+              [ngModel]="draft.presentation"
+              (ngModelChange)="updatePresentation($event)"
+              [ngModelOptions]="{ standalone: true }"
+            >
+              <mat-option value="modal">{{ t('editor.surface.presentation.modal', 'Modal') }}</mat-option>
+              <mat-option value="drawer">{{ t('editor.surface.presentation.drawer', 'Drawer') }}</mat-option>
+            </mat-select>
+          </mat-form-field>
+
+          <mat-form-field appearance="outline">
+            <mat-label>{{ t('editor.surface.titleLabel', 'Título') }}</mat-label>
+            <input
+              matInput
+              [ngModel]="draft.title || ''"
+              (ngModelChange)="updateTextField('title', $event)"
+              [ngModelOptions]="{ standalone: true }"
+            />
+          </mat-form-field>
+
+          <mat-form-field appearance="outline">
+            <mat-label>{{ t('editor.surface.subtitleLabel', 'Subtítulo') }}</mat-label>
+            <input
+              matInput
+              [ngModel]="draft.subtitle || ''"
+              (ngModelChange)="updateTextField('subtitle', $event)"
+              [ngModelOptions]="{ standalone: true }"
+            />
+          </mat-form-field>
+
+          <mat-form-field appearance="outline">
+            <mat-label>{{ t('editor.surface.iconLabel', 'Ícone') }}</mat-label>
+            <input
+              matInput
+              [ngModel]="draft.icon || ''"
+              (ngModelChange)="updateTextField('icon', $event)"
+              [ngModelOptions]="{ standalone: true }"
+              placeholder="open_in_new"
+            />
+          </mat-form-field>
+
+          <mat-form-field appearance="outline">
+            <mat-label>{{ t('editor.surface.widthLabel', 'Largura') }}</mat-label>
+            <input
+              matInput
+              [ngModel]="draft.size?.width || ''"
+              (ngModelChange)="updateSizeField('width', $event)"
+              [ngModelOptions]="{ standalone: true }"
+              placeholder="720px"
+            />
+          </mat-form-field>
+
+          <mat-form-field appearance="outline">
+            <mat-label>{{ t('editor.surface.heightLabel', 'Altura') }}</mat-label>
+            <input
+              matInput
+              [ngModel]="draft.size?.height || ''"
+              (ngModelChange)="updateSizeField('height', $event)"
+              [ngModelOptions]="{ standalone: true }"
+              placeholder="80vh"
+            />
+          </mat-form-field>
+
+          <mat-form-field appearance="outline">
+            <mat-label>{{ t('editor.surface.minWidthLabel', 'Largura mínima') }}</mat-label>
+            <input
+              matInput
+              [ngModel]="draft.size?.minWidth || ''"
+              (ngModelChange)="updateSizeField('minWidth', $event)"
+              [ngModelOptions]="{ standalone: true }"
+              placeholder="360px"
+            />
+          </mat-form-field>
+
+          <mat-form-field appearance="outline">
+            <mat-label>{{ t('editor.surface.maxWidthLabel', 'Largura máxima') }}</mat-label>
+            <input
+              matInput
+              [ngModel]="draft.size?.maxWidth || ''"
+              (ngModelChange)="updateSizeField('maxWidth', $event)"
+              [ngModelOptions]="{ standalone: true }"
+              placeholder="90vw"
+            />
+          </mat-form-field>
+        </div>
+      </div>
+
+      <div class="surface-section">
+        <div class="surface-section-title">{{ t('editor.component.title', 'Componente') }}</div>
+        <div class="surface-grid">
+          <mat-form-field appearance="outline" class="surface-span-2">
+            <mat-label>{{ t('editor.component.select', 'Componente registrado') }}</mat-label>
+            <mat-select
+              [ngModel]="draft.widget.id"
+              (ngModelChange)="updateWidgetId($event)"
+              [ngModelOptions]="{ standalone: true }"
+            >
+              <mat-option value="">{{ t('editor.component.selectPlaceholder', '-- Selecionar --') }}</mat-option>
+              @for (option of componentOptions; track option.id) {
+                <mat-option [value]="option.id">
+                  {{ option.friendlyName || option.id }}
+                </mat-option>
+              }
+            </mat-select>
+          </mat-form-field>
+
+          @if (selectedComponentMeta) {
+            <div class="surface-component-meta surface-span-2">
+              <div class="surface-component-title">
+                {{ selectedComponentMeta.friendlyName || selectedComponentMeta.id }}
+              </div>
+              @if (selectedComponentMeta.description) {
+                <div class="surface-component-description">
+                  {{ selectedComponentMeta.description }}
+                </div>
+              }
+            </div>
+          }
+
+          <mat-form-field appearance="outline" class="surface-span-2">
+            <mat-label>{{ t('editor.component.bindingOrder', 'bindingOrder (CSV)') }}</mat-label>
+            <input
+              matInput
+              [ngModel]="bindingOrderText"
+              (ngModelChange)="updateBindingOrder($event)"
+              [ngModelOptions]="{ standalone: true }"
+              [placeholder]="t('editor.component.bindingOrderPlaceholder', 'resourcePath, formId, resourceId')"
+            />
+          </mat-form-field>
+        </div>
+      </div>
+
+      <div class="surface-section">
+        <div class="surface-section-title">{{ t('editor.inputs.title', 'Inputs') }}</div>
+        @if (selectedInputs.length) {
+          <div class="surface-grid">
+            @for (input of selectedInputs; track input.name) {
+              @if (isBooleanType(input.type)) {
+                <mat-slide-toggle
+                  [ngModel]="getBooleanInputValue(input.name)"
+                  (ngModelChange)="updateBooleanInput(input.name, $event)"
+                  [ngModelOptions]="{ standalone: true }"
+                >
+                  {{ input.label || input.name }}
+                </mat-slide-toggle>
+              } @else if (isJsonType(input.type)) {
+                <mat-form-field appearance="outline" class="surface-span-2">
+                  <mat-label>{{ input.label || input.name }}</mat-label>
+                  <textarea
+                    matInput
+                    rows="4"
+                    [ngModel]="getJsonInputDraft(input.name)"
+                    (ngModelChange)="updateJsonInput(input.name, $event)"
+                    [ngModelOptions]="{ standalone: true }"
+                    [placeholder]="jsonPlaceholder(input)"
+                  ></textarea>
+                  @if (input.description) {
+                    <mat-hint>{{ input.description }}</mat-hint>
+                  }
+                  @if (inputErrors[input.name]) {
+                    <mat-error>{{ inputErrors[input.name] }}</mat-error>
+                  }
+                </mat-form-field>
+              } @else {
+                <mat-form-field appearance="outline">
+                  <mat-label>{{ input.label || input.name }}</mat-label>
+                  <input
+                    matInput
+                    [type]="isNumberType(input.type) ? 'number' : 'text'"
+                    [ngModel]="getScalarInputValue(input.name)"
+                    (ngModelChange)="updateScalarInput(input.name, input.type, $event)"
+                    [ngModelOptions]="{ standalone: true }"
+                    [placeholder]="scalarPlaceholder(input)"
+                  />
+                  @if (input.description) {
+                    <mat-hint>{{ input.description }}</mat-hint>
+                  }
+                </mat-form-field>
+              }
+            }
+          </div>
+        } @else {
+          <div class="surface-empty">
+            {{ t('editor.inputs.empty', 'Selecione um componente registrado para configurar inputs públicos.') }}
+          </div>
+        }
+      </div>
+
+      <div class="surface-section">
+        <div class="surface-section-header">
+          <div class="surface-section-title">{{ t('editor.bindings.title', 'Bindings') }}</div>
+          <button mat-stroked-button type="button" (click)="addBinding()">
+            <mat-icon>add</mat-icon>
+            {{ t('editor.bindings.add', 'Binding') }}
+          </button>
+        </div>
+        @if (draft.bindings?.length) {
+          <div class="surface-bindings">
+            @for (binding of draft.bindings || []; track $index) {
+              <div class="surface-binding-row">
+                <mat-form-field appearance="outline">
+                  <mat-label>{{ t('editor.bindings.source', 'Origem') }}</mat-label>
+                  <input
+                    matInput
+                    [ngModel]="binding.from || ''"
+                    (ngModelChange)="updateBinding($index, 'from', $event)"
+                    [ngModelOptions]="{ standalone: true }"
+                    [attr.list]="sourceSuggestionsListId"
+                    placeholder="payload.row.id"
+                  />
+                </mat-form-field>
+
+                <mat-form-field appearance="outline">
+                  <mat-label>{{ t('editor.bindings.target', 'Destino') }}</mat-label>
+                  <input
+                    matInput
+                    [ngModel]="binding.to"
+                    (ngModelChange)="updateBinding($index, 'to', $event)"
+                    [ngModelOptions]="{ standalone: true }"
+                    [attr.list]="targetSuggestionsListId"
+                    placeholder="widget.inputs.resourceId"
+                  />
+                </mat-form-field>
+
+                <mat-form-field appearance="outline">
+                  <mat-label>{{ t('editor.bindings.mode', 'Modo') }}</mat-label>
+                  <mat-select
+                    [ngModel]="binding.mode || 'path'"
+                    (ngModelChange)="updateBinding($index, 'mode', $event)"
+                    [ngModelOptions]="{ standalone: true }"
+                  >
+                    <mat-option value="path">path</mat-option>
+                    <mat-option value="template">template</mat-option>
+                    <mat-option value="constant">constant</mat-option>
+                  </mat-select>
+                </mat-form-field>
+
+                @if ((binding.mode || 'path') === 'constant') {
+                  <mat-form-field appearance="outline">
+                    <mat-label>{{ t('editor.bindings.constantValue', 'Valor constante') }}</mat-label>
+                    <input
+                      matInput
+                      [ngModel]="binding.value ?? ''"
+                      (ngModelChange)="updateBinding($index, 'value', $event)"
+                      [ngModelOptions]="{ standalone: true }"
+                    />
+                  </mat-form-field>
+                }
+
+                <button
+                  mat-icon-button
+                  color="warn"
+                  type="button"
+                  (click)="removeBinding($index)"
+                  [attr.aria-label]="t('editor.bindings.remove', 'Remover binding')"
+                >
+                  <mat-icon>delete</mat-icon>
+                </button>
+              </div>
+            }
+          </div>
+        } @else {
+          <div class="surface-empty">
+            {{ t('editor.bindings.empty', 'Nenhum binding configurado ainda.') }}
+          </div>
+        }
+        <div class="surface-empty">
+          @if (bindingSourceSuggestionsPreview) {
+            <div>
+              {{ t('editor.bindings.suggestedSources', 'Origens sugeridas: {{value}}', { value: bindingSourceSuggestionsPreview }) }}
+            </div>
+          }
+          @if (bindingTargetSuggestionsPreview) {
+            <div>
+              {{ t('editor.bindings.suggestedTargets', 'Destinos sugeridos: {{value}}', { value: bindingTargetSuggestionsPreview }) }}
+            </div>
+          }
+        </div>
+        <datalist [id]="sourceSuggestionsListId">
+          @for (suggestion of bindingSourceSuggestions; track suggestion) {
+            <option [value]="suggestion"></option>
+          }
+        </datalist>
+        <datalist [id]="targetSuggestionsListId">
+          @for (suggestion of bindingTargetSuggestions; track suggestion) {
+            <option [value]="suggestion"></option>
+          }
+        </datalist>
+      </div>
+
+      <div class="surface-section">
+        <div class="surface-section-title">{{ t('editor.context.title', 'Contexto extra') }}</div>
+        <mat-form-field appearance="outline" class="surface-span-all">
+          <mat-label>{{ t('editor.context.label', 'context (JSON)') }}</mat-label>
+          <textarea
+            matInput
+            rows="4"
+            [ngModel]="contextDraft"
+            (ngModelChange)="updateContext($event)"
+            [ngModelOptions]="{ standalone: true }"
+            placeholder="{ }"
+          ></textarea>
+          <mat-hint>{{ t('editor.context.hint', 'Opcional. Mesclado ao contexto da action no runtime.') }}</mat-hint>
+          @if (contextError) {
+            <mat-error>{{ contextError }}</mat-error>
+          }
+        </mat-form-field>
+      </div>
+    </div>
+  `, isInline: true, styles: [".surface-editor{display:grid;gap:16px}.surface-section{padding:12px 14px;border:1px dashed var(--md-sys-color-outline-variant, rgba(0, 0, 0, .18));border-radius:10px;background:var(--md-sys-color-surface-container-lowest, #fff)}.surface-section-header{display:flex;align-items:center;justify-content:space-between;gap:12px;margin-bottom:10px}.surface-section-title{font-size:12px;font-weight:600;letter-spacing:.02em;text-transform:uppercase;color:var(--md-sys-color-on-surface-variant, #5f6368);margin-bottom:10px}.surface-section-header .surface-section-title{margin-bottom:0}.surface-grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(220px,1fr));gap:12px 16px}.surface-preset-row{display:flex;flex-wrap:wrap;gap:8px;margin-bottom:8px}.surface-span-2{grid-column:span 2}.surface-span-all{width:100%}.surface-component-meta{display:grid;gap:4px}.surface-component-title{font-weight:600}.surface-component-description,.surface-empty{color:var(--md-sys-color-on-surface-variant, #5f6368);font-size:12px}.surface-bindings{display:grid;gap:12px}.surface-binding-row{display:grid;grid-template-columns:minmax(200px,1.2fr) minmax(220px,1.4fr) minmax(140px,.8fr) minmax(180px,1fr) auto;gap:12px;align-items:start}mat-form-field{width:100%}@media(max-width:960px){.surface-binding-row{grid-template-columns:minmax(0,1fr)}}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i1$1.NgSelectOption, selector: "option", inputs: ["ngValue", "value"] }, { kind: "directive", type: i1$1.ɵNgSelectMultipleOption, selector: "option", inputs: ["ngValue", "value"] }, { kind: "directive", type: i1$1.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i1$1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1$1.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i2.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: "component", type: i2.MatIconButton, selector: "button[mat-icon-button], a[mat-icon-button], button[matIconButton], a[matIconButton]", exportAs: ["matButton", "matAnchor"] }, { kind: "ngmodule", type: MatFormFieldModule }, { kind: "component", type: i3.MatFormField, selector: "mat-form-field", inputs: ["hideRequiredMarker", "color", "floatLabel", "appearance", "subscriptSizing", "hintLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i3.MatLabel, selector: "mat-label" }, { kind: "directive", type: i3.MatHint, selector: "mat-hint", inputs: ["align", "id"] }, { kind: "directive", type: i3.MatError, selector: "mat-error, [matError]", inputs: ["id"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i4.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "ngmodule", type: MatInputModule }, { kind: "directive", type: i5.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly", "disabledInteractive"], exportAs: ["matInput"] }, { kind: "ngmodule", type: MatSelectModule }, { kind: "component", type: i6.MatSelect, selector: "mat-select", inputs: ["aria-describedby", "panelClass", "disabled", "disableRipple", "tabIndex", "hideSingleSelectionIndicator", "placeholder", "required", "multiple", "disableOptionCentering", "compareWith", "value", "aria-label", "aria-labelledby", "errorStateMatcher", "typeaheadDebounceInterval", "sortComparator", "id", "panelWidth", "canSelectNullableOptions"], outputs: ["openedChange", "opened", "closed", "selectionChange", "valueChange"], exportAs: ["matSelect"] }, { kind: "component", type: i6.MatOption, selector: "mat-option", inputs: ["value", "id", "disabled"], outputs: ["onSelectionChange"], exportAs: ["matOption"] }, { kind: "ngmodule", type: MatSlideToggleModule }, { kind: "component", type: i7.MatSlideToggle, selector: "mat-slide-toggle", inputs: ["name", "id", "labelPosition", "aria-label", "aria-labelledby", "aria-describedby", "required", "color", "disabled", "disableRipple", "tabIndex", "checked", "hideIcon", "disabledInteractive"], outputs: ["change", "toggleChange"], exportAs: ["matSlideToggle"] }, { kind: "ngmodule", type: MatTooltipModule }, { kind: "directive", type: i5$1.MatTooltip, selector: "[matTooltip]", inputs: ["matTooltipPosition", "matTooltipPositionAtOrigin", "matTooltipDisabled", "matTooltipShowDelay", "matTooltipHideDelay", "matTooltipTouchGestures", "matTooltip", "matTooltipClass"], exportAs: ["matTooltip"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: SurfaceOpenActionEditorComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'praxis-surface-open-action-editor', standalone: true, providers: [providePraxisI18nConfig(SURFACE_OPEN_I18N_CONFIG)], imports: [
+                        CommonModule,
+                        FormsModule,
+                        MatButtonModule,
+                        MatFormFieldModule,
+                        MatIconModule,
+                        MatInputModule,
+                        MatSelectModule,
+                        MatSlideToggleModule,
+                        MatTooltipModule,
+                    ], template: `
+    <div class="surface-editor">
+      <div class="surface-section">
+        <div class="surface-section-title">{{ t('editor.presets.title', 'Presets') }}</div>
+        <div class="surface-preset-row">
+          @for (preset of availablePresets; track preset.id) {
+            <button
+              mat-stroked-button
+              type="button"
+              (click)="applyPreset(preset)"
+              [matTooltip]="presetDescription(preset)"
+            >
+              {{ presetLabel(preset) }}
+            </button>
+          }
+        </div>
+        <div class="surface-empty">
+          {{
+            t(
+              'editor.presets.help',
+              'Aplique um preset para começar com inputs mínimos e depois configure bindings conforme a origem da action.'
+            )
+          }}
+        </div>
+      </div>
+
+      <div class="surface-section">
+        <div class="surface-section-title">{{ t('editor.surface.title', 'Surface') }}</div>
+        <div class="surface-grid">
+          <mat-form-field appearance="outline">
+            <mat-label>{{ t('editor.surface.presentation', 'Apresentação') }}</mat-label>
+            <mat-select
+              [ngModel]="draft.presentation"
+              (ngModelChange)="updatePresentation($event)"
+              [ngModelOptions]="{ standalone: true }"
+            >
+              <mat-option value="modal">{{ t('editor.surface.presentation.modal', 'Modal') }}</mat-option>
+              <mat-option value="drawer">{{ t('editor.surface.presentation.drawer', 'Drawer') }}</mat-option>
+            </mat-select>
+          </mat-form-field>
+
+          <mat-form-field appearance="outline">
+            <mat-label>{{ t('editor.surface.titleLabel', 'Título') }}</mat-label>
+            <input
+              matInput
+              [ngModel]="draft.title || ''"
+              (ngModelChange)="updateTextField('title', $event)"
+              [ngModelOptions]="{ standalone: true }"
+            />
+          </mat-form-field>
+
+          <mat-form-field appearance="outline">
+            <mat-label>{{ t('editor.surface.subtitleLabel', 'Subtítulo') }}</mat-label>
+            <input
+              matInput
+              [ngModel]="draft.subtitle || ''"
+              (ngModelChange)="updateTextField('subtitle', $event)"
+              [ngModelOptions]="{ standalone: true }"
+            />
+          </mat-form-field>
+
+          <mat-form-field appearance="outline">
+            <mat-label>{{ t('editor.surface.iconLabel', 'Ícone') }}</mat-label>
+            <input
+              matInput
+              [ngModel]="draft.icon || ''"
+              (ngModelChange)="updateTextField('icon', $event)"
+              [ngModelOptions]="{ standalone: true }"
+              placeholder="open_in_new"
+            />
+          </mat-form-field>
+
+          <mat-form-field appearance="outline">
+            <mat-label>{{ t('editor.surface.widthLabel', 'Largura') }}</mat-label>
+            <input
+              matInput
+              [ngModel]="draft.size?.width || ''"
+              (ngModelChange)="updateSizeField('width', $event)"
+              [ngModelOptions]="{ standalone: true }"
+              placeholder="720px"
+            />
+          </mat-form-field>
+
+          <mat-form-field appearance="outline">
+            <mat-label>{{ t('editor.surface.heightLabel', 'Altura') }}</mat-label>
+            <input
+              matInput
+              [ngModel]="draft.size?.height || ''"
+              (ngModelChange)="updateSizeField('height', $event)"
+              [ngModelOptions]="{ standalone: true }"
+              placeholder="80vh"
+            />
+          </mat-form-field>
+
+          <mat-form-field appearance="outline">
+            <mat-label>{{ t('editor.surface.minWidthLabel', 'Largura mínima') }}</mat-label>
+            <input
+              matInput
+              [ngModel]="draft.size?.minWidth || ''"
+              (ngModelChange)="updateSizeField('minWidth', $event)"
+              [ngModelOptions]="{ standalone: true }"
+              placeholder="360px"
+            />
+          </mat-form-field>
+
+          <mat-form-field appearance="outline">
+            <mat-label>{{ t('editor.surface.maxWidthLabel', 'Largura máxima') }}</mat-label>
+            <input
+              matInput
+              [ngModel]="draft.size?.maxWidth || ''"
+              (ngModelChange)="updateSizeField('maxWidth', $event)"
+              [ngModelOptions]="{ standalone: true }"
+              placeholder="90vw"
+            />
+          </mat-form-field>
+        </div>
+      </div>
+
+      <div class="surface-section">
+        <div class="surface-section-title">{{ t('editor.component.title', 'Componente') }}</div>
+        <div class="surface-grid">
+          <mat-form-field appearance="outline" class="surface-span-2">
+            <mat-label>{{ t('editor.component.select', 'Componente registrado') }}</mat-label>
+            <mat-select
+              [ngModel]="draft.widget.id"
+              (ngModelChange)="updateWidgetId($event)"
+              [ngModelOptions]="{ standalone: true }"
+            >
+              <mat-option value="">{{ t('editor.component.selectPlaceholder', '-- Selecionar --') }}</mat-option>
+              @for (option of componentOptions; track option.id) {
+                <mat-option [value]="option.id">
+                  {{ option.friendlyName || option.id }}
+                </mat-option>
+              }
+            </mat-select>
+          </mat-form-field>
+
+          @if (selectedComponentMeta) {
+            <div class="surface-component-meta surface-span-2">
+              <div class="surface-component-title">
+                {{ selectedComponentMeta.friendlyName || selectedComponentMeta.id }}
+              </div>
+              @if (selectedComponentMeta.description) {
+                <div class="surface-component-description">
+                  {{ selectedComponentMeta.description }}
+                </div>
+              }
+            </div>
+          }
+
+          <mat-form-field appearance="outline" class="surface-span-2">
+            <mat-label>{{ t('editor.component.bindingOrder', 'bindingOrder (CSV)') }}</mat-label>
+            <input
+              matInput
+              [ngModel]="bindingOrderText"
+              (ngModelChange)="updateBindingOrder($event)"
+              [ngModelOptions]="{ standalone: true }"
+              [placeholder]="t('editor.component.bindingOrderPlaceholder', 'resourcePath, formId, resourceId')"
+            />
+          </mat-form-field>
+        </div>
+      </div>
+
+      <div class="surface-section">
+        <div class="surface-section-title">{{ t('editor.inputs.title', 'Inputs') }}</div>
+        @if (selectedInputs.length) {
+          <div class="surface-grid">
+            @for (input of selectedInputs; track input.name) {
+              @if (isBooleanType(input.type)) {
+                <mat-slide-toggle
+                  [ngModel]="getBooleanInputValue(input.name)"
+                  (ngModelChange)="updateBooleanInput(input.name, $event)"
+                  [ngModelOptions]="{ standalone: true }"
+                >
+                  {{ input.label || input.name }}
+                </mat-slide-toggle>
+              } @else if (isJsonType(input.type)) {
+                <mat-form-field appearance="outline" class="surface-span-2">
+                  <mat-label>{{ input.label || input.name }}</mat-label>
+                  <textarea
+                    matInput
+                    rows="4"
+                    [ngModel]="getJsonInputDraft(input.name)"
+                    (ngModelChange)="updateJsonInput(input.name, $event)"
+                    [ngModelOptions]="{ standalone: true }"
+                    [placeholder]="jsonPlaceholder(input)"
+                  ></textarea>
+                  @if (input.description) {
+                    <mat-hint>{{ input.description }}</mat-hint>
+                  }
+                  @if (inputErrors[input.name]) {
+                    <mat-error>{{ inputErrors[input.name] }}</mat-error>
+                  }
+                </mat-form-field>
+              } @else {
+                <mat-form-field appearance="outline">
+                  <mat-label>{{ input.label || input.name }}</mat-label>
+                  <input
+                    matInput
+                    [type]="isNumberType(input.type) ? 'number' : 'text'"
+                    [ngModel]="getScalarInputValue(input.name)"
+                    (ngModelChange)="updateScalarInput(input.name, input.type, $event)"
+                    [ngModelOptions]="{ standalone: true }"
+                    [placeholder]="scalarPlaceholder(input)"
+                  />
+                  @if (input.description) {
+                    <mat-hint>{{ input.description }}</mat-hint>
+                  }
+                </mat-form-field>
+              }
+            }
+          </div>
+        } @else {
+          <div class="surface-empty">
+            {{ t('editor.inputs.empty', 'Selecione um componente registrado para configurar inputs públicos.') }}
+          </div>
+        }
+      </div>
+
+      <div class="surface-section">
+        <div class="surface-section-header">
+          <div class="surface-section-title">{{ t('editor.bindings.title', 'Bindings') }}</div>
+          <button mat-stroked-button type="button" (click)="addBinding()">
+            <mat-icon>add</mat-icon>
+            {{ t('editor.bindings.add', 'Binding') }}
+          </button>
+        </div>
+        @if (draft.bindings?.length) {
+          <div class="surface-bindings">
+            @for (binding of draft.bindings || []; track $index) {
+              <div class="surface-binding-row">
+                <mat-form-field appearance="outline">
+                  <mat-label>{{ t('editor.bindings.source', 'Origem') }}</mat-label>
+                  <input
+                    matInput
+                    [ngModel]="binding.from || ''"
+                    (ngModelChange)="updateBinding($index, 'from', $event)"
+                    [ngModelOptions]="{ standalone: true }"
+                    [attr.list]="sourceSuggestionsListId"
+                    placeholder="payload.row.id"
+                  />
+                </mat-form-field>
+
+                <mat-form-field appearance="outline">
+                  <mat-label>{{ t('editor.bindings.target', 'Destino') }}</mat-label>
+                  <input
+                    matInput
+                    [ngModel]="binding.to"
+                    (ngModelChange)="updateBinding($index, 'to', $event)"
+                    [ngModelOptions]="{ standalone: true }"
+                    [attr.list]="targetSuggestionsListId"
+                    placeholder="widget.inputs.resourceId"
+                  />
+                </mat-form-field>
+
+                <mat-form-field appearance="outline">
+                  <mat-label>{{ t('editor.bindings.mode', 'Modo') }}</mat-label>
+                  <mat-select
+                    [ngModel]="binding.mode || 'path'"
+                    (ngModelChange)="updateBinding($index, 'mode', $event)"
+                    [ngModelOptions]="{ standalone: true }"
+                  >
+                    <mat-option value="path">path</mat-option>
+                    <mat-option value="template">template</mat-option>
+                    <mat-option value="constant">constant</mat-option>
+                  </mat-select>
+                </mat-form-field>
+
+                @if ((binding.mode || 'path') === 'constant') {
+                  <mat-form-field appearance="outline">
+                    <mat-label>{{ t('editor.bindings.constantValue', 'Valor constante') }}</mat-label>
+                    <input
+                      matInput
+                      [ngModel]="binding.value ?? ''"
+                      (ngModelChange)="updateBinding($index, 'value', $event)"
+                      [ngModelOptions]="{ standalone: true }"
+                    />
+                  </mat-form-field>
+                }
+
+                <button
+                  mat-icon-button
+                  color="warn"
+                  type="button"
+                  (click)="removeBinding($index)"
+                  [attr.aria-label]="t('editor.bindings.remove', 'Remover binding')"
+                >
+                  <mat-icon>delete</mat-icon>
+                </button>
+              </div>
+            }
+          </div>
+        } @else {
+          <div class="surface-empty">
+            {{ t('editor.bindings.empty', 'Nenhum binding configurado ainda.') }}
+          </div>
+        }
+        <div class="surface-empty">
+          @if (bindingSourceSuggestionsPreview) {
+            <div>
+              {{ t('editor.bindings.suggestedSources', 'Origens sugeridas: {{value}}', { value: bindingSourceSuggestionsPreview }) }}
+            </div>
+          }
+          @if (bindingTargetSuggestionsPreview) {
+            <div>
+              {{ t('editor.bindings.suggestedTargets', 'Destinos sugeridos: {{value}}', { value: bindingTargetSuggestionsPreview }) }}
+            </div>
+          }
+        </div>
+        <datalist [id]="sourceSuggestionsListId">
+          @for (suggestion of bindingSourceSuggestions; track suggestion) {
+            <option [value]="suggestion"></option>
+          }
+        </datalist>
+        <datalist [id]="targetSuggestionsListId">
+          @for (suggestion of bindingTargetSuggestions; track suggestion) {
+            <option [value]="suggestion"></option>
+          }
+        </datalist>
+      </div>
+
+      <div class="surface-section">
+        <div class="surface-section-title">{{ t('editor.context.title', 'Contexto extra') }}</div>
+        <mat-form-field appearance="outline" class="surface-span-all">
+          <mat-label>{{ t('editor.context.label', 'context (JSON)') }}</mat-label>
+          <textarea
+            matInput
+            rows="4"
+            [ngModel]="contextDraft"
+            (ngModelChange)="updateContext($event)"
+            [ngModelOptions]="{ standalone: true }"
+            placeholder="{ }"
+          ></textarea>
+          <mat-hint>{{ t('editor.context.hint', 'Opcional. Mesclado ao contexto da action no runtime.') }}</mat-hint>
+          @if (contextError) {
+            <mat-error>{{ contextError }}</mat-error>
+          }
+        </mat-form-field>
+      </div>
+    </div>
+  `, styles: [".surface-editor{display:grid;gap:16px}.surface-section{padding:12px 14px;border:1px dashed var(--md-sys-color-outline-variant, rgba(0, 0, 0, .18));border-radius:10px;background:var(--md-sys-color-surface-container-lowest, #fff)}.surface-section-header{display:flex;align-items:center;justify-content:space-between;gap:12px;margin-bottom:10px}.surface-section-title{font-size:12px;font-weight:600;letter-spacing:.02em;text-transform:uppercase;color:var(--md-sys-color-on-surface-variant, #5f6368);margin-bottom:10px}.surface-section-header .surface-section-title{margin-bottom:0}.surface-grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(220px,1fr));gap:12px 16px}.surface-preset-row{display:flex;flex-wrap:wrap;gap:8px;margin-bottom:8px}.surface-span-2{grid-column:span 2}.surface-span-all{width:100%}.surface-component-meta{display:grid;gap:4px}.surface-component-title{font-weight:600}.surface-component-description,.surface-empty{color:var(--md-sys-color-on-surface-variant, #5f6368);font-size:12px}.surface-bindings{display:grid;gap:12px}.surface-binding-row{display:grid;grid-template-columns:minmax(200px,1.2fr) minmax(220px,1.4fr) minmax(140px,.8fr) minmax(180px,1fr) auto;gap:12px;align-items:start}mat-form-field{width:100%}@media(max-width:960px){.surface-binding-row{grid-template-columns:minmax(0,1fr)}}\n"] }]
+        }], propDecorators: { value: [{
+                type: Input
+            }], hostKind: [{
+                type: Input
+            }], valueChange: [{
+                type: Output
+            }] } });
+
+/**
+ * Catálogo de capacidades genéricas de FieldMetadata para uso da IA.
+ * Baseado em projects/praxis-core/src/lib/models/component-metadata.interface.ts
+ */
+const ENUMS$1 = {
+    fieldControlType: Object.values(FieldControlType),
+    fieldDataType: Object.values(FieldDataType),
+    componentContext: ['form', 'filter', 'table', 'dialog', 'standalone'],
+    iconPosition: ['start', 'end'],
+    iconSize: ['small', 'medium', 'large'],
+    validationMode: ['immediate', 'blur', 'submit'],
+    validatorTrigger: ['change', 'blur', 'submit', 'immediate'],
+    validatorErrorPosition: ['bottom', 'top', 'tooltip'],
+    dependencyMergeStrategy: ['replace', 'merge'],
+    dependencyLoadOnChange: ['respectLoadOn', 'immediate', 'manual'],
+    textTransformApply: ['displayOnly', 'saveOnly', 'both'],
+    visibleIn: ['form', 'filter', 'table', 'dialog'],
+    appearance: ['fill', 'outline'],
+    color: ['primary', 'accent', 'warn'],
+    floatLabel: ['auto', 'always', 'never'],
+    hintPosition: ['start', 'end'],
+    align: ['start', 'center', 'end', 'stretch'],
+    sectionTitleStyle: ['titleLarge', 'titleMedium', 'titleSmall', 'headlineSmall'],
+    sectionDescriptionStyle: ['bodyLarge', 'bodyMedium', 'bodySmall'],
+};
+const FIELD_METADATA_CAPABILITIES = {
+    version: 'v1.3',
+    enums: ENUMS$1,
+    notes: [
+        'Este catálogo define as capacidades genéricas de FieldMetadata.',
+        'O host típico para estes metadados é FormConfig (via fieldMetadata[]) ou FormLayout.',
+        'Detalhes específicos de cada controle (ex: opções de datepicker, máscaras específicas) devem ser consultados nos catálogos de microcomponentes.',
+        'POLICY: Arrays e objetos (ex: options, validators) devem sofrer merge/append, nunca substituição completa sem confirmação.',
+        'Funções (conditionalRequired, transforms) não são serializáveis. O LLM não deve gerar código de função, apenas expressões string se suportado pelo interpretador, ou solicitar configuração manual.',
+    ],
     capabilities: [
         // =============================================================================
         // COMPONENT METADATA (BASE)
@@ -13547,7 +15490,7 @@ class PraxisFooterLinksComponent {
         </a>
       </nav>
     </footer>
-  `, isInline: true, styles: [":host{display:block;--pfl-border: color-mix(in srgb, var(--md-sys-color-outline-variant) 78%, transparent);--pfl-brand-color: var(--md-sys-color-on-surface);--pfl-secondary-color: var(--md-sys-color-on-surface-variant);--pfl-link-color: var(--md-sys-color-primary);--pfl-surface-bg: color-mix(in srgb, var(--md-sys-color-surface-container-low) 92%, transparent)}:host-context(.mdc-theme-dark),:host-context(.theme-dark){--pfl-border: color-mix(in srgb, var(--md-sys-color-outline-variant) 90%, transparent);--pfl-link-color: color-mix(in srgb, var(--md-sys-color-primary) 86%, white);--pfl-surface-bg: color-mix(in srgb, var(--md-sys-color-surface-container-low) 96%, transparent)}.pfl-shell{display:flex;align-items:center;justify-content:space-between;gap:16px 24px;padding:16px 4px 4px;border-top:1px solid var(--pfl-border)}.pfl-stacked{flex-direction:column;align-items:flex-start}.pfl-plain{padding-top:6px;border-top:0}.pfl-surface{padding:16px 18px;border-top:0;border-radius:18px;background:var(--pfl-surface-bg)}.pfl-brand{display:grid;gap:4px}.pfl-brand-text{color:var(--pfl-brand-color);font-size:.92rem;font-weight:700}.pfl-secondary-text{color:var(--pfl-secondary-color);font-size:.8rem;line-height:1.5}.pfl-nav{display:flex;flex-wrap:wrap;gap:10px 16px}.pfl-link{color:var(--pfl-link-color);font-size:.84rem;line-height:1.5;text-decoration:underline;text-underline-offset:2px}@media(max-width:720px){.pfl-shell{flex-direction:column;align-items:flex-start}}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1$1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1$1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+  `, isInline: true, styles: [":host{display:block;--pfl-border: color-mix(in srgb, var(--md-sys-color-outline-variant) 78%, transparent);--pfl-brand-color: var(--md-sys-color-on-surface);--pfl-secondary-color: var(--md-sys-color-on-surface-variant);--pfl-link-color: var(--md-sys-color-primary);--pfl-surface-bg: color-mix(in srgb, var(--md-sys-color-surface-container-low) 92%, transparent)}:host-context(.mdc-theme-dark),:host-context(.theme-dark){--pfl-border: color-mix(in srgb, var(--md-sys-color-outline-variant) 90%, transparent);--pfl-link-color: color-mix(in srgb, var(--md-sys-color-primary) 86%, white);--pfl-surface-bg: color-mix(in srgb, var(--md-sys-color-surface-container-low) 96%, transparent)}.pfl-shell{display:flex;align-items:center;justify-content:space-between;gap:16px 24px;padding:16px 4px 4px;border-top:1px solid var(--pfl-border)}.pfl-stacked{flex-direction:column;align-items:flex-start}.pfl-plain{padding-top:6px;border-top:0}.pfl-surface{padding:16px 18px;border-top:0;border-radius:18px;background:var(--pfl-surface-bg)}.pfl-brand{display:grid;gap:4px}.pfl-brand-text{color:var(--pfl-brand-color);font-size:.92rem;font-weight:700}.pfl-secondary-text{color:var(--pfl-secondary-color);font-size:.8rem;line-height:1.5}.pfl-nav{display:flex;flex-wrap:wrap;gap:10px 16px}.pfl-link{color:var(--pfl-link-color);font-size:.84rem;line-height:1.5;text-decoration:underline;text-underline-offset:2px}@media(max-width:720px){.pfl-shell{flex-direction:column;align-items:flex-start}}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1$2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1$2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: PraxisFooterLinksComponent, decorators: [{
             type: Component,
@@ -13699,7 +15642,7 @@ class PraxisHeroBannerComponent {
         </div>
       </ng-template>
     </section>
-  `, isInline: true, styles: [":host{display:block;--phb-shell-border: color-mix(in srgb, var(--md-sys-color-outline-variant) 60%, transparent);--phb-shell-shadow: 0 24px 60px color-mix(in srgb, var(--md-sys-color-shadow, #000) 10%, transparent);--phb-shell-bg: radial-gradient(circle at top right, color-mix(in srgb, var(--md-sys-color-primary) 14%, transparent), transparent 38%), linear-gradient( 135deg, color-mix(in srgb, var(--md-sys-color-surface-container-lowest) 92%, var(--md-sys-color-primary-container) 8%) 0%, color-mix(in srgb, var(--md-sys-color-surface-container-low) 88%, var(--md-sys-color-primary-container) 12%) 54%, color-mix(in srgb, var(--md-sys-color-surface) 96%, var(--md-sys-color-surface-container) 4%) 100% );--phb-event-bg: radial-gradient(circle at top right, rgba(255, 184, 77, .24), transparent 34%), linear-gradient( 135deg, color-mix(in srgb, var(--md-sys-color-primary-container) 16%, var(--md-sys-color-surface-container-lowest) 84%) 0%, color-mix(in srgb, var(--md-sys-color-primary-container) 24%, var(--md-sys-color-surface-container-low) 76%) 45%, color-mix(in srgb, var(--md-sys-color-surface) 92%, var(--md-sys-color-primary-container) 8%) 100% );--phb-institutional-bg: radial-gradient(circle at top right, rgba(17, 94, 89, .2), transparent 34%), linear-gradient( 135deg, color-mix(in srgb, var(--md-sys-color-secondary-container) 18%, var(--md-sys-color-surface-container-lowest) 82%) 0%, color-mix(in srgb, var(--md-sys-color-secondary-container) 24%, var(--md-sys-color-surface-container-low) 76%) 48%, color-mix(in srgb, var(--md-sys-color-surface) 94%, var(--md-sys-color-secondary-container) 6%) 100% );--phb-brand-color: color-mix(in srgb, var(--md-sys-color-primary) 68%, var(--md-sys-color-on-surface) 32%);--phb-subtitle-color: color-mix(in srgb, var(--md-sys-color-primary) 52%, var(--md-sys-color-on-surface) 48%);--phb-title-color: var(--md-sys-color-on-surface);--phb-description-color: var(--md-sys-color-on-surface-variant);--phb-badge-bg: color-mix(in srgb, var(--md-sys-color-surface-container-high) 78%, transparent);--phb-badge-color: var(--md-sys-color-on-surface);--phb-badge-highlight-bg: color-mix(in srgb, var(--md-sys-color-primary-container) 78%, transparent);--phb-badge-highlight-color: var(--md-sys-color-on-primary-container);--phb-badge-muted-bg: color-mix(in srgb, var(--md-sys-color-surface-container-highest) 82%, transparent);--phb-badge-muted-color: var(--md-sys-color-on-surface-variant);--phb-badge-warning-bg: color-mix(in srgb, var(--md-sys-color-error-container) 74%, transparent);--phb-badge-warning-color: var(--md-sys-color-on-error-container);--phb-meta-bg: color-mix(in srgb, var(--md-sys-color-surface-container-lowest) 72%, transparent);--phb-meta-border: color-mix(in srgb, var(--md-sys-color-outline-variant) 48%, transparent);--phb-meta-label-color: var(--md-sys-color-on-surface-variant);--phb-meta-value-color: var(--md-sys-color-on-surface);--phb-visual-bg: linear-gradient( 160deg, color-mix(in srgb, var(--md-sys-color-surface-container-high) 90%, var(--md-sys-color-primary) 10%), color-mix(in srgb, var(--md-sys-color-surface-container-low) 88%, var(--md-sys-color-primary-container) 12%) );--phb-visual-fallback: linear-gradient( 180deg, color-mix(in srgb, var(--md-sys-color-surface-bright, var(--md-sys-color-surface-container-high)) 24%, transparent), color-mix(in srgb, var(--md-sys-color-surface-container-lowest) 8%, transparent) ), linear-gradient( 145deg, color-mix(in srgb, var(--md-sys-color-primary) 18%, var(--md-sys-color-surface-container-high) 82%), color-mix(in srgb, var(--md-sys-color-primary-container) 18%, var(--md-sys-color-surface-container-low) 82%) );--phb-orb-a-bg: color-mix(in srgb, var(--md-sys-color-surface-bright, var(--md-sys-color-surface-container-high)) 68%, transparent);--phb-orb-b-bg: color-mix(in srgb, var(--md-sys-color-primary) 22%, transparent);--phb-grid-line: color-mix(in srgb, var(--md-sys-color-on-surface) 12%, transparent)}:host-context(.mdc-theme-dark),:host-context(.theme-dark){--phb-shell-border: color-mix(in srgb, var(--md-sys-color-outline-variant) 84%, transparent);--phb-shell-shadow: 0 22px 54px rgba(0, 0, 0, .28);--phb-shell-bg: radial-gradient(circle at top right, color-mix(in srgb, var(--md-sys-color-primary) 16%, transparent), transparent 40%), linear-gradient( 135deg, color-mix(in srgb, var(--md-sys-color-surface-container-lowest) 90%, var(--md-sys-color-primary-container) 10%) 0%, color-mix(in srgb, var(--md-sys-color-surface-container-low) 84%, var(--md-sys-color-primary-container) 16%) 54%, color-mix(in srgb, var(--md-sys-color-surface) 92%, var(--md-sys-color-primary-container) 8%) 100% );--phb-event-bg: radial-gradient(circle at top right, rgba(255, 184, 77, .18), transparent 36%), linear-gradient( 135deg, color-mix(in srgb, var(--md-sys-color-primary-container) 16%, var(--md-sys-color-surface-container-lowest) 84%) 0%, color-mix(in srgb, var(--md-sys-color-primary-container) 22%, var(--md-sys-color-surface-container-low) 78%) 45%, color-mix(in srgb, var(--md-sys-color-surface-container) 90%, var(--md-sys-color-primary-container) 10%) 100% );--phb-institutional-bg: radial-gradient(circle at top right, rgba(17, 94, 89, .16), transparent 36%), linear-gradient( 135deg, color-mix(in srgb, var(--md-sys-color-secondary-container) 16%, var(--md-sys-color-surface-container-lowest) 84%) 0%, color-mix(in srgb, var(--md-sys-color-secondary-container) 20%, var(--md-sys-color-surface-container-low) 80%) 48%, color-mix(in srgb, var(--md-sys-color-surface-container) 92%, var(--md-sys-color-secondary-container) 8%) 100% );--phb-meta-bg: color-mix(in srgb, var(--md-sys-color-surface-container-lowest) 70%, transparent);--phb-meta-border: color-mix(in srgb, var(--md-sys-color-outline-variant) 60%, transparent);--phb-visual-bg: linear-gradient( 160deg, color-mix(in srgb, var(--md-sys-color-surface-container-high) 88%, var(--md-sys-color-primary) 12%), color-mix(in srgb, var(--md-sys-color-surface-container) 82%, var(--md-sys-color-primary-container) 18%) );--phb-visual-fallback: linear-gradient( 180deg, color-mix(in srgb, var(--md-sys-color-surface-container-high) 22%, transparent), color-mix(in srgb, var(--md-sys-color-surface-container-lowest) 8%, transparent) ), linear-gradient( 145deg, color-mix(in srgb, var(--md-sys-color-primary) 22%, var(--md-sys-color-surface-container-high) 78%), color-mix(in srgb, var(--md-sys-color-primary-container) 24%, var(--md-sys-color-surface-container-low) 76%) );--phb-orb-a-bg: color-mix(in srgb, var(--md-sys-color-surface-container-highest) 34%, transparent);--phb-orb-b-bg: color-mix(in srgb, var(--md-sys-color-primary) 26%, transparent);--phb-grid-line: color-mix(in srgb, var(--md-sys-color-on-surface) 10%, transparent)}.phb-shell{display:grid;grid-template-columns:minmax(0,1.45fr) minmax(240px,.95fr);gap:22px;align-items:stretch;padding:22px;border-radius:28px;overflow:hidden;background:var(--phb-shell-bg);border:1px solid var(--phb-shell-border);box-shadow:var(--phb-shell-shadow)}.phb-event{background:var(--phb-event-bg)}.phb-institutional{background:var(--phb-institutional-bg)}.phb-copy{display:grid;gap:18px;min-width:0}.phb-brand{margin:0;color:var(--phb-brand-color);font-size:.88rem;font-weight:700;letter-spacing:.08em;text-transform:uppercase}.phb-badges{display:flex;flex-wrap:wrap;gap:8px}.phb-badge{display:inline-flex;align-items:center;min-height:28px;padding:0 12px;border-radius:999px;background:var(--phb-badge-bg);color:var(--phb-badge-color);font-size:.76rem;font-weight:700;letter-spacing:.02em}.phb-badge-highlight{background:var(--phb-badge-highlight-bg);color:var(--phb-badge-highlight-color)}.phb-badge-muted{background:var(--phb-badge-muted-bg);color:var(--phb-badge-muted-color)}.phb-badge-warning{background:var(--phb-badge-warning-bg);color:var(--phb-badge-warning-color)}.phb-text{display:grid;gap:8px}.phb-subtitle{margin:0;color:var(--phb-subtitle-color);font-size:.9rem;font-weight:700;text-transform:uppercase;letter-spacing:.08em}.phb-title{margin:0;color:var(--phb-title-color);font-size:clamp(1.6rem,2.2vw,2.5rem);line-height:1.08;letter-spacing:-.03em}.phb-title-accent{display:inline;margin-left:.18em;background:linear-gradient(90deg,#4285f4,#6ea8ff 28%,#a142f4 62%,#ea4335);-webkit-background-clip:text;background-clip:text;color:transparent}.phb-description{margin:0;max-width:56ch;color:var(--phb-description-color);font-size:.98rem;line-height:1.65}.phb-meta{display:grid;grid-template-columns:repeat(auto-fit,minmax(180px,1fr));gap:12px;margin:0}.phb-meta-item{display:grid;gap:4px;padding:12px 14px;border-radius:16px;background:var(--phb-meta-bg);border:1px solid var(--phb-meta-border);-webkit-backdrop-filter:blur(12px);backdrop-filter:blur(12px)}.phb-meta-item dt{margin:0;color:var(--phb-meta-label-color);font-size:.73rem;font-weight:700;text-transform:uppercase;letter-spacing:.08em}.phb-meta-item dd{margin:0;color:var(--phb-meta-value-color);font-size:.92rem;line-height:1.45}.phb-visual{position:relative;min-height:220px;border-radius:22px;overflow:hidden;background:var(--phb-visual-bg)}.phb-image{display:block;width:100%;height:100%;object-fit:cover}.phb-visual-fallback{background:var(--phb-visual-fallback)}.phb-flat{padding:0 0 18px;border:0;border-radius:0;box-shadow:none;background:transparent;grid-template-columns:minmax(0,1.15fr) minmax(220px,.85fr);gap:18px}.phb-flat .phb-brand{color:var(--md-sys-color-primary)}.phb-flat .phb-badges{order:3}.phb-flat .phb-meta{grid-template-columns:1fr;gap:6px}.phb-flat .phb-meta-item{padding:0;border:0;border-radius:0;background:transparent;-webkit-backdrop-filter:none;backdrop-filter:none}.phb-flat .phb-meta-item dt,.phb-flat .phb-meta-item dd{display:inline}.phb-flat .phb-meta-item dt{margin-right:6px}.phb-flat .phb-visual{min-height:190px;border-radius:26px}.phb-orb{position:absolute;border-radius:999px;filter:blur(2px)}.phb-orb-a{inset:24px auto auto 20px;width:86px;height:86px;background:var(--phb-orb-a-bg)}.phb-orb-b{inset:auto 16px 18px auto;width:132px;height:132px;background:var(--phb-orb-b-bg)}.phb-grid{position:absolute;inset:0;background-image:linear-gradient(var(--phb-grid-line) 1px,transparent 1px),linear-gradient(90deg,var(--phb-grid-line) 1px,transparent 1px);background-size:24px 24px;opacity:.5}@media(max-width:900px){.phb-shell{grid-template-columns:1fr;padding:18px}.phb-visual{order:-1;min-height:180px}}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1$1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1$1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+  `, isInline: true, styles: [":host{display:block;--phb-shell-border: color-mix(in srgb, var(--md-sys-color-outline-variant) 60%, transparent);--phb-shell-shadow: 0 24px 60px color-mix(in srgb, var(--md-sys-color-shadow, #000) 10%, transparent);--phb-shell-bg: radial-gradient(circle at top right, color-mix(in srgb, var(--md-sys-color-primary) 14%, transparent), transparent 38%), linear-gradient( 135deg, color-mix(in srgb, var(--md-sys-color-surface-container-lowest) 92%, var(--md-sys-color-primary-container) 8%) 0%, color-mix(in srgb, var(--md-sys-color-surface-container-low) 88%, var(--md-sys-color-primary-container) 12%) 54%, color-mix(in srgb, var(--md-sys-color-surface) 96%, var(--md-sys-color-surface-container) 4%) 100% );--phb-event-bg: radial-gradient(circle at top right, rgba(255, 184, 77, .24), transparent 34%), linear-gradient( 135deg, color-mix(in srgb, var(--md-sys-color-primary-container) 16%, var(--md-sys-color-surface-container-lowest) 84%) 0%, color-mix(in srgb, var(--md-sys-color-primary-container) 24%, var(--md-sys-color-surface-container-low) 76%) 45%, color-mix(in srgb, var(--md-sys-color-surface) 92%, var(--md-sys-color-primary-container) 8%) 100% );--phb-institutional-bg: radial-gradient(circle at top right, rgba(17, 94, 89, .2), transparent 34%), linear-gradient( 135deg, color-mix(in srgb, var(--md-sys-color-secondary-container) 18%, var(--md-sys-color-surface-container-lowest) 82%) 0%, color-mix(in srgb, var(--md-sys-color-secondary-container) 24%, var(--md-sys-color-surface-container-low) 76%) 48%, color-mix(in srgb, var(--md-sys-color-surface) 94%, var(--md-sys-color-secondary-container) 6%) 100% );--phb-brand-color: color-mix(in srgb, var(--md-sys-color-primary) 68%, var(--md-sys-color-on-surface) 32%);--phb-subtitle-color: color-mix(in srgb, var(--md-sys-color-primary) 52%, var(--md-sys-color-on-surface) 48%);--phb-title-color: var(--md-sys-color-on-surface);--phb-description-color: var(--md-sys-color-on-surface-variant);--phb-badge-bg: color-mix(in srgb, var(--md-sys-color-surface-container-high) 78%, transparent);--phb-badge-color: var(--md-sys-color-on-surface);--phb-badge-highlight-bg: color-mix(in srgb, var(--md-sys-color-primary-container) 78%, transparent);--phb-badge-highlight-color: var(--md-sys-color-on-primary-container);--phb-badge-muted-bg: color-mix(in srgb, var(--md-sys-color-surface-container-highest) 82%, transparent);--phb-badge-muted-color: var(--md-sys-color-on-surface-variant);--phb-badge-warning-bg: color-mix(in srgb, var(--md-sys-color-error-container) 74%, transparent);--phb-badge-warning-color: var(--md-sys-color-on-error-container);--phb-meta-bg: color-mix(in srgb, var(--md-sys-color-surface-container-lowest) 72%, transparent);--phb-meta-border: color-mix(in srgb, var(--md-sys-color-outline-variant) 48%, transparent);--phb-meta-label-color: var(--md-sys-color-on-surface-variant);--phb-meta-value-color: var(--md-sys-color-on-surface);--phb-visual-bg: linear-gradient( 160deg, color-mix(in srgb, var(--md-sys-color-surface-container-high) 90%, var(--md-sys-color-primary) 10%), color-mix(in srgb, var(--md-sys-color-surface-container-low) 88%, var(--md-sys-color-primary-container) 12%) );--phb-visual-fallback: linear-gradient( 180deg, color-mix(in srgb, var(--md-sys-color-surface-bright, var(--md-sys-color-surface-container-high)) 24%, transparent), color-mix(in srgb, var(--md-sys-color-surface-container-lowest) 8%, transparent) ), linear-gradient( 145deg, color-mix(in srgb, var(--md-sys-color-primary) 18%, var(--md-sys-color-surface-container-high) 82%), color-mix(in srgb, var(--md-sys-color-primary-container) 18%, var(--md-sys-color-surface-container-low) 82%) );--phb-orb-a-bg: color-mix(in srgb, var(--md-sys-color-surface-bright, var(--md-sys-color-surface-container-high)) 68%, transparent);--phb-orb-b-bg: color-mix(in srgb, var(--md-sys-color-primary) 22%, transparent);--phb-grid-line: color-mix(in srgb, var(--md-sys-color-on-surface) 12%, transparent)}:host-context(.mdc-theme-dark),:host-context(.theme-dark){--phb-shell-border: color-mix(in srgb, var(--md-sys-color-outline-variant) 84%, transparent);--phb-shell-shadow: 0 22px 54px rgba(0, 0, 0, .28);--phb-shell-bg: radial-gradient(circle at top right, color-mix(in srgb, var(--md-sys-color-primary) 16%, transparent), transparent 40%), linear-gradient( 135deg, color-mix(in srgb, var(--md-sys-color-surface-container-lowest) 90%, var(--md-sys-color-primary-container) 10%) 0%, color-mix(in srgb, var(--md-sys-color-surface-container-low) 84%, var(--md-sys-color-primary-container) 16%) 54%, color-mix(in srgb, var(--md-sys-color-surface) 92%, var(--md-sys-color-primary-container) 8%) 100% );--phb-event-bg: radial-gradient(circle at top right, rgba(255, 184, 77, .18), transparent 36%), linear-gradient( 135deg, color-mix(in srgb, var(--md-sys-color-primary-container) 16%, var(--md-sys-color-surface-container-lowest) 84%) 0%, color-mix(in srgb, var(--md-sys-color-primary-container) 22%, var(--md-sys-color-surface-container-low) 78%) 45%, color-mix(in srgb, var(--md-sys-color-surface-container) 90%, var(--md-sys-color-primary-container) 10%) 100% );--phb-institutional-bg: radial-gradient(circle at top right, rgba(17, 94, 89, .16), transparent 36%), linear-gradient( 135deg, color-mix(in srgb, var(--md-sys-color-secondary-container) 16%, var(--md-sys-color-surface-container-lowest) 84%) 0%, color-mix(in srgb, var(--md-sys-color-secondary-container) 20%, var(--md-sys-color-surface-container-low) 80%) 48%, color-mix(in srgb, var(--md-sys-color-surface-container) 92%, var(--md-sys-color-secondary-container) 8%) 100% );--phb-meta-bg: color-mix(in srgb, var(--md-sys-color-surface-container-lowest) 70%, transparent);--phb-meta-border: color-mix(in srgb, var(--md-sys-color-outline-variant) 60%, transparent);--phb-visual-bg: linear-gradient( 160deg, color-mix(in srgb, var(--md-sys-color-surface-container-high) 88%, var(--md-sys-color-primary) 12%), color-mix(in srgb, var(--md-sys-color-surface-container) 82%, var(--md-sys-color-primary-container) 18%) );--phb-visual-fallback: linear-gradient( 180deg, color-mix(in srgb, var(--md-sys-color-surface-container-high) 22%, transparent), color-mix(in srgb, var(--md-sys-color-surface-container-lowest) 8%, transparent) ), linear-gradient( 145deg, color-mix(in srgb, var(--md-sys-color-primary) 22%, var(--md-sys-color-surface-container-high) 78%), color-mix(in srgb, var(--md-sys-color-primary-container) 24%, var(--md-sys-color-surface-container-low) 76%) );--phb-orb-a-bg: color-mix(in srgb, var(--md-sys-color-surface-container-highest) 34%, transparent);--phb-orb-b-bg: color-mix(in srgb, var(--md-sys-color-primary) 26%, transparent);--phb-grid-line: color-mix(in srgb, var(--md-sys-color-on-surface) 10%, transparent)}.phb-shell{display:grid;grid-template-columns:minmax(0,1.45fr) minmax(240px,.95fr);gap:22px;align-items:stretch;padding:22px;border-radius:28px;overflow:hidden;background:var(--phb-shell-bg);border:1px solid var(--phb-shell-border);box-shadow:var(--phb-shell-shadow)}.phb-event{background:var(--phb-event-bg)}.phb-institutional{background:var(--phb-institutional-bg)}.phb-copy{display:grid;gap:18px;min-width:0}.phb-brand{margin:0;color:var(--phb-brand-color);font-size:.88rem;font-weight:700;letter-spacing:.08em;text-transform:uppercase}.phb-badges{display:flex;flex-wrap:wrap;gap:8px}.phb-badge{display:inline-flex;align-items:center;min-height:28px;padding:0 12px;border-radius:999px;background:var(--phb-badge-bg);color:var(--phb-badge-color);font-size:.76rem;font-weight:700;letter-spacing:.02em}.phb-badge-highlight{background:var(--phb-badge-highlight-bg);color:var(--phb-badge-highlight-color)}.phb-badge-muted{background:var(--phb-badge-muted-bg);color:var(--phb-badge-muted-color)}.phb-badge-warning{background:var(--phb-badge-warning-bg);color:var(--phb-badge-warning-color)}.phb-text{display:grid;gap:8px}.phb-subtitle{margin:0;color:var(--phb-subtitle-color);font-size:.9rem;font-weight:700;text-transform:uppercase;letter-spacing:.08em}.phb-title{margin:0;color:var(--phb-title-color);font-size:clamp(1.6rem,2.2vw,2.5rem);line-height:1.08;letter-spacing:-.03em}.phb-title-accent{display:inline;margin-left:.18em;background:linear-gradient(90deg,#4285f4,#6ea8ff 28%,#a142f4 62%,#ea4335);-webkit-background-clip:text;background-clip:text;color:transparent}.phb-description{margin:0;max-width:56ch;color:var(--phb-description-color);font-size:.98rem;line-height:1.65}.phb-meta{display:grid;grid-template-columns:repeat(auto-fit,minmax(180px,1fr));gap:12px;margin:0}.phb-meta-item{display:grid;gap:4px;padding:12px 14px;border-radius:16px;background:var(--phb-meta-bg);border:1px solid var(--phb-meta-border);-webkit-backdrop-filter:blur(12px);backdrop-filter:blur(12px)}.phb-meta-item dt{margin:0;color:var(--phb-meta-label-color);font-size:.73rem;font-weight:700;text-transform:uppercase;letter-spacing:.08em}.phb-meta-item dd{margin:0;color:var(--phb-meta-value-color);font-size:.92rem;line-height:1.45}.phb-visual{position:relative;min-height:220px;border-radius:22px;overflow:hidden;background:var(--phb-visual-bg)}.phb-image{display:block;width:100%;height:100%;object-fit:cover}.phb-visual-fallback{background:var(--phb-visual-fallback)}.phb-flat{padding:0 0 18px;border:0;border-radius:0;box-shadow:none;background:transparent;grid-template-columns:minmax(0,1.15fr) minmax(220px,.85fr);gap:18px}.phb-flat .phb-brand{color:var(--md-sys-color-primary)}.phb-flat .phb-badges{order:3}.phb-flat .phb-meta{grid-template-columns:1fr;gap:6px}.phb-flat .phb-meta-item{padding:0;border:0;border-radius:0;background:transparent;-webkit-backdrop-filter:none;backdrop-filter:none}.phb-flat .phb-meta-item dt,.phb-flat .phb-meta-item dd{display:inline}.phb-flat .phb-meta-item dt{margin-right:6px}.phb-flat .phb-visual{min-height:190px;border-radius:26px}.phb-orb{position:absolute;border-radius:999px;filter:blur(2px)}.phb-orb-a{inset:24px auto auto 20px;width:86px;height:86px;background:var(--phb-orb-a-bg)}.phb-orb-b{inset:auto 16px 18px auto;width:132px;height:132px;background:var(--phb-orb-b-bg)}.phb-grid{position:absolute;inset:0;background-image:linear-gradient(var(--phb-grid-line) 1px,transparent 1px),linear-gradient(90deg,var(--phb-grid-line) 1px,transparent 1px);background-size:24px 24px;opacity:.5}@media(max-width:900px){.phb-shell{grid-template-columns:1fr;padding:18px}.phb-visual{order:-1;min-height:180px}}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1$2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1$2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: PraxisHeroBannerComponent, decorators: [{
             type: Component,
@@ -13954,7 +15897,7 @@ class PraxisRichTextBlockComponent {
 
       <div class="prt-content" [innerHTML]="renderedContent"></div>
     </section>
-  `, isInline: true, styles: [":host{display:block;--prt-border: color-mix(in srgb, var(--md-sys-color-outline-variant) 72%, transparent);--prt-bg: linear-gradient( 180deg, color-mix(in srgb, var(--md-sys-color-surface) 96%, var(--md-sys-color-surface-container-lowest) 4%), color-mix(in srgb, var(--md-sys-color-surface-container-low) 92%, var(--md-sys-color-surface) 8%) );--prt-emphasis-border: color-mix(in srgb, var(--md-sys-color-primary) 32%, var(--md-sys-color-outline-variant));--prt-emphasis-bg: linear-gradient( 180deg, color-mix(in srgb, var(--md-sys-color-primary-container) 36%, var(--md-sys-color-surface) 64%), color-mix(in srgb, var(--md-sys-color-surface) 96%, var(--md-sys-color-primary-container) 4%) );--prt-subtle-bg: color-mix(in srgb, var(--md-sys-color-surface-container-low) 82%, transparent);--prt-icon-bg: color-mix(in srgb, var(--md-sys-color-primary-container) 64%, transparent);--prt-code-bg: color-mix(in srgb, var(--md-sys-color-surface-container-highest) 82%, transparent)}:host-context(.mdc-theme-dark),:host-context(.theme-dark){--prt-border: color-mix(in srgb, var(--md-sys-color-outline-variant) 84%, transparent);--prt-bg: linear-gradient( 180deg, color-mix(in srgb, var(--md-sys-color-surface-container-low) 92%, var(--md-sys-color-surface) 8%), color-mix(in srgb, var(--md-sys-color-surface-container) 90%, var(--md-sys-color-surface-container-high) 10%) );--prt-emphasis-border: color-mix(in srgb, var(--md-sys-color-primary) 42%, var(--md-sys-color-outline-variant));--prt-emphasis-bg: linear-gradient( 180deg, color-mix(in srgb, var(--md-sys-color-primary-container) 28%, var(--md-sys-color-surface-container-low) 72%), color-mix(in srgb, var(--md-sys-color-surface-container) 92%, var(--md-sys-color-primary-container) 8%) );--prt-subtle-bg: color-mix(in srgb, var(--md-sys-color-surface-container-low) 88%, transparent);--prt-icon-bg: color-mix(in srgb, var(--md-sys-color-primary-container) 42%, transparent);--prt-code-bg: color-mix(in srgb, var(--md-sys-color-surface-container-high) 88%, transparent)}.prt-block{display:grid;gap:12px;padding:16px 18px;border-radius:16px;border:1px solid var(--prt-border);background:var(--prt-bg);color:var(--md-sys-color-on-surface)}.prt-block-emphasis{border-color:var(--prt-emphasis-border);background:var(--prt-emphasis-bg)}.prt-block-subtle{background:var(--prt-subtle-bg);border-style:dashed}.prt-block-plain{padding:0;border:0;border-radius:0;background:transparent}.prt-head{display:grid;grid-template-columns:auto 1fr;gap:12px;align-items:start}.prt-icon{display:inline-flex;align-items:center;justify-content:center;width:36px;height:36px;border-radius:12px;background:var(--prt-icon-bg);color:var(--md-sys-color-primary);font-size:20px;line-height:1}.prt-title-wrap{display:grid;gap:4px}.prt-title{margin:0;font-size:1rem;font-weight:700;line-height:1.3}.prt-subtitle{margin:0;color:var(--md-sys-color-on-surface-variant);font-size:.86rem;line-height:1.4}.prt-content{color:var(--md-sys-color-on-surface);font-size:.94rem;line-height:1.6}.prt-content :where(p,ul){margin:0}.prt-content :where(p+p,p+ul,ul+p,ul+ul){margin-top:10px}.prt-content ul{padding-left:18px}.prt-content a{color:var(--md-sys-color-primary);text-decoration:underline;text-underline-offset:2px}.prt-content strong{font-weight:700}.prt-content em{font-style:italic}.prt-content code{font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;font-size:.88em;padding:.1em .35em;border-radius:6px;background:var(--prt-code-bg)}.prt-block-plain .prt-icon{width:32px;height:32px;border-radius:10px;background:color-mix(in srgb,var(--md-sys-color-surface-container-high) 80%,transparent)}.prt-block-plain .prt-content{font-size:.92rem}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1$1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i4.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "directive", type: PraxisIconDirective, selector: "mat-icon[praxisIcon]", inputs: ["praxisIcon"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+  `, isInline: true, styles: [":host{display:block;--prt-border: color-mix(in srgb, var(--md-sys-color-outline-variant) 72%, transparent);--prt-bg: linear-gradient( 180deg, color-mix(in srgb, var(--md-sys-color-surface) 96%, var(--md-sys-color-surface-container-lowest) 4%), color-mix(in srgb, var(--md-sys-color-surface-container-low) 92%, var(--md-sys-color-surface) 8%) );--prt-emphasis-border: color-mix(in srgb, var(--md-sys-color-primary) 32%, var(--md-sys-color-outline-variant));--prt-emphasis-bg: linear-gradient( 180deg, color-mix(in srgb, var(--md-sys-color-primary-container) 36%, var(--md-sys-color-surface) 64%), color-mix(in srgb, var(--md-sys-color-surface) 96%, var(--md-sys-color-primary-container) 4%) );--prt-subtle-bg: color-mix(in srgb, var(--md-sys-color-surface-container-low) 82%, transparent);--prt-icon-bg: color-mix(in srgb, var(--md-sys-color-primary-container) 64%, transparent);--prt-code-bg: color-mix(in srgb, var(--md-sys-color-surface-container-highest) 82%, transparent)}:host-context(.mdc-theme-dark),:host-context(.theme-dark){--prt-border: color-mix(in srgb, var(--md-sys-color-outline-variant) 84%, transparent);--prt-bg: linear-gradient( 180deg, color-mix(in srgb, var(--md-sys-color-surface-container-low) 92%, var(--md-sys-color-surface) 8%), color-mix(in srgb, var(--md-sys-color-surface-container) 90%, var(--md-sys-color-surface-container-high) 10%) );--prt-emphasis-border: color-mix(in srgb, var(--md-sys-color-primary) 42%, var(--md-sys-color-outline-variant));--prt-emphasis-bg: linear-gradient( 180deg, color-mix(in srgb, var(--md-sys-color-primary-container) 28%, var(--md-sys-color-surface-container-low) 72%), color-mix(in srgb, var(--md-sys-color-surface-container) 92%, var(--md-sys-color-primary-container) 8%) );--prt-subtle-bg: color-mix(in srgb, var(--md-sys-color-surface-container-low) 88%, transparent);--prt-icon-bg: color-mix(in srgb, var(--md-sys-color-primary-container) 42%, transparent);--prt-code-bg: color-mix(in srgb, var(--md-sys-color-surface-container-high) 88%, transparent)}.prt-block{display:grid;gap:12px;padding:16px 18px;border-radius:16px;border:1px solid var(--prt-border);background:var(--prt-bg);color:var(--md-sys-color-on-surface)}.prt-block-emphasis{border-color:var(--prt-emphasis-border);background:var(--prt-emphasis-bg)}.prt-block-subtle{background:var(--prt-subtle-bg);border-style:dashed}.prt-block-plain{padding:0;border:0;border-radius:0;background:transparent}.prt-head{display:grid;grid-template-columns:auto 1fr;gap:12px;align-items:start}.prt-icon{display:inline-flex;align-items:center;justify-content:center;width:36px;height:36px;border-radius:12px;background:var(--prt-icon-bg);color:var(--md-sys-color-primary);font-size:20px;line-height:1}.prt-title-wrap{display:grid;gap:4px}.prt-title{margin:0;font-size:1rem;font-weight:700;line-height:1.3}.prt-subtitle{margin:0;color:var(--md-sys-color-on-surface-variant);font-size:.86rem;line-height:1.4}.prt-content{color:var(--md-sys-color-on-surface);font-size:.94rem;line-height:1.6}.prt-content :where(p,ul){margin:0}.prt-content :where(p+p,p+ul,ul+p,ul+ul){margin-top:10px}.prt-content ul{padding-left:18px}.prt-content a{color:var(--md-sys-color-primary);text-decoration:underline;text-underline-offset:2px}.prt-content strong{font-weight:700}.prt-content em{font-style:italic}.prt-content code{font-family:ui-monospace,SFMono-Regular,Menlo,Consolas,monospace;font-size:.88em;padding:.1em .35em;border-radius:6px;background:var(--prt-code-bg)}.prt-block-plain .prt-icon{width:32px;height:32px;border-radius:10px;background:color-mix(in srgb,var(--md-sys-color-surface-container-high) 80%,transparent)}.prt-block-plain .prt-content{font-size:.92rem}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1$2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i4.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "directive", type: PraxisIconDirective, selector: "mat-icon[praxisIcon]", inputs: ["praxisIcon"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: PraxisRichTextBlockComponent, decorators: [{
             type: Component,
@@ -14160,7 +16103,7 @@ class PraxisLegalNoticeComponent {
         </a>
       </nav>
     </section>
-  `, isInline: true, styles: [":host{display:block}.pln-shell{display:grid;gap:10px}.pln-shell .praxis-rich-text-block .prt-block,.pln-shell .prt-block{border-left:4px solid color-mix(in srgb,var(--md-sys-color-primary) 56%,transparent)}.pln-warning .praxis-rich-text-block .prt-block,.pln-warning .prt-block{border-left-color:var(--md-sys-color-error)}.pln-muted .praxis-rich-text-block .prt-block,.pln-muted .prt-block{border-left-color:color-mix(in srgb,var(--md-sys-color-outline) 58%,transparent)}.pln-plain .praxis-rich-text-block .prt-block,.pln-plain .prt-block{border-left:0}.pln-links{display:flex;flex-wrap:wrap;gap:8px 12px;padding-left:18px}.pln-plain .pln-links{padding-left:0;padding-top:2px}.pln-link{color:var(--md-sys-color-primary);font-size:.84rem;line-height:1.4;text-decoration:underline;text-underline-offset:2px}:host-context(.mdc-theme-dark) .pln-link,:host-context(.theme-dark) .pln-link{color:color-mix(in srgb,var(--md-sys-color-primary) 86%,white)}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1$1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1$1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: PraxisRichTextBlockComponent, selector: "praxis-rich-text-block", inputs: ["instanceId", "analyticsId", "ariaLabel", "title", "subtitle", "icon", "variant", "appearance", "contentFormat", "content"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+  `, isInline: true, styles: [":host{display:block}.pln-shell{display:grid;gap:10px}.pln-shell .praxis-rich-text-block .prt-block,.pln-shell .prt-block{border-left:4px solid color-mix(in srgb,var(--md-sys-color-primary) 56%,transparent)}.pln-warning .praxis-rich-text-block .prt-block,.pln-warning .prt-block{border-left-color:var(--md-sys-color-error)}.pln-muted .praxis-rich-text-block .prt-block,.pln-muted .prt-block{border-left-color:color-mix(in srgb,var(--md-sys-color-outline) 58%,transparent)}.pln-plain .praxis-rich-text-block .prt-block,.pln-plain .prt-block{border-left:0}.pln-links{display:flex;flex-wrap:wrap;gap:8px 12px;padding-left:18px}.pln-plain .pln-links{padding-left:0;padding-top:2px}.pln-link{color:var(--md-sys-color-primary);font-size:.84rem;line-height:1.4;text-decoration:underline;text-underline-offset:2px}:host-context(.mdc-theme-dark) .pln-link,:host-context(.theme-dark) .pln-link{color:color-mix(in srgb,var(--md-sys-color-primary) 86%,white)}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1$2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1$2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: PraxisRichTextBlockComponent, selector: "praxis-rich-text-block", inputs: ["instanceId", "analyticsId", "ariaLabel", "title", "subtitle", "icon", "variant", "appearance", "contentFormat", "content"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: PraxisLegalNoticeComponent, decorators: [{
             type: Component,
@@ -14350,7 +16293,7 @@ class PraxisUserContextSummaryComponent {
         <button type="button" class="pux-action" (click)="emitAction()">{{ actionLabel }}</button>
       </div>
     </section>
-  `, isInline: true, styles: [":host{display:block}.pux-card{display:grid;gap:14px;padding:16px 18px;border-radius:18px;border:1px solid color-mix(in srgb,var(--md-sys-color-outline-variant) 78%,transparent);background:linear-gradient(180deg,#fffffffa,#f4f8fcfa)}.pux-head{display:grid;gap:4px}.pux-title{margin:0;color:var(--md-sys-color-on-surface);font-size:.98rem;font-weight:700}.pux-subtitle{margin:0;color:var(--md-sys-color-on-surface-variant);font-size:.84rem;line-height:1.5}.pux-grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(180px,1fr));gap:10px;margin:0}.pux-item{display:grid;gap:4px;padding:12px 14px;border-radius:14px;background:#ffffffb8;border:1px solid rgba(66,93,135,.1)}.pux-item dt{margin:0;color:#5d7186;font-size:.73rem;font-weight:700;text-transform:uppercase;letter-spacing:.06em}.pux-item dd{margin:0;color:#17314f;font-size:.92rem;line-height:1.45}.pux-actions{display:flex;justify-content:flex-start}.pux-action{min-height:36px;padding:0 14px;border:1px solid rgba(33,88,201,.18);border-radius:999px;background:#2060d214;color:#1e55b8;font:inherit;font-size:.84rem;font-weight:700;cursor:pointer}.pux-empty{margin:0;color:var(--md-sys-color-on-surface-variant);font-size:.84rem}.pux-plain{gap:10px;padding:8px 0 4px;border:0;border-radius:0;background:transparent}.pux-plain .pux-grid{grid-template-columns:1fr;gap:6px}.pux-plain .pux-item{padding:12px 14px;border-radius:14px;background:#ffffff8f;border:1px solid rgba(66,93,135,.08)}.pux-plain .pux-actions{margin-top:2px}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1$1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1$1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+  `, isInline: true, styles: [":host{display:block}.pux-card{display:grid;gap:14px;padding:16px 18px;border-radius:18px;border:1px solid color-mix(in srgb,var(--md-sys-color-outline-variant) 78%,transparent);background:linear-gradient(180deg,#fffffffa,#f4f8fcfa)}.pux-head{display:grid;gap:4px}.pux-title{margin:0;color:var(--md-sys-color-on-surface);font-size:.98rem;font-weight:700}.pux-subtitle{margin:0;color:var(--md-sys-color-on-surface-variant);font-size:.84rem;line-height:1.5}.pux-grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(180px,1fr));gap:10px;margin:0}.pux-item{display:grid;gap:4px;padding:12px 14px;border-radius:14px;background:#ffffffb8;border:1px solid rgba(66,93,135,.1)}.pux-item dt{margin:0;color:#5d7186;font-size:.73rem;font-weight:700;text-transform:uppercase;letter-spacing:.06em}.pux-item dd{margin:0;color:#17314f;font-size:.92rem;line-height:1.45}.pux-actions{display:flex;justify-content:flex-start}.pux-action{min-height:36px;padding:0 14px;border:1px solid rgba(33,88,201,.18);border-radius:999px;background:#2060d214;color:#1e55b8;font:inherit;font-size:.84rem;font-weight:700;cursor:pointer}.pux-empty{margin:0;color:var(--md-sys-color-on-surface-variant);font-size:.84rem}.pux-plain{gap:10px;padding:8px 0 4px;border:0;border-radius:0;background:transparent}.pux-plain .pux-grid{grid-template-columns:1fr;gap:6px}.pux-plain .pux-item{padding:12px 14px;border-radius:14px;background:#ffffff8f;border:1px solid rgba(66,93,135,.08)}.pux-plain .pux-actions{margin-top:2px}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1$2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1$2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: PraxisUserContextSummaryComponent, decorators: [{
             type: Component,
@@ -15102,7 +17045,7 @@ class WidgetShellComponent {
     @if (expanded || fullscreen) {
     <div class="pdx-shell-backdrop" (click)="closeOverlay()"></div>
     }
-  `, isInline: true, styles: [":host{display:block;height:100%}.pdx-shell{position:relative;height:100%;display:flex;flex-direction:column}.pdx-shell.no-shell{background:transparent;border:none;border-radius:0;box-shadow:none}.pdx-shell.dashboard{background:var(--pdx-shell-card-bg, var(--pdx-dashboard-card-bg, var(--md-sys-color-surface-container-low)));border:1px solid var(--pdx-shell-card-border, var(--pdx-dashboard-card-border, var(--md-sys-color-outline-variant)));border-radius:var(--pdx-shell-card-radius, 14px);box-shadow:var(--pdx-shell-card-shadow, var(--mat-elevation-level2));overflow:hidden}.pdx-shell-header{display:flex;align-items:center;gap:12px;padding:10px 12px 8px;border-bottom:1px solid var(--pdx-shell-header-border, var(--md-sys-color-outline-variant));background:var(--pdx-shell-header-bg, var(--md-sys-color-surface-container))}.pdx-shell-title{display:flex;align-items:center;gap:10px;min-width:0;flex:1;color:var(--pdx-shell-title-color, inherit)}.pdx-shell-title mat-icon{color:var(--pdx-shell-icon-color, currentColor)}.pdx-shell-text{min-width:0}.pdx-shell-title-text{font-weight:var(--pdx-shell-title-weight, 600);font-size:var(--pdx-shell-title-size, 14px);line-height:1.2;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.pdx-shell-subtitle{font-size:var(--pdx-shell-subtitle-size, 12px);opacity:.75;color:var(--pdx-shell-subtitle-color, currentColor);white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.pdx-shell-actions,.pdx-shell-window-actions{display:flex;align-items:center;gap:6px}.pdx-shell-window-actions{margin-left:auto}.pdx-action-outlined{border:1px solid var(--md-sys-color-outline-variant);border-radius:999px;padding:0 10px}.pdx-action-text{padding:0 8px}.pdx-action-label{font-size:12px;font-weight:500}.pdx-shell-body{flex:1;min-height:0;padding:var(--pdx-shell-body-padding, 10px 12px 12px 12px);background:var(--pdx-shell-body-bg, transparent);color:var(--pdx-shell-body-color, inherit)}.pdx-shell.no-shell .pdx-shell-body{padding:0}.pdx-shell-body.hidden{display:none}.pdx-shell.collapsed .pdx-shell-header{border-bottom-color:transparent}.pdx-shell.expanded .pdx-shell-body,.pdx-shell.fullscreen .pdx-shell-body{overflow:auto;display:flex;flex-direction:column;min-height:0}.pdx-shell.expanded .pdx-shell-body>*,.pdx-shell.fullscreen .pdx-shell-body>*{flex:1 1 auto;min-height:0;width:100%}.pdx-shell.expanded{position:fixed;top:10vh;left:50%;width:min(920px,92vw);height:min(640px,82vh);transform:translate(-50%);z-index:1200;box-shadow:var(--mat-elevation-level8)}.pdx-shell.fullscreen{position:fixed;top:50%;left:50%;width:95vw;height:95vh;transform:translate(-50%,-50%);z-index:1201;box-shadow:var(--mat-elevation-level8)}.pdx-shell-backdrop{position:fixed;inset:0;z-index:1199;background:#0000008c;-webkit-backdrop-filter:blur(2px);backdrop-filter:blur(2px)}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1$1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i1$1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i2.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: "component", type: i2.MatIconButton, selector: "button[mat-icon-button], a[mat-icon-button], button[matIconButton], a[matIconButton]", exportAs: ["matButton", "matAnchor"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i4.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "ngmodule", type: MatMenuModule }, { kind: "component", type: i4$1.MatMenu, selector: "mat-menu", inputs: ["backdropClass", "aria-label", "aria-labelledby", "aria-describedby", "xPosition", "yPosition", "overlapTrigger", "hasBackdrop", "class", "classList"], outputs: ["closed", "close"], exportAs: ["matMenu"] }, { kind: "component", type: i4$1.MatMenuItem, selector: "[mat-menu-item]", inputs: ["role", "disabled", "disableRipple"], exportAs: ["matMenuItem"] }, { kind: "directive", type: i4$1.MatMenuTrigger, selector: "[mat-menu-trigger-for], [matMenuTriggerFor]", inputs: ["mat-menu-trigger-for", "matMenuTriggerFor", "matMenuTriggerData", "matMenuTriggerRestoreFocus"], outputs: ["menuOpened", "onMenuOpen", "menuClosed", "onMenuClose"], exportAs: ["matMenuTrigger"] }, { kind: "ngmodule", type: MatTooltipModule }, { kind: "directive", type: i5.MatTooltip, selector: "[matTooltip]", inputs: ["matTooltipPosition", "matTooltipPositionAtOrigin", "matTooltipDisabled", "matTooltipShowDelay", "matTooltipHideDelay", "matTooltipTouchGestures", "matTooltip", "matTooltipClass"], exportAs: ["matTooltip"] }, { kind: "directive", type: PraxisIconDirective, selector: "mat-icon[praxisIcon]", inputs: ["praxisIcon"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+  `, isInline: true, styles: [":host{display:block;height:100%}.pdx-shell{position:relative;height:100%;display:flex;flex-direction:column}.pdx-shell.no-shell{background:transparent;border:none;border-radius:0;box-shadow:none}.pdx-shell.dashboard{background:var(--pdx-shell-card-bg, var(--pdx-dashboard-card-bg, var(--md-sys-color-surface-container-low)));border:1px solid var(--pdx-shell-card-border, var(--pdx-dashboard-card-border, var(--md-sys-color-outline-variant)));border-radius:var(--pdx-shell-card-radius, 14px);box-shadow:var(--pdx-shell-card-shadow, var(--mat-elevation-level2));overflow:hidden}.pdx-shell-header{display:flex;align-items:center;gap:12px;padding:10px 12px 8px;border-bottom:1px solid var(--pdx-shell-header-border, var(--md-sys-color-outline-variant));background:var(--pdx-shell-header-bg, var(--md-sys-color-surface-container))}.pdx-shell-title{display:flex;align-items:center;gap:10px;min-width:0;flex:1;color:var(--pdx-shell-title-color, inherit)}.pdx-shell-title mat-icon{color:var(--pdx-shell-icon-color, currentColor)}.pdx-shell-text{min-width:0}.pdx-shell-title-text{font-weight:var(--pdx-shell-title-weight, 600);font-size:var(--pdx-shell-title-size, 14px);line-height:1.2;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.pdx-shell-subtitle{font-size:var(--pdx-shell-subtitle-size, 12px);opacity:.75;color:var(--pdx-shell-subtitle-color, currentColor);white-space:nowrap;overflow:hidden;text-overflow:ellipsis}.pdx-shell-actions,.pdx-shell-window-actions{display:flex;align-items:center;gap:6px}.pdx-shell-window-actions{margin-left:auto}.pdx-action-outlined{border:1px solid var(--md-sys-color-outline-variant);border-radius:999px;padding:0 10px}.pdx-action-text{padding:0 8px}.pdx-action-label{font-size:12px;font-weight:500}.pdx-shell-body{flex:1;min-height:0;padding:var(--pdx-shell-body-padding, 10px 12px 12px 12px);background:var(--pdx-shell-body-bg, transparent);color:var(--pdx-shell-body-color, inherit)}.pdx-shell.no-shell .pdx-shell-body{padding:0}.pdx-shell-body.hidden{display:none}.pdx-shell.collapsed .pdx-shell-header{border-bottom-color:transparent}.pdx-shell.expanded .pdx-shell-body,.pdx-shell.fullscreen .pdx-shell-body{overflow:auto;display:flex;flex-direction:column;min-height:0}.pdx-shell.expanded .pdx-shell-body>*,.pdx-shell.fullscreen .pdx-shell-body>*{flex:1 1 auto;min-height:0;width:100%}.pdx-shell.expanded{position:fixed;top:10vh;left:50%;width:min(920px,92vw);height:min(640px,82vh);transform:translate(-50%);z-index:1200;box-shadow:var(--mat-elevation-level8)}.pdx-shell.fullscreen{position:fixed;top:50%;left:50%;width:95vw;height:95vh;transform:translate(-50%,-50%);z-index:1201;box-shadow:var(--mat-elevation-level8)}.pdx-shell-backdrop{position:fixed;inset:0;z-index:1199;background:#0000008c;-webkit-backdrop-filter:blur(2px);backdrop-filter:blur(2px)}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1$2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i1$2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i2.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: "component", type: i2.MatIconButton, selector: "button[mat-icon-button], a[mat-icon-button], button[matIconButton], a[matIconButton]", exportAs: ["matButton", "matAnchor"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i4.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "ngmodule", type: MatMenuModule }, { kind: "component", type: i4$1.MatMenu, selector: "mat-menu", inputs: ["backdropClass", "aria-label", "aria-labelledby", "aria-describedby", "xPosition", "yPosition", "overlapTrigger", "hasBackdrop", "class", "classList"], outputs: ["closed", "close"], exportAs: ["matMenu"] }, { kind: "component", type: i4$1.MatMenuItem, selector: "[mat-menu-item]", inputs: ["role", "disabled", "disableRipple"], exportAs: ["matMenuItem"] }, { kind: "directive", type: i4$1.MatMenuTrigger, selector: "[mat-menu-trigger-for], [matMenuTriggerFor]", inputs: ["mat-menu-trigger-for", "matMenuTriggerFor", "matMenuTriggerData", "matMenuTriggerRestoreFocus"], outputs: ["menuOpened", "onMenuOpen", "menuClosed", "onMenuClose"], exportAs: ["matMenuTrigger"] }, { kind: "ngmodule", type: MatTooltipModule }, { kind: "directive", type: i5$1.MatTooltip, selector: "[matTooltip]", inputs: ["matTooltipPosition", "matTooltipPositionAtOrigin", "matTooltipDisabled", "matTooltipShowDelay", "matTooltipHideDelay", "matTooltipTouchGestures", "matTooltip", "matTooltipClass"], exportAs: ["matTooltip"] }, { kind: "directive", type: PraxisIconDirective, selector: "mat-icon[praxisIcon]", inputs: ["praxisIcon"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: WidgetShellComponent, decorators: [{
             type: Component,
@@ -15243,6 +17186,180 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImpo
                 args: [DynamicWidgetLoaderDirective]
             }] } });
 
+const BUILTIN_PAGE_LAYOUT_PRESETS = {
+    'analytics-overview': {
+        id: 'analytics-overview',
+        label: 'Analytics Overview',
+        description: 'Hero, KPIs, charts principais e tabela detalhada em uma página analítica ampla.',
+        category: 'analytics',
+        defaultLayout: {
+            orientation: 'columns',
+            columns: 2,
+            gap: '20px',
+            breakpoints: { sm: 1, md: 2, lg: 2, xl: 2 },
+        },
+        defaultGrouping: [
+            { kind: 'hero', id: 'hero', widgetKeys: ['hero'], emphasis: 'high' },
+            { kind: 'section', id: 'kpis', label: 'KPIs', widgetKeys: ['kpis'], layout: 'row' },
+            { kind: 'section', id: 'charts', label: 'Charts', widgetKeys: ['primary-chart', 'secondary-chart-a', 'secondary-chart-b'], layout: 'grid' },
+            { kind: 'section', id: 'detail-table', label: 'Detail Table', widgetKeys: ['detail-table'], layout: 'stack' },
+        ],
+        defaultThemePreset: 'analytics-calm',
+        slotModel: [
+            { id: 'hero', label: 'Hero', required: false, maxItems: 1 },
+            { id: 'kpis', label: 'KPIs', required: true, minItems: 1 },
+            { id: 'primary-chart', label: 'Primary Chart', required: true, minItems: 1, maxItems: 1 },
+            { id: 'secondary-chart-a', label: 'Secondary Chart A', required: false, maxItems: 1 },
+            { id: 'secondary-chart-b', label: 'Secondary Chart B', required: false, maxItems: 1 },
+            { id: 'detail-table', label: 'Detail Table', required: true, minItems: 1, maxItems: 1 },
+        ],
+        widgetSuggestions: [
+            { slot: 'kpis', widgetType: 'form:user-context-summary', priority: 'primary' },
+            { slot: 'primary-chart', widgetType: 'praxis-chart', priority: 'primary' },
+            { slot: 'detail-table', widgetType: 'praxis-table', priority: 'primary' },
+        ],
+        devicePolicy: {
+            stacking: 'compress',
+            preferTabsOnMobile: false,
+        },
+    },
+    'kpi-plus-table': {
+        id: 'kpi-plus-table',
+        label: 'KPI Plus Table',
+        description: 'Faixa superior de métricas com uma tabela dominante e visuais auxiliares.',
+        category: 'analytics',
+        defaultLayout: {
+            orientation: 'columns',
+            columns: 2,
+            gap: '18px',
+            breakpoints: { sm: 1, md: 1, lg: 2, xl: 2 },
+        },
+        defaultGrouping: [
+            { kind: 'section', id: 'filters', label: 'Filters', widgetKeys: ['filters'], layout: 'stack' },
+            { kind: 'section', id: 'kpis', label: 'KPIs', widgetKeys: ['kpis'], layout: 'row' },
+            { kind: 'section', id: 'table', label: 'Table', widgetKeys: ['detail-table'], layout: 'stack' },
+            { kind: 'section', id: 'aux', label: 'Auxiliary Charts', widgetKeys: ['aux-chart-a', 'aux-chart-b'], layout: 'grid' },
+        ],
+        defaultThemePreset: 'analytics-calm',
+        slotModel: [
+            { id: 'filters', label: 'Filters', required: false, maxItems: 1 },
+            { id: 'kpis', label: 'KPIs', required: true, minItems: 1 },
+            { id: 'detail-table', label: 'Detail Table', required: true, minItems: 1, maxItems: 1 },
+            { id: 'aux-chart-a', label: 'Auxiliary Chart A', required: false, maxItems: 1 },
+            { id: 'aux-chart-b', label: 'Auxiliary Chart B', required: false, maxItems: 1 },
+        ],
+        widgetSuggestions: [
+            { slot: 'filters', widgetType: 'praxis-filter', priority: 'primary' },
+            { slot: 'detail-table', widgetType: 'praxis-table', priority: 'primary' },
+        ],
+        devicePolicy: {
+            stacking: 'linearize',
+            hideSecondaryContentOnMobile: true,
+        },
+    },
+    'master-detail-dashboard': {
+        id: 'master-detail-dashboard',
+        label: 'Master Detail Dashboard',
+        description: 'Master dominante com áreas de detalhe, KPIs e tabs sincronizadas.',
+        category: 'master-detail',
+        defaultLayout: {
+            orientation: 'columns',
+            columns: 3,
+            gap: '18px',
+            breakpoints: { sm: 1, md: 1, lg: 2, xl: 3 },
+        },
+        defaultGrouping: [
+            { kind: 'section', id: 'master', label: 'Master', widgetKeys: ['master'], layout: 'stack' },
+            { kind: 'section', id: 'detail-kpis', label: 'Detail KPIs', widgetKeys: ['detail-kpis'], layout: 'row' },
+            {
+                kind: 'tabs',
+                id: 'detail-tabs',
+                label: 'Detail Tabs',
+                tabs: [
+                    { id: 'detail-insights', label: 'Insights', widgetKeys: ['detail-chart-a', 'detail-chart-b'] },
+                    { id: 'detail-table', label: 'Details', widgetKeys: ['detail-table'] },
+                ],
+            },
+        ],
+        defaultThemePreset: 'workspace-balanced',
+        slotModel: [
+            { id: 'master', label: 'Master', required: true, minItems: 1, maxItems: 1 },
+            { id: 'detail-kpis', label: 'Detail KPIs', required: false, minItems: 1 },
+            { id: 'detail-chart-a', label: 'Detail Chart A', required: false, maxItems: 1 },
+            { id: 'detail-chart-b', label: 'Detail Chart B', required: false, maxItems: 1 },
+            { id: 'detail-table', label: 'Detail Table', required: true, minItems: 1, maxItems: 1 },
+        ],
+        widgetSuggestions: [
+            { slot: 'master', widgetType: 'praxis-table', priority: 'primary' },
+            { slot: 'detail-table', widgetType: 'praxis-table', priority: 'primary' },
+            { slot: 'detail-chart-a', widgetType: 'praxis-chart', priority: 'secondary' },
+        ],
+        devicePolicy: {
+            stacking: 'compress',
+            preferTabsOnMobile: true,
+        },
+    },
+    'ops-monitoring': {
+        id: 'ops-monitoring',
+        label: 'Ops Monitoring',
+        description: 'Cards de status, séries temporais, fila operacional e área de alertas.',
+        category: 'operations',
+        defaultLayout: {
+            orientation: 'columns',
+            columns: 3,
+            gap: '18px',
+            breakpoints: { sm: 1, md: 2, lg: 3, xl: 3 },
+        },
+        defaultGrouping: [
+            { kind: 'hero', id: 'status-cards', widgetKeys: ['status-cards'], emphasis: 'medium' },
+            { kind: 'section', id: 'timelines', label: 'Timelines', widgetKeys: ['timeline-a', 'timeline-b'], layout: 'grid' },
+            { kind: 'section', id: 'queue', label: 'Operational Queue', widgetKeys: ['queue'], layout: 'stack' },
+            { kind: 'rail', id: 'alerts', side: 'right', widgetKeys: ['alerts'] },
+        ],
+        defaultThemePreset: 'ops-monitoring',
+        slotModel: [
+            { id: 'status-cards', label: 'Status Cards', required: true, minItems: 1 },
+            { id: 'timeline-a', label: 'Timeline A', required: true, minItems: 1, maxItems: 1 },
+            { id: 'timeline-b', label: 'Timeline B', required: false, maxItems: 1 },
+            { id: 'queue', label: 'Operational Queue', required: true, minItems: 1, maxItems: 1 },
+            { id: 'alerts', label: 'Alerts Rail', required: false, maxItems: 1 },
+        ],
+        widgetSuggestions: [
+            { slot: 'status-cards', widgetType: 'form:user-context-summary', priority: 'primary' },
+            { slot: 'timeline-a', widgetType: 'praxis-chart', priority: 'primary' },
+            { slot: 'queue', widgetType: 'praxis-table', priority: 'primary' },
+        ],
+        devicePolicy: {
+            stacking: 'compress',
+            hideSecondaryContentOnMobile: true,
+            preferTabsOnMobile: true,
+        },
+    },
+};
+const BUILTIN_PAGE_THEME_PRESETS = {
+    'analytics-calm': {
+        id: 'analytics-calm',
+        label: 'Analytics Calm',
+        description: 'Superfícies leves, ênfase clara em dados e motion sutil.',
+        density: 'comfortable',
+        motion: 'subtle',
+    },
+    'workspace-balanced': {
+        id: 'workspace-balanced',
+        label: 'Workspace Balanced',
+        description: 'Equilíbrio entre densidade operacional e clareza visual.',
+        density: 'comfortable',
+        motion: 'subtle',
+    },
+    'ops-monitoring': {
+        id: 'ops-monitoring',
+        label: 'Ops Monitoring',
+        description: 'Contraste um pouco maior para leitura rápida de status, filas e alertas.',
+        density: 'compact',
+        motion: 'subtle',
+    },
+};
+
 class ConnectionManagerService {
     /** Extract value from an object using dot-path (e.g., 'payload.row.id'). */
     extractByPath(obj, path) {
@@ -15577,6 +17694,69 @@ class WidgetPageStateRuntimeService {
                 }
                 return omitted;
             }
+            case 'aggregate-array': {
+                const source = this.resolveNamedSource(options['source'], sources, env.state);
+                const metrics = Array.isArray(options['metrics']) ? options['metrics'] : [];
+                if (!Array.isArray(source))
+                    return {};
+                return this.aggregateArray(source, metrics);
+            }
+            case 'build-field-list': {
+                const source = this.resolveNamedSource(options['source'], sources, env.state);
+                const items = Array.isArray(options['items']) ? options['items'] : [];
+                return this.buildFieldList(source, items, env);
+            }
+            case 'group-top': {
+                const source = this.resolveNamedSource(options['source'], sources, env.state);
+                if (!Array.isArray(source))
+                    return [];
+                return this.groupTop(source, options);
+            }
+            case 'when-present': {
+                const source = this.resolveNamedSource(options['source'], sources, env.state);
+                if (source == null)
+                    return options['fallback'];
+                const text = String(source).trim();
+                if (!text)
+                    return options['fallback'];
+                return `${String(options['prefix'] || '')}${text}${String(options['suffix'] || '')}`;
+            }
+            case 'join-nonempty': {
+                const values = Array.isArray(options['paths'])
+                    ? options['paths'].map((path) => this.readPath(env.state, String(path)))
+                    : sources;
+                const parts = values
+                    .map((value) => value == null ? '' : String(value).trim())
+                    .filter((value) => value.length > 0);
+                if (!parts.length)
+                    return options['fallback'];
+                return parts.join(typeof options['delimiter'] === 'string' ? options['delimiter'] : ', ');
+            }
+            case 'format-value': {
+                const source = this.resolveNamedSource(options['source'], sources, env.state);
+                return this.formatFieldValue(source, options['format']);
+            }
+            case 'coalesce': {
+                const values = Array.isArray(options['paths'])
+                    ? options['paths'].map((path) => this.readPath(env.state, String(path)))
+                    : sources;
+                for (const value of values) {
+                    if (value == null)
+                        continue;
+                    if (typeof value === 'string' && !value.trim())
+                        continue;
+                    return value;
+                }
+                return options['fallback'];
+            }
+            case 'count-nonempty-entries': {
+                const source = this.resolveNamedSource(options['source'], sources, env.state);
+                if (!this.isPlainObject(source))
+                    return 0;
+                return Object.values(source).filter((value) => !this.isEmptyValue(value)).length;
+            }
+            case 'select-case':
+                return this.selectCase(options, env);
             case 'template':
                 return this.resolveTemplate(options['value'], env);
             default:
@@ -15593,6 +17773,145 @@ class WidgetPageStateRuntimeService {
     resolveSourceValues(paths, state) {
         return (paths || []).map((path) => this.readPath(state, path));
     }
+    aggregateArray(rows, metrics) {
+        const output = {};
+        for (const metric of metrics) {
+            const key = typeof metric?.['key'] === 'string' ? metric['key'].trim() : '';
+            const op = typeof metric?.['op'] === 'string' ? metric['op'].trim() : '';
+            if (!key || !op)
+                continue;
+            switch (op) {
+                case 'count':
+                    output[key] = rows.length;
+                    break;
+                case 'sum':
+                    output[key] = rows.reduce((sum, row) => sum + this.toNumber(this.readMetricValue(row, metric['field'])), 0);
+                    break;
+                case 'avg':
+                    output[key] = rows.length
+                        ? rows.reduce((sum, row) => sum + this.toNumber(this.readMetricValue(row, metric['field'])), 0) / rows.length
+                        : 0;
+                    break;
+                case 'distinct-count': {
+                    const values = rows
+                        .map((row) => this.readMetricValue(row, metric['field']))
+                        .filter((value) => value !== null && value !== undefined && String(value).trim() !== '');
+                    output[key] = new Set(values.map((value) => String(value))).size;
+                    break;
+                }
+            }
+        }
+        return output;
+    }
+    buildFieldList(source, items, env) {
+        const templateEnv = {
+            ...env,
+            source: this.clone(source),
+        };
+        return items.reduce((acc, item) => {
+            if (!item || typeof item !== 'object')
+                return acc;
+            const label = typeof item['labelTemplate'] === 'string'
+                ? this.resolveTemplate(item['labelTemplate'], templateEnv)
+                : this.resolveTemplate(item['label'] ?? '', templateEnv);
+            const rawValue = typeof item['valueTemplate'] === 'string'
+                ? this.resolveTemplate(item['valueTemplate'], templateEnv)
+                : this.readPath(source || {}, String(item['valuePath'] || '').trim());
+            const formattedValue = this.formatFieldValue(rawValue, item['format']);
+            acc.push({
+                label: typeof label === 'string' ? label : String(label ?? ''),
+                value: formattedValue,
+            });
+            return acc;
+        }, []);
+    }
+    groupTop(rows, options) {
+        const groupBy = typeof options['groupBy'] === 'string' ? options['groupBy'].trim() : '';
+        if (!groupBy)
+            return [];
+        const aggregate = typeof options['aggregate'] === 'string' ? options['aggregate'].trim() : 'count';
+        const field = typeof options['field'] === 'string' ? options['field'].trim() : '';
+        const limit = typeof options['limit'] === 'number' && options['limit'] > 0 ? Math.floor(options['limit']) : 5;
+        const totals = new Map();
+        for (const row of rows) {
+            const groupValue = this.readMetricValue(row, groupBy);
+            const key = String(groupValue ?? '').trim();
+            if (!key)
+                continue;
+            const amount = aggregate === 'sum'
+                ? this.toNumber(this.readMetricValue(row, field))
+                : 1;
+            totals.set(key, (totals.get(key) || 0) + amount);
+        }
+        return Array.from(totals.entries())
+            .sort((left, right) => right[1] - left[1])
+            .slice(0, limit)
+            .map(([value, total]) => ({
+            label: value,
+            value,
+            metric: this.formatFieldValue(total, options['metricFormat'] || 'integer'),
+        }));
+    }
+    selectCase(options, env) {
+        const cases = Array.isArray(options['cases']) ? options['cases'] : [];
+        for (const item of cases) {
+            if (!item || typeof item !== 'object')
+                continue;
+            if (!this.matchesCase(item['when'], env.state))
+                continue;
+            return this.resolveCaseValue(item, env);
+        }
+        return this.resolveCaseValue({
+            value: options['defaultValue'],
+            template: options['defaultTemplate'],
+            path: options['defaultPath'],
+        }, env);
+    }
+    matchesCase(condition, state) {
+        if (!condition || typeof condition !== 'object')
+            return false;
+        const path = typeof condition['path'] === 'string' ? condition['path'].trim() : '';
+        const value = path ? this.readPath(state, path) : undefined;
+        const compareValue = condition['comparePath']
+            ? this.readPath(state, String(condition['comparePath']).trim())
+            : condition['value'];
+        if ('equals' in condition)
+            return value === condition['equals'];
+        if ('notEquals' in condition)
+            return value !== condition['notEquals'];
+        if (condition['truthy'] === true)
+            return Boolean(value);
+        if (condition['falsy'] === true)
+            return !value;
+        if (condition['notEmpty'] === true)
+            return value != null && String(value).trim().length > 0;
+        if ('lt' in condition)
+            return this.toNumber(value) < this.toNumber(condition['lt']);
+        if ('lte' in condition)
+            return this.toNumber(value) <= this.toNumber(condition['lte']);
+        if ('gt' in condition)
+            return this.toNumber(value) > this.toNumber(condition['gt']);
+        if ('gte' in condition)
+            return this.toNumber(value) >= this.toNumber(condition['gte']);
+        if ('comparePath' in condition && 'op' in condition) {
+            switch (String(condition['op']).trim()) {
+                case 'lt': return this.toNumber(value) < this.toNumber(compareValue);
+                case 'lte': return this.toNumber(value) <= this.toNumber(compareValue);
+                case 'gt': return this.toNumber(value) > this.toNumber(compareValue);
+                case 'gte': return this.toNumber(value) >= this.toNumber(compareValue);
+                case 'equals': return value === compareValue;
+            }
+        }
+        return false;
+    }
+    resolveCaseValue(item, env) {
+        if ('path' in item && typeof item['path'] === 'string' && item['path'].trim()) {
+            return this.readPath(env.state, item['path'].trim());
+        }
+        if ('template' in item)
+            return this.resolveTemplate(item['template'], env);
+        return item['value'];
+    }
     resolveTemplate(node, env) {
         if (node == null)
             return node;
@@ -15626,6 +17945,65 @@ class WidgetPageStateRuntimeService {
     isEqual(left, right) {
         return JSON.stringify(left) === JSON.stringify(right);
     }
+    isEmptyValue(value) {
+        if (value == null)
+            return true;
+        if (typeof value === 'string')
+            return value.trim().length === 0;
+        if (Array.isArray(value))
+            return value.length === 0 || value.every((item) => this.isEmptyValue(item));
+        if (this.isPlainObject(value))
+            return Object.values(value).every((item) => this.isEmptyValue(item));
+        return false;
+    }
+    readMetricValue(row, field) {
+        if (typeof field !== 'string' || !field.trim())
+            return row;
+        return this.readPath(row || {}, field.trim());
+    }
+    toNumber(value) {
+        if (typeof value === 'number')
+            return Number.isFinite(value) ? value : 0;
+        if (typeof value === 'string' && value.trim()) {
+            const parsed = Number(value);
+            return Number.isFinite(parsed) ? parsed : 0;
+        }
+        return 0;
+    }
+    formatFieldValue(value, format) {
+        if (format == null)
+            return value == null ? '' : String(value);
+        const normalized = typeof format === 'string' ? { kind: format } : format;
+        const kind = typeof normalized?.kind === 'string' ? normalized.kind.trim() : '';
+        const locale = typeof normalized?.locale === 'string' && normalized.locale.trim() ? normalized.locale.trim() : 'pt-BR';
+        switch (kind) {
+            case 'integer':
+                return new Intl.NumberFormat(locale, {
+                    maximumFractionDigits: 0,
+                    minimumFractionDigits: 0,
+                }).format(this.toNumber(value));
+            case 'number':
+                return new Intl.NumberFormat(locale, {
+                    maximumFractionDigits: this.toNumber(normalized?.maximumFractionDigits),
+                    minimumFractionDigits: this.toNumber(normalized?.minimumFractionDigits),
+                }).format(this.toNumber(value));
+            case 'currency':
+                return new Intl.NumberFormat(locale, {
+                    style: 'currency',
+                    currency: typeof normalized?.currency === 'string' && normalized.currency.trim() ? normalized.currency.trim() : 'BRL',
+                    maximumFractionDigits: normalized?.maximumFractionDigits ?? 2,
+                    minimumFractionDigits: normalized?.minimumFractionDigits ?? 2,
+                }).format(this.toNumber(value));
+            case 'percent':
+                return new Intl.NumberFormat(locale, {
+                    style: 'percent',
+                    maximumFractionDigits: normalized?.maximumFractionDigits ?? 1,
+                    minimumFractionDigits: normalized?.minimumFractionDigits ?? 0,
+                }).format(this.toNumber(value));
+            default:
+                return value == null ? '' : String(value);
+        }
+    }
     clone(value) {
         if (value == null || typeof value !== 'object')
             return value;
@@ -15664,6 +18042,7 @@ class DynamicWidgetPageComponent {
     componentInstanceId;
     pageChange = new EventEmitter();
     widgets = signal([], ...(ngDevMode ? [{ debugName: "widgets" }] : []));
+    renderedGroups = signal([], ...(ngDevMode ? [{ debugName: "renderedGroups" }] : []));
     mergedContext = {};
     pageGap = '16px';
     gridTemplateColumns = 'minmax(0, 1fr)';
@@ -15677,6 +18056,9 @@ class DynamicWidgetPageComponent {
         diagnostics: [],
     };
     layout;
+    grouping = [];
+    pageColumnCount = 1;
+    activeTabs = {};
     appliedPersisted = false;
     isHydrating = false;
     persistenceReady = false;
@@ -15700,17 +18082,16 @@ class DynamicWidgetPageComponent {
     ngOnChanges(changes) {
         if (changes['page'] || changes['context'] || changes['enableCustomization']) {
             const parsed = this.parsePage(this.page);
-            this.pageDefinition = parsed ? { ...parsed, state: this.stateRuntime.normalizeState(parsed.state) } : parsed;
+            const resolvedPage = parsed ? this.resolvePagePresets(parsed) : parsed;
+            this.pageDefinition = resolvedPage ? { ...resolvedPage, state: this.stateRuntime.normalizeState(resolvedPage.state) } : resolvedPage;
             this.pageRuntime = this.buildStateRuntime(this.pageDefinition?.state, this.pageDefinition?.context);
             this.pageState = this.pageRuntime.state;
-            const rawWidgets = parsed?.widgets || [];
+            const rawWidgets = this.pageDefinition?.widgets || [];
             let widgets = this.applyEditShellActions(rawWidgets);
-            widgets = this.applyStateConnections(parsed?.connections, this.pageRuntime.effectiveValues, this.collectConnectedStatePaths(parsed?.connections), widgets);
+            widgets = this.applyStateConnections(this.pageDefinition?.connections, this.pageRuntime.effectiveValues, this.collectConnectedStatePaths(this.pageDefinition?.connections), widgets);
             this.pageDefinition = this.pageDefinition ? { ...this.pageDefinition, widgets } : this.pageDefinition;
             this.page = this.pageDefinition;
-            this.widgets.set(widgets);
-            this.mergedContext = this.mergeContext(parsed?.context, this.context, this.pageRuntime);
-            this.applyLayout(parsed?.layout);
+            this.applyResponsivePresentation(this.pageDefinition, widgets, this.pageRuntime);
             this.reportStateDiagnostics(this.pageRuntime.diagnostics);
         }
         if (this.autoPersist && (changes['pageIdentity'] || changes['componentInstanceId'])) {
@@ -15962,42 +18343,49 @@ class DynamicWidgetPageComponent {
     applyPageUpdate(next, persist = true, runtime = this.buildStateRuntime(next.state, next.context)) {
         const normalized = { ...next, state: runtime.state };
         const stateBoundWidgets = this.applyStateConnections(normalized.connections, runtime.effectiveValues, this.collectConnectedStatePaths(normalized.connections), normalized.widgets || []);
-        const hydrated = { ...normalized, widgets: stateBoundWidgets };
+        const hydrated = this.resolvePagePresets({ ...normalized, widgets: stateBoundWidgets });
         this.pageDefinition = hydrated;
         this.page = hydrated;
         this.pageState = runtime.state;
         this.pageRuntime = runtime;
-        this.widgets.set(this.applyEditShellActions(stateBoundWidgets));
-        this.mergedContext = this.mergeContext(hydrated.context, this.context, runtime);
-        this.applyLayout(hydrated.layout);
+        this.applyResponsivePresentation(hydrated, stateBoundWidgets, runtime);
         this.pageChange.emit(hydrated);
         this.reportStateDiagnostics(runtime.diagnostics);
         if (persist && this.autoPersist && !this.isHydrating) {
             this.savePage(hydrated);
         }
     }
-    applyLayout(layout) {
+    applyLayout(layout, grouping) {
         this.layout = layout;
+        this.grouping = grouping || [];
         const orientation = layout?.orientation || 'vertical';
         const columns = orientation === 'columns' ? this.resolveColumns(layout) : 1;
+        this.pageColumnCount = columns;
         this.gridTemplateColumns = `repeat(${columns}, minmax(0, 1fr))`;
         this.pageGap = layout?.gap || '16px';
     }
-    mergeContext(pageContext, inputContext, runtime) {
+    mergeContext(pageContext, inputContext, runtime, pageDefinition) {
         const baseContext = this.buildStateContext(pageContext);
+        const themePresetId = pageDefinition?.themePreset || '';
+        const themePreset = themePresetId ? BUILTIN_PAGE_THEME_PRESETS[themePresetId] : undefined;
+        const layoutPresetId = pageDefinition?.layoutPreset || '';
+        const layoutPreset = layoutPresetId ? BUILTIN_PAGE_LAYOUT_PRESETS[layoutPresetId] : undefined;
         return {
             ...baseContext,
             ...(inputContext || {}),
+            pageDeviceKind: this.resolveDeviceKind(),
+            pageLayoutPreset: layoutPreset || null,
+            pageThemePreset: themePreset || null,
+            pageGrouping: this.cloneGrouping(pageDefinition?.grouping),
             pageState: this.cloneStateValues(runtime.primaryValues),
             pageStateDerived: this.cloneStateValues(runtime.derivedValues),
             pageStateEffective: this.cloneStateValues(runtime.effectiveValues),
         };
     }
     onWindowResize() {
-        if (!this.layout || (this.layout.orientation || 'vertical') !== 'columns')
+        if (!this.pageDefinition)
             return;
-        const columns = this.resolveColumns(this.layout);
-        this.gridTemplateColumns = `repeat(${columns}, minmax(0, 1fr))`;
+        this.applyResponsivePresentation(this.pageDefinition, this.pageDefinition.widgets || [], this.pageRuntime);
     }
     resolveColumns(layout) {
         const base = Math.max(1, Number(layout?.columns) || 2);
@@ -16030,7 +18418,7 @@ class DynamicWidgetPageComponent {
             return this.pageDefinition;
         const parsed = this.parsePage(this.page);
         if (parsed)
-            return parsed;
+            return this.resolvePagePresets(parsed);
         return { widgets: this.widgets(), state: this.stateRuntime.normalizeState(this.pageState) };
     }
     parsePage(input) {
@@ -16046,6 +18434,217 @@ class DynamicWidgetPageComponent {
         }
         return input;
     }
+    resolvePagePresets(page) {
+        const preset = page.layoutPreset ? BUILTIN_PAGE_LAYOUT_PRESETS[page.layoutPreset] : undefined;
+        const themePresetId = page.themePreset || preset?.defaultThemePreset;
+        const mergedLayout = this.mergeLayout(preset?.defaultLayout, page.layout);
+        const grouping = (page.grouping && page.grouping.length ? page.grouping : preset?.defaultGrouping) || undefined;
+        return {
+            ...page,
+            layout: mergedLayout,
+            grouping,
+            themePreset: themePresetId,
+        };
+    }
+    mergeLayout(presetLayout, pageLayout) {
+        if (!presetLayout && !pageLayout)
+            return undefined;
+        return {
+            ...(presetLayout || {}),
+            ...(pageLayout || {}),
+            breakpoints: {
+                ...(presetLayout?.breakpoints || {}),
+                ...(pageLayout?.breakpoints || {}),
+            },
+        };
+    }
+    applyResponsivePresentation(pageDefinition, widgets, runtime) {
+        const effective = this.resolveEffectivePresentation(pageDefinition, widgets);
+        this.applyLayout(effective.layout, effective.grouping);
+        this.syncActiveTabs(effective.groups);
+        this.mergedContext = this.mergeContext(pageDefinition?.context, this.context, runtime, {
+            ...(pageDefinition || { widgets: [] }),
+            layout: effective.layout,
+            grouping: effective.grouping,
+        });
+        this.renderedGroups.set(effective.groups);
+        this.widgets.set(this.resolveShellTemplates(effective.widgets, runtime));
+    }
+    resolveEffectivePresentation(pageDefinition, widgets) {
+        const variant = this.resolveDeviceVariant(pageDefinition?.deviceLayouts);
+        const layout = this.mergeLayout(pageDefinition?.layout, variant?.layout);
+        const grouping = this.applyGroupingOverrides(pageDefinition?.grouping, variant?.groupingOverrides);
+        const widgetsWithOverrides = this.applyWidgetLayoutOverrides(this.applyEditShellActions(widgets), variant?.widgetOverrides);
+        const groups = this.buildRenderedGroups(grouping, widgetsWithOverrides);
+        return {
+            layout,
+            grouping,
+            widgets: widgetsWithOverrides,
+            groups,
+        };
+    }
+    resolveDeviceVariant(deviceLayouts) {
+        const kind = this.resolveDeviceKind();
+        if (kind === 'mobile')
+            return deviceLayouts?.mobile;
+        if (kind === 'tablet')
+            return deviceLayouts?.tablet;
+        return deviceLayouts?.desktop;
+    }
+    resolveDeviceKind() {
+        const width = typeof window !== 'undefined' ? window.innerWidth : 1440;
+        if (width < 768)
+            return 'mobile';
+        if (width < 1280)
+            return 'tablet';
+        return 'desktop';
+    }
+    applyWidgetLayoutOverrides(widgets, overrides) {
+        const rendered = widgets
+            .map((widget) => {
+            const override = overrides?.[widget.key];
+            if (override?.hidden)
+                return null;
+            const renderClassName = this.mergeClassNames(widget.className, override?.className);
+            return {
+                ...widget,
+                renderClassName,
+                renderSpan: override?.span,
+                __order: typeof override?.order === 'number' ? override.order : Number.MAX_SAFE_INTEGER,
+            };
+        })
+            .filter((widget) => !!widget)
+            .sort((left, right) => left.__order - right.__order);
+        return rendered.map(({ __order, ...widget }) => widget);
+    }
+    applyGroupingOverrides(grouping, overrides) {
+        if (!grouping?.length)
+            return grouping;
+        if (!overrides?.length)
+            return this.cloneGrouping(grouping);
+        const overridesById = new Map(overrides.map((item) => [item.id, item]));
+        return this.cloneGrouping(grouping)
+            .map((group) => {
+            const override = overridesById.get(group.id);
+            if (!override || override.hidden)
+                return override?.hidden ? null : group;
+            if (group.kind === 'tabs') {
+                return {
+                    ...group,
+                    tabs: override.tabs?.length ? override.tabs : group.tabs,
+                };
+            }
+            return {
+                ...group,
+                widgetKeys: override.widgetKeys?.length ? override.widgetKeys : group.widgetKeys,
+            };
+        })
+            .filter((group) => !!group);
+    }
+    buildRenderedGroups(grouping, widgets) {
+        if (!grouping?.length)
+            return [];
+        const widgetMap = new Map(widgets.map((widget) => [widget.key, widget]));
+        const usedKeys = new Set();
+        const groups = [];
+        for (const group of grouping) {
+            if (group.kind === 'tabs') {
+                const tabs = group.tabs
+                    .map((tab) => {
+                    const tabWidgets = tab.widgetKeys
+                        .map((key) => widgetMap.get(key))
+                        .filter((widget) => !!widget);
+                    for (const widget of tabWidgets)
+                        usedKeys.add(widget.key);
+                    return { id: tab.id, label: tab.label, widgets: tabWidgets };
+                })
+                    .filter((tab) => tab.widgets.length);
+                if (tabs.length) {
+                    groups.push({
+                        id: group.id,
+                        kind: 'tabs',
+                        label: group.label,
+                        widgets: [],
+                        tabs,
+                    });
+                }
+                continue;
+            }
+            const groupWidgets = group.widgetKeys
+                .map((key) => widgetMap.get(key))
+                .filter((widget) => !!widget);
+            for (const widget of groupWidgets)
+                usedKeys.add(widget.key);
+            if (!groupWidgets.length)
+                continue;
+            groups.push({
+                id: group.id,
+                kind: group.kind,
+                label: 'label' in group ? group.label : undefined,
+                layout: 'layout' in group ? group.layout : undefined,
+                emphasis: 'emphasis' in group ? group.emphasis : undefined,
+                side: 'side' in group ? group.side : undefined,
+                widgets: groupWidgets,
+            });
+        }
+        const ungrouped = widgets.filter((widget) => !usedKeys.has(widget.key));
+        if (ungrouped.length) {
+            groups.push({
+                id: 'ungrouped',
+                kind: 'ungrouped',
+                label: undefined,
+                layout: this.pageColumnCount > 1 ? 'grid' : 'stack',
+                widgets: ungrouped,
+            });
+        }
+        return groups;
+    }
+    syncActiveTabs(groups) {
+        const next = { ...this.activeTabs };
+        for (const group of groups) {
+            if (group.kind !== 'tabs' || !group.tabs?.length)
+                continue;
+            const current = next[group.id];
+            if (!current || !group.tabs.some((tab) => tab.id === current)) {
+                next[group.id] = group.tabs[0].id;
+            }
+        }
+        this.activeTabs = next;
+    }
+    activeTabId(groupId) {
+        return this.activeTabs[groupId] || '';
+    }
+    selectGroupTab(groupId, tabId) {
+        this.activeTabs = { ...this.activeTabs, [groupId]: tabId };
+    }
+    resolveGroupContentLayout(group) {
+        if (group.kind === 'hero')
+            return 'row';
+        if (group.kind === 'rail')
+            return 'stack';
+        return group.layout || (this.pageColumnCount > 1 ? 'grid' : 'stack');
+    }
+    groupGridColumn(group) {
+        if (group.kind === 'rail' && this.pageColumnCount > 1) {
+            return `${this.pageColumnCount} / span 1`;
+        }
+        return '1 / -1';
+    }
+    widgetGridColumn(widget) {
+        if (!widget.renderSpan || widget.renderSpan <= 1)
+            return null;
+        return `span ${widget.renderSpan}`;
+    }
+    widgetClassName(widget) {
+        return widget.renderClassName || widget.className || '';
+    }
+    mergeClassNames(...classNames) {
+        const merged = classNames
+            .flatMap((value) => (value || '').split(/\s+/))
+            .map((value) => value.trim())
+            .filter(Boolean);
+        return merged.length ? Array.from(new Set(merged)).join(' ') : undefined;
+    }
     applyEditShellActions(widgets) {
         if (!this.enableCustomization)
             return widgets;
@@ -16173,6 +18772,9 @@ class DynamicWidgetPageComponent {
     cloneStateValues(state) {
         return state ? JSON.parse(JSON.stringify(state)) : {};
     }
+    cloneGrouping(grouping) {
+        return grouping ? JSON.parse(JSON.stringify(grouping)) : [];
+    }
     collectConnectedStatePaths(connections) {
         return Array.from(new Set((connections || [])
             .filter((connection) => 'state' in connection.from)
@@ -16187,6 +18789,18 @@ class DynamicWidgetPageComponent {
             ...(this.context || {}),
         };
     }
+    resolveShellTemplates(widgets, runtime) {
+        const context = {
+            ...(this.mergedContext || {}),
+            state: this.cloneStateValues(runtime.effectiveValues),
+            pageState: this.cloneStateValues(runtime.primaryValues),
+            pageStateDerived: this.cloneStateValues(runtime.derivedValues),
+            pageStateEffective: this.cloneStateValues(runtime.effectiveValues),
+        };
+        return widgets.map((widget) => (widget.shell
+            ? { ...widget, shell: this.resolveTemplate(widget.shell, context) }
+            : widget));
+    }
     reportStateDiagnostics(diagnostics) {
         for (const diagnostic of diagnostics || []) {
             console.warn(`[DynamicWidgetPage] ${diagnostic}`);
@@ -16213,25 +18827,100 @@ class DynamicWidgetPageComponent {
         [style.gap]="pageGap"
         [style.gridTemplateColumns]="gridTemplateColumns"
       >
-        @for (w of widgets(); track w.key) {
-          <div class="pdx-widget" [class]="w.className || ''">
-            <praxis-widget-shell
-              [shell]="w.shell"
-              [context]="mergedContext"
-              (action)="onShellAction(w.key, $event)"
+        @if (renderedGroups().length) {
+          @for (group of renderedGroups(); track group.id) {
+            <section
+              class="pdx-group"
+              [class]="'pdx-group--' + group.kind + (group.layout ? ' pdx-group--layout-' + group.layout : '') + (group.emphasis ? ' pdx-group--emphasis-' + group.emphasis : '') + (group.side ? ' pdx-group--side-' + group.side : '')"
+              [style.gridColumn]="groupGridColumn(group)"
+              [attr.data-group-id]="group.id"
+              [attr.data-group-kind]="group.kind"
             >
-              <ng-container
-                [dynamicWidgetLoader]="w.definition"
+              @if (group.label) {
+                <header class="pdx-group-header">
+                  <div class="pdx-group-title">{{ group.label }}</div>
+                </header>
+              }
+              @if (group.kind === 'tabs') {
+                <div class="pdx-group-tabs">
+                  <div class="pdx-tabs-header">
+                    @for (tab of group.tabs || []; track tab.id) {
+                      <button
+                        class="pdx-tab-chip"
+                        type="button"
+                        [class.active]="activeTabId(group.id) === tab.id"
+                        (click)="selectGroupTab(group.id, tab.id)"
+                      >
+                        {{ tab.label || tab.id }}
+                      </button>
+                    }
+                  </div>
+                  @for (tab of group.tabs || []; track tab.id) {
+                    @if (activeTabId(group.id) === tab.id) {
+                      <div class="pdx-group-content" [class]="'pdx-group-content--' + resolveGroupContentLayout(group)">
+                        @for (w of tab.widgets; track w.key) {
+                          <div class="pdx-widget" [class]="w.renderClassName || w.className || ''" [style.gridColumn]="widgetGridColumn(w)">
+                            <praxis-widget-shell
+                              [shell]="w.shell"
+                              [context]="mergedContext"
+                              (action)="onShellAction(w.key, $event)"
+                            >
+                              <ng-container
+                                [dynamicWidgetLoader]="w.definition"
+                                [context]="mergedContext"
+                                [strictValidation]="strictValidation"
+                                (widgetEvent)="onWidgetEvent(w.key, $event)"
+                              ></ng-container>
+                            </praxis-widget-shell>
+                          </div>
+                        }
+                      </div>
+                    }
+                  }
+                </div>
+              } @else {
+                <div class="pdx-group-content" [class]="'pdx-group-content--' + resolveGroupContentLayout(group)">
+                  @for (w of group.widgets; track w.key) {
+                    <div class="pdx-widget" [class]="widgetClassName(w)" [style.gridColumn]="widgetGridColumn(w)">
+                      <praxis-widget-shell
+                        [shell]="w.shell"
+                        [context]="mergedContext"
+                        (action)="onShellAction(w.key, $event)"
+                      >
+                        <ng-container
+                          [dynamicWidgetLoader]="w.definition"
+                          [context]="mergedContext"
+                          [strictValidation]="strictValidation"
+                          (widgetEvent)="onWidgetEvent(w.key, $event)"
+                        ></ng-container>
+                      </praxis-widget-shell>
+                    </div>
+                  }
+                </div>
+              }
+            </section>
+          }
+        } @else {
+          @for (w of widgets(); track w.key) {
+            <div class="pdx-widget" [class]="widgetClassName(w)" [style.gridColumn]="widgetGridColumn(w)">
+              <praxis-widget-shell
+                [shell]="w.shell"
                 [context]="mergedContext"
-                [strictValidation]="strictValidation"
-                (widgetEvent)="onWidgetEvent(w.key, $event)"
-              ></ng-container>
-            </praxis-widget-shell>
-          </div>
+                (action)="onShellAction(w.key, $event)"
+              >
+                <ng-container
+                  [dynamicWidgetLoader]="w.definition"
+                  [context]="mergedContext"
+                  [strictValidation]="strictValidation"
+                  (widgetEvent)="onWidgetEvent(w.key, $event)"
+                ></ng-container>
+              </praxis-widget-shell>
+            </div>
+          }
         }
       </div>
     </div>
-  `, isInline: true, styles: [".pdx-page-wrapper{position:relative;display:block}.pdx-page{display:grid;gap:16px;grid-template-columns:minmax(0,1fr)}.pdx-page-settings{position:sticky;top:8px;z-index:2;border:1px solid var(--md-sys-color-outline-variant);background:var(--md-sys-color-surface-container-low);color:inherit;border-radius:999px;margin-bottom:8px}.pdx-widget{position:relative;background:var(--pfx-surface, transparent);border-radius:8px}.pdx-page-wrapper.editing .pdx-widget-settings{opacity:1}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i2.MatIconButton, selector: "button[mat-icon-button], a[mat-icon-button], button[matIconButton], a[matIconButton]", exportAs: ["matButton", "matAnchor"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i4.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "ngmodule", type: MatTooltipModule }, { kind: "directive", type: i5.MatTooltip, selector: "[matTooltip]", inputs: ["matTooltipPosition", "matTooltipPositionAtOrigin", "matTooltipDisabled", "matTooltipShowDelay", "matTooltipHideDelay", "matTooltipTouchGestures", "matTooltip", "matTooltipClass"], exportAs: ["matTooltip"] }, { kind: "directive", type: DynamicWidgetLoaderDirective, selector: "[dynamicWidgetLoader]", inputs: ["dynamicWidgetLoader", "context", "strictValidation", "autoWireOutputs"], outputs: ["widgetEvent"], exportAs: ["dynamicWidgetLoader"] }, { kind: "component", type: WidgetShellComponent, selector: "praxis-widget-shell", inputs: ["shell", "context"], outputs: ["action"] }] });
+  `, isInline: true, styles: [".pdx-page-wrapper{position:relative;display:block}.pdx-page{display:grid;gap:16px;grid-template-columns:minmax(0,1fr)}.pdx-page-settings{position:sticky;top:8px;z-index:2;border:1px solid var(--md-sys-color-outline-variant);background:var(--md-sys-color-surface-container-low);color:inherit;border-radius:999px;margin-bottom:8px}.pdx-widget{position:relative;background:var(--pfx-surface, transparent);border-radius:8px}.pdx-group{display:grid;gap:12px;grid-column:1 / -1;padding:12px;border-radius:16px;background:color-mix(in srgb,var(--md-sys-color-surface-container-low) 76%,transparent);border:1px solid color-mix(in srgb,var(--md-sys-color-outline-variant) 72%,transparent)}.pdx-group--hero{padding:16px;background:linear-gradient(180deg,color-mix(in srgb,var(--md-sys-color-primary-container) 42%,transparent),color-mix(in srgb,var(--md-sys-color-surface-container-low) 86%,transparent))}.pdx-group--rail{align-self:start}.pdx-group-header{display:flex;align-items:center;justify-content:space-between;gap:12px}.pdx-group-title{font-size:.95rem;font-weight:600;color:var(--md-sys-color-on-surface)}.pdx-group-content{display:grid;gap:12px}.pdx-group-content--stack{grid-template-columns:minmax(0,1fr)}.pdx-group-content--row{grid-template-columns:repeat(auto-fit,minmax(220px,1fr))}.pdx-group-content--grid{grid-template-columns:repeat(auto-fit,minmax(260px,1fr))}.pdx-group-tabs{display:grid;gap:12px}.pdx-tabs-header{display:flex;flex-wrap:wrap;gap:8px}.pdx-tab-chip{appearance:none;border:1px solid var(--md-sys-color-outline-variant);background:var(--md-sys-color-surface-container-lowest);color:var(--md-sys-color-on-surface);border-radius:999px;padding:8px 12px;font:inherit;cursor:pointer}.pdx-tab-chip.active{border-color:var(--md-sys-color-primary);background:color-mix(in srgb,var(--md-sys-color-primary-container) 78%,transparent);color:var(--md-sys-color-on-primary-container)}.pdx-page-wrapper.editing .pdx-widget-settings{opacity:1}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i2.MatIconButton, selector: "button[mat-icon-button], a[mat-icon-button], button[matIconButton], a[matIconButton]", exportAs: ["matButton", "matAnchor"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i4.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "ngmodule", type: MatTooltipModule }, { kind: "directive", type: i5$1.MatTooltip, selector: "[matTooltip]", inputs: ["matTooltipPosition", "matTooltipPositionAtOrigin", "matTooltipDisabled", "matTooltipShowDelay", "matTooltipHideDelay", "matTooltipTouchGestures", "matTooltip", "matTooltipClass"], exportAs: ["matTooltip"] }, { kind: "directive", type: DynamicWidgetLoaderDirective, selector: "[dynamicWidgetLoader]", inputs: ["dynamicWidgetLoader", "context", "strictValidation", "autoWireOutputs"], outputs: ["widgetEvent"], exportAs: ["dynamicWidgetLoader"] }, { kind: "component", type: WidgetShellComponent, selector: "praxis-widget-shell", inputs: ["shell", "context"], outputs: ["action"] }] });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: DynamicWidgetPageComponent, decorators: [{
             type: Component,
@@ -16255,25 +18944,100 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImpo
         [style.gap]="pageGap"
         [style.gridTemplateColumns]="gridTemplateColumns"
       >
-        @for (w of widgets(); track w.key) {
-          <div class="pdx-widget" [class]="w.className || ''">
-            <praxis-widget-shell
-              [shell]="w.shell"
-              [context]="mergedContext"
-              (action)="onShellAction(w.key, $event)"
+        @if (renderedGroups().length) {
+          @for (group of renderedGroups(); track group.id) {
+            <section
+              class="pdx-group"
+              [class]="'pdx-group--' + group.kind + (group.layout ? ' pdx-group--layout-' + group.layout : '') + (group.emphasis ? ' pdx-group--emphasis-' + group.emphasis : '') + (group.side ? ' pdx-group--side-' + group.side : '')"
+              [style.gridColumn]="groupGridColumn(group)"
+              [attr.data-group-id]="group.id"
+              [attr.data-group-kind]="group.kind"
             >
-              <ng-container
-                [dynamicWidgetLoader]="w.definition"
+              @if (group.label) {
+                <header class="pdx-group-header">
+                  <div class="pdx-group-title">{{ group.label }}</div>
+                </header>
+              }
+              @if (group.kind === 'tabs') {
+                <div class="pdx-group-tabs">
+                  <div class="pdx-tabs-header">
+                    @for (tab of group.tabs || []; track tab.id) {
+                      <button
+                        class="pdx-tab-chip"
+                        type="button"
+                        [class.active]="activeTabId(group.id) === tab.id"
+                        (click)="selectGroupTab(group.id, tab.id)"
+                      >
+                        {{ tab.label || tab.id }}
+                      </button>
+                    }
+                  </div>
+                  @for (tab of group.tabs || []; track tab.id) {
+                    @if (activeTabId(group.id) === tab.id) {
+                      <div class="pdx-group-content" [class]="'pdx-group-content--' + resolveGroupContentLayout(group)">
+                        @for (w of tab.widgets; track w.key) {
+                          <div class="pdx-widget" [class]="w.renderClassName || w.className || ''" [style.gridColumn]="widgetGridColumn(w)">
+                            <praxis-widget-shell
+                              [shell]="w.shell"
+                              [context]="mergedContext"
+                              (action)="onShellAction(w.key, $event)"
+                            >
+                              <ng-container
+                                [dynamicWidgetLoader]="w.definition"
+                                [context]="mergedContext"
+                                [strictValidation]="strictValidation"
+                                (widgetEvent)="onWidgetEvent(w.key, $event)"
+                              ></ng-container>
+                            </praxis-widget-shell>
+                          </div>
+                        }
+                      </div>
+                    }
+                  }
+                </div>
+              } @else {
+                <div class="pdx-group-content" [class]="'pdx-group-content--' + resolveGroupContentLayout(group)">
+                  @for (w of group.widgets; track w.key) {
+                    <div class="pdx-widget" [class]="widgetClassName(w)" [style.gridColumn]="widgetGridColumn(w)">
+                      <praxis-widget-shell
+                        [shell]="w.shell"
+                        [context]="mergedContext"
+                        (action)="onShellAction(w.key, $event)"
+                      >
+                        <ng-container
+                          [dynamicWidgetLoader]="w.definition"
+                          [context]="mergedContext"
+                          [strictValidation]="strictValidation"
+                          (widgetEvent)="onWidgetEvent(w.key, $event)"
+                        ></ng-container>
+                      </praxis-widget-shell>
+                    </div>
+                  }
+                </div>
+              }
+            </section>
+          }
+        } @else {
+          @for (w of widgets(); track w.key) {
+            <div class="pdx-widget" [class]="widgetClassName(w)" [style.gridColumn]="widgetGridColumn(w)">
+              <praxis-widget-shell
+                [shell]="w.shell"
                 [context]="mergedContext"
-                [strictValidation]="strictValidation"
-                (widgetEvent)="onWidgetEvent(w.key, $event)"
-              ></ng-container>
-            </praxis-widget-shell>
-          </div>
+                (action)="onShellAction(w.key, $event)"
+              >
+                <ng-container
+                  [dynamicWidgetLoader]="w.definition"
+                  [context]="mergedContext"
+                  [strictValidation]="strictValidation"
+                  (widgetEvent)="onWidgetEvent(w.key, $event)"
+                ></ng-container>
+              </praxis-widget-shell>
+            </div>
+          }
         }
       </div>
     </div>
-  `, styles: [".pdx-page-wrapper{position:relative;display:block}.pdx-page{display:grid;gap:16px;grid-template-columns:minmax(0,1fr)}.pdx-page-settings{position:sticky;top:8px;z-index:2;border:1px solid var(--md-sys-color-outline-variant);background:var(--md-sys-color-surface-container-low);color:inherit;border-radius:999px;margin-bottom:8px}.pdx-widget{position:relative;background:var(--pfx-surface, transparent);border-radius:8px}.pdx-page-wrapper.editing .pdx-widget-settings{opacity:1}\n"] }]
+  `, styles: [".pdx-page-wrapper{position:relative;display:block}.pdx-page{display:grid;gap:16px;grid-template-columns:minmax(0,1fr)}.pdx-page-settings{position:sticky;top:8px;z-index:2;border:1px solid var(--md-sys-color-outline-variant);background:var(--md-sys-color-surface-container-low);color:inherit;border-radius:999px;margin-bottom:8px}.pdx-widget{position:relative;background:var(--pfx-surface, transparent);border-radius:8px}.pdx-group{display:grid;gap:12px;grid-column:1 / -1;padding:12px;border-radius:16px;background:color-mix(in srgb,var(--md-sys-color-surface-container-low) 76%,transparent);border:1px solid color-mix(in srgb,var(--md-sys-color-outline-variant) 72%,transparent)}.pdx-group--hero{padding:16px;background:linear-gradient(180deg,color-mix(in srgb,var(--md-sys-color-primary-container) 42%,transparent),color-mix(in srgb,var(--md-sys-color-surface-container-low) 86%,transparent))}.pdx-group--rail{align-self:start}.pdx-group-header{display:flex;align-items:center;justify-content:space-between;gap:12px}.pdx-group-title{font-size:.95rem;font-weight:600;color:var(--md-sys-color-on-surface)}.pdx-group-content{display:grid;gap:12px}.pdx-group-content--stack{grid-template-columns:minmax(0,1fr)}.pdx-group-content--row{grid-template-columns:repeat(auto-fit,minmax(220px,1fr))}.pdx-group-content--grid{grid-template-columns:repeat(auto-fit,minmax(260px,1fr))}.pdx-group-tabs{display:grid;gap:12px}.pdx-tabs-header{display:flex;flex-wrap:wrap;gap:8px}.pdx-tab-chip{appearance:none;border:1px solid var(--md-sys-color-outline-variant);background:var(--md-sys-color-surface-container-lowest);color:var(--md-sys-color-on-surface);border-radius:999px;padding:8px 12px;font:inherit;cursor:pointer}.pdx-tab-chip.active{border-color:var(--md-sys-color-primary);background:color-mix(in srgb,var(--md-sys-color-primary-container) 78%,transparent);color:var(--md-sys-color-on-primary-container)}.pdx-page-wrapper.editing .pdx-widget-settings{opacity:1}\n"] }]
         }], ctorParameters: () => [{ type: ConnectionManagerService }, { type: WidgetPageStateRuntimeService }, { type: undefined, decorators: [{
                     type: Optional
                 }, {
@@ -16649,6 +19413,92 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImpo
                 type: Input
             }] } });
 
+class PraxisSurfaceHostComponent {
+    title;
+    subtitle;
+    icon;
+    widget;
+    context = null;
+    strictValidation = true;
+    /**
+     * Keep disabled by default to avoid duplicating the title already shown by
+     * modal/drawer hosts. Inline consumers may opt into rendering it again.
+     */
+    renderTitleInsideBody = false;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: PraxisSurfaceHostComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.3.17", type: PraxisSurfaceHostComponent, isStandalone: true, selector: "praxis-surface-host", inputs: { title: "title", subtitle: "subtitle", icon: "icon", widget: "widget", context: "context", strictValidation: "strictValidation", renderTitleInsideBody: "renderTitleInsideBody" }, ngImport: i0, template: `
+    <div class="pdx-surface-host">
+      @if (subtitle || (title && renderTitleInsideBody)) {
+        <header class="pdx-surface-host__header">
+          @if (icon) {
+            <span class="material-icons pdx-surface-host__icon" aria-hidden="true">{{ icon }}</span>
+          }
+          <div class="pdx-surface-host__copy">
+            @if (title && renderTitleInsideBody) {
+              <h2 class="pdx-surface-host__title">{{ title }}</h2>
+            }
+            @if (subtitle) {
+              <p class="pdx-surface-host__subtitle">{{ subtitle }}</p>
+            }
+          </div>
+        </header>
+      }
+
+      <section class="pdx-surface-host__body">
+        <ng-container
+          [dynamicWidgetLoader]="widget"
+          [context]="context"
+          [strictValidation]="strictValidation"
+        ></ng-container>
+      </section>
+    </div>
+  `, isInline: true, styles: [":host{display:block;min-width:0}.pdx-surface-host{display:grid;gap:16px;min-width:0}.pdx-surface-host__header{display:grid;grid-template-columns:auto 1fr;gap:12px;align-items:start}.pdx-surface-host__icon{font-size:20px;line-height:20px;color:var(--md-sys-color-primary, currentColor)}.pdx-surface-host__copy{display:grid;gap:4px;min-width:0}.pdx-surface-host__title,.pdx-surface-host__subtitle{margin:0}.pdx-surface-host__title{font-size:1rem;font-weight:600}.pdx-surface-host__subtitle{color:var(--md-sys-color-on-surface-variant, rgba(0, 0, 0, .64));font-size:.9375rem}.pdx-surface-host__body{min-width:0}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: DynamicWidgetLoaderDirective, selector: "[dynamicWidgetLoader]", inputs: ["dynamicWidgetLoader", "context", "strictValidation", "autoWireOutputs"], outputs: ["widgetEvent"], exportAs: ["dynamicWidgetLoader"] }] });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: PraxisSurfaceHostComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'praxis-surface-host', standalone: true, imports: [CommonModule, DynamicWidgetLoaderDirective], template: `
+    <div class="pdx-surface-host">
+      @if (subtitle || (title && renderTitleInsideBody)) {
+        <header class="pdx-surface-host__header">
+          @if (icon) {
+            <span class="material-icons pdx-surface-host__icon" aria-hidden="true">{{ icon }}</span>
+          }
+          <div class="pdx-surface-host__copy">
+            @if (title && renderTitleInsideBody) {
+              <h2 class="pdx-surface-host__title">{{ title }}</h2>
+            }
+            @if (subtitle) {
+              <p class="pdx-surface-host__subtitle">{{ subtitle }}</p>
+            }
+          </div>
+        </header>
+      }
+
+      <section class="pdx-surface-host__body">
+        <ng-container
+          [dynamicWidgetLoader]="widget"
+          [context]="context"
+          [strictValidation]="strictValidation"
+        ></ng-container>
+      </section>
+    </div>
+  `, styles: [":host{display:block;min-width:0}.pdx-surface-host{display:grid;gap:16px;min-width:0}.pdx-surface-host__header{display:grid;grid-template-columns:auto 1fr;gap:12px;align-items:start}.pdx-surface-host__icon{font-size:20px;line-height:20px;color:var(--md-sys-color-primary, currentColor)}.pdx-surface-host__copy{display:grid;gap:4px;min-width:0}.pdx-surface-host__title,.pdx-surface-host__subtitle{margin:0}.pdx-surface-host__title{font-size:1rem;font-weight:600}.pdx-surface-host__subtitle{color:var(--md-sys-color-on-surface-variant, rgba(0, 0, 0, .64));font-size:.9375rem}.pdx-surface-host__body{min-width:0}\n"] }]
+        }], propDecorators: { title: [{
+                type: Input
+            }], subtitle: [{
+                type: Input
+            }], icon: [{
+                type: Input
+            }], widget: [{
+                type: Input
+            }], context: [{
+                type: Input
+            }], strictValidation: [{
+                type: Input
+            }], renderTitleInsideBody: [{
+                type: Input
+            }] } });
+
 class EmptyStateCardComponent {
     icon = 'tab';
     title = 'Sem configuração disponível';
@@ -16686,7 +19536,7 @@ class EmptyStateCardComponent {
         </div>
       </mat-card-content>
     </mat-card>
-  `, isInline: true, styles: [".empty-card{display:block;margin:12px;border-color:var(--md-sys-color-outline-variant);--empty-icon-color: var(--md-sys-color-on-surface-variant)}.empty-card.empty-inline{margin:8px 0}.content{display:flex;align-items:center;gap:12px}.icon{font-size:32px;width:32px;height:32px;color:var(--empty-icon-color)}.texts{display:grid;gap:4px}.title{margin:0;font-size:16px;font-weight:600;color:var(--md-sys-color-on-surface)}.desc{margin:0;color:var(--md-sys-color-on-surface-variant)}.actions{display:flex;gap:8px;margin-top:12px;flex-wrap:wrap}.empty-card.tone-primary{--empty-icon-color: var(--md-sys-color-primary)}.empty-card.tone-secondary{--empty-icon-color: var(--md-sys-color-secondary)}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1$1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1$1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: MatCardModule }, { kind: "component", type: i3.MatCard, selector: "mat-card", inputs: ["appearance"], exportAs: ["matCard"] }, { kind: "directive", type: i3.MatCardContent, selector: "mat-card-content" }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i2.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: i4.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }] });
+  `, isInline: true, styles: [".empty-card{display:block;margin:12px;border-color:var(--md-sys-color-outline-variant);--empty-icon-color: var(--md-sys-color-on-surface-variant)}.empty-card.empty-inline{margin:8px 0}.content{display:flex;align-items:center;gap:12px}.icon{font-size:32px;width:32px;height:32px;color:var(--empty-icon-color)}.texts{display:grid;gap:4px}.title{margin:0;font-size:16px;font-weight:600;color:var(--md-sys-color-on-surface)}.desc{margin:0;color:var(--md-sys-color-on-surface-variant)}.actions{display:flex;gap:8px;margin-top:12px;flex-wrap:wrap}.empty-card.tone-primary{--empty-icon-color: var(--md-sys-color-primary)}.empty-card.tone-secondary{--empty-icon-color: var(--md-sys-color-secondary)}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1$2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1$2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: MatCardModule }, { kind: "component", type: i3$1.MatCard, selector: "mat-card", inputs: ["appearance"], exportAs: ["matCard"] }, { kind: "directive", type: i3$1.MatCardContent, selector: "mat-card-content" }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i2.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: i4.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }] });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: EmptyStateCardComponent, decorators: [{
             type: Component,
@@ -16791,7 +19641,7 @@ class ResourceQuickConnectComponent {
         Rota normalizada: {{ normalizedPath() }}
       </small>
     </div>
-  `, isInline: true, styles: [".pdx-quick-connect{display:grid;gap:12px;padding:12px;border-radius:12px;border:1px solid var(--md-sys-color-outline-variant);background:var(--md-sys-color-surface);color:var(--md-sys-color-on-surface)}.pdx-quick-connect__hint{color:var(--md-sys-color-on-surface-variant);font-size:.9rem}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1$1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i2$1.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i2$1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i2$1.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "ngmodule", type: MatFormFieldModule }, { kind: "component", type: i3$1.MatFormField, selector: "mat-form-field", inputs: ["hideRequiredMarker", "color", "floatLabel", "appearance", "subscriptSizing", "hintLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i3$1.MatLabel, selector: "mat-label" }, { kind: "directive", type: i3$1.MatError, selector: "mat-error, [matError]", inputs: ["id"] }, { kind: "directive", type: i3$1.MatSuffix, selector: "[matSuffix], [matIconSuffix], [matTextSuffix]", inputs: ["matTextSuffix"] }, { kind: "ngmodule", type: MatInputModule }, { kind: "directive", type: i4$2.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly", "disabledInteractive"], exportAs: ["matInput"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i4.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "directive", type: PraxisIconDirective, selector: "mat-icon[praxisIcon]", inputs: ["praxisIcon"] }] });
+  `, isInline: true, styles: [".pdx-quick-connect{display:grid;gap:12px;padding:12px;border-radius:12px;border:1px solid var(--md-sys-color-outline-variant);background:var(--md-sys-color-surface);color:var(--md-sys-color-on-surface)}.pdx-quick-connect__hint{color:var(--md-sys-color-on-surface-variant);font-size:.9rem}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1$2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i1$1.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i1$1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1$1.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "ngmodule", type: MatFormFieldModule }, { kind: "component", type: i3.MatFormField, selector: "mat-form-field", inputs: ["hideRequiredMarker", "color", "floatLabel", "appearance", "subscriptSizing", "hintLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i3.MatLabel, selector: "mat-label" }, { kind: "directive", type: i3.MatError, selector: "mat-error, [matError]", inputs: ["id"] }, { kind: "directive", type: i3.MatSuffix, selector: "[matSuffix], [matIconSuffix], [matTextSuffix]", inputs: ["matTextSuffix"] }, { kind: "ngmodule", type: MatInputModule }, { kind: "directive", type: i5.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly", "disabledInteractive"], exportAs: ["matInput"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i4.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "directive", type: PraxisIconDirective, selector: "mat-icon[praxisIcon]", inputs: ["praxisIcon"] }] });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: ResourceQuickConnectComponent, decorators: [{
             type: Component,
@@ -16961,7 +19811,7 @@ class PraxisIconPickerComponent {
             return { family: 'mss', name };
         return { family: 'mi', name };
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: PraxisIconPickerComponent, deps: [{ token: MAT_DIALOG_DATA, optional: true }, { token: i1$2.MatDialogRef, optional: true }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: PraxisIconPickerComponent, deps: [{ token: MAT_DIALOG_DATA, optional: true }, { token: i1$3.MatDialogRef, optional: true }], target: i0.ɵɵFactoryTarget.Component });
     static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.3.17", type: PraxisIconPickerComponent, isStandalone: true, selector: "praxis-icon-picker", inputs: { value: "value", icons: "icons" }, outputs: { selected: "selected", cancel: "cancel" }, host: { listeners: { "document:keydown.escape": "onEsc($event)", "document:keydown": "onGlobalKey($event)" } }, viewQueries: [{ propertyName: "searchInput", first: true, predicate: ["searchInput"], descendants: true }], ngImport: i0, template: `
   <div class="pip-root">
     <div class="pip-head">
@@ -17019,7 +19869,7 @@ class PraxisIconPickerComponent {
       <span class="pip-typed" *ngIf="query.trim()">{{ previewValue() }}</span>
     </div>
   </div>
-  `, isInline: true, styles: [".pip-root{display:flex;flex-direction:column;min-width:340px;max-width:760px;max-height:80vh;overflow:hidden;padding:16px;color:var(--md-sys-color-on-surface)}.pip-head{display:flex;gap:12px;align-items:center;margin-bottom:12px;flex-wrap:wrap}.pip-search{flex:1;min-width:180px}.pip-spacer{flex:1}.pip-body{flex:1;overflow:auto;display:grid;grid-template-columns:repeat(auto-fill,minmax(120px,1fr));gap:10px;padding:4px}.pip-item{display:flex;gap:10px;align-items:center;justify-content:flex-start;padding:10px;border:1px solid var(--md-sys-color-outline-variant);border-radius:10px;background:var(--md-sys-color-surface);color:inherit;cursor:pointer;transition:background-color .18s ease,border-color .18s ease,box-shadow .18s ease}.pip-item:hover{background:var(--md-sys-color-surface-container)}.pip-item:focus-visible{outline:2px solid var(--md-sys-color-primary);outline-offset:2px}.pip-item.selected{border-color:var(--md-sys-color-primary);box-shadow:0 0 0 2px var(--md-sys-color-primary)}.pip-name{font-size:12px;color:var(--md-sys-color-on-surface-variant);white-space:nowrap;text-overflow:ellipsis;overflow:hidden}.pip-hint{font-size:12px;color:var(--md-sys-color-on-surface-variant);margin:-6px 0 8px}.pip-stats{display:flex;justify-content:space-between;gap:8px;font-size:12px;color:var(--md-sys-color-on-surface-variant);margin-bottom:8px}.pip-shortcut{opacity:.9}.pip-empty{padding:12px;border:1px dashed var(--md-sys-color-outline-variant);border-radius:10px;color:var(--md-sys-color-on-surface-variant);background:var(--md-sys-color-surface-container);margin-top:8px}.pip-footer{display:flex;gap:12px;align-items:center;margin-top:10px}.pip-typed{font-family:ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,monospace;font-size:12px;color:var(--md-sys-color-on-surface)}.pip-family{display:flex;align-items:center}.pip-family .mat-mdc-chip-listbox{min-width:260px}.pip-root .mat-icon{font-family:Material Icons,Material Symbols Outlined,Material Symbols Rounded,Material Symbols Sharp!important;font-variation-settings:\"FILL\" 0,\"wght\" 400,\"GRAD\" 0,\"opsz\" 24;color:currentColor}.material-symbols-outlined{font-family:Material Symbols Outlined;font-weight:400;font-style:normal;font-size:24px;line-height:1;letter-spacing:normal;text-transform:none;display:inline-block;white-space:nowrap;word-wrap:normal;direction:ltr;-webkit-font-feature-settings:\"liga\";-webkit-font-smoothing:antialiased;font-variation-settings:\"FILL\" 0,\"wght\" 400,\"GRAD\" 0,\"opsz\" 24}.material-symbols-rounded{font-family:Material Symbols Rounded;font-weight:400;font-style:normal;font-size:24px;line-height:1;letter-spacing:normal;text-transform:none;display:inline-block;white-space:nowrap;word-wrap:normal;direction:ltr;-webkit-font-feature-settings:\"liga\";-webkit-font-smoothing:antialiased;font-variation-settings:\"FILL\" 0,\"wght\" 400,\"GRAD\" 0,\"opsz\" 24}.material-symbols-sharp{font-family:Material Symbols Sharp;font-weight:400;font-style:normal;font-size:24px;line-height:1;letter-spacing:normal;text-transform:none;display:inline-block;white-space:nowrap;word-wrap:normal;direction:ltr;-webkit-font-feature-settings:\"liga\";-webkit-font-smoothing:antialiased;font-variation-settings:\"FILL\" 0,\"wght\" 400,\"GRAD\" 0,\"opsz\" 24}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1$1.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i1$1.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1$1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i2$1.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i2$1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i2$1.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "ngmodule", type: MatFormFieldModule }, { kind: "component", type: i3$1.MatFormField, selector: "mat-form-field", inputs: ["hideRequiredMarker", "color", "floatLabel", "appearance", "subscriptSizing", "hintLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i3$1.MatLabel, selector: "mat-label" }, { kind: "ngmodule", type: MatInputModule }, { kind: "directive", type: i4$2.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly", "disabledInteractive"], exportAs: ["matInput"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i4.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i2.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: MatChipsModule }, { kind: "component", type: i8.MatChipListbox, selector: "mat-chip-listbox", inputs: ["multiple", "aria-orientation", "selectable", "compareWith", "required", "hideSingleSelectionIndicator", "value"], outputs: ["change"] }, { kind: "component", type: i8.MatChipOption, selector: "mat-basic-chip-option, [mat-basic-chip-option], mat-chip-option, [mat-chip-option]", inputs: ["selectable", "selected"], outputs: ["selectionChange"] }, { kind: "ngmodule", type: MatDialogModule }, { kind: "ngmodule", type: MatTooltipModule }, { kind: "directive", type: i5.MatTooltip, selector: "[matTooltip]", inputs: ["matTooltipPosition", "matTooltipPositionAtOrigin", "matTooltipDisabled", "matTooltipShowDelay", "matTooltipHideDelay", "matTooltipTouchGestures", "matTooltip", "matTooltipClass"], exportAs: ["matTooltip"] }] });
+  `, isInline: true, styles: [".pip-root{display:flex;flex-direction:column;min-width:340px;max-width:760px;max-height:80vh;overflow:hidden;padding:16px;color:var(--md-sys-color-on-surface)}.pip-head{display:flex;gap:12px;align-items:center;margin-bottom:12px;flex-wrap:wrap}.pip-search{flex:1;min-width:180px}.pip-spacer{flex:1}.pip-body{flex:1;overflow:auto;display:grid;grid-template-columns:repeat(auto-fill,minmax(120px,1fr));gap:10px;padding:4px}.pip-item{display:flex;gap:10px;align-items:center;justify-content:flex-start;padding:10px;border:1px solid var(--md-sys-color-outline-variant);border-radius:10px;background:var(--md-sys-color-surface);color:inherit;cursor:pointer;transition:background-color .18s ease,border-color .18s ease,box-shadow .18s ease}.pip-item:hover{background:var(--md-sys-color-surface-container)}.pip-item:focus-visible{outline:2px solid var(--md-sys-color-primary);outline-offset:2px}.pip-item.selected{border-color:var(--md-sys-color-primary);box-shadow:0 0 0 2px var(--md-sys-color-primary)}.pip-name{font-size:12px;color:var(--md-sys-color-on-surface-variant);white-space:nowrap;text-overflow:ellipsis;overflow:hidden}.pip-hint{font-size:12px;color:var(--md-sys-color-on-surface-variant);margin:-6px 0 8px}.pip-stats{display:flex;justify-content:space-between;gap:8px;font-size:12px;color:var(--md-sys-color-on-surface-variant);margin-bottom:8px}.pip-shortcut{opacity:.9}.pip-empty{padding:12px;border:1px dashed var(--md-sys-color-outline-variant);border-radius:10px;color:var(--md-sys-color-on-surface-variant);background:var(--md-sys-color-surface-container);margin-top:8px}.pip-footer{display:flex;gap:12px;align-items:center;margin-top:10px}.pip-typed{font-family:ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,monospace;font-size:12px;color:var(--md-sys-color-on-surface)}.pip-family{display:flex;align-items:center}.pip-family .mat-mdc-chip-listbox{min-width:260px}.pip-root .mat-icon{font-family:Material Icons,Material Symbols Outlined,Material Symbols Rounded,Material Symbols Sharp!important;font-variation-settings:\"FILL\" 0,\"wght\" 400,\"GRAD\" 0,\"opsz\" 24;color:currentColor}.material-symbols-outlined{font-family:Material Symbols Outlined;font-weight:400;font-style:normal;font-size:24px;line-height:1;letter-spacing:normal;text-transform:none;display:inline-block;white-space:nowrap;word-wrap:normal;direction:ltr;-webkit-font-feature-settings:\"liga\";-webkit-font-smoothing:antialiased;font-variation-settings:\"FILL\" 0,\"wght\" 400,\"GRAD\" 0,\"opsz\" 24}.material-symbols-rounded{font-family:Material Symbols Rounded;font-weight:400;font-style:normal;font-size:24px;line-height:1;letter-spacing:normal;text-transform:none;display:inline-block;white-space:nowrap;word-wrap:normal;direction:ltr;-webkit-font-feature-settings:\"liga\";-webkit-font-smoothing:antialiased;font-variation-settings:\"FILL\" 0,\"wght\" 400,\"GRAD\" 0,\"opsz\" 24}.material-symbols-sharp{font-family:Material Symbols Sharp;font-weight:400;font-style:normal;font-size:24px;line-height:1;letter-spacing:normal;text-transform:none;display:inline-block;white-space:nowrap;word-wrap:normal;direction:ltr;-webkit-font-feature-settings:\"liga\";-webkit-font-smoothing:antialiased;font-variation-settings:\"FILL\" 0,\"wght\" 400,\"GRAD\" 0,\"opsz\" 24}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1$2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { kind: "directive", type: i1$2.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i1$2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: FormsModule }, { kind: "directive", type: i1$1.DefaultValueAccessor, selector: "input:not([type=checkbox])[formControlName],textarea[formControlName],input:not([type=checkbox])[formControl],textarea[formControl],input:not([type=checkbox])[ngModel],textarea[ngModel],[ngDefaultControl]" }, { kind: "directive", type: i1$1.NgControlStatus, selector: "[formControlName],[ngModel],[formControl]" }, { kind: "directive", type: i1$1.NgModel, selector: "[ngModel]:not([formControlName]):not([formControl])", inputs: ["name", "disabled", "ngModel", "ngModelOptions"], outputs: ["ngModelChange"], exportAs: ["ngModel"] }, { kind: "ngmodule", type: MatFormFieldModule }, { kind: "component", type: i3.MatFormField, selector: "mat-form-field", inputs: ["hideRequiredMarker", "color", "floatLabel", "appearance", "subscriptSizing", "hintLabel"], exportAs: ["matFormField"] }, { kind: "directive", type: i3.MatLabel, selector: "mat-label" }, { kind: "ngmodule", type: MatInputModule }, { kind: "directive", type: i5.MatInput, selector: "input[matInput], textarea[matInput], select[matNativeControl],      input[matNativeControl], textarea[matNativeControl]", inputs: ["disabled", "id", "placeholder", "name", "required", "type", "errorStateMatcher", "aria-describedby", "value", "readonly", "disabledInteractive"], exportAs: ["matInput"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i4.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i2.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: MatChipsModule }, { kind: "component", type: i8.MatChipListbox, selector: "mat-chip-listbox", inputs: ["multiple", "aria-orientation", "selectable", "compareWith", "required", "hideSingleSelectionIndicator", "value"], outputs: ["change"] }, { kind: "component", type: i8.MatChipOption, selector: "mat-basic-chip-option, [mat-basic-chip-option], mat-chip-option, [mat-chip-option]", inputs: ["selectable", "selected"], outputs: ["selectionChange"] }, { kind: "ngmodule", type: MatDialogModule }, { kind: "ngmodule", type: MatTooltipModule }, { kind: "directive", type: i5$1.MatTooltip, selector: "[matTooltip]", inputs: ["matTooltipPosition", "matTooltipPositionAtOrigin", "matTooltipDisabled", "matTooltipShowDelay", "matTooltipHideDelay", "matTooltipTouchGestures", "matTooltip", "matTooltipClass"], exportAs: ["matTooltip"] }] });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: PraxisIconPickerComponent, decorators: [{
             type: Component,
@@ -17086,7 +19936,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImpo
                 }, {
                     type: Inject,
                     args: [MAT_DIALOG_DATA]
-                }] }, { type: i1$2.MatDialogRef, decorators: [{
+                }] }, { type: i1$3.MatDialogRef, decorators: [{
                     type: Optional
                 }] }], propDecorators: { value: [{
                 type: Input
@@ -17363,7 +20213,7 @@ class SchemaViewerComponent {
         </mat-tab-group>
       </mat-card-content>
     </mat-card>
-  `, isInline: true, styles: [".schema-viewer{display:block;border-color:var(--md-sys-color-outline-variant)}.header{display:flex;align-items:center;justify-content:space-between;gap:8px}.title{display:flex;align-items:center;gap:8px}.title h3{margin:0;font-weight:600;color:var(--md-sys-color-on-surface)}.notes{margin-top:6px;color:var(--md-sys-color-on-surface-variant);font-size:12px}.copy-status{margin-top:6px;font-size:12px;color:var(--md-sys-color-primary)}.section{padding:12px}.section-actions{display:flex;justify-content:flex-end;margin-bottom:8px}.sub{font-weight:600;margin:12px 0 4px;color:var(--md-sys-color-on-surface)}.pretty{background:var(--md-sys-color-surface-container);padding:10px;border-radius:8px;overflow:auto;border:1px solid var(--md-sys-color-outline-variant)}.kv{display:grid;grid-template-columns:140px 1fr;align-items:baseline;gap:8px;margin:2px 0}.kv>span{color:var(--md-sys-color-on-surface-variant)}.kv>code{font-family:ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,monospace}.muted{color:var(--md-sys-color-on-surface-variant)}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1$1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: MatTabsModule }, { kind: "component", type: i2$2.MatTab, selector: "mat-tab", inputs: ["disabled", "label", "aria-label", "aria-labelledby", "labelClass", "bodyClass", "id"], exportAs: ["matTab"] }, { kind: "component", type: i2$2.MatTabGroup, selector: "mat-tab-group", inputs: ["color", "fitInkBarToContent", "mat-stretch-tabs", "mat-align-tabs", "dynamicHeight", "selectedIndex", "headerPosition", "animationDuration", "contentTabIndex", "disablePagination", "disableRipple", "preserveContent", "backgroundColor", "aria-label", "aria-labelledby"], outputs: ["selectedIndexChange", "focusChange", "animationDone", "selectedTabChange"], exportAs: ["matTabGroup"] }, { kind: "ngmodule", type: MatCardModule }, { kind: "component", type: i3.MatCard, selector: "mat-card", inputs: ["appearance"], exportAs: ["matCard"] }, { kind: "directive", type: i3.MatCardContent, selector: "mat-card-content" }, { kind: "component", type: i3.MatCardHeader, selector: "mat-card-header" }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i2.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: i4.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "pipe", type: i1$1.JsonPipe, name: "json" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+  `, isInline: true, styles: [".schema-viewer{display:block;border-color:var(--md-sys-color-outline-variant)}.header{display:flex;align-items:center;justify-content:space-between;gap:8px}.title{display:flex;align-items:center;gap:8px}.title h3{margin:0;font-weight:600;color:var(--md-sys-color-on-surface)}.notes{margin-top:6px;color:var(--md-sys-color-on-surface-variant);font-size:12px}.copy-status{margin-top:6px;font-size:12px;color:var(--md-sys-color-primary)}.section{padding:12px}.section-actions{display:flex;justify-content:flex-end;margin-bottom:8px}.sub{font-weight:600;margin:12px 0 4px;color:var(--md-sys-color-on-surface)}.pretty{background:var(--md-sys-color-surface-container);padding:10px;border-radius:8px;overflow:auto;border:1px solid var(--md-sys-color-outline-variant)}.kv{display:grid;grid-template-columns:140px 1fr;align-items:baseline;gap:8px;margin:2px 0}.kv>span{color:var(--md-sys-color-on-surface-variant)}.kv>code{font-family:ui-monospace,SFMono-Regular,Menlo,Monaco,Consolas,Liberation Mono,Courier New,monospace}.muted{color:var(--md-sys-color-on-surface-variant)}\n"], dependencies: [{ kind: "ngmodule", type: CommonModule }, { kind: "directive", type: i1$2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: MatTabsModule }, { kind: "component", type: i2$1.MatTab, selector: "mat-tab", inputs: ["disabled", "label", "aria-label", "aria-labelledby", "labelClass", "bodyClass", "id"], exportAs: ["matTab"] }, { kind: "component", type: i2$1.MatTabGroup, selector: "mat-tab-group", inputs: ["color", "fitInkBarToContent", "mat-stretch-tabs", "mat-align-tabs", "dynamicHeight", "selectedIndex", "headerPosition", "animationDuration", "contentTabIndex", "disablePagination", "disableRipple", "preserveContent", "backgroundColor", "aria-label", "aria-labelledby"], outputs: ["selectedIndexChange", "focusChange", "animationDone", "selectedTabChange"], exportAs: ["matTabGroup"] }, { kind: "ngmodule", type: MatCardModule }, { kind: "component", type: i3$1.MatCard, selector: "mat-card", inputs: ["appearance"], exportAs: ["matCard"] }, { kind: "directive", type: i3$1.MatCardContent, selector: "mat-card-content" }, { kind: "component", type: i3$1.MatCardHeader, selector: "mat-card-header" }, { kind: "ngmodule", type: MatButtonModule }, { kind: "component", type: i2.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: i4.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "pipe", type: i1$2.JsonPipe, name: "json" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: SchemaViewerComponent, decorators: [{
             type: Component,
@@ -18129,5 +20979,5 @@ function provideHookWhitelist(allowed) {
  * Generated bundle index. Do not edit.
  */
 
-export { API_CONFIG_STORAGE_OPTIONS, API_URL, ASYNC_CONFIG_STORAGE, AllowedFileTypes, ApiConfigStorage, ApiEndpoint, BUILTIN_SHELL_PRESETS, CONFIG_STORAGE, CONNECTION_STORAGE, ComponentKeyService, ComponentMetadataRegistry, ConnectionManagerService, ConsoleLoggerSink, DEFAULT_FIELD_SELECTOR_CONTROL_TYPE_MAP, DEFAULT_TABLE_CONFIG, DYNAMIC_PAGE_AI_CAPABILITIES, DYNAMIC_PAGE_COMPONENT_CONTEXT_PACK, DYNAMIC_PAGE_CONFIG_EDITOR, DYNAMIC_PAGE_SHELL_EDITOR, DefaultLoadingRenderer, DeferredAsyncConfigStorage, DynamicFormService, DynamicGridPageComponent, DynamicWidgetLoaderDirective, DynamicWidgetPageComponent, EDITORIAL_ALLOWED_CONTENT_FORMATS, EDITORIAL_COMPLIANCE_PRESETS, EDITORIAL_EXTERNAL_LINK_REL, EDITORIAL_FORM_TEMPLATE_CATALOG, EDITORIAL_HTML_ENABLED, EDITORIAL_MARKDOWN_IMAGES_ENABLED, EDITORIAL_SOLUTION_CATALOG, EDITORIAL_SOLUTION_PRESETS, EDITORIAL_THEME_PRESETS, EDITORIAL_WIDGET_CONVENTION_INPUTS, EDITORIAL_WIDGET_TAG, EMPLOYEE_ONBOARDING_EDITORIAL_SOLUTION, EMPLOYEE_ONBOARDING_EDITORIAL_TEMPLATE, EMPLOYEE_ONBOARDING_GUIDED_EDITORIAL_SOLUTION, EMPLOYEE_ONBOARDING_GUIDED_EDITORIAL_TEMPLATE, EVENT_REGISTRATION_EDITORIAL_SOLUTION, EVENT_REGISTRATION_EDITORIAL_TEMPLATE, EmptyStateCardComponent, ErrorMessageService, FIELD_METADATA_CAPABILITIES, FIELD_SELECTOR_REGISTRY_BASE, FIELD_SELECTOR_REGISTRY_DISABLE_DEFAULTS, FIELD_SELECTOR_REGISTRY_OVERRIDES, FORM_HOOKS, FORM_HOOKS_PRESETS, FORM_HOOKS_WHITELIST, FORM_HOOK_RESOLVERS, FieldControlType, FieldDataType, FieldSelectorRegistry, FormHooksRegistry, GLOBAL_ACTION_CATALOG$1 as GLOBAL_ACTION_CATALOG, GLOBAL_ACTION_HANDLERS, GLOBAL_ACTION_CATALOG as GLOBAL_ACTION_SPEC_CATALOG, GLOBAL_ACTION_UI_SCHEMAS, GLOBAL_ANALYTICS_SERVICE, GLOBAL_API_CLIENT, GLOBAL_CONFIG, GLOBAL_DIALOG_SERVICE, GLOBAL_ROUTE_GUARD_RESOLVER, GLOBAL_TOAST_SERVICE, GenericCrudService, GlobalActionService, GlobalConfigService, INLINE_FILTER_ALIAS_TOKENS, INLINE_FILTER_CONTROL_TYPES, INLINE_FILTER_CONTROL_TYPE_SET, INLINE_FILTER_CONTROL_TYPE_VALUES, INLINE_FILTER_TOKEN_TO_BASE_CONTROL_TYPE, INLINE_FILTER_TOKEN_TO_CONTROL_TYPE, IconPickerService, IconPosition, IconSize, LOGGER_LEVEL_BY_ENV, LOGGER_LEVEL_PRIORITY, LoadingOrchestrator, LocalConnectionStorage, LocalStorageAsyncAdapter, LocalStorageCacheAdapter, LocalStorageConfigService, LoggerService, LoggerThrottleTracker, LoggerWarnOnceTracker, MemoryCacheAdapter, NumericFormat, OVERLAY_DECIDER_DEBUG, OVERLAY_DECISION_MATRIX, ObservabilityDashboardService, OverlayDeciderService, PRAXIS_CORPORATE_SENSITIVE_KEYS, PRAXIS_DEFAULT_OBSERVABILITY_ALERT_RULES, PRAXIS_DYNAMIC_PAGE_COMPONENT_METADATA, PRAXIS_FOOTER_LINKS_METADATA, PRAXIS_GLOBAL_ACTION_CATALOG, PRAXIS_GLOBAL_CONFIG_BOOTSTRAP_OPTIONS, PRAXIS_GLOBAL_CONFIG_BOOTSTRAP_READY, PRAXIS_GLOBAL_CONFIG_TENANT_RESOLVER, PRAXIS_HERO_BANNER_METADATA, PRAXIS_I18N_CONFIG, PRAXIS_I18N_TRANSLATOR, PRAXIS_LEGAL_NOTICE_METADATA, PRAXIS_LOADING_CTX, PRAXIS_LOADING_RENDERER, PRAXIS_LOGGER_CONFIG, PRAXIS_LOGGER_SINKS, PRAXIS_OBSERVABILITY_DASHBOARD_OPTIONS, PRAXIS_RICH_TEXT_BLOCK_METADATA, PRAXIS_TELEMETRY_TRANSPORT, PRAXIS_USER_CONTEXT_SUMMARY_METADATA, PRIVACY_CONSENT_EDITORIAL_SOLUTION, PRIVACY_CONSENT_EDITORIAL_TEMPLATE, PraxisCore, PraxisFooterLinksComponent, PraxisGlobalErrorHandler, PraxisHeroBannerComponent, PraxisI18nService, PraxisIconDirective, PraxisIconPickerComponent, PraxisLegalNoticeComponent, PraxisLoadingInterceptor, PraxisRichTextBlockComponent, PraxisUserContextSummaryComponent, RULE_PROPERTY_SCHEMA, RemoteConfigStorage, ResourceQuickConnectComponent, SCHEMA_VIEWER_CONTEXT, SETTINGS_PANEL_BRIDGE, SETTINGS_PANEL_DATA, STEPPER_CONFIG_EDITOR, SchemaMetadataClient, SchemaNormalizerService, SchemaViewerComponent, TABLE_CONFIG_EDITOR, TableConfigService, TelemetryLoggerSink, TelemetryService, ValidationPattern, WidgetPageStateRuntimeService, WidgetShellComponent, applyLocalCustomizations$2 as applyLocalCustomizations, applyLocalCustomizations$1 as applyLocalFormCustomizations, buildAngularValidators, buildApiUrl, buildBaseColumnFromDef, buildBaseFormField, buildFormConfigFromEditorialTemplate, buildHeaders, buildPageKey, buildSchemaId, buildValidatorsFromValidatorOptions, cancelIfCpfInvalidHook, clampRange, cloneTableConfig, cnpjAlphaValidator, collapseWhitespace, composeHeadersWithVersion, conditionalAsyncValidator, convertFormLayoutToConfig, createCorporateLoggerConfig, createCorporateObservabilityOptions, createCpfCnpjValidator, createDefaultFormConfig, createDefaultTableConfig, createEmptyFormConfig, createPersistedPage, customAsyncValidatorFn, customValidatorFn, debounceAsyncValidator, deepMerge, ensureIds, ensureNoConflictsHookFactory, ensurePageIds, extractNormalizedError, fetchWithETag, fileTypeValidator, fillUndefined, generateId, getDefaultFormHints, getEditorialCompliancePresetById, getEditorialFormTemplateById, getEditorialFormTemplateCatalog, getEditorialSolutionById, getEditorialSolutionCatalog, getEditorialSolutionPresetById, getEditorialThemePresetById, getEssentialConfig, getFieldMetadataCapabilities, getGlobalActionCatalog, getGlobalActionUiSchema, getReferencedFieldMetadata, getTextTransformer, interpolatePraxisTranslation, isAllowedEditorialContentFormat, isAllowedEditorialHref, isCssTextTransform, isEditorialComponentMeta, isInlineFilterControlType, isRangeValidForFilter, isTableConfigV2, isValidFormConfig, isValidTableConfig, legacyCnpjValidator, legacyCpfValidator, logOnErrorHook, mapFieldDefinitionToMetadata, mapFieldDefinitionsToMetadata, matchFieldValidator, maxFileSizeValidator, mergeFieldMetadata, mergePraxisI18nConfigs, mergeTableConfigs, migrateFormLayoutRule, minWordsValidator, normalizeControlTypeKey, normalizeControlTypeToken, normalizeEditorialLink, normalizeEnd, normalizeFieldConstraints, normalizeFormConfig, normalizeFormMetadata, normalizePath, normalizeStart, normalizeUnknownError, notifySuccessHook, parseJsonResponseOrEmpty, praxisLoadingInterceptorFn, prefillFromContextHook, provideDefaultFormHooks, provideFieldSelectorRegistryBase, provideFieldSelectorRegistryOverride, provideFieldSelectorRegistryRuntime, provideFormHookPresets, provideFormHooks, provideGlobalActionCatalog, provideGlobalActionHandler, provideGlobalConfig, provideGlobalConfigReady, provideGlobalConfigSeed, provideGlobalConfigTenant, provideHookResolvers, provideHookWhitelist, provideOverlayDecisionMatrix, providePraxisAnalyticsGlobalActions, providePraxisDynamicPageMetadata, providePraxisFooterLinksMetadata, providePraxisGlobalActionCatalog, providePraxisGlobalActions, providePraxisGlobalConfigBootstrap, providePraxisHeroBannerMetadata, providePraxisHttpLoading, providePraxisI18n, providePraxisI18nConfig, providePraxisI18nTranslator, providePraxisLegalNoticeMetadata, providePraxisLoadingDefaults, providePraxisLogging, providePraxisRichTextBlockMetadata, providePraxisToastGlobalActions, providePraxisUserContextSummaryMetadata, provideRemoteGlobalConfig, reconcileFilterConfig, reconcileFormConfig, reconcileTableConfig, removeDiacritics, reportTelemetryHookFactory, requiredCheckedValidator, resolveBuiltinPresets, resolveControlTypeAlias, resolveHidden, resolveInlineFilterControlType, resolveInlineFilterControlTypeToBaseControlType, resolveLoggerConfig, resolveObservabilityOptions, resolveOffset, resolveOrder, resolveSpan, slugify, stripMasksHook, syncWithServerMetadata, toCamel, toCapitalize, toKebab, toPascal, toSentenceCase, toSnake, toTitleCase, trim, uniqueAsyncValidator, urlValidator, withMessage, withPraxisHttpLoading };
+export { API_CONFIG_STORAGE_OPTIONS, API_URL, ASYNC_CONFIG_STORAGE, AllowedFileTypes, ApiConfigStorage, ApiEndpoint, BUILTIN_PAGE_LAYOUT_PRESETS, BUILTIN_PAGE_THEME_PRESETS, BUILTIN_SHELL_PRESETS, CONFIG_STORAGE, CONNECTION_STORAGE, ComponentKeyService, ComponentMetadataRegistry, ConnectionManagerService, ConsoleLoggerSink, DEFAULT_FIELD_SELECTOR_CONTROL_TYPE_MAP, DEFAULT_TABLE_CONFIG, DYNAMIC_PAGE_AI_CAPABILITIES, DYNAMIC_PAGE_COMPONENT_CONTEXT_PACK, DYNAMIC_PAGE_CONFIG_EDITOR, DYNAMIC_PAGE_SHELL_EDITOR, DefaultLoadingRenderer, DeferredAsyncConfigStorage, DynamicFormService, DynamicGridPageComponent, DynamicWidgetLoaderDirective, DynamicWidgetPageComponent, EDITORIAL_ALLOWED_CONTENT_FORMATS, EDITORIAL_COMPLIANCE_PRESETS, EDITORIAL_EXTERNAL_LINK_REL, EDITORIAL_FORM_TEMPLATE_CATALOG, EDITORIAL_HTML_ENABLED, EDITORIAL_MARKDOWN_IMAGES_ENABLED, EDITORIAL_SOLUTION_CATALOG, EDITORIAL_SOLUTION_PRESETS, EDITORIAL_THEME_PRESETS, EDITORIAL_WIDGET_CONVENTION_INPUTS, EDITORIAL_WIDGET_TAG, EMPLOYEE_ONBOARDING_EDITORIAL_SOLUTION, EMPLOYEE_ONBOARDING_EDITORIAL_TEMPLATE, EMPLOYEE_ONBOARDING_GUIDED_EDITORIAL_SOLUTION, EMPLOYEE_ONBOARDING_GUIDED_EDITORIAL_TEMPLATE, EVENT_REGISTRATION_EDITORIAL_SOLUTION, EVENT_REGISTRATION_EDITORIAL_TEMPLATE, EmptyStateCardComponent, ErrorMessageService, FIELD_METADATA_CAPABILITIES, FIELD_SELECTOR_REGISTRY_BASE, FIELD_SELECTOR_REGISTRY_DISABLE_DEFAULTS, FIELD_SELECTOR_REGISTRY_OVERRIDES, FORM_HOOKS, FORM_HOOKS_PRESETS, FORM_HOOKS_WHITELIST, FORM_HOOK_RESOLVERS, FieldControlType, FieldDataType, FieldSelectorRegistry, FormHooksRegistry, GLOBAL_ACTION_CATALOG$1 as GLOBAL_ACTION_CATALOG, GLOBAL_ACTION_HANDLERS, GLOBAL_ACTION_CATALOG as GLOBAL_ACTION_SPEC_CATALOG, GLOBAL_ACTION_UI_SCHEMAS, GLOBAL_ANALYTICS_SERVICE, GLOBAL_API_CLIENT, GLOBAL_CONFIG, GLOBAL_DIALOG_SERVICE, GLOBAL_ROUTE_GUARD_RESOLVER, GLOBAL_SURFACE_SERVICE, GLOBAL_TOAST_SERVICE, GenericCrudService, GlobalActionService, GlobalConfigService, INLINE_FILTER_ALIAS_TOKENS, INLINE_FILTER_CONTROL_TYPES, INLINE_FILTER_CONTROL_TYPE_SET, INLINE_FILTER_CONTROL_TYPE_VALUES, INLINE_FILTER_TOKEN_TO_BASE_CONTROL_TYPE, INLINE_FILTER_TOKEN_TO_CONTROL_TYPE, IconPickerService, IconPosition, IconSize, LOGGER_LEVEL_BY_ENV, LOGGER_LEVEL_PRIORITY, LoadingOrchestrator, LocalConnectionStorage, LocalStorageAsyncAdapter, LocalStorageCacheAdapter, LocalStorageConfigService, LoggerService, LoggerThrottleTracker, LoggerWarnOnceTracker, MemoryCacheAdapter, NumericFormat, OVERLAY_DECIDER_DEBUG, OVERLAY_DECISION_MATRIX, ObservabilityDashboardService, OverlayDeciderService, PRAXIS_CORPORATE_SENSITIVE_KEYS, PRAXIS_DEFAULT_OBSERVABILITY_ALERT_RULES, PRAXIS_DYNAMIC_PAGE_COMPONENT_METADATA, PRAXIS_FOOTER_LINKS_METADATA, PRAXIS_GLOBAL_ACTION_CATALOG, PRAXIS_GLOBAL_CONFIG_BOOTSTRAP_OPTIONS, PRAXIS_GLOBAL_CONFIG_BOOTSTRAP_READY, PRAXIS_GLOBAL_CONFIG_TENANT_RESOLVER, PRAXIS_HERO_BANNER_METADATA, PRAXIS_I18N_CONFIG, PRAXIS_I18N_TRANSLATOR, PRAXIS_LEGAL_NOTICE_METADATA, PRAXIS_LOADING_CTX, PRAXIS_LOADING_RENDERER, PRAXIS_LOGGER_CONFIG, PRAXIS_LOGGER_SINKS, PRAXIS_OBSERVABILITY_DASHBOARD_OPTIONS, PRAXIS_RICH_TEXT_BLOCK_METADATA, PRAXIS_TELEMETRY_TRANSPORT, PRAXIS_USER_CONTEXT_SUMMARY_METADATA, PRIVACY_CONSENT_EDITORIAL_SOLUTION, PRIVACY_CONSENT_EDITORIAL_TEMPLATE, PraxisCore, PraxisFooterLinksComponent, PraxisGlobalErrorHandler, PraxisHeroBannerComponent, PraxisI18nService, PraxisIconDirective, PraxisIconPickerComponent, PraxisLegalNoticeComponent, PraxisLoadingInterceptor, PraxisRichTextBlockComponent, PraxisSurfaceHostComponent, PraxisUserContextSummaryComponent, RULE_PROPERTY_SCHEMA, RemoteConfigStorage, ResourceQuickConnectComponent, SCHEMA_VIEWER_CONTEXT, SETTINGS_PANEL_BRIDGE, SETTINGS_PANEL_DATA, STEPPER_CONFIG_EDITOR, SURFACE_OPEN_I18N_CONFIG, SURFACE_OPEN_I18N_NAMESPACE, SURFACE_OPEN_PRESETS, SchemaMetadataClient, SchemaNormalizerService, SchemaViewerComponent, SurfaceBindingRuntimeService, SurfaceOpenActionEditorComponent, TABLE_CONFIG_EDITOR, TableConfigService, TelemetryLoggerSink, TelemetryService, ValidationPattern, WidgetPageStateRuntimeService, WidgetShellComponent, applyLocalCustomizations$2 as applyLocalCustomizations, applyLocalCustomizations$1 as applyLocalFormCustomizations, buildAngularValidators, buildApiUrl, buildBaseColumnFromDef, buildBaseFormField, buildFormConfigFromEditorialTemplate, buildHeaders, buildPageKey, buildSchemaId, buildValidatorsFromValidatorOptions, cancelIfCpfInvalidHook, clampRange, cloneTableConfig, cnpjAlphaValidator, collapseWhitespace, composeHeadersWithVersion, conditionalAsyncValidator, convertFormLayoutToConfig, createCorporateLoggerConfig, createCorporateObservabilityOptions, createCpfCnpjValidator, createDefaultFormConfig, createDefaultTableConfig, createEmptyFormConfig, createPersistedPage, customAsyncValidatorFn, customValidatorFn, debounceAsyncValidator, deepMerge, ensureIds, ensureNoConflictsHookFactory, ensurePageIds, extractNormalizedError, fetchWithETag, fileTypeValidator, fillUndefined, generateId, getDefaultFormHints, getEditorialCompliancePresetById, getEditorialFormTemplateById, getEditorialFormTemplateCatalog, getEditorialSolutionById, getEditorialSolutionCatalog, getEditorialSolutionPresetById, getEditorialThemePresetById, getEssentialConfig, getFieldMetadataCapabilities, getGlobalActionCatalog, getGlobalActionUiSchema, getReferencedFieldMetadata, getTextTransformer, interpolatePraxisTranslation, isAllowedEditorialContentFormat, isAllowedEditorialHref, isCssTextTransform, isEditorialComponentMeta, isInlineFilterControlType, isRangeValidForFilter, isTableConfigV2, isValidFormConfig, isValidTableConfig, legacyCnpjValidator, legacyCpfValidator, logOnErrorHook, mapFieldDefinitionToMetadata, mapFieldDefinitionsToMetadata, matchFieldValidator, maxFileSizeValidator, mergeFieldMetadata, mergePraxisI18nConfigs, mergeTableConfigs, migrateFormLayoutRule, minWordsValidator, normalizeControlTypeKey, normalizeControlTypeToken, normalizeEditorialLink, normalizeEnd, normalizeFieldConstraints, normalizeFormConfig, normalizeFormMetadata, normalizePath, normalizePraxisDataQueryContext, normalizeStart, normalizeUnknownError, notifySuccessHook, parseJsonResponseOrEmpty, praxisLoadingInterceptorFn, prefillFromContextHook, provideDefaultFormHooks, provideFieldSelectorRegistryBase, provideFieldSelectorRegistryOverride, provideFieldSelectorRegistryRuntime, provideFormHookPresets, provideFormHooks, provideGlobalActionCatalog, provideGlobalActionHandler, provideGlobalConfig, provideGlobalConfigReady, provideGlobalConfigSeed, provideGlobalConfigTenant, provideHookResolvers, provideHookWhitelist, provideOverlayDecisionMatrix, providePraxisAnalyticsGlobalActions, providePraxisDynamicPageMetadata, providePraxisFooterLinksMetadata, providePraxisGlobalActionCatalog, providePraxisGlobalActions, providePraxisGlobalConfigBootstrap, providePraxisHeroBannerMetadata, providePraxisHttpLoading, providePraxisI18n, providePraxisI18nConfig, providePraxisI18nTranslator, providePraxisLegalNoticeMetadata, providePraxisLoadingDefaults, providePraxisLogging, providePraxisRichTextBlockMetadata, providePraxisToastGlobalActions, providePraxisUserContextSummaryMetadata, provideRemoteGlobalConfig, reconcileFilterConfig, reconcileFormConfig, reconcileTableConfig, removeDiacritics, reportTelemetryHookFactory, requiredCheckedValidator, resolveBuiltinPresets, resolveControlTypeAlias, resolveDefaultValuePresentationFormat, resolveHidden, resolveInlineFilterControlType, resolveInlineFilterControlTypeToBaseControlType, resolveLoggerConfig, resolveObservabilityOptions, resolveOffset, resolveOrder, resolvePraxisFilterCriteria, resolveSpan, resolveValuePresentation, resolveValuePresentationLocale, slugify, stripMasksHook, supportsImplicitValuePresentation, syncWithServerMetadata, toCamel, toCapitalize, toKebab, toPascal, toSentenceCase, toSnake, toTitleCase, trim, uniqueAsyncValidator, urlValidator, withMessage, withPraxisHttpLoading };
 //# sourceMappingURL=praxisui-core.mjs.map