@praxisui/core 3.0.0-beta.9 → 4.0.0-beta.0

package/fesm2022/praxisui-core.mjs

@@ -5,7 +5,7 @@ import { HttpHeaders, HttpClient, HttpParams, HttpResponse, HttpContextToken, HT
 import { of, defer, throwError, from, EMPTY, BehaviorSubject, firstValueFrom, Subject, map as map$1 } from 'rxjs';
 import { switchMap, take, map, catchError, concatMap, tap, shareReplay, takeUntil, toArray, finalize } from 'rxjs/operators';
 import * as i1$2 from '@angular/common';
-import { Location, CommonModule } from '@angular/common';
+import { Location, DOCUMENT, CommonModule } from '@angular/common';
 import { Router, ActivatedRoute } from '@angular/router';
 import * as i1$1 from '@angular/forms';
 import { Validators, FormGroup, FormControl, FormsModule } from '@angular/forms';
@@ -14,9 +14,9 @@ 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 i5 from '@angular/material/icon';
+import * as i3$1 from '@angular/material/icon';
 import { MatIconModule } from '@angular/material/icon';
-import * as i5$1 from '@angular/material/input';
+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';
@@ -27,7 +27,7 @@ import { MatTooltipModule } from '@angular/material/tooltip';
 import { DomSanitizer } from '@angular/platform-browser';
 import * as i4 from '@angular/material/menu';
 import { MatMenuModule } from '@angular/material/menu';
-import * as i3$1 from '@angular/material/card';
+import * as i3$2 from '@angular/material/card';
 import { MatCardModule } from '@angular/material/card';
 import * as i8$1 from '@angular/material/chips';
 import { MatChipsModule } from '@angular/material/chips';
@@ -1822,9 +1822,9 @@ function isObject(value) {
  */
 function deepMerge(left, right) {
     if (right === undefined || right === null)
-        return clone(left);
+        return clone$1(left);
     if (Array.isArray(left)) {
-        return (Array.isArray(right) ? right : clone(left));
+        return (Array.isArray(right) ? right : clone$1(left));
     }
     if (!isObject(left) || !isObject(right)) {
         // Right wins when defined, else left
@@ -1837,13 +1837,13 @@ function deepMerge(left, right) {
         if (r === undefined)
             continue; // keep left as-is
         if (Array.isArray(r)) {
-            out[key] = r.map((v) => clone(v));
+            out[key] = r.map((v) => clone$1(v));
         }
         else if (isObject(r) && isObject(l)) {
             out[key] = deepMerge(l, r);
         }
         else {
-            out[key] = clone(r);
+            out[key] = clone$1(r);
         }
     }
     return out;
@@ -1855,7 +1855,7 @@ function deepMerge(left, right) {
  */
 function fillUndefined(target, defaults) {
     if (defaults === undefined || defaults === null)
-        return clone(target);
+        return clone$1(target);
     if (!isObject(target) || !isObject(defaults)) {
         return (target === undefined || target === null ? defaults : target);
     }
@@ -1864,7 +1864,7 @@ function fillUndefined(target, defaults) {
         const d = defaults[key];
         const t = target[key];
         if (t === undefined || t === null) {
-            out[key] = clone(d);
+            out[key] = clone$1(d);
         }
         else if (isObject(t) && isObject(d)) {
             out[key] = fillUndefined(t, d);
@@ -1875,7 +1875,7 @@ function fillUndefined(target, defaults) {
     }
     return out;
 }
-function clone(v) {
+function clone$1(v) {
     if (v == null || typeof v !== 'object')
         return v;
     try {
@@ -2183,12 +2183,15 @@ class GenericCrudService {
     get errorMessages() {
         return GenericCrudService.ERROR_MESSAGES;
     }
-    configure(resourcePath, endpointKey) {
+    configure(resourcePath, endpointKeyOrOptions) {
         if (!resourcePath || !resourcePath.trim()) {
             throw new Error(this.errorMessages.emptyResourcePath);
         }
-        const nextEndpointKey = endpointKey ?? this.currentEndpointKey;
-        const entry = this.resolveEndpointEntry(nextEndpointKey);
+        const configureOptions = typeof endpointKeyOrOptions === 'object' && endpointKeyOrOptions !== null
+            ? endpointKeyOrOptions
+            : { endpointKey: endpointKeyOrOptions };
+        const nextEndpointKey = configureOptions.endpointKey ?? this.currentEndpointKey;
+        const entry = configureOptions.apiUrlEntry ?? this.resolveEndpointEntry(nextEndpointKey);
         const nextBaseApiUrl = buildApiUrl(entry);
         const base = nextBaseApiUrl.replace(/\/+$/, '');
         let resource = resourcePath.trim();
@@ -2963,6 +2966,16 @@ class GenericCrudService {
         })));
     }
     filter(filterCriteria, pageable, opts) {
+        const response$ = opts
+            ? this.filterResponse(filterCriteria, pageable, opts)
+            : this.filterResponse(filterCriteria, pageable);
+        return response$.pipe(map((resp) => {
+            const body = this.unwrapPageResponse(resp?.data);
+            const version = resp?.dataVersion;
+            return version ? { ...body, dataVersion: version } : body;
+        }));
+    }
+    filterResponse(filterCriteria, pageable, opts) {
         let params = new HttpParams()
             .set('page', pageable.pageNumber)
             .set('size', pageable.pageSize);
@@ -2987,12 +3000,13 @@ class GenericCrudService {
                 headers: composeHeadersWithVersion(entry),
                 context: opts?.httpContext,
             });
-        return observeVersion ? req$.pipe(map((resp) => {
-            const raw = resp.body;
-            const body = this.unwrapPageResponse(raw);
-            const version = resp.headers.get('X-Data-Version') || undefined;
-            return version ? { ...body, dataVersion: version } : body;
-        }), catchError(this.handleError)) : req$.pipe(map((raw) => this.unwrapPageResponse(raw)), catchError(this.handleError));
+        return observeVersion
+            ? req$.pipe(map((resp) => {
+                const body = this.normalizeRestApiResponse(resp.body);
+                const version = resp.headers.get('X-Data-Version') || undefined;
+                return version ? { ...body, dataVersion: version } : body;
+            }), catchError(this.handleError))
+            : req$.pipe(map((raw) => this.normalizeRestApiResponse(raw)), catchError(this.handleError));
     }
     /** GET /by-ids */
     getByIds(ids, options) {
@@ -3693,6 +3707,12 @@ class GenericCrudService {
         }
         return raw;
     }
+    normalizeRestApiResponse(raw) {
+        if (raw && typeof raw === 'object' && 'data' in raw) {
+            return raw;
+        }
+        return { data: raw };
+    }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: GenericCrudService, deps: [{ token: i1.HttpClient }, { token: SchemaNormalizerService }, { token: GlobalConfigService }, { token: API_URL }], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: GenericCrudService, providedIn: null });
 }
@@ -7012,7 +7032,7 @@ class DefaultLoadingRenderer {
       .pfx-loading-root {
         position: fixed;
         inset: 0;
-        z-index: 10000;
+        z-index: var(--praxis-layer-loading-blocking, 2000);
         pointer-events: none;
       }
       .pfx-loading-entry {
@@ -7090,260 +7110,1293 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImpo
             type: Injectable
         }] });
 
-function provideFieldSelectorRegistryRuntime(map, opts) {
-    return {
-        provide: ENVIRONMENT_INITIALIZER,
-        multi: true,
-        useFactory: () => {
-            const registry = inject(FieldSelectorRegistry);
-            return () => registry.register(map, { overwrite: opts?.overwrite ?? false });
-        },
-    };
-}
-
-function providePraxisToastGlobalActions(opts = {}) {
-    return {
-        provide: GLOBAL_TOAST_SERVICE,
-        useFactory: () => {
-            const snack = (() => { try {
-                return inject(MatSnackBar);
-            }
-            catch {
-                return null;
-            } })();
-            const successDuration = opts.successDurationMs ?? 2500;
-            const errorDuration = opts.errorDurationMs ?? 3500;
-            const successClass = opts.successPanelClass ?? ['pdx-toast-success'];
-            const errorClass = opts.errorPanelClass ?? ['pdx-toast-error'];
-            return {
-                success: (message) => {
-                    if (snack) {
-                        snack.open(message, undefined, { duration: successDuration, panelClass: successClass });
-                    }
-                    else {
-                        console.log('[Toast]', message);
-                    }
-                },
-                error: (message) => {
-                    if (snack) {
-                        snack.open(message, undefined, { duration: errorDuration, panelClass: errorClass });
-                    }
-                    else {
-                        console.error('[Toast]', message);
-                    }
-                },
-            };
-        },
-    };
+const PRAXIS_LAYER_SCALE_DEFAULTS = {
+    stickyLocal: 100,
+    floatingLocal: 200,
+    authoringInsert: 280,
+    authoringHover: 300,
+    authoringSelected: 320,
+    authoringToolbar: 340,
+    cdkOverlayContainer: 1200,
+    cdkOverlayBackdrop: 1200,
+    cdkOverlayWrapper: 1210,
+    settingsPanel: 1220,
+    widgetShellBackdrop: 1280,
+    widgetShellExpanded: 1290,
+    widgetShellFullscreen: 1291,
+    dialog: 1300,
+    popup: 1400,
+    loadingBlocking: 2000,
+};
+const PRAXIS_LAYER_SCALE_VARS = {
+    stickyLocal: '--praxis-layer-sticky-local',
+    floatingLocal: '--praxis-layer-floating-local',
+    authoringInsert: '--praxis-layer-authoring-insert',
+    authoringHover: '--praxis-layer-authoring-hover',
+    authoringSelected: '--praxis-layer-authoring-selected',
+    authoringToolbar: '--praxis-layer-authoring-toolbar',
+    cdkOverlayContainer: '--praxis-layer-cdk-overlay-container',
+    cdkOverlayBackdrop: '--praxis-layer-cdk-overlay-backdrop',
+    cdkOverlayWrapper: '--praxis-layer-cdk-overlay-wrapper',
+    settingsPanel: '--praxis-layer-settings-panel',
+    widgetShellBackdrop: '--praxis-layer-widget-shell-backdrop',
+    widgetShellExpanded: '--praxis-layer-widget-shell-expanded',
+    widgetShellFullscreen: '--praxis-layer-widget-shell-fullscreen',
+    dialog: '--praxis-layer-dialog',
+    popup: '--praxis-layer-popup',
+    loadingBlocking: '--praxis-layer-loading-blocking',
+};
+function buildPraxisLayerScaleCss(scale = PRAXIS_LAYER_SCALE_DEFAULTS) {
+    return `
+:root {
+  ${PRAXIS_LAYER_SCALE_VARS.stickyLocal}: ${scale.stickyLocal};
+  ${PRAXIS_LAYER_SCALE_VARS.floatingLocal}: ${scale.floatingLocal};
+  ${PRAXIS_LAYER_SCALE_VARS.authoringInsert}: ${scale.authoringInsert};
+  ${PRAXIS_LAYER_SCALE_VARS.authoringHover}: ${scale.authoringHover};
+  ${PRAXIS_LAYER_SCALE_VARS.authoringSelected}: ${scale.authoringSelected};
+  ${PRAXIS_LAYER_SCALE_VARS.authoringToolbar}: ${scale.authoringToolbar};
+  ${PRAXIS_LAYER_SCALE_VARS.cdkOverlayContainer}: ${scale.cdkOverlayContainer};
+  ${PRAXIS_LAYER_SCALE_VARS.cdkOverlayBackdrop}: ${scale.cdkOverlayBackdrop};
+  ${PRAXIS_LAYER_SCALE_VARS.cdkOverlayWrapper}: ${scale.cdkOverlayWrapper};
+  ${PRAXIS_LAYER_SCALE_VARS.settingsPanel}: ${scale.settingsPanel};
+  ${PRAXIS_LAYER_SCALE_VARS.widgetShellBackdrop}: ${scale.widgetShellBackdrop};
+  ${PRAXIS_LAYER_SCALE_VARS.widgetShellExpanded}: ${scale.widgetShellExpanded};
+  ${PRAXIS_LAYER_SCALE_VARS.widgetShellFullscreen}: ${scale.widgetShellFullscreen};
+  ${PRAXIS_LAYER_SCALE_VARS.dialog}: ${scale.dialog};
+  ${PRAXIS_LAYER_SCALE_VARS.popup}: ${scale.popup};
+  ${PRAXIS_LAYER_SCALE_VARS.loadingBlocking}: ${scale.loadingBlocking};
 }
 
-function providePraxisAnalyticsGlobalActions(opts = {}) {
-    return {
-        provide: GLOBAL_ANALYTICS_SERVICE,
-        useFactory: () => {
-            const telemetry = (() => { try {
-                return inject(TelemetryService);
-            }
-            catch {
-                return null;
-            } })();
-            const prefix = opts.prefix ? `${opts.prefix}.` : '';
-            return {
-                track: (eventName, payload) => {
-                    if (telemetry) {
-                        telemetry.record(`${prefix}${eventName}`, payload);
-                    }
-                    else {
-                        console.log('[Analytics]', `${prefix}${eventName}`, payload ?? null);
-                    }
-                },
-            };
-        },
-    };
+.cdk-overlay-container {
+  z-index: var(${PRAXIS_LAYER_SCALE_VARS.cdkOverlayContainer}, ${scale.cdkOverlayContainer}) !important;
 }
 
-/**
- * Registers only the default visual renderer for Praxis loading.
- *
- * This does not wire any HTTP interceptor by itself. Use this when the host
- * wants a custom HTTP integration path but still wants the stock Praxis UI.
- */
-function providePraxisLoadingDefaults() {
-    return [
-        {
-            provide: PRAXIS_LOADING_RENDERER,
-            useClass: DefaultLoadingRenderer,
-        },
-    ];
-}
-/**
- * Official DI-based entrypoint to enable Praxis HTTP loading.
- *
- * Recommended when the host already uses DI interceptors, e.g.:
- *
- * ```ts
- * providers: [
- *   provideHttpClient(withInterceptorsFromDi()),
- *   ...providePraxisHttpLoading(),
- * ]
- * ```
- *
- * By default this provider does not register any renderer implementation.
- * Add `...providePraxisLoadingDefaults()` or a custom `PRAXIS_LOADING_RENDERER`
- * explicitly so hosts keep full control over visual composition.
- *
- * Requests remain opt-in and only show loading when they carry
- * `PRAXIS_LOADING_CTX` in the `HttpContext`.
- */
-function providePraxisHttpLoading(opts = {}) {
-    const providers = [
-        {
-            provide: HTTP_INTERCEPTORS,
-            useClass: PraxisLoadingInterceptor,
-            multi: true,
-        },
-    ];
-    if (opts.includeDefaultRenderer === true) {
-        providers.unshift(...providePraxisLoadingDefaults());
-    }
-    return providers;
-}
-/**
- * Angular modern helper for `provideHttpClient(...)`.
- *
- * Usage:
- *
- * ```ts
- * providers: [
- *   provideHttpClient(
- *     withInterceptors([authInterceptor]),
- *     withPraxisHttpLoading(),
- *   ),
- *   ...providePraxisLoadingDefaults(),
- * ]
- * ```
- *
- * Use this helper or `providePraxisHttpLoading()`, never both in the same host.
- */
-function withPraxisHttpLoading() {
-    return withInterceptors([praxisLoadingInterceptorFn]);
+.cdk-overlay-backdrop {
+  z-index: var(${PRAXIS_LAYER_SCALE_VARS.cdkOverlayBackdrop}, ${scale.cdkOverlayBackdrop}) !important;
 }
 
-const LOGGER_LEVEL_PRIORITY = {
-    error: 0,
-    warn: 1,
-    info: 2,
-    debug: 3,
-    trace: 4,
-};
-const LOGGER_LEVEL_BY_ENV = {
-    prod: 'warn',
-    qa: 'warn',
-    hml: 'info',
-    dev: 'debug',
-};
-const PRAXIS_CORPORATE_SENSITIVE_KEYS = [
-    'password',
-    'pass',
-    'token',
-    'accessToken',
-    'refreshToken',
-    'authorization',
-    'secret',
-    'apiKey',
-    'cpf',
-    'cnpj',
-    'document',
-    'ssn',
-    'email',
-    'phone',
-];
-const PRAXIS_CORPORATE_THROTTLE = {
-    enabled: true,
-    windowMs: 5000,
-    maxOccurrences: 3,
-};
-function createCorporateLoggerConfig(environment = 'prod') {
-    return {
-        environment,
-        minLevel: LOGGER_LEVEL_BY_ENV[environment],
-        warnOnceEnabled: true,
-        throttle: { ...PRAXIS_CORPORATE_THROTTLE },
-        pii: {
-            enabled: true,
-            redactionText: '[REDACTED]',
-            sensitiveKeys: [...PRAXIS_CORPORATE_SENSITIVE_KEYS],
-        },
-    };
+.cdk-global-overlay-wrapper {
+  z-index: var(${PRAXIS_LAYER_SCALE_VARS.cdkOverlayWrapper}, ${scale.cdkOverlayWrapper}) !important;
 }
-function resolveLoggerConfig(options = {}) {
-    const environment = options.environment ?? 'prod';
-    const corporate = createCorporateLoggerConfig(environment);
-    const overridePII = options.pii ?? {};
-    return {
-        ...corporate,
-        minLevel: options.minLevel ?? corporate.minLevel,
-        warnOnceEnabled: options.warnOnceEnabled ?? corporate.warnOnceEnabled,
-        throttle: {
-            ...corporate.throttle,
-            ...(options.throttle ?? {}),
-        },
-        pii: {
-            ...corporate.pii,
-            ...overridePII,
-            sensitiveKeys: overridePII.sensitiveKeys
-                ? [...overridePII.sensitiveKeys]
-                : [...corporate.pii.sensitiveKeys],
-        },
-        defaultContext: options.defaultContext
-            ? { ...options.defaultContext }
-            : corporate.defaultContext,
-        environment,
-    };
+`;
 }
 
-class ConsoleLoggerSink {
-    log(event) {
-        const print = this.resolveMethod(event.level);
-        const prefix = `[Praxis][${event.level.toUpperCase()}]`;
-        const envelope = {
-            environment: event.environment,
-            timestamp: event.timestamp,
-            context: event.context ?? null,
-            data: event.data ?? null,
-        };
-        if (event.context || event.data !== undefined) {
-            print(`${prefix} ${event.message}`, envelope);
-            return;
-        }
-        print(`${prefix} ${event.message}`);
+class PraxisLayerScaleStyleService {
+    doc = inject(DOCUMENT);
+    styleId = 'praxis-layer-scale';
+    constructor() {
+        this.ensureInstalled();
     }
-    resolveMethod(level) {
-        if (level === 'error' && typeof console.error === 'function') {
-            return console.error.bind(console);
-        }
-        if (level === 'warn' && typeof console.warn === 'function') {
-            return console.warn.bind(console);
-        }
-        if (level === 'info' && typeof console.info === 'function') {
-            return console.info.bind(console);
-        }
-        if (level === 'debug' && typeof console.debug === 'function') {
-            return console.debug.bind(console);
+    ensureInstalled() {
+        const doc = this.doc;
+        if (!doc?.head) {
+            return;
         }
-        if (level === 'trace') {
-            if (typeof console.trace === 'function') {
-                return console.trace.bind(console);
-            }
-            if (typeof console.debug === 'function') {
-                return console.debug.bind(console);
+        const css = buildPraxisLayerScaleCss();
+        const existing = doc.getElementById(this.styleId);
+        if (existing) {
+            if (existing.textContent !== css) {
+                existing.textContent = css;
             }
+            return;
         }
-        return console.log.bind(console);
+        const style = doc.createElement('style');
+        style.id = this.styleId;
+        style.textContent = css;
+        doc.head.appendChild(style);
     }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: PraxisLayerScaleStyleService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: PraxisLayerScaleStyleService, providedIn: 'root' });
 }
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: PraxisLayerScaleStyleService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
 
-const PRAXIS_LOGGER_CONFIG = new InjectionToken('PRAXIS_LOGGER_CONFIG', {
+class ResourceDiscoveryService {
+    http = inject(HttpClient);
+    schemaNormalizer = inject(SchemaNormalizerService);
+    apiUrlConfig = inject(API_URL);
+    getLinks(source, rel) {
+        const candidate = this.extractLinks(source)?.[rel];
+        if (!candidate) {
+            return [];
+        }
+        return Array.isArray(candidate) ? candidate.filter(Boolean) : [candidate];
+    }
+    getLink(source, rel) {
+        return this.getLinks(source, rel)[0] ?? null;
+    }
+    hasLink(source, rel) {
+        return this.getLinks(source, rel).length > 0;
+    }
+    resolveLinkHref(source, rel, options) {
+        const link = this.getLink(source, rel);
+        return link?.href ? this.resolveHref(link.href, options) : null;
+    }
+    followLink(source, rel, options) {
+        return this.fetchJson(this.requireLinkHref(source, rel, options), options);
+    }
+    getSurfaces(source, options) {
+        return this.followLink(source, 'surfaces', options);
+    }
+    getActions(source, options) {
+        return this.followLink(source, 'actions', options);
+    }
+    getCapabilities(source, options) {
+        return this.followLink(source, 'capabilities', options);
+    }
+    fetchJson(href, options) {
+        return this.http.get(this.resolveHref(href, options));
+    }
+    getSchemaByUrl(schemaUrl, options) {
+        return this.fetchJson(schemaUrl, options);
+    }
+    getSchemaFieldsByUrl(schemaUrl, options) {
+        return this.getSchemaByUrl(schemaUrl, options).pipe(map$1((schema) => this.schemaNormalizer.normalizeSchema(schema)));
+    }
+    resolveHref(href, options) {
+        const normalizedHref = String(href || '').trim();
+        if (!normalizedHref) {
+            throw new Error('ResourceDiscoveryService cannot resolve an empty href.');
+        }
+        if (/^https?:\/\//i.test(normalizedHref)) {
+            return normalizedHref;
+        }
+        const apiBaseUrl = this.resolveApiBaseHref(options);
+        if (!apiBaseUrl) {
+            return normalizedHref;
+        }
+        if (normalizedHref.startsWith('/')) {
+            const apiOrigin = this.resolveApiOrigin(options);
+            return apiOrigin
+                ? new URL(normalizedHref, `${apiOrigin}/`).toString()
+                : normalizedHref;
+        }
+        return new URL(normalizedHref, this.ensureTrailingSlash(apiBaseUrl)).toString();
+    }
+    requireLinkHref(source, rel, options) {
+        const href = this.resolveLinkHref(source, rel, options);
+        if (!href) {
+            throw new Error(`ResourceDiscoveryService could not resolve rel "${rel}".`);
+        }
+        return href;
+    }
+    extractLinks(source) {
+        if (!source) {
+            return undefined;
+        }
+        if (this.isRestApiResponse(source)) {
+            return source._links;
+        }
+        return source;
+    }
+    resolveApiEntry(options) {
+        if (options?.apiUrlEntry) {
+            return options.apiUrlEntry;
+        }
+        return this.resolveEndpointEntry(options?.endpointKey);
+    }
+    resolveApiOrigin(options) {
+        const baseUrl = this.resolveApiBaseUrl(options);
+        if (!baseUrl) {
+            return '';
+        }
+        try {
+            return new URL(baseUrl).origin.replace(/\/+$/, '');
+        }
+        catch {
+            const runtimeOrigin = this.getRuntimeOrigin();
+            return runtimeOrigin ? runtimeOrigin.replace(/\/+$/, '') : '';
+        }
+    }
+    resolveApiBaseUrl(options) {
+        const entry = this.resolveApiEntry(options);
+        return String(buildApiUrl(entry) || '').trim();
+    }
+    resolveApiBaseHref(options) {
+        const baseUrl = this.resolveApiBaseUrl(options);
+        if (!baseUrl) {
+            return '';
+        }
+        try {
+            return new URL(baseUrl).toString();
+        }
+        catch {
+            const runtimeOrigin = this.getRuntimeOrigin();
+            return runtimeOrigin
+                ? new URL(baseUrl.replace(/^\/+/, ''), this.ensureTrailingSlash(runtimeOrigin)).toString()
+                : '';
+        }
+    }
+    resolveEndpointEntry(endpointKey) {
+        const key = endpointKey ?? ApiEndpoint.Default;
+        return this.apiUrlConfig[key] || this.apiUrlConfig.default || {};
+    }
+    getRuntimeOrigin() {
+        try {
+            const origin = globalThis?.location?.origin;
+            return typeof origin === 'string' && origin.startsWith('http') ? origin : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    ensureTrailingSlash(value) {
+        return /\/$/.test(value) ? value : `${value}/`;
+    }
+    isRestApiResponse(source) {
+        return 'data' in source;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: ResourceDiscoveryService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: ResourceDiscoveryService, providedIn: 'any' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: ResourceDiscoveryService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'any' }]
+        }] });
+
+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 ResourceActionOpenAdapterService {
+    discovery = inject(ResourceDiscoveryService);
+    toPayload(action, options) {
+        const resourcePath = this.normalizeResourcePath(options.resourcePath);
+        if (!resourcePath) {
+            throw new Error('ResourceActionOpenAdapterService requires resourcePath.');
+        }
+        if (!action.requestSchemaUrl) {
+            throw new Error(`ResourceActionOpenAdapterService requires requestSchemaUrl for action "${action.id}".`);
+        }
+        const discoveryOptions = options.endpointKey || options.apiUrlEntry
+            ? {
+                ...(options.endpointKey ? { endpointKey: options.endpointKey } : {}),
+                ...(options.apiUrlEntry ? { apiUrlEntry: options.apiUrlEntry } : {}),
+            }
+            : undefined;
+        const resolvedRequestSchemaUrl = this.discovery.resolveHref(action.requestSchemaUrl, discoveryOptions);
+        const resolvedResponseSchemaUrl = action.responseSchemaUrl
+            ? this.discovery.resolveHref(action.responseSchemaUrl, discoveryOptions)
+            : null;
+        const resolvedSubmitUrl = this.discovery.resolveHref(action.path, discoveryOptions);
+        const payload = this.clone(this.resolveDynamicFormPreset());
+        payload.presentation = options.presentation ?? payload.presentation;
+        payload.title = options.title ?? action.title ?? payload.title;
+        payload.subtitle = options.subtitle ?? action.description ?? payload.subtitle;
+        payload.icon = options.icon ?? payload.icon;
+        payload.context = {
+            resource: {
+                resourceKey: action.resourceKey,
+                resourcePath,
+                resourceId: options.resourceId ?? null,
+                group: options.group ?? null,
+            },
+            action: {
+                id: action.id,
+                scope: action.scope,
+                operationId: action.operationId,
+                path: action.path,
+                method: action.method,
+                requestSchemaId: action.requestSchemaId ?? null,
+                requestSchemaUrl: action.requestSchemaUrl,
+                responseSchemaId: action.responseSchemaId ?? null,
+                responseSchemaUrl: action.responseSchemaUrl ?? null,
+                availability: action.availability,
+                successMessage: action.successMessage ?? null,
+                tags: action.tags,
+            },
+        };
+        payload.widget.inputs = {
+            ...(payload.widget.inputs || {}),
+            resourcePath,
+            formId: this.buildStableInstanceId(action),
+            mode: 'create',
+            schemaUrl: resolvedRequestSchemaUrl,
+            apiEndpointKey: options.endpointKey ?? null,
+            apiUrlEntry: options.apiUrlEntry ?? (discoveryOptions ? this.discovery.resolveApiEntry(discoveryOptions) : null),
+            submitMethod: String(action.method || '').trim().toLowerCase(),
+            submitUrl: resolvedSubmitUrl,
+            responseSchemaUrl: resolvedResponseSchemaUrl,
+        };
+        if (action.scope === 'ITEM') {
+            if (options.resourceId != null) {
+                payload.widget.inputs['resourceId'] = options.resourceId;
+            }
+            else if (options.idBindingPath) {
+                payload.bindings = [
+                    ...(payload.bindings || []),
+                    this.buildIdBinding(options.idBindingPath),
+                ];
+            }
+            else {
+                throw new Error(`ResourceActionOpenAdapterService requires resourceId or idBindingPath for item action "${action.id}".`);
+            }
+        }
+        return payload;
+    }
+    resolveDynamicFormPreset() {
+        const preset = SURFACE_OPEN_PRESETS.find((candidate) => candidate.id === 'praxis-dynamic-form');
+        if (!preset) {
+            throw new Error('Missing canonical surface preset "praxis-dynamic-form".');
+        }
+        return preset.payload;
+    }
+    buildStableInstanceId(action) {
+        return `${action.resourceKey}.action.${action.id}`.replace(/[^a-zA-Z0-9._-]+/g, '-');
+    }
+    normalizeResourcePath(resourcePath) {
+        return String(resourcePath || '').trim().replace(/^\/+/, '').replace(/\/+$/, '');
+    }
+    buildIdBinding(idBindingPath) {
+        return {
+            from: idBindingPath,
+            to: 'widget.inputs.resourceId',
+            mode: 'path',
+        };
+    }
+    clone(value) {
+        return value == null ? value : JSON.parse(JSON.stringify(value));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: ResourceActionOpenAdapterService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: ResourceActionOpenAdapterService, providedIn: 'any' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: ResourceActionOpenAdapterService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'any' }]
+        }] });
+
+class ResourceSurfaceOpenAdapterService {
+    discovery = inject(ResourceDiscoveryService);
+    toPayload(surface, options) {
+        const resourcePath = this.normalizeResourcePath(options.resourcePath);
+        if (!resourcePath) {
+            throw new Error('ResourceSurfaceOpenAdapterService requires resourcePath.');
+        }
+        const discoveryOptions = options.endpointKey || options.apiUrlEntry
+            ? {
+                ...(options.endpointKey ? { endpointKey: options.endpointKey } : {}),
+                ...(options.apiUrlEntry ? { apiUrlEntry: options.apiUrlEntry } : {}),
+            }
+            : undefined;
+        const resolvedSchemaUrl = this.discovery.resolveHref(surface.schemaUrl, discoveryOptions);
+        const resolvedSubmitUrl = this.isWritableFormSurface(surface.kind)
+            ? this.discovery.resolveHref(surface.path, discoveryOptions)
+            : null;
+        const basePayload = this.buildBasePayload(surface);
+        const payload = {
+            ...basePayload,
+            presentation: options.presentation ?? basePayload.presentation,
+            title: options.title ?? surface.title ?? basePayload.title,
+            subtitle: options.subtitle ?? surface.description ?? basePayload.subtitle,
+            icon: options.icon ?? basePayload.icon,
+            context: {
+                resource: {
+                    resourceKey: surface.resourceKey,
+                    resourcePath,
+                    resourceId: options.resourceId ?? null,
+                    group: options.group ?? null,
+                },
+                surface: {
+                    id: surface.id,
+                    kind: surface.kind,
+                    scope: surface.scope,
+                    intent: surface.intent ?? null,
+                    operationId: surface.operationId,
+                    path: surface.path,
+                    method: surface.method,
+                    schemaId: surface.schemaId,
+                    schemaUrl: surface.schemaUrl,
+                    availability: surface.availability,
+                    tags: surface.tags,
+                },
+            },
+        };
+        if (basePayload.widget.id === 'praxis-table') {
+            payload.widget.inputs = {
+                ...(payload.widget.inputs || {}),
+                resourcePath,
+                tableId: this.buildStableInstanceId(surface),
+                queryContext: options.queryContext ?? payload.widget.inputs?.['queryContext'] ?? { filters: {} },
+            };
+            return payload;
+        }
+        const mode = this.resolveFormMode(surface.kind, surface.scope);
+        payload.widget.inputs = {
+            ...(payload.widget.inputs || {}),
+            resourcePath,
+            formId: this.buildStableInstanceId(surface),
+            mode,
+            schemaUrl: resolvedSchemaUrl,
+            apiEndpointKey: options.endpointKey ?? null,
+            apiUrlEntry: options.apiUrlEntry ?? (discoveryOptions ? this.discovery.resolveApiEntry(discoveryOptions) : null),
+        };
+        if (this.isWritableFormSurface(surface.kind)) {
+            payload.widget.inputs['submitMethod'] = surface.method.toLowerCase();
+            payload.widget.inputs['submitUrl'] = resolvedSubmitUrl;
+        }
+        if (surface.scope === 'ITEM') {
+            if (options.resourceId != null) {
+                payload.widget.inputs['resourceId'] = options.resourceId;
+            }
+            else if (options.idBindingPath) {
+                payload.bindings = [
+                    ...(payload.bindings || []),
+                    this.buildIdBinding(options.idBindingPath),
+                ];
+            }
+            else {
+                throw new Error(`ResourceSurfaceOpenAdapterService requires resourceId or idBindingPath for item surface "${surface.id}".`);
+            }
+        }
+        return payload;
+    }
+    buildBasePayload(surface) {
+        const presetId = surface.scope === 'COLLECTION' && this.isCollectionView(surface.kind)
+            ? 'praxis-table'
+            : 'praxis-dynamic-form';
+        const preset = SURFACE_OPEN_PRESETS.find((candidate) => candidate.id === presetId);
+        if (!preset) {
+            throw new Error(`Missing canonical surface preset "${presetId}".`);
+        }
+        return this.clone(preset.payload);
+    }
+    buildStableInstanceId(surface) {
+        return `${surface.resourceKey}.${surface.id}`.replace(/[^a-zA-Z0-9._-]+/g, '-');
+    }
+    normalizeResourcePath(resourcePath) {
+        return String(resourcePath || '').trim().replace(/^\/+/, '').replace(/\/+$/, '');
+    }
+    resolveFormMode(kind, scope) {
+        if (kind === 'VIEW' || kind === 'READ_PROJECTION') {
+            return 'view';
+        }
+        if (scope === 'ITEM') {
+            return 'edit';
+        }
+        return 'create';
+    }
+    isCollectionView(kind) {
+        return kind === 'VIEW' || kind === 'READ_PROJECTION';
+    }
+    isWritableFormSurface(kind) {
+        return kind === 'FORM' || kind === 'PARTIAL_FORM';
+    }
+    buildIdBinding(idBindingPath) {
+        return {
+            from: idBindingPath,
+            to: 'widget.inputs.resourceId',
+            mode: 'path',
+        };
+    }
+    clone(value) {
+        return value == null ? value : JSON.parse(JSON.stringify(value));
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: ResourceSurfaceOpenAdapterService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: ResourceSurfaceOpenAdapterService, providedIn: 'any' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: ResourceSurfaceOpenAdapterService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'any' }]
+        }] });
+
+const DEFAULT_FAMILIES = [
+    'chart',
+    'analytic-table',
+    'kpi',
+    'summary-list',
+];
+const ANALYTIC_TABLE_OPERATIONS = new Set(['group-by', 'timeseries', 'distribution']);
+class AnalyticsPresentationResolver {
+    resolve(analytics, options) {
+        const projections = analytics?.projections?.filter(Boolean) ?? [];
+        if (!projections.length) {
+            throw new Error('AnalyticsPresentationResolver requires at least one analytics projection.');
+        }
+        const availableFamilies = this.normalizeFamilies(options?.availableFamilies);
+        const preferredDecision = this.tryResolvePreferredProjection(projections, availableFamilies, options?.preferFamily ?? null);
+        if (preferredDecision) {
+            return preferredDecision;
+        }
+        for (const projection of projections) {
+            const inferredDecision = this.inferDecision(projection, availableFamilies);
+            if (inferredDecision) {
+                return inferredDecision;
+            }
+        }
+        throw new Error('AnalyticsPresentationResolver could not resolve a semantic presentation family. Expose analytic-table or publish stronger semantic hints.');
+    }
+    tryResolvePreferredProjection(projections, availableFamilies, preferredFamily) {
+        if (preferredFamily) {
+            for (const projection of projections) {
+                if (this.supportsFamily(projection, preferredFamily, availableFamilies)) {
+                    return {
+                        projectionId: projection.id,
+                        family: preferredFamily,
+                        reason: `Preferencia explicita do host pelo renderer "${preferredFamily}".`,
+                    };
+                }
+            }
+        }
+        for (const projection of projections) {
+            const compatibleFamilies = this.getCompatiblePreferredFamilies(projection, availableFamilies);
+            if (!compatibleFamilies.length) {
+                continue;
+            }
+            return {
+                projectionId: projection.id,
+                family: compatibleFamilies[0],
+                reason: `Projection "${projection.id}" publicou a familia preferencial "${compatibleFamilies[0]}".`,
+            };
+        }
+        return null;
+    }
+    inferDecision(projection, availableFamilies) {
+        if (this.supportsFamily(projection, 'chart', availableFamilies)) {
+            return {
+                projectionId: projection.id,
+                family: 'chart',
+                reason: this.buildInferenceReason(projection, 'chart'),
+            };
+        }
+        if (this.supportsFamily(projection, 'analytic-table', availableFamilies)) {
+            return {
+                projectionId: projection.id,
+                family: 'analytic-table',
+                reason: this.buildInferenceReason(projection, 'analytic-table'),
+            };
+        }
+        return null;
+    }
+    buildInferenceReason(projection, family) {
+        if (family === 'chart') {
+            return `Projection "${projection.id}" foi inferida como chart por combinar trend + timeseries + eixo temporal.`;
+        }
+        return `Projection "${projection.id}" foi resolvida como analytic-table por preservar a leitura semantica declarada sem forcar um chart ambiguo.`;
+    }
+    getCompatiblePreferredFamilies(projection, availableFamilies) {
+        const preferredFamilies = projection.presentationHints?.preferredFamilies ?? [];
+        return preferredFamilies.filter((family) => this.supportsFamily(projection, family, availableFamilies));
+    }
+    supportsFamily(projection, family, availableFamilies) {
+        if (!availableFamilies.includes(family)) {
+            return false;
+        }
+        if (family === 'chart') {
+            return this.isChartInequivocal(projection) || this.hasExplicitPreferredFamily(projection, 'chart');
+        }
+        if (family === 'analytic-table') {
+            return this.isAnalyticTableEligible(projection) || this.hasExplicitPreferredFamily(projection, 'analytic-table');
+        }
+        return this.hasExplicitPreferredFamily(projection, family);
+    }
+    isChartInequivocal(projection) {
+        return (projection.intent === 'trend' &&
+            projection.source.operation === 'timeseries' &&
+            projection.bindings.primaryDimension?.role === 'time');
+    }
+    isAnalyticTableEligible(projection) {
+        return (projection.bindings.primaryMetrics.length > 0 &&
+            ANALYTIC_TABLE_OPERATIONS.has(projection.source.operation) &&
+            (!!projection.bindings.primaryDimension || projection.bindings.primaryMetrics.length > 0));
+    }
+    hasExplicitPreferredFamily(projection, family) {
+        return (projection.presentationHints?.preferredFamilies ?? []).includes(family);
+    }
+    normalizeFamilies(families) {
+        const normalized = (families ?? DEFAULT_FAMILIES).filter(Boolean);
+        return normalized.length ? normalized : [...DEFAULT_FAMILIES];
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: AnalyticsPresentationResolver, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: AnalyticsPresentationResolver, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: AnalyticsPresentationResolver, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+async function parseJsonResponseOrEmpty(res, context = 'response') {
+    const raw = await res.text();
+    if (!raw || !raw.trim()) {
+        return {};
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        const e = new Error(`${context}: invalid JSON payload`);
+        e.cause = error;
+        throw e;
+    }
+}
+async function fetchWithETag(params) {
+    const headers = { Accept: 'application/json' };
+    if (params.schemaHash)
+        headers['If-None-Match'] = `"${params.schemaHash}"`;
+    if (params.tenant)
+        headers['X-Tenant'] = params.tenant;
+    if (params.locale)
+        headers['Accept-Language'] = params.locale;
+    // Allow host apps to provide additional headers (e.g., Authorization) without coupling
+    try {
+        const extra = globalThis?.PAX_FETCH_HEADERS?.();
+        if (extra && typeof extra === 'object') {
+            for (const [k, v] of Object.entries(extra)) {
+                const key = String(k);
+                const val = Array.isArray(v) ? String(v[0]) : String(v);
+                if (val && !headers[key])
+                    headers[key] = val;
+            }
+        }
+    }
+    catch {
+        // ignore header hook errors
+    }
+    const res = await fetch(params.url, {
+        headers,
+        cache: 'no-cache',
+        credentials: params.credentials ?? 'include',
+        signal: params.signal,
+    });
+    if (res.status === 304)
+        return { status: 304 };
+    if (!res.ok) {
+        const raw = await res.text().catch(() => '');
+        const bodyHint = raw?.trim() ? `: ${raw.trim().slice(0, 240)}` : '';
+        throw new Error(`fetchWithETag failed (${res.status} ${res.statusText || 'HTTP error'})${bodyHint}`);
+    }
+    const etag = res.headers.get('ETag') || '';
+    const newHash = etag.replace(/^W\//, '').replace(/^\"|\"$/g, '');
+    const xSchemaHash = res.headers.get('X-Schema-Hash');
+    const schemaHash = xSchemaHash || newHash; // prefer explicit header when available
+    const schema = await parseJsonResponseOrEmpty(res, 'fetchWithETag');
+    return { status: 200, schema, schemaHash };
+}
+
+class SchemaMetadataClient {
+    cache;
+    inFlight = new Map();
+    constructor(cache) {
+        this.cache = cache;
+    }
+    async getSchema(params) {
+        // Bind identity to API origin to avoid cross-origin collisions
+        let apiOrigin = '';
+        try {
+            apiOrigin = new URL(params.baseUrl).origin;
+        }
+        catch {
+            try {
+                apiOrigin = globalThis?.location?.origin || '';
+            }
+            catch { }
+        }
+        const schemaId = buildSchemaId({ ...params, apiOrigin });
+        const cached = await this.cache.get(schemaId);
+        // Build URL with query params
+        let u;
+        try {
+            u = new URL(params.baseUrl);
+        }
+        catch (err) {
+            // Accept relative baseUrl by resolving against the app origin when available
+            const origin = (() => {
+                try {
+                    return globalThis?.location?.origin;
+                }
+                catch {
+                    return undefined;
+                }
+            })();
+            if (origin && origin.startsWith('http')) {
+                u = new URL(params.baseUrl, origin);
+            }
+            else {
+                // Friendly error for hosts: instruct to set absolute baseUrl or provide runtime origin
+                const e = new Error(`Failed to construct schema URL. API_URL.baseUrl appears relative and no runtime origin is available. ` +
+                    `Set API_URL.baseUrl to an absolute URL (e.g., http://localhost:4200/api) or run in a browser context. ` +
+                    `Received baseUrl="${params.baseUrl}".`);
+                e.cause = err;
+                throw e;
+            }
+        }
+        u.searchParams.set('path', params.path);
+        u.searchParams.set('operation', (params.operation || 'get').toLowerCase());
+        u.searchParams.set('schemaType', (params.schemaType || 'response').toLowerCase());
+        u.searchParams.set('includeInternalSchemas', String(!!params.includeInternalSchemas));
+        const key = schemaId;
+        if (this.inFlight.has(key))
+            return this.inFlight.get(key);
+        const p = (async () => {
+            const res = await fetchWithETag({
+                url: u.toString(),
+                schemaHash: cached?.schemaHash,
+                tenant: params.tenant,
+                locale: params.locale,
+            });
+            if (res.status === 304) {
+                if (cached)
+                    return cached;
+                // No cache: refetch without If-None-Match
+                const refetch = await fetch(u.toString(), { cache: 'no-cache', credentials: 'include' });
+                if (!refetch.ok) {
+                    const raw = await refetch.text().catch(() => '');
+                    const bodyHint = raw?.trim() ? `: ${raw.trim().slice(0, 240)}` : '';
+                    throw new Error(`SchemaMetadataClient refetch failed (${refetch.status} ${refetch.statusText || 'HTTP error'})${bodyHint}`);
+                }
+                const etag = refetch.headers.get('ETag') || '';
+                const xHash = refetch.headers.get('X-Schema-Hash') || '';
+                const schemaHash = (xHash || etag).replace(/^W\//, '').replace(/^\"|\"$/g, '');
+                const schema = await parseJsonResponseOrEmpty(refetch, 'SchemaMetadataClient refetch');
+                const fallback = { schema, schemaHash };
+                await this.cache.set(schemaId, fallback);
+                return fallback;
+            }
+            // res.status === 200
+            const entry = {
+                schema: res.schema,
+                schemaHash: res.schemaHash,
+            };
+            await this.cache.set(schemaId, entry);
+            return entry;
+        })();
+        this.inFlight.set(key, p);
+        try {
+            const result = await p;
+            return result;
+        }
+        finally {
+            this.inFlight.delete(key);
+        }
+    }
+}
+
+const DEFAULT_CACHE_NAMESPACE = 'praxis.analytics.contract';
+const DEFAULT_CACHE_TTL_MS = 5 * 60 * 1000;
+class AnalyticsSchemaContractService {
+    apiUrl;
+    constructor(apiUrl) {
+        this.apiUrl = apiUrl;
+    }
+    async getAnalytics(request) {
+        const client = new SchemaMetadataClient(new LocalStorageCacheAdapter({
+            namespace: request.cacheNamespace || DEFAULT_CACHE_NAMESPACE,
+            ttlMs: request.cacheTtlMs ?? DEFAULT_CACHE_TTL_MS,
+        }));
+        const entry = await client.getSchema({
+            baseUrl: this.buildSchemasBaseUrl(),
+            path: request.path,
+            operation: request.operation ?? 'post',
+            schemaType: request.schemaType ?? 'response',
+            includeInternalSchemas: request.includeInternalSchemas ?? false,
+            tenant: request.tenant,
+            locale: request.locale,
+        });
+        const schema = this.asRecord(entry.schema);
+        if (!schema) {
+            throw new Error(`Schema payload for ${request.path} is not a JSON object.`);
+        }
+        const xUi = this.asRecord(schema?.['x-ui']);
+        const analytics = this.asRecord(xUi?.['analytics']);
+        const projections = Array.isArray(analytics?.['projections'])
+            ? analytics['projections']
+            : [];
+        if (!analytics || !projections.length) {
+            throw new Error(`x-ui.analytics.projections[] was not published for ${request.path}.`);
+        }
+        return {
+            ...analytics,
+            projections: projections,
+        };
+    }
+    buildSchemasBaseUrl() {
+        const baseUrl = String(this.apiUrl?.default?.baseUrl || '').replace(/\/+$/, '');
+        if (!baseUrl) {
+            throw new Error('AnalyticsSchemaContractService requires API_URL.default.baseUrl to resolve /schemas/filtered.');
+        }
+        return `${baseUrl}/schemas/filtered`;
+    }
+    asRecord(value) {
+        return value && typeof value === 'object' && !Array.isArray(value)
+            ? value
+            : null;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: AnalyticsSchemaContractService, deps: [{ token: API_URL }], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: AnalyticsSchemaContractService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: AnalyticsSchemaContractService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [API_URL]
+                }] }] });
+
+class AnalyticsStatsRequestBuilderService {
+    buildExecutionPlan(projection) {
+        const dimension = projection.bindings.primaryDimension;
+        const metrics = this.getExecutionMetrics(projection);
+        if (!dimension?.field) {
+            throw new Error(`AnalyticsStatsRequestBuilderService requires primaryDimension for projection "${projection.id}".`);
+        }
+        if (!metrics.length) {
+            throw new Error(`AnalyticsStatsRequestBuilderService requires at least one metric for projection "${projection.id}".`);
+        }
+        return {
+            resourcePath: projection.source.resource,
+            statsPath: `${projection.source.resource.replace(/\/+$/, '')}/stats/${projection.source.operation}`,
+            operation: projection.source.operation,
+            statsRequest: this.buildStatsRequest(projection),
+            dimensions: [dimension.field],
+            metrics: metrics.map((metric) => ({
+                field: metric.field,
+                aggregation: metric.aggregation ?? undefined,
+                alias: metric.field,
+            })),
+            sort: projection.defaults?.sort?.map((item) => `${item.field}:${item.direction}`) ?? undefined,
+            limit: projection.defaults?.limit ?? undefined,
+        };
+    }
+    buildStatsRequest(projection) {
+        const field = projection.bindings.primaryDimension.field;
+        const metrics = this.getExecutionMetrics(projection).map((metric) => this.buildStatsMetric(metric.field, metric.aggregation));
+        const metric = metrics[0];
+        const requestMetrics = metrics.length > 1 ? metrics : undefined;
+        const limit = projection.defaults?.limit ?? undefined;
+        const orderBy = this.mapOrderBy(projection.defaults?.sort?.[0]?.field, projection.defaults?.sort?.[0]?.direction, projection);
+        switch (projection.source.operation) {
+            case 'group-by':
+                return {
+                    filter: {},
+                    field,
+                    metric,
+                    metrics: requestMetrics,
+                    limit,
+                    orderBy,
+                };
+            case 'timeseries':
+                if (!projection.defaults?.granularity) {
+                    throw new Error(`AnalyticsStatsRequestBuilderService requires defaults.granularity for timeseries projection "${projection.id}".`);
+                }
+                return {
+                    filter: {},
+                    field,
+                    granularity: this.mapGranularityToBackend(projection.defaults.granularity),
+                    metric,
+                    metrics: requestMetrics,
+                };
+            case 'distribution':
+                return {
+                    filter: {},
+                    field,
+                    mode: 'TERMS',
+                    metric,
+                    bucketCount: limit,
+                    limit,
+                    orderBy,
+                };
+            default:
+                throw new Error(`Unsupported analytics stats operation "${projection.source.operation}".`);
+        }
+    }
+    buildStatsMetric(field, aggregation) {
+        const operation = this.mapAggregationToBackend(aggregation);
+        return {
+            operation,
+            field: operation === 'COUNT' ? undefined : field,
+            alias: field,
+        };
+    }
+    mapAggregationToBackend(aggregation) {
+        switch ((aggregation ?? '').toLowerCase()) {
+            case 'avg':
+                return 'AVG';
+            case 'min':
+                return 'MIN';
+            case 'max':
+                return 'MAX';
+            case 'count':
+            case '':
+                return 'COUNT';
+            case 'sum':
+                return 'SUM';
+            default:
+                throw new Error(`Analytics aggregation "${aggregation}" is not supported in praxis.stats execution.`);
+        }
+    }
+    mapOrderBy(field, direction, projection) {
+        if (!field || !direction) {
+            return undefined;
+        }
+        const dimensionField = projection.bindings.primaryDimension?.field;
+        if (field === dimensionField) {
+            return direction === 'asc' ? 'KEY_ASC' : 'KEY_DESC';
+        }
+        const metricFields = [
+            ...(projection.bindings.primaryMetrics ?? []),
+            ...(projection.bindings.secondaryMetrics ?? []),
+        ].map((metric) => metric.field);
+        if (metricFields.includes(field)) {
+            return direction === 'asc' ? 'VALUE_ASC' : 'VALUE_DESC';
+        }
+        return undefined;
+    }
+    mapGranularityToBackend(granularity) {
+        switch (granularity) {
+            case 'hour':
+                return 'HOUR';
+            case 'day':
+                return 'DAY';
+            case 'week':
+                return 'WEEK';
+            case 'month':
+                return 'MONTH';
+            case 'quarter':
+                return 'QUARTER';
+            case 'year':
+                return 'YEAR';
+        }
+    }
+    getExecutionMetrics(projection) {
+        return [
+            ...(projection.bindings.primaryMetrics ?? []),
+            ...(projection.bindings.secondaryMetrics ?? []),
+        ];
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: AnalyticsStatsRequestBuilderService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: AnalyticsStatsRequestBuilderService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: AnalyticsStatsRequestBuilderService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+function provideFieldSelectorRegistryRuntime(map, opts) {
+    return {
+        provide: ENVIRONMENT_INITIALIZER,
+        multi: true,
+        useFactory: () => {
+            const registry = inject(FieldSelectorRegistry);
+            return () => registry.register(map, { overwrite: opts?.overwrite ?? false });
+        },
+    };
+}
+
+function providePraxisToastGlobalActions(opts = {}) {
+    return {
+        provide: GLOBAL_TOAST_SERVICE,
+        useFactory: () => {
+            const snack = (() => { try {
+                return inject(MatSnackBar);
+            }
+            catch {
+                return null;
+            } })();
+            const successDuration = opts.successDurationMs ?? 2500;
+            const errorDuration = opts.errorDurationMs ?? 3500;
+            const successClass = opts.successPanelClass ?? ['pdx-toast-success'];
+            const errorClass = opts.errorPanelClass ?? ['pdx-toast-error'];
+            return {
+                success: (message) => {
+                    if (snack) {
+                        snack.open(message, undefined, { duration: successDuration, panelClass: successClass });
+                    }
+                    else {
+                        console.log('[Toast]', message);
+                    }
+                },
+                error: (message) => {
+                    if (snack) {
+                        snack.open(message, undefined, { duration: errorDuration, panelClass: errorClass });
+                    }
+                    else {
+                        console.error('[Toast]', message);
+                    }
+                },
+            };
+        },
+    };
+}
+
+function providePraxisAnalyticsGlobalActions(opts = {}) {
+    return {
+        provide: GLOBAL_ANALYTICS_SERVICE,
+        useFactory: () => {
+            const telemetry = (() => { try {
+                return inject(TelemetryService);
+            }
+            catch {
+                return null;
+            } })();
+            const prefix = opts.prefix ? `${opts.prefix}.` : '';
+            return {
+                track: (eventName, payload) => {
+                    if (telemetry) {
+                        telemetry.record(`${prefix}${eventName}`, payload);
+                    }
+                    else {
+                        console.log('[Analytics]', `${prefix}${eventName}`, payload ?? null);
+                    }
+                },
+            };
+        },
+    };
+}
+
+/**
+ * Registers only the default visual renderer for Praxis loading.
+ *
+ * This does not wire any HTTP interceptor by itself. Use this when the host
+ * wants a custom HTTP integration path but still wants the stock Praxis UI.
+ */
+function providePraxisLoadingDefaults() {
+    return [
+        {
+            provide: PRAXIS_LOADING_RENDERER,
+            useClass: DefaultLoadingRenderer,
+        },
+    ];
+}
+/**
+ * Official DI-based entrypoint to enable Praxis HTTP loading.
+ *
+ * Recommended when the host already uses DI interceptors, e.g.:
+ *
+ * ```ts
+ * providers: [
+ *   provideHttpClient(withInterceptorsFromDi()),
+ *   ...providePraxisHttpLoading(),
+ * ]
+ * ```
+ *
+ * By default this provider does not register any renderer implementation.
+ * Add `...providePraxisLoadingDefaults()` or a custom `PRAXIS_LOADING_RENDERER`
+ * explicitly so hosts keep full control over visual composition.
+ *
+ * Requests remain opt-in and only show loading when they carry
+ * `PRAXIS_LOADING_CTX` in the `HttpContext`.
+ */
+function providePraxisHttpLoading(opts = {}) {
+    const providers = [
+        {
+            provide: HTTP_INTERCEPTORS,
+            useClass: PraxisLoadingInterceptor,
+            multi: true,
+        },
+    ];
+    if (opts.includeDefaultRenderer === true) {
+        providers.unshift(...providePraxisLoadingDefaults());
+    }
+    return providers;
+}
+/**
+ * Angular modern helper for `provideHttpClient(...)`.
+ *
+ * Usage:
+ *
+ * ```ts
+ * providers: [
+ *   provideHttpClient(
+ *     withInterceptors([authInterceptor]),
+ *     withPraxisHttpLoading(),
+ *   ),
+ *   ...providePraxisLoadingDefaults(),
+ * ]
+ * ```
+ *
+ * Use this helper or `providePraxisHttpLoading()`, never both in the same host.
+ */
+function withPraxisHttpLoading() {
+    return withInterceptors([praxisLoadingInterceptorFn]);
+}
+
+const LOGGER_LEVEL_PRIORITY = {
+    error: 0,
+    warn: 1,
+    info: 2,
+    debug: 3,
+    trace: 4,
+};
+const LOGGER_LEVEL_BY_ENV = {
+    prod: 'warn',
+    qa: 'warn',
+    hml: 'info',
+    dev: 'debug',
+};
+const PRAXIS_CORPORATE_SENSITIVE_KEYS = [
+    'password',
+    'pass',
+    'token',
+    'accessToken',
+    'refreshToken',
+    'authorization',
+    'secret',
+    'apiKey',
+    'cpf',
+    'cnpj',
+    'document',
+    'ssn',
+    'email',
+    'phone',
+];
+const PRAXIS_CORPORATE_THROTTLE = {
+    enabled: true,
+    windowMs: 5000,
+    maxOccurrences: 3,
+};
+function createCorporateLoggerConfig(environment = 'prod') {
+    return {
+        environment,
+        minLevel: LOGGER_LEVEL_BY_ENV[environment],
+        warnOnceEnabled: true,
+        throttle: { ...PRAXIS_CORPORATE_THROTTLE },
+        pii: {
+            enabled: true,
+            redactionText: '[REDACTED]',
+            sensitiveKeys: [...PRAXIS_CORPORATE_SENSITIVE_KEYS],
+        },
+    };
+}
+function resolveLoggerConfig(options = {}) {
+    const environment = options.environment ?? 'prod';
+    const corporate = createCorporateLoggerConfig(environment);
+    const overridePII = options.pii ?? {};
+    return {
+        ...corporate,
+        minLevel: options.minLevel ?? corporate.minLevel,
+        warnOnceEnabled: options.warnOnceEnabled ?? corporate.warnOnceEnabled,
+        throttle: {
+            ...corporate.throttle,
+            ...(options.throttle ?? {}),
+        },
+        pii: {
+            ...corporate.pii,
+            ...overridePII,
+            sensitiveKeys: overridePII.sensitiveKeys
+                ? [...overridePII.sensitiveKeys]
+                : [...corporate.pii.sensitiveKeys],
+        },
+        defaultContext: options.defaultContext
+            ? { ...options.defaultContext }
+            : corporate.defaultContext,
+        environment,
+    };
+}
+
+class ConsoleLoggerSink {
+    log(event) {
+        const print = this.resolveMethod(event.level);
+        const prefix = `[Praxis][${event.level.toUpperCase()}]`;
+        const envelope = {
+            environment: event.environment,
+            timestamp: event.timestamp,
+            context: event.context ?? null,
+            data: event.data ?? null,
+        };
+        if (event.context || event.data !== undefined) {
+            print(`${prefix} ${event.message}`, envelope);
+            return;
+        }
+        print(`${prefix} ${event.message}`);
+    }
+    resolveMethod(level) {
+        if (level === 'error' && typeof console.error === 'function') {
+            return console.error.bind(console);
+        }
+        if (level === 'warn' && typeof console.warn === 'function') {
+            return console.warn.bind(console);
+        }
+        if (level === 'info' && typeof console.info === 'function') {
+            return console.info.bind(console);
+        }
+        if (level === 'debug' && typeof console.debug === 'function') {
+            return console.debug.bind(console);
+        }
+        if (level === 'trace') {
+            if (typeof console.trace === 'function') {
+                return console.trace.bind(console);
+            }
+            if (typeof console.debug === 'function') {
+                return console.debug.bind(console);
+            }
+        }
+        return console.log.bind(console);
+    }
+}
+
+const PRAXIS_LOGGER_CONFIG = new InjectionToken('PRAXIS_LOGGER_CONFIG', {
     providedIn: 'root',
     factory: () => createCorporateLoggerConfig('prod'),
 });
@@ -9078,16 +10131,98 @@ const SURFACE_OPEN_I18N_CONFIG = {
     },
 };
 
+/**
+ * Authoring/editor drawer bridge.
+ *
+ * Use this token for settings/configuration flows that depend on
+ * `SettingsValueProvider` semantics (`apply/save/reset/cancel`).
+ *
+ * Runtime surfaces opened by `surface.open` should migrate to
+ * `SURFACE_DRAWER_BRIDGE`, which carries runtime-oriented semantics instead of
+ * editor semantics.
+ */
 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.
 const SETTINGS_PANEL_DATA = new InjectionToken('SETTINGS_PANEL_DATA');
 
+const SURFACE_DRAWER_BRIDGE = new InjectionToken('SURFACE_DRAWER_BRIDGE');
+
 const TABLE_CONFIG_EDITOR = new InjectionToken('TABLE_CONFIG_EDITOR');
 const STEPPER_CONFIG_EDITOR = new InjectionToken('STEPPER_CONFIG_EDITOR');
 const DYNAMIC_PAGE_SHELL_EDITOR = new InjectionToken('DYNAMIC_PAGE_SHELL_EDITOR');
 const DYNAMIC_PAGE_CONFIG_EDITOR = new InjectionToken('DYNAMIC_PAGE_CONFIG_EDITOR');
 
+const RESOURCE_DISCOVERY_I18N_NAMESPACE = 'resourceDiscovery';
+const RESOURCE_AVAILABILITY_REASON_KEY_BY_CODE = {
+    'resource-state-blocked': 'availability.reason.resource-state-blocked',
+    'missing-authority': 'availability.reason.missing-authority',
+    'resource-context-required': 'availability.reason.resource-context-required',
+    'resource-not-found': 'availability.reason.resource-not-found',
+};
+const RESOURCE_DISCOVERY_I18N_CONFIG = {
+    namespaces: {
+        [RESOURCE_DISCOVERY_I18N_NAMESPACE]: {
+            'pt-BR': {
+                'workflow.unavailable.default': 'A\u00e7\u00e3o indispon\u00edvel no contexto atual.',
+                'workflow.unavailable.withReason': 'A\u00e7\u00e3o indispon\u00edvel: {{reason}}',
+                'rowActions.menu.loading': 'Carregando a\u00e7\u00f5es contextuais',
+                'rowActions.menu.more': 'Mais a\u00e7\u00f5es',
+                'availability.reason.resource-state-blocked': 'Dependente do estado atual do registro.',
+                'availability.reason.missing-authority': 'Voc\u00ea n\u00e3o tem permiss\u00e3o para executar esta a\u00e7\u00e3o.',
+                'availability.reason.resource-context-required': 'Abra um item espec\u00edfico para continuar.',
+                'availability.reason.resource-not-found': 'O registro n\u00e3o est\u00e1 dispon\u00edvel.',
+                'availability.reason.unknown': 'O contexto atual n\u00e3o permite esta a\u00e7\u00e3o.',
+            },
+            'en-US': {
+                'workflow.unavailable.default': 'Action is unavailable in the current context.',
+                'workflow.unavailable.withReason': 'Action unavailable: {{reason}}',
+                'rowActions.menu.loading': 'Loading contextual actions',
+                'rowActions.menu.more': 'More actions',
+                'availability.reason.resource-state-blocked': 'Blocked by the current resource state.',
+                'availability.reason.missing-authority': 'You do not have permission to perform this action.',
+                'availability.reason.resource-context-required': 'Open a specific item to continue.',
+                'availability.reason.resource-not-found': 'The record is not available.',
+                'availability.reason.unknown': 'The current context does not allow this action.',
+            },
+        },
+    },
+};
+function normalizeResourceAvailabilityReasonCode(reason) {
+    return String(reason || '').trim().toLowerCase();
+}
+function resolveResourceAvailabilityReasonKey(reason) {
+    const normalized = normalizeResourceAvailabilityReasonCode(reason);
+    return (RESOURCE_AVAILABILITY_REASON_KEY_BY_CODE[normalized] ||
+        'availability.reason.unknown');
+}
+function translateResourceDiscoveryText(i18n, key, params, fallback) {
+    return i18n.t(key, params, fallback, RESOURCE_DISCOVERY_I18N_NAMESPACE);
+}
+function translateResourceAvailabilityReason(i18n, reason) {
+    const key = resolveResourceAvailabilityReasonKey(reason);
+    const fallback = key === 'availability.reason.resource-state-blocked'
+        ? 'Dependente do estado atual do registro.'
+        : key === 'availability.reason.missing-authority'
+            ? 'Voc\u00ea n\u00e3o tem permiss\u00e3o para executar esta a\u00e7\u00e3o.'
+            : key === 'availability.reason.resource-context-required'
+                ? 'Abra um item espec\u00edfico para continuar.'
+                : key === 'availability.reason.resource-not-found'
+                    ? 'O registro n\u00e3o est\u00e1 dispon\u00edvel.'
+                    : 'O contexto atual n\u00e3o permite esta a\u00e7\u00e3o.';
+    return translateResourceDiscoveryText(i18n, key, undefined, fallback);
+}
+function translateUnavailableWorkflowMessage(i18n, availability) {
+    const reason = normalizeResourceAvailabilityReasonCode(availability?.reason);
+    if (!reason) {
+        return translateResourceDiscoveryText(i18n, 'workflow.unavailable.default', undefined, 'A\u00e7\u00e3o indispon\u00edvel no contexto atual.');
+    }
+    const translatedReason = translateResourceAvailabilityReason(i18n, reason);
+    return translateResourceDiscoveryText(i18n, 'workflow.unavailable.withReason', {
+        reason: translatedReason,
+    }, `A\u00e7\u00e3o indispon\u00edvel: ${translatedReason}`);
+}
+
 const DEFAULT_LOCALE = 'en-US';
 const DEFAULT_DATE_TIME = {
     dateFormat: 'shortDate',
@@ -11693,6 +12828,196 @@ function getEditorialSolutionPresetById(presetId) {
     return match ? structuredClone(match) : undefined;
 }
 
+const WIDGET_PAGE_COMPOSITION_SCHEMA_VERSION = '1.0.0';
+/**
+ * Normalizes a CompositionLink for deterministic persistence.
+ * Ensures explicit ordering and strips compatibility-only legacy residues.
+ */
+function normalizeCompositionLink(link) {
+    const normalized = {
+        id: link.id,
+        from: normalizeEndpoint$1(link.from),
+        to: normalizeEndpoint$1(link.to),
+        intent: link.intent,
+    };
+    if (link.transform) {
+        normalized.transform = clone(link.transform);
+    }
+    const conditions = normalizeConditions(link.conditions);
+    if (conditions) {
+        normalized.conditions = conditions;
+    }
+    const policy = normalizePolicy(link.policy);
+    if (policy) {
+        normalized.policy = policy;
+    }
+    const metadata = normalizeMetadata(link.metadata);
+    if (metadata) {
+        normalized.metadata = metadata;
+    }
+    return normalized;
+}
+/**
+ * Normalizes an array of CompositionLinks for deterministic persistence.
+ */
+function normalizeCompositionLinks(links) {
+    return links
+        .map(normalizeCompositionLink)
+        .sort(compareNormalizedLinks);
+}
+/**
+ * Canonical persisted write surface for CompositionLink[].
+ * New saved shapes must serialize links under `composition.links`.
+ */
+function serializeCompositionLinks(links) {
+    return {
+        version: WIDGET_PAGE_COMPOSITION_SCHEMA_VERSION,
+        links: normalizeCompositionLinks(links),
+    };
+}
+/**
+ * Writes the canonical persisted composition surface into a page shape.
+ * The canonical writer omits legacy `connections` to avoid dual-write ambiguity.
+ */
+function writeCompositionLinksToPersistedPage(page, links) {
+    const { composition: _legacyComposition, ...rest } = clone(page);
+    return {
+        ...rest,
+        composition: serializeCompositionLinks(links),
+    };
+}
+function normalizeEndpoint$1(endpoint) {
+    if (endpoint.kind === 'component-port') {
+        return {
+            kind: 'component-port',
+            ref: {
+                widget: endpoint.ref.widget,
+                port: endpoint.ref.port,
+                direction: endpoint.ref.direction,
+                ...(endpoint.ref.componentType ? { componentType: endpoint.ref.componentType } : {}),
+                ...(endpoint.ref.bindingPath ? { bindingPath: endpoint.ref.bindingPath } : {}),
+            },
+        };
+    }
+    return {
+        kind: 'state',
+        ref: {
+            path: endpoint.ref.path,
+            ...(endpoint.ref.layer ? { layer: endpoint.ref.layer } : {}),
+        },
+    };
+}
+function normalizeConditions(conditions) {
+    if (!conditions?.length) {
+        return undefined;
+    }
+    return conditions
+        .map((condition) => ({
+        kind: condition.kind,
+        ...(condition.expression ? { expression: condition.expression } : {}),
+        ...(condition.path ? { path: condition.path } : {}),
+        ...(condition.value !== undefined ? { value: clone(condition.value) } : {}),
+        ...(condition.negate !== undefined ? { negate: condition.negate } : {}),
+        ...(condition.description ? { description: condition.description } : {}),
+    }))
+        .sort(compareConditions);
+}
+function normalizePolicy(policy) {
+    if (!policy) {
+        return undefined;
+    }
+    const normalized = {
+        ...(policy.debounceMs !== undefined ? { debounceMs: policy.debounceMs } : {}),
+        ...(policy.distinct !== undefined ? { distinct: policy.distinct } : {}),
+        ...(policy.distinctBy ? { distinctBy: policy.distinctBy } : {}),
+        ...(policy.delivery ? { delivery: policy.delivery } : {}),
+        ...(policy.missingValuePolicy ? { missingValuePolicy: policy.missingValuePolicy } : {}),
+        ...(policy.errorPolicy ? { errorPolicy: policy.errorPolicy } : {}),
+    };
+    return Object.keys(normalized).length ? normalized : undefined;
+}
+function normalizeMetadata(metadata) {
+    if (!metadata) {
+        return undefined;
+    }
+    const tags = metadata.tags?.length
+        ? [...metadata.tags].sort((a, b) => a.localeCompare(b))
+        : undefined;
+    const source = metadata.source === 'legacy-widget-connection'
+        ? undefined
+        : metadata.source;
+    const normalized = {
+        ...(metadata.label ? { label: metadata.label } : {}),
+        ...(metadata.description ? { description: metadata.description } : {}),
+        ...(tags?.length ? { tags } : {}),
+        ...(metadata.deprecated !== undefined ? { deprecated: metadata.deprecated } : {}),
+        ...(source ? { source } : {}),
+    };
+    return Object.keys(normalized).length ? normalized : undefined;
+}
+function compareConditions(a, b) {
+    return compareValues([
+        a.kind,
+        a.expression || '',
+        a.path || '',
+        JSON.stringify(a.value ?? null),
+        String(a.negate ?? ''),
+        a.description || '',
+    ], [
+        b.kind,
+        b.expression || '',
+        b.path || '',
+        JSON.stringify(b.value ?? null),
+        String(b.negate ?? ''),
+        b.description || '',
+    ]);
+}
+function compareNormalizedLinks(a, b) {
+    return compareValues([
+        a.id,
+        a.intent,
+        endpointSortKey(a.from),
+        endpointSortKey(a.to),
+    ], [
+        b.id,
+        b.intent,
+        endpointSortKey(b.from),
+        endpointSortKey(b.to),
+    ]);
+}
+function endpointSortKey(endpoint) {
+    if (endpoint.kind === 'component-port') {
+        return [
+            endpoint.kind,
+            endpoint.ref.widget,
+            endpoint.ref.port,
+            endpoint.ref.direction,
+            endpoint.ref.bindingPath || '',
+            endpoint.ref.componentType || '',
+        ].join('|');
+    }
+    return [
+        endpoint.kind,
+        endpoint.ref.path,
+        endpoint.ref.layer || '',
+    ].join('|');
+}
+function compareValues(left, right) {
+    for (let index = 0; index < Math.max(left.length, right.length); index += 1) {
+        const comparison = (left[index] || '').localeCompare(right[index] || '');
+        if (comparison !== 0) {
+            return comparison;
+        }
+    }
+    return 0;
+}
+function clone(value) {
+    if (value == null || typeof value !== 'object') {
+        return value;
+    }
+    return JSON.parse(JSON.stringify(value));
+}
+
 /** Utility: generate a random id using crypto.randomUUID or fallback. */
 function generateId() {
     const g = globalThis.crypto?.randomUUID?.();
@@ -11732,7 +13057,8 @@ function ensurePageIds(page) {
  * Create a persisted page record from an in-memory page definition and identity.
  */
 function createPersistedPage(identity, page, opts) {
-    const { page: pageWithIds } = ensurePageIds(page);
+    const persistedPage = writeCompositionLinksToPersistedPage(page, page.composition?.links || []);
+    const { page: pageWithIds } = ensurePageIds(persistedPage);
     const now = new Date().toISOString();
     return {
         id: opts?.id || generateId(),
@@ -12977,104 +14303,29 @@ const GLOBAL_ACTION_UI_SCHEMAS = [
         ],
     },
     {
-        id: 'copyToClipboard',
-        label: 'Copiar para clipboard',
-        fields: [
-            { key: 'text', label: 'Texto', type: 'text' },
-            { key: 'useFieldValue', label: 'Usar valor do campo', type: 'toggle' },
-        ],
-    },
-    {
-        id: 'refreshOptions',
-        label: 'Recarregar opções',
-        fields: [{ key: 'field', label: 'Campo', type: 'text', required: true }],
-    },
-    {
-        id: 'loadDependentData',
-        label: 'Carregar dependentes',
-        fields: [{ key: 'field', label: 'Campo alvo', type: 'text', required: true }],
-    },
-];
-function getGlobalActionUiSchema(id) {
-    if (!id)
-        return undefined;
-    return GLOBAL_ACTION_UI_SCHEMAS.find((schema) => schema.id === id);
-}
-
-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: [],
-        },
+        id: 'copyToClipboard',
+        label: 'Copiar para clipboard',
+        fields: [
+            { key: 'text', label: 'Texto', type: 'text' },
+            { key: 'useFieldValue', label: 'Usar valor do campo', type: 'toggle' },
+        ],
+    },
+    {
+        id: 'refreshOptions',
+        label: 'Recarregar opções',
+        fields: [{ key: 'field', label: 'Campo', type: 'text', required: true }],
+    },
+    {
+        id: 'loadDependentData',
+        label: 'Carregar dependentes',
+        fields: [{ key: 'field', label: 'Campo alvo', type: 'text', required: true }],
     },
 ];
+function getGlobalActionUiSchema(id) {
+    if (!id)
+        return undefined;
+    return GLOBAL_ACTION_UI_SCHEMAS.find((schema) => schema.id === id);
+}
 
 class SurfaceOpenActionEditorComponent {
     value;
@@ -13806,7 +15057,7 @@ class SurfaceOpenActionEditorComponent {
         </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: i5.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "ngmodule", type: MatInputModule }, { kind: "directive", type: i5$1.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: i8.MatTooltip, selector: "[matTooltip]", inputs: ["matTooltipPosition", "matTooltipPositionAtOrigin", "matTooltipDisabled", "matTooltipShowDelay", "matTooltipHideDelay", "matTooltipTouchGestures", "matTooltip", "matTooltipClass"], exportAs: ["matTooltip"] }] });
+  `, 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: i3$1.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: i8.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,
@@ -15078,11 +16329,11 @@ const ENUMS = {
     actionPlacement: ['header', 'window'],
 };
 const CAPS = [
-    { path: 'page', category: 'page', valueKind: 'object', description: 'Definição da página dinâmica.' },
+    { path: 'page', category: 'page', valueKind: 'object', description: 'Definicao da pagina dinamica.' },
     { path: 'page.context', category: 'context', valueKind: 'object', description: 'Contexto compartilhado entre widgets.' },
-    { path: 'page.layout', category: 'layout', valueKind: 'object', description: 'Layout base da página.' },
-    { path: 'page.layout.orientation', category: 'layout', valueKind: 'enum', allowedValues: ENUMS.layoutOrientation, description: 'Orientação do grid (vertical/columns).' },
-    { path: 'page.layout.columns', category: 'layout', valueKind: 'number', description: 'Número de colunas (quando orientation=columns).' },
+    { path: 'page.layout', category: 'layout', valueKind: 'object', description: 'Layout base da pagina.' },
+    { path: 'page.layout.orientation', category: 'layout', valueKind: 'enum', allowedValues: ENUMS.layoutOrientation, description: 'Orientacao do grid (vertical/columns).' },
+    { path: 'page.layout.columns', category: 'layout', valueKind: 'number', description: 'Numero de colunas (quando orientation=columns).' },
     { path: 'page.layout.gap', category: 'layout', valueKind: 'string', description: 'Gap entre widgets (ex: 16px).' },
     { path: 'page.layout.breakpoints', category: 'layout', valueKind: 'object', description: 'Colunas por breakpoint.' },
     { path: 'page.layout.breakpoints.sm', category: 'layout', valueKind: 'number', description: 'Colunas para breakpoint sm.' },
@@ -15090,46 +16341,49 @@ const CAPS = [
     { path: 'page.layout.breakpoints.lg', category: 'layout', valueKind: 'number', description: 'Colunas para breakpoint lg.' },
     { path: 'page.layout.breakpoints.xl', category: 'layout', valueKind: 'number', description: 'Colunas para breakpoint xl.' },
     { path: 'page.widgets', category: 'widgets', valueKind: 'array', description: 'Lista de widgets renderizados.' },
-    { path: 'page.widgets[].key', category: 'widgets', valueKind: 'string', description: 'Identificador único do widget.' },
+    { path: 'page.widgets[].key', category: 'widgets', valueKind: 'string', description: 'Identificador unico do widget.' },
     { path: 'page.widgets[].className', category: 'widgets', valueKind: 'string', description: 'Classe CSS opcional do widget.' },
     { path: 'page.widgets[].definition.id', category: 'widgets', valueKind: 'string', description: 'ID do componente do widget (ex: praxis-table).' },
     { path: 'page.widgets[].definition.inputs', category: 'widgets', valueKind: 'object', description: 'Inputs iniciais do widget.' },
     { path: 'page.widgets[].definition.bindingOrder', category: 'widgets', valueKind: 'array', description: 'Ordem de binding de inputs.' },
-    { path: 'page.widgets[].shell', category: 'shell', valueKind: 'object', description: 'Configuração do shell do widget.' },
+    { path: 'page.widgets[].shell', category: 'shell', valueKind: 'object', description: 'Configuracao do shell do widget.' },
     { path: 'page.widgets[].shell.kind', category: 'shell', valueKind: 'enum', allowedValues: ENUMS.shellKind, description: 'Tipo de shell.' },
-    { path: 'page.widgets[].shell.title', category: 'shell', valueKind: 'string', description: 'Título do shell.' },
-    { path: 'page.widgets[].shell.subtitle', category: 'shell', valueKind: 'string', description: 'Subtítulo do shell.' },
-    { path: 'page.widgets[].shell.icon', category: 'shell', valueKind: 'string', description: 'Ícone do shell.' },
+    { path: 'page.widgets[].shell.title', category: 'shell', valueKind: 'string', description: 'Titulo do shell.' },
+    { path: 'page.widgets[].shell.subtitle', category: 'shell', valueKind: 'string', description: 'Subtitulo do shell.' },
+    { path: 'page.widgets[].shell.icon', category: 'shell', valueKind: 'string', description: 'Icone do shell.' },
     { path: 'page.widgets[].shell.showHeader', category: 'shell', valueKind: 'boolean', description: 'Exibe o header do shell.' },
-    { path: 'page.widgets[].shell.actions', category: 'shell', valueKind: 'array', description: 'Ações do shell.' },
-    { path: 'page.widgets[].shell.actions[].id', category: 'shell', valueKind: 'string', description: 'ID da ação.' },
-    { path: 'page.widgets[].shell.actions[].label', category: 'shell', valueKind: 'string', description: 'Label da ação.' },
-    { path: 'page.widgets[].shell.actions[].icon', category: 'shell', valueKind: 'string', description: 'Ícone da ação.' },
-    { path: 'page.widgets[].shell.actions[].variant', category: 'shell', valueKind: 'enum', allowedValues: ENUMS.actionVariant, description: 'Estilo visual da ação.' },
-    { path: 'page.widgets[].shell.actions[].placement', category: 'shell', valueKind: 'enum', allowedValues: ENUMS.actionPlacement, description: 'Posicionamento da ação.' },
-    { path: 'page.widgets[].shell.actions[].emit', category: 'shell', valueKind: 'string', description: 'Evento emitido ao acionar a ação.' },
-    { path: 'page.connections', category: 'connections', valueKind: 'array', description: 'Conexões entre widgets.' },
-    { path: 'page.connections[].from.widget', category: 'connections', valueKind: 'string', description: 'Widget de origem.' },
-    { path: 'page.connections[].from.output', category: 'connections', valueKind: 'string', description: 'Output de origem.' },
-    { path: 'page.connections[].to.widget', category: 'connections', valueKind: 'string', description: 'Widget de destino.' },
-    { path: 'page.connections[].to.input', category: 'connections', valueKind: 'string', description: 'Input de destino.' },
-    { path: 'page.connections[].to.bindingOrder', category: 'connections', valueKind: 'array', description: 'Ordem de binding no destino.' },
-    { path: 'page.connections[].map', category: 'connections', valueKind: 'string', description: 'Caminho de extração do payload.' },
-    { path: 'page.connections[].set', category: 'connections', valueKind: 'object', description: 'Valor constante para a conexão.' },
+    { path: 'page.widgets[].shell.actions', category: 'shell', valueKind: 'array', description: 'Acoes do shell.' },
+    { path: 'page.widgets[].shell.actions[].id', category: 'shell', valueKind: 'string', description: 'ID da acao.' },
+    { path: 'page.widgets[].shell.actions[].label', category: 'shell', valueKind: 'string', description: 'Label da acao.' },
+    { path: 'page.widgets[].shell.actions[].icon', category: 'shell', valueKind: 'string', description: 'Icone da acao.' },
+    { path: 'page.widgets[].shell.actions[].variant', category: 'shell', valueKind: 'enum', allowedValues: ENUMS.actionVariant, description: 'Estilo visual da acao.' },
+    { path: 'page.widgets[].shell.actions[].placement', category: 'shell', valueKind: 'enum', allowedValues: ENUMS.actionPlacement, description: 'Posicionamento da acao.' },
+    { path: 'page.widgets[].shell.actions[].emit', category: 'shell', valueKind: 'string', description: 'Evento emitido ao acionar a acao.' },
+    { path: 'page.composition', category: 'connections', valueKind: 'object', description: 'Envelope canonico da composicao persistida.' },
+    { path: 'page.composition.version', category: 'connections', valueKind: 'string', description: 'Versao do envelope de composicao.' },
+    { path: 'page.composition.links', category: 'connections', valueKind: 'array', description: 'Links canonicos entre widgets e estado.' },
+    { path: 'page.composition.links[].id', category: 'connections', valueKind: 'string', description: 'Identificador estavel do link.' },
+    { path: 'page.composition.links[].from', category: 'connections', valueKind: 'object', description: 'Endpoint de origem do link.' },
+    { path: 'page.composition.links[].to', category: 'connections', valueKind: 'object', description: 'Endpoint de destino do link.' },
+    { path: 'page.composition.links[].intent', category: 'connections', valueKind: 'string', description: 'Intencao semantica do link.' },
+    { path: 'page.composition.links[].transform', category: 'connections', valueKind: 'object', description: 'Pipeline de transformacao do link.' },
+    { path: 'page.composition.links[].conditions', category: 'connections', valueKind: 'array', description: 'Condicoes opcionais de entrega.' },
+    { path: 'page.composition.links[].policy', category: 'connections', valueKind: 'object', description: 'Politicas opcionais de entrega.' },
+    { path: 'page.composition.links[].metadata', category: 'connections', valueKind: 'object', description: 'Metadados opcionais do link.' },
 ];
 const DYNAMIC_PAGE_AI_CAPABILITIES = {
     version: 'v1.0',
     enums: ENUMS,
     targets: ['praxis-dynamic-page'],
     notes: [
-        'Este catálogo é específico para o componente praxis-dynamic-page.',
-        'Widgets e connections são arrays; o adapter faz merge por key.',
-        'Para remoção/replace, use flags {_remove:true} ou {_replace:true} no item.',
-        'Para alterar origem/destino de conexão, inclua {_beforeKey:"from|out|to|in"} no item.',
-        'Inputs de widgets dependem do componente (ex: praxis-table, praxis-dynamic-form). Evite inventar campos; prefira pedir confirmação.',
-        'Use keys estáveis para widgets ao criar conexões.',
-        'Objetivo: compor widgets e relacionamentos (ex.: master-detail).',
-        'Conexões típicas: table.rowClick -> form.resourceId (map: payload.row.id). Para master-detail, use este padrão.',
+        'Este catalogo e especifico para o componente praxis-dynamic-page.',
+        'Widgets e page.composition.links sao arrays; o adapter faz merge por key estavel.',
+        'Para remocao/replace, use flags {_remove:true} ou {_replace:true} no item.',
+        'Para renomear um link, inclua {_beforeKey:"link-id-anterior"} no item.',
+        'Inputs de widgets dependem do componente (ex: praxis-table, praxis-dynamic-form). Evite inventar campos; prefira pedir confirmacao.',
+        'Use ids estaveis para links e keys estaveis para widgets.',
+        'Objetivo: compor widgets e relacionamentos canonicos (ex.: master-detail).',
+        'Link tipico de master-detail: component-port(table.rowClick) -> component-port(form.resourceId) com transform map payload.row.id.',
     ],
     capabilities: CAPS,
 };
@@ -15154,7 +16408,7 @@ const DYNAMIC_PAGE_COMPONENT_CONTEXT_PACK = {
         'page.widgets[].shell.actions[].variant': {
             mode: 'enum',
             options: [
-                { value: 'icon', label: 'Ícone' },
+                { value: 'icon', label: 'Icone' },
                 { value: 'text', label: 'Texto' },
                 { value: 'outlined', label: 'Outlined' },
             ],
@@ -15166,25 +16420,39 @@ const DYNAMIC_PAGE_COMPONENT_CONTEXT_PACK = {
                 { value: 'window', label: 'Janela' },
             ],
         },
-        'page.connections[].from.output': {
+        'page.composition.version': {
+            mode: 'enum',
+            options: [
+                { value: '1.0.0', label: 'Schema canonico 1.0.0' },
+            ],
+        },
+        'page.composition.links[].intent': {
+            mode: 'enum',
+            options: [
+                { value: 'event-propagation', label: 'Propagacao de evento' },
+                { value: 'state-read', label: 'Leitura de estado' },
+                { value: 'state-write', label: 'Escrita de estado' },
+            ],
+        },
+        'page.composition.links[].from.ref.port': {
             mode: 'suggested',
             options: [
-                { value: 'rowClick', label: 'Clique na linha (praxis-table)', example: 'Usar table.rowClick -> form.resourceId' },
-                { value: 'rowAction', label: 'Ação da linha (praxis-table)' },
-                { value: 'formSubmit', label: 'Submit do formulário (praxis-dynamic-form)' },
+                { value: 'rowClick', label: 'Clique na linha (praxis-table)', example: 'Usar table.rowClick -> form.resourceId via transform pick-path payload.row.id' },
+                { value: 'rowAction', label: 'Acao da linha (praxis-table)' },
+                { value: 'formSubmit', label: 'Submit do formulario (praxis-dynamic-form)' },
             ],
         },
-        'page.connections[].to.input': {
+        'page.composition.links[].to.ref.port': {
             mode: 'suggested',
             options: [
-                { value: 'resourceId', label: 'ID do registro (praxis-dynamic-form)', example: 'map: payload.row.id' },
-                { value: 'mode', label: 'Modo do formulário (create|edit|view)' },
+                { value: 'resourceId', label: 'ID do registro (praxis-dynamic-form)', example: 'transform pick-path payload.row.id' },
+                { value: 'mode', label: 'Modo do formulario (create|edit|view)' },
             ],
         },
-        'page.connections[].map': {
+        'page.composition.links[].transform.steps[].config.path': {
             mode: 'suggested',
             options: [
-                { value: 'payload.row.id', label: 'ID padrão do registro', example: 'rowClick -> resourceId' },
+                { value: 'payload.row.id', label: 'ID padrao do registro', example: 'rowClick -> resourceId' },
             ],
         },
     },
@@ -15208,21 +16476,20 @@ const DYNAMIC_PAGE_COMPONENT_CONTEXT_PACK = {
             requiresExistingTarget: true,
             scope: 'ROW',
             params: [
-                { name: 'fromWidget', type: 'STRING' },
-                { name: 'fromOutput', type: 'STRING' },
-                { name: 'toWidget', type: 'STRING' },
-                { name: 'toInput', type: 'STRING' },
+                { name: 'linkId', type: 'STRING' },
             ],
             patchTemplate: {
                 page: {
-                    connections: [
-                        {
-                            _beforeKey: '{{target}}',
-                            from: { widget: '{{params.fromWidget}}', output: '{{params.fromOutput}}' },
-                            to: { widget: '{{params.toWidget}}', input: '{{params.toInput}}' },
-                            _remove: true,
-                        },
-                    ],
+                    composition: {
+                        version: '1.0.0',
+                        links: [
+                            {
+                                _beforeKey: '{{target}}',
+                                id: '{{params.linkId}}',
+                                _remove: true,
+                            },
+                        ],
+                    },
                 },
             },
         },
@@ -15323,14 +16590,40 @@ const DYNAMIC_PAGE_COMPONENT_CONTEXT_PACK = {
             ],
             patchTemplate: {
                 page: {
-                    connections: [
-                        {
-                            from: { widget: '{{params.fromWidget}}', output: '{{params.fromOutput}}' },
-                            to: { widget: '{{params.toWidget}}', input: '{{params.toInput}}' },
-                            set: '{{params.value}}',
-                            _replace: true,
-                        },
-                    ],
+                    composition: {
+                        version: '1.0.0',
+                        links: [
+                            {
+                                id: '{{params.fromWidget}}.{{params.fromOutput}}->{{params.toWidget}}.{{params.toInput}}',
+                                from: {
+                                    kind: 'component-port',
+                                    ref: { widget: '{{params.fromWidget}}', port: '{{params.fromOutput}}', direction: 'output' },
+                                },
+                                to: {
+                                    kind: 'component-port',
+                                    ref: { widget: '{{params.toWidget}}', port: '{{params.toInput}}', direction: 'input' },
+                                },
+                                intent: 'event-propagation',
+                                transform: {
+                                    version: '2.0',
+                                    phase: 'link-propagation',
+                                    mode: 'single-value',
+                                    steps: [
+                                        {
+                                            id: 'constant-value',
+                                            kind: 'constant',
+                                            phase: 'link-propagation',
+                                            config: { value: '{{params.value}}' },
+                                        },
+                                    ],
+                                },
+                                metadata: {
+                                    source: 'persisted-composition-link',
+                                },
+                                _replace: true,
+                            },
+                        ],
+                    },
                 },
             },
         },
@@ -15372,13 +16665,27 @@ const DYNAMIC_PAGE_COMPONENT_CONTEXT_PACK = {
             ],
             patchTemplate: {
                 page: {
-                    connections: [
-                        {
-                            _beforeKey: '{{params.beforeFromWidget}}|{{params.beforeFromOutput}}|{{params.beforeToWidget}}|{{params.beforeToInput}}',
-                            from: { widget: '{{params.fromWidget}}', output: '{{params.fromOutput}}' },
-                            to: { widget: '{{params.toWidget}}', input: '{{params.toInput}}' },
-                        },
-                    ],
+                    composition: {
+                        version: '1.0.0',
+                        links: [
+                            {
+                                _beforeKey: '{{params.beforeFromWidget}}.{{params.beforeFromOutput}}->{{params.beforeToWidget}}.{{params.beforeToInput}}',
+                                id: '{{params.fromWidget}}.{{params.fromOutput}}->{{params.toWidget}}.{{params.toInput}}',
+                                from: {
+                                    kind: 'component-port',
+                                    ref: { widget: '{{params.fromWidget}}', port: '{{params.fromOutput}}', direction: 'output' },
+                                },
+                                to: {
+                                    kind: 'component-port',
+                                    ref: { widget: '{{params.toWidget}}', port: '{{params.toInput}}', direction: 'input' },
+                                },
+                                intent: 'event-propagation',
+                                metadata: {
+                                    source: 'persisted-composition-link',
+                                },
+                            },
+                        ],
+                    },
                 },
             },
         },
@@ -15392,7 +16699,7 @@ const DYNAMIC_PAGE_COMPONENT_CONTEXT_PACK = {
                 { name: 'widgetKey', type: 'STRING' },
                 { name: 'resourcePath', type: 'STRING' },
             ],
-            safetyNotes: 'Use apenas resourcePath base. Evite inventar colunas; deixe config mínima.',
+            safetyNotes: 'Use apenas resourcePath base. Evite inventar colunas; deixe config minima.',
             patchTemplate: {
                 page: {
                     widgets: [
@@ -15457,17 +16764,44 @@ const DYNAMIC_PAGE_COMPONENT_CONTEXT_PACK = {
                 { name: 'toInput', type: 'STRING' },
                 { name: 'map', type: 'STRING' },
             ],
-            safetyNotes: 'Use map payload.row.id para master-detail padrão.',
+            safetyNotes: 'Use transform pick-path payload.row.id para master-detail padrao.',
             patchTemplate: {
                 page: {
-                    connections: [
-                        {
-                            from: { widget: '{{params.fromWidget}}', output: '{{params.fromOutput}}' },
-                            to: { widget: '{{params.toWidget}}', input: '{{params.toInput}}' },
-                            map: '{{params.map}}',
-                            _replace: true,
-                        },
-                    ],
+                    composition: {
+                        version: '1.0.0',
+                        links: [
+                            {
+                                id: '{{params.fromWidget}}.{{params.fromOutput}}->{{params.toWidget}}.{{params.toInput}}',
+                                from: {
+                                    kind: 'component-port',
+                                    ref: { widget: '{{params.fromWidget}}', port: '{{params.fromOutput}}', direction: 'output' },
+                                },
+                                to: {
+                                    kind: 'component-port',
+                                    ref: { widget: '{{params.toWidget}}', port: '{{params.toInput}}', direction: 'input' },
+                                },
+                                intent: 'event-propagation',
+                                transform: {
+                                    version: '2.0',
+                                    phase: 'link-propagation',
+                                    mode: 'single-value',
+                                    steps: [
+                                        {
+                                            id: 'pick-master-detail-value',
+                                            kind: 'pick-path',
+                                            phase: 'link-propagation',
+                                            input: { source: 'event' },
+                                            config: { path: '{{params.map}}' },
+                                        },
+                                    ],
+                                },
+                                metadata: {
+                                    source: 'persisted-composition-link',
+                                },
+                                _replace: true,
+                            },
+                        ],
+                    },
                 },
             },
         },
@@ -15481,17 +16815,44 @@ const DYNAMIC_PAGE_COMPONENT_CONTEXT_PACK = {
                 { name: 'fromWidget', type: 'STRING' },
                 { name: 'toWidget', type: 'STRING' },
             ],
-            safetyNotes: 'Padrao master-detail: rowClick -> resourceId com map payload.row.id.',
+            safetyNotes: 'Padrao master-detail: rowClick -> resourceId com transform pick-path payload.row.id.',
             patchTemplate: {
                 page: {
-                    connections: [
-                        {
-                            from: { widget: '{{params.fromWidget}}', output: 'rowClick' },
-                            to: { widget: '{{params.toWidget}}', input: 'resourceId' },
-                            map: 'payload.row.id',
-                            _replace: true,
-                        },
-                    ],
+                    composition: {
+                        version: '1.0.0',
+                        links: [
+                            {
+                                id: '{{params.fromWidget}}.rowClick->{{params.toWidget}}.resourceId',
+                                from: {
+                                    kind: 'component-port',
+                                    ref: { widget: '{{params.fromWidget}}', port: 'rowClick', direction: 'output' },
+                                },
+                                to: {
+                                    kind: 'component-port',
+                                    ref: { widget: '{{params.toWidget}}', port: 'resourceId', direction: 'input' },
+                                },
+                                intent: 'event-propagation',
+                                transform: {
+                                    version: '2.0',
+                                    phase: 'link-propagation',
+                                    mode: 'single-value',
+                                    steps: [
+                                        {
+                                            id: 'pick-master-row-id',
+                                            kind: 'pick-path',
+                                            phase: 'link-propagation',
+                                            input: { source: 'event' },
+                                            config: { path: 'payload.row.id' },
+                                        },
+                                    ],
+                                },
+                                metadata: {
+                                    source: 'persisted-composition-link',
+                                },
+                                _replace: true,
+                            },
+                        ],
+                    },
                 },
             },
         },
@@ -15506,7 +16867,7 @@ const DYNAMIC_PAGE_COMPONENT_CONTEXT_PACK = {
                 { name: 'formId', type: 'STRING' },
                 { name: 'resourcePath', type: 'STRING' },
             ],
-            safetyNotes: 'Padrao master-detail: tabela (rowClick) -> formulario (resourceId) com map payload.row.id.',
+            safetyNotes: 'Padrao master-detail: tabela (rowClick) -> formulario (resourceId) com transform pick-path payload.row.id.',
             patchTemplate: {
                 page: {
                     widgets: [
@@ -15537,45 +16898,72 @@ const DYNAMIC_PAGE_COMPONENT_CONTEXT_PACK = {
                             _replace: true,
                         },
                     ],
-                    connections: [
-                        {
-                            from: { widget: '{{params.tableId}}', output: 'rowClick' },
-                            to: { widget: '{{params.formId}}', input: 'resourceId' },
-                            map: 'payload.row.id',
-                            _replace: true,
-                        },
-                    ],
+                    composition: {
+                        version: '1.0.0',
+                        links: [
+                            {
+                                id: '{{params.tableId}}.rowClick->{{params.formId}}.resourceId',
+                                from: {
+                                    kind: 'component-port',
+                                    ref: { widget: '{{params.tableId}}', port: 'rowClick', direction: 'output' },
+                                },
+                                to: {
+                                    kind: 'component-port',
+                                    ref: { widget: '{{params.formId}}', port: 'resourceId', direction: 'input' },
+                                },
+                                intent: 'event-propagation',
+                                transform: {
+                                    version: '2.0',
+                                    phase: 'link-propagation',
+                                    mode: 'single-value',
+                                    steps: [
+                                        {
+                                            id: 'pick-master-row-id',
+                                            kind: 'pick-path',
+                                            phase: 'link-propagation',
+                                            input: { source: 'event' },
+                                            config: { path: 'payload.row.id' },
+                                        },
+                                    ],
+                                },
+                                metadata: {
+                                    source: 'persisted-composition-link',
+                                },
+                                _replace: true,
+                            },
+                        ],
+                    },
                 },
             },
         },
     ],
     fieldResolvers: {
         'page.widgets[]': ['key'],
-        'page.connections[]': ['_label', 'id', 'name'],
+        'page.composition.links[]': ['id'],
     },
     hints: [
-        'praxis-dynamic-page é um host de composição: cria widgets, conecta outputs e mantém relações.',
-        'Widgets e connections são arrays; o adapter faz merge por key (widgets) e chave composta (conexões).',
-        'Preferir mudanças incrementais: alterar/estender em vez de substituir toda a página.',
-        'Para remover um item, envie {_remove: true} junto ao widget/connection.',
+        'praxis-dynamic-page e um host de composicao: cria widgets, conecta ports canonicos e mantem relacoes em page.composition.links.',
+        'Widgets e composition.links sao arrays; o patching deve fazer merge por key (widgets) e por id (links).',
+        'Preferir mudancas incrementais: alterar/estender em vez de substituir toda a pagina.',
+        'Para remover um item, envie {_remove: true} junto ao widget/link.',
         'Para substituir um item inteiro, envie {_replace: true}.',
-        'Para alterar origem/destino de conexão, use {_beforeKey} com a chave antiga.',
-        'Use keys estáveis para widgets ao criar conexões.',
-        'resourcePath sempre é o path base do recurso (sem /filter, /all).',
+        'Para alterar origem/destino de link, use {_beforeKey} com o id antigo.',
+        'Use keys estaveis para widgets e ids estaveis para links ao criar composicoes.',
+        'resourcePath sempre e o path base do recurso (sem /filter, /all).',
         'Praxis Table gera colunas dinamicamente a partir do resourcePath quando columns nao forem definidas.',
         'Praxis Dynamic Form gera campos dinamicamente a partir do resourcePath quando config nao for definida.',
         'Praxis List pode filtrar via config.dataSource.query (enviado para /filter).',
         'Quando houver recursos secundarios (ex.: enderecos), use contextHints.addressResourcePath.',
-        'Exemplo master-detail: tabela emite rowClick -> form.resourceId (map: payload.row.id).',
-        'Pattern Master-Detail: { "from": {"output": "rowClick"}, "to": {"input": "resourceId"}, "map": "payload.row.id" }',
-        'Ao criar widgets, use inputs mínimos e complemente depois (evite inventar campos).',
-        'Quando widgets já existem, interpretar outputs/inputs antes de conectar.',
-        'Intenção comum: criar pagina master-detail = criar tabela + criar formulário + conectar seleção.',
-        'Intenção comum: ajustar pagina existente = modificar apenas widgets/inputs necessários.',
-        'Exemplo de conexão (master-detail): { from:{widget:\"masterTable\",output:\"rowClick\"}, to:{widget:\"detailForm\",input:\"resourceId\"}, map:\"payload.row.id\" }',
-        'Exemplo de widget tabela (mínimo): { key:\"masterTable\", definition:{ id:\"praxis-table\", inputs:{ resourcePath:\"/api/x\" }}}',
-        'Exemplo de widget formulário (mínimo): { key:\"detailForm\", definition:{ id:\"praxis-dynamic-form\", inputs:{ resourcePath:\"/api/x\", mode:\"view\" }}}',
-        'Se houver idField conhecido, use map: payload.row.{idField} em conexões.',
+        'Exemplo master-detail: tabela emite rowClick -> form.resourceId via transform pick-path payload.row.id.',
+        'Pattern Master-Detail: { "id":"master.rowClick->detail.resourceId", "from":{"kind":"component-port","ref":{"port":"rowClick","direction":"output"}}, "to":{"kind":"component-port","ref":{"port":"resourceId","direction":"input"}}, "transform":{"steps":[{"kind":"pick-path","config":{"path":"payload.row.id"}}]}}',
+        'Ao criar widgets, use inputs minimos e complemente depois (evite inventar campos).',
+        'Quando widgets ja existem, interpretar ports de origem/destino antes de conectar.',
+        'Intencao comum: criar pagina master-detail = criar tabela + criar formulario + conectar selecao via composition.links.',
+        'Intencao comum: ajustar pagina existente = modificar apenas widgets/inputs necessarios.',
+        'Exemplo de link canonico (master-detail): { id:"masterTable.rowClick->detailForm.resourceId", from:{kind:"component-port",ref:{widget:"masterTable",port:"rowClick",direction:"output"}}, to:{kind:"component-port",ref:{widget:"detailForm",port:"resourceId",direction:"input"}}, intent:"event-propagation", transform:{version:"2.0",phase:"link-propagation",mode:"single-value",steps:[{kind:"pick-path",phase:"link-propagation",input:{source:"event"},config:{path:"payload.row.id"}}]}}',
+        'Exemplo de widget tabela (minimo): { key:"masterTable", definition:{ id:"praxis-table", inputs:{ resourcePath:"/api/x" }}}',
+        'Exemplo de widget formulario (minimo): { key:"detailForm", definition:{ id:"praxis-dynamic-form", inputs:{ resourcePath:"/api/x", mode:"view" }}}',
+        'Se houver idField conhecido, use transform pick-path payload.row.{idField} em links canonicos.',
     ],
 };
 
@@ -16072,7 +17460,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$2.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "ngmodule", type: MatIconModule }, { kind: "component", type: i5.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: i3$1.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,
@@ -17313,7 +18701,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-header--drag-enabled{cursor:grab;-webkit-user-select:none;user-select:none;touch-action:none}.pdx-shell-header--drag-enabled:active{cursor:grabbing}.pdx-shell-header--drag-enabled:focus-visible{outline:2px solid color-mix(in srgb,var(--md-sys-color-primary) 72%,white 28%);outline-offset:-2px}.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: i5.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "ngmodule", type: MatMenuModule }, { kind: "component", type: i4.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.MatMenuItem, selector: "[mat-menu-item]", inputs: ["role", "disabled", "disableRipple"], exportAs: ["matMenuItem"] }, { kind: "directive", type: i4.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: i8.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-header--drag-enabled{cursor:grab;-webkit-user-select:none;user-select:none;touch-action:none}.pdx-shell-header--drag-enabled:active{cursor:grabbing}.pdx-shell-header--drag-enabled:focus-visible{outline:2px solid color-mix(in srgb,var(--md-sys-color-primary) 72%,white 28%);outline-offset:-2px}.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:var(--praxis-layer-widget-shell-expanded, 1290);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:var(--praxis-layer-widget-shell-fullscreen, 1291);box-shadow:var(--mat-elevation-level8)}.pdx-shell-backdrop{position:fixed;inset:0;z-index:var(--praxis-layer-widget-shell-backdrop, 1280);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: i3$1.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "ngmodule", type: MatMenuModule }, { kind: "component", type: i4.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.MatMenuItem, selector: "[mat-menu-item]", inputs: ["role", "disabled", "disableRipple"], exportAs: ["matMenuItem"] }, { kind: "directive", type: i4.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: i8.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,
@@ -17449,7 +18837,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImpo
     @if (expanded || fullscreen) {
     <div class="pdx-shell-backdrop" (click)="closeOverlay()"></div>
     }
-  `, changeDetection: ChangeDetectionStrategy.OnPush, 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-header--drag-enabled{cursor:grab;-webkit-user-select:none;user-select:none;touch-action:none}.pdx-shell-header--drag-enabled:active{cursor:grabbing}.pdx-shell-header--drag-enabled:focus-visible{outline:2px solid color-mix(in srgb,var(--md-sys-color-primary) 72%,white 28%);outline-offset:-2px}.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"] }]
+  `, changeDetection: ChangeDetectionStrategy.OnPush, 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-header--drag-enabled{cursor:grab;-webkit-user-select:none;user-select:none;touch-action:none}.pdx-shell-header--drag-enabled:active{cursor:grabbing}.pdx-shell-header--drag-enabled:focus-visible{outline:2px solid color-mix(in srgb,var(--md-sys-color-primary) 72%,white 28%);outline-offset:-2px}.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:var(--praxis-layer-widget-shell-expanded, 1290);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:var(--praxis-layer-widget-shell-fullscreen, 1291);box-shadow:var(--mat-elevation-level8)}.pdx-shell-backdrop{position:fixed;inset:0;z-index:var(--praxis-layer-widget-shell-backdrop, 1280);background:#0000008c;-webkit-backdrop-filter:blur(2px);backdrop-filter:blur(2px)}\n"] }]
         }], propDecorators: { shell: [{
                 type: Input
             }], context: [{
@@ -17824,10 +19212,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImpo
         }] });
 
 class WidgetPageStateRuntimeService {
-    connections;
-    constructor(connections) {
-        this.connections = connections;
-    }
+    connections = new ConnectionManagerService();
     normalizeState(state) {
         if (!state)
             return { values: {} };
@@ -17855,12 +19240,19 @@ class WidgetPageStateRuntimeService {
             const node = normalized.derived?.[key];
             if (!node)
                 continue;
-            const value = this.computeDerivedNode(node, {
-                state: effectiveValues,
-                values: primaryValues,
-                derived: derivedValues,
-                context: this.clone(context) || {},
-            }, diagnostics, key);
+            let value;
+            try {
+                value = this.computeDerivedNode(node, {
+                    state: effectiveValues,
+                    values: primaryValues,
+                    derived: derivedValues,
+                    context: this.clone(context) || {},
+                }, diagnostics, key);
+            }
+            catch (error) {
+                diagnostics.push(`Derived state '${key}' failed: ${this.describeError(error)}`);
+                continue;
+            }
             if (value === undefined)
                 continue;
             effectiveValues = this.connections.setValueAtPath(effectiveValues, key, this.clone(value));
@@ -17909,7 +19301,8 @@ class WidgetPageStateRuntimeService {
             visiting.add(key);
             const deps = derived[key]?.dependsOn || [];
             for (const dep of deps) {
-                const dependencyKey = keys.find((candidate) => dep === candidate || dep.startsWith(`${candidate}.`));
+                const normalizedDependency = this.normalizeDependencyPath(dep);
+                const dependencyKey = keys.find((candidate) => (normalizedDependency === candidate || normalizedDependency.startsWith(`${candidate}.`)));
                 if (!dependencyKey)
                     continue;
                 visit(dependencyKey, [...stack, key]);
@@ -17924,8 +19317,10 @@ class WidgetPageStateRuntimeService {
     }
     computeDerivedNode(node, env, diagnostics, key) {
         const compute = node.compute;
-        if (!compute)
+        if (!compute) {
+            diagnostics.push(`Derived state '${key}' is missing compute definition.`);
             return undefined;
+        }
         if (compute.kind === 'template') {
             return this.resolveTemplate(compute.value, env);
         }
@@ -17936,9 +19331,16 @@ class WidgetPageStateRuntimeService {
             diagnostics.push(`Derived state '${key}' references transformer '${compute.transformerId}', but transformer runtime is not implemented yet.`);
             return undefined;
         }
-        if (compute.kind !== 'operator')
+        if (compute.kind !== 'operator') {
+            const computeKind = compute.kind;
+            diagnostics.push(`Derived state '${key}' uses unsupported compute kind '${String(computeKind ?? '')}'.`);
             return undefined;
+        }
         const operator = (compute.operator || '').trim();
+        if (!operator) {
+            diagnostics.push(`Derived state '${key}' uses operator compute without a valid operator.`);
+            return undefined;
+        }
         const options = compute.options || {};
         const sources = this.resolveSourceValues(node.dependsOn, env.state);
         switch (operator) {
@@ -18048,13 +19450,17 @@ class WidgetPageStateRuntimeService {
         }
     }
     resolveNamedSource(sourcePath, sources, effectiveState) {
-        if (typeof sourcePath === 'string' && sourcePath.trim()) {
-            return this.readPath(effectiveState, sourcePath.trim());
+        const normalizedSourcePath = this.normalizeDependencyPath(sourcePath);
+        if (normalizedSourcePath) {
+            return this.readPath(effectiveState, normalizedSourcePath);
         }
         return sources[0];
     }
     resolveSourceValues(paths, state) {
-        return (paths || []).map((path) => this.readPath(state, path));
+        return (paths || [])
+            .map((path) => this.normalizeDependencyPath(path))
+            .filter(Boolean)
+            .map((path) => this.readPath(state, path));
     }
     aggregateArray(rows, metrics) {
         const output = {};
@@ -18217,6 +19623,22 @@ class WidgetPageStateRuntimeService {
         }
         return node;
     }
+    normalizeDependencyPath(path) {
+        if (typeof path !== 'string')
+            return '';
+        const trimmed = path.trim();
+        if (!trimmed)
+            return '';
+        const exactTemplate = trimmed.match(/^\$\{([^}]+)\}$/);
+        const normalized = exactTemplate ? exactTemplate[1].trim() : trimmed;
+        if (normalized.startsWith('state.')) {
+            return normalized.slice('state.'.length);
+        }
+        if (normalized.startsWith('derived.')) {
+            return normalized.slice('derived.'.length);
+        }
+        return normalized;
+    }
     readPath(source, path) {
         if (!path)
             return source;
@@ -18292,213 +19714,20 @@ class WidgetPageStateRuntimeService {
             return value;
         return JSON.parse(JSON.stringify(value));
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: WidgetPageStateRuntimeService, deps: [{ token: ConnectionManagerService }], target: i0.ɵɵFactoryTarget.Injectable });
+    describeError(error) {
+        if (error instanceof Error)
+            return error.message;
+        if (typeof error === 'string')
+            return error;
+        return 'Unknown runtime error';
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: WidgetPageStateRuntimeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
     static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: WidgetPageStateRuntimeService, providedIn: 'root' });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: WidgetPageStateRuntimeService, decorators: [{
             type: Injectable,
             args: [{ providedIn: 'root' }]
-        }], ctorParameters: () => [{ type: ConnectionManagerService }] });
-
-function adaptWidgetConnectionToCompositionLink(connection) {
-    const from = adaptSource(connection);
-    const to = adaptTarget(connection);
-    return {
-        id: buildLinkId(connection),
-        from,
-        to,
-        intent: resolveIntent(from, to),
-        transform: adaptTransform(connection),
-        conditions: adaptConditions(connection),
-        policy: adaptPolicy(connection),
-        metadata: {
-            source: 'legacy-widget-connection',
-            traceKey: buildTraceKey(connection),
-        },
-    };
-}
-function adaptWidgetConnectionsToCompositionLinks(connections) {
-    return (connections || []).map((connection) => adaptWidgetConnectionToCompositionLink(connection));
-}
-function adaptSource(connection) {
-    if ('widget' in connection.from) {
-        return {
-            kind: 'component-port',
-            ref: {
-                widget: connection.from.widget,
-                port: connection.from.output,
-                direction: 'output',
-            },
-        };
-    }
-    return {
-        kind: 'state',
-        ref: {
-            path: connection.from.state,
-            writable: false,
-        },
-    };
-}
-function adaptTarget(connection) {
-    if ('widget' in connection.to) {
-        const binding = normalizeBindingPath(connection.to.input);
-        return {
-            kind: 'component-port',
-            ref: {
-                widget: connection.to.widget,
-                port: binding.port,
-                direction: 'input',
-                bindingPath: binding.bindingPath,
-            },
-        };
-    }
-    return {
-        kind: 'state',
-        ref: {
-            path: connection.to.state,
-            layer: 'values',
-            writable: true,
-        },
-    };
-}
-function adaptTransform(connection) {
-    if (connection.set !== undefined) {
-        return {
-            version: '2.0',
-            phase: 'link-propagation',
-            mode: inferPipelineMode(connection.set),
-            sourceBindings: [{ source: 'constant', value: connection.set }],
-            steps: [
-                {
-                    id: 'constant',
-                    kind: 'constant',
-                    phase: 'link-propagation',
-                    input: {
-                        source: 'constant',
-                        value: connection.set,
-                    },
-                },
-            ],
-        };
-    }
-    if (!connection.map) {
-        return undefined;
-    }
-    const trimmed = connection.map.trim();
-    const kind = resolveMapTransformKind(trimmed);
-    return {
-        version: '2.0',
-        phase: 'link-propagation',
-        mode: kind === 'array-template'
-            ? 'collection'
-            : kind === 'object-template'
-                ? 'object-fragment'
-                : 'single-value',
-        sourceBindings: [{ source: 'event' }],
-        steps: [
-            {
-                id: 'legacy-map',
-                kind,
-                phase: 'link-propagation',
-                input: { source: 'event' },
-                config: buildMapConfig(kind, trimmed),
-            },
-        ],
-    };
-}
-function adaptConditions(connection) {
-    const conditions = [];
-    if (connection.meta?.filterExpr) {
-        conditions.push({
-            kind: 'expression',
-            expression: connection.meta.filterExpr,
-            description: 'Adaptado de WidgetConnection.meta.filterExpr',
-        });
-    }
-    return conditions.length ? conditions : undefined;
-}
-function adaptPolicy(connection) {
-    const policy = {};
-    if (typeof connection.meta?.debounceMs === 'number') {
-        policy.debounceMs = connection.meta.debounceMs;
-    }
-    if (typeof connection.meta?.distinct === 'boolean') {
-        policy.distinct = connection.meta.distinct;
-    }
-    if (typeof connection.meta?.distinctBy === 'string' && connection.meta.distinctBy.trim()) {
-        policy.distinctBy = connection.meta.distinctBy.trim();
-    }
-    return Object.keys(policy).length ? policy : undefined;
-}
-function resolveIntent(from, to) {
-    if (from.kind === 'component-port' && to.kind === 'state') {
-        return 'state-write';
-    }
-    if (from.kind === 'state' && to.kind === 'component-port') {
-        return 'state-read';
-    }
-    if (from.kind === 'state' && to.kind === 'state') {
-        return 'data-projection';
-    }
-    return 'event-propagation';
-}
-function normalizeBindingPath(rawInput) {
-    const trimmed = (rawInput || '').trim();
-    const dotIndex = trimmed.search(/[.[]/);
-    if (dotIndex <= 0) {
-        return { port: trimmed };
-    }
-    return {
-        port: trimmed.slice(0, dotIndex),
-        bindingPath: trimmed,
-    };
-}
-function resolveMapTransformKind(map) {
-    if (isQuotedLiteral(map)) {
-        return 'template';
-    }
-    if (map.startsWith('{')) {
-        return 'object-template';
-    }
-    if (map.startsWith('[')) {
-        return 'array-template';
-    }
-    return 'pick-path';
-}
-function buildMapConfig(kind, map) {
-    if (kind === 'pick-path') {
-        return { path: map };
-    }
-    if (kind === 'template') {
-        return { value: map };
-    }
-    return { template: map };
-}
-function inferPipelineMode(value) {
-    if (Array.isArray(value)) {
-        return 'collection';
-    }
-    if (value != null && typeof value === 'object') {
-        return 'object-fragment';
-    }
-    return 'single-value';
-}
-function isQuotedLiteral(value) {
-    return (value.startsWith('"') && value.endsWith('"'))
-        || (value.startsWith('\'') && value.endsWith('\''));
-}
-function buildLinkId(connection) {
-    return `legacy:${buildTraceKey(connection)}`;
-}
-function buildTraceKey(connection) {
-    const from = 'widget' in connection.from
-        ? `widget:${connection.from.widget}.${connection.from.output}`
-        : `state:${connection.from.state}`;
-    const to = 'widget' in connection.to
-        ? `widget:${connection.to.widget}.${connection.to.input}`
-        : `state:${connection.to.state}`;
-    return `${from}->${to}`;
-}
+        }] });
 
 class CompositionRuntimeStore {
     snapshot;
@@ -18606,13 +19835,18 @@ function applyLinkPatches(current, patches) {
         return {
             ...cloneLink(link),
             status: patch.status ?? link.status,
-            lastEventAt: patch.lastEventAt ?? link.lastEventAt,
-            lastDispatchTraceId: patch.lastDispatchTraceId ?? link.lastDispatchTraceId,
-            lastDeliveredValuePreview: patch.lastDeliveredValuePreview ?? link.lastDeliveredValuePreview,
+            lastEventAt: pickPatchedValue(patch, 'lastEventAt', link.lastEventAt),
+            lastDispatchTraceId: pickPatchedValue(patch, 'lastDispatchTraceId', link.lastDispatchTraceId),
+            lastDeliveredValuePreview: pickPatchedValue(patch, 'lastDeliveredValuePreview', link.lastDeliveredValuePreview),
             diagnostics: cloneDiagnostics$1(patch.diagnostics ?? link.diagnostics),
         };
     });
 }
+function pickPatchedValue(patch, key, fallback) {
+    return Object.prototype.hasOwnProperty.call(patch, key)
+        ? patch[key]
+        : fallback;
+}
 function cloneLinks(links) {
     return links.map((link) => cloneLink(link));
 }
@@ -18779,19 +20013,33 @@ class TransformRuntimeService {
         const env = this.buildEnvironment(runtime);
         let current = this.resolvePipelineSeed(pipeline, env);
         for (const [index, step] of pipeline.steps.entries()) {
-            if (!this.matchesStepCondition(step.when, env)) {
-                continue;
+            try {
+                if (!this.matchesStepCondition(step.when, env)) {
+                    continue;
+                }
+                if (!isSupportedTransformKind(step.kind)) {
+                    diagnostics.push(this.createDiagnostic('RUNTIME_TRANSFORM_UNSUPPORTED', `O transform ${step.kind} ainda nao e suportado pelo runtime da Wave 1.`, {
+                        kind: 'transform-step',
+                        transformIndex: index,
+                        label: step.id,
+                    }, { transformKind: step.kind, pipelineId: pipeline.id, stepId: step.id }, undefined, 'unsupported-kind'));
+                    continue;
+                }
+                current = this.executeStep(step, current, env, diagnostics, index);
+                env.current = this.clone(current);
             }
-            if (!isSupportedTransformKind(step.kind)) {
-                diagnostics.push(this.createDiagnostic('RUNTIME_TRANSFORM_UNSUPPORTED', `O transform ${step.kind} ainda nao e suportado pelo runtime da Wave 1.`, {
+            catch (error) {
+                diagnostics.push(this.createDiagnostic('RUNTIME_TRANSFORM_STEP_FAILED', `O transform ${step.kind} falhou no passo '${step.id || index}'. ${this.describeError(error)}`, {
                     kind: 'transform-step',
                     transformIndex: index,
                     label: step.id,
-                }, { transformKind: step.kind, pipelineId: pipeline.id }));
-                continue;
+                }, {
+                    transformKind: step.kind,
+                    pipelineId: pipeline.id,
+                    stepId: step.id,
+                    errorMessage: this.describeError(error),
+                }, undefined, 'step-failed'));
             }
-            current = this.executeStep(step, current, env, diagnostics, index);
-            env.current = this.clone(current);
         }
         if (current === undefined && pipeline.fallbackValue !== undefined) {
             current = this.clone(pipeline.fallbackValue);
@@ -18846,9 +20094,9 @@ class TransformRuntimeService {
             case 'array-template':
                 return this.resolveStructuredTemplate(step, inputs[0], env);
             case 'coalesce':
-                return this.resolveCoalesce(step, inputs, env);
+                return this.resolveCoalesce(step, inputs, env, diagnostics, index);
             case 'merge-objects':
-                return this.resolveMergeObjects(step, inputs, env);
+                return this.resolveMergeObjects(step, inputs, env, diagnostics, index);
             case 'select-case':
                 return this.resolveSelectCase(step, inputs[0], env);
             default:
@@ -18856,7 +20104,7 @@ class TransformRuntimeService {
                     kind: 'transform-step',
                     transformIndex: index,
                     label: step.id,
-                }, { transformKind: step.kind }));
+                }, { transformKind: step.kind }, undefined, 'unsupported-kind'));
                 return current;
         }
     }
@@ -18958,14 +20206,11 @@ class TransformRuntimeService {
         const template = step.config?.['template'] ?? source;
         return this.templateResolver.resolveTemplate(template, this.buildTemplateContext(env, source));
     }
-    resolveCoalesce(step, inputs, env) {
-        const configuredPaths = Array.isArray(step.config?.['paths'])
-            ? step.config?.['paths']
-            : [];
-        const candidates = configuredPaths.map((path) => typeof path === 'string'
-            ? this.pathAccessor.extractByPath({ state: env['state'], payload: env['payload'], context: env['context'] }, path)
-            : undefined);
-        for (const value of [...inputs, ...candidates]) {
+    resolveCoalesce(step, inputs, env, diagnostics, index) {
+        const configuredValues = this.resolveConfiguredValues(step, env, diagnostics, index);
+        const explicitInputs = step.inputs?.length || step.input ? inputs : [];
+        const fallbackInputs = explicitInputs.length ? [] : inputs;
+        for (const value of [...explicitInputs, ...configuredValues, ...fallbackInputs]) {
             if (value == null) {
                 continue;
             }
@@ -18976,16 +20221,11 @@ class TransformRuntimeService {
         }
         return this.clone(step.config?.['fallback']);
     }
-    resolveMergeObjects(step, inputs, env) {
-        const configuredPaths = Array.isArray(step.config?.['paths'])
-            ? step.config?.['paths']
-            : [];
-        const values = [
-            ...inputs,
-            ...configuredPaths.map((path) => typeof path === 'string'
-                ? this.pathAccessor.extractByPath({ state: env['state'], payload: env['payload'], context: env['context'] }, path)
-                : undefined),
-        ];
+    resolveMergeObjects(step, inputs, env, diagnostics, index) {
+        const configuredValues = this.resolveConfiguredValues(step, env, diagnostics, index);
+        const explicitInputs = step.inputs?.length || step.input ? inputs : [];
+        const fallbackInputs = explicitInputs.length || configuredValues.length ? [] : inputs;
+        const values = [...explicitInputs, ...configuredValues, ...fallbackInputs];
         return values.reduce((acc, value) => {
             if (!this.isPlainObject(value)) {
                 return acc;
@@ -18993,6 +20233,59 @@ class TransformRuntimeService {
             return deepMerge(acc, this.clone(value));
         }, {});
     }
+    resolveConfiguredValues(step, env, diagnostics, index) {
+        if (!Array.isArray(step.config?.['paths'])) {
+            return [];
+        }
+        const rawPaths = step.config?.['paths'];
+        const validPaths = [];
+        const invalidEntries = [];
+        for (const item of rawPaths) {
+            if (typeof item === 'string' && item.trim()) {
+                validPaths.push(item);
+            }
+            else {
+                invalidEntries.push(item);
+            }
+        }
+        if (invalidEntries.length) {
+            diagnostics.push(this.createDiagnostic('RUNTIME_TRANSFORM_CONFIG_INVALID', `O transform ${step.kind} recebeu entradas invalidas em config.paths no passo '${step.id || index}'.`, {
+                kind: 'transform-step',
+                transformIndex: index,
+                label: step.id,
+            }, {
+                transformKind: step.kind,
+                stepId: step.id,
+                invalidPathEntries: this.clone(invalidEntries),
+            }, 'warning', 'invalid-path-entries'));
+        }
+        if (!validPaths.length) {
+            if (rawPaths.length) {
+                diagnostics.push(this.createDiagnostic('RUNTIME_TRANSFORM_CONFIG_INVALID', `O transform ${step.kind} nao encontrou nenhum path valido em config.paths no passo '${step.id || index}'.`, {
+                    kind: 'transform-step',
+                    transformIndex: index,
+                    label: step.id,
+                }, {
+                    transformKind: step.kind,
+                    stepId: step.id,
+                }, 'warning', 'missing-valid-paths'));
+            }
+            return [];
+        }
+        const resolved = validPaths.map((path) => this.resolveConfiguredPath(path, env));
+        if (resolved.every((value) => value === undefined)) {
+            diagnostics.push(this.createDiagnostic('RUNTIME_TRANSFORM_PATHS_UNRESOLVED', `O transform ${step.kind} nao resolveu nenhum dos paths configurados no passo '${step.id || index}'.`, {
+                kind: 'transform-step',
+                transformIndex: index,
+                label: step.id,
+            }, {
+                transformKind: step.kind,
+                stepId: step.id,
+                paths: validPaths,
+            }, 'warning', `paths-unresolved:${this.hashIdParts(validPaths)}`));
+        }
+        return resolved;
+    }
     resolveSelectCase(step, source, env) {
         const cases = Array.isArray(step.config?.['cases'])
             ? step.config?.['cases']
@@ -19018,7 +20311,7 @@ class TransformRuntimeService {
             ? conditionRecord['path'].trim()
             : '';
         const value = path
-            ? this.pathAccessor.extractByPath({ source, state: env['state'], payload: env['payload'], context: env['context'] }, path)
+            ? this.resolveCasePath(path, env, source)
             : source;
         if ('equals' in conditionRecord) {
             return value === conditionRecord['equals'];
@@ -19036,12 +20329,38 @@ class TransformRuntimeService {
     }
     resolveCaseValue(item, env, source) {
         if (typeof item['path'] === 'string' && item['path'].trim()) {
-            return this.pathAccessor.extractByPath({ source, state: env['state'], payload: env['payload'], context: env['context'] }, item['path']);
+            return this.resolveCasePath(item['path'], env, source);
         }
         if (item['template'] !== undefined) {
             return this.templateResolver.resolveTemplate(item['template'], this.buildTemplateContext(env, source));
         }
-        return this.clone(item['value']);
+        return this.templateResolver.resolveTemplate(item['value'], this.buildTemplateContext(env, source));
+    }
+    resolveCasePath(path, env, source) {
+        if (/^(event|payload|state|context|current|source)\b/.test(path)) {
+            return this.pathAccessor.extractByPath({
+                event: env['event'],
+                payload: env['payload'],
+                state: env['state'],
+                context: env['context'],
+                current: source,
+                source,
+            }, path);
+        }
+        return this.pathAccessor.extractByPath(source, path);
+    }
+    resolveConfiguredPath(path, env) {
+        if (/^(event|payload|state|context|current|source)\b/.test(path)) {
+            return this.pathAccessor.extractByPath({
+                event: env['event'],
+                payload: env['payload'],
+                state: env['state'],
+                context: env['context'],
+                current: env['current'],
+                source: env['current'],
+            }, path);
+        }
+        return this.pathAccessor.extractByPath(env['current'], path);
     }
     buildEffectiveState(state, derived, transient) {
         return deepMerge(deepMerge(this.clone(state) || {}, this.clone(derived) || {}), this.clone(transient) || {});
@@ -19080,26 +20399,65 @@ class TransformRuntimeService {
         }
         return false;
     }
-    createDiagnostic(code, message, subject, details) {
+    createDiagnostic(code, message, subject, details, severity = 'error', occurrenceKey) {
         return {
-            id: `${code}:${subject.transformIndex ?? 'root'}`,
+            id: this.buildDiagnosticId(code, subject, occurrenceKey),
             code,
-            severity: 'error',
+            severity,
             phase: 'runtime-transform',
             message,
             summary: message,
             subject,
             details,
             source: 'runtime-engine',
-            blocking: true,
+            blocking: severity === 'error' || severity === 'fatal',
             createdAt: new Date().toISOString(),
         };
     }
-    clone(value) {
-        if (value == null || typeof value !== 'object') {
-            return value;
+    clone(value) {
+        if (value == null || typeof value !== 'object') {
+            return value;
+        }
+        return JSON.parse(JSON.stringify(value));
+    }
+    describeError(error) {
+        if (error instanceof Error) {
+            return error.message;
+        }
+        if (typeof error === 'string') {
+            return error;
+        }
+        return 'Erro desconhecido.';
+    }
+    buildDiagnosticId(code, subject, occurrenceKey) {
+        const parts = [
+            code,
+            String(subject.transformIndex ?? 'root'),
+        ];
+        if (subject.label) {
+            parts.push(this.sanitizeIdPart(subject.label));
+        }
+        if (occurrenceKey) {
+            parts.push(this.sanitizeIdPart(occurrenceKey));
+        }
+        return parts.filter(Boolean).join(':');
+    }
+    sanitizeIdPart(value) {
+        return value
+            .trim()
+            .toLowerCase()
+            .replace(/[^a-z0-9]+/g, '-')
+            .replace(/^-+|-+$/g, '')
+            .slice(0, 48);
+    }
+    hashIdParts(values) {
+        let hash = 0;
+        for (const value of values) {
+            for (const char of value) {
+                hash = ((hash * 31) + char.charCodeAt(0)) >>> 0;
+            }
         }
-        return JSON.parse(JSON.stringify(value));
+        return hash.toString(36);
     }
 }
 
@@ -19153,7 +20511,7 @@ class LinkExecutorService {
                 skippedReason: missingResolution.reason,
             };
         }
-        const policySkip = this.resolvePolicySkip(link, value, context, now);
+        const policySkip = this.resolvePolicySkip(link, sourceValue, value, context, now);
         if (policySkip) {
             return {
                 status: 'skipped',
@@ -19189,13 +20547,34 @@ class LinkExecutorService {
         if (endpoint.kind === 'state') {
             return this.readStatePath(snapshot, endpoint.ref.path, endpoint.ref.layer);
         }
-        if (context.payload !== undefined) {
-            return this.clone(context.payload);
+        const payload = context.payload !== undefined
+            ? context.payload
+            : (context.event && typeof context.event === 'object' && 'payload' in context.event)
+                ? context.event['payload']
+                : context.event;
+        if (endpoint.ref.bindingPath) {
+            const extracted = this.extractComponentSourceBinding(endpoint.ref.bindingPath, payload, context);
+            if (extracted !== undefined) {
+                return this.clone(extracted);
+            }
+        }
+        return this.clone(payload);
+    }
+    extractComponentSourceBinding(bindingPath, payload, context) {
+        const normalized = String(bindingPath || '').trim();
+        if (!normalized) {
+            return undefined;
         }
-        if (context.event && typeof context.event === 'object' && 'payload' in context.event) {
-            return this.clone(context.event['payload']);
+        const fromPayload = this.pathAccessor.extractByPath(payload, normalized);
+        if (fromPayload !== undefined) {
+            return fromPayload;
         }
-        return this.clone(context.event);
+        return this.pathAccessor.extractByPath({
+            source: payload,
+            payload,
+            event: context.event,
+            context: context.context || {},
+        }, normalized);
     }
     matchesConditions(link, sourceValue, context, snapshot, diagnostics) {
         for (const condition of link.conditions || []) {
@@ -19321,7 +20700,7 @@ class LinkExecutorService {
         };
     }
     resolveMissingValuePolicy(link, value) {
-        if (value !== undefined) {
+        if (value !== undefined && value !== null) {
             return { value, skipped: false };
         }
         switch (link.policy?.missingValuePolicy) {
@@ -19336,13 +20715,22 @@ class LinkExecutorService {
                 return { value, skipped: false };
         }
     }
-    resolvePolicySkip(link, value, context, now) {
+    resolvePolicySkip(link, sourceValue, value, context, now) {
         if (link.policy?.distinct) {
             const currentValue = link.policy.distinctBy
-                ? this.pathAccessor.extractByPath({ payload: value, value }, link.policy.distinctBy)
+                ? this.resolveDistinctValue(link.policy.distinctBy, {
+                    sourceValue,
+                    transformedValue: value,
+                    payload: context.payload,
+                    event: context.event,
+                    context: context.context,
+                })
                 : value;
             const previousValue = link.policy.distinctBy
-                ? this.pathAccessor.extractByPath({ payload: context.lastDeliveredValue, value: context.lastDeliveredValue }, link.policy.distinctBy)
+                ? this.resolveDistinctValue(link.policy.distinctBy, {
+                    sourceValue: context.lastDeliveredValue,
+                    transformedValue: context.lastDeliveredValue,
+                })
                 : context.lastDeliveredValue;
             if (this.isEqual(currentValue, previousValue)) {
                 return 'distinct-skip';
@@ -19389,6 +20777,45 @@ class LinkExecutorService {
             bindingPath: link.to.ref.bindingPath,
         };
     }
+    resolveDistinctValue(distinctBy, options) {
+        const normalized = String(distinctBy || '').trim();
+        if (!normalized) {
+            return options.transformedValue;
+        }
+        const payload = options.payload !== undefined
+            ? options.payload
+            : (options.event && typeof options.event === 'object'
+                ? options.event['payload']
+                : undefined);
+        const envelopes = [
+            {
+                source: options.sourceValue,
+                value: options.transformedValue,
+                payload,
+                event: options.event,
+                context: options.context || {},
+                original: {
+                    source: options.sourceValue,
+                    payload,
+                    event: options.event,
+                },
+            },
+            {
+                source: options.sourceValue,
+                value: options.transformedValue,
+                payload: options.transformedValue,
+                event: options.event,
+                context: options.context || {},
+            },
+        ];
+        for (const envelope of envelopes) {
+            const extracted = this.pathAccessor.extractByPath(envelope, normalized);
+            if (extracted !== undefined) {
+                return extracted;
+            }
+        }
+        return options.transformedValue;
+    }
     readStatePath(snapshot, path, preferredLayer) {
         const lookup = (layer) => {
             switch (layer) {
@@ -19556,8 +20983,9 @@ class CompositionRuntimeEngine {
         this.definition = definition;
         const generatedAt = this.now();
         const stateSnapshot = this.materializeDerivedState(definition.state.primaryValues, definition);
+        const bootstrapDiagnostics = uniqueDiagnosticsById(stateSnapshot.diagnostics);
         const init = {
-            status: stateSnapshot.diagnostics.some(isBlockingDiagnostic) ? 'degraded' : 'ready',
+            status: bootstrapDiagnostics.some(isBlockingDiagnostic) ? 'degraded' : 'ready',
             generatedAt,
             links: definition.links.map((link) => this.createLinkSnapshot(link)),
             state: {
@@ -19565,9 +20993,9 @@ class CompositionRuntimeEngine {
                 derivedValues: stateSnapshot.derivedValues,
                 transientValues: stateSnapshot.transientValues,
                 changedPaths: [],
-                diagnostics: stateSnapshot.diagnostics,
+                diagnostics: bootstrapDiagnostics,
             },
-            diagnostics: stateSnapshot.diagnostics,
+            diagnostics: bootstrapDiagnostics,
             traceTail: [
                 this.traceService.createEntry('bootstrap', 0, {
                     timestamp: generatedAt,
@@ -19581,9 +21009,9 @@ class CompositionRuntimeEngine {
                         linkCount: definition.links.length,
                         derivedDefinitionCount: Object.keys(definition.state.derivedDefinitions || {}).length,
                     },
-                    diagnostics: stateSnapshot.diagnostics.map((item) => item.code),
+                    diagnostics: bootstrapDiagnostics.map((item) => item.code),
                 }),
-                ...stateSnapshot.diagnostics.map((diagnostic, index) => this.traceService.createEntry('bootstrap', index + 1, {
+                ...bootstrapDiagnostics.map((diagnostic, index) => this.traceService.createEntry('bootstrap', index + 1, {
                     timestamp: diagnostic.createdAt,
                     phase: 'diagnostic-emitted',
                     subject: diagnostic.subject,
@@ -19610,6 +21038,7 @@ class CompositionRuntimeEngine {
         const runtimeDiagnostics = [];
         const linkResults = new Map();
         const trace = [];
+        const emittedDiagnosticIds = new Set();
         let sequence = 0;
         trace.push(this.traceService.createEntry(event.eventId, sequence++, {
             timestamp: occurredAt,
@@ -19719,53 +21148,28 @@ class CompositionRuntimeEngine {
                 },
                 diagnostics: result.diagnostics.map((item) => item.code),
             }));
-            for (const diagnostic of result.diagnostics) {
-                trace.push(this.traceService.createEntry(event.eventId, sequence++, {
-                    timestamp: diagnostic.createdAt,
-                    phase: 'diagnostic-emitted',
-                    linkId: link.id,
-                    subject: diagnostic.subject,
-                    details: {
-                        code: diagnostic.code,
-                        severity: diagnostic.severity,
-                        phase: diagnostic.phase,
-                    },
-                    diagnostics: [diagnostic.code],
-                }));
-            }
+            sequence = this.appendDiagnosticTraceEntries(trace, emittedDiagnosticIds, event.eventId, sequence, result.diagnostics, link.id);
         }
         const materializedState = this.materializeDerivedState(workingState.primaryValues, this.definition, workingState.transientValues);
-        const diagnostics = [
+        const diagnostics = uniqueDiagnosticsById([
             ...runtimeDiagnostics,
             ...materializedState.diagnostics,
-        ];
+        ]);
         materializedState.changedPaths = Array.from(new Set([
             ...(workingState.changedPaths ?? []),
             ...this.stateRuntime.collectChangedPaths(this.store.getSnapshot().state.derivedValues, materializedState.derivedValues, Object.keys(this.definition.state.derivedDefinitions || {})),
         ]));
         materializedState.diagnostics = cloneDiagnostics(diagnostics);
-        for (const diagnostic of materializedState.diagnostics.filter((item) => !runtimeDiagnostics.some((runtimeItem) => runtimeItem.id === item.id))) {
-            trace.push(this.traceService.createEntry(event.eventId, sequence++, {
-                timestamp: diagnostic.createdAt,
-                phase: 'diagnostic-emitted',
-                subject: diagnostic.subject,
-                details: {
-                    code: diagnostic.code,
-                    severity: diagnostic.severity,
-                    phase: diagnostic.phase,
-                },
-                diagnostics: [diagnostic.code],
-            }));
-        }
+        sequence = this.appendDiagnosticTraceEntries(trace, emittedDiagnosticIds, event.eventId, sequence, materializedState.diagnostics.filter((item) => !runtimeDiagnostics.some((runtimeItem) => runtimeItem.id === item.id)));
         const snapshot = this.store.applyCycle({
             generatedAt: occurredAt,
             status: diagnostics.some(isBlockingDiagnostic)
                 ? 'degraded'
                 : 'ready',
             stateSnapshot: materializedState,
-            linkPatches: this.definition.links.map((link) => ({
+            linkPatches: matchedLinks.map((link) => ({
                 linkId: link.id,
-                status: linkResults.get(link.id)?.status ?? 'idle',
+                status: linkResults.get(link.id)?.status,
                 lastEventAt: linkResults.has(link.id) ? occurredAt : undefined,
                 lastDispatchTraceId: linkResults.has(link.id) ? event.eventId : undefined,
                 lastDeliveredValuePreview: linkResults.get(link.id)?.value,
@@ -19802,7 +21206,6 @@ class CompositionRuntimeEngine {
             if (link.from.kind !== 'state' || link.to.kind !== 'component-port') {
                 continue;
             }
-            matchedLinkIds.push(link.id);
             const result = this.linkExecutor.executeLink(link, {
                 snapshot: { state: runtimeState },
                 context: definition.context,
@@ -19816,16 +21219,17 @@ class CompositionRuntimeEngine {
             if (widgetIndex < 0) {
                 continue;
             }
-            const bindingPath = result.delivery.bindingPath || result.delivery.portId;
-            if (!bindingPath) {
+            const previewBindingPath = resolvePreviewBindingPath(result.delivery.portId, result.delivery.bindingPath);
+            if (!previewBindingPath) {
                 continue;
             }
+            matchedLinkIds.push(link.id);
             const currentInputs = widgets[widgetIndex].definition.inputs || {};
             widgets[widgetIndex] = {
                 ...widgets[widgetIndex],
                 definition: {
                     ...widgets[widgetIndex].definition,
-                    inputs: this.pathAccessor.setValueAtPath(this.cloneJson(currentInputs), bindingPath, this.cloneJson(result.value)),
+                    inputs: this.pathAccessor.setValueAtPath(this.cloneJson(currentInputs), previewBindingPath, this.cloneJson(result.value)),
                 },
             };
         }
@@ -19853,6 +21257,9 @@ class CompositionRuntimeEngine {
         const linkResults = new Map();
         const diagnostics = [...snapshot.diagnostics];
         const trace = [...snapshot.traceTail];
+        const emittedDiagnosticIds = new Set(trace
+            .filter((entry) => entry.phase === 'diagnostic-emitted')
+            .flatMap((entry) => entry.diagnostics || []));
         let sequence = trace.length;
         for (const link of hydrationLinks) {
             const stateBefore = cloneStateSnapshot(workingState);
@@ -19916,24 +21323,12 @@ class CompositionRuntimeEngine {
                 },
                 diagnostics: result.diagnostics.map((item) => item.code),
             }));
-            for (const diagnostic of result.diagnostics) {
-                trace.push(this.traceService.createEntry('bootstrap', sequence++, {
-                    timestamp: diagnostic.createdAt,
-                    phase: 'diagnostic-emitted',
-                    linkId: link.id,
-                    subject: diagnostic.subject,
-                    details: {
-                        code: diagnostic.code,
-                        severity: diagnostic.severity,
-                        phase: diagnostic.phase,
-                    },
-                    diagnostics: [diagnostic.code],
-                }));
-            }
+            sequence = this.appendDiagnosticTraceEntries(trace, emittedDiagnosticIds, 'bootstrap', sequence, result.diagnostics, link.id);
         }
+        const dedupedDiagnostics = uniqueDiagnosticsById(diagnostics);
         return this.store.applyCycle({
             generatedAt: occurredAt,
-            status: diagnostics.some(isBlockingDiagnostic) ? 'degraded' : 'ready',
+            status: dedupedDiagnostics.some(isBlockingDiagnostic) ? 'degraded' : 'ready',
             stateSnapshot: {
                 ...workingState,
                 changedPaths: [],
@@ -19947,7 +21342,7 @@ class CompositionRuntimeEngine {
                 lastDeliveredValuePreview: linkResults.get(link.id)?.value,
                 diagnostics: linkResults.get(link.id)?.diagnostics,
             })),
-            diagnostics,
+            diagnostics: dedupedDiagnostics,
             traceTail: trace,
         });
     }
@@ -19966,26 +21361,30 @@ class CompositionRuntimeEngine {
         };
     }
     createDerivedDiagnostic(definition, message, index) {
+        const nodeKey = this.extractDerivedNodeKey(message);
+        const classification = classifyDerivedDiagnosticMessage(message);
         return {
             id: `derived:${index}:${message}`,
-            code: message.includes('cycle')
-                ? 'RUNTIME_DERIVED_STATE_CYCLE'
-                : message.includes('transformer')
-                    ? 'RUNTIME_DERIVED_TRANSFORMER_UNSUPPORTED'
-                    : 'RUNTIME_DERIVED_STATE_WARNING',
-            severity: message.includes('cycle') || message.includes('not implemented')
-                ? 'warning'
-                : 'info',
+            code: classification.code,
+            severity: classification.severity,
             phase: 'runtime-state',
             message,
             summary: message,
-            subject: {
-                kind: 'runtime-snapshot',
-                label: definition.widgetOrder.join(', '),
-            },
+            subject: nodeKey
+                ? {
+                    kind: 'derived-state',
+                    statePath: nodeKey,
+                    path: nodeKey,
+                    label: nodeKey,
+                }
+                : {
+                    kind: 'runtime-snapshot',
+                    label: definition.widgetOrder.join(', '),
+                },
             source: 'runtime-engine',
-            blocking: false,
+            blocking: classification.severity === 'error' || classification.severity === 'fatal',
             createdAt: this.now(),
+            details: nodeKey ? { nodeKey } : undefined,
         };
     }
     clonePreviewWidgets(widgets) {
@@ -19997,6 +21396,31 @@ class CompositionRuntimeEngine {
         }
         return JSON.parse(JSON.stringify(value));
     }
+    extractDerivedNodeKey(message) {
+        const match = message.match(/Derived state '([^']+)'/);
+        return match?.[1];
+    }
+    appendDiagnosticTraceEntries(trace, emittedDiagnosticIds, traceId, sequence, diagnostics, linkId) {
+        for (const diagnostic of diagnostics) {
+            if (emittedDiagnosticIds.has(diagnostic.id)) {
+                continue;
+            }
+            emittedDiagnosticIds.add(diagnostic.id);
+            trace.push(this.traceService.createEntry(traceId, sequence++, {
+                timestamp: diagnostic.createdAt,
+                phase: 'diagnostic-emitted',
+                linkId,
+                subject: diagnostic.subject,
+                details: {
+                    code: diagnostic.code,
+                    severity: diagnostic.severity,
+                    phase: diagnostic.phase,
+                },
+                diagnostics: [diagnostic.code],
+            }));
+        }
+        return sequence;
+    }
 }
 function createDefaultLinkExecutor() {
     const connections = new ConnectionManagerService();
@@ -20004,7 +21428,7 @@ function createDefaultLinkExecutor() {
     return new LinkExecutorService(transforms, connections);
 }
 function createDefaultStateRuntime() {
-    return new WidgetPageStateRuntimeService(new ConnectionManagerService());
+    return new WidgetPageStateRuntimeService();
 }
 function cloneStateSnapshot(snapshot) {
     return {
@@ -20026,9 +21450,92 @@ function cloneDiagnostics(diagnostics) {
         details: item.details ? { ...item.details } : undefined,
     }));
 }
+function uniqueDiagnosticsById(diagnostics) {
+    const deduped = [];
+    const seen = new Set();
+    for (const diagnostic of diagnostics) {
+        if (seen.has(diagnostic.id)) {
+            continue;
+        }
+        seen.add(diagnostic.id);
+        deduped.push(diagnostic);
+    }
+    return deduped;
+}
 function isBlockingDiagnostic(item) {
     return item.severity === 'error' || item.severity === 'fatal';
 }
+function resolvePreviewBindingPath(portId, bindingPath) {
+    const normalizedPortId = String(portId || '').trim();
+    const normalizedBindingPath = String(bindingPath || '').trim();
+    if (!normalizedPortId && !normalizedBindingPath) {
+        return undefined;
+    }
+    if (!normalizedBindingPath) {
+        return normalizedPortId || undefined;
+    }
+    if (!normalizedPortId) {
+        return normalizedBindingPath;
+    }
+    if (normalizedBindingPath === normalizedPortId
+        || normalizedBindingPath.startsWith(`${normalizedPortId}.`)
+        || normalizedBindingPath.startsWith(`${normalizedPortId}[`)) {
+        return normalizedBindingPath;
+    }
+    if (normalizedBindingPath.startsWith('.')
+        || normalizedBindingPath.startsWith('[')) {
+        return `${normalizedPortId}${normalizedBindingPath}`;
+    }
+    return `${normalizedPortId}.${normalizedBindingPath}`;
+}
+function classifyDerivedDiagnosticMessage(message) {
+    if (message.includes('cycle')) {
+        return {
+            code: 'RUNTIME_DERIVED_STATE_CYCLE',
+            severity: 'warning',
+        };
+    }
+    if (message.includes('transformer')) {
+        return {
+            code: 'RUNTIME_DERIVED_TRANSFORMER_UNSUPPORTED',
+            severity: 'warning',
+        };
+    }
+    if (message.includes('missing compute definition')) {
+        return {
+            code: 'RUNTIME_DERIVED_COMPUTE_MISSING',
+            severity: 'warning',
+        };
+    }
+    if (message.includes('unsupported compute kind')) {
+        return {
+            code: 'RUNTIME_DERIVED_COMPUTE_KIND_UNSUPPORTED',
+            severity: 'warning',
+        };
+    }
+    if (message.includes('without a valid operator')) {
+        return {
+            code: 'RUNTIME_DERIVED_OPERATOR_MISSING',
+            severity: 'warning',
+        };
+    }
+    if (message.includes('uses unsupported operator')) {
+        return {
+            code: 'RUNTIME_DERIVED_OPERATOR_UNSUPPORTED',
+            severity: 'warning',
+        };
+    }
+    if (message.includes(' failed: ')) {
+        return {
+            code: 'RUNTIME_DERIVED_STATE_FAILED',
+            severity: 'error',
+        };
+    }
+    return {
+        code: 'RUNTIME_DERIVED_STATE_WARNING',
+        severity: 'info',
+    };
+}
 function matchesEndpoint(expected, actual) {
     if (expected.kind !== actual.kind) {
         return false;
@@ -20154,7 +21661,7 @@ class WidgetPageCompositionFactory {
         return {
             widgetOrder: page.widgets.map((widget) => widget.key),
             widgetsByKey,
-            links: adaptWidgetConnectionsToCompositionLinks(page.connections),
+            links: this.readCanonicalLinks(page),
             state: {
                 primaryValues: this.materializePrimaryValues(normalizedState),
                 schema: this.clone(normalizedState.schema) || {},
@@ -20163,6 +21670,9 @@ class WidgetPageCompositionFactory {
             context: this.clone(page.context) || {},
         };
     }
+    readCanonicalLinks(page) {
+        return this.clone(page.composition?.links) || [];
+    }
     indexWidgets(widgets) {
         const widgetsByKey = {};
         for (const widget of widgets) {
@@ -20252,11 +21762,6 @@ const CANVAS_RESIZE_HANDLES = [
     { id: 'south-west', className: 'pdx-canvas-resize--south-west' },
 ];
 class DynamicWidgetPageComponent {
-    conn;
-    stateRuntime;
-    settingsPanel;
-    defaultShellEditor;
-    defaultPageEditor;
     pageCanvasHost;
     page;
     context = null;
@@ -20310,6 +21815,7 @@ class DynamicWidgetPageComponent {
     isHydrating = false;
     persistenceReady = false;
     warnedMissingKey = false;
+    runtimeEventSequence = 0;
     compositionFactory = new WidgetPageCompositionFactory();
     compositionRuntime = new CompositionRuntimeFacade();
     compositionDefinition;
@@ -20323,13 +21829,12 @@ class DynamicWidgetPageComponent {
     catch {
         return undefined;
     } })();
-    constructor(conn, stateRuntime, settingsPanel, defaultShellEditor, defaultPageEditor) {
-        this.conn = conn;
-        this.stateRuntime = stateRuntime;
-        this.settingsPanel = settingsPanel;
-        this.defaultShellEditor = defaultShellEditor;
-        this.defaultPageEditor = defaultPageEditor;
-    }
+    conn = inject(ConnectionManagerService);
+    stateRuntime = inject(WidgetPageStateRuntimeService);
+    settingsPanel = inject(SETTINGS_PANEL_BRIDGE, { optional: true });
+    defaultShellEditor = inject(DYNAMIC_PAGE_SHELL_EDITOR, { optional: true });
+    defaultPageEditor = inject(DYNAMIC_PAGE_CONFIG_EDITOR, { optional: true });
+    constructor() { }
     ngOnDestroy() {
         this.compositionRuntime.destroy();
     }
@@ -20337,6 +21842,7 @@ class DynamicWidgetPageComponent {
         if (changes['page'] || changes['context'] || changes['enableCustomization']) {
             const parsed = this.parsePage(this.page);
             const resolvedPage = parsed ? this.resolvePagePresets(parsed) : parsed;
+            this.assertNoLegacyConnections(resolvedPage);
             this.widgetDiagnostics = {};
             this.widgetDiagnosticsChange.emit({});
             this.pageDefinition = resolvedPage ? { ...resolvedPage, state: this.stateRuntime.normalizeState(resolvedPage.state) } : resolvedPage;
@@ -20374,7 +21880,7 @@ class DynamicWidgetPageComponent {
         if (!cycle || !cycle.matchedLinkIds.length)
             return;
         const state = this.stateFromCompositionSnapshot(page.state, cycle.snapshot.state.primaryValues);
-        const runtimeStatePaths = Array.from(new Set(cycle.snapshot.state.changedPaths || []));
+        const runtimeStatePaths = Array.from(new Set((cycle.snapshot.state.changedPaths || []).filter((path) => typeof path === 'string')));
         const updatedPrimaryStatePaths = runtimeStatePaths.filter((path) => (!this.areStateValuesEqual(this.conn.extractByPath(this.stateRuntime.normalizeState(page.state).values || {}, path), this.conn.extractByPath(state.values || {}, path))));
         let widgets = this.cloneWidgets(page.widgets || []);
         const directDelivery = this.applyCompositionWidgetDeliveries(widgets, cycle);
@@ -20392,6 +21898,220 @@ class DynamicWidgetPageComponent {
         }
         this.applyPageUpdate({ ...page, widgets, state }, true, nextRuntime, false);
     }
+    buildStateRuntime(state, pageContext) {
+        return this.stateRuntime.buildRuntimeSnapshot(state, this.buildStateContext(pageContext));
+    }
+    bootstrapCompositionAdapter(page) {
+        if (!page) {
+            this.compositionDefinition = undefined;
+            return undefined;
+        }
+        this.compositionDefinition = this.compositionFactory.create(page);
+        return this.compositionRuntime.bootstrap(this.compositionDefinition);
+    }
+    applyEditShellActions(widgets) {
+        return this.cloneWidgets(widgets).map((widget) => {
+            if (!this.shouldInjectWidgetSettings(widget)) {
+                return widget;
+            }
+            const existingActions = widget.shell?.actions || [];
+            if (existingActions.some((action) => action.id === 'widget-settings')) {
+                return widget;
+            }
+            const widgetSettingsAction = {
+                id: 'widget-settings',
+                icon: 'settings',
+                variant: 'icon',
+                placement: 'header',
+                label: this.t('controls.widgetSettings', 'Configurar widget'),
+                tooltip: this.t('controls.widgetSettingsTooltip', 'Abrir configurações do widget'),
+            };
+            return {
+                ...widget,
+                shell: {
+                    ...(widget.shell || {}),
+                    actions: [...existingActions, widgetSettingsAction],
+                },
+            };
+        });
+    }
+    applyBootstrapCompositionHydration(widgets, bootstrapSnapshot) {
+        if (!this.compositionDefinition || !bootstrapSnapshot) {
+            return this.cloneWidgets(widgets);
+        }
+        return this.compositionRuntime.projectStateWidgetInputs(this.compositionDefinition, {
+            widgets,
+            state: bootstrapSnapshot.state,
+            now: bootstrapSnapshot.generatedAt,
+        }).widgets;
+    }
+    reportStateDiagnostics(diagnostics) {
+        if (!diagnostics?.length)
+            return;
+        console.warn('[DynamicWidgetPage] State runtime diagnostics', diagnostics);
+    }
+    dispatchWidgetEventToComposition(page, fromKey, evt) {
+        const output = String(evt?.output || '').trim();
+        if (!output)
+            return undefined;
+        const definition = this.compositionDefinition ?? this.compositionFactory.create(page);
+        this.compositionDefinition = definition;
+        if (!definition.links.some((link) => (link.from.kind === 'component-port'
+            && link.from.ref.widget === fromKey
+            && link.from.ref.port === output
+            && link.from.ref.direction === 'output'))) {
+            return undefined;
+        }
+        let payload;
+        try {
+            payload = this.cloneStateValues(evt?.payload);
+        }
+        catch (error) {
+            const message = `DynamicWidgetPageComponent could not serialize widget event payload for "${fromKey}.${output}". ` +
+                `Composition links only support JSON-safe payloads.`;
+            const wrapped = new Error(message);
+            wrapped.cause = error;
+            throw wrapped;
+        }
+        return this.compositionRuntime.dispatch({
+            eventId: this.buildRuntimeEventId(fromKey, output),
+            source: {
+                kind: 'component-port',
+                ref: {
+                    widget: fromKey,
+                    port: output,
+                    direction: 'output',
+                    componentType: evt.sourceComponentId,
+                },
+            },
+            payload,
+        });
+    }
+    stateFromCompositionSnapshot(previousState, primaryValues) {
+        const normalized = this.stateRuntime.normalizeState(previousState);
+        return {
+            ...normalized,
+            values: this.cloneStateValues(primaryValues) || {},
+        };
+    }
+    applyCompositionWidgetDeliveries(widgets, cycle) {
+        if (!this.compositionDefinition) {
+            return {
+                widgets: this.cloneWidgets(widgets),
+                changed: false,
+            };
+        }
+        const linksById = new Map(this.compositionDefinition.links.map((link) => [link.id, link]));
+        const runtimeLinks = cycle.snapshot.links.filter((link) => (link.lastDispatchTraceId === cycle.cycleId && link.status === 'delivered'));
+        let nextWidgets = this.cloneWidgets(widgets);
+        let changed = false;
+        for (const runtimeLink of runtimeLinks) {
+            const link = linksById.get(runtimeLink.linkId);
+            if (!link || link.from.kind === 'state' || link.to.kind !== 'component-port') {
+                continue;
+            }
+            const targetRef = link.to.ref;
+            const bindingPath = this.resolveComponentBindingPath(targetRef.port, targetRef.bindingPath);
+            if (!bindingPath) {
+                continue;
+            }
+            const widgetIndex = nextWidgets.findIndex((widget) => widget.key === targetRef.widget);
+            if (widgetIndex < 0) {
+                continue;
+            }
+            const widget = nextWidgets[widgetIndex];
+            const currentInputs = this.cloneStateValues(widget.definition.inputs || {});
+            const nextInputs = this.conn.setValueAtPath(currentInputs, bindingPath, this.cloneStateValues(runtimeLink.lastDeliveredValuePreview));
+            if (this.areStateValuesEqual(currentInputs, nextInputs)) {
+                continue;
+            }
+            nextWidgets[widgetIndex] = {
+                ...widget,
+                definition: {
+                    ...widget.definition,
+                    inputs: nextInputs,
+                },
+            };
+            changed = true;
+        }
+        return { widgets: nextWidgets, changed };
+    }
+    buildStateContext(pageContext) {
+        return {
+            ...(this.cloneStateValues(pageContext) || {}),
+            ...(this.cloneStateValues(this.context) || {}),
+        };
+    }
+    cloneStateValues(value) {
+        if (value == null || typeof value !== 'object') {
+            return value;
+        }
+        return JSON.parse(JSON.stringify(value));
+    }
+    cloneGrouping(grouping) {
+        return this.cloneStateValues(grouping);
+    }
+    resolveShellTemplates(widgets, runtime) {
+        const templateContext = {
+            context: this.buildStateContext(this.pageDefinition?.context),
+            pageContext: this.buildStateContext(this.pageDefinition?.context),
+            state: this.cloneStateValues(runtime.effectiveValues),
+            values: this.cloneStateValues(runtime.primaryValues),
+            derived: this.cloneStateValues(runtime.derivedValues),
+            pageState: this.cloneStateValues(runtime.primaryValues),
+            pageStateDerived: this.cloneStateValues(runtime.derivedValues),
+            pageStateEffective: this.cloneStateValues(runtime.effectiveValues),
+        };
+        return this.cloneWidgets(widgets).map((widget) => {
+            if (!widget.shell) {
+                return widget;
+            }
+            return {
+                ...widget,
+                shell: this.resolveTemplate(widget.shell, templateContext),
+            };
+        });
+    }
+    resolveComponentBindingPath(portId, bindingPath) {
+        const normalizedPortId = String(portId || '').trim();
+        const normalizedBindingPath = String(bindingPath || '').trim();
+        if (!normalizedPortId && !normalizedBindingPath) {
+            return undefined;
+        }
+        if (!normalizedBindingPath) {
+            return normalizedPortId || undefined;
+        }
+        if (!normalizedPortId) {
+            return normalizedBindingPath;
+        }
+        if (normalizedBindingPath === normalizedPortId
+            || normalizedBindingPath.startsWith(`${normalizedPortId}.`)
+            || normalizedBindingPath.startsWith(`${normalizedPortId}[`)) {
+            return normalizedBindingPath;
+        }
+        if (normalizedBindingPath.startsWith('.')
+            || normalizedBindingPath.startsWith('[')) {
+            return `${normalizedPortId}${normalizedBindingPath}`;
+        }
+        return `${normalizedPortId}.${normalizedBindingPath}`;
+    }
+    buildRuntimeEventId(fromKey, output) {
+        const sequence = ++this.runtimeEventSequence;
+        const timestamp = Date.now();
+        if (typeof globalThis !== 'undefined' && globalThis.crypto?.randomUUID) {
+            return `widget:${fromKey}:${output}:${sequence}:${globalThis.crypto.randomUUID()}`;
+        }
+        return `widget:${fromKey}:${output}:${timestamp}:${sequence}`;
+    }
+    shouldInjectWidgetSettings(widget) {
+        if (!this.enableCustomization || !this.settingsPanel) {
+            return false;
+        }
+        if (!(this.shellEditorComponent || this.defaultShellEditor)) {
+            return false;
+        }
+        return !!widget.shell && widget.shell.kind !== 'none';
+    }
     areStateValuesEqual(left, right) {
         if (left === right)
             return true;
@@ -20651,6 +22371,7 @@ class DynamicWidgetPageComponent {
         }, persist);
     }
     applyPageUpdate(next, persist = true, runtime = this.buildStateRuntime(next.state, next.context), syncCompositionAdapter = true) {
+        this.assertNoLegacyConnections(next);
         const normalized = { ...next, state: runtime.state };
         const normalizedWidgets = this.applyEditShellActions(normalized.widgets || []);
         const bootstrapSnapshot = syncCompositionAdapter
@@ -20828,12 +22549,15 @@ class DynamicWidgetPageComponent {
             return undefined;
         if (typeof input === 'string') {
             try {
-                return JSON.parse(input);
+                const parsed = JSON.parse(input);
+                this.assertNoLegacyConnections(parsed);
+                return parsed;
             }
             catch {
                 return undefined;
             }
         }
+        this.assertNoLegacyConnections(input);
         return input;
     }
     resolvePagePresets(page) {
@@ -21518,9 +23242,9 @@ class DynamicWidgetPageComponent {
         if (!grouping?.length)
             return grouping;
         if (!overrides?.length)
-            return this.cloneGrouping(grouping);
+            return this.cloneGrouping(grouping) || [];
         const overridesById = new Map(overrides.map((item) => [item.id, item]));
-        return this.cloneGrouping(grouping)
+        return (this.cloneGrouping(grouping) || [])
             .map((group) => {
             const override = overridesById.get(group.id);
             if (!override || override.hidden)
@@ -21658,35 +23382,16 @@ class DynamicWidgetPageComponent {
     resolveRenderedCanvasItem(widget) {
         return this.transientCanvasItemsState()[widget.key] || widget.renderCanvasItem;
     }
-    applyEditShellActions(widgets) {
-        if (!this.enableCustomization)
-            return widgets;
-        return widgets.map((w) => {
-            if (!w.shell || w.shell.kind === 'none')
-                return w;
-            const shell = { ...w.shell };
-            const actions = [...(shell.actions || [])];
-            if (!actions.some((a) => a.id === 'widget-settings')) {
-                actions.push({
-                    id: 'widget-settings',
-                    icon: 'settings',
-                    label: 'Configurar Card',
-                    placement: 'window',
-                    variant: 'icon',
-                    tooltip: 'Configurar Card',
-                });
-            }
-            if (shell.showHeader === false)
-                shell.showHeader = true;
-            return { ...w, shell: { ...shell, actions } };
-        });
+    toPersistedCanonicalPage(page) {
+        this.assertNoLegacyConnections(page);
+        return writeCompositionLinksToPersistedPage(page, page.composition?.links || []);
     }
     savePage(page) {
         const key = this.storageKey();
         if (!key)
             return;
         try {
-            this.storage.saveConfig(key, page).pipe(take(1)).subscribe({ error: () => { } });
+            this.storage.saveConfig(key, this.toPersistedCanonicalPage(page)).pipe(take(1)).subscribe({ error: () => { } });
         }
         catch { }
     }
@@ -21761,135 +23466,15 @@ class DynamicWidgetPageComponent {
             return '';
         return String(value).trim().replace(/[\r\n\t|:]/g, '-');
     }
-    cloneStateValues(state) {
-        return state ? JSON.parse(JSON.stringify(state)) : {};
-    }
-    cloneValue(value) {
-        if (value == null || typeof value !== 'object') {
-            return value;
-        }
-        return JSON.parse(JSON.stringify(value));
-    }
-    cloneGrouping(grouping) {
-        return grouping ? JSON.parse(JSON.stringify(grouping)) : [];
-    }
-    buildStateRuntime(state, pageContext) {
-        return this.stateRuntime.buildRuntimeSnapshot(state, this.buildStateContext(pageContext));
-    }
-    buildStateContext(pageContext) {
-        return {
-            ...(pageContext || {}),
-            ...(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}`);
-        }
-    }
-    applyBootstrapCompositionHydration(widgets, snapshot) {
-        const matchedLinkIds = (snapshot?.links || [])
-            .filter((link) => link.status === 'delivered')
-            .map((link) => link.linkId);
-        if (!snapshot || !matchedLinkIds.length) {
-            return widgets;
-        }
-        return this.applyCompositionWidgetDeliveries(widgets, {
-            cycleId: 'bootstrap',
-            matchedLinkIds,
-            snapshot,
-            diagnostics: snapshot.diagnostics,
-        }).widgets;
-    }
-    bootstrapCompositionAdapter(page) {
-        if (!page) {
-            this.compositionDefinition = undefined;
-            return undefined;
-        }
-        this.compositionDefinition = this.compositionFactory.create({
-            ...page,
-            state: this.stateRuntime.normalizeState(page.state),
-        });
-        return this.compositionRuntime.bootstrap(this.compositionDefinition);
-    }
-    dispatchWidgetEventToComposition(page, fromKey, evt) {
-        if (!evt?.output) {
-            return null;
-        }
-        if (!this.compositionDefinition) {
-            this.bootstrapCompositionAdapter(page);
-        }
-        return this.compositionRuntime.dispatch({
-            eventId: `widget:${evt.ownerWidgetKey || fromKey}:${evt.output}:${Date.now()}`,
-            source: {
-                kind: 'component-port',
-                ref: {
-                    widget: evt.ownerWidgetKey || fromKey,
-                    port: evt.output,
-                    direction: 'output',
-                    componentType: evt.sourceComponentId,
-                },
-            },
-            payload: evt.payload,
-            occurredAt: new Date().toISOString(),
-        });
-    }
-    stateFromCompositionSnapshot(baseState, primaryValues) {
-        const normalized = this.stateRuntime.normalizeState(baseState);
-        return {
-            ...normalized,
-            values: this.cloneStateValues(primaryValues),
-        };
-    }
-    applyCompositionWidgetDeliveries(widgets, cycle) {
-        if (!this.compositionDefinition) {
-            return { widgets, changed: false };
-        }
-        const linkMap = new Map(this.compositionDefinition.links.map((link) => [link.id, link]));
-        const snapshotMap = new Map(cycle.snapshot.links.map((link) => [link.linkId, link]));
-        let changed = false;
-        for (const linkId of cycle.matchedLinkIds) {
-            const link = linkMap.get(linkId);
-            const linkSnapshot = snapshotMap.get(linkId);
-            if (!link || !linkSnapshot || linkSnapshot.status !== 'delivered' || link.to.kind !== 'component-port') {
-                continue;
-            }
-            const targetRef = link.to.ref;
-            const widgetIndex = widgets.findIndex((widget) => widget.key === targetRef.widget);
-            if (widgetIndex < 0) {
-                continue;
-            }
-            const bindingPath = targetRef.bindingPath || targetRef.port;
-            const currentInputs = widgets[widgetIndex].definition.inputs || {};
-            const nextValue = this.cloneValue(linkSnapshot.lastDeliveredValuePreview);
-            const currentValue = this.conn.extractByPath(currentInputs, bindingPath);
-            if (this.areStateValuesEqual(currentValue, nextValue)) {
-                continue;
-            }
-            widgets[widgetIndex] = {
-                ...widgets[widgetIndex],
-                definition: {
-                    ...widgets[widgetIndex].definition,
-                    inputs: this.conn.setValueAtPath(this.cloneStateValues(currentInputs), bindingPath, nextValue),
-                },
-            };
-            changed = true;
+    assertNoLegacyConnections(page) {
+        if (!page)
+            return;
+        if (!Object.prototype.hasOwnProperty.call(page, 'connections')) {
+            return;
         }
-        return { widgets, changed };
+        throw new Error('DynamicWidgetPageComponent no longer accepts `page.connections`. Use `composition.links` only.');
     }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: DynamicWidgetPageComponent, deps: [{ token: ConnectionManagerService }, { token: WidgetPageStateRuntimeService }, { token: SETTINGS_PANEL_BRIDGE, optional: true }, { token: DYNAMIC_PAGE_SHELL_EDITOR, optional: true }, { token: DYNAMIC_PAGE_CONFIG_EDITOR, optional: true }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: DynamicWidgetPageComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
     static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "17.0.0", version: "20.3.17", type: DynamicWidgetPageComponent, isStandalone: true, selector: "praxis-dynamic-page", inputs: { page: "page", context: "context", strictValidation: "strictValidation", enableCustomization: "enableCustomization", showPageSettingsButton: "showPageSettingsButton", shellEditorComponent: "shellEditorComponent", pageEditorComponent: "pageEditorComponent", autoPersist: "autoPersist", pageIdentity: "pageIdentity", componentInstanceId: "componentInstanceId" }, outputs: { pageChange: "pageChange", widgetDiagnosticsChange: "widgetDiagnosticsChange" }, host: { listeners: { "window:resize": "onWindowResize()", "window:pointermove": "onCanvasPointerMove($event)", "window:pointerup": "onCanvasPointerUp($event)", "window:pointercancel": "onCanvasPointerCancel($event)" } }, providers: [providePraxisI18nConfig(DYNAMIC_WIDGET_PAGE_I18N_CONFIG)], viewQueries: [{ propertyName: "pageCanvasHost", first: true, predicate: ["pageCanvasHost"], descendants: true }], usesOnChanges: true, ngImport: i0, template: `
     <div class="pdx-page-wrapper" [class.editing]="enableCustomization">
       @if (enableCustomization && showPageSettingsButton) {
@@ -22073,7 +23658,7 @@ class DynamicWidgetPageComponent {
         <div class="pdx-sr-only" aria-live="polite">{{ layoutAnnouncement }}</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--canvas{align-items:start;grid-auto-flow:dense}.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;min-width:0;min-height:0}.pdx-widget--canvas{align-self:stretch;--pdx-resize-gradient-horizontal: linear-gradient( 90deg, color-mix(in srgb, var(--md-sys-color-primary) 94%, white 6%), color-mix(in srgb, var(--md-sys-color-tertiary) 90%, white 10%), color-mix(in srgb, var(--md-sys-color-secondary) 88%, white 12%) );--pdx-resize-gradient-vertical: linear-gradient( 180deg, color-mix(in srgb, var(--md-sys-color-primary) 94%, white 6%), color-mix(in srgb, var(--md-sys-color-tertiary) 90%, white 10%), color-mix(in srgb, var(--md-sys-color-secondary) 88%, white 12%) );--pdx-resize-gradient-diagonal-se: linear-gradient( 135deg, color-mix(in srgb, var(--md-sys-color-primary) 94%, white 6%), color-mix(in srgb, var(--md-sys-color-tertiary) 90%, white 10%), color-mix(in srgb, var(--md-sys-color-secondary) 88%, white 12%) );--pdx-resize-gradient-diagonal-sw: linear-gradient( 225deg, color-mix(in srgb, var(--md-sys-color-primary) 94%, white 6%), color-mix(in srgb, var(--md-sys-color-tertiary) 90%, white 10%), color-mix(in srgb, var(--md-sys-color-secondary) 88%, white 12%) );--pdx-active-resize-gradient: var(--pdx-resize-gradient-diagonal-se)}.pdx-widget--canvas:after{content:\"\";position:absolute;inset:0;padding:2px;border-radius:14px;background:var(--pdx-active-resize-gradient);opacity:0;pointer-events:none;transition:opacity .14s ease,filter .14s ease;filter:saturate(1.02) drop-shadow(0 0 5px color-mix(in srgb,var(--md-sys-color-primary) 10%,transparent));-webkit-mask:linear-gradient(#fff 0 0) content-box,linear-gradient(#fff 0 0);-webkit-mask-composite:xor;mask-composite:exclude}.pdx-widget--canvas-selected:before,.pdx-widget--canvas-blocked:before{content:\"\";position:absolute;inset:0;border-radius:14px;pointer-events:none;z-index:1;transition:opacity .14s ease,box-shadow .14s ease,border-color .14s ease}.pdx-widget--canvas-selected:before{border:1px dashed color-mix(in srgb,var(--md-sys-color-primary) 34%,transparent);box-shadow:0 0 0 1px color-mix(in srgb,var(--md-sys-color-primary) 6%,transparent),0 8px 20px color-mix(in srgb,var(--md-sys-color-primary) 6%,transparent)}.pdx-widget--canvas-blocked:before{border:1px solid color-mix(in srgb,var(--md-sys-color-error) 74%,transparent);box-shadow:0 0 0 1px color-mix(in srgb,var(--md-sys-color-error) 20%,transparent),0 10px 24px color-mix(in srgb,var(--md-sys-color-error) 12%,transparent)}.pdx-widget--canvas:has(.pdx-canvas-resize:hover):after,.pdx-widget--canvas:has(.pdx-canvas-resize:focus-visible):after{opacity:.82}.pdx-widget--canvas:has(.pdx-canvas-resize--north:hover),.pdx-widget--canvas:has(.pdx-canvas-resize--north:focus-visible),.pdx-widget--canvas:has(.pdx-canvas-resize--south:hover),.pdx-widget--canvas:has(.pdx-canvas-resize--south:focus-visible){--pdx-active-resize-gradient: var(--pdx-resize-gradient-horizontal)}.pdx-widget--canvas:has(.pdx-canvas-resize--east:hover),.pdx-widget--canvas:has(.pdx-canvas-resize--east:focus-visible),.pdx-widget--canvas:has(.pdx-canvas-resize--west:hover),.pdx-widget--canvas:has(.pdx-canvas-resize--west:focus-visible){--pdx-active-resize-gradient: var(--pdx-resize-gradient-vertical)}.pdx-widget--canvas:has(.pdx-canvas-resize--north-east:hover),.pdx-widget--canvas:has(.pdx-canvas-resize--north-east:focus-visible),.pdx-widget--canvas:has(.pdx-canvas-resize--south-west:hover),.pdx-widget--canvas:has(.pdx-canvas-resize--south-west:focus-visible){--pdx-active-resize-gradient: var(--pdx-resize-gradient-diagonal-sw)}.pdx-widget--canvas:has(.pdx-canvas-resize--north-west:hover),.pdx-widget--canvas:has(.pdx-canvas-resize--north-west:focus-visible),.pdx-widget--canvas:has(.pdx-canvas-resize--south-east:hover),.pdx-widget--canvas:has(.pdx-canvas-resize--south-east:focus-visible){--pdx-active-resize-gradient: var(--pdx-resize-gradient-diagonal-se)}.pdx-canvas-resize{position:absolute;z-index:7;border:0;padding:0;margin:0;background:transparent;touch-action:none;cursor:pointer;opacity:0;pointer-events:none;transform:scale(.94);transition:opacity .14s ease,transform .14s ease,filter .14s ease;filter:saturate(.9)}.pdx-widget--canvas:hover .pdx-canvas-resize,.pdx-widget--canvas:focus-within .pdx-canvas-resize,.pdx-widget--canvas-selected .pdx-canvas-resize{opacity:.88;pointer-events:auto;transform:scale(1);filter:saturate(1)}.pdx-canvas-resize-grip{display:block;width:9px;height:9px;border-radius:999px;border:1px solid color-mix(in srgb,var(--md-sys-color-primary) 42%,var(--md-sys-color-outline-variant) 58%);background:color-mix(in srgb,var(--md-sys-color-surface) 92%,var(--md-sys-color-primary) 8%);box-shadow:0 1px 4px color-mix(in srgb,var(--md-sys-color-shadow) 10%,transparent);transition:transform .14s ease,border-color .14s ease,background .14s ease,box-shadow .14s ease}.pdx-canvas-resize:hover .pdx-canvas-resize-grip,.pdx-canvas-resize:focus-visible .pdx-canvas-resize-grip{border-color:color-mix(in srgb,var(--md-sys-color-primary) 58%,var(--md-sys-color-outline-variant) 42%);background:color-mix(in srgb,var(--md-sys-color-surface) 84%,var(--md-sys-color-primary) 16%);box-shadow:0 2px 7px color-mix(in srgb,var(--md-sys-color-primary) 14%,transparent);transform:scale(1.04)}.pdx-canvas-resize--north,.pdx-canvas-resize--south{left:50%;width:40px;height:18px;margin-left:-20px;display:flex;align-items:center;justify-content:center}.pdx-canvas-resize--north{top:-8px;cursor:ns-resize}.pdx-canvas-resize--south{bottom:-8px;cursor:ns-resize}.pdx-canvas-resize--east,.pdx-canvas-resize--west{top:50%;width:18px;height:40px;margin-top:-20px;display:flex;align-items:center;justify-content:center}.pdx-canvas-resize--east{right:-8px;cursor:ew-resize}.pdx-canvas-resize--west{left:-8px;cursor:ew-resize}.pdx-canvas-resize--north-east,.pdx-canvas-resize--north-west,.pdx-canvas-resize--south-east,.pdx-canvas-resize--south-west{width:18px;height:18px;display:flex;align-items:center;justify-content:center}.pdx-canvas-resize--north-east{top:-8px;right:-8px;cursor:nesw-resize}.pdx-canvas-resize--north-west{top:-8px;left:-8px;cursor:nwse-resize}.pdx-canvas-resize--south-east{bottom:-8px;right:-8px;cursor:nwse-resize}.pdx-canvas-resize--south-west{bottom:-8px;left:-8px;cursor:nesw-resize}.pdx-canvas-snap-preview{position:relative;align-self:stretch;border-radius:12px;pointer-events:none;z-index:0;background:linear-gradient(135deg,color-mix(in srgb,var(--md-sys-color-primary) 10%,transparent),color-mix(in srgb,var(--md-sys-color-tertiary) 12%,transparent));box-shadow:inset 0 0 0 1px color-mix(in srgb,var(--md-sys-color-primary) 42%,transparent),inset 0 0 0 2px color-mix(in srgb,var(--md-sys-color-surface) 55%,transparent);animation:pdx-snap-preview-pulse .48s ease-out infinite alternate}.pdx-canvas-snap-preview:before,.pdx-canvas-snap-preview:after{content:\"\";position:absolute;border-radius:999px;background:color-mix(in srgb,var(--md-sys-color-primary) 82%,var(--md-sys-color-tertiary) 18%);opacity:.72}.pdx-canvas-snap-preview:before{inset:0 auto 0 0;width:3px}.pdx-canvas-snap-preview:after{inset:0 0 auto;height:3px}.pdx-canvas-snap-preview--invalid{background:linear-gradient(135deg,color-mix(in srgb,var(--md-sys-color-error) 18%,transparent),color-mix(in srgb,var(--md-sys-color-error-container) 22%,transparent));box-shadow:inset 0 0 0 1px color-mix(in srgb,var(--md-sys-color-error) 58%,transparent),inset 0 0 0 2px color-mix(in srgb,var(--md-sys-color-surface) 40%,transparent)}.pdx-canvas-snap-preview--invalid:before,.pdx-canvas-snap-preview--invalid:after{background:color-mix(in srgb,var(--md-sys-color-error) 86%,var(--md-sys-color-error-container) 14%)}.pdx-canvas-resize:focus-visible{outline:2px solid var(--md-sys-color-primary);outline-offset:2px}.pdx-canvas-resize:hover .pdx-canvas-resize-grip,.pdx-canvas-resize:focus-visible .pdx-canvas-resize-grip{border-color:transparent;box-shadow:0 0 0 1px color-mix(in srgb,var(--md-sys-color-primary) 20%,transparent),var(--mat-elevation-level3)}.pdx-canvas-resize--north:hover .pdx-canvas-resize-grip,.pdx-canvas-resize--north:focus-visible .pdx-canvas-resize-grip,.pdx-canvas-resize--south:hover .pdx-canvas-resize-grip,.pdx-canvas-resize--south:focus-visible .pdx-canvas-resize-grip{background:var(--pdx-resize-gradient-horizontal)}.pdx-canvas-resize--east:hover .pdx-canvas-resize-grip,.pdx-canvas-resize--east:focus-visible .pdx-canvas-resize-grip,.pdx-canvas-resize--west:hover .pdx-canvas-resize-grip,.pdx-canvas-resize--west:focus-visible .pdx-canvas-resize-grip{background:var(--pdx-resize-gradient-vertical)}.pdx-canvas-resize--north-east:hover .pdx-canvas-resize-grip,.pdx-canvas-resize--north-east:focus-visible .pdx-canvas-resize-grip,.pdx-canvas-resize--south-west:hover .pdx-canvas-resize-grip,.pdx-canvas-resize--south-west:focus-visible .pdx-canvas-resize-grip{background:var(--pdx-resize-gradient-diagonal-sw)}.pdx-canvas-resize--north-west:hover .pdx-canvas-resize-grip,.pdx-canvas-resize--north-west:focus-visible .pdx-canvas-resize-grip,.pdx-canvas-resize--south-east:hover .pdx-canvas-resize-grip,.pdx-canvas-resize--south-east:focus-visible .pdx-canvas-resize-grip{background:var(--pdx-resize-gradient-diagonal-se)}.pdx-canvas-resize:hover .pdx-canvas-resize-grip,.pdx-canvas-resize:focus-visible .pdx-canvas-resize-grip{transform:scale(1.08)}@keyframes pdx-snap-preview-pulse{0%{opacity:.72;transform:scale(.996)}to{opacity:1;transform:scale(1)}}.pdx-sr-only{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0}.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: "directive", type: i1$2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { 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: i5.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "ngmodule", type: MatTooltipModule }, { kind: "directive", type: i8.MatTooltip, selector: "[matTooltip]", inputs: ["matTooltipPosition", "matTooltipPositionAtOrigin", "matTooltipDisabled", "matTooltipShowDelay", "matTooltipHideDelay", "matTooltipTouchGestures", "matTooltip", "matTooltipClass"], exportAs: ["matTooltip"] }, { kind: "directive", type: DynamicWidgetLoaderDirective, selector: "[dynamicWidgetLoader]", inputs: ["dynamicWidgetLoader", "ownerWidgetKey", "context", "strictValidation", "autoWireOutputs"], outputs: ["widgetEvent", "widgetDiagnostic"], exportAs: ["dynamicWidgetLoader"] }, { kind: "component", type: WidgetShellComponent, selector: "praxis-widget-shell", inputs: ["shell", "context", "dragSurfaceEnabled", "dragSurfaceLabel"], outputs: ["action", "dragSurfacePointerDown", "dragSurfaceKeydown"] }] });
+  `, isInline: true, styles: [".pdx-page-wrapper{position:relative;display:block}.pdx-page{display:grid;gap:16px;grid-template-columns:minmax(0,1fr)}.pdx-page--canvas{align-items:start;grid-auto-flow:dense}.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;min-width:0;min-height:0}.pdx-widget--canvas{align-self:stretch;--pdx-resize-gradient-horizontal: linear-gradient( 90deg, color-mix(in srgb, var(--md-sys-color-primary) 94%, white 6%), color-mix(in srgb, var(--md-sys-color-tertiary) 90%, white 10%), color-mix(in srgb, var(--md-sys-color-secondary) 88%, white 12%) );--pdx-resize-gradient-vertical: linear-gradient( 180deg, color-mix(in srgb, var(--md-sys-color-primary) 94%, white 6%), color-mix(in srgb, var(--md-sys-color-tertiary) 90%, white 10%), color-mix(in srgb, var(--md-sys-color-secondary) 88%, white 12%) );--pdx-resize-gradient-diagonal-se: linear-gradient( 135deg, color-mix(in srgb, var(--md-sys-color-primary) 94%, white 6%), color-mix(in srgb, var(--md-sys-color-tertiary) 90%, white 10%), color-mix(in srgb, var(--md-sys-color-secondary) 88%, white 12%) );--pdx-resize-gradient-diagonal-sw: linear-gradient( 225deg, color-mix(in srgb, var(--md-sys-color-primary) 94%, white 6%), color-mix(in srgb, var(--md-sys-color-tertiary) 90%, white 10%), color-mix(in srgb, var(--md-sys-color-secondary) 88%, white 12%) );--pdx-active-resize-gradient: var(--pdx-resize-gradient-diagonal-se)}.pdx-widget--canvas:after{content:\"\";position:absolute;inset:0;padding:2px;border-radius:14px;background:var(--pdx-active-resize-gradient);opacity:0;pointer-events:none;transition:opacity .14s ease,filter .14s ease;filter:saturate(1.02) drop-shadow(0 0 5px color-mix(in srgb,var(--md-sys-color-primary) 10%,transparent));-webkit-mask:linear-gradient(#fff 0 0) content-box,linear-gradient(#fff 0 0);-webkit-mask-composite:xor;mask-composite:exclude}.pdx-widget--canvas-selected:before,.pdx-widget--canvas-blocked:before{content:\"\";position:absolute;inset:0;border-radius:14px;pointer-events:none;z-index:1;transition:opacity .14s ease,box-shadow .14s ease,border-color .14s ease}.pdx-widget--canvas-selected:before{border:1px dashed color-mix(in srgb,var(--md-sys-color-primary) 34%,transparent);box-shadow:0 0 0 1px color-mix(in srgb,var(--md-sys-color-primary) 6%,transparent),0 8px 20px color-mix(in srgb,var(--md-sys-color-primary) 6%,transparent)}.pdx-widget--canvas-blocked:before{border:1px solid color-mix(in srgb,var(--md-sys-color-error) 74%,transparent);box-shadow:0 0 0 1px color-mix(in srgb,var(--md-sys-color-error) 20%,transparent),0 10px 24px color-mix(in srgb,var(--md-sys-color-error) 12%,transparent)}.pdx-widget--canvas:has(.pdx-canvas-resize:hover):after,.pdx-widget--canvas:has(.pdx-canvas-resize:focus-visible):after{opacity:.82}.pdx-widget--canvas:has(.pdx-canvas-resize--north:hover),.pdx-widget--canvas:has(.pdx-canvas-resize--north:focus-visible),.pdx-widget--canvas:has(.pdx-canvas-resize--south:hover),.pdx-widget--canvas:has(.pdx-canvas-resize--south:focus-visible){--pdx-active-resize-gradient: var(--pdx-resize-gradient-horizontal)}.pdx-widget--canvas:has(.pdx-canvas-resize--east:hover),.pdx-widget--canvas:has(.pdx-canvas-resize--east:focus-visible),.pdx-widget--canvas:has(.pdx-canvas-resize--west:hover),.pdx-widget--canvas:has(.pdx-canvas-resize--west:focus-visible){--pdx-active-resize-gradient: var(--pdx-resize-gradient-vertical)}.pdx-widget--canvas:has(.pdx-canvas-resize--north-east:hover),.pdx-widget--canvas:has(.pdx-canvas-resize--north-east:focus-visible),.pdx-widget--canvas:has(.pdx-canvas-resize--south-west:hover),.pdx-widget--canvas:has(.pdx-canvas-resize--south-west:focus-visible){--pdx-active-resize-gradient: var(--pdx-resize-gradient-diagonal-sw)}.pdx-widget--canvas:has(.pdx-canvas-resize--north-west:hover),.pdx-widget--canvas:has(.pdx-canvas-resize--north-west:focus-visible),.pdx-widget--canvas:has(.pdx-canvas-resize--south-east:hover),.pdx-widget--canvas:has(.pdx-canvas-resize--south-east:focus-visible){--pdx-active-resize-gradient: var(--pdx-resize-gradient-diagonal-se)}.pdx-canvas-resize{position:absolute;z-index:7;border:0;padding:0;margin:0;background:transparent;touch-action:none;cursor:pointer;opacity:0;pointer-events:none;transform:scale(.94);transition:opacity .14s ease,transform .14s ease,filter .14s ease;filter:saturate(.9)}.pdx-widget--canvas:hover .pdx-canvas-resize,.pdx-widget--canvas:focus-within .pdx-canvas-resize,.pdx-widget--canvas-selected .pdx-canvas-resize{opacity:.88;pointer-events:auto;transform:scale(1);filter:saturate(1)}.pdx-canvas-resize-grip{display:block;width:9px;height:9px;border-radius:999px;border:1px solid color-mix(in srgb,var(--md-sys-color-primary) 42%,var(--md-sys-color-outline-variant) 58%);background:color-mix(in srgb,var(--md-sys-color-surface) 92%,var(--md-sys-color-primary) 8%);box-shadow:0 1px 4px color-mix(in srgb,var(--md-sys-color-shadow) 10%,transparent);transition:transform .14s ease,border-color .14s ease,background .14s ease,box-shadow .14s ease}.pdx-canvas-resize:hover .pdx-canvas-resize-grip,.pdx-canvas-resize:focus-visible .pdx-canvas-resize-grip{border-color:color-mix(in srgb,var(--md-sys-color-primary) 58%,var(--md-sys-color-outline-variant) 42%);background:color-mix(in srgb,var(--md-sys-color-surface) 84%,var(--md-sys-color-primary) 16%);box-shadow:0 2px 7px color-mix(in srgb,var(--md-sys-color-primary) 14%,transparent);transform:scale(1.04)}.pdx-canvas-resize--north,.pdx-canvas-resize--south{left:50%;width:40px;height:18px;margin-left:-20px;display:flex;align-items:center;justify-content:center}.pdx-canvas-resize--north{top:-8px;cursor:ns-resize}.pdx-canvas-resize--south{bottom:-8px;cursor:ns-resize}.pdx-canvas-resize--east,.pdx-canvas-resize--west{top:50%;width:18px;height:40px;margin-top:-20px;display:flex;align-items:center;justify-content:center}.pdx-canvas-resize--east{right:-8px;cursor:ew-resize}.pdx-canvas-resize--west{left:-8px;cursor:ew-resize}.pdx-canvas-resize--north-east,.pdx-canvas-resize--north-west,.pdx-canvas-resize--south-east,.pdx-canvas-resize--south-west{width:18px;height:18px;display:flex;align-items:center;justify-content:center}.pdx-canvas-resize--north-east{top:-8px;right:-8px;cursor:nesw-resize}.pdx-canvas-resize--north-west{top:-8px;left:-8px;cursor:nwse-resize}.pdx-canvas-resize--south-east{bottom:-8px;right:-8px;cursor:nwse-resize}.pdx-canvas-resize--south-west{bottom:-8px;left:-8px;cursor:nesw-resize}.pdx-canvas-snap-preview{position:relative;align-self:stretch;border-radius:12px;pointer-events:none;z-index:0;background:linear-gradient(135deg,color-mix(in srgb,var(--md-sys-color-primary) 10%,transparent),color-mix(in srgb,var(--md-sys-color-tertiary) 12%,transparent));box-shadow:inset 0 0 0 1px color-mix(in srgb,var(--md-sys-color-primary) 42%,transparent),inset 0 0 0 2px color-mix(in srgb,var(--md-sys-color-surface) 55%,transparent);animation:pdx-snap-preview-pulse .48s ease-out infinite alternate}.pdx-canvas-snap-preview:before,.pdx-canvas-snap-preview:after{content:\"\";position:absolute;border-radius:999px;background:color-mix(in srgb,var(--md-sys-color-primary) 82%,var(--md-sys-color-tertiary) 18%);opacity:.72}.pdx-canvas-snap-preview:before{inset:0 auto 0 0;width:3px}.pdx-canvas-snap-preview:after{inset:0 0 auto;height:3px}.pdx-canvas-snap-preview--invalid{background:linear-gradient(135deg,color-mix(in srgb,var(--md-sys-color-error) 18%,transparent),color-mix(in srgb,var(--md-sys-color-error-container) 22%,transparent));box-shadow:inset 0 0 0 1px color-mix(in srgb,var(--md-sys-color-error) 58%,transparent),inset 0 0 0 2px color-mix(in srgb,var(--md-sys-color-surface) 40%,transparent)}.pdx-canvas-snap-preview--invalid:before,.pdx-canvas-snap-preview--invalid:after{background:color-mix(in srgb,var(--md-sys-color-error) 86%,var(--md-sys-color-error-container) 14%)}.pdx-canvas-resize:focus-visible{outline:2px solid var(--md-sys-color-primary);outline-offset:2px}.pdx-canvas-resize:hover .pdx-canvas-resize-grip,.pdx-canvas-resize:focus-visible .pdx-canvas-resize-grip{border-color:transparent;box-shadow:0 0 0 1px color-mix(in srgb,var(--md-sys-color-primary) 20%,transparent),var(--mat-elevation-level3)}.pdx-canvas-resize--north:hover .pdx-canvas-resize-grip,.pdx-canvas-resize--north:focus-visible .pdx-canvas-resize-grip,.pdx-canvas-resize--south:hover .pdx-canvas-resize-grip,.pdx-canvas-resize--south:focus-visible .pdx-canvas-resize-grip{background:var(--pdx-resize-gradient-horizontal)}.pdx-canvas-resize--east:hover .pdx-canvas-resize-grip,.pdx-canvas-resize--east:focus-visible .pdx-canvas-resize-grip,.pdx-canvas-resize--west:hover .pdx-canvas-resize-grip,.pdx-canvas-resize--west:focus-visible .pdx-canvas-resize-grip{background:var(--pdx-resize-gradient-vertical)}.pdx-canvas-resize--north-east:hover .pdx-canvas-resize-grip,.pdx-canvas-resize--north-east:focus-visible .pdx-canvas-resize-grip,.pdx-canvas-resize--south-west:hover .pdx-canvas-resize-grip,.pdx-canvas-resize--south-west:focus-visible .pdx-canvas-resize-grip{background:var(--pdx-resize-gradient-diagonal-sw)}.pdx-canvas-resize--north-west:hover .pdx-canvas-resize-grip,.pdx-canvas-resize--north-west:focus-visible .pdx-canvas-resize-grip,.pdx-canvas-resize--south-east:hover .pdx-canvas-resize-grip,.pdx-canvas-resize--south-east:focus-visible .pdx-canvas-resize-grip{background:var(--pdx-resize-gradient-diagonal-se)}.pdx-canvas-resize:hover .pdx-canvas-resize-grip,.pdx-canvas-resize:focus-visible .pdx-canvas-resize-grip{transform:scale(1.08)}@keyframes pdx-snap-preview-pulse{0%{opacity:.72;transform:scale(.996)}to{opacity:1;transform:scale(1)}}.pdx-sr-only{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0}.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: "directive", type: i1$2.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { 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: i3$1.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "ngmodule", type: MatTooltipModule }, { kind: "directive", type: i8.MatTooltip, selector: "[matTooltip]", inputs: ["matTooltipPosition", "matTooltipPositionAtOrigin", "matTooltipDisabled", "matTooltipShowDelay", "matTooltipHideDelay", "matTooltipTouchGestures", "matTooltip", "matTooltipClass"], exportAs: ["matTooltip"] }, { kind: "directive", type: DynamicWidgetLoaderDirective, selector: "[dynamicWidgetLoader]", inputs: ["dynamicWidgetLoader", "ownerWidgetKey", "context", "strictValidation", "autoWireOutputs"], outputs: ["widgetEvent", "widgetDiagnostic"], exportAs: ["dynamicWidgetLoader"] }, { kind: "component", type: WidgetShellComponent, selector: "praxis-widget-shell", inputs: ["shell", "context", "dragSurfaceEnabled", "dragSurfaceLabel"], outputs: ["action", "dragSurfacePointerDown", "dragSurfaceKeydown"] }] });
 }
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImport: i0, type: DynamicWidgetPageComponent, decorators: [{
             type: Component,
@@ -22261,22 +23846,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImpo
       }
     </div>
   `, styles: [".pdx-page-wrapper{position:relative;display:block}.pdx-page{display:grid;gap:16px;grid-template-columns:minmax(0,1fr)}.pdx-page--canvas{align-items:start;grid-auto-flow:dense}.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;min-width:0;min-height:0}.pdx-widget--canvas{align-self:stretch;--pdx-resize-gradient-horizontal: linear-gradient( 90deg, color-mix(in srgb, var(--md-sys-color-primary) 94%, white 6%), color-mix(in srgb, var(--md-sys-color-tertiary) 90%, white 10%), color-mix(in srgb, var(--md-sys-color-secondary) 88%, white 12%) );--pdx-resize-gradient-vertical: linear-gradient( 180deg, color-mix(in srgb, var(--md-sys-color-primary) 94%, white 6%), color-mix(in srgb, var(--md-sys-color-tertiary) 90%, white 10%), color-mix(in srgb, var(--md-sys-color-secondary) 88%, white 12%) );--pdx-resize-gradient-diagonal-se: linear-gradient( 135deg, color-mix(in srgb, var(--md-sys-color-primary) 94%, white 6%), color-mix(in srgb, var(--md-sys-color-tertiary) 90%, white 10%), color-mix(in srgb, var(--md-sys-color-secondary) 88%, white 12%) );--pdx-resize-gradient-diagonal-sw: linear-gradient( 225deg, color-mix(in srgb, var(--md-sys-color-primary) 94%, white 6%), color-mix(in srgb, var(--md-sys-color-tertiary) 90%, white 10%), color-mix(in srgb, var(--md-sys-color-secondary) 88%, white 12%) );--pdx-active-resize-gradient: var(--pdx-resize-gradient-diagonal-se)}.pdx-widget--canvas:after{content:\"\";position:absolute;inset:0;padding:2px;border-radius:14px;background:var(--pdx-active-resize-gradient);opacity:0;pointer-events:none;transition:opacity .14s ease,filter .14s ease;filter:saturate(1.02) drop-shadow(0 0 5px color-mix(in srgb,var(--md-sys-color-primary) 10%,transparent));-webkit-mask:linear-gradient(#fff 0 0) content-box,linear-gradient(#fff 0 0);-webkit-mask-composite:xor;mask-composite:exclude}.pdx-widget--canvas-selected:before,.pdx-widget--canvas-blocked:before{content:\"\";position:absolute;inset:0;border-radius:14px;pointer-events:none;z-index:1;transition:opacity .14s ease,box-shadow .14s ease,border-color .14s ease}.pdx-widget--canvas-selected:before{border:1px dashed color-mix(in srgb,var(--md-sys-color-primary) 34%,transparent);box-shadow:0 0 0 1px color-mix(in srgb,var(--md-sys-color-primary) 6%,transparent),0 8px 20px color-mix(in srgb,var(--md-sys-color-primary) 6%,transparent)}.pdx-widget--canvas-blocked:before{border:1px solid color-mix(in srgb,var(--md-sys-color-error) 74%,transparent);box-shadow:0 0 0 1px color-mix(in srgb,var(--md-sys-color-error) 20%,transparent),0 10px 24px color-mix(in srgb,var(--md-sys-color-error) 12%,transparent)}.pdx-widget--canvas:has(.pdx-canvas-resize:hover):after,.pdx-widget--canvas:has(.pdx-canvas-resize:focus-visible):after{opacity:.82}.pdx-widget--canvas:has(.pdx-canvas-resize--north:hover),.pdx-widget--canvas:has(.pdx-canvas-resize--north:focus-visible),.pdx-widget--canvas:has(.pdx-canvas-resize--south:hover),.pdx-widget--canvas:has(.pdx-canvas-resize--south:focus-visible){--pdx-active-resize-gradient: var(--pdx-resize-gradient-horizontal)}.pdx-widget--canvas:has(.pdx-canvas-resize--east:hover),.pdx-widget--canvas:has(.pdx-canvas-resize--east:focus-visible),.pdx-widget--canvas:has(.pdx-canvas-resize--west:hover),.pdx-widget--canvas:has(.pdx-canvas-resize--west:focus-visible){--pdx-active-resize-gradient: var(--pdx-resize-gradient-vertical)}.pdx-widget--canvas:has(.pdx-canvas-resize--north-east:hover),.pdx-widget--canvas:has(.pdx-canvas-resize--north-east:focus-visible),.pdx-widget--canvas:has(.pdx-canvas-resize--south-west:hover),.pdx-widget--canvas:has(.pdx-canvas-resize--south-west:focus-visible){--pdx-active-resize-gradient: var(--pdx-resize-gradient-diagonal-sw)}.pdx-widget--canvas:has(.pdx-canvas-resize--north-west:hover),.pdx-widget--canvas:has(.pdx-canvas-resize--north-west:focus-visible),.pdx-widget--canvas:has(.pdx-canvas-resize--south-east:hover),.pdx-widget--canvas:has(.pdx-canvas-resize--south-east:focus-visible){--pdx-active-resize-gradient: var(--pdx-resize-gradient-diagonal-se)}.pdx-canvas-resize{position:absolute;z-index:7;border:0;padding:0;margin:0;background:transparent;touch-action:none;cursor:pointer;opacity:0;pointer-events:none;transform:scale(.94);transition:opacity .14s ease,transform .14s ease,filter .14s ease;filter:saturate(.9)}.pdx-widget--canvas:hover .pdx-canvas-resize,.pdx-widget--canvas:focus-within .pdx-canvas-resize,.pdx-widget--canvas-selected .pdx-canvas-resize{opacity:.88;pointer-events:auto;transform:scale(1);filter:saturate(1)}.pdx-canvas-resize-grip{display:block;width:9px;height:9px;border-radius:999px;border:1px solid color-mix(in srgb,var(--md-sys-color-primary) 42%,var(--md-sys-color-outline-variant) 58%);background:color-mix(in srgb,var(--md-sys-color-surface) 92%,var(--md-sys-color-primary) 8%);box-shadow:0 1px 4px color-mix(in srgb,var(--md-sys-color-shadow) 10%,transparent);transition:transform .14s ease,border-color .14s ease,background .14s ease,box-shadow .14s ease}.pdx-canvas-resize:hover .pdx-canvas-resize-grip,.pdx-canvas-resize:focus-visible .pdx-canvas-resize-grip{border-color:color-mix(in srgb,var(--md-sys-color-primary) 58%,var(--md-sys-color-outline-variant) 42%);background:color-mix(in srgb,var(--md-sys-color-surface) 84%,var(--md-sys-color-primary) 16%);box-shadow:0 2px 7px color-mix(in srgb,var(--md-sys-color-primary) 14%,transparent);transform:scale(1.04)}.pdx-canvas-resize--north,.pdx-canvas-resize--south{left:50%;width:40px;height:18px;margin-left:-20px;display:flex;align-items:center;justify-content:center}.pdx-canvas-resize--north{top:-8px;cursor:ns-resize}.pdx-canvas-resize--south{bottom:-8px;cursor:ns-resize}.pdx-canvas-resize--east,.pdx-canvas-resize--west{top:50%;width:18px;height:40px;margin-top:-20px;display:flex;align-items:center;justify-content:center}.pdx-canvas-resize--east{right:-8px;cursor:ew-resize}.pdx-canvas-resize--west{left:-8px;cursor:ew-resize}.pdx-canvas-resize--north-east,.pdx-canvas-resize--north-west,.pdx-canvas-resize--south-east,.pdx-canvas-resize--south-west{width:18px;height:18px;display:flex;align-items:center;justify-content:center}.pdx-canvas-resize--north-east{top:-8px;right:-8px;cursor:nesw-resize}.pdx-canvas-resize--north-west{top:-8px;left:-8px;cursor:nwse-resize}.pdx-canvas-resize--south-east{bottom:-8px;right:-8px;cursor:nwse-resize}.pdx-canvas-resize--south-west{bottom:-8px;left:-8px;cursor:nesw-resize}.pdx-canvas-snap-preview{position:relative;align-self:stretch;border-radius:12px;pointer-events:none;z-index:0;background:linear-gradient(135deg,color-mix(in srgb,var(--md-sys-color-primary) 10%,transparent),color-mix(in srgb,var(--md-sys-color-tertiary) 12%,transparent));box-shadow:inset 0 0 0 1px color-mix(in srgb,var(--md-sys-color-primary) 42%,transparent),inset 0 0 0 2px color-mix(in srgb,var(--md-sys-color-surface) 55%,transparent);animation:pdx-snap-preview-pulse .48s ease-out infinite alternate}.pdx-canvas-snap-preview:before,.pdx-canvas-snap-preview:after{content:\"\";position:absolute;border-radius:999px;background:color-mix(in srgb,var(--md-sys-color-primary) 82%,var(--md-sys-color-tertiary) 18%);opacity:.72}.pdx-canvas-snap-preview:before{inset:0 auto 0 0;width:3px}.pdx-canvas-snap-preview:after{inset:0 0 auto;height:3px}.pdx-canvas-snap-preview--invalid{background:linear-gradient(135deg,color-mix(in srgb,var(--md-sys-color-error) 18%,transparent),color-mix(in srgb,var(--md-sys-color-error-container) 22%,transparent));box-shadow:inset 0 0 0 1px color-mix(in srgb,var(--md-sys-color-error) 58%,transparent),inset 0 0 0 2px color-mix(in srgb,var(--md-sys-color-surface) 40%,transparent)}.pdx-canvas-snap-preview--invalid:before,.pdx-canvas-snap-preview--invalid:after{background:color-mix(in srgb,var(--md-sys-color-error) 86%,var(--md-sys-color-error-container) 14%)}.pdx-canvas-resize:focus-visible{outline:2px solid var(--md-sys-color-primary);outline-offset:2px}.pdx-canvas-resize:hover .pdx-canvas-resize-grip,.pdx-canvas-resize:focus-visible .pdx-canvas-resize-grip{border-color:transparent;box-shadow:0 0 0 1px color-mix(in srgb,var(--md-sys-color-primary) 20%,transparent),var(--mat-elevation-level3)}.pdx-canvas-resize--north:hover .pdx-canvas-resize-grip,.pdx-canvas-resize--north:focus-visible .pdx-canvas-resize-grip,.pdx-canvas-resize--south:hover .pdx-canvas-resize-grip,.pdx-canvas-resize--south:focus-visible .pdx-canvas-resize-grip{background:var(--pdx-resize-gradient-horizontal)}.pdx-canvas-resize--east:hover .pdx-canvas-resize-grip,.pdx-canvas-resize--east:focus-visible .pdx-canvas-resize-grip,.pdx-canvas-resize--west:hover .pdx-canvas-resize-grip,.pdx-canvas-resize--west:focus-visible .pdx-canvas-resize-grip{background:var(--pdx-resize-gradient-vertical)}.pdx-canvas-resize--north-east:hover .pdx-canvas-resize-grip,.pdx-canvas-resize--north-east:focus-visible .pdx-canvas-resize-grip,.pdx-canvas-resize--south-west:hover .pdx-canvas-resize-grip,.pdx-canvas-resize--south-west:focus-visible .pdx-canvas-resize-grip{background:var(--pdx-resize-gradient-diagonal-sw)}.pdx-canvas-resize--north-west:hover .pdx-canvas-resize-grip,.pdx-canvas-resize--north-west:focus-visible .pdx-canvas-resize-grip,.pdx-canvas-resize--south-east:hover .pdx-canvas-resize-grip,.pdx-canvas-resize--south-east:focus-visible .pdx-canvas-resize-grip{background:var(--pdx-resize-gradient-diagonal-se)}.pdx-canvas-resize:hover .pdx-canvas-resize-grip,.pdx-canvas-resize:focus-visible .pdx-canvas-resize-grip{transform:scale(1.08)}@keyframes pdx-snap-preview-pulse{0%{opacity:.72;transform:scale(.996)}to{opacity:1;transform:scale(1)}}.pdx-sr-only{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0}.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
-                }, {
-                    type: Inject,
-                    args: [SETTINGS_PANEL_BRIDGE]
-                }] }, { type: i0.Type, decorators: [{
-                    type: Optional
-                }, {
-                    type: Inject,
-                    args: [DYNAMIC_PAGE_SHELL_EDITOR]
-                }] }, { type: i0.Type, decorators: [{
-                    type: Optional
-                }, {
-                    type: Inject,
-                    args: [DYNAMIC_PAGE_CONFIG_EDITOR]
-                }] }], propDecorators: { pageCanvasHost: [{
+        }], ctorParameters: () => [], propDecorators: { pageCanvasHost: [{
                 type: ViewChild,
                 args: ['pageCanvasHost']
             }], page: [{
@@ -22323,23 +23893,23 @@ const PRAXIS_DYNAMIC_PAGE_COMPONENT_METADATA = {
     selector: 'praxis-dynamic-page',
     component: DynamicWidgetPageComponent,
     friendlyName: 'Dynamic Page',
-    description: 'Página dinâmica com widgets e conexões em layout de grid responsivo.',
+    description: 'Pagina dinamica com widgets e composition.links em layout de grid responsivo.',
     icon: 'dashboard',
     inputs: [
-        { name: 'page', type: 'WidgetPageDefinition', description: 'Definição da página (widgets, layout e conexões).' },
+        { name: 'page', type: 'WidgetPageDefinition', description: 'Definicao da pagina (widgets, layout e composition.links).' },
         { name: 'context', type: 'Record<string, any>', description: 'Contexto adicional compartilhado entre widgets.' },
-        { name: 'strictValidation', type: 'boolean', description: 'Habilita validação estrita de inputs.' },
-        { name: 'enableCustomization', type: 'boolean', description: 'Habilita affordances de edição na página.' },
-        { name: 'showPageSettingsButton', type: 'boolean', description: 'Exibe botão de configuração da página.' },
+        { name: 'strictValidation', type: 'boolean', description: 'Habilita validacao estrita de inputs.' },
+        { name: 'enableCustomization', type: 'boolean', description: 'Habilita affordances de edicao na pagina.' },
+        { name: 'showPageSettingsButton', type: 'boolean', description: 'Exibe botao de configuracao da pagina.' },
         { name: 'shellEditorComponent', type: 'Type<any>', description: 'Override do editor de shell dos widgets.' },
-        { name: 'pageEditorComponent', type: 'Type<any>', description: 'Override do editor de configuração da página.' },
-        { name: 'autoPersist', type: 'boolean', description: 'Ativa persistência automática (load/save) da página.' },
-        { name: 'pageIdentity', type: 'PageIdentity', description: 'Identidade de persistência (tenant/usuário/rota/locale).' },
-        { name: 'componentInstanceId', type: 'string', description: 'Identificador opcional para múltiplas instâncias na mesma rota.' },
+        { name: 'pageEditorComponent', type: 'Type<any>', description: 'Override do editor de configuracao da pagina.' },
+        { name: 'autoPersist', type: 'boolean', description: 'Ativa persistencia automatica (load/save) da pagina.' },
+        { name: 'pageIdentity', type: 'PageIdentity', description: 'Identidade de persistencia (tenant/usuario/rota/locale).' },
+        { name: 'componentInstanceId', type: 'string', description: 'Identificador opcional para multiplas instancias na mesma rota.' },
     ],
     outputs: [
-        { name: 'pageChange', type: 'WidgetPageDefinition', description: 'Emitido ao alterar a definição da página.' },
-        { name: 'widgetDiagnosticsChange', type: 'Record<string, WidgetResolutionDiagnostic>', description: 'Emitido quando o runtime detecta widgets resolvidos ou falhos durante o carregamento dinâmico.' },
+        { name: 'pageChange', type: 'WidgetPageDefinition', description: 'Emitido ao alterar a definicao da pagina.' },
+        { name: 'widgetDiagnosticsChange', type: 'Record<string, WidgetResolutionDiagnostic>', description: 'Emitido quando o runtime detecta widgets resolvidos ou falhos durante o carregamento dinamico.' },
     ],
     tags: ['widget', 'page', 'dynamic', 'layout'],
     lib: '@praxisui/core',
@@ -22481,7 +24051,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$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: i5.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$2.MatCard, selector: "mat-card", inputs: ["appearance"], exportAs: ["matCard"] }, { kind: "directive", type: i3$2.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: i3$1.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,
@@ -22586,7 +24156,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$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$1.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: i5.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: i3$1.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,
@@ -22814,7 +24384,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$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$1.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: i5.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$1.MatChipListbox, selector: "mat-chip-listbox", inputs: ["multiple", "aria-orientation", "selectable", "compareWith", "required", "hideSingleSelectionIndicator", "value"], outputs: ["change"] }, { kind: "component", type: i8$1.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: i8.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: i3$1.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$1.MatChipListbox, selector: "mat-chip-listbox", inputs: ["multiple", "aria-orientation", "selectable", "compareWith", "required", "hideSingleSelectionIndicator", "value"], outputs: ["change"] }, { kind: "component", type: i8$1.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: i8.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,
@@ -23158,7 +24728,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$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: i5.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { kind: "pipe", type: i1$2.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$2.MatCard, selector: "mat-card", inputs: ["appearance"], exportAs: ["matCard"] }, { kind: "directive", type: i3$2.MatCardContent, selector: "mat-card-content" }, { kind: "component", type: i3$2.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: i3$1.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,
@@ -23269,162 +24839,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.17", ngImpo
                 type: Input
             }] } });
 
-async function parseJsonResponseOrEmpty(res, context = 'response') {
-    const raw = await res.text();
-    if (!raw || !raw.trim()) {
-        return {};
-    }
-    try {
-        return JSON.parse(raw);
-    }
-    catch (error) {
-        const e = new Error(`${context}: invalid JSON payload`);
-        e.cause = error;
-        throw e;
-    }
-}
-async function fetchWithETag(params) {
-    const headers = { Accept: 'application/json' };
-    if (params.schemaHash)
-        headers['If-None-Match'] = `"${params.schemaHash}"`;
-    if (params.tenant)
-        headers['X-Tenant'] = params.tenant;
-    if (params.locale)
-        headers['Accept-Language'] = params.locale;
-    // Allow host apps to provide additional headers (e.g., Authorization) without coupling
-    try {
-        const extra = globalThis?.PAX_FETCH_HEADERS?.();
-        if (extra && typeof extra === 'object') {
-            for (const [k, v] of Object.entries(extra)) {
-                const key = String(k);
-                const val = Array.isArray(v) ? String(v[0]) : String(v);
-                if (val && !headers[key])
-                    headers[key] = val;
-            }
-        }
-    }
-    catch {
-        // ignore header hook errors
-    }
-    const res = await fetch(params.url, {
-        headers,
-        cache: 'no-cache',
-        credentials: params.credentials ?? 'include',
-        signal: params.signal,
-    });
-    if (res.status === 304)
-        return { status: 304 };
-    if (!res.ok) {
-        const raw = await res.text().catch(() => '');
-        const bodyHint = raw?.trim() ? `: ${raw.trim().slice(0, 240)}` : '';
-        throw new Error(`fetchWithETag failed (${res.status} ${res.statusText || 'HTTP error'})${bodyHint}`);
-    }
-    const etag = res.headers.get('ETag') || '';
-    const newHash = etag.replace(/^W\//, '').replace(/^\"|\"$/g, '');
-    const xSchemaHash = res.headers.get('X-Schema-Hash');
-    const schemaHash = xSchemaHash || newHash; // prefer explicit header when available
-    const schema = await parseJsonResponseOrEmpty(res, 'fetchWithETag');
-    return { status: 200, schema, schemaHash };
-}
-
-class SchemaMetadataClient {
-    cache;
-    inFlight = new Map();
-    constructor(cache) {
-        this.cache = cache;
-    }
-    async getSchema(params) {
-        // Bind identity to API origin to avoid cross-origin collisions
-        let apiOrigin = '';
-        try {
-            apiOrigin = new URL(params.baseUrl).origin;
-        }
-        catch {
-            try {
-                apiOrigin = globalThis?.location?.origin || '';
-            }
-            catch { }
-        }
-        const schemaId = buildSchemaId({ ...params, apiOrigin });
-        const cached = await this.cache.get(schemaId);
-        // Build URL with query params
-        let u;
-        try {
-            u = new URL(params.baseUrl);
-        }
-        catch (err) {
-            // Accept relative baseUrl by resolving against the app origin when available
-            const origin = (() => {
-                try {
-                    return globalThis?.location?.origin;
-                }
-                catch {
-                    return undefined;
-                }
-            })();
-            if (origin && origin.startsWith('http')) {
-                u = new URL(params.baseUrl, origin);
-            }
-            else {
-                // Friendly error for hosts: instruct to set absolute baseUrl or provide runtime origin
-                const e = new Error(`Failed to construct schema URL. API_URL.baseUrl appears relative and no runtime origin is available. ` +
-                    `Set API_URL.baseUrl to an absolute URL (e.g., http://localhost:4200/api) or run in a browser context. ` +
-                    `Received baseUrl="${params.baseUrl}".`);
-                e.cause = err;
-                throw e;
-            }
-        }
-        u.searchParams.set('path', params.path);
-        u.searchParams.set('operation', (params.operation || 'get').toLowerCase());
-        u.searchParams.set('schemaType', (params.schemaType || 'response').toLowerCase());
-        u.searchParams.set('includeInternalSchemas', String(!!params.includeInternalSchemas));
-        const key = schemaId;
-        if (this.inFlight.has(key))
-            return this.inFlight.get(key);
-        const p = (async () => {
-            const res = await fetchWithETag({
-                url: u.toString(),
-                schemaHash: cached?.schemaHash,
-                tenant: params.tenant,
-                locale: params.locale,
-            });
-            if (res.status === 304) {
-                if (cached)
-                    return cached;
-                // No cache: refetch without If-None-Match
-                const refetch = await fetch(u.toString(), { cache: 'no-cache', credentials: 'include' });
-                if (!refetch.ok) {
-                    const raw = await refetch.text().catch(() => '');
-                    const bodyHint = raw?.trim() ? `: ${raw.trim().slice(0, 240)}` : '';
-                    throw new Error(`SchemaMetadataClient refetch failed (${refetch.status} ${refetch.statusText || 'HTTP error'})${bodyHint}`);
-                }
-                const etag = refetch.headers.get('ETag') || '';
-                const xHash = refetch.headers.get('X-Schema-Hash') || '';
-                const schemaHash = (xHash || etag).replace(/^W\//, '').replace(/^\"|\"$/g, '');
-                const schema = await parseJsonResponseOrEmpty(refetch, 'SchemaMetadataClient refetch');
-                const fallback = { schema, schemaHash };
-                await this.cache.set(schemaId, fallback);
-                return fallback;
-            }
-            // res.status === 200
-            const entry = {
-                schema: res.schema,
-                schemaHash: res.schemaHash,
-            };
-            await this.cache.set(schemaId, entry);
-            return entry;
-        })();
-        this.inFlight.set(key, p);
-        try {
-            const result = await p;
-            return result;
-        }
-        finally {
-            this.inFlight.delete(key);
-        }
-    }
-}
-
 function buildBaseFormField(def) {
     const meta = mapFieldDefinitionsToMetadata([def])[0];
     return meta;
@@ -23913,9 +25327,6 @@ function provideHookWhitelist(allowed) {
     return [{ provide: FORM_HOOKS_WHITELIST, useValue: allowed, multi: true }];
 }
 
-/*
- * Public API Surface of praxis-core
- */
 /*
  * Public API Surface of praxis-core
  */
@@ -23924,4 +25335,4 @@ function provideHookWhitelist(allowed) {
  * Generated bundle index. Do not edit.
  */
 
-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, CompositionRuntimeFacade, 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, 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, adaptWidgetConnectionToCompositionLink, adaptWidgetConnectionsToCompositionLinks, 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 };
+export { API_CONFIG_STORAGE_OPTIONS, API_URL, ASYNC_CONFIG_STORAGE, AllowedFileTypes, AnalyticsPresentationResolver, AnalyticsSchemaContractService, AnalyticsStatsRequestBuilderService, ApiConfigStorage, ApiEndpoint, BUILTIN_PAGE_LAYOUT_PRESETS, BUILTIN_PAGE_THEME_PRESETS, BUILTIN_SHELL_PRESETS, CONFIG_STORAGE, CONNECTION_STORAGE, ComponentKeyService, ComponentMetadataRegistry, CompositionRuntimeFacade, 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, 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_LAYER_SCALE_DEFAULTS, PRAXIS_LAYER_SCALE_VARS, 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, PraxisLayerScaleStyleService, PraxisLegalNoticeComponent, PraxisLoadingInterceptor, PraxisRichTextBlockComponent, PraxisSurfaceHostComponent, PraxisUserContextSummaryComponent, RESOURCE_DISCOVERY_I18N_CONFIG, RESOURCE_DISCOVERY_I18N_NAMESPACE, RULE_PROPERTY_SCHEMA, RemoteConfigStorage, ResourceActionOpenAdapterService, ResourceDiscoveryService, ResourceQuickConnectComponent, ResourceSurfaceOpenAdapterService, SCHEMA_VIEWER_CONTEXT, SETTINGS_PANEL_BRIDGE, SETTINGS_PANEL_DATA, STEPPER_CONFIG_EDITOR, SURFACE_DRAWER_BRIDGE, 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, buildPraxisLayerScaleCss, 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, normalizeResourceAvailabilityReasonCode, 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, resolveResourceAvailabilityReasonKey, resolveSpan, resolveValuePresentation, resolveValuePresentationLocale, slugify, stripMasksHook, supportsImplicitValuePresentation, syncWithServerMetadata, toCamel, toCapitalize, toKebab, toPascal, toSentenceCase, toSnake, toTitleCase, translateResourceAvailabilityReason, translateResourceDiscoveryText, translateUnavailableWorkflowMessage, trim, uniqueAsyncValidator, urlValidator, withMessage, withPraxisHttpLoading };